diff --git a/ui/gfx/BUILD.gn b/ui/gfx/BUILD.gn
new file mode 100644
index 0000000..4d34a46
--- /dev/null
+++ b/ui/gfx/BUILD.gn
@@ -0,0 +1,975 @@
+# Copyright 2014 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.
+
+import("//build/config/ozone.gni")
+import("//build/config/ui.gni")
+import("//device/vr/buildflags/buildflags.gni")
+import("//testing/libfuzzer/fuzzer_test.gni")
+import("//testing/test.gni")
+
+if (is_android) {
+  import("//build/config/android/config.gni")
+  import("//build/config/android/rules.gni")
+}
+
+# Several targets want to include this header file, and some of them are
+# child dependencies of "gfx". Therefore, we separate it out here so multiple
+# targets can all have a dependency for header checking purposes without
+# creating circular dependencies.
+source_set("gfx_export") {
+  sources = [ "gfx_export.h" ]
+}
+
+# Used for color generation at build time without importing all the gfx.
+component("color_utils") {
+  sources = [
+    "color_palette.h",
+    "color_utils.cc",
+    "color_utils.h",
+  ]
+  defines = [ "GFX_IMPLEMENTATION" ]
+  public_deps = [
+    ":gfx_export",
+    "//base",
+    "//skia",
+    "//ui/gfx/geometry",
+  ]
+}
+
+component("gfx_skia") {
+  sources = [
+    "gfx_skia_export.h",
+    "skia_util.cc",
+    "skia_util.h",
+  ]
+  configs += [ "//build/config/compiler:wexit_time_destructors" ]
+  public_deps = [
+    "//base",
+    "//skia",
+  ]
+  defines = [ "GFX_SKIA_IMPLEMENTATION" ]
+}
+
+component("gfx") {
+  sources = [
+    "break_list.h",
+    "color_analysis.cc",
+    "color_analysis.h",
+    "color_transform.cc",
+    "color_transform.h",
+    "decorated_text.cc",
+    "decorated_text.h",
+    "delegated_ink_metadata.cc",
+    "delegated_ink_metadata.h",
+    "delegated_ink_point.cc",
+    "delegated_ink_point.h",
+    "extension_set.cc",
+    "extension_set.h",
+    "favicon_size.cc",
+    "favicon_size.h",
+    "font.cc",
+    "font.h",
+    "font_fallback.h",
+    "font_list.cc",
+    "font_list.h",
+    "font_list_impl.cc",
+    "font_list_impl.h",
+    "font_render_params.cc",
+    "font_render_params.h",
+    "font_util.cc",
+    "font_util.h",
+    "gdi_util.cc",
+    "gdi_util.h",
+    "gpu_extra_info.cc",
+    "gpu_extra_info.h",
+    "half_float.cc",
+    "half_float.h",
+    "icon_util.cc",
+    "icon_util.h",
+    "image/buffer_w_stream.cc",
+    "image/buffer_w_stream.h",
+    "image/image.cc",
+    "image/image.h",
+    "image/image_family.cc",
+    "image/image_family.h",
+    "image/image_platform.h",
+    "image/image_png_rep.cc",
+    "image/image_png_rep.h",
+    "image/image_skia.cc",
+    "image/image_skia.h",
+    "image/image_skia_rep.h",
+    "image/image_skia_source.cc",
+    "image/image_skia_source.h",
+    "image/image_util.cc",
+    "image/image_util.h",
+    "interpolated_transform.cc",
+    "interpolated_transform.h",
+    "nine_image_painter.cc",
+    "nine_image_painter.h",
+    "overlay_plane_data.cc",
+    "overlay_plane_data.h",
+    "overlay_transform_utils.cc",
+    "overlay_transform_utils.h",
+    "platform_font.h",
+    "rendering_pipeline.cc",
+    "rendering_pipeline.h",
+    "rendering_stage_scheduler.cc",
+    "rendering_stage_scheduler.h",
+    "scrollbar_size.cc",
+    "scrollbar_size.h",
+    "selection_model.cc",
+    "selection_model.h",
+    "sequential_id_generator.cc",
+    "sequential_id_generator.h",
+    "shadow_value.cc",
+    "shadow_value.h",
+    "skbitmap_operations.cc",
+    "skbitmap_operations.h",
+    "swap_result.cc",
+    "sys_color_change_listener.cc",
+    "sys_color_change_listener.h",
+    "text_constants.h",
+    "text_elider.cc",
+    "text_elider.h",
+    "text_utils.cc",
+    "text_utils.h",
+    "ui_gfx_exports.cc",
+    "utf16_indexing.cc",
+    "utf16_indexing.h",
+    "vector_icon_types.h",
+    "vector_icon_utils.cc",
+    "vector_icon_utils.h",
+    "video_types.h",
+    "vsync_provider.cc",
+    "vsync_provider.h",
+  ]
+  if (is_android) {
+    sources += [
+      "android/android_surface_control_compat.cc",
+      "android/android_surface_control_compat.h",
+      "android/java_bitmap.cc",
+      "android/java_bitmap.h",
+      "android/view_configuration.cc",
+      "android/view_configuration.h",
+    ]
+  }
+  if (is_linux || is_chromeos) {
+    sources += [
+      "font_fallback_linux.cc",
+      "font_fallback_linux.h",
+      "font_render_params_linux.cc",
+      "linux/fontconfig_util.cc",
+      "linux/fontconfig_util.h",
+    ]
+  }
+  if (is_mac) {
+    sources += [
+      "canvas_paint_mac.h",
+      "canvas_paint_mac.mm",
+      "decorated_text_mac.h",
+      "decorated_text_mac.mm",
+      "font_fallback_mac.mm",
+      "font_render_params_mac.cc",
+      "image/image_mac.mm",
+      "image/image_skia_util_mac.h",
+      "image/image_skia_util_mac.mm",
+      "image/image_util_mac.mm",
+      "mac/coordinate_conversion.h",
+      "mac/coordinate_conversion.mm",
+      "mac/nswindow_frame_controls.h",
+      "mac/nswindow_frame_controls.mm",
+      "mac/scoped_cocoa_disable_screen_updates.h",
+      "mac/scoped_cocoa_disable_screen_updates.mm",
+      "path_mac.h",
+      "path_mac.mm",
+      "platform_font_mac.h",
+      "platform_font_mac.mm",
+      "scoped_cg_context_save_gstate_mac.h",
+      "scoped_ns_graphics_context_save_gstate_mac.h",
+      "scoped_ns_graphics_context_save_gstate_mac.mm",
+    ]
+  }
+  if (is_win) {
+    sources += [
+      "font_fallback_win.cc",
+      "font_fallback_win.h",
+      "font_render_params_win.cc",
+      "path_win.cc",
+      "path_win.h",
+      "system_fonts_win.cc",
+      "system_fonts_win.h",
+      "win/crash_id_helper.cc",
+      "win/crash_id_helper.h",
+      "win/direct_write.cc",
+      "win/direct_write.h",
+      "win/hwnd_util.cc",
+      "win/hwnd_util.h",
+      "win/msg_util.h",
+      "win/physical_size.cc",
+      "win/physical_size.h",
+      "win/rendering_window_manager.cc",
+      "win/rendering_window_manager.h",
+      "win/scoped_set_map_mode.h",
+      "win/singleton_hwnd.cc",
+      "win/singleton_hwnd.h",
+      "win/singleton_hwnd_hot_key_observer.cc",
+      "win/singleton_hwnd_hot_key_observer.h",
+      "win/singleton_hwnd_observer.cc",
+      "win/singleton_hwnd_observer.h",
+      "win/text_analysis_source.cc",
+      "win/text_analysis_source.h",
+      "win/window_impl.cc",
+      "win/window_impl.h",
+    ]
+  }
+  if (is_ios) {
+    sources += [
+      "image/image_ios.mm",
+      "image/image_skia_rep_ios.cc",
+      "image/image_skia_rep_ios.h",
+      "image/image_skia_util_ios.h",
+      "image/image_skia_util_ios.mm",
+      "image/image_util_ios.mm",
+      "ios/NSString+CrStringDrawing.h",
+      "ios/NSString+CrStringDrawing.mm",
+      "ios/uikit_util.h",
+      "ios/uikit_util.mm",
+      "platform_font_ios.h",
+      "platform_font_ios.mm",
+      "scoped_ui_graphics_push_context_ios.h",
+      "scoped_ui_graphics_push_context_ios.mm",
+      "text_utils_ios.mm",
+    ]
+  }
+  if (!is_ios) {
+    sources += [
+      "blit.cc",
+      "blit.h",
+      "canvas.cc",
+      "canvas.h",
+      "canvas_skia.cc",
+      "canvas_skia_paint.h",
+      "image/canvas_image_source.cc",
+      "image/canvas_image_source.h",
+      "image/image_generic.cc",
+      "image/image_skia_operations.cc",
+      "image/image_skia_operations.h",
+      "image/image_skia_rep_default.cc",
+      "image/image_skia_rep_default.h",
+      "paint_throbber.cc",
+      "paint_throbber.h",
+      "scoped_canvas.cc",
+      "scoped_canvas.h",
+      "shadow_util.cc",
+      "shadow_util.h",
+      "skia_paint_util.cc",
+      "skia_paint_util.h",
+    ]
+  }
+
+  configs += [
+    "//build/config:precompiled_headers",
+    "//build/config/compiler:noshadowing",
+    "//build/config/compiler:wexit_time_destructors",
+  ]
+
+  # This is part of the gfx component in the component build.
+  defines = [ "GFX_IMPLEMENTATION" ]
+
+  public_deps = [
+    ":color_space",
+    ":color_utils",
+    ":gfx_skia",
+    ":gfx_switches",
+    ":memory_buffer_sources",
+    ":native_widget_types",
+    ":resize_image_dimensions",
+    ":selection_bound_sources",
+    "//base",
+    "//skia",
+    "//skia:skcms",
+    "//third_party/icu",
+    "//ui/gfx/animation",
+    "//ui/gfx/codec",
+    "//ui/gfx/geometry",
+    "//ui/gfx/geometry:geometry_skia",
+    "//ui/gfx/range",
+  ]
+  deps = [
+    ":gfx_export",
+    "//base",
+    "//base:base_static",
+    "//base:i18n",
+    "//base/third_party/dynamic_annotations",
+    "//build:chromeos_buildflags",
+    "//device/vr/buildflags",
+    "//mojo/public/cpp/bindings:struct_traits",
+    "//skia",
+    "//third_party/zlib",
+  ]
+
+  if (!is_apple) {
+    sources += [
+      "platform_font_skia.cc",
+      "platform_font_skia.h",
+      "skia_font_delegate.cc",
+      "skia_font_delegate.h",
+    ]
+  }
+
+  # iOS.
+  if (is_ios) {
+    sources += [ "scoped_cg_context_save_gstate_mac.h" ]
+  } else {
+    public_deps += [ "//cc/paint" ]
+    deps += [ "//third_party:freetype_harfbuzz" ]
+  }
+
+  # Android.
+  if (is_android) {
+    if (!is_debug) {
+      configs -= [ "//build/config/compiler:default_optimization" ]
+      configs += [ "//build/config/compiler:optimize_max" ]
+    }
+
+    deps += [ ":gfx_jni_headers" ]
+    libs = [
+      "android",
+      "jnigraphics",
+    ]
+  }
+
+  if (is_android || is_fuchsia) {
+    sources += [
+      "font_fallback_skia.cc",
+      "font_render_params_skia.cc",
+    ]
+  }
+
+  if (is_android || is_fuchsia || is_win || is_mac) {
+    sources += [
+      "font_fallback_skia_impl.cc",
+      "font_fallback_skia_impl.h",
+    ]
+  }
+
+  if (!is_ios) {
+    sources += [
+      "bidi_line_iterator.cc",
+      "bidi_line_iterator.h",
+      "harfbuzz_font_skia.cc",
+      "harfbuzz_font_skia.h",
+      "paint_vector_icon.cc",
+      "paint_vector_icon.h",
+      "render_text.cc",
+      "render_text.h",
+      "render_text_harfbuzz.cc",
+      "render_text_harfbuzz.h",
+      "text_utils_skia.cc",
+    ]
+  }
+
+  # Windows.
+  if (is_win) {
+    libs = [
+      "setupapi.lib",
+      "dwrite.lib",
+    ]
+    deps += [ "//components/crash/core/common" ]
+  } else {
+    sources -= [
+      "gdi_util.cc",
+      "gdi_util.h",
+      "icon_util.cc",
+      "icon_util.h",
+      "sys_color_change_listener.cc",
+      "sys_color_change_listener.h",
+    ]
+  }
+
+  # Linux.
+  if (is_linux || is_chromeos) {
+    deps += [ "//third_party/fontconfig" ]
+  }
+
+  if (is_mac) {
+    frameworks = [
+      "AppKit.framework",
+      "CoreFoundation.framework",
+      "CoreGraphics.framework",
+      "CoreText.framework",
+      "IOSurface.framework",
+    ]
+  }
+
+  if ((!use_aura && !toolkit_views) || is_ios) {
+    sources -= [
+      "nine_image_painter.cc",
+      "nine_image_painter.h",
+    ]
+  }
+
+  if (use_ozone) {
+    deps += [ "//ui/ozone:buildflags" ]
+  }
+
+  if (ozone_platform_x11 || use_x11) {
+    deps += [ "//ui/gfx/x" ]
+  }
+}
+
+component("color_space") {
+  sources = [
+    "color_space.cc",
+    "color_space.h",
+    "color_space_export.h",
+    "display_color_spaces.cc",
+    "display_color_spaces.h",
+    "hdr_static_metadata.cc",
+    "hdr_static_metadata.h",
+    "icc_profile.cc",
+    "icc_profile.h",
+    "skia_color_space_util.cc",
+    "skia_color_space_util.h",
+  ]
+  if (is_win) {
+    sources += [
+      "color_space_win.cc",
+      "color_space_win.h",
+    ]
+  }
+  deps = [
+    "//build:chromeos_buildflags",
+    "//skia:skcms",
+    "//ui/gfx:buffer_types",
+  ]
+  public_deps = [
+    "//base",
+    "//skia",
+  ]
+  if (is_mac) {
+    sources += [
+      "mac/display_icc_profiles.cc",
+      "mac/display_icc_profiles.h",
+    ]
+    frameworks = [
+      "CoreFoundation.framework",
+      "CoreGraphics.framework",
+    ]
+  }
+  if (use_x11) {
+    deps += [ "//ui/gfx/x" ]
+  }
+  defines = [ "COLOR_SPACE_IMPLEMENTATION" ]
+}
+
+# Depend on this to use image/resize_image_dimensions.h without pulling in
+# all of gfx.
+source_set("resize_image_dimensions") {
+  sources = [ "image/resize_image_dimensions.h" ]
+}
+
+# Depend on this to use native_widget_types.h without pulling in all of gfx.
+source_set("native_widget_types") {
+  public = [ "native_widget_types.h" ]
+
+  public_deps = [
+    ":gfx_export",
+    "//base",
+  ]
+
+  deps = [ "//build:chromeos_buildflags" ]
+}
+
+group("selection_bound") {
+  if (is_component_build) {
+    public_deps = [ ":gfx" ]
+  } else {
+    public_deps = [ ":selection_bound_sources" ]
+  }
+}
+
+# Depend on this to use selection_bound.h without pulling in all of gfx.
+# Cannot be a static_library in component builds due to exported functions
+source_set("selection_bound_sources") {
+  visibility = [ ":*" ]
+
+  sources = [
+    "gfx_export.h",
+    "selection_bound.cc",
+    "selection_bound.h",
+  ]
+
+  configs += [ "//build/config/compiler:wexit_time_destructors" ]
+
+  defines = [ "GFX_IMPLEMENTATION" ]
+
+  public_deps = [
+    "//base",
+    "//ui/gfx/geometry",
+  ]
+}
+
+# Depend on this to use buffer_types.h without pulling in all of gfx.
+source_set("buffer_types") {
+  sources = [ "buffer_types.h" ]
+}
+
+# The GPU memory buffer stuff is separate from "gfx" to allow GPU-related
+# things to use these files without pulling in all of gfx, which includes large
+# things like Skia.
+#
+# The structure here allows the memory buffer to be part of the gfx component
+# in the component build, but be a separate source set in a static build.
+group("memory_buffer") {
+  if (is_component_build) {
+    public_deps = [ ":gfx" ]
+  } else {
+    public_deps = [ ":memory_buffer_sources" ]
+  }
+}
+
+# Cannot be a static_library in component builds due to exported functions
+source_set("memory_buffer_sources") {
+  visibility = [ ":*" ]  # Depend on through ":memory_buffer".
+
+  # TODO(brettw) refactor this so these sources are in a coherent directory
+  # structure rather than random samplings of ui/gfx and ui/gfx/mac.
+  sources = [
+    "buffer_format_util.cc",
+    "buffer_format_util.h",
+    "buffer_usage_util.cc",
+    "buffer_usage_util.h",
+    "ca_layer_params.cc",
+    "ca_layer_params.h",
+    "client_native_pixmap.h",
+    "client_native_pixmap_factory.h",
+    "generic_shared_memory_id.cc",
+    "generic_shared_memory_id.h",
+    "gfx_export.h",
+    "gpu_fence.cc",
+    "gpu_fence.h",
+    "gpu_fence_handle.cc",
+    "gpu_fence_handle.h",
+    "hdr_metadata.cc",
+    "hdr_metadata.h",
+    "native_pixmap.h",
+    "overlay_priority_hint.h",
+    "overlay_transform.h",
+    "surface_origin.h",
+  ]
+
+  if (!is_ios) {
+    sources += [
+      "gpu_memory_buffer.cc",
+      "gpu_memory_buffer.h",
+    ]
+  }
+
+  configs += [ "//build/config/compiler:wexit_time_destructors" ]
+
+  defines = [ "GFX_IMPLEMENTATION" ]
+
+  public_deps = [ ":buffer_types" ]
+
+  deps = [
+    ":gfx_switches",
+    ":native_widget_types",
+    "//base",
+    "//build:chromecast_buildflags",
+    "//build:chromeos_buildflags",
+    "//ui/gfx/geometry",
+  ]
+
+  if (is_linux || is_chromeos) {
+    sources += [
+      "linux/client_native_pixmap_dmabuf.cc",
+      "linux/client_native_pixmap_dmabuf.h",
+      "linux/client_native_pixmap_factory_dmabuf.cc",
+      "linux/client_native_pixmap_factory_dmabuf.h",
+      "linux/native_pixmap_dmabuf.cc",
+      "linux/native_pixmap_dmabuf.h",
+    ]
+
+    deps += [ "//build/config/linux/libdrm" ]
+  }
+
+  if (is_linux || is_chromeos || is_android) {
+    deps += [ "//third_party/libsync" ]
+  }
+
+  if (is_mac) {
+    sources += [
+      "mac/io_surface.cc",
+      "mac/io_surface.h",
+    ]
+
+    public_deps += [ "//ui/gfx:color_space" ]
+  }
+
+  if (is_win) {
+    public_deps += [ "//ipc:message_support" ]
+  }
+
+  if ((is_linux || is_chromeos || use_ozone) && !is_nacl) {
+    sources += [
+      "native_pixmap_handle.cc",
+      "native_pixmap_handle.h",
+    ]
+  }
+}
+
+# TODO(ccameron): This can be moved into a separate source_set.
+component("gfx_switches") {
+  sources = [
+    "switches.cc",
+    "switches.h",
+    "switches_export.h",
+  ]
+
+  defines = [ "GFX_SWITCHES_IMPLEMENTATION" ]
+
+  deps = [ "//base" ]
+}
+
+static_library("test_support") {
+  testonly = true
+  sources = [
+    "animation/animation_test_api.cc",
+    "animation/animation_test_api.h",
+    "animation/keyframe/test/animation_utils.cc",
+    "animation/keyframe/test/animation_utils.h",
+    "animation/test_animation_delegate.h",
+    "geometry/test/rect_test_util.cc",
+    "geometry/test/rect_test_util.h",
+    "geometry/test/size_test_util.h",
+    "geometry/test/transform_test_util.cc",
+    "geometry/test/transform_test_util.h",
+    "image/image_unittest_util.cc",
+    "image/image_unittest_util.h",
+    "test/font_fallback_test_data.cc",
+    "test/font_fallback_test_data.h",
+    "test/gfx_util.cc",
+    "test/gfx_util.h",
+    "test/icc_profiles.cc",
+    "test/icc_profiles.h",
+  ]
+  if (is_ios) {
+    sources += [ "image/image_unittest_util_ios.mm" ]
+  }
+  if (is_mac) {
+    sources += [ "image/image_unittest_util_mac.mm" ]
+  }
+
+  public_deps = [ ":gfx" ]
+
+  deps = [
+    "//base",
+    "//base/test:test_support",
+    "//skia",
+    "//testing/gtest",
+    "//ui/gfx/animation",
+    "//ui/gfx/animation/keyframe",
+    "//ui/gfx/geometry",
+  ]
+
+  if (!is_ios) {
+    sources += [ "render_text_test_api.h" ]
+
+    deps += [ "//third_party:freetype_harfbuzz" ]
+  }
+}
+
+if (is_mac) {
+  component("gfx_io_surface_hdr_metadata") {
+    sources = [
+      "mac/io_surface_hdr_metadata.cc",
+      "mac/io_surface_hdr_metadata.h",
+    ]
+    defines = [ "IS_GFX_IO_SURFACE_HDR_METADATA_IMPL" ]
+
+    # This is a separate component from the other sources because it depends on
+    # the mojo serialize and deserialize methods.
+    deps = [
+      ":gfx",
+      "//ui/gfx/mojom:mojom",
+    ]
+    frameworks = [
+      "CoreFoundation.framework",
+      "IOSurface.framework",
+    ]
+  }
+}
+
+test("gfx_unittests") {
+  sources = [
+    "animation/keyframe/keyframe_animation_unittest.cc",
+    "animation/keyframe/keyframed_animation_curve_unittest.cc",
+    "font_names_testing.cc",
+    "font_names_testing.h",
+    "font_unittest.cc",
+    "geometry/rrect_f_unittest.cc",
+    "geometry/transform_operations_unittest.cc",
+    "geometry/transform_unittest.cc",
+    "image/buffer_w_stream_unittest.cc",
+    "image/image_family_unittest.cc",
+    "image/image_skia_unittest.cc",
+    "image/image_unittest.cc",
+    "interpolated_transform_unittest.cc",
+    "test/run_all_unittests.cc",
+    "text_elider_unittest.cc",
+    "text_utils_unittest.cc",
+  ]
+  if (is_linux || is_chromeos) {
+    sources += [
+      "font_fallback_linux_unittest.cc",
+      "font_render_params_linux_unittest.cc",
+    ]
+  }
+  if (is_mac) {
+    sources += [
+      "font_fallback_mac_unittest.cc",
+      "image/image_mac_unittest.mm",
+      "mac/coordinate_conversion_unittest.mm",
+      "mac/io_surface_unittest.cc",
+      "path_mac_unittest.mm",
+      "platform_font_mac_unittest.mm",
+      "range/range_mac_unittest.mm",
+    ]
+    frameworks = [ "IOSurface.framework" ]
+  }
+  if (is_win) {
+    sources += [ "font_fallback_win_unittest.cc" ]
+  }
+  if (is_ios) {
+    sources += [
+      "image/image_ios_unittest.mm",
+      "ios/NSString+CrStringDrawing_unittest.mm",
+      "ios/uikit_util_unittest.mm",
+    ]
+  }
+  if (is_android) {
+    sources += [ "android/android_surface_control_compat_unittest.cc" ]
+  }
+
+  include_dirs = [ "//third_party/skia/include/private" ]
+
+  data = [ "test/data/" ]
+
+  if (!is_ios) {
+    sources += [
+      "animation/animation_container_unittest.cc",
+      "animation/animation_runner_unittest.cc",
+      "animation/animation_unittest.cc",
+      "animation/multi_animation_unittest.cc",
+      "animation/slide_animation_unittest.cc",
+      "animation/tween_unittest.cc",
+      "blit_unittest.cc",
+      "break_list_unittest.cc",
+      "canvas_unittest.cc",
+      "codec/jpeg_codec_unittest.cc",
+      "codec/png_codec_unittest.cc",
+      "color_analysis_unittest.cc",
+      "color_space_unittest.cc",
+      "color_transform_unittest.cc",
+      "color_utils_unittest.cc",
+      "delegated_ink_unittest.cc",
+      "font_fallback_unittest.cc",
+      "font_list_unittest.cc",
+      "geometry/axis_transform2d_unittest.cc",
+      "geometry/box_unittest.cc",
+      "geometry/cubic_bezier_unittest.cc",
+      "geometry/insets_unittest.cc",
+      "geometry/matrix3_unittest.cc",
+      "geometry/point3_unittest.cc",
+      "geometry/point_unittest.cc",
+      "geometry/quad_unittest.cc",
+      "geometry/quaternion_unittest.cc",
+      "geometry/rect_f_unittest.cc",
+      "geometry/rect_unittest.cc",
+      "geometry/resize_utils_unittest.cc",
+      "geometry/rounded_corners_f_unittest.cc",
+      "geometry/size_unittest.cc",
+      "geometry/transform_util_unittest.cc",
+      "geometry/vector2d_unittest.cc",
+      "geometry/vector3d_unittest.cc",
+      "half_float_unittest.cc",
+      "icc_profile_unittest.cc",
+      "image/image_skia_operations_unittest.cc",
+      "image/image_util_unittest.cc",
+      "mojom/mojom_traits_unittest.cc",
+      "nine_image_painter_unittest.cc",
+      "overlay_transform_utils_unittest.cc",
+      "paint_vector_icon_unittest.cc",
+      "range/range_unittest.cc",
+      "selection_bound_unittest.cc",
+      "selection_model_unittest.cc",
+      "sequential_id_generator_unittest.cc",
+      "shadow_value_unittest.cc",
+      "skbitmap_operations_unittest.cc",
+      "skia_util_unittest.cc",
+      "skrect_conversion_unittest.cc",
+      "utf16_indexing_unittest.cc",
+    ]
+  }
+
+  if (is_win) {
+    sources += [ "system_fonts_win_unittest.cc" ]
+  }
+
+  if (is_linux || is_chromeos || is_android || is_fuchsia || is_win) {
+    sources += [ "platform_font_skia_unittest.cc" ]
+  }
+
+  deps = [
+    ":gfx",
+    ":test_support",
+    "//base",
+    "//base/test:test_support",
+    "//build:chromeos_buildflags",
+    "//skia",
+    "//skia:skcms",
+    "//testing/gtest",
+    "//third_party/icu:icuuc",
+    "//third_party/libpng",
+    "//third_party/zlib",
+    "//ui/base",
+    "//ui/gfx/animation",
+    "//ui/gfx/animation/keyframe",
+    "//ui/gfx/geometry",
+    "//ui/gfx/range",
+  ]
+
+  if (!is_ios) {
+    sources += [
+      "bidi_line_iterator_unittest.cc",
+      "render_text_unittest.cc",
+    ]
+    deps += [ "//third_party:freetype_harfbuzz" ]
+  }
+
+  data_deps = [ "//ui/resources:ui_test_pak_data" ]
+
+  if (is_apple) {
+    deps += [ "//ui/resources:ui_test_pak_bundle_data" ]
+  }
+
+  if (is_mac) {
+    deps += [ ":gfx_io_surface_hdr_metadata" ]
+  }
+
+  if (is_android) {
+    deps += [ "//ui/android:ui_java" ]
+  }
+
+  if (is_android || is_fuchsia) {
+    sources += [ "font_fallback_skia_unittest.cc" ]
+  }
+
+  if (!use_aura && !is_ios) {
+    sources -= [ "nine_image_painter_unittest.cc" ]
+  }
+
+  if (is_win) {
+    sources += [
+      "icon_util_unittest.cc",
+      "icon_util_unittests.rc",
+      "icon_util_unittests_resource.h",
+      "path_win_unittest.cc",
+      "win/crash_id_helper_unittest.cc",
+      "win/direct_write_unittest.cc",
+      "win/text_analysis_source_unittest.cc",
+    ]
+
+    ldflags = [
+      "/DELAYLOAD:d2d1.dll",
+      "/DELAYLOAD:d3d10_1.dll",
+    ]
+
+    libs = [
+      "d2d1.lib",
+      "d3d10_1.lib",
+      "dwrite.lib",
+      "imm32.lib",
+      "oleacc.lib",
+    ]
+  }
+
+  if (!is_ios) {
+    deps += [
+      "//cc/paint",
+      "//mojo/core/embedder",
+      "//mojo/public/cpp/bindings",
+      "//mojo/public/cpp/test_support:test_utils",
+      "//ui/gfx/geometry/mojom:unit_test",
+      "//ui/gfx/image/mojom:unit_test",
+      "//ui/gfx/mojom:test_interfaces",
+      "//ui/gfx/range/mojom:unit_test",
+    ]
+  }
+
+  if (is_linux || is_chromeos) {
+    sources += [
+      "linux/fontconfig_util_unittest.cc",
+      "linux/native_pixmap_dmabuf_unittest.cc",
+    ]
+    deps += [ "//third_party/fontconfig" ]
+  }
+
+  if (is_fuchsia) {
+    deps += [ "//skia:test_fonts" ]
+  }
+}
+
+if (is_android) {
+  generate_jni("gfx_jni_headers") {
+    sources = [
+      "../android/java/src/org/chromium/ui/gfx/AdpfRenderingStageScheduler.java",
+      "../android/java/src/org/chromium/ui/gfx/Animation.java",
+      "../android/java/src/org/chromium/ui/gfx/BitmapHelper.java",
+      "../android/java/src/org/chromium/ui/gfx/ViewConfigurationHelper.java",
+    ]
+  }
+}
+
+fuzzer_test("color_analysis_fuzzer") {
+  sources = [ "color_analysis_fuzzer.cc" ]
+
+  deps = [ ":gfx" ]
+}
+
+fuzzer_test("color_transform_fuzzer") {
+  sources = [ "color_transform_fuzzer.cc" ]
+
+  dict = "//testing/libfuzzer/fuzzers/dicts/icc.dict"
+
+  deps = [ ":gfx" ]
+
+  libfuzzer_options = [ "max_len=4194304" ]
+}
+
+fuzzer_test("render_text_fuzzer") {
+  sources = [ "render_text_fuzzer.cc" ]
+
+  deps = [
+    ":gfx",
+    "//base",
+    "//base/test:test_support",
+  ]
+
+  dict = "test/data/render_text/unicode_text_fuzzer.dict"
+}
+
+fuzzer_test("render_text_api_fuzzer") {
+  sources = [ "render_text_api_fuzzer.cc" ]
+
+  deps = [
+    ":gfx",
+    "//base",
+    "//base/test:test_support",
+    "//build:chromeos_buildflags",
+  ]
+
+  dict = "test/data/render_text/unicode_text_fuzzer.dict"
+}
diff --git a/ui/gfx/DEPS b/ui/gfx/DEPS
new file mode 100644
index 0000000..bff9445
--- /dev/null
+++ b/ui/gfx/DEPS
@@ -0,0 +1,20 @@
+include_rules = [
+  "+base",
+  "+cc/base",
+  "+cc/paint",
+  "+device/vr/buildflags/buildflags.h",
+  "+skia/ext",
+  "+third_party/harfbuzz-ng",
+  "+third_party/skia",
+  "+third_party/test_fonts",
+  "+ui/ios",
+  "+ui/ozone/buildflags.h",
+
+  "-testing/gmock",
+]
+
+specific_include_rules = {
+  "delegated_ink_point\.h" : [
+    "+mojo/public/cpp/bindings/struct_traits.h",
+  ],
+}
diff --git a/ui/gfx/DIR_METADATA b/ui/gfx/DIR_METADATA
new file mode 100644
index 0000000..b89d550
--- /dev/null
+++ b/ui/gfx/DIR_METADATA
@@ -0,0 +1,12 @@
+# Metadata information for this directory.
+#
+# For more information on DIR_METADATA files, see:
+#   https://source.chromium.org/chromium/infra/infra/+/main:go/src/infra/tools/dirmd/README.md
+#
+# For the schema of this file, see Metadata message:
+#   https://source.chromium.org/chromium/infra/infra/+/main:go/src/infra/tools/dirmd/proto/dir_metadata.proto
+
+monorail {
+  component: "UI>GFX"
+}
+team_email: "graphics-dev@chromium.org"
\ No newline at end of file
diff --git a/ui/gfx/METADATA b/ui/gfx/METADATA
new file mode 100644
index 0000000..6ed0bf4
--- /dev/null
+++ b/ui/gfx/METADATA
@@ -0,0 +1,15 @@
+third_party {
+  identifier {
+    type: "ChromiumVersion"
+    value: "96.0.4664.219"  # from https://chromereleases.googleblog.com/2022/08/long-term-support-channel-update-for_31.html
+  }
+  identifier {
+    type: "Git"
+    value: "https://chromium.googlesource.com/chromium/src.git"
+    version: "6a496db5ef7219101beacceca9566367c9cb1a09"
+  }
+  identifier {
+    type: "UpstreamSubdir"
+    value: "ui/gfx"
+  }
+}
diff --git a/ui/gfx/OWNERS b/ui/gfx/OWNERS
new file mode 100644
index 0000000..4bec2f1
--- /dev/null
+++ b/ui/gfx/OWNERS
@@ -0,0 +1,63 @@
+# For any other files, defer to ui/OWNERS.
+
+# RenderText and related classes.
+per-file render_text*=etienneb@chromium.org
+per-file render_text*=msw@chromium.org
+per-file text_elider*=etienneb@chromium.org
+per-file text_elider*=msw@chromium.org
+
+# Fonts and fallback fonts.
+per-file font*=etienneb@chromium.org
+per-file font*=robliao@chromium.org
+per-file platform_font*=etienneb@chromium.org
+per-file platform_font*=robliao@chromium.org
+
+# Color utils.
+per-file color_palette.h=pkasting@chromium.org
+per-file color_utils*=pkasting@chromium.org
+
+# Display and related classes.
+per-file display*=oshima@chromium.org
+per-file screen*=oshima@chromium.org
+
+# Canvas painting.
+per-file canvas*=danakj@chromium.org
+
+# Overlay transforms.
+per-file overlay*=spang@chromium.org
+
+# Overlay plane data.
+per-file overlay_plane_data*=rjkroege@chromium.org
+
+# Transform, interpolated transform and transform util.
+per-file transform*=danakj@chromium.org
+per-file transform*=vollick@chromium.org
+per-file interpolated_transform*=danakj@chromium.org
+per-file interpolated_transform*=vollick@chromium.org
+
+# Skia geometry helpers.
+per-file skia_util*=danakj@chromium.org
+per-file skia_paint_util*=danakj@chromium.org
+
+# GPU memory buffer and GpuFence interfaces.
+per-file gpu_fence*=dcastagna@chromium.org
+per-file gpu_fence*=rjkroege@chromium.org
+per-file gpu_fence*=spang@chromium.org
+per-file gpu_memory_buffer*=dcastagna@chromium.org
+per-file gpu_memory_buffer*=rjkroege@chromium.org
+per-file gpu_memory_buffer*=spang@chromium.org
+per-file buffer_format*=dcastagna@chromium.org
+per-file buffer_format*=rjkroege@chromium.org
+per-file buffer_format*=spang@chromium.org
+per-file buffer_usage*=rjkroege@chromium.org
+per-file *buffer_types.*=dcastagna@chromium.org
+per-file *buffer_types.*=rjkroege@chromium.org
+per-file *buffer_types.*=spang@chromium.org
+per-file *native_pixmap*=rjkroege@chromium.org
+per-file *native_pixmap*=spang@chromium.org
+
+# Vector icons.
+per-file *vector_icon*=estade@chromium.org
+
+# If you're doing structural changes get a review from one of the OWNERS.
+per-file BUILD.gn=*
diff --git a/ui/gfx/android/DEPS b/ui/gfx/android/DEPS
new file mode 100644
index 0000000..841ceff
--- /dev/null
+++ b/ui/gfx/android/DEPS
@@ -0,0 +1,3 @@
+include_rules = [
+  "+ui/gfx/gfx_jni_headers",
+]
diff --git a/ui/gfx/android/OWNERS b/ui/gfx/android/OWNERS
new file mode 100644
index 0000000..15a182a
--- /dev/null
+++ b/ui/gfx/android/OWNERS
@@ -0,0 +1 @@
+skyostil@chromium.org
diff --git a/ui/gfx/android/android_surface_control_compat.cc b/ui/gfx/android/android_surface_control_compat.cc
new file mode 100644
index 0000000..a92788e
--- /dev/null
+++ b/ui/gfx/android/android_surface_control_compat.cc
@@ -0,0 +1,693 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/android/android_surface_control_compat.h"
+
+#include <android/data_space.h>
+#include <dlfcn.h>
+
+#include "base/android/build_info.h"
+#include "base/atomic_sequence_num.h"
+#include "base/bind.h"
+#include "base/bind_post_task.h"
+#include "base/debug/crash_logging.h"
+#include "base/hash/md5_constexpr.h"
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/system/sys_info.h"
+#include "base/trace_event/trace_event.h"
+#include "ui/gfx/color_space.h"
+
+extern "C" {
+typedef struct ASurfaceTransactionStats ASurfaceTransactionStats;
+typedef void (*ASurfaceTransaction_OnComplete)(void* context,
+                                               ASurfaceTransactionStats* stats);
+typedef void (*ASurfaceTransaction_OnCommit)(void* context,
+                                             ASurfaceTransactionStats* stats);
+
+// ASurface
+using pASurfaceControl_createFromWindow =
+    ASurfaceControl* (*)(ANativeWindow* parent, const char* name);
+using pASurfaceControl_create = ASurfaceControl* (*)(ASurfaceControl* parent,
+                                                     const char* name);
+using pASurfaceControl_release = void (*)(ASurfaceControl*);
+
+// ASurfaceTransaction enums
+enum {
+  ASURFACE_TRANSACTION_TRANSPARENCY_TRANSPARENT = 0,
+  ASURFACE_TRANSACTION_TRANSPARENCY_TRANSLUCENT = 1,
+  ASURFACE_TRANSACTION_TRANSPARENCY_OPAQUE = 2,
+};
+
+// ANativeWindow_FrameRateCompatibility enums
+enum {
+  ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT = 0,
+  ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_FIXED_SOURCE = 1
+};
+
+// ASurfaceTransaction
+using pASurfaceTransaction_create = ASurfaceTransaction* (*)(void);
+using pASurfaceTransaction_delete = void (*)(ASurfaceTransaction*);
+using pASurfaceTransaction_apply = int64_t (*)(ASurfaceTransaction*);
+using pASurfaceTransaction_setOnComplete =
+    void (*)(ASurfaceTransaction*, void* ctx, ASurfaceTransaction_OnComplete);
+using pASurfaceTransaction_setOnCommit = void (*)(ASurfaceTransaction*,
+                                                  void* ctx,
+                                                  ASurfaceTransaction_OnCommit);
+using pASurfaceTransaction_setVisibility = void (*)(ASurfaceTransaction*,
+                                                    ASurfaceControl*,
+                                                    int8_t visibility);
+using pASurfaceTransaction_setZOrder =
+    void (*)(ASurfaceTransaction* transaction, ASurfaceControl*, int32_t z);
+using pASurfaceTransaction_setBuffer =
+    void (*)(ASurfaceTransaction* transaction,
+             ASurfaceControl*,
+             AHardwareBuffer*,
+             int32_t fence_fd);
+using pASurfaceTransaction_setGeometry =
+    void (*)(ASurfaceTransaction* transaction,
+             ASurfaceControl* surface,
+             const ARect& src,
+             const ARect& dst,
+             int32_t transform);
+using pASurfaceTransaction_setPosition =
+    void (*)(ASurfaceTransaction* transaction,
+             ASurfaceControl* surface,
+             int32_t x,
+             int32_t y);
+using pASurfaceTransaction_setScale = void (*)(ASurfaceTransaction* transaction,
+                                               ASurfaceControl* surface,
+                                               float x_scale,
+                                               float y_scale);
+using pASurfaceTransaction_setCrop = void (*)(ASurfaceTransaction* transaction,
+                                              ASurfaceControl* surface,
+                                              const ARect& src);
+using pASurfaceTransaction_setBufferTransparency =
+    void (*)(ASurfaceTransaction* transaction,
+             ASurfaceControl* surface,
+             int8_t transparency);
+using pASurfaceTransaction_setDamageRegion =
+    void (*)(ASurfaceTransaction* transaction,
+             ASurfaceControl* surface,
+             const ARect rects[],
+             uint32_t count);
+using pASurfaceTransaction_setBufferDataSpace =
+    void (*)(ASurfaceTransaction* transaction,
+             ASurfaceControl* surface,
+             uint64_t data_space);
+using pASurfaceTransaction_setFrameRate =
+    void (*)(ASurfaceTransaction* transaction,
+             ASurfaceControl* surface_control,
+             float frameRate,
+             int8_t compatibility);
+using pASurfaceTransaction_reparent = void (*)(ASurfaceTransaction*,
+                                               ASurfaceControl* surface_control,
+                                               ASurfaceControl* new_parent);
+// ASurfaceTransactionStats
+using pASurfaceTransactionStats_getPresentFenceFd =
+    int (*)(ASurfaceTransactionStats* stats);
+using pASurfaceTransactionStats_getLatchTime =
+    int64_t (*)(ASurfaceTransactionStats* stats);
+using pASurfaceTransactionStats_getASurfaceControls =
+    void (*)(ASurfaceTransactionStats* stats,
+             ASurfaceControl*** surface_controls,
+             size_t* size);
+using pASurfaceTransactionStats_releaseASurfaceControls =
+    void (*)(ASurfaceControl** surface_controls);
+using pASurfaceTransactionStats_getPreviousReleaseFenceFd =
+    int (*)(ASurfaceTransactionStats* stats, ASurfaceControl* surface_control);
+}
+
+namespace gfx {
+namespace {
+
+base::AtomicSequenceNumber g_next_transaction_id;
+
+uint64_t g_agb_required_usage_bits = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY;
+
+#define LOAD_FUNCTION(lib, func)                             \
+  do {                                                       \
+    func##Fn = reinterpret_cast<p##func>(dlsym(lib, #func)); \
+    if (!func##Fn) {                                         \
+      supported = false;                                     \
+      LOG(ERROR) << "Unable to load function " << #func;     \
+    }                                                        \
+  } while (0)
+
+#define LOAD_FUNCTION_MAYBE(lib, func)                       \
+  do {                                                       \
+    func##Fn = reinterpret_cast<p##func>(dlsym(lib, #func)); \
+  } while (0)
+
+struct SurfaceControlMethods {
+ public:
+  static SurfaceControlMethods& GetImpl(bool load_functions) {
+    static SurfaceControlMethods instance(load_functions);
+    return instance;
+  }
+
+  static const SurfaceControlMethods& Get() {
+    return GetImpl(/*load_functions=*/true);
+  }
+
+  void InitWithStubs() {
+    struct TransactionStub {
+      ASurfaceTransaction_OnComplete on_complete = nullptr;
+      void* on_complete_ctx = nullptr;
+      ASurfaceTransaction_OnCommit on_commit = nullptr;
+      void* on_commit_ctx = nullptr;
+    };
+
+    ASurfaceTransaction_createFn = []() {
+      return reinterpret_cast<ASurfaceTransaction*>(new TransactionStub);
+    };
+    ASurfaceTransaction_deleteFn = [](ASurfaceTransaction* transaction) {
+      delete reinterpret_cast<TransactionStub*>(transaction);
+    };
+    ASurfaceTransaction_applyFn = [](ASurfaceTransaction* transaction) {
+      auto* stub = reinterpret_cast<TransactionStub*>(transaction);
+
+      if (stub->on_commit)
+        stub->on_commit(stub->on_commit_ctx, nullptr);
+      stub->on_commit = nullptr;
+      stub->on_commit_ctx = nullptr;
+
+      if (stub->on_complete)
+        stub->on_complete(stub->on_complete_ctx, nullptr);
+      stub->on_complete = nullptr;
+      stub->on_complete_ctx = nullptr;
+
+      return static_cast<int64_t>(0);
+    };
+
+    ASurfaceTransaction_setOnCompleteFn =
+        [](ASurfaceTransaction* transaction, void* ctx,
+           ASurfaceTransaction_OnComplete callback) {
+          auto* stub = reinterpret_cast<TransactionStub*>(transaction);
+          stub->on_complete = callback;
+          stub->on_complete_ctx = ctx;
+        };
+
+    ASurfaceTransaction_setOnCommitFn =
+        [](ASurfaceTransaction* transaction, void* ctx,
+           ASurfaceTransaction_OnCommit callback) {
+          auto* stub = reinterpret_cast<TransactionStub*>(transaction);
+          stub->on_commit = callback;
+          stub->on_commit_ctx = ctx;
+        };
+  }
+
+  SurfaceControlMethods(bool load_functions) {
+    if (!load_functions)
+      return;
+
+    void* main_dl_handle = dlopen("libandroid.so", RTLD_NOW);
+    if (!main_dl_handle) {
+      LOG(ERROR) << "Couldnt load android so";
+      supported = false;
+      return;
+    }
+
+    LOAD_FUNCTION(main_dl_handle, ASurfaceControl_createFromWindow);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceControl_create);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceControl_release);
+
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_create);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_delete);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_apply);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setOnComplete);
+    LOAD_FUNCTION_MAYBE(main_dl_handle, ASurfaceTransaction_setOnCommit);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_reparent);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setVisibility);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setZOrder);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setBuffer);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setGeometry);
+    LOAD_FUNCTION_MAYBE(main_dl_handle, ASurfaceTransaction_setPosition);
+    LOAD_FUNCTION_MAYBE(main_dl_handle, ASurfaceTransaction_setScale);
+    LOAD_FUNCTION_MAYBE(main_dl_handle, ASurfaceTransaction_setCrop);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setBufferTransparency);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setDamageRegion);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransaction_setBufferDataSpace);
+    LOAD_FUNCTION_MAYBE(main_dl_handle, ASurfaceTransaction_setFrameRate);
+
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransactionStats_getPresentFenceFd);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransactionStats_getLatchTime);
+    LOAD_FUNCTION(main_dl_handle, ASurfaceTransactionStats_getASurfaceControls);
+    LOAD_FUNCTION(main_dl_handle,
+                  ASurfaceTransactionStats_releaseASurfaceControls);
+    LOAD_FUNCTION(main_dl_handle,
+                  ASurfaceTransactionStats_getPreviousReleaseFenceFd);
+  }
+
+  ~SurfaceControlMethods() = default;
+
+  bool supported = true;
+  // Surface methods.
+  pASurfaceControl_createFromWindow ASurfaceControl_createFromWindowFn;
+  pASurfaceControl_create ASurfaceControl_createFn;
+  pASurfaceControl_release ASurfaceControl_releaseFn;
+
+  // Transaction methods.
+  pASurfaceTransaction_create ASurfaceTransaction_createFn;
+  pASurfaceTransaction_delete ASurfaceTransaction_deleteFn;
+  pASurfaceTransaction_apply ASurfaceTransaction_applyFn;
+  pASurfaceTransaction_setOnComplete ASurfaceTransaction_setOnCompleteFn;
+  pASurfaceTransaction_setOnCommit ASurfaceTransaction_setOnCommitFn;
+  pASurfaceTransaction_reparent ASurfaceTransaction_reparentFn;
+  pASurfaceTransaction_setVisibility ASurfaceTransaction_setVisibilityFn;
+  pASurfaceTransaction_setZOrder ASurfaceTransaction_setZOrderFn;
+  pASurfaceTransaction_setBuffer ASurfaceTransaction_setBufferFn;
+  pASurfaceTransaction_setGeometry ASurfaceTransaction_setGeometryFn;
+  pASurfaceTransaction_setPosition ASurfaceTransaction_setPositionFn;
+  pASurfaceTransaction_setScale ASurfaceTransaction_setScaleFn;
+  pASurfaceTransaction_setCrop ASurfaceTransaction_setCropFn;
+  pASurfaceTransaction_setBufferTransparency
+      ASurfaceTransaction_setBufferTransparencyFn;
+  pASurfaceTransaction_setDamageRegion ASurfaceTransaction_setDamageRegionFn;
+  pASurfaceTransaction_setBufferDataSpace
+      ASurfaceTransaction_setBufferDataSpaceFn;
+  pASurfaceTransaction_setFrameRate ASurfaceTransaction_setFrameRateFn;
+
+  // TransactionStats methods.
+  pASurfaceTransactionStats_getPresentFenceFd
+      ASurfaceTransactionStats_getPresentFenceFdFn;
+  pASurfaceTransactionStats_getLatchTime
+      ASurfaceTransactionStats_getLatchTimeFn;
+  pASurfaceTransactionStats_getASurfaceControls
+      ASurfaceTransactionStats_getASurfaceControlsFn;
+  pASurfaceTransactionStats_releaseASurfaceControls
+      ASurfaceTransactionStats_releaseASurfaceControlsFn;
+  pASurfaceTransactionStats_getPreviousReleaseFenceFd
+      ASurfaceTransactionStats_getPreviousReleaseFenceFdFn;
+};
+
+ARect RectToARect(const gfx::Rect& rect) {
+  return ARect{rect.x(), rect.y(), rect.right(), rect.bottom()};
+}
+
+int32_t OverlayTransformToWindowTransform(gfx::OverlayTransform transform) {
+  // Note that the gfx::OverlayTransform expresses rotations in anticlockwise
+  // direction while the ANativeWindow rotations are in clockwise direction.
+  switch (transform) {
+    case gfx::OVERLAY_TRANSFORM_INVALID:
+      DCHECK(false) << "Invalid Transform";
+      return ANATIVEWINDOW_TRANSFORM_IDENTITY;
+    case gfx::OVERLAY_TRANSFORM_NONE:
+      return ANATIVEWINDOW_TRANSFORM_IDENTITY;
+    case gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
+      return ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL;
+    case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
+      return ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_90:
+      return ANATIVEWINDOW_TRANSFORM_ROTATE_270;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_180:
+      return ANATIVEWINDOW_TRANSFORM_ROTATE_180;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_270:
+      return ANATIVEWINDOW_TRANSFORM_ROTATE_90;
+  };
+  NOTREACHED();
+  return ANATIVEWINDOW_TRANSFORM_IDENTITY;
+}
+
+uint64_t ColorSpaceToADataSpace(const gfx::ColorSpace& color_space) {
+  if (!color_space.IsValid() || color_space == gfx::ColorSpace::CreateSRGB())
+    return ADATASPACE_SRGB;
+
+  if (color_space == gfx::ColorSpace::CreateSCRGBLinear())
+    return ADATASPACE_SCRGB_LINEAR;
+
+  if (color_space == gfx::ColorSpace::CreateDisplayP3D65())
+    return ADATASPACE_DISPLAY_P3;
+
+  // TODO(khushalsagar): Check if we can support BT2020 using
+  // ADATASPACE_BT2020_PQ.
+  return ADATASPACE_UNKNOWN;
+}
+
+SurfaceControl::TransactionStats ToTransactionStats(
+    ASurfaceTransactionStats* stats) {
+  SurfaceControl::TransactionStats transaction_stats;
+
+  // In unit tests we don't have stats.
+  if (!stats)
+    return transaction_stats;
+
+  transaction_stats.present_fence = base::ScopedFD(
+      SurfaceControlMethods::Get().ASurfaceTransactionStats_getPresentFenceFdFn(
+          stats));
+  transaction_stats.latch_time =
+      base::TimeTicks() +
+      base::Nanoseconds(
+          SurfaceControlMethods::Get().ASurfaceTransactionStats_getLatchTimeFn(
+              stats));
+  if (transaction_stats.latch_time == base::TimeTicks())
+    transaction_stats.latch_time = base::TimeTicks::Now();
+
+  ASurfaceControl** surface_controls = nullptr;
+  size_t size = 0u;
+  SurfaceControlMethods::Get().ASurfaceTransactionStats_getASurfaceControlsFn(
+      stats, &surface_controls, &size);
+  transaction_stats.surface_stats.resize(size);
+  for (size_t i = 0u; i < size; ++i) {
+    transaction_stats.surface_stats[i].surface = surface_controls[i];
+    int fence_fd = SurfaceControlMethods::Get()
+                       .ASurfaceTransactionStats_getPreviousReleaseFenceFdFn(
+                           stats, surface_controls[i]);
+    if (fence_fd != -1) {
+      transaction_stats.surface_stats[i].fence = base::ScopedFD(fence_fd);
+    }
+  }
+  SurfaceControlMethods::Get()
+      .ASurfaceTransactionStats_releaseASurfaceControlsFn(surface_controls);
+
+  return transaction_stats;
+}
+
+struct TransactionAckCtx {
+  int id = 0;
+  SurfaceControl::Transaction::OnCompleteCb callback;
+  SurfaceControl::Transaction::OnCommitCb latch_callback;
+};
+
+uint64_t GetTraceIdForTransaction(int transaction_id) {
+  constexpr uint64_t kMask =
+      base::MD5Hash64Constexpr("SurfaceControl::Transaction");
+  return kMask ^ transaction_id;
+}
+
+// Note that the framework API states that this callback can be dispatched on
+// any thread (in practice it should be a binder thread).
+void OnTransactionCompletedOnAnyThread(void* context,
+                                       ASurfaceTransactionStats* stats) {
+  auto* ack_ctx = static_cast<TransactionAckCtx*>(context);
+  auto transaction_stats = ToTransactionStats(stats);
+  TRACE_EVENT_NESTABLE_ASYNC_END0("gpu,benchmark", "SurfaceControlTransaction",
+                                  ack_ctx->id);
+  TRACE_EVENT_WITH_FLOW0(
+      "toplevel.flow", "gfx::SurfaceControlTransaction completed",
+      GetTraceIdForTransaction(ack_ctx->id), TRACE_EVENT_FLAG_FLOW_IN);
+
+  std::move(ack_ctx->callback).Run(std::move(transaction_stats));
+  delete ack_ctx;
+}
+
+// Note that the framework API states that this callback can be dispatched on
+// any thread (in practice it should be a binder thread).
+void OnTransactiOnCommittedOnAnyThread(void* context,
+                                       ASurfaceTransactionStats* stats) {
+  auto* ack_ctx = static_cast<TransactionAckCtx*>(context);
+  TRACE_EVENT_INSTANT0("gpu,benchmark", "SurfaceControlTransaction committed",
+                       TRACE_EVENT_SCOPE_THREAD);
+
+  std::move(ack_ctx->latch_callback).Run();
+  delete ack_ctx;
+}
+
+}  // namespace
+
+// static
+bool SurfaceControl::IsSupported() {
+  const auto* build_info = base::android::BuildInfo::GetInstance();
+
+  // Disabled on Samsung devices due to a platform bug fixed in R.
+  int min_sdk_version = base::android::SDK_VERSION_Q;
+  if (base::EqualsCaseInsensitiveASCII(build_info->manufacturer(), "samsung"))
+    min_sdk_version = base::android::SDK_VERSION_R;
+
+  if (build_info->sdk_int() < min_sdk_version)
+    return false;
+
+  CHECK(SurfaceControlMethods::Get().supported);
+  return true;
+}
+
+bool SurfaceControl::SupportsColorSpace(const gfx::ColorSpace& color_space) {
+  return ColorSpaceToADataSpace(color_space) != ADATASPACE_UNKNOWN;
+}
+
+uint64_t SurfaceControl::RequiredUsage() {
+  if (!IsSupported())
+    return 0u;
+  return g_agb_required_usage_bits;
+}
+
+void SurfaceControl::EnableQualcommUBWC() {
+  g_agb_required_usage_bits |= AHARDWAREBUFFER_USAGE_VENDOR_0;
+}
+
+bool SurfaceControl::SupportsSetFrameRate() {
+  // TODO(khushalsagar): Assert that this function is always available on R.
+  return IsSupported() &&
+         SurfaceControlMethods::Get().ASurfaceTransaction_setFrameRateFn !=
+             nullptr;
+}
+
+bool SurfaceControl::SupportsOnCommit() {
+  return IsSupported() &&
+         SurfaceControlMethods::Get().ASurfaceTransaction_setOnCommitFn !=
+             nullptr;
+}
+
+void SurfaceControl::SetStubImplementationForTesting() {
+  SurfaceControlMethods::GetImpl(/*load_functions=*/false).InitWithStubs();
+}
+
+void SurfaceControl::ApplyTransaction(ASurfaceTransaction* transaction) {
+  SurfaceControlMethods::Get().ASurfaceTransaction_applyFn(transaction);
+}
+
+scoped_refptr<SurfaceControl::Surface> SurfaceControl::Surface::WrapUnowned(
+    ASurfaceControl* surface) {
+  scoped_refptr<SurfaceControl::Surface> result =
+      base::MakeRefCounted<SurfaceControl::Surface>();
+  result->surface_ = surface;
+  return result;
+}
+
+SurfaceControl::Surface::Surface() = default;
+
+SurfaceControl::Surface::Surface(const Surface& parent, const char* name) {
+  owned_surface_ = SurfaceControlMethods::Get().ASurfaceControl_createFn(
+      parent.surface(), name);
+  if (!owned_surface_)
+    LOG(ERROR) << "Failed to create ASurfaceControl : " << name;
+  surface_ = owned_surface_;
+}
+
+SurfaceControl::Surface::Surface(ANativeWindow* parent, const char* name) {
+  owned_surface_ =
+      SurfaceControlMethods::Get().ASurfaceControl_createFromWindowFn(parent,
+                                                                      name);
+  if (!owned_surface_)
+    LOG(ERROR) << "Failed to create ASurfaceControl : " << name;
+  surface_ = owned_surface_;
+}
+
+SurfaceControl::Surface::~Surface() {
+  if (owned_surface_)
+    SurfaceControlMethods::Get().ASurfaceControl_releaseFn(owned_surface_);
+}
+
+SurfaceControl::SurfaceStats::SurfaceStats() = default;
+SurfaceControl::SurfaceStats::~SurfaceStats() = default;
+
+SurfaceControl::SurfaceStats::SurfaceStats(SurfaceStats&& other) = default;
+SurfaceControl::SurfaceStats& SurfaceControl::SurfaceStats::operator=(
+    SurfaceStats&& other) = default;
+
+SurfaceControl::TransactionStats::TransactionStats() = default;
+SurfaceControl::TransactionStats::~TransactionStats() = default;
+
+SurfaceControl::TransactionStats::TransactionStats(TransactionStats&& other) =
+    default;
+SurfaceControl::TransactionStats& SurfaceControl::TransactionStats::operator=(
+    TransactionStats&& other) = default;
+
+SurfaceControl::Transaction::Transaction()
+    : id_(g_next_transaction_id.GetNext()) {
+  transaction_ = SurfaceControlMethods::Get().ASurfaceTransaction_createFn();
+  DCHECK(transaction_);
+}
+
+SurfaceControl::Transaction::~Transaction() {
+  if (transaction_)
+    SurfaceControlMethods::Get().ASurfaceTransaction_deleteFn(transaction_);
+}
+
+SurfaceControl::Transaction::Transaction(Transaction&& other)
+    : id_(other.id_),
+      transaction_(other.transaction_),
+      on_commit_cb_(std::move(other.on_commit_cb_)),
+      on_complete_cb_(std::move(other.on_complete_cb_)) {
+  other.transaction_ = nullptr;
+  other.id_ = 0;
+}
+
+SurfaceControl::Transaction& SurfaceControl::Transaction::operator=(
+    Transaction&& other) {
+  if (transaction_)
+    SurfaceControlMethods::Get().ASurfaceTransaction_deleteFn(transaction_);
+
+  transaction_ = other.transaction_;
+  id_ = other.id_;
+  on_commit_cb_ = std::move(other.on_commit_cb_);
+  on_complete_cb_ = std::move(other.on_complete_cb_);
+
+  other.transaction_ = nullptr;
+  other.id_ = 0;
+  return *this;
+}
+
+void SurfaceControl::Transaction::SetVisibility(const Surface& surface,
+                                                bool show) {
+  SurfaceControlMethods::Get().ASurfaceTransaction_setVisibilityFn(
+      transaction_, surface.surface(), show);
+}
+
+void SurfaceControl::Transaction::SetZOrder(const Surface& surface, int32_t z) {
+  SurfaceControlMethods::Get().ASurfaceTransaction_setZOrderFn(
+      transaction_, surface.surface(), z);
+}
+
+void SurfaceControl::Transaction::SetBuffer(const Surface& surface,
+                                            AHardwareBuffer* buffer,
+                                            base::ScopedFD fence_fd) {
+  SurfaceControlMethods::Get().ASurfaceTransaction_setBufferFn(
+      transaction_, surface.surface(), buffer,
+      fence_fd.is_valid() ? fence_fd.release() : -1);
+}
+
+void SurfaceControl::Transaction::SetGeometry(const Surface& surface,
+                                              const gfx::Rect& src,
+                                              const gfx::Rect& dst,
+                                              gfx::OverlayTransform transform) {
+  SurfaceControlMethods::Get().ASurfaceTransaction_setGeometryFn(
+      transaction_, surface.surface(), RectToARect(src), RectToARect(dst),
+      OverlayTransformToWindowTransform(transform));
+}
+
+void SurfaceControl::Transaction::SetPosition(const Surface& surface,
+                                              const gfx::Point& position) {
+  CHECK(SurfaceControlMethods::Get().ASurfaceTransaction_setPositionFn);
+  SurfaceControlMethods::Get().ASurfaceTransaction_setPositionFn(
+      transaction_, surface.surface(), position.x(), position.y());
+}
+
+void SurfaceControl::Transaction::SetScale(const Surface& surface,
+                                           const float sx,
+                                           float sy) {
+  CHECK(SurfaceControlMethods::Get().ASurfaceTransaction_setScaleFn);
+  SurfaceControlMethods::Get().ASurfaceTransaction_setScaleFn(
+      transaction_, surface.surface(), sx, sy);
+}
+
+void SurfaceControl::Transaction::SetCrop(const Surface& surface,
+                                          const gfx::Rect& rect) {
+  CHECK(SurfaceControlMethods::Get().ASurfaceTransaction_setCropFn);
+  SurfaceControlMethods::Get().ASurfaceTransaction_setCropFn(
+      transaction_, surface.surface(), RectToARect(rect));
+}
+
+void SurfaceControl::Transaction::SetOpaque(const Surface& surface,
+                                            bool opaque) {
+  int8_t transparency = opaque ? ASURFACE_TRANSACTION_TRANSPARENCY_OPAQUE
+                               : ASURFACE_TRANSACTION_TRANSPARENCY_TRANSLUCENT;
+  SurfaceControlMethods::Get().ASurfaceTransaction_setBufferTransparencyFn(
+      transaction_, surface.surface(), transparency);
+}
+
+void SurfaceControl::Transaction::SetDamageRect(const Surface& surface,
+                                                const gfx::Rect& rect) {
+  auto a_rect = RectToARect(rect);
+  SurfaceControlMethods::Get().ASurfaceTransaction_setDamageRegionFn(
+      transaction_, surface.surface(), &a_rect, 1u);
+}
+
+void SurfaceControl::Transaction::SetColorSpace(
+    const Surface& surface,
+    const gfx::ColorSpace& color_space) {
+  auto data_space = ColorSpaceToADataSpace(color_space);
+
+  // Log the data space in crash keys for debugging crbug.com/997592.
+  static auto* kCrashKey = base::debug::AllocateCrashKeyString(
+      "data_space_for_buffer", base::debug::CrashKeySize::Size256);
+  auto crash_key_value = base::NumberToString(data_space);
+  base::debug::ScopedCrashKeyString scoped_crash_key(kCrashKey,
+                                                     crash_key_value);
+
+  SurfaceControlMethods::Get().ASurfaceTransaction_setBufferDataSpaceFn(
+      transaction_, surface.surface(), data_space);
+}
+
+void SurfaceControl::Transaction::SetFrameRate(const Surface& surface,
+                                               float frame_rate) {
+  DCHECK(SupportsSetFrameRate());
+
+  // We always used fixed source here since a non-default value is only used for
+  // videos which have a fixed playback rate.
+  SurfaceControlMethods::Get().ASurfaceTransaction_setFrameRateFn(
+      transaction_, surface.surface(), frame_rate,
+      ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_FIXED_SOURCE);
+}
+
+void SurfaceControl::Transaction::SetParent(const Surface& surface,
+                                            Surface* new_parent) {
+  SurfaceControlMethods::Get().ASurfaceTransaction_reparentFn(
+      transaction_, surface.surface(),
+      new_parent ? new_parent->surface() : nullptr);
+}
+
+void SurfaceControl::Transaction::SetOnCompleteCb(
+    OnCompleteCb cb,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  TRACE_EVENT_WITH_FLOW0(
+      "toplevel.flow", "gfx::SurfaceControl::Transaction::SetOnCompleteCb",
+      GetTraceIdForTransaction(id_), TRACE_EVENT_FLAG_FLOW_OUT);
+
+  DCHECK(!on_complete_cb_);
+  on_complete_cb_ = base::BindPostTask(std::move(task_runner), std::move(cb));
+}
+
+void SurfaceControl::Transaction::SetOnCommitCb(
+    OnCommitCb cb,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(!on_commit_cb_);
+  on_commit_cb_ = base::BindPostTask(std::move(task_runner), std::move(cb));
+}
+
+void SurfaceControl::Transaction::Apply() {
+  TRACE_EVENT_NESTABLE_ASYNC_BEGIN0("gpu,benchmark",
+                                    "SurfaceControlTransaction", id_);
+
+  PrepareCallbacks();
+  SurfaceControlMethods::Get().ASurfaceTransaction_applyFn(transaction_);
+}
+
+ASurfaceTransaction* SurfaceControl::Transaction::GetTransaction() {
+  PrepareCallbacks();
+  return transaction_;
+}
+
+void SurfaceControl::Transaction::PrepareCallbacks() {
+  if (on_commit_cb_) {
+    TransactionAckCtx* ack_ctx = new TransactionAckCtx;
+    ack_ctx->latch_callback = std::move(on_commit_cb_);
+    ack_ctx->id = id_;
+
+    SurfaceControlMethods::Get().ASurfaceTransaction_setOnCommitFn(
+        transaction_, ack_ctx, &OnTransactiOnCommittedOnAnyThread);
+  }
+
+  if (on_complete_cb_) {
+    TransactionAckCtx* ack_ctx = new TransactionAckCtx;
+    ack_ctx->callback = std::move(on_complete_cb_);
+    ack_ctx->id = id_;
+
+    SurfaceControlMethods::Get().ASurfaceTransaction_setOnCompleteFn(
+        transaction_, ack_ctx, &OnTransactionCompletedOnAnyThread);
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/android/android_surface_control_compat.h b/ui/gfx/android/android_surface_control_compat.h
new file mode 100644
index 0000000..d5eee6f
--- /dev/null
+++ b/ui/gfx/android/android_surface_control_compat.h
@@ -0,0 +1,175 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANDROID_ANDROID_SURFACE_CONTROL_COMPAT_H_
+#define UI_GFX_ANDROID_ANDROID_SURFACE_CONTROL_COMPAT_H_
+
+#include <android/hardware_buffer.h>
+#include <android/native_window.h>
+
+#include <memory>
+#include <vector>
+
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/overlay_transform.h"
+
+extern "C" {
+typedef struct ASurfaceControl ASurfaceControl;
+typedef struct ASurfaceTransaction ASurfaceTransaction;
+}
+
+namespace gfx {
+class ColorSpace;
+
+class GFX_EXPORT SurfaceControl {
+ public:
+  // Check if the platform is capable of supporting the low-level SurfaceControl
+  // API. See also gpu/config/gpu_util's GetAndroidSurfaceControlFeatureStatus
+  // which checks other prerequisites such as Gpufence support before declaring
+  // support for the high-level SurfaceControl feature in Chrome.
+  static bool IsSupported();
+
+  // Returns true if overlays with |color_space| are supported by the platform.
+  static bool SupportsColorSpace(const gfx::ColorSpace& color_space);
+
+  // Returns the usage flags required for using an AHardwareBuffer with the
+  // SurfaceControl API, if it is supported.
+  static uint64_t RequiredUsage();
+
+  // Enables usage bits requires for getting UBWC on Qualcomm devices. Must be
+  // called early at process startup, before any buffer allocations are made.
+  static void EnableQualcommUBWC();
+
+  // Returns true if tagging a surface with a frame rate value is supported.
+  static bool SupportsSetFrameRate();
+
+  // Returns true if OnCommit callback is supported.
+  static bool SupportsOnCommit();
+
+  // Applies transaction. Used to emulate webview functor interface, where we
+  // pass raw ASurfaceTransaction object. For use inside Chromium use
+  // Transaction class below instead.
+  static void ApplyTransaction(ASurfaceTransaction* transaction);
+
+  static void SetStubImplementationForTesting();
+
+  class GFX_EXPORT Surface : public base::RefCounted<Surface> {
+   public:
+    // Wraps ASurfaceControl, but doesn't transfer ownership. Will not release
+    // in dtor.
+    static scoped_refptr<Surface> WrapUnowned(ASurfaceControl* surface);
+
+    Surface();
+    Surface(const Surface& parent, const char* name);
+    Surface(ANativeWindow* parent, const char* name);
+
+    Surface(const Surface&) = delete;
+    Surface& operator=(const Surface&) = delete;
+
+    ASurfaceControl* surface() const { return surface_; }
+
+   private:
+    friend class base::RefCounted<Surface>;
+    ~Surface();
+
+    ASurfaceControl* surface_ = nullptr;
+    ASurfaceControl* owned_surface_ = nullptr;
+  };
+
+  struct GFX_EXPORT SurfaceStats {
+    SurfaceStats();
+    ~SurfaceStats();
+
+    SurfaceStats(SurfaceStats&& other);
+    SurfaceStats& operator=(SurfaceStats&& other);
+
+    ASurfaceControl* surface = nullptr;
+
+    // The fence which is signaled when the reads for the previous buffer for
+    // the given |surface| are finished.
+    base::ScopedFD fence;
+  };
+
+  struct GFX_EXPORT TransactionStats {
+   public:
+    TransactionStats();
+
+    TransactionStats(const TransactionStats&) = delete;
+    TransactionStats& operator=(const TransactionStats&) = delete;
+
+    ~TransactionStats();
+
+    TransactionStats(TransactionStats&& other);
+    TransactionStats& operator=(TransactionStats&& other);
+
+    // The fence which is signaled when this transaction is presented by the
+    // display.
+    base::ScopedFD present_fence;
+    std::vector<SurfaceStats> surface_stats;
+    base::TimeTicks latch_time;
+  };
+
+  class GFX_EXPORT Transaction {
+   public:
+    Transaction();
+
+    Transaction(const Transaction&) = delete;
+    Transaction& operator=(const Transaction&) = delete;
+
+    ~Transaction();
+
+    Transaction(Transaction&& other);
+    Transaction& operator=(Transaction&& other);
+
+    void SetVisibility(const Surface& surface, bool show);
+    void SetZOrder(const Surface& surface, int32_t z);
+    void SetBuffer(const Surface& surface,
+                   AHardwareBuffer* buffer,
+                   base::ScopedFD fence_fd);
+    void SetGeometry(const Surface& surface,
+                     const gfx::Rect& src,
+                     const gfx::Rect& dst,
+                     gfx::OverlayTransform transform);
+    void SetOpaque(const Surface& surface, bool opaque);
+    void SetDamageRect(const Surface& surface, const gfx::Rect& rect);
+    void SetColorSpace(const Surface& surface,
+                       const gfx::ColorSpace& color_space);
+    void SetFrameRate(const Surface& surface, float frame_rate);
+    void SetParent(const Surface& surface, Surface* new_parent);
+    void SetPosition(const Surface& surface, const gfx::Point& position);
+    void SetScale(const Surface& surface, float sx, float sy);
+    void SetCrop(const Surface& surface, const gfx::Rect& rect);
+
+    // Sets the callback which will be dispatched when the transaction is acked
+    // by the framework.
+    // |task_runner| provides an optional task runner on which the callback
+    // should be run.
+    using OnCompleteCb = base::OnceCallback<void(TransactionStats stats)>;
+    void SetOnCompleteCb(
+        OnCompleteCb cb,
+        scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
+    using OnCommitCb = base::OnceClosure;
+    void SetOnCommitCb(OnCommitCb cb,
+                       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
+    void Apply();
+    ASurfaceTransaction* GetTransaction();
+
+   private:
+    void PrepareCallbacks();
+
+    int id_;
+    ASurfaceTransaction* transaction_;
+    OnCommitCb on_commit_cb_;
+    OnCompleteCb on_complete_cb_;
+  };
+};
+}  // namespace gfx
+
+#endif  // UI_GFX_ANDROID_ANDROID_SURFACE_CONTROL_COMPAT_H_
diff --git a/ui/gfx/android/android_surface_control_compat_unittest.cc b/ui/gfx/android/android_surface_control_compat_unittest.cc
new file mode 100644
index 0000000..fd7d181
--- /dev/null
+++ b/ui/gfx/android/android_surface_control_compat_unittest.cc
@@ -0,0 +1,163 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/android/android_surface_control_compat.h"
+
+#include "base/callback.h"
+#include "base/run_loop.h"
+#include "base/test/task_environment.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+namespace {
+
+class SurfaceControlTransactionTest : public testing::Test {
+ public:
+  SurfaceControlTransactionTest() {
+    gfx::SurfaceControl::SetStubImplementationForTesting();
+  }
+
+ protected:
+  struct CallbackContext {
+    CallbackContext(bool* called, bool* destroyed)
+        : called(called), destroyed(destroyed) {}
+    ~CallbackContext() { *destroyed = true; }
+    bool* called;
+    bool* destroyed;
+  };
+
+  SurfaceControl::Transaction::OnCompleteCb CreateOnCompleteCb(
+      bool* called,
+      bool* destroyed) {
+    return base::BindOnce(
+        [](std::unique_ptr<CallbackContext> context,
+           SurfaceControl::TransactionStats stats) {
+          DCHECK(!*context->called);
+          *context->called = true;
+        },
+        std::make_unique<CallbackContext>(called, destroyed));
+  }
+
+  SurfaceControl::Transaction::OnCommitCb CreateOnCommitCb(bool* called,
+                                                           bool* destroyed) {
+    return base::BindOnce(
+        [](std::unique_ptr<CallbackContext> context) {
+          DCHECK(!*context->called);
+          *context->called = true;
+        },
+        std::make_unique<CallbackContext>(called, destroyed));
+  }
+
+  void RunRemainingTasks() {
+    base::RunLoop runloop;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  runloop.QuitClosure());
+    runloop.Run();
+  }
+
+  base::test::SingleThreadTaskEnvironment task_environment;
+};
+
+TEST_F(SurfaceControlTransactionTest, CallbackCalledAfterApply) {
+  bool on_complete_called = false;
+  bool on_commit_called = false;
+  bool on_commit_destroyed = false;
+  bool on_complete_destroyed = false;
+
+  gfx::SurfaceControl::Transaction transaction;
+  transaction.SetOnCompleteCb(
+      CreateOnCompleteCb(&on_complete_called, &on_complete_destroyed),
+      base::ThreadTaskRunnerHandle::Get());
+  transaction.SetOnCommitCb(
+      CreateOnCommitCb(&on_commit_called, &on_commit_destroyed),
+      base::ThreadTaskRunnerHandle::Get());
+
+  // Nothing should have been called yet.
+  EXPECT_FALSE(on_complete_called);
+  EXPECT_FALSE(on_commit_called);
+
+  transaction.Apply();
+  RunRemainingTasks();
+
+  // After apply callbacks should be called.
+  EXPECT_TRUE(on_complete_called);
+  EXPECT_TRUE(on_commit_called);
+
+  // As this is Once callback naturally it's context should have been destroyed.
+  EXPECT_TRUE(on_complete_destroyed);
+  EXPECT_TRUE(on_commit_destroyed);
+}
+
+TEST_F(SurfaceControlTransactionTest, CallbackDestroyedWithoutApply) {
+  bool on_complete_called = false;
+  bool on_commit_called = false;
+  bool on_commit_destroyed = false;
+  bool on_complete_destroyed = false;
+
+  {
+    SurfaceControl::Transaction transaction;
+    transaction.SetOnCompleteCb(
+        CreateOnCompleteCb(&on_complete_called, &on_complete_destroyed),
+        base::ThreadTaskRunnerHandle::Get());
+    transaction.SetOnCommitCb(
+        CreateOnCommitCb(&on_commit_called, &on_commit_destroyed),
+        base::ThreadTaskRunnerHandle::Get());
+
+    // Nothing should have been called yet.
+    EXPECT_FALSE(on_complete_called);
+    EXPECT_FALSE(on_commit_called);
+  }
+
+  RunRemainingTasks();
+
+  // Apply wasn't called, but transaction left the scope, so the callback
+  // contexts should have been destroyed.
+  EXPECT_TRUE(on_complete_destroyed);
+  EXPECT_TRUE(on_commit_destroyed);
+}
+
+TEST_F(SurfaceControlTransactionTest, CallbackSetupAfterGetTransaction) {
+  bool on_complete_called = false;
+  bool on_commit_called = false;
+  bool on_commit_destroyed = false;
+  bool on_complete_destroyed = false;
+
+  gfx::SurfaceControl::Transaction transaction;
+  transaction.SetOnCompleteCb(
+      CreateOnCompleteCb(&on_complete_called, &on_complete_destroyed),
+      base::ThreadTaskRunnerHandle::Get());
+  transaction.SetOnCommitCb(
+      CreateOnCommitCb(&on_commit_called, &on_commit_destroyed),
+      base::ThreadTaskRunnerHandle::Get());
+
+  // Nothing should have been called yet.
+  EXPECT_FALSE(on_complete_called);
+  EXPECT_FALSE(on_commit_called);
+
+  auto* asurfacetransaction = transaction.GetTransaction();
+
+  // Should be no task to run, but calling this to make sure nothing is
+  // scheduled that can call callbacks.
+  RunRemainingTasks();
+
+  // And not yet.
+  EXPECT_FALSE(on_complete_called);
+  EXPECT_FALSE(on_commit_called);
+
+  // This is usually called by framework.
+  SurfaceControl::ApplyTransaction(asurfacetransaction);
+  RunRemainingTasks();
+
+  // After apply callbacks should be called.
+  EXPECT_TRUE(on_complete_called);
+  EXPECT_TRUE(on_commit_called);
+
+  // As this is Once callback naturally it's context should have been destroyed.
+  EXPECT_TRUE(on_complete_destroyed);
+  EXPECT_TRUE(on_commit_destroyed);
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/android/java_bitmap.cc b/ui/gfx/android/java_bitmap.cc
new file mode 100644
index 0000000..e107a55
--- /dev/null
+++ b/ui/gfx/android/java_bitmap.cc
@@ -0,0 +1,148 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/android/java_bitmap.h"
+
+#include <android/bitmap.h>
+
+#include "base/android/jni_string.h"
+#include "base/bits.h"
+#include "base/check_op.h"
+#include "base/notreached.h"
+#include "base/numerics/safe_conversions.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_jni_headers/BitmapHelper_jni.h"
+
+using base::android::AttachCurrentThread;
+using base::android::ConvertUTF8ToJavaString;
+using base::android::ScopedJavaLocalRef;
+using base::android::JavaRef;
+
+namespace gfx {
+namespace {
+
+int SkColorTypeToBitmapFormat(SkColorType color_type) {
+  switch (color_type) {
+    case kN32_SkColorType:
+      return BITMAP_FORMAT_ARGB_8888;
+    case kRGB_565_SkColorType:
+      return BITMAP_FORMAT_RGB_565;
+    default:
+      // A bad format can cause out-of-bounds issues when copying pixels into or
+      // out of the java bitmap's pixel buffer.
+      CHECK_NE(color_type, color_type);
+  }
+  return BITMAP_FORMAT_NO_CONFIG;
+}
+
+SkColorType BitmapFormatToSkColorType(BitmapFormat bitmap_format) {
+  switch (bitmap_format) {
+    case BITMAP_FORMAT_ALPHA_8:
+      return kAlpha_8_SkColorType;
+    case BITMAP_FORMAT_ARGB_4444:
+      return kARGB_4444_SkColorType;
+    case BITMAP_FORMAT_ARGB_8888:
+      return kN32_SkColorType;
+    case BITMAP_FORMAT_RGB_565:
+      return kRGB_565_SkColorType;
+    case BITMAP_FORMAT_NO_CONFIG:
+    default:
+      CHECK_NE(bitmap_format, bitmap_format);
+      return kUnknown_SkColorType;
+  }
+}
+
+// Wraps a Java bitmap as an SkPixmap. Since the pixmap references the
+// underlying pixel data in the Java bitmap directly, it is only valid as long
+// as |bitmap| is.
+SkPixmap WrapJavaBitmapAsPixmap(const JavaBitmap& bitmap) {
+  auto color_type = BitmapFormatToSkColorType(bitmap.format());
+  auto image_info =
+      SkImageInfo::Make(bitmap.size().width(), bitmap.size().height(),
+                        color_type, kPremul_SkAlphaType);
+  return SkPixmap(image_info, bitmap.pixels(), bitmap.bytes_per_row());
+}
+
+}  // namespace
+
+#define ASSERT_ENUM_EQ(a, b) \
+  static_assert(static_cast<int>(a) == static_cast<int>(b), "")
+
+// BitmapFormat has the same values as AndroidBitmapFormat, for simplicitly, so
+// that SkColorTypeToBitmapFormat() and the JavaBitmap::format() have the same
+// values.
+ASSERT_ENUM_EQ(BITMAP_FORMAT_NO_CONFIG, ANDROID_BITMAP_FORMAT_NONE);
+ASSERT_ENUM_EQ(BITMAP_FORMAT_ALPHA_8, ANDROID_BITMAP_FORMAT_A_8);
+ASSERT_ENUM_EQ(BITMAP_FORMAT_ARGB_4444, ANDROID_BITMAP_FORMAT_RGBA_4444);
+ASSERT_ENUM_EQ(BITMAP_FORMAT_ARGB_8888, ANDROID_BITMAP_FORMAT_RGBA_8888);
+ASSERT_ENUM_EQ(BITMAP_FORMAT_RGB_565, ANDROID_BITMAP_FORMAT_RGB_565);
+
+JavaBitmap::JavaBitmap(const JavaRef<jobject>& bitmap)
+    : bitmap_(bitmap), pixels_(NULL) {
+  int err =
+      AndroidBitmap_lockPixels(AttachCurrentThread(), bitmap_.obj(), &pixels_);
+  DCHECK(!err);
+  DCHECK(pixels_);
+
+  AndroidBitmapInfo info;
+  err = AndroidBitmap_getInfo(AttachCurrentThread(), bitmap_.obj(), &info);
+  DCHECK(!err);
+  size_ = gfx::Size(info.width, info.height);
+  format_ = static_cast<BitmapFormat>(info.format);
+  bytes_per_row_ = info.stride;
+  byte_count_ = Java_BitmapHelper_getByteCount(AttachCurrentThread(), bitmap_);
+}
+
+JavaBitmap::~JavaBitmap() {
+  int err = AndroidBitmap_unlockPixels(AttachCurrentThread(), bitmap_.obj());
+  DCHECK(!err);
+}
+
+ScopedJavaLocalRef<jobject> ConvertToJavaBitmap(const SkBitmap& skbitmap,
+                                                OomBehavior reaction) {
+  DCHECK(!skbitmap.isNull());
+  DCHECK_GT(skbitmap.width(), 0);
+  DCHECK_GT(skbitmap.height(), 0);
+
+  int java_bitmap_format = SkColorTypeToBitmapFormat(skbitmap.colorType());
+
+  ScopedJavaLocalRef<jobject> jbitmap = Java_BitmapHelper_createBitmap(
+      AttachCurrentThread(), skbitmap.width(), skbitmap.height(),
+      java_bitmap_format, reaction == OomBehavior::kReturnNullOnOom);
+  if (!jbitmap) {
+    DCHECK_EQ(OomBehavior::kReturnNullOnOom, reaction);
+    return jbitmap;
+  }
+
+  JavaBitmap dst_lock(jbitmap);
+  SkPixmap dst = WrapJavaBitmapAsPixmap(dst_lock);
+  skbitmap.readPixels(dst);
+  return jbitmap;
+}
+
+SkBitmap CreateSkBitmapFromJavaBitmap(const JavaBitmap& jbitmap) {
+  DCHECK(!jbitmap.size().IsEmpty());
+  DCHECK_GT(jbitmap.bytes_per_row(), 0U);
+  DCHECK(jbitmap.pixels());
+
+  // Ensure 4 byte stride alignment since the texture upload code in the
+  // compositor relies on this.
+  SkPixmap src = WrapJavaBitmapAsPixmap(jbitmap);
+  const size_t min_row_bytes = src.info().minRowBytes();
+  const size_t row_bytes = base::bits::AlignUp(min_row_bytes, 4u);
+
+  SkBitmap skbitmap;
+  skbitmap.allocPixels(src.info(), row_bytes);
+  skbitmap.writePixels(src);
+  return skbitmap;
+}
+
+SkColorType ConvertToSkiaColorType(const JavaRef<jobject>& bitmap_config) {
+  BitmapFormat jbitmap_format =
+      static_cast<BitmapFormat>(Java_BitmapHelper_getBitmapFormatForConfig(
+          AttachCurrentThread(), bitmap_config));
+  return BitmapFormatToSkColorType(jbitmap_format);
+}
+
+}  //  namespace gfx
diff --git a/ui/gfx/android/java_bitmap.h b/ui/gfx/android/java_bitmap.h
new file mode 100644
index 0000000..72ec80b
--- /dev/null
+++ b/ui/gfx/android/java_bitmap.h
@@ -0,0 +1,81 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANDROID_JAVA_BITMAP_H_
+#define UI_GFX_ANDROID_JAVA_BITMAP_H_
+
+#include <jni.h>
+#include <stdint.h>
+
+#include "base/android/scoped_java_ref.h"
+#include "base/macros.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// A Java counterpart will be generated for this enum.
+// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.ui.gfx
+// The order and values here match AndroidBitmapFormat, as verified
+// by static_asserts in java_bitmap.cc.
+enum BitmapFormat {
+  BITMAP_FORMAT_NO_CONFIG = 0,
+  BITMAP_FORMAT_ARGB_8888 = 1,
+  BITMAP_FORMAT_RGB_565 = 4,
+  BITMAP_FORMAT_ARGB_4444 = 7,
+  BITMAP_FORMAT_ALPHA_8 = 8,
+};
+
+// This class wraps a JNI AndroidBitmap object to make it easier to use. It
+// handles locking and unlocking of the underlying pixels, along with wrapping
+// various JNI methods.
+class GFX_EXPORT JavaBitmap {
+ public:
+  explicit JavaBitmap(const base::android::JavaRef<jobject>& bitmap);
+
+  JavaBitmap(const JavaBitmap&) = delete;
+  JavaBitmap& operator=(const JavaBitmap&) = delete;
+
+  ~JavaBitmap();
+
+  inline void* pixels() { return pixels_; }
+  inline const void* pixels() const { return pixels_; }
+  inline const gfx::Size& size() const { return size_; }
+  inline BitmapFormat format() const { return format_; }
+  inline uint32_t bytes_per_row() const { return bytes_per_row_; }
+  inline int byte_count() const { return byte_count_; }
+
+ private:
+  base::android::ScopedJavaGlobalRef<jobject> bitmap_;
+  void* pixels_;
+  gfx::Size size_;
+  BitmapFormat format_;
+  uint32_t bytes_per_row_;
+  int byte_count_;
+};
+
+enum class OomBehavior {
+  kCrashOnOom,
+  kReturnNullOnOom,
+};
+
+// Converts |skbitmap| to a Java-backed bitmap (android.graphics.Bitmap).
+// Note: |skbitmap| is assumed to be non-null, non-empty and one of RGBA_8888 or
+// RGB_565 formats.
+GFX_EXPORT base::android::ScopedJavaLocalRef<jobject> ConvertToJavaBitmap(
+    const SkBitmap& skbitmap,
+    OomBehavior reaction = OomBehavior::kCrashOnOom);
+
+// Converts |bitmap| to an SkBitmap of the same size and format.
+// Note: |jbitmap| is assumed to be non-null, non-empty and of format RGBA_8888.
+GFX_EXPORT SkBitmap CreateSkBitmapFromJavaBitmap(const JavaBitmap& jbitmap);
+
+// Returns a Skia color type value for the requested input java Bitmap.Config.
+GFX_EXPORT SkColorType
+ConvertToSkiaColorType(const base::android::JavaRef<jobject>& jbitmap_config);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANDROID_JAVA_BITMAP_H_
diff --git a/ui/gfx/android/view_configuration.cc b/ui/gfx/android/view_configuration.cc
new file mode 100644
index 0000000..6397809
--- /dev/null
+++ b/ui/gfx/android/view_configuration.cc
@@ -0,0 +1,179 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/android/view_configuration.h"
+
+#include "base/android/jni_android.h"
+#include "base/lazy_instance.h"
+#include "base/macros.h"
+#include "base/synchronization/lock.h"
+#include "ui/gfx/gfx_jni_headers/ViewConfigurationHelper_jni.h"
+
+using base::android::AttachCurrentThread;
+using base::android::JavaParamRef;
+
+namespace gfx {
+
+namespace {
+
+struct ViewConfigurationData {
+  ViewConfigurationData()
+      : double_tap_timeout_in_ms_(0),
+        long_press_timeout_in_ms_(0),
+        tap_timeout_in_ms_(0),
+        max_fling_velocity_in_dips_s_(0),
+        min_fling_velocity_in_dips_s_(0),
+        touch_slop_in_dips_(0),
+        double_tap_slop_in_dips_(0),
+        min_scaling_span_in_dips_(0) {
+    JNIEnv* env = AttachCurrentThread();
+    j_view_configuration_helper_.Reset(
+        Java_ViewConfigurationHelper_createWithListener(env));
+
+    double_tap_timeout_in_ms_ =
+        Java_ViewConfigurationHelper_getDoubleTapTimeout(env);
+    long_press_timeout_in_ms_ =
+        Java_ViewConfigurationHelper_getLongPressTimeout(env);
+    tap_timeout_in_ms_ = Java_ViewConfigurationHelper_getTapTimeout(env);
+
+    Update(Java_ViewConfigurationHelper_getMaximumFlingVelocity(
+               env, j_view_configuration_helper_),
+           Java_ViewConfigurationHelper_getMinimumFlingVelocity(
+               env, j_view_configuration_helper_),
+           Java_ViewConfigurationHelper_getTouchSlop(
+               env, j_view_configuration_helper_),
+           Java_ViewConfigurationHelper_getDoubleTapSlop(
+               env, j_view_configuration_helper_),
+           Java_ViewConfigurationHelper_getMinScalingSpan(
+               env, j_view_configuration_helper_));
+  }
+
+  ViewConfigurationData(const ViewConfigurationData&) = delete;
+  ViewConfigurationData& operator=(const ViewConfigurationData&) = delete;
+
+  ~ViewConfigurationData() {}
+
+  void SynchronizedUpdate(float maximum_fling_velocity,
+                          float minimum_fling_velocity,
+                          float touch_slop,
+                          float double_tap_slop,
+                          float min_scaling_span) {
+    base::AutoLock autolock(lock_);
+    Update(maximum_fling_velocity, minimum_fling_velocity, touch_slop,
+           double_tap_slop, min_scaling_span);
+  }
+
+  int double_tap_timeout_in_ms() const { return double_tap_timeout_in_ms_; }
+  int long_press_timeout_in_ms() const { return long_press_timeout_in_ms_; }
+  int tap_timeout_in_ms() const { return tap_timeout_in_ms_; }
+
+  int max_fling_velocity_in_dips_s() {
+    base::AutoLock autolock(lock_);
+    return max_fling_velocity_in_dips_s_;
+  }
+
+  int min_fling_velocity_in_dips_s() {
+    base::AutoLock autolock(lock_);
+    return min_fling_velocity_in_dips_s_;
+  }
+
+  int touch_slop_in_dips() {
+    base::AutoLock autolock(lock_);
+    return touch_slop_in_dips_;
+  }
+
+  int double_tap_slop_in_dips() {
+    base::AutoLock autolock(lock_);
+    return double_tap_slop_in_dips_;
+  }
+
+  int min_scaling_span_in_dips() {
+    base::AutoLock autolock(lock_);
+    return min_scaling_span_in_dips_;
+  }
+
+ private:
+  void Update(float maximum_fling_velocity,
+              float minimum_fling_velocity,
+              float touch_slop,
+              float double_tap_slop,
+              float min_scaling_span) {
+    DCHECK_LE(minimum_fling_velocity, maximum_fling_velocity);
+    max_fling_velocity_in_dips_s_ = maximum_fling_velocity;
+    min_fling_velocity_in_dips_s_ = minimum_fling_velocity;
+    touch_slop_in_dips_ = touch_slop;
+    double_tap_slop_in_dips_ = double_tap_slop;
+    min_scaling_span_in_dips_ = min_scaling_span;
+  }
+
+  base::Lock lock_;
+  base::android::ScopedJavaGlobalRef<jobject> j_view_configuration_helper_;
+
+  // These values will remain constant throughout the lifetime of the app, so
+  // read-access needn't be synchronized.
+  int double_tap_timeout_in_ms_;
+  int long_press_timeout_in_ms_;
+  int tap_timeout_in_ms_;
+
+  // These values may vary as view-specific parameters change, so read/write
+  // access must be synchronized.
+  int max_fling_velocity_in_dips_s_;
+  int min_fling_velocity_in_dips_s_;
+  int touch_slop_in_dips_;
+  int double_tap_slop_in_dips_;
+  int min_scaling_span_in_dips_;
+};
+
+// Leaky to allow access from any thread.
+base::LazyInstance<ViewConfigurationData>::Leaky g_view_configuration =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+static void JNI_ViewConfigurationHelper_UpdateSharedViewConfiguration(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    jfloat maximum_fling_velocity,
+    jfloat minimum_fling_velocity,
+    jfloat touch_slop,
+    jfloat double_tap_slop,
+    jfloat min_scaling_span) {
+  g_view_configuration.Get().SynchronizedUpdate(
+      maximum_fling_velocity, minimum_fling_velocity, touch_slop,
+      double_tap_slop, min_scaling_span);
+}
+
+int ViewConfiguration::GetDoubleTapTimeoutInMs() {
+  return g_view_configuration.Get().double_tap_timeout_in_ms();
+}
+
+int ViewConfiguration::GetLongPressTimeoutInMs() {
+  return g_view_configuration.Get().long_press_timeout_in_ms();
+}
+
+int ViewConfiguration::GetTapTimeoutInMs() {
+  return g_view_configuration.Get().tap_timeout_in_ms();
+}
+
+int ViewConfiguration::GetMaximumFlingVelocityInDipsPerSecond() {
+  return g_view_configuration.Get().max_fling_velocity_in_dips_s();
+}
+
+int ViewConfiguration::GetMinimumFlingVelocityInDipsPerSecond() {
+  return g_view_configuration.Get().min_fling_velocity_in_dips_s();
+}
+
+int ViewConfiguration::GetTouchSlopInDips() {
+  return g_view_configuration.Get().touch_slop_in_dips();
+}
+
+int ViewConfiguration::GetDoubleTapSlopInDips() {
+  return g_view_configuration.Get().double_tap_slop_in_dips();
+}
+
+int ViewConfiguration::GetMinScalingSpanInDips() {
+  return g_view_configuration.Get().min_scaling_span_in_dips();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/android/view_configuration.h b/ui/gfx/android/view_configuration.h
new file mode 100644
index 0000000..e7353de
--- /dev/null
+++ b/ui/gfx/android/view_configuration.h
@@ -0,0 +1,33 @@
+// 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.
+
+#ifndef UI_GFX_ANDROID_VIEW_CONFIGURATION_H_
+#define UI_GFX_ANDROID_VIEW_CONFIGURATION_H_
+
+#include <jni.h>
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Provides access to Android's ViewConfiguration for gesture-related constants.
+// Note: All methods may be safely called from any thread.
+class GFX_EXPORT ViewConfiguration {
+ public:
+  static int GetDoubleTapTimeoutInMs();
+  static int GetLongPressTimeoutInMs();
+  static int GetTapTimeoutInMs();
+
+  static int GetMaximumFlingVelocityInDipsPerSecond();
+  static int GetMinimumFlingVelocityInDipsPerSecond();
+
+  static int GetTouchSlopInDips();
+  static int GetDoubleTapSlopInDips();
+
+  static int GetMinScalingSpanInDips();
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANDROID_VIEW_CONFIGURATION_H_
diff --git a/ui/gfx/animation/BUILD.gn b/ui/gfx/animation/BUILD.gn
new file mode 100644
index 0000000..7876107
--- /dev/null
+++ b/ui/gfx/animation/BUILD.gn
@@ -0,0 +1,88 @@
+# Copyright 2017 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.
+
+import("//build/config/chromeos/ui_mode.gni")
+import("//build/config/ui.gni")
+
+if (is_android) {
+  import("//build/config/android/config.gni")
+  import("//build/config/android/rules.gni")
+}
+
+component("animation") {
+  sources = [
+    "animation.cc",
+    "animation.h",
+    "animation_container.cc",
+    "animation_container.h",
+    "animation_container_element.h",
+    "animation_container_observer.h",
+    "animation_delegate.h",
+    "animation_delegate_notifier.h",
+    "animation_export.h",
+    "animation_runner.cc",
+    "animation_runner.h",
+    "linear_animation.cc",
+    "linear_animation.h",
+    "multi_animation.cc",
+    "multi_animation.h",
+    "slide_animation.cc",
+    "slide_animation.h",
+    "tween.cc",
+    "tween.h",
+  ]
+
+  if (is_android) {
+    sources += [ "animation_android.cc" ]
+  }
+
+  if (is_mac) {
+    sources += [ "animation_mac.mm" ]
+  }
+
+  if (is_win) {
+    sources += [ "animation_win.cc" ]
+  }
+
+  if (is_linux || is_chromeos_lacros) {
+    sources += [
+      "animation_linux.cc",
+      "animation_settings_provider_linux.cc",
+      "animation_settings_provider_linux.h",
+    ]
+  }
+
+  if (!is_android) {
+    sources += [
+      "throb_animation.cc",
+      "throb_animation.h",
+    ]
+  }
+
+  if (is_mac) {
+    frameworks = [
+      "AppKit.framework",
+      "CoreFoundation.framework",
+      "CoreGraphics.framework",
+      "CoreText.framework",
+      "IOSurface.framework",
+    ]
+  }
+
+  deps = [
+    "//base",
+    "//build:chromeos_buildflags",
+    "//skia",
+    "//ui/gfx:gfx_export",
+    "//ui/gfx:gfx_switches",
+    "//ui/gfx/geometry",
+    "//ui/gfx/geometry:geometry_skia",
+  ]
+
+  if (is_android) {
+    deps += [ "//ui/gfx:gfx_jni_headers" ]
+  }
+
+  defines = [ "ANIMATION_IMPLEMENTATION" ]
+}
diff --git a/ui/gfx/animation/DEPS b/ui/gfx/animation/DEPS
new file mode 100644
index 0000000..841ceff
--- /dev/null
+++ b/ui/gfx/animation/DEPS
@@ -0,0 +1,3 @@
+include_rules = [
+  "+ui/gfx/gfx_jni_headers",
+]
diff --git a/ui/gfx/animation/DIR_METADATA b/ui/gfx/animation/DIR_METADATA
new file mode 100644
index 0000000..bc9e717
--- /dev/null
+++ b/ui/gfx/animation/DIR_METADATA
@@ -0,0 +1,12 @@
+# Metadata information for this directory.
+#
+# For more information on DIR_METADATA files, see:
+#   https://source.chromium.org/chromium/infra/infra/+/main:go/src/infra/tools/dirmd/README.md
+#
+# For the schema of this file, see Metadata message:
+#   https://source.chromium.org/chromium/infra/infra/+/main:go/src/infra/tools/dirmd/proto/dir_metadata.proto
+
+monorail {
+  component: "Internals>Compositing>Animation"
+}
+team_email: "threaded-rendering-dev@chromium.org"
\ No newline at end of file
diff --git a/ui/gfx/animation/OWNERS b/ui/gfx/animation/OWNERS
new file mode 100644
index 0000000..a56274e
--- /dev/null
+++ b/ui/gfx/animation/OWNERS
@@ -0,0 +1,2 @@
+flackr@chromium.org
+vollick@chromium.org
diff --git a/ui/gfx/animation/animation.cc b/ui/gfx/animation/animation.cc
new file mode 100644
index 0000000..c07fb28
--- /dev/null
+++ b/ui/gfx/animation/animation.cc
@@ -0,0 +1,169 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/animation/animation.h"
+
+#include <memory>
+
+#include "base/command_line.h"
+#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
+#include "ui/gfx/animation/animation_container.h"
+#include "ui/gfx/animation/animation_delegate.h"
+#include "ui/gfx/animation/tween.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+
+// static
+Animation::RichAnimationRenderMode Animation::rich_animation_rendering_mode_ =
+    RichAnimationRenderMode::PLATFORM;
+
+// static
+absl::optional<bool> Animation::prefers_reduced_motion_;
+
+Animation::Animation(base::TimeDelta timer_interval)
+    : timer_interval_(timer_interval),
+      is_animating_(false),
+      delegate_(nullptr) {}
+
+Animation::~Animation() {
+  // Don't send out notification from the destructor. Chances are the delegate
+  // owns us and is being deleted as well.
+  if (is_animating_)
+    container_->Stop(this);
+}
+
+void Animation::Start() {
+  if (is_animating_)
+    return;
+
+  if (!container_) {
+    container_ = base::MakeRefCounted<AnimationContainer>();
+    if (delegate_)
+      delegate_->AnimationContainerWasSet(container_.get());
+  }
+
+  is_animating_ = true;
+
+  container_->Start(this);
+
+  AnimationStarted();
+}
+
+void Animation::Stop() {
+  if (!is_animating_)
+    return;
+
+  is_animating_ = false;
+
+  // Notify the container first as the delegate may delete us.
+  container_->Stop(this);
+
+  AnimationStopped();
+
+  if (delegate_) {
+    if (ShouldSendCanceledFromStop())
+      delegate_->AnimationCanceled(this);
+    else
+      delegate_->AnimationEnded(this);
+  }
+}
+
+double Animation::CurrentValueBetween(double start, double target) const {
+  return Tween::DoubleValueBetween(GetCurrentValue(), start, target);
+}
+
+int Animation::CurrentValueBetween(int start, int target) const {
+  return Tween::IntValueBetween(GetCurrentValue(), start, target);
+}
+
+gfx::Rect Animation::CurrentValueBetween(const gfx::Rect& start_bounds,
+                                         const gfx::Rect& target_bounds) const {
+  return Tween::RectValueBetween(
+      GetCurrentValue(), start_bounds, target_bounds);
+}
+
+void Animation::SetContainer(AnimationContainer* container) {
+  if (container == container_.get())
+    return;
+
+  if (is_animating_)
+    container_->Stop(this);
+
+  if (container)
+    container_ = container;
+  else
+    container_ = new AnimationContainer();
+
+  if (delegate_)
+    delegate_->AnimationContainerWasSet(container_.get());
+
+  if (is_animating_)
+    container_->Start(this);
+}
+
+bool Animation::ShouldRenderRichAnimation() {
+  if (rich_animation_rendering_mode_ == RichAnimationRenderMode::PLATFORM)
+    return ShouldRenderRichAnimationImpl();
+  return rich_animation_rendering_mode_ ==
+         RichAnimationRenderMode::FORCE_ENABLED;
+}
+
+#if defined(OS_ANDROID) || BUILDFLAG(IS_CHROMEOS_ASH) || defined(OS_IOS) || \
+    defined(OS_FUCHSIA)
+// static
+bool Animation::ShouldRenderRichAnimationImpl() {
+  return true;
+  // Defined in platform specific file for Windows and OSX and Linux.
+}
+
+// static
+bool Animation::ScrollAnimationsEnabledBySystem() {
+  return true;
+  // Defined in platform specific files for Windows and OSX and Linux.
+}
+
+#if !defined(OS_ANDROID)
+// static
+void Animation::UpdatePrefersReducedMotion() {
+  // prefers_reduced_motion_ should only be modified on the UI thread.
+  // TODO(crbug.com/927163): DCHECK this assertion once tests are well-behaved.
+
+  // By default, we assume that animations are enabled, to avoid impacting the
+  // experience for users on systems that don't have APIs for reduced motion.
+  prefers_reduced_motion_ = false;
+}
+#endif  // !defined(OS_ANDROID)
+#endif  // defined(OS_ANDROID) || BUILDFLAG(IS_CHROMEOS_ASH) || defined(OS_IOS)
+        // || defined(OS_FUCHSIA)
+
+// static
+bool Animation::PrefersReducedMotion() {
+  // --force-prefers-reduced-motion must always override
+  // |prefers_reduced_motion_|, so check it first.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kForcePrefersReducedMotion)) {
+    return true;
+  }
+
+  if (!prefers_reduced_motion_.has_value())
+    UpdatePrefersReducedMotion();
+  return prefers_reduced_motion_.value();
+}
+
+bool Animation::ShouldSendCanceledFromStop() {
+  return false;
+}
+
+void Animation::SetStartTime(base::TimeTicks start_time) {
+  start_time_ = start_time;
+}
+
+base::TimeDelta Animation::GetTimerInterval() const {
+  return timer_interval_;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation.h b/ui/gfx/animation/animation.h
new file mode 100644
index 0000000..e665d1f
--- /dev/null
+++ b/ui/gfx/animation/animation.h
@@ -0,0 +1,147 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_H_
+#define UI_GFX_ANIMATION_ANIMATION_H_
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/time/time.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/animation/animation_container_element.h"
+#include "ui/gfx/animation/animation_export.h"
+
+namespace gfx {
+class Rect;
+}
+
+namespace gfx {
+
+class AnimationContainer;
+class AnimationDelegate;
+class AnimationTestApi;
+
+// Base class used in implementing animations. You only need use this class if
+// you're implementing a new animation type, otherwise you'll likely want one of
+// LinearAnimation, SlideAnimation, ThrobAnimation or MultiAnimation.
+//
+// To subclass override Step, which is invoked as the animation progresses and
+// GetCurrentValue() to return the value appropriate to the animation.
+class ANIMATION_EXPORT Animation : public AnimationContainerElement {
+ public:
+  // Used with SetRichAnimationRenderMode() to force enable/disable rich
+  // animations during tests.
+  enum class RichAnimationRenderMode {
+    PLATFORM,
+    FORCE_ENABLED,
+    FORCE_DISABLED
+  };
+
+  explicit Animation(base::TimeDelta timer_interval);
+
+  Animation(const Animation&) = delete;
+  Animation& operator=(const Animation&) = delete;
+
+  ~Animation() override;
+
+  // Starts the animation. Does nothing if the animation is already running.
+  void Start();
+
+  // Stops the animation. Does nothing if the animation is not running.
+  void Stop();
+
+  // Gets the value for the current state, according to the animation
+  // curve in use.
+  virtual double GetCurrentValue() const = 0;
+
+  // Convenience for returning a value between |start| and |target| based on
+  // the current value. This is (target - start) * GetCurrentValue() + start.
+  double CurrentValueBetween(double start, double target) const;
+  int CurrentValueBetween(int start, int target) const;
+  gfx::Rect CurrentValueBetween(const gfx::Rect& start_bounds,
+                                const gfx::Rect& target_bounds) const;
+
+  // Sets the delegate.
+  void set_delegate(AnimationDelegate* delegate) { delegate_ = delegate; }
+
+  // Sets the container used to manage the timer. A value of NULL results in
+  // creating a new AnimationContainer.
+  void SetContainer(AnimationContainer* container);
+
+  bool is_animating() const { return is_animating_; }
+
+  base::TimeDelta timer_interval() const { return timer_interval_; }
+
+  // Returns true if rich animations should be rendered.
+  // Looks at session type (e.g. remote desktop) and accessibility settings
+  // to give guidance for heavy animations such as "start download" arrow.
+  static bool ShouldRenderRichAnimation();
+
+  // Determines on a per-platform basis whether scroll animations (e.g. produced
+  // by home/end key) should be enabled. Should only be called from the browser
+  // process.
+  static bool ScrollAnimationsEnabledBySystem();
+
+  // Determines whether the user desires reduced motion based on platform APIs.
+  // Should only be called from the browser process, on the UI thread.
+  static bool PrefersReducedMotion();
+  static void UpdatePrefersReducedMotion();
+  static void SetPrefersReducedMotionForTesting(bool prefers_reduced_motion) {
+    prefers_reduced_motion_ = prefers_reduced_motion;
+  }
+
+ protected:
+  // Invoked from Start to allow subclasses to prepare for the animation.
+  virtual void AnimationStarted() {}
+
+  // Invoked from Stop after we're removed from the container but before the
+  // delegate has been invoked.
+  virtual void AnimationStopped() {}
+
+  // Invoked from stop to determine if cancel should be invoked. If this returns
+  // true the delegate is notified the animation was canceled, otherwise the
+  // delegate is notified the animation stopped.
+  virtual bool ShouldSendCanceledFromStop();
+
+  AnimationContainer* container() { return container_.get(); }
+  base::TimeTicks start_time() const { return start_time_; }
+  AnimationDelegate* delegate() { return delegate_; }
+
+  // AnimationContainer::Element overrides
+  void SetStartTime(base::TimeTicks start_time) override;
+  void Step(base::TimeTicks time_now) override = 0;
+  base::TimeDelta GetTimerInterval() const override;
+
+ private:
+  friend class AnimationTestApi;
+
+  static bool ShouldRenderRichAnimationImpl();
+
+  // The mode in which to render rich animations.
+  static RichAnimationRenderMode rich_animation_rendering_mode_;
+
+  // Interval for the animation.
+  const base::TimeDelta timer_interval_;
+
+  // If true we're running.
+  bool is_animating_;
+
+  // Our delegate; may be null.
+  AnimationDelegate* delegate_;
+
+  // Container we're in. If non-null we're animating.
+  scoped_refptr<AnimationContainer> container_;
+
+  // Time we started at.
+  base::TimeTicks start_time_;
+
+  // Obtaining the PrefersReducedMotion system setting can be expensive, so it
+  // is cached in this boolean.
+  static absl::optional<bool> prefers_reduced_motion_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_H_
diff --git a/ui/gfx/animation/animation_android.cc b/ui/gfx/animation/animation_android.cc
new file mode 100644
index 0000000..1637e2d
--- /dev/null
+++ b/ui/gfx/animation/animation_android.cc
@@ -0,0 +1,23 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/animation/animation.h"
+
+#include "base/android/jni_android.h"
+#include "ui/gfx/gfx_jni_headers/Animation_jni.h"
+
+using base::android::AttachCurrentThread;
+
+namespace gfx {
+
+// static
+void Animation::UpdatePrefersReducedMotion() {
+  // prefers_reduced_motion_ should only be modified on the UI thread.
+  // TODO(crbug.com/927163): DCHECK this assertion once tests are well-behaved.
+
+  JNIEnv* env = AttachCurrentThread();
+  prefers_reduced_motion_ = Java_Animation_prefersReducedMotion(env);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_container.cc b/ui/gfx/animation/animation_container.cc
new file mode 100644
index 0000000..dbfbd6b
--- /dev/null
+++ b/ui/gfx/animation/animation_container.cc
@@ -0,0 +1,146 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/animation/animation_container.h"
+
+#include "base/bind.h"
+#include "ui/gfx/animation/animation_container_element.h"
+#include "ui/gfx/animation/animation_container_observer.h"
+
+using base::TimeTicks;
+
+namespace gfx {
+
+AnimationContainer::AnimationContainer() = default;
+
+AnimationContainer::~AnimationContainer() {
+  if (observer_)
+    observer_->AnimationContainerShuttingDown(this);
+
+  // The animations own us and stop themselves before being deleted. If they're
+  // still running, something is wrong.
+  DCHECK(!is_running());
+}
+
+void AnimationContainer::Start(AnimationContainerElement* element) {
+  DCHECK(elements_.count(element) == 0);  // Start should only be invoked if the
+                                          // element isn't running.
+
+  if (!is_running()) {
+    last_tick_time_ = base::TimeTicks::Now();
+    SetMinTimerInterval(element->GetTimerInterval());
+    min_timer_interval_count_ = 1;
+  } else if (element->GetTimerInterval() < min_timer_interval_) {
+    SetMinTimerInterval(element->GetTimerInterval());
+    min_timer_interval_count_ = 1;
+  } else if (element->GetTimerInterval() == min_timer_interval_) {
+    min_timer_interval_count_++;
+  }
+
+  element->SetStartTime(last_tick_time_);
+  elements_.insert(element);
+}
+
+void AnimationContainer::Stop(AnimationContainerElement* element) {
+  DCHECK(elements_.count(element) > 0);  // The element must be running.
+
+  base::TimeDelta interval = element->GetTimerInterval();
+  elements_.erase(element);
+
+  if (!is_running()) {
+    runner_->Stop();
+    min_timer_interval_count_ = 0;
+    if (observer_)
+      observer_->AnimationContainerEmpty(this);
+  } else if (interval == min_timer_interval_) {
+    min_timer_interval_count_--;
+
+    // If the last element at the current (minimum) timer interval has been
+    // removed then go find the new minimum and the number of elements at that
+    // same minimum.
+    if (min_timer_interval_count_ == 0) {
+      std::pair<base::TimeDelta, size_t> interval_count =
+          GetMinIntervalAndCount();
+      DCHECK(interval_count.first > min_timer_interval_);
+      SetMinTimerInterval(interval_count.first);
+      min_timer_interval_count_ = interval_count.second;
+    }
+  }
+}
+
+void AnimationContainer::SetAnimationRunner(
+    std::unique_ptr<AnimationRunner> runner) {
+  has_custom_animation_runner_ = !!runner;
+  runner_ = has_custom_animation_runner_
+                ? std::move(runner)
+                : AnimationRunner::CreateDefaultAnimationRunner();
+  if (is_running())
+    RestartTimer(base::TimeTicks::Now() - last_tick_time_);
+}
+
+void AnimationContainer::Run(base::TimeTicks current_time) {
+  // We notify the observer after updating all the elements. If all the elements
+  // are deleted as a result of updating then our ref count would go to zero and
+  // we would be deleted before we notify our observer. We add a reference to
+  // ourself here to make sure we're still valid after running all the elements.
+  scoped_refptr<AnimationContainer> this_ref(this);
+
+  last_tick_time_ = current_time;
+
+  // Make a copy of the elements to iterate over so that if any elements are
+  // removed as part of invoking Step there aren't any problems.
+  Elements elements = elements_;
+
+  for (Elements::const_iterator i = elements.begin();
+       i != elements.end(); ++i) {
+    // Make sure the element is still valid.
+    if (elements_.find(*i) != elements_.end())
+      (*i)->Step(current_time);
+  }
+
+  if (observer_)
+    observer_->AnimationContainerProgressed(this);
+}
+
+void AnimationContainer::SetMinTimerInterval(base::TimeDelta delta) {
+  // This doesn't take into account how far along the current element is, but
+  // that shouldn't be a problem for uses of Animation/AnimationContainer.
+  runner_->Stop();
+  min_timer_interval_ = delta;
+  RestartTimer(base::TimeDelta());
+}
+
+void AnimationContainer::RestartTimer(base::TimeDelta elapsed) {
+  runner_->Start(
+      min_timer_interval_, elapsed,
+      base::BindRepeating(&AnimationContainer::Run, base::Unretained(this)));
+}
+
+std::pair<base::TimeDelta, size_t> AnimationContainer::GetMinIntervalAndCount()
+    const {
+  DCHECK(is_running());
+
+  // Find the minimum interval and the number of elements sharing that same
+  // interval. It is tempting to create a map of intervals -> counts in order to
+  // make this O(log n) instead of O(n). However, profiling shows that this
+  // offers no practical performance gain (the most common case is that all
+  // elements in the set share the same interval).
+  base::TimeDelta min;
+  size_t count = 1;
+  auto i = elements_.begin();
+  min = (*i)->GetTimerInterval();
+  for (++i; i != elements_.end(); ++i) {
+    auto interval = (*i)->GetTimerInterval();
+    if (interval < min) {
+      min = interval;
+      count = 1;
+    } else if (interval == min) {
+      count++;
+    }
+  }
+
+  return std::make_pair(min, count);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_container.h b/ui/gfx/animation/animation_container.h
new file mode 100644
index 0000000..fc80028
--- /dev/null
+++ b/ui/gfx/animation/animation_container.h
@@ -0,0 +1,122 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_CONTAINER_H_
+#define UI_GFX_ANIMATION_ANIMATION_CONTAINER_H_
+
+#include <memory>
+#include <utility>
+
+#include "base/containers/flat_set.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/time/time.h"
+#include "ui/gfx/animation/animation_export.h"
+#include "ui/gfx/animation/animation_runner.h"
+
+namespace gfx {
+
+class AnimationContainerElement;
+class AnimationContainerObserver;
+
+// AnimationContainer is used by Animation to manage the underlying
+// AnimationRunner. Internally each Animation creates a single
+// AnimationContainer. You can group a set of Animations into the same
+// AnimationContainer by way of Animation::SetContainer. Grouping a set of
+// Animations into the same AnimationContainer ensures they all update and start
+// at the same time.
+//
+// AnimationContainer is ref counted. Each Animation contained within the
+// AnimationContainer own it.
+class ANIMATION_EXPORT AnimationContainer
+    : public base::RefCounted<AnimationContainer> {
+ public:
+  AnimationContainer();
+
+  AnimationContainer(const AnimationContainer&) = delete;
+  AnimationContainer& operator=(const AnimationContainer&) = delete;
+
+  // Invoked by Animation when it needs to start. Starts the timer if necessary.
+  // NOTE: This is invoked by Animation for you, you shouldn't invoke this
+  // directly.
+  void Start(AnimationContainerElement* animation);
+
+  // Invoked by Animation when it needs to stop. If there are no more animations
+  // running the timer stops.
+  // NOTE: This is invoked by Animation for you, you shouldn't invoke this
+  // directly.
+  void Stop(AnimationContainerElement* animation);
+
+  void set_observer(AnimationContainerObserver* observer) {
+    observer_ = observer;
+  }
+
+  // The time the last animation ran at.
+  base::TimeTicks last_tick_time() const { return last_tick_time_; }
+
+  // Are there any timers running?
+  bool is_running() const { return !elements_.empty(); }
+
+  void SetAnimationRunner(std::unique_ptr<AnimationRunner> runner);
+  AnimationRunner* animation_runner_for_testing() { return runner_.get(); }
+  bool has_custom_animation_runner() const {
+    return has_custom_animation_runner_;
+  }
+
+ private:
+  friend class AnimationContainerTestApi;
+  friend class base::RefCounted<AnimationContainer>;
+
+  // This set is usually quite small so a flat_set is the most obvious choice.
+  // However, in extreme cases this can grow to 100s or even 1000s of elements.
+  // Since this set is duplicated on every call to 'Run' and indexed very
+  // frequently the cache locality of the vector is more important than the
+  // costlier (but rarer) insertion. Profiling shows that flat_set continues to
+  // perform best in these cases (up to 12x faster than std::set).
+  typedef base::flat_set<AnimationContainerElement*> Elements;
+
+  ~AnimationContainer();
+
+  // Timer callback method.
+  void Run(base::TimeTicks current_time);
+
+  // Sets min_timer_interval_ and restarts the timer.
+  void SetMinTimerInterval(base::TimeDelta delta);
+
+  // Restarts the timer, assuming |elapsed| has already elapsed out of the timer
+  // interval.
+  void RestartTimer(base::TimeDelta elapsed);
+
+  // Returns the min timer interval of all the timers, and the count of timers
+  // at that interval.
+  std::pair<base::TimeDelta, size_t> GetMinIntervalAndCount() const;
+
+  // Represents one of two possible values:
+  // . If only a single animation has been started and the timer hasn't yet
+  //   fired this is the time the animation was added.
+  // . The time the last animation ran at (::Run was invoked).
+  base::TimeTicks last_tick_time_ = base::TimeTicks::Now();
+
+  // Set of elements (animations) being managed.
+  Elements elements_;
+
+  // Minimum interval the timers run at, plus the number of timers that have
+  // been seen at that interval. The most common case is for all of the
+  // animations to run at 60Hz, in which case all of the intervals are the same.
+  // This acts as a cache of size 1, and when an animation stops and is removed
+  // it means that the linear scan for the new minimum timer can almost always
+  // be avoided.
+  base::TimeDelta min_timer_interval_;
+  size_t min_timer_interval_count_ = 0;
+
+  std::unique_ptr<AnimationRunner> runner_ =
+      AnimationRunner::CreateDefaultAnimationRunner();
+  bool has_custom_animation_runner_ = false;
+
+  AnimationContainerObserver* observer_ = nullptr;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_CONTAINER_H_
diff --git a/ui/gfx/animation/animation_container_element.h b/ui/gfx/animation/animation_container_element.h
new file mode 100644
index 0000000..6e39ef4
--- /dev/null
+++ b/ui/gfx/animation/animation_container_element.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_CONTAINER_ELEMENT_H_
+#define UI_GFX_ANIMATION_ANIMATION_CONTAINER_ELEMENT_H_
+
+#include "base/time/time.h"
+#include "ui/gfx/animation/animation_export.h"
+
+namespace gfx {
+
+// Interface for the elements the AnimationContainer contains. This is
+// implemented by Animation.
+class ANIMATION_EXPORT AnimationContainerElement {
+ public:
+  // Sets the start of the animation. This is invoked from
+  // AnimationContainer::Start.
+  virtual void SetStartTime(base::TimeTicks start_time) = 0;
+
+  // Invoked when the animation is to progress.
+  virtual void Step(base::TimeTicks time_now) = 0;
+
+  // Returns the time interval of the animation. If an Element needs to change
+  // this it should first invoke Stop, then Start.
+  virtual base::TimeDelta GetTimerInterval() const = 0;
+
+ protected:
+  virtual ~AnimationContainerElement() {}
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_CONTAINER_ELEMENT_H_
diff --git a/ui/gfx/animation/animation_container_observer.h b/ui/gfx/animation/animation_container_observer.h
new file mode 100644
index 0000000..77d9cb4
--- /dev/null
+++ b/ui/gfx/animation/animation_container_observer.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_CONTAINER_OBSERVER_H_
+#define UI_GFX_ANIMATION_ANIMATION_CONTAINER_OBSERVER_H_
+
+#include "ui/gfx/animation/animation_export.h"
+
+namespace gfx {
+
+class AnimationContainer;
+
+// The observer is notified after every update of the animations managed by
+// the container.
+class ANIMATION_EXPORT AnimationContainerObserver {
+ public:
+  // Invoked on every tick of the timer managed by the container and after
+  // all the animations have updated.
+  virtual void AnimationContainerProgressed(AnimationContainer* container) {}
+
+  // Invoked when no more animations are being managed by this container.
+  virtual void AnimationContainerEmpty(AnimationContainer* container) {}
+
+  // Invoked from AnimationContainer's destructor.
+  virtual void AnimationContainerShuttingDown(AnimationContainer* container) {}
+
+ protected:
+  virtual ~AnimationContainerObserver() {}
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_CONTAINER_OBSERVER_H_
diff --git a/ui/gfx/animation/animation_container_unittest.cc b/ui/gfx/animation/animation_container_unittest.cc
new file mode 100644
index 0000000..9322e21
--- /dev/null
+++ b/ui/gfx/animation/animation_container_unittest.cc
@@ -0,0 +1,175 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/animation/animation_container.h"
+
+#include <memory>
+
+#include "base/macros.h"
+#include "base/run_loop.h"
+#include "base/test/task_environment.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/animation/animation_container_observer.h"
+#include "ui/gfx/animation/animation_test_api.h"
+#include "ui/gfx/animation/linear_animation.h"
+#include "ui/gfx/animation/test_animation_delegate.h"
+
+namespace gfx {
+
+namespace {
+
+class FakeAnimationContainerObserver : public AnimationContainerObserver {
+ public:
+  FakeAnimationContainerObserver()
+      : progressed_count_(0),
+        empty_(false) {
+  }
+
+  FakeAnimationContainerObserver(const FakeAnimationContainerObserver&) =
+      delete;
+  FakeAnimationContainerObserver& operator=(
+      const FakeAnimationContainerObserver&) = delete;
+
+  int progressed_count() const { return progressed_count_; }
+  bool empty() const { return empty_; }
+
+ private:
+  void AnimationContainerProgressed(AnimationContainer* container) override {
+    progressed_count_++;
+  }
+
+  // Invoked when no more animations are being managed by this container.
+  void AnimationContainerEmpty(AnimationContainer* container) override {
+    empty_ = true;
+  }
+
+  void AnimationContainerShuttingDown(AnimationContainer* container) override {}
+
+  int progressed_count_;
+  bool empty_;
+};
+
+class TestAnimation : public LinearAnimation {
+ public:
+  explicit TestAnimation(AnimationDelegate* delegate)
+      : LinearAnimation(base::Milliseconds(20), 20, delegate) {}
+
+  TestAnimation(const TestAnimation&) = delete;
+  TestAnimation& operator=(const TestAnimation&) = delete;
+
+  void AnimateToState(double state) override {}
+
+  using LinearAnimation::duration;
+};
+
+}  // namespace
+
+class AnimationContainerTest: public testing::Test {
+ protected:
+  AnimationContainerTest()
+      : task_environment_(
+            base::test::SingleThreadTaskEnvironment::MainThreadType::UI) {}
+
+ private:
+  base::test::SingleThreadTaskEnvironment task_environment_;
+};
+
+// Makes sure the animation ups the ref count of the container and releases it
+// appropriately.
+TEST_F(AnimationContainerTest, Ownership) {
+  TestAnimationDelegate delegate;
+  scoped_refptr<AnimationContainer> container(new AnimationContainer());
+  std::unique_ptr<Animation> animation(new TestAnimation(&delegate));
+  animation->SetContainer(container.get());
+  // Setting the container should up the ref count.
+  EXPECT_FALSE(container->HasOneRef());
+
+  animation.reset();
+
+  // Releasing the animation should decrement the ref count.
+  EXPECT_TRUE(container->HasOneRef());
+}
+
+// Makes sure multiple animations are managed correctly.
+TEST_F(AnimationContainerTest, Multi) {
+  TestAnimationDelegate delegate1;
+  TestAnimationDelegate delegate2;
+
+  scoped_refptr<AnimationContainer> container(new AnimationContainer());
+  TestAnimation animation1(&delegate1);
+  TestAnimation animation2(&delegate2);
+  animation1.SetContainer(container.get());
+  animation2.SetContainer(container.get());
+
+  // Start both animations.
+  animation1.Start();
+  EXPECT_TRUE(container->is_running());
+  animation2.Start();
+  EXPECT_TRUE(container->is_running());
+
+  // Run the message loop the delegate quits the message loop when notified.
+  base::RunLoop().Run();
+
+  // Both timers should have finished.
+  EXPECT_TRUE(delegate1.finished());
+  EXPECT_TRUE(delegate2.finished());
+
+  // And the container should no longer be runnings.
+  EXPECT_FALSE(container->is_running());
+}
+
+// Makes sure observer is notified appropriately.
+TEST_F(AnimationContainerTest, Observer) {
+  FakeAnimationContainerObserver observer;
+  TestAnimationDelegate delegate1;
+
+  scoped_refptr<AnimationContainer> container(new AnimationContainer());
+  container->set_observer(&observer);
+  TestAnimation animation1(&delegate1);
+  animation1.SetContainer(container.get());
+
+  // Start the animation.
+  animation1.Start();
+  EXPECT_TRUE(container->is_running());
+
+  // Run the message loop. The delegate quits the message loop when notified.
+  base::RunLoop().Run();
+
+  EXPECT_EQ(1, observer.progressed_count());
+
+  // The timer should have finished.
+  EXPECT_TRUE(delegate1.finished());
+
+  EXPECT_TRUE(observer.empty());
+
+  // And the container should no longer be running.
+  EXPECT_FALSE(container->is_running());
+
+  container->set_observer(NULL);
+}
+
+// Tests that calling SetAnimationRunner() keeps running animations at their
+// current point.
+TEST_F(AnimationContainerTest, AnimationsRunAcrossRunnerChange) {
+  TestAnimationDelegate delegate;
+  auto container = base::MakeRefCounted<AnimationContainer>();
+  AnimationContainerTestApi test_api(container.get());
+  TestAnimation animation(&delegate);
+  animation.SetContainer(container.get());
+
+  animation.Start();
+  test_api.IncrementTime(animation.duration() / 2);
+  EXPECT_FALSE(delegate.finished());
+
+  container->SetAnimationRunner(nullptr);
+  AnimationRunner* runner = container->animation_runner_for_testing();
+  ASSERT_TRUE(runner);
+  ASSERT_FALSE(runner->step_is_null_for_testing());
+  EXPECT_FALSE(delegate.finished());
+
+  test_api.IncrementTime(animation.duration() / 2);
+  EXPECT_TRUE(delegate.finished());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_delegate.h b/ui/gfx/animation/animation_delegate.h
new file mode 100644
index 0000000..b582d16
--- /dev/null
+++ b/ui/gfx/animation/animation_delegate.h
@@ -0,0 +1,39 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_DELEGATE_H_
+#define UI_GFX_ANIMATION_ANIMATION_DELEGATE_H_
+
+#include "ui/gfx/animation/animation_export.h"
+
+namespace gfx {
+
+class Animation;
+class AnimationContainer;
+
+// AnimationDelegate
+//
+//  Implement this interface when you want to receive notifications about the
+//  state of an animation.
+class ANIMATION_EXPORT AnimationDelegate {
+ public:
+  virtual ~AnimationDelegate() {}
+
+  // Called when an animation has completed.
+  virtual void AnimationEnded(const Animation* animation) {}
+
+  // Called when an animation has progressed.
+  virtual void AnimationProgressed(const Animation* animation) {}
+
+  // Called when an animation has been canceled.
+  virtual void AnimationCanceled(const Animation* animation) {}
+
+  // Called when an animation container has been set. This gives a chance to
+  // set a custom animation runner.
+  virtual void AnimationContainerWasSet(AnimationContainer* container) {}
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_DELEGATE_H_
diff --git a/ui/gfx/animation/animation_delegate_notifier.h b/ui/gfx/animation/animation_delegate_notifier.h
new file mode 100644
index 0000000..7983a70
--- /dev/null
+++ b/ui/gfx/animation/animation_delegate_notifier.h
@@ -0,0 +1,55 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_DELEGATE_NOTIFIER_H_
+#define UI_GFX_ANIMATION_ANIMATION_DELEGATE_NOTIFIER_H_
+
+#include "base/check.h"
+#include "ui/gfx/animation/animation_delegate.h"
+
+namespace gfx {
+
+// AnimationDelegateNotifier adapts AnimationDelegate (which is used by
+// inheritance) into an object that is used by composition. This can be useful
+// to compose the functionality of an AnimationDelegate subclass into an object
+// that inherits directly from AnimationDelegate.
+template <class AnimationDelegateType = gfx::AnimationDelegate>
+class AnimationDelegateNotifier : public AnimationDelegateType {
+ public:
+  template <typename... Args>
+  AnimationDelegateNotifier(gfx::AnimationDelegate* owner, Args&&... args)
+      : AnimationDelegateType(std::forward<Args>(args)...), owner_(owner) {
+    DCHECK(owner_);
+  }
+
+  ~AnimationDelegateNotifier() override = default;
+
+  // AnimationDelegateType:
+  void AnimationEnded(const Animation* animation) override {
+    AnimationDelegateType::AnimationEnded(animation);
+    owner_->AnimationEnded(animation);
+  }
+
+  void AnimationProgressed(const Animation* animation) override {
+    AnimationDelegateType::AnimationProgressed(animation);
+    owner_->AnimationProgressed(animation);
+  }
+
+  void AnimationCanceled(const Animation* animation) override {
+    AnimationDelegateType::AnimationCanceled(animation);
+    owner_->AnimationCanceled(animation);
+  }
+
+  void AnimationContainerWasSet(AnimationContainer* container) override {
+    AnimationDelegateType::AnimationContainerWasSet(container);
+    owner_->AnimationContainerWasSet(container);
+  }
+
+ private:
+  gfx::AnimationDelegate* const owner_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_DELEGATE_NOTIFIER_H_
diff --git a/ui/gfx/animation/animation_export.h b/ui/gfx/animation/animation_export.h
new file mode 100644
index 0000000..0b03b1b
--- /dev/null
+++ b/ui/gfx/animation/animation_export.h
@@ -0,0 +1,29 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_EXPORT_H_
+#define UI_GFX_ANIMATION_ANIMATION_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(ANIMATION_IMPLEMENTATION)
+#define ANIMATION_EXPORT __declspec(dllexport)
+#else
+#define ANIMATION_EXPORT __declspec(dllimport)
+#endif  // defined(ANIMATION_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(ANIMATION_IMPLEMENTATION)
+#define ANIMATION_EXPORT __attribute__((visibility("default")))
+#else
+#define ANIMATION_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define ANIMATION_EXPORT
+#endif
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_EXPORT_H_
diff --git a/ui/gfx/animation/animation_linux.cc b/ui/gfx/animation/animation_linux.cc
new file mode 100644
index 0000000..0bcce53
--- /dev/null
+++ b/ui/gfx/animation/animation_linux.cc
@@ -0,0 +1,37 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/animation/animation.h"
+
+#include "ui/gfx/animation/animation_settings_provider_linux.h"
+
+namespace gfx {
+
+namespace {
+
+// GTK only has a global setting for whether animations should be enabled.  So
+// use it for all of the specific settings that Chrome needs.
+bool AnimationsEnabled() {
+  auto* provider = AnimationSettingsProviderLinux::GetInstance();
+  return !provider || provider->AnimationsEnabled();
+}
+
+}  // namespace
+
+// static
+bool Animation::ShouldRenderRichAnimationImpl() {
+  return AnimationsEnabled();
+}
+
+// static
+bool Animation::ScrollAnimationsEnabledBySystem() {
+  return AnimationsEnabled();
+}
+
+// static
+void Animation::UpdatePrefersReducedMotion() {
+  prefers_reduced_motion_ = !AnimationsEnabled();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_mac.mm b/ui/gfx/animation/animation_mac.mm
new file mode 100644
index 0000000..175ceff
--- /dev/null
+++ b/ui/gfx/animation/animation_mac.mm
@@ -0,0 +1,54 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/animation/animation.h"
+
+#import <Cocoa/Cocoa.h>
+
+#include "base/mac/mac_util.h"
+#include "base/task/current_thread.h"
+
+// Only available since 10.12.
+@interface NSWorkspace (AvailableSinceSierra)
+@property(readonly) BOOL accessibilityDisplayShouldReduceMotion;
+@end
+
+namespace gfx {
+
+// static
+bool Animation::ShouldRenderRichAnimationImpl() {
+  return !PrefersReducedMotion();
+}
+
+// static
+bool Animation::ScrollAnimationsEnabledBySystem() {
+  // Because of sandboxing, OS settings should only be queried from the browser
+  // process.
+  DCHECK(base::CurrentUIThread::IsSet() || base::CurrentIOThread::IsSet());
+
+  bool enabled = false;
+  id value = nil;
+  value = [[NSUserDefaults standardUserDefaults]
+      objectForKey:@"NSScrollAnimationEnabled"];
+  if (value)
+    enabled = [value boolValue];
+  return enabled;
+}
+
+// static
+void Animation::UpdatePrefersReducedMotion() {
+  // prefers_reduced_motion_ should only be modified on the UI thread.
+  // TODO(crbug.com/927163): DCHECK this assertion once tests are well-behaved.
+
+  // We default to assuming that animations are enabled, to avoid impacting the
+  // experience for users on pre-10.12 systems.
+  prefers_reduced_motion_ = false;
+  SEL sel = @selector(accessibilityDisplayShouldReduceMotion);
+  if ([[NSWorkspace sharedWorkspace] respondsToSelector:sel]) {
+    prefers_reduced_motion_ =
+        [[NSWorkspace sharedWorkspace] accessibilityDisplayShouldReduceMotion];
+  }
+}
+
+} // namespace gfx
diff --git a/ui/gfx/animation/animation_runner.cc b/ui/gfx/animation/animation_runner.cc
new file mode 100644
index 0000000..eebf9e4
--- /dev/null
+++ b/ui/gfx/animation/animation_runner.cc
@@ -0,0 +1,85 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/animation/animation_runner.h"
+
+#include <utility>
+
+#include "base/timer/timer.h"
+
+namespace {
+
+// A default AnimationRunner based on base::Timer.
+// TODO(https://crbug.com/953585): Remove this altogether.
+class DefaultAnimationRunner : public gfx::AnimationRunner {
+ public:
+  DefaultAnimationRunner() = default;
+  ~DefaultAnimationRunner() override = default;
+
+  // gfx::AnimationRunner:
+  void Stop() override;
+
+ protected:
+  // gfx::AnimationRunner:
+  void OnStart(base::TimeDelta min_interval, base::TimeDelta elapsed) override;
+
+ private:
+  void OnTimerTick();
+
+  base::OneShotTimer timer_;
+  base::TimeDelta min_interval_;
+};
+
+void DefaultAnimationRunner::Stop() {
+  timer_.Stop();
+}
+
+void DefaultAnimationRunner::OnStart(base::TimeDelta min_interval,
+                                     base::TimeDelta elapsed) {
+  min_interval_ = min_interval;
+  timer_.Start(FROM_HERE, min_interval - elapsed, this,
+               &DefaultAnimationRunner::OnTimerTick);
+}
+
+void DefaultAnimationRunner::OnTimerTick() {
+  // This is effectively a RepeatingTimer.  It's possible to use a true
+  // RepeatingTimer for this, but since OnStart() may need to use a OneShotTimer
+  // anyway (when |elapsed| is nonzero), it's just more complicated.
+  timer_.Start(FROM_HERE, min_interval_, this,
+               &DefaultAnimationRunner::OnTimerTick);
+  // Call Step() after timer_.Start() in case Step() calls Stop().
+  Step(base::TimeTicks::Now());
+}
+
+}  // namespace
+
+namespace gfx {
+
+// static
+std::unique_ptr<AnimationRunner>
+AnimationRunner::CreateDefaultAnimationRunner() {
+  return std::make_unique<DefaultAnimationRunner>();
+}
+
+AnimationRunner::~AnimationRunner() = default;
+
+void AnimationRunner::Start(
+    base::TimeDelta min_interval,
+    base::TimeDelta elapsed,
+    base::RepeatingCallback<void(base::TimeTicks)> step) {
+  step_ = std::move(step);
+  OnStart(min_interval, elapsed);
+}
+
+AnimationRunner::AnimationRunner() = default;
+
+void AnimationRunner::Step(base::TimeTicks tick) {
+  step_.Run(tick);
+}
+
+void AnimationRunner::SetAnimationTimeForTesting(base::TimeTicks time) {
+  step_.Run(time);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_runner.h b/ui/gfx/animation/animation_runner.h
new file mode 100644
index 0000000..988bc6c
--- /dev/null
+++ b/ui/gfx/animation/animation_runner.h
@@ -0,0 +1,64 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_RUNNER_H_
+#define UI_GFX_ANIMATION_ANIMATION_RUNNER_H_
+
+#include <memory>
+
+#include "base/callback.h"
+#include "base/time/time.h"
+#include "ui/gfx/animation/animation_export.h"
+
+namespace gfx {
+
+// Interface for custom animation runner. CompositorAnimationRunner can control
+// animation tick with this.
+class ANIMATION_EXPORT AnimationRunner {
+ public:
+  // Creates a default AnimationRunner based on base::Timer. Ideally,
+  // we should prefer the compositor-based animation runner to this.
+  // TODO(https://crbug.com/953585): Remove this altogether.
+  static std::unique_ptr<AnimationRunner> CreateDefaultAnimationRunner();
+
+  AnimationRunner(const AnimationRunner&) = delete;
+  AnimationRunner& operator=(const AnimationRunner&) = delete;
+  virtual ~AnimationRunner();
+
+  // Sets the provided |step| callback, then calls OnStart() with the provided
+  // |min_interval| and |elapsed| time to allow the subclass to actually begin
+  // animating. Subclasses are expected to call Step() periodically to drive the
+  // animation.
+  void Start(base::TimeDelta min_interval,
+             base::TimeDelta elapsed,
+             base::RepeatingCallback<void(base::TimeTicks)> step);
+
+  // Called when subclasses don't need to call Step() anymore.
+  virtual void Stop() = 0;
+
+  bool step_is_null_for_testing() const { return step_.is_null(); }
+
+ protected:
+  AnimationRunner();
+
+  // Called when subclasses should start calling Step() periodically to
+  // drive the animation.
+  virtual void OnStart(base::TimeDelta min_interval,
+                       base::TimeDelta elapsed) = 0;
+
+  // Advances the animation based on |tick|.
+  void Step(base::TimeTicks tick);
+
+ private:
+  friend class AnimationContainerTestApi;
+
+  // Advances the animation manually for testing.
+  void SetAnimationTimeForTesting(base::TimeTicks time);
+
+  base::RepeatingCallback<void(base::TimeTicks)> step_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_RUNNER_H_
diff --git a/ui/gfx/animation/animation_runner_unittest.cc b/ui/gfx/animation/animation_runner_unittest.cc
new file mode 100644
index 0000000..632740e
--- /dev/null
+++ b/ui/gfx/animation/animation_runner_unittest.cc
@@ -0,0 +1,37 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/animation/animation_runner.h"
+
+#include "base/test/bind.h"
+#include "base/test/task_environment.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+namespace {
+
+using AnimationRunnerTest = testing::Test;
+
+// Verifies that calling Stop() during Step() actually stops the timer.
+TEST(AnimationRunnerTest, StopDuringStep) {
+  base::test::TaskEnvironment task_environment(
+      base::test::TaskEnvironment::TimeSource::MOCK_TIME);
+
+  auto runner = AnimationRunner::CreateDefaultAnimationRunner();
+  constexpr auto kDelay = base::Milliseconds(20);
+  int call_count = 0;
+  runner->Start(kDelay, base::TimeDelta(),
+                base::BindLambdaForTesting([&](base::TimeTicks ticks) {
+                  ++call_count;
+                  runner->Stop();
+                }));
+  EXPECT_EQ(0, call_count);
+  task_environment.FastForwardBy(kDelay);
+  EXPECT_EQ(1, call_count);
+  task_environment.FastForwardBy(kDelay);
+  EXPECT_EQ(1, call_count);
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_settings_provider_linux.cc b/ui/gfx/animation/animation_settings_provider_linux.cc
new file mode 100644
index 0000000..e4d4c6c
--- /dev/null
+++ b/ui/gfx/animation/animation_settings_provider_linux.cc
@@ -0,0 +1,30 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/animation/animation_settings_provider_linux.h"
+
+#include "base/check_op.h"
+
+namespace gfx {
+
+// static
+AnimationSettingsProviderLinux* AnimationSettingsProviderLinux::instance_ =
+    nullptr;
+
+// static
+AnimationSettingsProviderLinux* AnimationSettingsProviderLinux::GetInstance() {
+  return instance_;
+}
+
+AnimationSettingsProviderLinux::AnimationSettingsProviderLinux() {
+  DCHECK(!instance_);
+  instance_ = this;
+}
+
+AnimationSettingsProviderLinux::~AnimationSettingsProviderLinux() {
+  DCHECK_EQ(instance_, this);
+  instance_ = nullptr;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_settings_provider_linux.h b/ui/gfx/animation/animation_settings_provider_linux.h
new file mode 100644
index 0000000..0deac36
--- /dev/null
+++ b/ui/gfx/animation/animation_settings_provider_linux.h
@@ -0,0 +1,36 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_SETTINGS_PROVIDER_LINUX_H_
+#define UI_GFX_ANIMATION_ANIMATION_SETTINGS_PROVIDER_LINUX_H_
+
+#include "base/macros.h"
+#include "ui/gfx/animation/animation_export.h"
+
+namespace gfx {
+
+class ANIMATION_EXPORT AnimationSettingsProviderLinux {
+ public:
+  AnimationSettingsProviderLinux(const AnimationSettingsProviderLinux&) =
+      delete;
+  AnimationSettingsProviderLinux& operator=(
+      const AnimationSettingsProviderLinux&) = delete;
+
+  virtual ~AnimationSettingsProviderLinux();
+
+  // Indicates if animations are enabled by the toolkit.
+  virtual bool AnimationsEnabled() const = 0;
+
+  static AnimationSettingsProviderLinux* GetInstance();
+
+ protected:
+  AnimationSettingsProviderLinux();
+
+ private:
+  static AnimationSettingsProviderLinux* instance_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_SETTINGS_PROVIDER_LINUX_H_
diff --git a/ui/gfx/animation/animation_test_api.cc b/ui/gfx/animation/animation_test_api.cc
new file mode 100644
index 0000000..365990c
--- /dev/null
+++ b/ui/gfx/animation/animation_test_api.cc
@@ -0,0 +1,48 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/animation/animation_test_api.h"
+
+#include "base/time/time.h"
+#include "ui/gfx/animation/animation.h"
+
+namespace gfx {
+
+// static
+std::unique_ptr<base::AutoReset<Animation::RichAnimationRenderMode>>
+AnimationTestApi::SetRichAnimationRenderMode(
+    Animation::RichAnimationRenderMode mode) {
+  DCHECK(Animation::rich_animation_rendering_mode_ ==
+         Animation::RichAnimationRenderMode::PLATFORM);
+  return std::make_unique<base::AutoReset<Animation::RichAnimationRenderMode>>(
+      &Animation::rich_animation_rendering_mode_, mode);
+}
+
+AnimationTestApi::AnimationTestApi(Animation* animation)
+    : animation_(animation) {}
+
+AnimationTestApi::~AnimationTestApi() {}
+
+void AnimationTestApi::SetStartTime(base::TimeTicks ticks) {
+  animation_->SetStartTime(ticks);
+}
+
+void AnimationTestApi::Step(base::TimeTicks ticks) {
+  animation_->Step(ticks);
+}
+
+AnimationContainerTestApi::AnimationContainerTestApi(
+    AnimationContainer* container)
+    : container_(container) {
+  container_->runner_->Stop();
+}
+
+AnimationContainerTestApi::~AnimationContainerTestApi() = default;
+
+void AnimationContainerTestApi::IncrementTime(base::TimeDelta delta) {
+  container_->runner_->SetAnimationTimeForTesting(container_->last_tick_time() +
+                                                  delta);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_test_api.h b/ui/gfx/animation/animation_test_api.h
new file mode 100644
index 0000000..0794046
--- /dev/null
+++ b/ui/gfx/animation/animation_test_api.h
@@ -0,0 +1,61 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_ANIMATION_TEST_API_H_
+#define UI_GFX_ANIMATION_ANIMATION_TEST_API_H_
+
+#include <memory>
+
+#include "base/auto_reset.h"
+#include "base/macros.h"
+#include "ui/gfx/animation/animation.h"
+#include "ui/gfx/animation/animation_container.h"
+#include "ui/gfx/animation/animation_export.h"
+
+namespace gfx {
+
+// Class to provide access to Animation internals for testing.
+class AnimationTestApi {
+ public:
+  // Sets the rich animation rendering mode. Allows rich animations to be force
+  // enabled/disabled during tests.
+  static std::unique_ptr<base::AutoReset<Animation::RichAnimationRenderMode>>
+  SetRichAnimationRenderMode(Animation::RichAnimationRenderMode mode);
+
+  explicit AnimationTestApi(Animation* animation);
+
+  AnimationTestApi(const AnimationTestApi&) = delete;
+  AnimationTestApi& operator=(const AnimationTestApi&) = delete;
+
+  ~AnimationTestApi();
+
+  // Sets the start of the animation.
+  void SetStartTime(base::TimeTicks ticks);
+
+  // Manually steps the animation forward
+  void Step(base::TimeTicks ticks);
+
+ private:
+  Animation* animation_;
+};
+
+// For manual animation time control in tests. Creating this object will
+// pause the AnimationRunner of |container| immediately.
+class AnimationContainerTestApi {
+ public:
+  explicit AnimationContainerTestApi(AnimationContainer* container);
+  AnimationContainerTestApi(const AnimationContainerTestApi&) = delete;
+  AnimationContainerTestApi& operator=(const AnimationContainerTestApi&) =
+      delete;
+  ~AnimationContainerTestApi();
+
+  void IncrementTime(base::TimeDelta delta);
+
+ private:
+  AnimationContainer* container_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_ANIMATION_TEST_API_H_
diff --git a/ui/gfx/animation/animation_unittest.cc b/ui/gfx/animation/animation_unittest.cc
new file mode 100644
index 0000000..130390d
--- /dev/null
+++ b/ui/gfx/animation/animation_unittest.cc
@@ -0,0 +1,177 @@
+// Copyright (c) 2011 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.
+
+#include "base/command_line.h"
+#include "base/run_loop.h"
+#include "base/test/task_environment.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/animation/animation_delegate.h"
+#include "ui/gfx/animation/linear_animation.h"
+#include "ui/gfx/animation/test_animation_delegate.h"
+#include "ui/gfx/switches.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
+namespace gfx {
+
+class AnimationTest : public testing::Test {
+ protected:
+  AnimationTest()
+      : task_environment_(
+            base::test::SingleThreadTaskEnvironment::MainThreadType::UI) {}
+
+ private:
+  base::test::SingleThreadTaskEnvironment task_environment_;
+};
+
+namespace {
+
+///////////////////////////////////////////////////////////////////////////////
+// RunAnimation
+
+class RunAnimation : public LinearAnimation {
+ public:
+  RunAnimation(int frame_rate, AnimationDelegate* delegate)
+      : LinearAnimation(delegate, frame_rate) {}
+
+  void AnimateToState(double state) override {
+    EXPECT_LE(0.0, state);
+    EXPECT_GE(1.0, state);
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// CancelAnimation
+
+class CancelAnimation : public LinearAnimation {
+ public:
+  CancelAnimation(base::TimeDelta duration,
+                  int frame_rate,
+                  AnimationDelegate* delegate)
+      : LinearAnimation(duration, frame_rate, delegate) {}
+
+  void AnimateToState(double state) override {
+    if (state >= 0.5)
+      Stop();
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// EndAnimation
+
+class EndAnimation : public LinearAnimation {
+ public:
+  EndAnimation(base::TimeDelta duration,
+               int frame_rate,
+               AnimationDelegate* delegate)
+      : LinearAnimation(duration, frame_rate, delegate) {}
+
+  void AnimateToState(double state) override {
+    if (state >= 0.5)
+      End();
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// DeletingAnimationDelegate
+
+// AnimationDelegate implementation that deletes the animation in ended.
+class DeletingAnimationDelegate : public AnimationDelegate {
+ public:
+  void AnimationEnded(const Animation* animation) override {
+    delete animation;
+    base::RunLoop::QuitCurrentWhenIdleDeprecated();
+  }
+};
+
+}  // namespace
+
+///////////////////////////////////////////////////////////////////////////////
+// LinearCase
+
+TEST_F(AnimationTest, RunCase) {
+  TestAnimationDelegate ad;
+  RunAnimation a1(150, &ad);
+  a1.SetDuration(base::Seconds(2));
+  a1.Start();
+  base::RunLoop().Run();
+
+  EXPECT_TRUE(ad.finished());
+  EXPECT_FALSE(ad.canceled());
+}
+
+TEST_F(AnimationTest, CancelCase) {
+  TestAnimationDelegate ad;
+  CancelAnimation a2(base::Seconds(2), 150, &ad);
+  a2.Start();
+  base::RunLoop().Run();
+
+  EXPECT_TRUE(ad.finished());
+  EXPECT_TRUE(ad.canceled());
+}
+
+// Lets an animation run, invoking End part way through and make sure we get the
+// right delegate methods invoked.
+TEST_F(AnimationTest, EndCase) {
+  TestAnimationDelegate ad;
+  EndAnimation a2(base::Seconds(2), 150, &ad);
+  a2.Start();
+  base::RunLoop().Run();
+
+  EXPECT_TRUE(ad.finished());
+  EXPECT_FALSE(ad.canceled());
+}
+
+// Runs an animation with a delegate that deletes the animation in end.
+TEST_F(AnimationTest, DeleteFromEnd) {
+  DeletingAnimationDelegate delegate;
+  RunAnimation* animation = new RunAnimation(150, &delegate);
+  animation->Start();
+  base::RunLoop().Run();
+  // delegate should have deleted animation.
+}
+
+TEST_F(AnimationTest, ShouldRenderRichAnimation) {
+#if defined(OS_WIN)
+  BOOL result;
+  ASSERT_NE(0,
+            ::SystemParametersInfo(SPI_GETCLIENTAREAANIMATION, 0, &result, 0));
+  // ShouldRenderRichAnimation() should check the SPI_GETCLIENTAREAANIMATION
+  // value on Vista.
+  EXPECT_EQ(!!result, Animation::ShouldRenderRichAnimation());
+#else
+  EXPECT_TRUE(Animation::ShouldRenderRichAnimation());
+#endif
+}
+
+// Test that current value is always 0 after Start() is called.
+TEST_F(AnimationTest, StartState) {
+  LinearAnimation animation(base::Milliseconds(100), 60, NULL);
+  EXPECT_EQ(0.0, animation.GetCurrentValue());
+  animation.Start();
+  EXPECT_EQ(0.0, animation.GetCurrentValue());
+  animation.End();
+  EXPECT_EQ(1.0, animation.GetCurrentValue());
+  animation.Start();
+  EXPECT_EQ(0.0, animation.GetCurrentValue());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PrefersReducedMotion tests
+
+TEST_F(AnimationTest, PrefersReducedMotionRespectsOverrideFlag) {
+  base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kForcePrefersReducedMotion, "1");
+  EXPECT_TRUE(Animation::PrefersReducedMotion());
+
+  // It doesn't matter what the system setting says; the flag should continue to
+  // override it.
+  Animation::SetPrefersReducedMotionForTesting(false);
+  EXPECT_TRUE(Animation::PrefersReducedMotion());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/animation_win.cc b/ui/gfx/animation/animation_win.cc
new file mode 100644
index 0000000..c8fdc6d
--- /dev/null
+++ b/ui/gfx/animation/animation_win.cc
@@ -0,0 +1,40 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/animation/animation.h"
+
+#include <windows.h>
+
+#include "base/win/win_util.h"
+
+namespace gfx {
+
+// static
+bool Animation::ShouldRenderRichAnimationImpl() {
+  BOOL result;
+  // Get "Turn off all unnecessary animations" value.
+  if (::SystemParametersInfo(SPI_GETCLIENTAREAANIMATION, 0, &result, 0)) {
+    return !!result;
+  }
+  return !base::win::IsCurrentSessionRemote();
+}
+
+// static
+bool Animation::ScrollAnimationsEnabledBySystem() {
+  return ShouldRenderRichAnimation();
+}
+
+// static
+void Animation::UpdatePrefersReducedMotion() {
+  // prefers_reduced_motion_ should only be modified on the UI thread.
+  // TODO(crbug.com/927163): DCHECK this assertion once tests are well-behaved.
+
+  // We default to assuming that animations are enabled, to avoid impacting the
+  // experience for users on systems that don't have SPI_GETCLIENTAREAANIMATION.
+  BOOL win_anim_enabled = true;
+  SystemParametersInfo(SPI_GETCLIENTAREAANIMATION, 0, &win_anim_enabled, 0);
+  prefers_reduced_motion_ = !win_anim_enabled;
+}
+
+} // namespace gfx
diff --git a/ui/gfx/animation/keyframe/BUILD.gn b/ui/gfx/animation/keyframe/BUILD.gn
new file mode 100644
index 0000000..85e2bef
--- /dev/null
+++ b/ui/gfx/animation/keyframe/BUILD.gn
@@ -0,0 +1,51 @@
+# Copyright 2021 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.
+
+import("//build/config/ui.gni")
+
+keyframe_animation_remove_configs = []
+keyframe_animation_add_configs = [
+  "//build/config:precompiled_headers",
+  "//build/config/compiler:noshadowing",
+  "//build/config/compiler:wexit_time_destructors",
+]
+
+if (!is_debug) {
+  keyframe_animation_remove_configs +=
+      [ "//build/config/compiler:default_optimization" ]
+  keyframe_animation_add_configs += [ "//build/config/compiler:optimize_max" ]
+}
+
+component("keyframe") {
+  sources = [
+    "animation_curve.cc",
+    "animation_curve.h",
+    "keyframe_animation_export.h",
+    "keyframe_effect.cc",
+    "keyframe_effect.h",
+    "keyframe_model.cc",
+    "keyframe_model.h",
+    "keyframed_animation_curve-inl.h",
+    "keyframed_animation_curve.cc",
+    "keyframed_animation_curve.h",
+    "target_property.h",
+    "timing_function.cc",
+    "timing_function.h",
+    "transition.cc",
+    "transition.h",
+  ]
+
+  defines = [ "GFX_KEYFRAME_ANIMATION_IMPLEMENTATION=1" ]
+
+  deps = [
+    "//base",
+    "//skia",
+    "//ui/gfx/animation",
+    "//ui/gfx/geometry",
+    "//ui/gfx/geometry:geometry_skia",
+  ]
+
+  configs += keyframe_animation_add_configs
+  configs -= keyframe_animation_remove_configs
+}
diff --git a/ui/gfx/animation/keyframe/animation_curve.cc b/ui/gfx/animation/keyframe/animation_curve.cc
new file mode 100644
index 0000000..17fcc23
--- /dev/null
+++ b/ui/gfx/animation/keyframe/animation_curve.cc
@@ -0,0 +1,49 @@
+// Copyright 2012 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.
+
+#include "ui/gfx/animation/keyframe/animation_curve.h"
+
+#include "base/check.h"
+
+namespace gfx {
+
+bool AnimationCurve::PreservesAxisAlignment() const {
+  return true;
+}
+
+bool AnimationCurve::MaximumScale(float* max_scale) const {
+  return false;
+}
+
+base::TimeDelta AnimationCurve::TickInterval() const {
+  return base::TimeDelta();
+}
+
+#define DEFINE_ANIMATION_CURVE(Name, CurveType)                                \
+  void Name##AnimationCurve::Tick(base::TimeDelta t, int property_id,          \
+                                  KeyframeModel* keyframe_model) const {       \
+    if (target_) {                                                             \
+      target_->On##Name##Animated(GetValue(t), property_id, keyframe_model);   \
+    }                                                                          \
+  }                                                                            \
+  int Name##AnimationCurve::Type() const { return AnimationCurve::CurveType; } \
+  const char* Name##AnimationCurve::TypeName() const { return #Name; }         \
+  const Name##AnimationCurve* Name##AnimationCurve::To##Name##AnimationCurve(  \
+      const AnimationCurve* c) {                                               \
+    DCHECK_EQ(AnimationCurve::CurveType, c->Type());                           \
+    return static_cast<const Name##AnimationCurve*>(c);                        \
+  }                                                                            \
+  Name##AnimationCurve* Name##AnimationCurve::To##Name##AnimationCurve(        \
+      AnimationCurve* c) {                                                     \
+    DCHECK_EQ(AnimationCurve::CurveType, c->Type());                           \
+    return static_cast<Name##AnimationCurve*>(c);                              \
+  }
+
+DEFINE_ANIMATION_CURVE(Transform, TRANSFORM)
+DEFINE_ANIMATION_CURVE(Float, FLOAT)
+DEFINE_ANIMATION_CURVE(Size, SIZE)
+DEFINE_ANIMATION_CURVE(Color, COLOR)
+DEFINE_ANIMATION_CURVE(Rect, RECT)
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/animation_curve.h b/ui/gfx/animation/keyframe/animation_curve.h
new file mode 100644
index 0000000..105c53e
--- /dev/null
+++ b/ui/gfx/animation/keyframe/animation_curve.h
@@ -0,0 +1,115 @@
+// Copyright 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_ANIMATION_CURVE_H_
+#define UI_GFX_ANIMATION_KEYFRAME_ANIMATION_CURVE_H_
+
+#include <memory>
+
+#include "base/time/time.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/animation/keyframe/keyframe_animation_export.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/geometry/transform_operations.h"
+
+namespace gfx {
+class TransformOperations;
+class KeyframeModel;
+
+// An animation curve is a function that returns a value given a time.
+class GFX_KEYFRAME_ANIMATION_EXPORT AnimationCurve {
+ public:
+  // TODO(crbug.com/1176334): we shouldn't need the curve type, long term.
+  //
+  // In the meanime, external clients of the animation machinery will have
+  // other curve types and should be added to this enum to ensure uniqueness
+  // (eg, there are serveral cc-specific types here, presently).
+  enum CurveType {
+    COLOR = 0,
+    FLOAT,
+    TRANSFORM,
+    SIZE,
+    RECT,
+
+    // cc:: curve types.
+    FILTER,
+    SCROLL_OFFSET,
+  };
+
+  virtual ~AnimationCurve() = default;
+
+  virtual base::TimeDelta Duration() const = 0;
+  virtual int Type() const = 0;
+  virtual const char* TypeName() const = 0;
+  virtual std::unique_ptr<AnimationCurve> Clone() const = 0;
+  virtual void Tick(base::TimeDelta t,
+                    int property_id,
+                    KeyframeModel* keyframe_model) const = 0;
+
+  // Returns true if this animation preserves axis alignment.
+  virtual bool PreservesAxisAlignment() const;
+
+  // Set |max_scale| to the maximum scale along any dimension during the
+  // animation, of all steps (keyframes) with calculatable scale. Returns
+  // false if none of the steps can calculate a scale.
+  virtual bool MaximumScale(float* max_scale) const;
+
+  // Returns step interval if it's step animation. Returns 0 otherwise.
+  virtual base::TimeDelta TickInterval() const;
+};
+
+#define DECLARE_ANIMATION_CURVE_BODY(T, Name)                                \
+ public:                                                                     \
+  static const Name##AnimationCurve* To##Name##AnimationCurve(               \
+      const AnimationCurve* c);                                              \
+  static Name##AnimationCurve* To##Name##AnimationCurve(AnimationCurve* c);  \
+  class Target {                                                             \
+   public:                                                                   \
+    virtual ~Target() = default;                                             \
+    virtual void On##Name##Animated(const T& value,                          \
+                                    int target_property_id,                  \
+                                    gfx::KeyframeModel* keyframe_model) = 0; \
+  };                                                                         \
+  ~Name##AnimationCurve() override = default;                                \
+  virtual T GetValue(base::TimeDelta t) const = 0;                           \
+  void Tick(base::TimeDelta t, int property_id,                              \
+            gfx::KeyframeModel* keyframe_model) const override;              \
+  void set_target(Target* target) { target_ = target; }                      \
+  int Type() const override;                                                 \
+  const char* TypeName() const override;                                     \
+                                                                             \
+ protected:                                                                  \
+  Target* target() const { return target_; }                                 \
+                                                                             \
+ private:                                                                    \
+  Target* target_ = nullptr;
+
+class GFX_KEYFRAME_ANIMATION_EXPORT ColorAnimationCurve
+    : public AnimationCurve {
+  DECLARE_ANIMATION_CURVE_BODY(SkColor, Color)
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT FloatAnimationCurve
+    : public AnimationCurve {
+  DECLARE_ANIMATION_CURVE_BODY(float, Float)
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT SizeAnimationCurve : public AnimationCurve {
+  DECLARE_ANIMATION_CURVE_BODY(gfx::SizeF, Size)
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT TransformAnimationCurve
+    : public AnimationCurve {
+  DECLARE_ANIMATION_CURVE_BODY(gfx::TransformOperations, Transform)
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT RectAnimationCurve : public AnimationCurve {
+  DECLARE_ANIMATION_CURVE_BODY(gfx::Rect, Rect)
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_ANIMATION_CURVE_H_
diff --git a/ui/gfx/animation/keyframe/keyframe_animation_export.h b/ui/gfx/animation/keyframe/keyframe_animation_export.h
new file mode 100644
index 0000000..db0f21e
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframe_animation_export.h
@@ -0,0 +1,29 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_ANIMATION_EXPORT_H_
+#define UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_ANIMATION_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_KEYFRAME_ANIMATION_IMPLEMENTATION)
+#define GFX_KEYFRAME_ANIMATION_EXPORT __declspec(dllexport)
+#else
+#define GFX_KEYFRAME_ANIMATION_EXPORT __declspec(dllimport)
+#endif  // defined(CC_ANIMATION_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_KEYFRAME_ANIMATION_IMPLEMENTATION)
+#define GFX_KEYFRAME_ANIMATION_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_KEYFRAME_ANIMATION_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_KEYFRAME_ANIMATION_EXPORT
+#endif
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_ANIMATION_EXPORT_H_
diff --git a/ui/gfx/animation/keyframe/keyframe_animation_unittest.cc b/ui/gfx/animation/keyframe/keyframe_animation_unittest.cc
new file mode 100644
index 0000000..90158df
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframe_animation_unittest.cc
@@ -0,0 +1,922 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/animation/keyframe/keyframe_effect.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/animation/keyframe/animation_curve.h"
+#include "ui/gfx/animation/keyframe/keyframed_animation_curve.h"
+#include "ui/gfx/animation/keyframe/test/animation_utils.h"
+#include "ui/gfx/geometry/test/size_test_util.h"
+#include "ui/gfx/test/gfx_util.h"
+
+namespace gfx {
+
+static constexpr float kNoise = 1e-6f;
+static constexpr float kEpsilon = 1e-5f;
+
+// Tests client-specific property ids.
+static constexpr int kLayoutOffsetPropertyId = 19;
+static constexpr int kBackgroundColorPropertyId = 20;
+static constexpr int kOpacityPropertyId = 21;
+static constexpr int kBoundsPropertyId = 22;
+static constexpr int kTransformPropertyId = 23;
+static constexpr int kRectPropertyId = 24;
+
+class TestAnimationTarget : public SizeAnimationCurve::Target,
+                            public TransformAnimationCurve::Target,
+                            public FloatAnimationCurve::Target,
+                            public ColorAnimationCurve::Target,
+                            public RectAnimationCurve::Target {
+ public:
+  TestAnimationTarget() {
+    layout_offset_.AppendTranslate(0, 0, 0);
+    operations_.AppendTranslate(0, 0, 0);
+    operations_.AppendRotate(1, 0, 0, 0);
+    operations_.AppendScale(1, 1, 1);
+  }
+
+  const SizeF& size() const { return size_; }
+  const TransformOperations& operations() const { return operations_; }
+  const TransformOperations& layout_offset() const { return layout_offset_; }
+  float opacity() const { return opacity_; }
+  SkColor background_color() const { return background_color_; }
+  Rect rect() const { return rect_; }
+
+  void OnSizeAnimated(const SizeF& size,
+                      int target_property_id,
+                      KeyframeModel* keyframe_model) override {
+    size_ = size;
+  }
+
+  void OnTransformAnimated(const TransformOperations& operations,
+                           int target_property_id,
+                           KeyframeModel* keyframe_model) override {
+    if (target_property_id == kLayoutOffsetPropertyId) {
+      layout_offset_ = operations;
+    } else {
+      operations_ = operations;
+    }
+  }
+
+  void OnFloatAnimated(const float& opacity,
+                       int target_property_id,
+                       KeyframeModel* keyframe_model) override {
+    opacity_ = opacity;
+  }
+
+  void OnColorAnimated(const SkColor& color,
+                       int target_property_id,
+                       KeyframeModel* keyframe_model) override {
+    background_color_ = color;
+  }
+
+  void OnRectAnimated(const Rect& rect,
+                      int target_property_id,
+                      KeyframeModel* keyframe_model) override {
+    rect_ = rect;
+  }
+
+ private:
+  TransformOperations layout_offset_;
+  TransformOperations operations_;
+  SizeF size_ = {10.0f, 10.0f};
+  float opacity_ = 1.0f;
+  SkColor background_color_ = SK_ColorRED;
+  Rect rect_;
+};
+
+TEST(KeyframeAnimationTest, AddRemoveKeyframeModels) {
+  KeyframeEffect animator;
+  EXPECT_TRUE(animator.keyframe_models().empty());
+  TestAnimationTarget target;
+
+  animator.AddKeyframeModel(CreateSizeAnimation(&target, 1, kBoundsPropertyId,
+                                                SizeF(10, 100), SizeF(20, 200),
+                                                MicrosecondsToDelta(10000)));
+  EXPECT_EQ(1ul, animator.keyframe_models().size());
+  EXPECT_EQ(kBoundsPropertyId, animator.keyframe_models()[0]->TargetProperty());
+
+  TransformOperations from_operations;
+  from_operations.AppendTranslate(10, 100, 1000);
+  TransformOperations to_operations;
+  to_operations.AppendTranslate(20, 200, 2000);
+  animator.AddKeyframeModel(CreateTransformAnimation(
+      &target, 2, kTransformPropertyId, from_operations, to_operations,
+      MicrosecondsToDelta(10000)));
+
+  EXPECT_EQ(2ul, animator.keyframe_models().size());
+  EXPECT_EQ(kTransformPropertyId,
+            animator.keyframe_models()[1]->TargetProperty());
+
+  animator.AddKeyframeModel(CreateTransformAnimation(
+      &target, 3, kTransformPropertyId, from_operations, to_operations,
+      MicrosecondsToDelta(10000)));
+  EXPECT_EQ(3ul, animator.keyframe_models().size());
+  EXPECT_EQ(kTransformPropertyId,
+            animator.keyframe_models()[2]->TargetProperty());
+
+  animator.RemoveKeyframeModels(kTransformPropertyId);
+  EXPECT_EQ(1ul, animator.keyframe_models().size());
+  EXPECT_EQ(kBoundsPropertyId, animator.keyframe_models()[0]->TargetProperty());
+
+  animator.RemoveKeyframeModel(animator.keyframe_models()[0]->id());
+  EXPECT_TRUE(animator.keyframe_models().empty());
+}
+
+TEST(KeyframeAnimationTest, AnimationLifecycle) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+
+  animator.AddKeyframeModel(CreateSizeAnimation(&target, 1, kBoundsPropertyId,
+                                                SizeF(10, 100), SizeF(20, 200),
+                                                MicrosecondsToDelta(10000)));
+  EXPECT_EQ(1ul, animator.keyframe_models().size());
+  EXPECT_EQ(kBoundsPropertyId, animator.keyframe_models()[0]->TargetProperty());
+  EXPECT_EQ(KeyframeModel::WAITING_FOR_TARGET_AVAILABILITY,
+            animator.keyframe_models()[0]->run_state());
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1);
+  animator.Tick(start_time);
+  EXPECT_EQ(KeyframeModel::RUNNING, animator.keyframe_models()[0]->run_state());
+
+  EXPECT_SIZEF_EQ(SizeF(10, 100), target.size());
+
+  // Tick beyond the animation
+  animator.Tick(start_time + MicrosecondsToDelta(20000));
+
+  EXPECT_TRUE(animator.keyframe_models().empty());
+
+  // Should have assumed the final value.
+  EXPECT_SIZEF_EQ(SizeF(20, 200), target.size());
+}
+
+TEST(KeyframeAnimationTest, AnimationQueue) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+
+  animator.AddKeyframeModel(CreateSizeAnimation(&target, 1, kBoundsPropertyId,
+                                                SizeF(10, 100), SizeF(20, 200),
+                                                MicrosecondsToDelta(10000)));
+  EXPECT_EQ(1ul, animator.keyframe_models().size());
+  EXPECT_EQ(kBoundsPropertyId, animator.keyframe_models()[0]->TargetProperty());
+  EXPECT_EQ(KeyframeModel::WAITING_FOR_TARGET_AVAILABILITY,
+            animator.keyframe_models()[0]->run_state());
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1);
+  animator.Tick(start_time);
+  EXPECT_EQ(KeyframeModel::RUNNING, animator.keyframe_models()[0]->run_state());
+  EXPECT_SIZEF_EQ(SizeF(10, 100), target.size());
+
+  animator.AddKeyframeModel(CreateSizeAnimation(&target, 2, kBoundsPropertyId,
+                                                SizeF(10, 100), SizeF(20, 200),
+                                                MicrosecondsToDelta(10000)));
+
+  TransformOperations from_operations;
+  from_operations.AppendTranslate(10, 100, 1000);
+  TransformOperations to_operations;
+  to_operations.AppendTranslate(20, 200, 2000);
+  animator.AddKeyframeModel(CreateTransformAnimation(
+      &target, 3, kTransformPropertyId, from_operations, to_operations,
+      MicrosecondsToDelta(10000)));
+
+  EXPECT_EQ(3ul, animator.keyframe_models().size());
+  EXPECT_EQ(kBoundsPropertyId, animator.keyframe_models()[1]->TargetProperty());
+  EXPECT_EQ(kTransformPropertyId,
+            animator.keyframe_models()[2]->TargetProperty());
+  int id1 = animator.keyframe_models()[1]->id();
+
+  animator.Tick(start_time + MicrosecondsToDelta(1));
+
+  // Only the transform animation should have started (since there's no
+  // conflicting animation).
+  EXPECT_EQ(KeyframeModel::WAITING_FOR_TARGET_AVAILABILITY,
+            animator.keyframe_models()[1]->run_state());
+  EXPECT_EQ(KeyframeModel::RUNNING, animator.keyframe_models()[2]->run_state());
+
+  // Tick beyond the first animator. This should cause it (and the transform
+  // animation) to get removed and for the second bounds animation to start.
+  animator.Tick(start_time + MicrosecondsToDelta(15000));
+
+  EXPECT_EQ(1ul, animator.keyframe_models().size());
+  EXPECT_EQ(KeyframeModel::RUNNING, animator.keyframe_models()[0]->run_state());
+  EXPECT_EQ(id1, animator.keyframe_models()[0]->id());
+
+  // Tick beyond all animations. There should be none remaining.
+  animator.Tick(start_time + MicrosecondsToDelta(30000));
+  EXPECT_TRUE(animator.keyframe_models().empty());
+}
+
+TEST(KeyframeAnimationTest, FinishedTransition) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kOpacityPropertyId};
+  transition.duration = MsToDelta(10);
+  animator.set_transition(transition);
+
+  base::TimeTicks start_time = MsToTicks(1000);
+  animator.Tick(start_time);
+
+  float from = 1.0f;
+  float to = 0.0f;
+  animator.TransitionFloatTo(&target, start_time, kOpacityPropertyId, from, to);
+
+  animator.Tick(start_time);
+  EXPECT_EQ(from, target.opacity());
+
+  // We now simulate a long pause where the element hasn't been ticked (eg, it
+  // may have been hidden). If this happens, the unticked transition must still
+  // be treated as having finished.
+  animator.TransitionFloatTo(&target, start_time + MsToDelta(1000),
+                             kOpacityPropertyId, target.opacity(), 1.0f);
+
+  animator.Tick(start_time + MsToDelta(1000));
+  EXPECT_EQ(to, target.opacity());
+}
+
+TEST(KeyframeAnimationTest, OpacityTransitions) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kOpacityPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  float from = 1.0f;
+  float to = 0.5f;
+  animator.TransitionFloatTo(&target, start_time, kOpacityPropertyId, from, to);
+
+  EXPECT_EQ(from, target.opacity());
+  animator.Tick(start_time);
+
+  // Scheduling a redundant, approximately equal transition should be ignored.
+  int keyframe_model_id = animator.keyframe_models().front()->id();
+  float nearby = to + kNoise;
+  animator.TransitionFloatTo(&target, start_time, kOpacityPropertyId, from,
+                             nearby);
+  EXPECT_EQ(keyframe_model_id, animator.keyframe_models().front()->id());
+
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_GT(from, target.opacity());
+  EXPECT_LT(to, target.opacity());
+
+  animator.Tick(start_time + MicrosecondsToDelta(10000));
+  EXPECT_EQ(to, target.opacity());
+}
+
+TEST(KeyframeAnimationTest, ReversedOpacityTransitions) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kOpacityPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  float from = 1.0f;
+  float to = 0.5f;
+  animator.TransitionFloatTo(&target, start_time, kOpacityPropertyId, from, to);
+
+  EXPECT_EQ(from, target.opacity());
+  animator.Tick(start_time);
+
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  float value_before_reversing = target.opacity();
+  EXPECT_GT(from, value_before_reversing);
+  EXPECT_LT(to, value_before_reversing);
+
+  animator.TransitionFloatTo(&target, start_time + MicrosecondsToDelta(1000),
+                             kOpacityPropertyId, target.opacity(), from);
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  EXPECT_FLOAT_EQ(value_before_reversing, target.opacity());
+
+  animator.Tick(start_time + MicrosecondsToDelta(2000));
+  EXPECT_EQ(from, target.opacity());
+}
+
+TEST(KeyframeAnimationTest, RetargetOpacityTransition) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      gfx::KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 1.0f, nullptr));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(MicrosecondsToDelta(10000), 0.0f, nullptr));
+  curve->set_target(&target);
+  animator.AddKeyframeModel(KeyframeModel::Create(
+      std::move(curve), KeyframeEffect::GetNextKeyframeModelId(),
+      kOpacityPropertyId));
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+  EXPECT_EQ(1.f, target.opacity());
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_FLOAT_EQ(0.5f, target.opacity());
+
+  animator.GetKeyframeModel(kOpacityPropertyId)
+      ->Retarget(start_time + MicrosecondsToDelta(5000), kOpacityPropertyId,
+                 1.f);
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_FLOAT_EQ(0.5f, target.opacity());
+
+  animator.Tick(start_time + MicrosecondsToDelta(7500));
+  EXPECT_FLOAT_EQ(0.75f, target.opacity());
+}
+
+TEST(KeyframeAnimationTest, RetargetTransitionBeforeLastKeyframe) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      gfx::KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 1.0f, nullptr));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(MicrosecondsToDelta(5000), 0.5f, nullptr));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(MicrosecondsToDelta(10000), 0.0f, nullptr));
+  curve->set_target(&target);
+  animator.AddKeyframeModel(KeyframeModel::Create(
+      std::move(curve), KeyframeEffect::GetNextKeyframeModelId(),
+      kOpacityPropertyId));
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+  EXPECT_EQ(1.f, target.opacity());
+
+  animator.GetKeyframeModel(kOpacityPropertyId)
+      ->Retarget(start_time + MicrosecondsToDelta(4000), kOpacityPropertyId,
+                 0.1f);
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_FLOAT_EQ(0.5f, target.opacity());
+
+  animator.Tick(start_time + MicrosecondsToDelta(7500));
+  EXPECT_FLOAT_EQ(0.3f, target.opacity());
+}
+
+TEST(KeyframeAnimationTest, LayoutOffsetTransitions) {
+  // In this test, we do expect exact equality.
+  float tolerance = 0.0f;
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kLayoutOffsetPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  TransformOperations from = target.layout_offset();
+
+  TransformOperations to;
+  to.AppendTranslate(8, 0, 0);
+
+  animator.TransitionTransformOperationsTo(&target, start_time,
+                                           kLayoutOffsetPropertyId, from, to);
+
+  EXPECT_TRUE(from.ApproximatelyEqual(target.layout_offset(), tolerance));
+  animator.Tick(start_time);
+
+  // Scheduling a redundant, approximately equal transition should be ignored.
+  int keyframe_model_id = animator.keyframe_models().front()->id();
+  TransformOperations nearby = to;
+  nearby.at(0).translate.x += kNoise;
+  animator.TransitionTransformOperationsTo(
+      &target, start_time, kLayoutOffsetPropertyId, from, nearby);
+  EXPECT_EQ(keyframe_model_id, animator.keyframe_models().front()->id());
+
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_LT(from.at(0).translate.x, target.layout_offset().at(0).translate.x);
+  EXPECT_GT(to.at(0).translate.x, target.layout_offset().at(0).translate.x);
+
+  animator.Tick(start_time + MicrosecondsToDelta(10000));
+  EXPECT_TRUE(to.ApproximatelyEqual(target.layout_offset(), tolerance));
+}
+
+TEST(KeyframeAnimationTest, TransformTransitions) {
+  // In this test, we do expect exact equality.
+  float tolerance = 0.0f;
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kTransformPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  TransformOperations from = target.operations();
+
+  TransformOperations to;
+  to.AppendTranslate(8, 0, 0);
+  to.AppendRotate(1, 0, 0, 0);
+  to.AppendScale(1, 1, 1);
+
+  animator.TransitionTransformOperationsTo(&target, start_time,
+                                           kTransformPropertyId, from, to);
+
+  EXPECT_TRUE(from.ApproximatelyEqual(target.operations(), tolerance));
+  animator.Tick(start_time);
+
+  // Scheduling a redundant, approximately equal transition should be ignored.
+  int keyframe_model_id = animator.keyframe_models().front()->id();
+  TransformOperations nearby = to;
+  nearby.at(0).translate.x += kNoise;
+  animator.TransitionTransformOperationsTo(&target, start_time,
+                                           kTransformPropertyId, from, nearby);
+  EXPECT_EQ(keyframe_model_id, animator.keyframe_models().front()->id());
+
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_LT(from.at(0).translate.x, target.operations().at(0).translate.x);
+  EXPECT_GT(to.at(0).translate.x, target.operations().at(0).translate.x);
+
+  animator.Tick(start_time + MicrosecondsToDelta(10000));
+  EXPECT_TRUE(to.ApproximatelyEqual(target.operations(), tolerance));
+}
+
+TEST(KeyframeAnimationTest, ReversedTransformTransitions) {
+  // In this test, we do expect exact equality.
+  float tolerance = 0.0f;
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kTransformPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  TransformOperations from = target.operations();
+
+  TransformOperations to;
+  to.AppendTranslate(8, 0, 0);
+  to.AppendRotate(1, 0, 0, 0);
+  to.AppendScale(1, 1, 1);
+
+  animator.TransitionTransformOperationsTo(&target, start_time,
+                                           kTransformPropertyId, from, to);
+
+  EXPECT_TRUE(from.ApproximatelyEqual(target.operations(), tolerance));
+  animator.Tick(start_time);
+
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  TransformOperations value_before_reversing = target.operations();
+  EXPECT_LT(from.at(0).translate.x, target.operations().at(0).translate.x);
+  EXPECT_GT(to.at(0).translate.x, target.operations().at(0).translate.x);
+
+  animator.TransitionTransformOperationsTo(
+      &target, start_time + MicrosecondsToDelta(1000), kTransformPropertyId,
+      target.operations(), from);
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  EXPECT_TRUE(value_before_reversing.ApproximatelyEqual(target.operations(),
+                                                        tolerance));
+
+  animator.Tick(start_time + MicrosecondsToDelta(2000));
+  EXPECT_TRUE(from.ApproximatelyEqual(target.operations(), tolerance));
+}
+
+TEST(KeyframeAnimationTest, RetargetTransformTransition) {
+  float tolerance = 0.0f;
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+
+  TransformOperations from;
+  from.AppendScale(1, 1, 1);
+  from.AppendTranslate(0, 0, 0);
+  TransformOperations to;
+  to.AppendScale(11, 11, 11);
+  to.AppendTranslate(-10, -10, -10);
+
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      gfx::KeyframedTransformAnimationCurve::Create());
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), from, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(MicrosecondsToDelta(10000), to, nullptr));
+  curve->set_target(&target);
+  animator.AddKeyframeModel(KeyframeModel::Create(
+      std::move(curve), KeyframeEffect::GetNextKeyframeModelId(),
+      kTransformPropertyId));
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+  EXPECT_TRUE(from.ApproximatelyEqual(target.operations(), tolerance));
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+
+  EXPECT_FLOAT_EQ(6.f, target.operations().at(0).scale.x);
+  EXPECT_FLOAT_EQ(-5.f, target.operations().at(1).translate.x);
+
+  TransformOperations new_to;
+  new_to.AppendScale(110, 110, 110);
+  new_to.AppendTranslate(-101, -101, -101);
+
+  animator.GetKeyframeModel(kTransformPropertyId)
+      ->Retarget(start_time + MicrosecondsToDelta(5000), kTransformPropertyId,
+                 new_to);
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_FLOAT_EQ(6.f, target.operations().at(0).scale.x);
+  EXPECT_FLOAT_EQ(-5.f, target.operations().at(1).translate.x);
+
+  animator.Tick(start_time + MicrosecondsToDelta(7500));
+  EXPECT_FLOAT_EQ(58.f, target.operations().at(0).scale.x);
+  EXPECT_FLOAT_EQ(-53.f, target.operations().at(1).translate.x);
+}
+
+TEST(KeyframeAnimationTest, BoundsTransitions) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kBoundsPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  SizeF from = target.size();
+  SizeF to(20.0f, 20.0f);
+
+  animator.TransitionSizeTo(&target, start_time, kBoundsPropertyId, from, to);
+
+  EXPECT_FLOAT_SIZE_EQ(from, target.size());
+  animator.Tick(start_time);
+
+  // Scheduling a redundant, approximately equal transition should be ignored.
+  int keyframe_model_id = animator.keyframe_models().front()->id();
+  SizeF nearby = to;
+  nearby.set_width(to.width() + kNoise);
+  animator.TransitionSizeTo(&target, start_time, kBoundsPropertyId, from,
+                            nearby);
+  EXPECT_EQ(keyframe_model_id, animator.keyframe_models().front()->id());
+
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_LT(from.width(), target.size().width());
+  EXPECT_GT(to.width(), target.size().width());
+  EXPECT_LT(from.height(), target.size().height());
+  EXPECT_GT(to.height(), target.size().height());
+
+  animator.Tick(start_time + MicrosecondsToDelta(10000));
+  EXPECT_FLOAT_SIZE_EQ(to, target.size());
+}
+
+TEST(KeyframeAnimationTest, RetargetSizeTransition) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+
+  SizeF from(1, 2);
+  SizeF to(11, 22);
+
+  std::unique_ptr<KeyframedSizeAnimationCurve> curve(
+      gfx::KeyframedSizeAnimationCurve::Create());
+  curve->AddKeyframe(SizeKeyframe::Create(base::TimeDelta(), from, nullptr));
+  curve->AddKeyframe(
+      SizeKeyframe::Create(MicrosecondsToDelta(10000), to, nullptr));
+  curve->set_target(&target);
+  animator.AddKeyframeModel(KeyframeModel::Create(
+      std::move(curve), KeyframeEffect::GetNextKeyframeModelId(),
+      kBoundsPropertyId));
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+  EXPECT_EQ(from, target.size());
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+
+  EXPECT_FLOAT_SIZE_EQ(SizeF(6, 12), target.size());
+
+  SizeF new_to(600, 1200);
+
+  animator.GetKeyframeModel(kBoundsPropertyId)
+      ->Retarget(start_time + MicrosecondsToDelta(5000), kRectPropertyId,
+                 new_to);
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_FLOAT_SIZE_EQ(SizeF(6, 12), target.size());
+
+  animator.Tick(start_time + MicrosecondsToDelta(7500));
+  EXPECT_FLOAT_SIZE_EQ(SizeF(303, 606), target.size());
+}
+
+TEST(KeyframeAnimationTest, ReversedBoundsTransitions) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kBoundsPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  SizeF from = target.size();
+  SizeF to(20.0f, 20.0f);
+
+  animator.TransitionSizeTo(&target, start_time, kBoundsPropertyId, from, to);
+
+  EXPECT_FLOAT_SIZE_EQ(from, target.size());
+  animator.Tick(start_time);
+
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  SizeF value_before_reversing = target.size();
+  EXPECT_LT(from.width(), target.size().width());
+  EXPECT_GT(to.width(), target.size().width());
+  EXPECT_LT(from.height(), target.size().height());
+  EXPECT_GT(to.height(), target.size().height());
+
+  animator.TransitionSizeTo(&target, start_time + MicrosecondsToDelta(1000),
+                            kBoundsPropertyId, target.size(), from);
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  EXPECT_FLOAT_SIZE_EQ(value_before_reversing, target.size());
+
+  animator.Tick(start_time + MicrosecondsToDelta(2000));
+  EXPECT_FLOAT_SIZE_EQ(from, target.size());
+}
+
+TEST(KeyframeAnimationTest, BackgroundColorTransitions) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kBackgroundColorPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  SkColor from = SK_ColorRED;
+  SkColor to = SK_ColorGREEN;
+
+  animator.TransitionColorTo(&target, start_time, kBackgroundColorPropertyId,
+                             from, to);
+
+  EXPECT_EQ(from, target.background_color());
+  animator.Tick(start_time);
+
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_GT(SkColorGetR(from), SkColorGetR(target.background_color()));
+  EXPECT_LT(SkColorGetR(to), SkColorGetR(target.background_color()));
+  EXPECT_LT(SkColorGetG(from), SkColorGetG(target.background_color()));
+  EXPECT_GT(SkColorGetG(to), SkColorGetG(target.background_color()));
+  EXPECT_EQ(0u, SkColorGetB(target.background_color()));
+  EXPECT_EQ(255u, SkColorGetA(target.background_color()));
+
+  animator.Tick(start_time + MicrosecondsToDelta(10000));
+  EXPECT_EQ(to, target.background_color());
+}
+
+TEST(KeyframeAnimationTest, ReversedBackgroundColorTransitions) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kBackgroundColorPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  SkColor from = SK_ColorRED;
+  SkColor to = SK_ColorGREEN;
+
+  animator.TransitionColorTo(&target, start_time, kBackgroundColorPropertyId,
+                             from, to);
+
+  EXPECT_EQ(from, target.background_color());
+  animator.Tick(start_time);
+
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  SkColor value_before_reversing = target.background_color();
+  EXPECT_GT(SkColorGetR(from), SkColorGetR(target.background_color()));
+  EXPECT_LT(SkColorGetR(to), SkColorGetR(target.background_color()));
+  EXPECT_LT(SkColorGetG(from), SkColorGetG(target.background_color()));
+  EXPECT_GT(SkColorGetG(to), SkColorGetG(target.background_color()));
+  EXPECT_EQ(0u, SkColorGetB(target.background_color()));
+  EXPECT_EQ(255u, SkColorGetA(target.background_color()));
+
+  animator.TransitionColorTo(&target, start_time + MicrosecondsToDelta(1000),
+                             kBackgroundColorPropertyId,
+                             target.background_color(), from);
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  EXPECT_EQ(value_before_reversing, target.background_color());
+
+  animator.Tick(start_time + MicrosecondsToDelta(2000));
+  EXPECT_EQ(from, target.background_color());
+}
+
+TEST(KeyframeAnimationTest, RetargetColorTransition) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+
+  SkColor from = SkColorSetRGB(0, 0, 0);
+  SkColor to = SkColorSetRGB(10, 10, 10);
+
+  std::unique_ptr<KeyframedColorAnimationCurve> curve(
+      gfx::KeyframedColorAnimationCurve::Create());
+  curve->AddKeyframe(ColorKeyframe::Create(base::TimeDelta(), from, nullptr));
+  curve->AddKeyframe(
+      ColorKeyframe::Create(MicrosecondsToDelta(10000), to, nullptr));
+  curve->set_target(&target);
+  animator.AddKeyframeModel(KeyframeModel::Create(
+      std::move(curve), KeyframeEffect::GetNextKeyframeModelId(),
+      kBackgroundColorPropertyId));
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+  EXPECT_EQ(from, target.background_color());
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+
+  EXPECT_EQ(5u, SkColorGetR(target.background_color()));
+
+  SkColor new_to = SkColorSetRGB(101, 101, 101);
+
+  animator.GetKeyframeModel(kBackgroundColorPropertyId)
+      ->Retarget(start_time + MicrosecondsToDelta(5000), kRectPropertyId,
+                 new_to);
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_EQ(5u, SkColorGetR(target.background_color()));
+
+  animator.Tick(start_time + MicrosecondsToDelta(7500));
+  EXPECT_EQ(53u, SkColorGetR(target.background_color()));
+}
+
+TEST(KeyframeAnimationTest, DoubleReversedTransitions) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kOpacityPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  float from = 1.0f;
+  float to = 0.5f;
+  animator.TransitionFloatTo(&target, start_time, kOpacityPropertyId, from, to);
+
+  EXPECT_EQ(from, target.opacity());
+  animator.Tick(start_time);
+
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  float value_before_reversing = target.opacity();
+  EXPECT_GT(from, value_before_reversing);
+  EXPECT_LT(to, value_before_reversing);
+
+  animator.TransitionFloatTo(&target, start_time + MicrosecondsToDelta(1000),
+                             kOpacityPropertyId, target.opacity(), from);
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  EXPECT_FLOAT_EQ(value_before_reversing, target.opacity());
+
+  animator.Tick(start_time + MicrosecondsToDelta(1500));
+  value_before_reversing = target.opacity();
+  // If the code for reversing transitions does not account for an existing time
+  // offset, then reversing a second time will give incorrect values.
+  animator.TransitionFloatTo(&target, start_time + MicrosecondsToDelta(1500),
+                             kOpacityPropertyId, target.opacity(), to);
+  animator.Tick(start_time + MicrosecondsToDelta(1500));
+  EXPECT_FLOAT_EQ(value_before_reversing, target.opacity());
+}
+
+TEST(KeyframeAnimationTest, RedundantTransition) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kOpacityPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  float from = 1.0f;
+  float to = 0.5f;
+  animator.TransitionFloatTo(&target, start_time, kOpacityPropertyId, from, to);
+
+  EXPECT_EQ(from, target.opacity());
+  animator.Tick(start_time);
+
+  animator.Tick(start_time + MicrosecondsToDelta(1000));
+  float value_before_redundant_transition = target.opacity();
+
+  // While an existing transition is in progress to the same value, we should
+  // not start a new transition.
+  animator.TransitionFloatTo(&target, start_time, kOpacityPropertyId,
+                             target.opacity(), to);
+
+  EXPECT_EQ(1lu, animator.keyframe_models().size());
+  EXPECT_EQ(value_before_redundant_transition, target.opacity());
+}
+
+TEST(KeyframeAnimationTest, TransitionToSameValue) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  Transition transition;
+  transition.target_properties = {kOpacityPropertyId};
+  transition.duration = MicrosecondsToDelta(10000);
+  animator.set_transition(transition);
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  // Transitioning to the same value should be a no-op.
+  float from = 1.0f;
+  float to = 1.0f;
+  animator.TransitionFloatTo(&target, start_time, kOpacityPropertyId, from, to);
+  EXPECT_EQ(from, target.opacity());
+  EXPECT_TRUE(animator.keyframe_models().empty());
+}
+
+TEST(KeyframeAnimationTest, CorrectTargetValue) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+  base::TimeDelta duration = MicrosecondsToDelta(10000);
+
+  float from_opacity = 1.0f;
+  float to_opacity = 0.5f;
+  SizeF from_bounds = SizeF(10, 200);
+  SizeF to_bounds = SizeF(20, 200);
+  SkColor from_color = SK_ColorRED;
+  SkColor to_color = SK_ColorGREEN;
+  TransformOperations from_transform;
+  from_transform.AppendTranslate(10, 100, 1000);
+  TransformOperations to_transform;
+  to_transform.AppendTranslate(20, 200, 2000);
+
+  // Verify the default value is returned if there's no running animations.
+  EXPECT_EQ(from_opacity,
+            animator.GetTargetFloatValue(kOpacityPropertyId, from_opacity));
+  EXPECT_SIZEF_EQ(from_bounds,
+                  animator.GetTargetSizeValue(kBoundsPropertyId, from_bounds));
+  EXPECT_EQ(from_color, animator.GetTargetColorValue(kBackgroundColorPropertyId,
+                                                     from_color));
+  EXPECT_TRUE(from_transform.ApproximatelyEqual(
+      animator.GetTargetTransformOperationsValue(kTransformPropertyId,
+                                                 from_transform),
+      kEpsilon));
+
+  // Add keyframe_models.
+  animator.AddKeyframeModel(CreateFloatAnimation(
+      &target, 2, kOpacityPropertyId, from_opacity, to_opacity, duration));
+  animator.AddKeyframeModel(CreateSizeAnimation(
+      &target, 1, kBoundsPropertyId, from_bounds, to_bounds, duration));
+  animator.AddKeyframeModel(CreateColorAnimation(
+      &target, 3, kBackgroundColorPropertyId, from_color, to_color, duration));
+  animator.AddKeyframeModel(
+      CreateTransformAnimation(&target, 4, kTransformPropertyId, from_transform,
+                               to_transform, duration));
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+
+  // Verify target value.
+  EXPECT_EQ(to_opacity,
+            animator.GetTargetFloatValue(kOpacityPropertyId, from_opacity));
+  EXPECT_SIZEF_EQ(to_bounds,
+                  animator.GetTargetSizeValue(kBoundsPropertyId, from_bounds));
+  EXPECT_EQ(to_color, animator.GetTargetColorValue(kBackgroundColorPropertyId,
+                                                   from_color));
+  EXPECT_TRUE(to_transform.ApproximatelyEqual(
+      animator.GetTargetTransformOperationsValue(kTransformPropertyId,
+                                                 from_transform),
+      kEpsilon));
+}
+
+TEST(KeyframeAnimationTest, RetargetRectTransition) {
+  TestAnimationTarget target;
+  KeyframeEffect animator;
+
+  Rect from(1, 2, 3, 4);
+  Rect to(11, 22, 33, 44);
+
+  std::unique_ptr<KeyframedRectAnimationCurve> curve(
+      gfx::KeyframedRectAnimationCurve::Create());
+  curve->AddKeyframe(RectKeyframe::Create(base::TimeDelta(), from, nullptr));
+  curve->AddKeyframe(
+      RectKeyframe::Create(MicrosecondsToDelta(10000), to, nullptr));
+  curve->set_target(&target);
+  animator.AddKeyframeModel(KeyframeModel::Create(
+      std::move(curve), KeyframeEffect::GetNextKeyframeModelId(),
+      kRectPropertyId));
+
+  base::TimeTicks start_time = MicrosecondsToTicks(1000000);
+  animator.Tick(start_time);
+  EXPECT_EQ(from, target.rect());
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+
+  EXPECT_EQ(Rect(6, 12, 18, 24), target.rect());
+
+  Rect new_to(600, 1200, 1800, 2400);
+
+  animator.GetKeyframeModel(kRectPropertyId)
+      ->Retarget(start_time + MicrosecondsToDelta(5000), kRectPropertyId,
+                 new_to);
+  animator.Tick(start_time + MicrosecondsToDelta(5000));
+  EXPECT_EQ(Rect(6, 12, 18, 24), target.rect());
+
+  animator.Tick(start_time + MicrosecondsToDelta(7500));
+  EXPECT_EQ(Rect(303, 606, 909, 1212), target.rect());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/keyframe_effect.cc b/ui/gfx/animation/keyframe/keyframe_effect.cc
new file mode 100644
index 0000000..46304b1
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframe_effect.cc
@@ -0,0 +1,397 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/animation/keyframe/keyframe_effect.h"
+
+#include <algorithm>
+
+#include "base/containers/cxx20_erase.h"
+#include "ui/gfx/animation/keyframe/animation_curve.h"
+#include "ui/gfx/animation/keyframe/keyframed_animation_curve.h"
+
+namespace gfx {
+
+namespace {
+
+static int s_next_keyframe_model_id = 1;
+static int s_next_group_id = 1;
+
+void ReverseKeyframeModel(base::TimeTicks monotonic_time,
+                          KeyframeModel* keyframe_model) {
+  keyframe_model->set_direction(keyframe_model->direction() ==
+                                        KeyframeModel::Direction::NORMAL
+                                    ? KeyframeModel::Direction::REVERSE
+                                    : KeyframeModel::Direction::NORMAL);
+  // Our goal here is to reverse the given keyframe_model. That is, if
+  // we're 20% of the way through the keyframe_model in the forward direction,
+  // we'd like to be 80% of the way of the reversed keyframe model (so it will
+  // end quickly).
+  //
+  // We can modify our "progress" through an animation by modifying the "time
+  // offset", a value added to the current time by the animation system before
+  // applying any other adjustments.
+  //
+  // Let our start time be s, our current time be t, and our final time (or
+  // duration) be d. After reversing the keyframe_model, we would like to start
+  // sampling from d - t as depicted below.
+  //
+  //  Forward:
+  //  s    t                         d
+  //  |----|-------------------------|
+  //
+  //  Reversed:
+  //  s                         t    d
+  //  |----|--------------------|----|
+  //       -----time-offset----->
+  //
+  // Now, if we let o represent our desired offset, we need to ensure that
+  //   t = d - (o + t)
+  //
+  // That is, sampling at the current time in either the forward or reverse
+  // curves must result in the same value, otherwise we'll get jank.
+  //
+  // This implies that,
+  //   0 = d - o - 2t
+  //   o = d - 2t
+  //
+  // Now if there was a previous offset, we must adjust d by that offset before
+  // performing this computation, so it becomes d - o_old - 2t:
+  keyframe_model->set_time_offset(
+      keyframe_model->curve()->Duration() - keyframe_model->time_offset() -
+      (2 * (monotonic_time - keyframe_model->start_time())));
+}
+
+std::unique_ptr<CubicBezierTimingFunction> CreateTransitionTimingFunction() {
+  return CubicBezierTimingFunction::CreatePreset(
+      CubicBezierTimingFunction::EaseType::EASE);
+}
+
+base::TimeDelta GetStartTime(KeyframeModel* keyframe_model) {
+  if (keyframe_model->direction() == KeyframeModel::Direction::NORMAL) {
+    return base::TimeDelta();
+  }
+  return keyframe_model->curve()->Duration();
+}
+
+base::TimeDelta GetEndTime(KeyframeModel* keyframe_model) {
+  if (keyframe_model->direction() == KeyframeModel::Direction::REVERSE) {
+    return base::TimeDelta();
+  }
+  return keyframe_model->curve()->Duration();
+}
+
+template <typename ValueType>
+void TransitionValueTo(KeyframeEffect* animator,
+                       typename AnimationTraits<ValueType>::TargetType* target,
+                       base::TimeTicks monotonic_time,
+                       int target_property,
+                       const ValueType& from,
+                       const ValueType& to) {
+  DCHECK(target);
+
+  if (animator->transition().target_properties.find(target_property) ==
+      animator->transition().target_properties.end()) {
+    AnimationTraits<ValueType>::OnValueAnimated(target, to, target_property);
+    return;
+  }
+
+  KeyframeModel* running_keyframe_model =
+      animator->GetRunningKeyframeModelForProperty(target_property);
+
+  ValueType effective_current = from;
+
+  if (running_keyframe_model) {
+    const auto* curve = AnimationTraits<ValueType>::ToDerivedCurve(
+        running_keyframe_model->curve());
+
+    if (running_keyframe_model->IsFinishedAt(monotonic_time)) {
+      effective_current = curve->GetValue(GetEndTime(running_keyframe_model));
+    } else {
+      if (SufficientlyEqual(
+              to, curve->GetValue(GetEndTime(running_keyframe_model)))) {
+        return;
+      }
+      if (SufficientlyEqual(
+              to, curve->GetValue(GetStartTime(running_keyframe_model)))) {
+        ReverseKeyframeModel(monotonic_time, running_keyframe_model);
+        return;
+      }
+    }
+  } else if (SufficientlyEqual(to, from)) {
+    return;
+  }
+
+  animator->RemoveKeyframeModels(target_property);
+
+  std::unique_ptr<typename AnimationTraits<ValueType>::KeyframedCurveType>
+      curve(AnimationTraits<ValueType>::KeyframedCurveType::Create());
+
+  curve->AddKeyframe(AnimationTraits<ValueType>::KeyframeType::Create(
+      base::TimeDelta(), effective_current, CreateTransitionTimingFunction()));
+
+  curve->AddKeyframe(AnimationTraits<ValueType>::KeyframeType::Create(
+      animator->transition().duration, to, CreateTransitionTimingFunction()));
+
+  curve->set_target(target);
+
+  animator->AddKeyframeModel(KeyframeModel::Create(
+      std::move(curve), KeyframeEffect::GetNextKeyframeModelId(),
+      target_property));
+}
+
+}  // namespace
+
+int KeyframeEffect::GetNextKeyframeModelId() {
+  return s_next_keyframe_model_id++;
+}
+
+int KeyframeEffect::GetNextGroupId() {
+  return s_next_group_id++;
+}
+
+KeyframeEffect::KeyframeEffect() = default;
+KeyframeEffect::KeyframeEffect(KeyframeEffect&&) = default;
+KeyframeEffect::~KeyframeEffect() = default;
+
+void KeyframeEffect::AddKeyframeModel(
+    std::unique_ptr<KeyframeModel> keyframe_model) {
+  keyframe_models_.push_back(std::move(keyframe_model));
+}
+
+void KeyframeEffect::RemoveKeyframeModel(int keyframe_model_id) {
+  // Since we want to use the KeyframeModels that we're going to remove, we
+  // need to use a stable_partition here instead of remove_if. remove_if leaves
+  // the removed items in an unspecified state.
+  auto keyframe_models_to_remove = std::stable_partition(
+      keyframe_models_.begin(), keyframe_models_.end(),
+      [keyframe_model_id](
+          const std::unique_ptr<gfx::KeyframeModel>& keyframe_model) {
+        return keyframe_model->id() != keyframe_model_id;
+      });
+
+  RemoveKeyframeModelRange(keyframe_models_to_remove, keyframe_models_.end());
+}
+
+void KeyframeEffect::RemoveKeyframeModels(int target_property) {
+  auto keyframe_models_to_remove = std::stable_partition(
+      keyframe_models_.begin(), keyframe_models_.end(),
+      [target_property](
+          const std::unique_ptr<gfx::KeyframeModel>& keyframe_model) {
+        return keyframe_model->TargetProperty() != target_property;
+      });
+  RemoveKeyframeModelRange(keyframe_models_to_remove, keyframe_models_.end());
+}
+
+void KeyframeEffect::RemoveAllKeyframeModels() {
+  RemoveKeyframeModelRange(keyframe_models_.begin(), keyframe_models_.end());
+}
+
+void KeyframeEffect::Tick(base::TimeTicks monotonic_time) {
+  TickInternal(monotonic_time, true);
+}
+
+void KeyframeEffect::RemoveKeyframeModelRange(
+    typename KeyframeModels::iterator to_remove_begin,
+    typename KeyframeModels::iterator to_remove_end) {
+  keyframe_models_.erase(to_remove_begin, to_remove_end);
+}
+
+void KeyframeEffect::TickKeyframeModel(base::TimeTicks monotonic_time,
+                                       KeyframeModel* keyframe_model) {
+  if ((keyframe_model->run_state() != KeyframeModel::STARTING &&
+       keyframe_model->run_state() != KeyframeModel::RUNNING &&
+       keyframe_model->run_state() != KeyframeModel::PAUSED) ||
+      !keyframe_model->HasActiveTime(monotonic_time)) {
+    return;
+  }
+
+  AnimationCurve* curve = keyframe_model->curve();
+  base::TimeDelta trimmed =
+      keyframe_model->TrimTimeToCurrentIteration(monotonic_time);
+  curve->Tick(trimmed, keyframe_model->TargetProperty(), keyframe_model);
+}
+
+void KeyframeEffect::TickInternal(base::TimeTicks monotonic_time,
+                                  bool include_infinite_animations) {
+  StartKeyframeModels(monotonic_time, include_infinite_animations);
+
+  for (auto& keyframe_model : keyframe_models_) {
+    if (!include_infinite_animations &&
+        keyframe_model->iterations() == std::numeric_limits<double>::infinity())
+      continue;
+    TickKeyframeModel(monotonic_time, keyframe_model.get());
+  }
+
+  // Remove finished keyframe_models.
+  base::EraseIf(
+      keyframe_models_,
+      [monotonic_time](const std::unique_ptr<KeyframeModel>& keyframe_model) {
+        return !keyframe_model->is_finished() &&
+               keyframe_model->IsFinishedAt(monotonic_time);
+      });
+
+  StartKeyframeModels(monotonic_time, include_infinite_animations);
+}
+
+void KeyframeEffect::FinishAll() {
+  base::TimeTicks now = base::TimeTicks::Now();
+  const bool include_infinite_animations = false;
+  TickInternal(now, include_infinite_animations);
+  TickInternal(base::TimeTicks::Max(), include_infinite_animations);
+#ifndef NDEBUG
+  for (auto& keyframe_model : keyframe_models_) {
+    DCHECK_EQ(std::numeric_limits<double>::infinity(),
+              keyframe_model->iterations());
+  }
+#endif
+}
+
+void KeyframeEffect::SetTransitionedProperties(
+    const std::set<int>& properties) {
+  transition_.target_properties = properties;
+}
+
+void KeyframeEffect::SetTransitionDuration(base::TimeDelta delta) {
+  transition_.duration = delta;
+}
+
+void KeyframeEffect::TransitionFloatTo(FloatAnimationCurve::Target* target,
+                                       base::TimeTicks monotonic_time,
+                                       int target_property,
+                                       float from,
+                                       float to) {
+  TransitionValueTo<float>(this, target, monotonic_time, target_property, from,
+                           to);
+}
+
+void KeyframeEffect::TransitionTransformOperationsTo(
+    TransformAnimationCurve::Target* target,
+    base::TimeTicks monotonic_time,
+    int target_property,
+    const gfx::TransformOperations& from,
+    const gfx::TransformOperations& to) {
+  TransitionValueTo<gfx::TransformOperations>(this, target, monotonic_time,
+                                              target_property, from, to);
+}
+
+void KeyframeEffect::TransitionSizeTo(SizeAnimationCurve::Target* target,
+                                      base::TimeTicks monotonic_time,
+                                      int target_property,
+                                      const gfx::SizeF& from,
+                                      const gfx::SizeF& to) {
+  TransitionValueTo<gfx::SizeF>(this, target, monotonic_time, target_property,
+                                from, to);
+}
+
+void KeyframeEffect::TransitionColorTo(ColorAnimationCurve::Target* target,
+                                       base::TimeTicks monotonic_time,
+                                       int target_property,
+                                       SkColor from,
+                                       SkColor to) {
+  TransitionValueTo<SkColor>(this, target, monotonic_time, target_property,
+                             from, to);
+}
+
+bool KeyframeEffect::IsAnimatingProperty(int property) const {
+  for (auto& keyframe_model : keyframe_models_) {
+    if (keyframe_model->TargetProperty() == property)
+      return true;
+  }
+  return false;
+}
+
+bool KeyframeEffect::IsAnimating() const {
+  return !keyframe_models_.empty();
+}
+
+float KeyframeEffect::GetTargetFloatValue(int target_property,
+                                          float default_value) const {
+  return GetTargetValue<float>(target_property, default_value);
+}
+
+gfx::TransformOperations KeyframeEffect::GetTargetTransformOperationsValue(
+    int target_property,
+    const gfx::TransformOperations& default_value) const {
+  return GetTargetValue<gfx::TransformOperations>(target_property,
+                                                  default_value);
+}
+
+gfx::SizeF KeyframeEffect::GetTargetSizeValue(
+    int target_property,
+    const gfx::SizeF& default_value) const {
+  return GetTargetValue<gfx::SizeF>(target_property, default_value);
+}
+
+SkColor KeyframeEffect::GetTargetColorValue(int target_property,
+                                            SkColor default_value) const {
+  return GetTargetValue<SkColor>(target_property, default_value);
+}
+
+void KeyframeEffect::StartKeyframeModels(base::TimeTicks monotonic_time,
+                                         bool include_infinite_animations) {
+  TargetProperties animated_properties;
+  for (auto& keyframe_model : keyframe_models_) {
+    if (!include_infinite_animations &&
+        keyframe_model->iterations() == std::numeric_limits<double>::infinity())
+      continue;
+    if (keyframe_model->run_state() == KeyframeModel::RUNNING ||
+        keyframe_model->run_state() == KeyframeModel::PAUSED) {
+      animated_properties[keyframe_model->TargetProperty()] = true;
+    }
+  }
+  for (auto& keyframe_model : keyframe_models_) {
+    if (!include_infinite_animations &&
+        keyframe_model->iterations() == std::numeric_limits<double>::infinity())
+      continue;
+    if (!animated_properties[keyframe_model->TargetProperty()] &&
+        keyframe_model->run_state() ==
+            KeyframeModel::WAITING_FOR_TARGET_AVAILABILITY) {
+      animated_properties[keyframe_model->TargetProperty()] = true;
+      keyframe_model->SetRunState(KeyframeModel::RUNNING, monotonic_time);
+      keyframe_model->set_start_time(monotonic_time);
+    }
+  }
+}
+
+KeyframeModel* KeyframeEffect::GetRunningKeyframeModelForProperty(
+    int target_property) const {
+  for (auto& keyframe_model : keyframe_models_) {
+    if ((keyframe_model->run_state() == KeyframeModel::RUNNING ||
+         keyframe_model->run_state() == KeyframeModel::PAUSED) &&
+        keyframe_model->TargetProperty() == target_property) {
+      return keyframe_model.get();
+    }
+  }
+  return nullptr;
+}
+
+KeyframeModel* KeyframeEffect::GetKeyframeModel(int target_property) const {
+  for (size_t i = 0; i < keyframe_models().size(); ++i) {
+    size_t index = keyframe_models().size() - i - 1;
+    if (keyframe_models_[index]->TargetProperty() == target_property)
+      return keyframe_models_[index].get();
+  }
+  return nullptr;
+}
+
+KeyframeModel* KeyframeEffect::GetKeyframeModelById(int id) const {
+  for (auto& keyframe_model : keyframe_models())
+    if (keyframe_model->id() == id)
+      return keyframe_model.get();
+  return nullptr;
+}
+
+template <typename ValueType>
+ValueType KeyframeEffect::GetTargetValue(int target_property,
+                                         const ValueType& default_value) const {
+  KeyframeModel* running_keyframe_model = GetKeyframeModel(target_property);
+  if (!running_keyframe_model) {
+    return default_value;
+  }
+  const auto* curve = AnimationTraits<ValueType>::ToDerivedCurve(
+      running_keyframe_model->curve());
+  return curve->GetValue(GetEndTime(running_keyframe_model));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/keyframe_effect.h b/ui/gfx/animation/keyframe/keyframe_effect.h
new file mode 100644
index 0000000..818dce7
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframe_effect.h
@@ -0,0 +1,134 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_EFFECT_H_
+#define UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_EFFECT_H_
+
+#include <bitset>
+#include <set>
+#include <vector>
+
+#include "base/macros.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/animation/keyframe/animation_curve.h"
+#include "ui/gfx/animation/keyframe/keyframe_animation_export.h"
+#include "ui/gfx/animation/keyframe/keyframe_model.h"
+#include "ui/gfx/animation/keyframe/transition.h"
+
+namespace gfx {
+class SizeF;
+class TransformOperations;
+
+static constexpr size_t kMaxTargetPropertyId = 32u;
+using TargetProperties = std::bitset<kMaxTargetPropertyId>;
+
+// This is a simplified version of cc::KeyframeEffect. Its sole purpose is the
+// management of its collection of KeyframeModels. Ticking them, updating their
+// state, and deleting them as required.
+//
+// For background on the name of this class, please refer to the WebAnimations
+// spec: https://www.w3.org/TR/web-animations-1/#the-keyframeeffect-interface
+//
+// TODO(crbug.com/747185): Make cc::KeyframeEffect a subclass of KeyframeEffect
+// and share common code.
+class GFX_KEYFRAME_ANIMATION_EXPORT KeyframeEffect {
+ public:
+  static int GetNextKeyframeModelId();
+  static int GetNextGroupId();
+
+  KeyframeEffect();
+  ~KeyframeEffect();
+
+  KeyframeEffect(KeyframeEffect&&);
+  KeyframeEffect(const KeyframeEffect&) = delete;
+
+  KeyframeEffect& operator=(KeyframeEffect&&) = default;
+  KeyframeEffect& operator=(const KeyframeEffect&) = delete;
+
+  virtual void AddKeyframeModel(std::unique_ptr<KeyframeModel> keyframe_model);
+  void RemoveAllKeyframeModels();
+  void RemoveKeyframeModel(int keyframe_model_id);
+  void RemoveKeyframeModels(int target_property);
+
+  virtual void Tick(base::TimeTicks monotonic_time);
+
+  // This ticks all keyframe models until they are complete.
+  void FinishAll();
+
+  using KeyframeModels = std::vector<std::unique_ptr<KeyframeModel>>;
+  const KeyframeModels& keyframe_models() const { return keyframe_models_; }
+  KeyframeModels& keyframe_models() { return keyframe_models_; }
+
+  // The transition is analogous to CSS transitions. When configured, the
+  // transition object will cause subsequent calls the corresponding
+  // TransitionXXXTo functions to induce transition animations.
+  const Transition& transition() const { return transition_; }
+  void set_transition(const Transition& transition) {
+    transition_ = transition;
+  }
+
+  void SetTransitionedProperties(const std::set<int>& properties);
+  void SetTransitionDuration(base::TimeDelta delta);
+
+  void TransitionFloatTo(FloatAnimationCurve::Target* target,
+                         base::TimeTicks monotonic_time,
+                         int target_property,
+                         float from,
+                         float to);
+  void TransitionTransformOperationsTo(TransformAnimationCurve::Target* target,
+                                       base::TimeTicks monotonic_time,
+                                       int target_property,
+                                       const gfx::TransformOperations& from,
+                                       const gfx::TransformOperations& to);
+  void TransitionSizeTo(SizeAnimationCurve::Target* target,
+                        base::TimeTicks monotonic_time,
+                        int target_property,
+                        const gfx::SizeF& from,
+                        const gfx::SizeF& to);
+  void TransitionColorTo(ColorAnimationCurve::Target* target,
+                         base::TimeTicks monotonic_time,
+                         int target_property,
+                         SkColor from,
+                         SkColor to);
+
+  bool IsAnimatingProperty(int property) const;
+  bool IsAnimating() const;
+
+  float GetTargetFloatValue(int target_property, float default_value) const;
+  gfx::TransformOperations GetTargetTransformOperationsValue(
+      int target_property,
+      const gfx::TransformOperations& default_value) const;
+  gfx::SizeF GetTargetSizeValue(int target_property,
+                                const gfx::SizeF& default_value) const;
+  SkColor GetTargetColorValue(int target_property, SkColor default_value) const;
+  KeyframeModel* GetRunningKeyframeModelForProperty(int target_property) const;
+  KeyframeModel* GetKeyframeModel(int target_property) const;
+  KeyframeModel* GetKeyframeModelById(int id) const;
+
+ protected:
+  // Removes all keyframe models in the range provided. This is virtual so that
+  // subclasses that need to do extra bookkeeping upon removals may do so. As a
+  // consequence, please ensure that all removals happen via this method.
+  virtual void RemoveKeyframeModelRange(
+      typename KeyframeModels::iterator to_remove_begin,
+      typename KeyframeModels::iterator to_remove_end);
+  void TickKeyframeModel(base::TimeTicks monotonic_time,
+                         KeyframeModel* keyframe_model);
+
+ private:
+  void TickInternal(base::TimeTicks monotonic_time,
+                    bool include_infinite_animations);
+  void StartKeyframeModels(base::TimeTicks monotonic_time,
+                           bool include_infinite_animations);
+  template <typename ValueType>
+  ValueType GetTargetValue(int target_property,
+                           const ValueType& default_value) const;
+
+  KeyframeModels keyframe_models_;
+  Transition transition_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_EFFECT_H_
diff --git a/ui/gfx/animation/keyframe/keyframe_model.cc b/ui/gfx/animation/keyframe/keyframe_model.cc
new file mode 100644
index 0000000..eaa8a86
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframe_model.cc
@@ -0,0 +1,257 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/animation/keyframe/keyframe_model.h"
+
+#include "base/cxx17_backports.h"
+#include "base/memory/ptr_util.h"
+#include "base/notreached.h"
+
+namespace gfx {
+namespace {
+
+// This should match the RunState enum.
+static const char* const s_runStateNames[] = {"WAITING_FOR_TARGET_AVAILABILITY",
+                                              "WAITING_FOR_DELETION",
+                                              "STARTING",
+                                              "RUNNING",
+                                              "PAUSED",
+                                              "FINISHED",
+                                              "ABORTED",
+                                              "ABORTED_BUT_NEEDS_COMPLETION"};
+
+static_assert(static_cast<int>(KeyframeModel::LAST_RUN_STATE) + 1 ==
+                  base::size(s_runStateNames),
+              "RunStateEnumSize should equal the number of elements in "
+              "s_runStateNames");
+
+}  // namespace
+
+std::string KeyframeModel::ToString(RunState state) {
+  return s_runStateNames[state];
+}
+
+std::unique_ptr<KeyframeModel> KeyframeModel::Create(
+    std::unique_ptr<AnimationCurve> curve,
+    int keyframe_model_id,
+    int target_property_id) {
+  return base::WrapUnique(new KeyframeModel(std::move(curve), keyframe_model_id,
+                                            target_property_id));
+}
+
+KeyframeModel::KeyframeModel(std::unique_ptr<AnimationCurve> curve,
+                             int keyframe_model_id,
+                             int target_property_id)
+    : curve_(std::move(curve)),
+      id_(keyframe_model_id),
+      target_property_(target_property_id),
+      run_state_(WAITING_FOR_TARGET_AVAILABILITY),
+      iterations_(1),
+      iteration_start_(0),
+      direction_(Direction::NORMAL),
+      playback_rate_(1),
+      fill_mode_(FillMode::BOTH) {}
+
+KeyframeModel::~KeyframeModel() {
+  if (run_state() == RUNNING || run_state() == PAUSED)
+    SetRunState(ABORTED, base::TimeTicks());
+}
+
+int KeyframeModel::TargetProperty() const {
+  return target_property_;
+}
+
+void KeyframeModel::SetRunState(RunState run_state,
+                                base::TimeTicks monotonic_time) {
+  if (run_state == RUNNING && run_state_ == PAUSED)
+    total_paused_duration_ += (monotonic_time - pause_time_);
+  else if (run_state == PAUSED)
+    pause_time_ = monotonic_time;
+  run_state_ = run_state;
+}
+
+void KeyframeModel::Pause(base::TimeDelta pause_offset) {
+  // Convert pause offset which is in local time to monotonic time.
+  // TODO(crbug.com/912407): This should be scaled by playbackrate.
+  base::TimeTicks monotonic_time =
+      pause_offset + start_time_ + total_paused_duration_;
+  SetRunState(PAUSED, monotonic_time);
+}
+
+KeyframeModel::Phase KeyframeModel::CalculatePhaseForTesting(
+    base::TimeDelta local_time) const {
+  return CalculatePhase(local_time);
+}
+
+KeyframeModel::Phase KeyframeModel::CalculatePhase(
+    base::TimeDelta local_time) const {
+  base::TimeDelta opposite_time_offset = time_offset_ == base::TimeDelta::Min()
+                                             ? base::TimeDelta::Max()
+                                             : -time_offset_;
+  base::TimeDelta before_active_boundary_time =
+      std::max(opposite_time_offset, base::TimeDelta());
+  if (local_time < before_active_boundary_time ||
+      (local_time == before_active_boundary_time && playback_rate_ < 0)) {
+    return KeyframeModel::Phase::BEFORE;
+  }
+  // TODO(crbug.com/909794): By spec end time = max(start delay + duration +
+  // end delay, 0). The logic should be updated once "end delay" is supported.
+  base::TimeDelta active_after_boundary_time = base::TimeDelta::Max();
+  if (std::isfinite(iterations_)) {
+    // Scaling the duration is against spec but needed to comply with the cc
+    // implementation. By spec (in blink) the playback rate is an Animation
+    // level concept but in cc it's per KeyframeModel. We grab the active time
+    // calculated here and later scale it with the playback rate in order to get
+    // a proper progress. Therefore we need to un-scale it here. This can be
+    // fixed once we scale the local time by playback rate. See
+    // https://crbug.com/912407.
+    base::TimeDelta active_duration =
+        curve_->Duration() * iterations_ / std::abs(playback_rate_);
+    active_after_boundary_time =
+        std::max(opposite_time_offset + active_duration, base::TimeDelta());
+  }
+  if (local_time > active_after_boundary_time ||
+      (local_time == active_after_boundary_time && playback_rate_ > 0)) {
+    return KeyframeModel::Phase::AFTER;
+  }
+  return KeyframeModel::Phase::ACTIVE;
+}
+
+absl::optional<base::TimeDelta> KeyframeModel::CalculateActiveTime(
+    base::TimeTicks monotonic_time) const {
+  base::TimeDelta local_time = ConvertMonotonicTimeToLocalTime(monotonic_time);
+  KeyframeModel::Phase phase = CalculatePhase(local_time);
+  DCHECK(playback_rate_);
+  switch (phase) {
+    case KeyframeModel::Phase::BEFORE:
+      if (fill_mode_ == FillMode::BACKWARDS || fill_mode_ == FillMode::BOTH)
+        return std::max(local_time + time_offset_, base::TimeDelta());
+      return absl::nullopt;
+    case KeyframeModel::Phase::ACTIVE:
+      return local_time + time_offset_;
+    case KeyframeModel::Phase::AFTER:
+      if (fill_mode_ == FillMode::FORWARDS || fill_mode_ == FillMode::BOTH) {
+        DCHECK_NE(iterations_, std::numeric_limits<double>::infinity());
+        base::TimeDelta active_duration =
+            curve_->Duration() * iterations_ / std::abs(playback_rate_);
+        return std::max(std::min(local_time + time_offset_, active_duration),
+                        base::TimeDelta());
+      }
+      return absl::nullopt;
+    default:
+      NOTREACHED();
+      return absl::nullopt;
+  }
+}
+
+bool KeyframeModel::IsFinishedAt(base::TimeTicks monotonic_time) const {
+  if (is_finished())
+    return true;
+
+  if (StartShouldBeDeferred())
+    return false;
+
+  if (playback_rate_ == 0)
+    return false;
+
+  return run_state_ == RUNNING && std::isfinite(iterations_) &&
+         (curve_->Duration() * (iterations_ / std::abs(playback_rate_))) <=
+             (ConvertMonotonicTimeToLocalTime(monotonic_time) + time_offset_);
+}
+
+bool KeyframeModel::HasActiveTime(base::TimeTicks monotonic_time) const {
+  return CalculateActiveTime(monotonic_time).has_value();
+}
+
+bool KeyframeModel::StartShouldBeDeferred() const {
+  return false;
+}
+
+base::TimeDelta KeyframeModel::TrimTimeToCurrentIteration(
+    base::TimeTicks monotonic_time) const {
+  DCHECK(playback_rate_);
+  DCHECK_GE(iteration_start_, 0);
+
+  DCHECK(HasActiveTime(monotonic_time));
+  base::TimeDelta active_time = CalculateActiveTime(monotonic_time).value();
+  base::TimeDelta start_offset = curve_->Duration() * iteration_start_;
+
+  // Return start offset if we are before the start of the keyframe model
+  if (active_time < base::TimeDelta())
+    return start_offset;
+  // Always return zero if we have no iterations.
+  if (!iterations_)
+    return base::TimeDelta();
+
+  // Don't attempt to trim if we have no duration.
+  if (curve_->Duration() <= base::TimeDelta())
+    return base::TimeDelta();
+
+  base::TimeDelta repeated_duration = std::isfinite(iterations_)
+                                          ? (curve_->Duration() * iterations_)
+                                          : base::TimeDelta::Max();
+
+  // Calculate the scaled active time
+  base::TimeDelta scaled_active_time;
+  if (playback_rate_ < 0) {
+    DCHECK(std::isfinite(iterations_));
+    base::TimeDelta active_duration =
+        repeated_duration / std::abs(playback_rate_);
+    scaled_active_time =
+        ((active_time - active_duration) * playback_rate_) + start_offset;
+  } else {
+    scaled_active_time = (active_time * playback_rate_) + start_offset;
+  }
+
+  // Calculate the iteration time
+  base::TimeDelta iteration_time;
+  bool has_defined_time_delta =
+      (start_offset != scaled_active_time) ||
+      !(start_offset.is_max() || start_offset.is_min());
+  if (has_defined_time_delta &&
+      scaled_active_time - start_offset == repeated_duration &&
+      fmod(iterations_ + iteration_start_, 1) == 0)
+    iteration_time = curve_->Duration();
+  else
+    iteration_time = scaled_active_time % curve_->Duration();
+
+  // Calculate the current iteration
+  int iteration;
+  if (scaled_active_time <= base::TimeDelta())
+    iteration = 0;
+  else if (iteration_time == curve_->Duration())
+    iteration = ceil(iteration_start_ + iterations_ - 1);
+  else
+    iteration = base::ClampFloor(scaled_active_time / curve_->Duration());
+
+  // Check if we are running the keyframe model in reverse direction for the
+  // current iteration
+  bool reverse =
+      (direction_ == Direction::REVERSE) ||
+      (direction_ == Direction::ALTERNATE_NORMAL && iteration % 2 == 1) ||
+      (direction_ == Direction::ALTERNATE_REVERSE && iteration % 2 == 0);
+
+  // If we are running the keyframe model in reverse direction, reverse the
+  // result
+  if (reverse)
+    iteration_time = curve_->Duration() - iteration_time;
+
+  return iteration_time;
+}
+
+// TODO(crbug.com/912407): Local time should be scaled by playback rate by spec.
+base::TimeDelta KeyframeModel::ConvertMonotonicTimeToLocalTime(
+    base::TimeTicks monotonic_time) const {
+  // When waiting on receiving a start time, then our global clock is 'stuck' at
+  // the initial state.
+  if ((run_state_ == STARTING && !has_set_start_time()) ||
+      StartShouldBeDeferred())
+    return base::TimeDelta();
+
+  // If we're paused, time is 'stuck' at the pause time.
+  base::TimeTicks time = (run_state_ == PAUSED) ? pause_time_ : monotonic_time;
+  return time - start_time_ - total_paused_duration_;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/keyframe_model.h b/ui/gfx/animation/keyframe/keyframe_model.h
new file mode 100644
index 0000000..3cb053b
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframe_model.h
@@ -0,0 +1,223 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_MODEL_H_
+#define UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_MODEL_H_
+
+#include <string>
+
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/animation/keyframe/animation_curve.h"
+#include "ui/gfx/animation/keyframe/keyframe_animation_export.h"
+#include "ui/gfx/animation/keyframe/keyframed_animation_curve.h"
+
+namespace gfx {
+
+class GFX_KEYFRAME_ANIMATION_EXPORT KeyframeModel {
+ public:
+  // KeyframeModels begin in the 'WAITING_FOR_TARGET_AVAILABILITY' state. A
+  // KeyframeModel waiting for target availability will run as soon as its
+  // target property is free (and all the KeyframeModels animating with it are
+  // also able to run). When this time arrives, the controller will move the
+  // keyframe model into the STARTING state, and then into the RUNNING state.
+  // RUNNING KeyframeModels may toggle between RUNNING and PAUSED, and may be
+  // stopped by moving into either the ABORTED or FINISHED states. A FINISHED
+  // keyframe model was allowed to run to completion, but an ABORTED keyframe
+  // model was not. An animation in the state ABORTED_BUT_NEEDS_COMPLETION is a
+  // keyframe model that was aborted for some reason, but needs to be finished.
+  // Currently this is for impl-only scroll offset KeyframeModels that need to
+  // be completed on the main thread.
+  enum RunState {
+    WAITING_FOR_TARGET_AVAILABILITY = 0,
+    WAITING_FOR_DELETION,
+    STARTING,
+    RUNNING,
+    PAUSED,
+    FINISHED,
+    ABORTED,
+    ABORTED_BUT_NEEDS_COMPLETION,
+    // This sentinel must be last.
+    LAST_RUN_STATE = ABORTED_BUT_NEEDS_COMPLETION
+  };
+  static std::string ToString(RunState);
+
+  enum class Direction { NORMAL, REVERSE, ALTERNATE_NORMAL, ALTERNATE_REVERSE };
+
+  enum class FillMode { NONE, FORWARDS, BACKWARDS, BOTH, AUTO };
+
+  enum class Phase { BEFORE, ACTIVE, AFTER };
+
+  static std::unique_ptr<KeyframeModel> Create(
+      std::unique_ptr<AnimationCurve> curve,
+      int keyframe_model_id,
+      int target_property_id);
+
+  KeyframeModel(const KeyframeModel&) = delete;
+  virtual ~KeyframeModel();
+
+  KeyframeModel& operator=(const KeyframeModel&) = delete;
+
+  int id() const { return id_; }
+
+  virtual int TargetProperty() const;
+
+  RunState run_state() const { return run_state_; }
+  virtual void SetRunState(RunState run_state, base::TimeTicks monotonic_time);
+
+  // Pause the keyframe effect at local time |pause_offset|.
+  void Pause(base::TimeDelta pause_offset);
+
+  base::TimeTicks start_time() const { return start_time_; }
+
+  void set_start_time(base::TimeTicks monotonic_time) {
+    start_time_ = monotonic_time;
+  }
+  bool has_set_start_time() const { return !start_time_.is_null(); }
+
+  base::TimeDelta time_offset() const { return time_offset_; }
+  void set_time_offset(base::TimeDelta monotonic_time) {
+    time_offset_ = monotonic_time;
+  }
+
+  Direction direction() const { return direction_; }
+  void set_direction(Direction direction) { direction_ = direction; }
+
+  FillMode fill_mode() const { return fill_mode_; }
+  void set_fill_mode(FillMode fill_mode) { fill_mode_ = fill_mode; }
+
+  double playback_rate() const { return playback_rate_; }
+  void set_playback_rate(double playback_rate) {
+    playback_rate_ = playback_rate;
+  }
+
+  base::TimeTicks pause_time() const { return pause_time_; }
+  void set_pause_time(base::TimeTicks pause_time) { pause_time_ = pause_time; }
+
+  base::TimeDelta total_paused_duration() const {
+    return total_paused_duration_;
+  }
+  void set_total_paused_duration(base::TimeDelta total_paused_duration) {
+    total_paused_duration_ = total_paused_duration;
+  }
+
+  // This is the number of times that the keyframe model will play. If this
+  // value is zero the keyframe model will not play. If it is negative, then
+  // the keyframe model will loop indefinitely.
+  double iterations() const { return iterations_; }
+  void set_iterations(double n) { iterations_ = n; }
+
+  double iteration_start() const { return iteration_start_; }
+  void set_iteration_start(double iteration_start) {
+    iteration_start_ = iteration_start;
+  }
+
+  AnimationCurve* curve() { return curve_.get(); }
+  const AnimationCurve* curve() const { return curve_.get(); }
+
+  bool IsFinishedAt(base::TimeTicks monotonic_time) const;
+  bool is_finished() const {
+    return run_state_ == FINISHED || run_state_ == ABORTED ||
+           run_state_ == WAITING_FOR_DELETION;
+  }
+
+  bool HasActiveTime(base::TimeTicks monotonic_time) const;
+
+  template <typename T>
+  void Retarget(base::TimeTicks now,
+                int property_id,
+                const T& new_target_value) {
+    if (!curve_)
+      return;
+    base::TimeDelta now_delta = TrimTimeToCurrentIteration(now);
+
+    DCHECK_EQ(CalculatePhase(now_delta), KeyframeModel::Phase::ACTIVE);
+    auto* keyframed_curve = AnimationTraits<T>::ToKeyframedCurve(curve_.get());
+    DCHECK(keyframed_curve);
+    if (auto new_curve = keyframed_curve->Retarget(now_delta, new_target_value))
+      curve_ = std::move(new_curve);
+  }
+
+  // Some clients may run threaded animations and may need to defer starting
+  // until the animation on the other thread has been started.
+  virtual bool StartShouldBeDeferred() const;
+
+  // Takes the given absolute time, and using the start time and the number
+  // of iterations, returns the relative time in the current iteration.
+  base::TimeDelta TrimTimeToCurrentIteration(
+      base::TimeTicks monotonic_time) const;
+
+  KeyframeModel::Phase CalculatePhaseForTesting(
+      base::TimeDelta local_time) const;
+
+ protected:
+  KeyframeModel(std::unique_ptr<AnimationCurve> curve,
+                int keyframe_model_id,
+                int target_property_id);
+
+  void ForceRunState(RunState run_state) { run_state_ = run_state; }
+  absl::optional<base::TimeDelta> CalculateActiveTime(
+      base::TimeTicks monotonic_time) const;
+
+ private:
+  KeyframeModel::Phase CalculatePhase(base::TimeDelta local_time) const;
+
+  // Return local time for this keyframe model given the absolute monotonic
+  // time.
+  //
+  // Local time represents the time value that is used to tick this keyframe
+  // model and is relative to its start time. It is closely related to the local
+  // time concept in web animations [1]. It is:
+  //  - for playing animation : wall time - start time - paused duration
+  //  - for paused animation  : paused time
+  //  - otherwise             : zero
+  //
+  // Here is small diagram that shows how active, local, and monotonic times
+  // relate to each other and to the run state.
+  //
+  //      run state   Starting  (R)unning  Paused (R) Paused (R)  Finished
+  //                    ^                                          ^
+  //                    |                                          |
+  // monotonic time  ------------------------------------------------->
+  //                    |                                          |
+  //     local time     +-----------------+      +---+      +--------->
+  //                    |                                          |
+  //    active time     +          +------+      +---+      +------+
+  //                      (-offset)
+  //
+  // [1] https://drafts.csswg.org/web-animations/#local-time-section
+  base::TimeDelta ConvertMonotonicTimeToLocalTime(
+      base::TimeTicks monotonic_time) const;
+
+  std::unique_ptr<AnimationCurve> curve_;
+
+  // IDs must be unique.
+  int id_;
+
+  int target_property_ = 0;
+  RunState run_state_;
+  double iterations_;
+  double iteration_start_;
+  Direction direction_;
+  double playback_rate_;
+  FillMode fill_mode_;
+
+  base::TimeTicks start_time_;
+
+  // The time offset effectively pushes the start of the keyframe model back in
+  // time. This is used for resuming paused KeyframeModels -- an animation is
+  // added with a non-zero time offset, causing the keyframe model to skip ahead
+  // to the desired point in time.
+  base::TimeDelta time_offset_;
+
+  // These are used when converting monotonic to local time to account for time
+  // spent while paused. This is not included in AnimationState since it
+  // there is absolutely no need for clients of this controller to know
+  // about these values.
+  base::TimeTicks pause_time_;
+  base::TimeDelta total_paused_duration_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_KEYFRAME_MODEL_H_
diff --git a/ui/gfx/animation/keyframe/keyframed_animation_curve-inl.h b/ui/gfx/animation/keyframe/keyframed_animation_curve-inl.h
new file mode 100644
index 0000000..ac226f6
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframed_animation_curve-inl.h
@@ -0,0 +1,148 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_KEYFRAMED_ANIMATION_CURVE_INL_H_
+#define UI_GFX_ANIMATION_KEYFRAME_KEYFRAMED_ANIMATION_CURVE_INL_H_
+
+namespace {
+
+template <class KeyframeType>
+void InsertKeyframe(std::unique_ptr<KeyframeType> keyframe,
+                    std::vector<std::unique_ptr<KeyframeType>>* keyframes) {
+  // Usually, the keyframes will be added in order, so this loop would be
+  // unnecessary and we should skip it if possible.
+  if (!keyframes->empty() && keyframe->Time() < keyframes->back()->Time()) {
+    for (size_t i = 0; i < keyframes->size(); ++i) {
+      if (keyframe->Time() < keyframes->at(i)->Time()) {
+        keyframes->insert(keyframes->begin() + i, std::move(keyframe));
+        return;
+      }
+    }
+  }
+
+  keyframes->push_back(std::move(keyframe));
+}
+
+struct TimeValues {
+  base::TimeDelta start_time;
+  base::TimeDelta duration;
+  double progress;
+};
+
+template <typename KeyframeType>
+TimeValues GetTimeValues(const KeyframeType& start_frame,
+                         const KeyframeType& end_frame,
+                         double scaled_duration,
+                         base::TimeDelta time) {
+  TimeValues values;
+  values.start_time = start_frame.Time() * scaled_duration;
+  values.duration = (end_frame.Time() * scaled_duration) - values.start_time;
+  const base::TimeDelta elapsed = time - values.start_time;
+  values.progress = (elapsed.is_inf() || values.duration.is_zero())
+                        ? 1.0
+                        : (elapsed / values.duration);
+  return values;
+}
+
+template <typename KeyframeType>
+base::TimeDelta TransformedAnimationTime(
+    const std::vector<std::unique_ptr<KeyframeType>>& keyframes,
+    const std::unique_ptr<gfx::TimingFunction>& timing_function,
+    double scaled_duration,
+    base::TimeDelta time) {
+  if (timing_function) {
+    const auto values = GetTimeValues(*keyframes.front(), *keyframes.back(),
+                                      scaled_duration, time);
+    time = (values.duration * timing_function->GetValue(values.progress)) +
+           values.start_time;
+  }
+
+  return time;
+}
+
+template <typename KeyframeType>
+size_t GetActiveKeyframe(
+    const std::vector<std::unique_ptr<KeyframeType>>& keyframes,
+    double scaled_duration,
+    base::TimeDelta time) {
+  DCHECK_GE(keyframes.size(), 2ul);
+  size_t i = 0;
+  while ((i < keyframes.size() - 2) &&  // Last keyframe is never active.
+         (time >= (keyframes[i + 1]->Time() * scaled_duration)))
+    ++i;
+
+  return i;
+}
+
+template <typename KeyframeType>
+double TransformedKeyframeProgress(
+    const std::vector<std::unique_ptr<KeyframeType>>& keyframes,
+    double scaled_duration,
+    base::TimeDelta time,
+    size_t i) {
+  const double progress =
+      GetTimeValues(*keyframes[i], *keyframes[i + 1], scaled_duration, time)
+          .progress;
+  return keyframes[i]->timing_function()
+             ? keyframes[i]->timing_function()->GetValue(progress)
+             : progress;
+}
+
+int GetTimingFunctionSteps(const gfx::TimingFunction* timing_function) {
+  DCHECK(timing_function &&
+         timing_function->GetType() == gfx::TimingFunction::Type::STEPS);
+  const gfx::StepsTimingFunction* steps_timing_function =
+      reinterpret_cast<const gfx::StepsTimingFunction*>(timing_function);
+  DCHECK(steps_timing_function);
+  return steps_timing_function->steps();
+}
+
+template <class KeyframeType>
+base::TimeDelta ComputeTickInterval(
+    const std::unique_ptr<gfx::TimingFunction>& timing_function,
+    double scaled_duration,
+    const std::vector<std::unique_ptr<KeyframeType>>& keyframes) {
+  // TODO(crbug.com/1140603): include animation progress in order to pinpoint
+  // which keyframe's timing function is in effect at any point in time.
+  DCHECK_LT(0u, keyframes.size());
+  gfx::TimingFunction::Type timing_function_type =
+      timing_function ? timing_function->GetType()
+                      : gfx::TimingFunction::Type::LINEAR;
+  // Even if the keyframe's have step timing functions, a non-linear
+  // animation-wide timing function results in unevenly timed steps.
+  switch (timing_function_type) {
+    case gfx::TimingFunction::Type::LINEAR: {
+      base::TimeDelta min_interval = base::TimeDelta::Max();
+      // If any keyframe uses non-step "easing", return 0, except for the last
+      // keyframe, whose "easing" is never used.
+      for (size_t ii = 0; ii < keyframes.size() - 1; ++ii) {
+        KeyframeType* keyframe = keyframes[ii].get();
+        if (!keyframe->timing_function() ||
+            keyframe->timing_function()->GetType() !=
+                gfx::TimingFunction::Type::STEPS) {
+          return base::TimeDelta();
+        }
+        KeyframeType* next_keyframe = keyframes[ii + 1].get();
+        int steps = GetTimingFunctionSteps(keyframe->timing_function());
+        DCHECK_LT(0, steps);
+        base::TimeDelta interval = (next_keyframe->Time() - keyframe->Time()) *
+                                   scaled_duration / steps;
+        if (interval < min_interval)
+          min_interval = interval;
+      }
+      return min_interval;
+    }
+    case gfx::TimingFunction::Type::STEPS: {
+      return (keyframes.back()->Time() - keyframes.front()->Time()) *
+             scaled_duration / GetTimingFunctionSteps(timing_function.get());
+    }
+    case gfx::TimingFunction::Type::CUBIC_BEZIER:
+      break;
+  }
+  return base::TimeDelta();
+}
+
+}  // namespace
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_KEYFRAMED_ANIMATION_CURVE_INL_H_
diff --git a/ui/gfx/animation/keyframe/keyframed_animation_curve.cc b/ui/gfx/animation/keyframe/keyframed_animation_curve.cc
new file mode 100644
index 0000000..3aba6cf
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframed_animation_curve.cc
@@ -0,0 +1,586 @@
+// Copyright 2012 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.
+
+#include "ui/gfx/animation/keyframe/keyframed_animation_curve.h"
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+
+#include "base/memory/ptr_util.h"
+#include "base/numerics/ranges.h"
+#include "base/time/time.h"
+#include "ui/gfx/animation/keyframe/keyframed_animation_curve-inl.h"
+#include "ui/gfx/animation/tween.h"
+#include "ui/gfx/geometry/box_f.h"
+
+namespace gfx {
+namespace {
+
+static constexpr float kTolerance = 1e-5f;
+
+template <typename KeyframeType, typename ValueType, typename TargetType>
+std::unique_ptr<AnimationCurve> RetargettedCurve(
+    std::vector<std::unique_ptr<KeyframeType>>& keyframes,
+    base::TimeDelta t,
+    const ValueType& value_at_t,
+    const ValueType& new_target_value,
+    double scaled_duration,
+    TargetType* target,
+    const TimingFunction* timing_function) {
+  if (SufficientlyEqual(keyframes.back()->Value(), new_target_value))
+    return nullptr;
+
+  DCHECK_GE(keyframes.size(), 2u);
+  DCHECK_GT(scaled_duration, 0.f);
+
+  // If we haven't progressed to animating between the last 2 keyframes, simply
+  // clobber the value for the last keyframe.
+  const bool at_last_keyframe =
+      (keyframes[keyframes.size() - 2]->Time() * scaled_duration) <= t;
+  if (!at_last_keyframe) {
+    auto& last_keyframe = keyframes.back();
+    auto* keyframe_timing_function = last_keyframe->timing_function();
+    last_keyframe = KeyframeType::Create(
+        last_keyframe->Time(), new_target_value,
+        keyframe_timing_function ? keyframe_timing_function->Clone() : nullptr);
+    return nullptr;
+  }
+
+  // Ensure that `t` happens between the last two keyframes.
+  DCHECK_GE(keyframes[keyframes.size() - 1]->Time() * scaled_duration, t);
+
+  // TODO(crbug.com/1198305): This can be changed to a different / special
+  // interpolation curve type to maintain c2 continuity.
+  auto curve = AnimationTraits<ValueType>::KeyframedCurveType::Create();
+  curve->set_scaled_duration(scaled_duration);
+  curve->set_target(target);
+
+  auto generate_timing_function =
+      [timing_function]() -> std::unique_ptr<gfx::TimingFunction> {
+    if (timing_function)
+      return timing_function->Clone();
+    return nullptr;
+  };
+
+  // Keep the curve duration the same by adding the same first frame.
+  curve->AddKeyframe(KeyframeType::Create(keyframes.front()->Time(),
+                                          keyframes.front()->Value(),
+                                          generate_timing_function()));
+
+  // Snap the current value at `t` so that the current value stays the same.
+  curve->AddKeyframe(KeyframeType::Create(t / scaled_duration, value_at_t,
+                                          generate_timing_function()));
+
+  // Add a new target at the same time as the last frame.
+  curve->AddKeyframe(KeyframeType::Create(
+      keyframes.back()->Time(), new_target_value, generate_timing_function()));
+
+  return curve;
+}
+
+}  // namespace
+
+Keyframe::Keyframe(base::TimeDelta time,
+                   std::unique_ptr<TimingFunction> timing_function)
+    : time_(time), timing_function_(std::move(timing_function)) {}
+
+Keyframe::~Keyframe() = default;
+
+base::TimeDelta Keyframe::Time() const {
+  return time_;
+}
+
+std::unique_ptr<ColorKeyframe> ColorKeyframe::Create(
+    base::TimeDelta time,
+    SkColor value,
+    std::unique_ptr<TimingFunction> timing_function) {
+  return base::WrapUnique(
+      new ColorKeyframe(time, value, std::move(timing_function)));
+}
+
+ColorKeyframe::ColorKeyframe(base::TimeDelta time,
+                             SkColor value,
+                             std::unique_ptr<TimingFunction> timing_function)
+    : Keyframe(time, std::move(timing_function)), value_(value) {}
+
+ColorKeyframe::~ColorKeyframe() = default;
+
+SkColor ColorKeyframe::Value() const {
+  return value_;
+}
+
+std::unique_ptr<ColorKeyframe> ColorKeyframe::Clone() const {
+  std::unique_ptr<TimingFunction> func;
+  if (timing_function())
+    func = timing_function()->Clone();
+  return ColorKeyframe::Create(Time(), Value(), std::move(func));
+}
+
+std::unique_ptr<FloatKeyframe> FloatKeyframe::Create(
+    base::TimeDelta time,
+    float value,
+    std::unique_ptr<TimingFunction> timing_function) {
+  return base::WrapUnique(
+      new FloatKeyframe(time, value, std::move(timing_function)));
+}
+
+FloatKeyframe::FloatKeyframe(base::TimeDelta time,
+                             float value,
+                             std::unique_ptr<TimingFunction> timing_function)
+    : Keyframe(time, std::move(timing_function)), value_(value) {}
+
+FloatKeyframe::~FloatKeyframe() = default;
+
+float FloatKeyframe::Value() const {
+  return value_;
+}
+
+std::unique_ptr<FloatKeyframe> FloatKeyframe::Clone() const {
+  std::unique_ptr<TimingFunction> func;
+  if (timing_function())
+    func = timing_function()->Clone();
+  return FloatKeyframe::Create(Time(), Value(), std::move(func));
+}
+
+std::unique_ptr<TransformKeyframe> TransformKeyframe::Create(
+    base::TimeDelta time,
+    const gfx::TransformOperations& value,
+    std::unique_ptr<TimingFunction> timing_function) {
+  return base::WrapUnique(
+      new TransformKeyframe(time, value, std::move(timing_function)));
+}
+
+TransformKeyframe::TransformKeyframe(
+    base::TimeDelta time,
+    const gfx::TransformOperations& value,
+    std::unique_ptr<TimingFunction> timing_function)
+    : Keyframe(time, std::move(timing_function)), value_(value) {}
+
+TransformKeyframe::~TransformKeyframe() = default;
+
+const gfx::TransformOperations& TransformKeyframe::Value() const {
+  return value_;
+}
+
+std::unique_ptr<TransformKeyframe> TransformKeyframe::Clone() const {
+  std::unique_ptr<TimingFunction> func;
+  if (timing_function())
+    func = timing_function()->Clone();
+  return TransformKeyframe::Create(Time(), Value(), std::move(func));
+}
+
+std::unique_ptr<SizeKeyframe> SizeKeyframe::Create(
+    base::TimeDelta time,
+    const gfx::SizeF& value,
+    std::unique_ptr<TimingFunction> timing_function) {
+  return base::WrapUnique(
+      new SizeKeyframe(time, value, std::move(timing_function)));
+}
+
+SizeKeyframe::SizeKeyframe(base::TimeDelta time,
+                           const gfx::SizeF& value,
+                           std::unique_ptr<TimingFunction> timing_function)
+    : Keyframe(time, std::move(timing_function)), value_(value) {}
+
+SizeKeyframe::~SizeKeyframe() = default;
+
+const gfx::SizeF& SizeKeyframe::Value() const {
+  return value_;
+}
+
+std::unique_ptr<SizeKeyframe> SizeKeyframe::Clone() const {
+  std::unique_ptr<TimingFunction> func;
+  if (timing_function())
+    func = timing_function()->Clone();
+  return SizeKeyframe::Create(Time(), Value(), std::move(func));
+}
+
+std::unique_ptr<RectKeyframe> RectKeyframe::Create(
+    base::TimeDelta time,
+    const gfx::Rect& value,
+    std::unique_ptr<TimingFunction> timing_function) {
+  return base::WrapUnique(
+      new RectKeyframe(time, value, std::move(timing_function)));
+}
+
+RectKeyframe::RectKeyframe(base::TimeDelta time,
+                           const gfx::Rect& value,
+                           std::unique_ptr<TimingFunction> timing_function)
+    : Keyframe(time, std::move(timing_function)), value_(value) {}
+
+RectKeyframe::~RectKeyframe() = default;
+
+const gfx::Rect& RectKeyframe::Value() const {
+  return value_;
+}
+
+std::unique_ptr<RectKeyframe> RectKeyframe::Clone() const {
+  std::unique_ptr<TimingFunction> func;
+  if (timing_function())
+    func = timing_function()->Clone();
+  return RectKeyframe::Create(Time(), Value(), std::move(func));
+}
+
+std::unique_ptr<KeyframedColorAnimationCurve>
+KeyframedColorAnimationCurve::Create() {
+  return base::WrapUnique(new KeyframedColorAnimationCurve);
+}
+
+KeyframedColorAnimationCurve::KeyframedColorAnimationCurve()
+    : scaled_duration_(1.0) {}
+
+KeyframedColorAnimationCurve::~KeyframedColorAnimationCurve() = default;
+
+void KeyframedColorAnimationCurve::AddKeyframe(
+    std::unique_ptr<ColorKeyframe> keyframe) {
+  InsertKeyframe(std::move(keyframe), &keyframes_);
+}
+
+base::TimeDelta KeyframedColorAnimationCurve::Duration() const {
+  return (keyframes_.back()->Time() - keyframes_.front()->Time()) *
+         scaled_duration();
+}
+
+base::TimeDelta KeyframedColorAnimationCurve::TickInterval() const {
+  return ComputeTickInterval(timing_function_, scaled_duration(), keyframes_);
+}
+
+std::unique_ptr<AnimationCurve> KeyframedColorAnimationCurve::Clone() const {
+  std::unique_ptr<KeyframedColorAnimationCurve> to_return =
+      KeyframedColorAnimationCurve::Create();
+  for (const auto& keyframe : keyframes_)
+    to_return->AddKeyframe(keyframe->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(timing_function_->Clone());
+
+  to_return->set_scaled_duration(scaled_duration());
+
+  return std::move(to_return);
+}
+
+SkColor KeyframedColorAnimationCurve::GetValue(base::TimeDelta t) const {
+  if (t <= (keyframes_.front()->Time() * scaled_duration()))
+    return keyframes_.front()->Value();
+
+  if (t >= (keyframes_.back()->Time() * scaled_duration()))
+    return keyframes_.back()->Value();
+
+  t = TransformedAnimationTime(keyframes_, timing_function_, scaled_duration(),
+                               t);
+  size_t i = GetActiveKeyframe(keyframes_, scaled_duration(), t);
+  double progress =
+      TransformedKeyframeProgress(keyframes_, scaled_duration(), t, i);
+
+  return gfx::Tween::ColorValueBetween(progress, keyframes_[i]->Value(),
+                                       keyframes_[i + 1]->Value());
+}
+
+std::unique_ptr<AnimationCurve> KeyframedColorAnimationCurve::Retarget(
+    base::TimeDelta t,
+    SkColor new_target) {
+  DCHECK(!keyframes_.empty());
+  return RetargettedCurve(keyframes_, t, GetValue(t), new_target,
+                          scaled_duration(), target(), timing_function_.get());
+}
+
+std::unique_ptr<KeyframedFloatAnimationCurve>
+KeyframedFloatAnimationCurve::Create() {
+  return base::WrapUnique(new KeyframedFloatAnimationCurve);
+}
+
+KeyframedFloatAnimationCurve::KeyframedFloatAnimationCurve()
+    : scaled_duration_(1.0) {}
+
+KeyframedFloatAnimationCurve::~KeyframedFloatAnimationCurve() = default;
+
+void KeyframedFloatAnimationCurve::AddKeyframe(
+    std::unique_ptr<FloatKeyframe> keyframe) {
+  InsertKeyframe(std::move(keyframe), &keyframes_);
+}
+
+base::TimeDelta KeyframedFloatAnimationCurve::Duration() const {
+  return (keyframes_.back()->Time() - keyframes_.front()->Time()) *
+         scaled_duration();
+}
+
+base::TimeDelta KeyframedFloatAnimationCurve::TickInterval() const {
+  return ComputeTickInterval(timing_function_, scaled_duration(), keyframes_);
+}
+
+std::unique_ptr<AnimationCurve> KeyframedFloatAnimationCurve::Clone() const {
+  std::unique_ptr<KeyframedFloatAnimationCurve> to_return =
+      KeyframedFloatAnimationCurve::Create();
+  for (const auto& keyframe : keyframes_)
+    to_return->AddKeyframe(keyframe->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(timing_function_->Clone());
+
+  to_return->set_scaled_duration(scaled_duration());
+
+  return std::move(to_return);
+}
+
+std::unique_ptr<AnimationCurve> KeyframedFloatAnimationCurve::Retarget(
+    base::TimeDelta t,
+    float new_target) {
+  DCHECK(!keyframes_.empty());
+  return RetargettedCurve(keyframes_, t, GetValue(t), new_target,
+                          scaled_duration(), target(), timing_function_.get());
+}
+
+float KeyframedFloatAnimationCurve::GetValue(base::TimeDelta t) const {
+  if (t <= (keyframes_.front()->Time() * scaled_duration()))
+    return keyframes_.front()->Value();
+
+  if (t >= (keyframes_.back()->Time() * scaled_duration()))
+    return keyframes_.back()->Value();
+
+  t = TransformedAnimationTime(keyframes_, timing_function_, scaled_duration(),
+                               t);
+  size_t i = GetActiveKeyframe(keyframes_, scaled_duration(), t);
+  double progress =
+      TransformedKeyframeProgress(keyframes_, scaled_duration(), t, i);
+
+  return keyframes_[i]->Value() +
+         (keyframes_[i + 1]->Value() - keyframes_[i]->Value()) * progress;
+}
+
+std::unique_ptr<KeyframedTransformAnimationCurve>
+KeyframedTransformAnimationCurve::Create() {
+  return base::WrapUnique(new KeyframedTransformAnimationCurve);
+}
+
+KeyframedTransformAnimationCurve::KeyframedTransformAnimationCurve()
+    : scaled_duration_(1.0) {}
+
+KeyframedTransformAnimationCurve::~KeyframedTransformAnimationCurve() = default;
+
+void KeyframedTransformAnimationCurve::AddKeyframe(
+    std::unique_ptr<TransformKeyframe> keyframe) {
+  InsertKeyframe(std::move(keyframe), &keyframes_);
+}
+
+base::TimeDelta KeyframedTransformAnimationCurve::Duration() const {
+  return (keyframes_.back()->Time() - keyframes_.front()->Time()) *
+         scaled_duration();
+}
+
+base::TimeDelta KeyframedTransformAnimationCurve::TickInterval() const {
+  return ComputeTickInterval(timing_function_, scaled_duration(), keyframes_);
+}
+
+std::unique_ptr<AnimationCurve> KeyframedTransformAnimationCurve::Clone()
+    const {
+  std::unique_ptr<KeyframedTransformAnimationCurve> to_return =
+      KeyframedTransformAnimationCurve::Create();
+  for (const auto& keyframe : keyframes_)
+    to_return->AddKeyframe(keyframe->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(timing_function_->Clone());
+
+  to_return->set_scaled_duration(scaled_duration());
+
+  return std::move(to_return);
+}
+
+gfx::TransformOperations KeyframedTransformAnimationCurve::GetValue(
+    base::TimeDelta t) const {
+  if (t <= (keyframes_.front()->Time() * scaled_duration()))
+    return keyframes_.front()->Value();
+
+  if (t >= (keyframes_.back()->Time() * scaled_duration()))
+    return keyframes_.back()->Value();
+
+  t = TransformedAnimationTime(keyframes_, timing_function_, scaled_duration(),
+                               t);
+  size_t i = GetActiveKeyframe(keyframes_, scaled_duration(), t);
+  double progress =
+      TransformedKeyframeProgress(keyframes_, scaled_duration(), t, i);
+
+  return keyframes_[i + 1]->Value().Blend(keyframes_[i]->Value(), progress);
+}
+
+bool KeyframedTransformAnimationCurve::PreservesAxisAlignment() const {
+  for (const auto& keyframe : keyframes_) {
+    if (!keyframe->Value().PreservesAxisAlignment())
+      return false;
+  }
+  return true;
+}
+
+bool KeyframedTransformAnimationCurve::MaximumScale(float* max_scale) const {
+  DCHECK_GE(keyframes_.size(), 2ul);
+  *max_scale = 0.f;
+  for (auto& keyframe : keyframes_) {
+    float keyframe_scale = 0.f;
+    if (!keyframe->Value().ScaleComponent(&keyframe_scale))
+      continue;
+    *max_scale = std::max(*max_scale, keyframe_scale);
+  }
+  return *max_scale > 0.f;
+}
+
+std::unique_ptr<AnimationCurve> KeyframedTransformAnimationCurve::Retarget(
+    base::TimeDelta t,
+    const gfx::TransformOperations& new_target) {
+  DCHECK(!keyframes_.empty());
+  return RetargettedCurve(keyframes_, t, GetValue(t), new_target,
+                          scaled_duration(), target(), timing_function_.get());
+}
+
+std::unique_ptr<KeyframedSizeAnimationCurve>
+KeyframedSizeAnimationCurve::Create() {
+  return base::WrapUnique(new KeyframedSizeAnimationCurve);
+}
+
+KeyframedSizeAnimationCurve::KeyframedSizeAnimationCurve()
+    : scaled_duration_(1.0) {}
+
+KeyframedSizeAnimationCurve::~KeyframedSizeAnimationCurve() = default;
+
+void KeyframedSizeAnimationCurve::AddKeyframe(
+    std::unique_ptr<SizeKeyframe> keyframe) {
+  InsertKeyframe(std::move(keyframe), &keyframes_);
+}
+
+base::TimeDelta KeyframedSizeAnimationCurve::Duration() const {
+  return (keyframes_.back()->Time() - keyframes_.front()->Time()) *
+         scaled_duration();
+}
+
+base::TimeDelta KeyframedSizeAnimationCurve::TickInterval() const {
+  return ComputeTickInterval(timing_function_, scaled_duration(), keyframes_);
+}
+
+std::unique_ptr<AnimationCurve> KeyframedSizeAnimationCurve::Clone() const {
+  std::unique_ptr<KeyframedSizeAnimationCurve> to_return =
+      KeyframedSizeAnimationCurve::Create();
+  for (const auto& keyframe : keyframes_)
+    to_return->AddKeyframe(keyframe->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(timing_function_->Clone());
+
+  to_return->set_scaled_duration(scaled_duration());
+
+  return std::move(to_return);
+}
+
+gfx::SizeF KeyframedSizeAnimationCurve::GetValue(base::TimeDelta t) const {
+  if (t <= (keyframes_.front()->Time() * scaled_duration()))
+    return keyframes_.front()->Value();
+
+  if (t >= (keyframes_.back()->Time() * scaled_duration()))
+    return keyframes_.back()->Value();
+
+  t = TransformedAnimationTime(keyframes_, timing_function_, scaled_duration(),
+                               t);
+  size_t i = GetActiveKeyframe(keyframes_, scaled_duration(), t);
+  double progress =
+      TransformedKeyframeProgress(keyframes_, scaled_duration(), t, i);
+
+  return gfx::Tween::SizeFValueBetween(progress, keyframes_[i]->Value(),
+                                       keyframes_[i + 1]->Value());
+}
+
+std::unique_ptr<AnimationCurve> KeyframedSizeAnimationCurve::Retarget(
+    base::TimeDelta t,
+    const gfx::SizeF& new_target) {
+  DCHECK(!keyframes_.empty());
+  return RetargettedCurve(keyframes_, t, GetValue(t), new_target,
+                          scaled_duration(), target(), timing_function_.get());
+}
+
+std::unique_ptr<KeyframedRectAnimationCurve>
+KeyframedRectAnimationCurve::Create() {
+  return base::WrapUnique(new KeyframedRectAnimationCurve);
+}
+
+KeyframedRectAnimationCurve::KeyframedRectAnimationCurve()
+    : scaled_duration_(1.0) {}
+
+KeyframedRectAnimationCurve::~KeyframedRectAnimationCurve() = default;
+
+void KeyframedRectAnimationCurve::AddKeyframe(
+    std::unique_ptr<RectKeyframe> keyframe) {
+  InsertKeyframe(std::move(keyframe), &keyframes_);
+}
+
+base::TimeDelta KeyframedRectAnimationCurve::Duration() const {
+  return (keyframes_.back()->Time() - keyframes_.front()->Time()) *
+         scaled_duration();
+}
+
+base::TimeDelta KeyframedRectAnimationCurve::TickInterval() const {
+  return ComputeTickInterval(timing_function_, scaled_duration(), keyframes_);
+}
+
+std::unique_ptr<AnimationCurve> KeyframedRectAnimationCurve::Clone() const {
+  std::unique_ptr<KeyframedRectAnimationCurve> to_return =
+      KeyframedRectAnimationCurve::Create();
+  for (const auto& keyframe : keyframes_)
+    to_return->AddKeyframe(keyframe->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(timing_function_->Clone());
+
+  to_return->set_scaled_duration(scaled_duration());
+
+  return std::move(to_return);
+}
+
+gfx::Rect KeyframedRectAnimationCurve::GetValue(base::TimeDelta t) const {
+  if (t <= (keyframes_.front()->Time() * scaled_duration()))
+    return keyframes_.front()->Value();
+
+  if (t >= (keyframes_.back()->Time() * scaled_duration()))
+    return keyframes_.back()->Value();
+
+  t = TransformedAnimationTime(keyframes_, timing_function_, scaled_duration(),
+                               t);
+  size_t i = GetActiveKeyframe(keyframes_, scaled_duration(), t);
+  double progress =
+      TransformedKeyframeProgress(keyframes_, scaled_duration(), t, i);
+
+  return gfx::Tween::RectValueBetween(progress, keyframes_[i]->Value(),
+                                      keyframes_[i + 1]->Value());
+}
+
+std::unique_ptr<AnimationCurve> KeyframedRectAnimationCurve::Retarget(
+    base::TimeDelta t,
+    const gfx::Rect& new_target) {
+  DCHECK(!keyframes_.empty());
+  return RetargettedCurve(keyframes_, t, GetValue(t), new_target,
+                          scaled_duration(), target(), timing_function_.get());
+}
+
+bool SufficientlyEqual(float lhs, float rhs) {
+  return base::IsApproximatelyEqual(lhs, rhs, kTolerance);
+}
+
+bool SufficientlyEqual(const TransformOperations& lhs,
+                       const TransformOperations& rhs) {
+  return lhs.ApproximatelyEqual(rhs, kTolerance);
+}
+
+bool SufficientlyEqual(const SizeF& lhs, const SizeF& rhs) {
+  return base::IsApproximatelyEqual(lhs.width(), rhs.width(), kTolerance) &&
+         base::IsApproximatelyEqual(lhs.height(), rhs.height(), kTolerance);
+}
+
+bool SufficientlyEqual(SkColor lhs, SkColor rhs) {
+  return lhs == rhs;
+}
+
+bool SufficientlyEqual(const Rect& lhs, const Rect& rhs) {
+  return lhs == rhs;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/keyframed_animation_curve.h b/ui/gfx/animation/keyframe/keyframed_animation_curve.h
new file mode 100644
index 0000000..9a292b5
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframed_animation_curve.h
@@ -0,0 +1,413 @@
+// Copyright 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_KEYFRAMED_ANIMATION_CURVE_H_
+#define UI_GFX_ANIMATION_KEYFRAME_KEYFRAMED_ANIMATION_CURVE_H_
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "base/time/time.h"
+#include "ui/gfx/animation/keyframe/animation_curve.h"
+#include "ui/gfx/animation/keyframe/keyframe_animation_export.h"
+#include "ui/gfx/animation/keyframe/timing_function.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/transform_operations.h"
+
+namespace gfx {
+
+class GFX_KEYFRAME_ANIMATION_EXPORT Keyframe {
+ public:
+  Keyframe(const Keyframe&) = delete;
+  Keyframe& operator=(const Keyframe&) = delete;
+
+  base::TimeDelta Time() const;
+  const TimingFunction* timing_function() const {
+    return timing_function_.get();
+  }
+
+ protected:
+  Keyframe(base::TimeDelta time,
+           std::unique_ptr<TimingFunction> timing_function);
+  virtual ~Keyframe();
+
+ private:
+  base::TimeDelta time_;
+  std::unique_ptr<TimingFunction> timing_function_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT ColorKeyframe : public Keyframe {
+ public:
+  static std::unique_ptr<ColorKeyframe> Create(
+      base::TimeDelta time,
+      SkColor value,
+      std::unique_ptr<TimingFunction> timing_function);
+  ~ColorKeyframe() override;
+
+  SkColor Value() const;
+
+  std::unique_ptr<ColorKeyframe> Clone() const;
+
+ private:
+  ColorKeyframe(base::TimeDelta time,
+                SkColor value,
+                std::unique_ptr<TimingFunction> timing_function);
+
+  SkColor value_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT FloatKeyframe : public Keyframe {
+ public:
+  static std::unique_ptr<FloatKeyframe> Create(
+      base::TimeDelta time,
+      float value,
+      std::unique_ptr<TimingFunction> timing_function);
+  ~FloatKeyframe() override;
+
+  float Value() const;
+
+  std::unique_ptr<FloatKeyframe> Clone() const;
+
+ private:
+  FloatKeyframe(base::TimeDelta time,
+                float value,
+                std::unique_ptr<TimingFunction> timing_function);
+
+  float value_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT TransformKeyframe : public Keyframe {
+ public:
+  static std::unique_ptr<TransformKeyframe> Create(
+      base::TimeDelta time,
+      const gfx::TransformOperations& value,
+      std::unique_ptr<TimingFunction> timing_function);
+  ~TransformKeyframe() override;
+
+  const gfx::TransformOperations& Value() const;
+
+  std::unique_ptr<TransformKeyframe> Clone() const;
+
+ private:
+  TransformKeyframe(base::TimeDelta time,
+                    const gfx::TransformOperations& value,
+                    std::unique_ptr<TimingFunction> timing_function);
+
+  gfx::TransformOperations value_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT SizeKeyframe : public Keyframe {
+ public:
+  static std::unique_ptr<SizeKeyframe> Create(
+      base::TimeDelta time,
+      const gfx::SizeF& bounds,
+      std::unique_ptr<TimingFunction> timing_function);
+  ~SizeKeyframe() override;
+
+  const gfx::SizeF& Value() const;
+
+  std::unique_ptr<SizeKeyframe> Clone() const;
+
+ private:
+  SizeKeyframe(base::TimeDelta time,
+               const gfx::SizeF& value,
+               std::unique_ptr<TimingFunction> timing_function);
+
+  gfx::SizeF value_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT RectKeyframe : public Keyframe {
+ public:
+  static std::unique_ptr<RectKeyframe> Create(
+      base::TimeDelta time,
+      const gfx::Rect& value,
+      std::unique_ptr<TimingFunction> timing_function);
+  ~RectKeyframe() override;
+
+  const gfx::Rect& Value() const;
+
+  std::unique_ptr<RectKeyframe> Clone() const;
+
+ private:
+  RectKeyframe(base::TimeDelta time,
+               const gfx::Rect& value,
+               std::unique_ptr<TimingFunction> timing_function);
+
+  gfx::Rect value_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT KeyframedColorAnimationCurve
+    : public ColorAnimationCurve {
+ public:
+  // It is required that the keyframes be sorted by time.
+  static std::unique_ptr<KeyframedColorAnimationCurve> Create();
+
+  KeyframedColorAnimationCurve(const KeyframedColorAnimationCurve&) = delete;
+  ~KeyframedColorAnimationCurve() override;
+
+  KeyframedColorAnimationCurve& operator=(const KeyframedColorAnimationCurve&) =
+      delete;
+
+  void AddKeyframe(std::unique_ptr<ColorKeyframe> keyframe);
+  void SetTimingFunction(std::unique_ptr<TimingFunction> timing_function) {
+    timing_function_ = std::move(timing_function);
+  }
+  double scaled_duration() const { return scaled_duration_; }
+  void set_scaled_duration(double scaled_duration) {
+    scaled_duration_ = scaled_duration;
+  }
+
+  // AnimationCurve implementation
+  base::TimeDelta Duration() const override;
+  std::unique_ptr<AnimationCurve> Clone() const override;
+  base::TimeDelta TickInterval() const override;
+
+  // BackgrounColorAnimationCurve implementation
+  SkColor GetValue(base::TimeDelta t) const override;
+
+  std::unique_ptr<AnimationCurve> Retarget(base::TimeDelta t,
+                                           SkColor new_target);
+
+  using Keyframes = std::vector<std::unique_ptr<ColorKeyframe>>;
+  const Keyframes& keyframes_for_testing() const { return keyframes_; }
+
+ private:
+  KeyframedColorAnimationCurve();
+
+  // Always sorted in order of increasing time. No two keyframes have the
+  // same time.
+  Keyframes keyframes_;
+  std::unique_ptr<TimingFunction> timing_function_;
+  double scaled_duration_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT KeyframedFloatAnimationCurve
+    : public FloatAnimationCurve {
+ public:
+  // It is required that the keyframes be sorted by time.
+  static std::unique_ptr<KeyframedFloatAnimationCurve> Create();
+
+  KeyframedFloatAnimationCurve(const KeyframedFloatAnimationCurve&) = delete;
+  ~KeyframedFloatAnimationCurve() override;
+
+  KeyframedFloatAnimationCurve& operator=(const KeyframedFloatAnimationCurve&) =
+      delete;
+
+  void AddKeyframe(std::unique_ptr<FloatKeyframe> keyframe);
+
+  void SetTimingFunction(std::unique_ptr<TimingFunction> timing_function) {
+    timing_function_ = std::move(timing_function);
+  }
+  TimingFunction* timing_function_for_testing() const {
+    return timing_function_.get();
+  }
+  double scaled_duration() const { return scaled_duration_; }
+  void set_scaled_duration(double scaled_duration) {
+    scaled_duration_ = scaled_duration;
+  }
+
+  // AnimationCurve implementation
+  base::TimeDelta Duration() const override;
+  std::unique_ptr<AnimationCurve> Clone() const override;
+  base::TimeDelta TickInterval() const override;
+
+  // FloatAnimationCurve implementation
+  float GetValue(base::TimeDelta t) const override;
+
+  std::unique_ptr<AnimationCurve> Retarget(base::TimeDelta t, float new_target);
+
+  using Keyframes = std::vector<std::unique_ptr<FloatKeyframe>>;
+  const Keyframes& keyframes_for_testing() const { return keyframes_; }
+
+ private:
+  KeyframedFloatAnimationCurve();
+
+  // Always sorted in order of increasing time. No two keyframes have the
+  // same time.
+  Keyframes keyframes_;
+  std::unique_ptr<TimingFunction> timing_function_;
+  double scaled_duration_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT KeyframedTransformAnimationCurve
+    : public TransformAnimationCurve {
+ public:
+  // It is required that the keyframes be sorted by time.
+  static std::unique_ptr<KeyframedTransformAnimationCurve> Create();
+
+  KeyframedTransformAnimationCurve(const KeyframedTransformAnimationCurve&) =
+      delete;
+  ~KeyframedTransformAnimationCurve() override;
+
+  KeyframedTransformAnimationCurve& operator=(
+      const KeyframedTransformAnimationCurve&) = delete;
+
+  void AddKeyframe(std::unique_ptr<TransformKeyframe> keyframe);
+  void SetTimingFunction(std::unique_ptr<TimingFunction> timing_function) {
+    timing_function_ = std::move(timing_function);
+  }
+  double scaled_duration() const { return scaled_duration_; }
+  void set_scaled_duration(double scaled_duration) {
+    scaled_duration_ = scaled_duration;
+  }
+
+  // AnimationCurve implementation
+  base::TimeDelta Duration() const override;
+  std::unique_ptr<AnimationCurve> Clone() const override;
+  base::TimeDelta TickInterval() const override;
+
+  // TransformAnimationCurve implementation
+  gfx::TransformOperations GetValue(base::TimeDelta t) const override;
+  bool PreservesAxisAlignment() const override;
+  bool MaximumScale(float* max_scale) const override;
+
+  std::unique_ptr<AnimationCurve> Retarget(
+      base::TimeDelta t,
+      const gfx::TransformOperations& new_target);
+
+ private:
+  KeyframedTransformAnimationCurve();
+
+  // Always sorted in order of increasing time. No two keyframes have the
+  // same time.
+  std::vector<std::unique_ptr<TransformKeyframe>> keyframes_;
+  std::unique_ptr<TimingFunction> timing_function_;
+  double scaled_duration_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT KeyframedSizeAnimationCurve
+    : public SizeAnimationCurve {
+ public:
+  // It is required that the keyframes be sorted by time.
+  static std::unique_ptr<KeyframedSizeAnimationCurve> Create();
+
+  KeyframedSizeAnimationCurve(const KeyframedSizeAnimationCurve&) = delete;
+  ~KeyframedSizeAnimationCurve() override;
+
+  KeyframedSizeAnimationCurve& operator=(const KeyframedSizeAnimationCurve&) =
+      delete;
+
+  void AddKeyframe(std::unique_ptr<SizeKeyframe> keyframe);
+  void SetTimingFunction(std::unique_ptr<TimingFunction> timing_function) {
+    timing_function_ = std::move(timing_function);
+  }
+  double scaled_duration() const { return scaled_duration_; }
+  void set_scaled_duration(double scaled_duration) {
+    scaled_duration_ = scaled_duration;
+  }
+
+  // AnimationCurve implementation
+  base::TimeDelta Duration() const override;
+  std::unique_ptr<AnimationCurve> Clone() const override;
+  base::TimeDelta TickInterval() const override;
+
+  // SizeAnimationCurve implementation
+  gfx::SizeF GetValue(base::TimeDelta t) const override;
+
+  std::unique_ptr<AnimationCurve> Retarget(base::TimeDelta t,
+                                           const gfx::SizeF& new_target);
+
+ private:
+  KeyframedSizeAnimationCurve();
+
+  // Always sorted in order of increasing time. No two keyframes have the
+  // same time.
+  std::vector<std::unique_ptr<SizeKeyframe>> keyframes_;
+  std::unique_ptr<TimingFunction> timing_function_;
+  double scaled_duration_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT KeyframedRectAnimationCurve
+    : public RectAnimationCurve {
+ public:
+  // It is required that the keyframes be sorted by time.
+  static std::unique_ptr<KeyframedRectAnimationCurve> Create();
+
+  KeyframedRectAnimationCurve(const KeyframedRectAnimationCurve&) = delete;
+  ~KeyframedRectAnimationCurve() override;
+
+  KeyframedRectAnimationCurve& operator=(const KeyframedRectAnimationCurve&) =
+      delete;
+
+  void AddKeyframe(std::unique_ptr<RectKeyframe> keyframe);
+  void SetTimingFunction(std::unique_ptr<TimingFunction> timing_function) {
+    timing_function_ = std::move(timing_function);
+  }
+  double scaled_duration() const { return scaled_duration_; }
+  void set_scaled_duration(double scaled_duration) {
+    scaled_duration_ = scaled_duration;
+  }
+
+  // AnimationCurve implementation
+  base::TimeDelta Duration() const override;
+  std::unique_ptr<AnimationCurve> Clone() const override;
+  base::TimeDelta TickInterval() const override;
+
+  // RectAnimationCurve implementation
+  gfx::Rect GetValue(base::TimeDelta t) const override;
+
+  std::unique_ptr<AnimationCurve> Retarget(base::TimeDelta t,
+                                           const gfx::Rect& new_target);
+
+ private:
+  KeyframedRectAnimationCurve();
+
+  // Always sorted in order of increasing time. No two keyframes have the
+  // same time.
+  std::vector<std::unique_ptr<RectKeyframe>> keyframes_;
+  std::unique_ptr<TimingFunction> timing_function_;
+  double scaled_duration_ = 0.;
+};
+
+template <typename T>
+struct AnimationTraits {};
+
+#define DEFINE_ANIMATION_TRAITS(value_type, name)                           \
+  template <>                                                               \
+  struct AnimationTraits<value_type> {                                      \
+    typedef value_type ValueType;                                           \
+    typedef name##AnimationCurve::Target TargetType;                        \
+    typedef name##AnimationCurve CurveType;                                 \
+    typedef Keyframed##name##AnimationCurve KeyframedCurveType;             \
+    typedef name##Keyframe KeyframeType;                                    \
+    static const CurveType* ToDerivedCurve(const AnimationCurve* curve) {   \
+      return name##AnimationCurve::To##name##AnimationCurve(curve);         \
+    }                                                                       \
+    static CurveType* ToDerivedCurve(AnimationCurve* curve) {               \
+      return name##AnimationCurve::To##name##AnimationCurve(curve);         \
+    }                                                                       \
+    static const KeyframedCurveType* ToKeyframedCurve(                      \
+        const AnimationCurve* curve) {                                      \
+      return static_cast<const KeyframedCurveType*>(ToDerivedCurve(curve)); \
+    }                                                                       \
+    static KeyframedCurveType* ToKeyframedCurve(AnimationCurve* curve) {    \
+      return static_cast<KeyframedCurveType*>(ToDerivedCurve(curve));       \
+    }                                                                       \
+    static void OnValueAnimated(name##AnimationCurve::Target* target,       \
+                                const ValueType& target_value,              \
+                                int target_property) {                      \
+      target->On##name##Animated(target_value, target_property, nullptr);   \
+    }                                                                       \
+  }
+
+DEFINE_ANIMATION_TRAITS(float, Float);
+DEFINE_ANIMATION_TRAITS(TransformOperations, Transform);
+DEFINE_ANIMATION_TRAITS(SizeF, Size);
+DEFINE_ANIMATION_TRAITS(SkColor, Color);
+DEFINE_ANIMATION_TRAITS(Rect, Rect);
+
+#undef DEFINE_ANIMATION_TRAITS
+
+bool SufficientlyEqual(float lhs, float rhs);
+bool SufficientlyEqual(const TransformOperations& lhs,
+                       const TransformOperations& rhs);
+bool SufficientlyEqual(const SizeF& lhs, const SizeF& rhs);
+bool SufficientlyEqual(SkColor lhs, SkColor rhs);
+bool SufficientlyEqual(const Rect& lhs, const Rect& rhs);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_KEYFRAMED_ANIMATION_CURVE_H_
diff --git a/ui/gfx/animation/keyframe/keyframed_animation_curve_unittest.cc b/ui/gfx/animation/keyframe/keyframed_animation_curve_unittest.cc
new file mode 100644
index 0000000..2153163
--- /dev/null
+++ b/ui/gfx/animation/keyframe/keyframed_animation_curve_unittest.cc
@@ -0,0 +1,991 @@
+// Copyright 2012 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.
+
+#include "ui/gfx/animation/keyframe/keyframed_animation_curve.h"
+
+#include <memory>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/animation/tween.h"
+#include "ui/gfx/geometry/box_f.h"
+#include "ui/gfx/geometry/test/transform_test_util.h"
+#include "ui/gfx/geometry/transform_operations.h"
+#include "ui/gfx/test/gfx_util.h"
+
+namespace gfx {
+namespace {
+
+void ExpectTranslateX(SkScalar translate_x,
+                      const gfx::TransformOperations& operations) {
+  EXPECT_FLOAT_EQ(translate_x, operations.Apply().matrix().get(0, 3));
+}
+
+// Tests that a color animation with one keyframe works as expected.
+TEST(KeyframedAnimationCurveTest, OneColorKeyFrame) {
+  SkColor color = SkColorSetARGB(255, 255, 255, 255);
+  std::unique_ptr<KeyframedColorAnimationCurve> curve(
+      KeyframedColorAnimationCurve::Create());
+  curve->AddKeyframe(ColorKeyframe::Create(base::TimeDelta(), color, nullptr));
+
+  EXPECT_SKCOLOR_EQ(color, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_SKCOLOR_EQ(color, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_SKCOLOR_EQ(color, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_SKCOLOR_EQ(color, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_SKCOLOR_EQ(color, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a color animation with two keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, TwoColorKeyFrame) {
+  SkColor color_a = SkColorSetARGB(255, 255, 0, 0);
+  SkColor color_b = SkColorSetARGB(255, 0, 255, 0);
+  SkColor color_midpoint = gfx::Tween::ColorValueBetween(0.5, color_a, color_b);
+  std::unique_ptr<KeyframedColorAnimationCurve> curve(
+      KeyframedColorAnimationCurve::Create());
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::TimeDelta(), color_a, nullptr));
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::Seconds(1.0), color_b, nullptr));
+
+  EXPECT_SKCOLOR_EQ(color_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_SKCOLOR_EQ(color_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_SKCOLOR_EQ(color_midpoint, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_SKCOLOR_EQ(color_b, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_SKCOLOR_EQ(color_b, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a color animation with three keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, ThreeColorKeyFrame) {
+  SkColor color_a = SkColorSetARGB(255, 255, 0, 0);
+  SkColor color_b = SkColorSetARGB(255, 0, 255, 0);
+  SkColor color_c = SkColorSetARGB(255, 0, 0, 255);
+  SkColor color_midpoint1 =
+      gfx::Tween::ColorValueBetween(0.5, color_a, color_b);
+  SkColor color_midpoint2 =
+      gfx::Tween::ColorValueBetween(0.5, color_b, color_c);
+  std::unique_ptr<KeyframedColorAnimationCurve> curve(
+      KeyframedColorAnimationCurve::Create());
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::TimeDelta(), color_a, nullptr));
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::Seconds(1.0), color_b, nullptr));
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::Seconds(2.0), color_c, nullptr));
+
+  EXPECT_SKCOLOR_EQ(color_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_SKCOLOR_EQ(color_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_SKCOLOR_EQ(color_midpoint1, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_SKCOLOR_EQ(color_b, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_SKCOLOR_EQ(color_midpoint2, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_SKCOLOR_EQ(color_c, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_SKCOLOR_EQ(color_c, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a color animation with multiple keys at a given time works sanely.
+TEST(KeyframedAnimationCurveTest, RepeatedColorKeyFrame) {
+  SkColor color_a = SkColorSetARGB(255, 64, 0, 0);
+  SkColor color_b = SkColorSetARGB(255, 192, 0, 0);
+
+  std::unique_ptr<KeyframedColorAnimationCurve> curve(
+      KeyframedColorAnimationCurve::Create());
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::TimeDelta(), color_a, nullptr));
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::Seconds(1.0), color_a, nullptr));
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::Seconds(1.0), color_b, nullptr));
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::Seconds(2.0), color_b, nullptr));
+
+  EXPECT_SKCOLOR_EQ(color_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_SKCOLOR_EQ(color_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_SKCOLOR_EQ(color_a, curve->GetValue(base::Seconds(0.5f)));
+
+  SkColor value = curve->GetValue(base::Seconds(1.0f));
+  EXPECT_EQ(255u, SkColorGetA(value));
+  int red_value = SkColorGetR(value);
+  EXPECT_LE(64, red_value);
+  EXPECT_GE(192, red_value);
+
+  EXPECT_SKCOLOR_EQ(color_b, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_SKCOLOR_EQ(color_b, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_SKCOLOR_EQ(color_b, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a float animation with one keyframe works as expected.
+TEST(KeyframedAnimationCurveTest, OneFloatKeyframe) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 2.f, nullptr));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a float animation with two keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, TwoFloatKeyframe) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 2.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 4.f, nullptr));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_FLOAT_EQ(3.f, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_FLOAT_EQ(4.f, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_FLOAT_EQ(4.f, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a float animation with three keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, ThreeFloatKeyframe) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 2.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 4.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(2.0), 8.f, nullptr));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_FLOAT_EQ(3.f, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_FLOAT_EQ(4.f, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_FLOAT_EQ(6.f, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_FLOAT_EQ(8.f, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_FLOAT_EQ(8.f, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a float animation with multiple keys at a given time works sanely.
+TEST(KeyframedAnimationCurveTest, RepeatedFloatKeyTimes) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 4.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 4.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 6.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(2.0), 6.f, nullptr));
+
+  EXPECT_FLOAT_EQ(4.f, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_FLOAT_EQ(4.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_FLOAT_EQ(4.f, curve->GetValue(base::Seconds(0.5f)));
+
+  // There is a discontinuity at 1. Any value between 4 and 6 is valid.
+  float value = curve->GetValue(base::Seconds(1.f));
+  EXPECT_TRUE(value >= 4 && value <= 6);
+
+  EXPECT_FLOAT_EQ(6.f, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_FLOAT_EQ(6.f, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_FLOAT_EQ(6.f, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a transform animation with one keyframe works as expected.
+TEST(KeyframedAnimationCurveTest, OneTransformKeyframe) {
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+  gfx::TransformOperations operations;
+  operations.AppendTranslate(2.f, 0.f, 0.f);
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), operations, nullptr));
+
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(-1.f)));
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(0.f)));
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(0.5f)));
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(1.f)));
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a transform animation with two keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, TwoTransformKeyframe) {
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+  gfx::TransformOperations operations1;
+  operations1.AppendTranslate(2.f, 0.f, 0.f);
+  gfx::TransformOperations operations2;
+  operations2.AppendTranslate(4.f, 0.f, 0.f);
+
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::Seconds(1.0), operations2, nullptr));
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(-1.f)));
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(0.f)));
+  ExpectTranslateX(3.f, curve->GetValue(base::Seconds(0.5f)));
+  ExpectTranslateX(4.f, curve->GetValue(base::Seconds(1.f)));
+  ExpectTranslateX(4.f, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a transform animation with three keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, ThreeTransformKeyframe) {
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+  gfx::TransformOperations operations1;
+  operations1.AppendTranslate(2.f, 0.f, 0.f);
+  gfx::TransformOperations operations2;
+  operations2.AppendTranslate(4.f, 0.f, 0.f);
+  gfx::TransformOperations operations3;
+  operations3.AppendTranslate(8.f, 0.f, 0.f);
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::Seconds(1.0), operations2, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::Seconds(2.0), operations3, nullptr));
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(-1.f)));
+  ExpectTranslateX(2.f, curve->GetValue(base::Seconds(0.f)));
+  ExpectTranslateX(3.f, curve->GetValue(base::Seconds(0.5f)));
+  ExpectTranslateX(4.f, curve->GetValue(base::Seconds(1.f)));
+  ExpectTranslateX(6.f, curve->GetValue(base::Seconds(1.5f)));
+  ExpectTranslateX(8.f, curve->GetValue(base::Seconds(2.f)));
+  ExpectTranslateX(8.f, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a transform animation with multiple keys at a given time works
+// sanely.
+TEST(KeyframedAnimationCurveTest, RepeatedTransformKeyTimes) {
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+  // A step function.
+  gfx::TransformOperations operations1;
+  operations1.AppendTranslate(4.f, 0.f, 0.f);
+  gfx::TransformOperations operations2;
+  operations2.AppendTranslate(4.f, 0.f, 0.f);
+  gfx::TransformOperations operations3;
+  operations3.AppendTranslate(6.f, 0.f, 0.f);
+  gfx::TransformOperations operations4;
+  operations4.AppendTranslate(6.f, 0.f, 0.f);
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::Seconds(1.0), operations2, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::Seconds(1.0), operations3, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::Seconds(2.0), operations4, nullptr));
+
+  ExpectTranslateX(4.f, curve->GetValue(base::Seconds(-1.f)));
+  ExpectTranslateX(4.f, curve->GetValue(base::Seconds(0.f)));
+  ExpectTranslateX(4.f, curve->GetValue(base::Seconds(0.5f)));
+
+  // There is a discontinuity at 1. Any value between 4 and 6 is valid.
+  gfx::Transform value = curve->GetValue(base::Seconds(1.f)).Apply();
+  EXPECT_GE(value.matrix().get(0, 3), 4.f);
+  EXPECT_LE(value.matrix().get(0, 3), 6.f);
+
+  ExpectTranslateX(6.f, curve->GetValue(base::Seconds(1.5f)));
+  ExpectTranslateX(6.f, curve->GetValue(base::Seconds(2.f)));
+  ExpectTranslateX(6.f, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a discrete transform animation (e.g. where one or more keyframes
+// is a non-invertible matrix) works as expected.
+TEST(KeyframedAnimationCurveTest, DiscreteLinearTransformAnimation) {
+  gfx::Transform non_invertible_matrix(0, 0, 0, 0, 0, 0);
+  gfx::Transform identity_matrix;
+
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+  gfx::TransformOperations operations1;
+  operations1.AppendMatrix(non_invertible_matrix);
+  gfx::TransformOperations operations2;
+  operations2.AppendMatrix(identity_matrix);
+  gfx::TransformOperations operations3;
+  operations3.AppendMatrix(non_invertible_matrix);
+
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::Seconds(1.0), operations2, nullptr));
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::Seconds(2.0), operations3, nullptr));
+
+  gfx::TransformOperations result;
+
+  // Between 0 and 0.5 seconds, the first keyframe should be returned.
+  result = curve->GetValue(base::Seconds(0.01f));
+  ExpectTransformationMatrixEq(non_invertible_matrix, result.Apply());
+
+  result = curve->GetValue(base::Seconds(0.49f));
+  ExpectTransformationMatrixEq(non_invertible_matrix, result.Apply());
+
+  // Between 0.5 and 1.5 seconds, the middle keyframe should be returned.
+  result = curve->GetValue(base::Seconds(0.5f));
+  ExpectTransformationMatrixEq(identity_matrix, result.Apply());
+
+  result = curve->GetValue(base::Seconds(1.49f));
+  ExpectTransformationMatrixEq(identity_matrix, result.Apply());
+
+  // Between 1.5 and 2.0 seconds, the last keyframe should be returned.
+  result = curve->GetValue(base::Seconds(1.5f));
+  ExpectTransformationMatrixEq(non_invertible_matrix, result.Apply());
+
+  result = curve->GetValue(base::Seconds(2.0f));
+  ExpectTransformationMatrixEq(non_invertible_matrix, result.Apply());
+}
+
+TEST(KeyframedAnimationCurveTest, DiscreteCubicBezierTransformAnimation) {
+  gfx::Transform non_invertible_matrix(0, 0, 0, 0, 0, 0);
+  gfx::Transform identity_matrix;
+
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+  gfx::TransformOperations operations1;
+  operations1.AppendMatrix(non_invertible_matrix);
+  gfx::TransformOperations operations2;
+  operations2.AppendMatrix(identity_matrix);
+  gfx::TransformOperations operations3;
+  operations3.AppendMatrix(non_invertible_matrix);
+
+  // The cubic-bezier here is a nice fairly strong ease-in curve, where 50%
+  // progression is at approximately 85% of the time.
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta(), operations1,
+      CubicBezierTimingFunction::Create(0.75f, 0.25f, 0.9f, 0.4f)));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::Seconds(1.0), operations2,
+      CubicBezierTimingFunction::Create(0.75f, 0.25f, 0.9f, 0.4f)));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::Seconds(2.0), operations3,
+      CubicBezierTimingFunction::Create(0.75f, 0.25f, 0.9f, 0.4f)));
+
+  gfx::TransformOperations result;
+
+  // Due to the cubic-bezier, the first keyframe is returned almost all the way
+  // to 1 second.
+  result = curve->GetValue(base::Seconds(0.01f));
+  ExpectTransformationMatrixEq(non_invertible_matrix, result.Apply());
+
+  result = curve->GetValue(base::Seconds(0.8f));
+  ExpectTransformationMatrixEq(non_invertible_matrix, result.Apply());
+
+  // Between ~0.85 and ~1.85 seconds, the middle keyframe should be returned.
+  result = curve->GetValue(base::Seconds(0.85f));
+  ExpectTransformationMatrixEq(identity_matrix, result.Apply());
+
+  result = curve->GetValue(base::Seconds(1.8f));
+  ExpectTransformationMatrixEq(identity_matrix, result.Apply());
+
+  // Finally the last keyframe only takes effect after ~1.85 seconds.
+  result = curve->GetValue(base::Seconds(1.85f));
+  ExpectTransformationMatrixEq(non_invertible_matrix, result.Apply());
+
+  result = curve->GetValue(base::Seconds(2.0f));
+  ExpectTransformationMatrixEq(non_invertible_matrix, result.Apply());
+}
+
+// Tests that the keyframes may be added out of order.
+TEST(KeyframedAnimationCurveTest, UnsortedKeyframes) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(2.f), 8.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 2.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.f), 4.f, nullptr));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_FLOAT_EQ(3.f, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_FLOAT_EQ(4.f, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_FLOAT_EQ(6.f, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_FLOAT_EQ(8.f, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_FLOAT_EQ(8.f, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a linear timing function works as expected.
+TEST(KeyframedAnimationCurveTest, LinearTimingFunction) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f,
+                                           LinearTimingFunction::Create()));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 1.f, nullptr));
+
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_FLOAT_EQ(0.75f, curve->GetValue(base::Seconds(0.75f)));
+}
+
+// Tests that a cubic bezier timing function works as expected.
+TEST(KeyframedAnimationCurveTest, CubicBezierTimingFunction) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      CubicBezierTimingFunction::Create(0.25f, 0.f, 0.75f, 1.f)));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 1.f, nullptr));
+
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_LT(0.f, curve->GetValue(base::Seconds(0.25f)));
+  EXPECT_GT(0.25f, curve->GetValue(base::Seconds(0.25f)));
+  EXPECT_NEAR(curve->GetValue(base::Seconds(0.5f)), 0.5f, 0.00015f);
+  EXPECT_LT(0.75f, curve->GetValue(base::Seconds(0.75f)));
+  EXPECT_GT(1.f, curve->GetValue(base::Seconds(0.75f)));
+  EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::Seconds(1.f)));
+}
+
+// Tests a step timing function if the change of values occur at the start.
+TEST(KeyframedAnimationCurveTest, StepsTimingFunctionStepAtStart) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  const int num_steps = 36;
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      StepsTimingFunction::Create(num_steps,
+                                  StepsTimingFunction::StepPosition::START)));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::Seconds(1.0), num_steps, nullptr));
+
+  const float time_threshold = 0.0001f;
+
+  for (float i = 0.f; i < num_steps; i += 1.f) {
+    const base::TimeDelta time1 = base::Seconds(i / num_steps - time_threshold);
+    const base::TimeDelta time2 = base::Seconds(i / num_steps + time_threshold);
+    EXPECT_FLOAT_EQ(std::ceil(i), curve->GetValue(time1));
+    EXPECT_FLOAT_EQ(std::ceil(i) + 1.f, curve->GetValue(time2));
+  }
+  EXPECT_FLOAT_EQ(num_steps, curve->GetValue(base::Seconds(1.0)));
+
+  for (float i = 0.5f; i <= num_steps; i += 1.0f) {
+    const base::TimeDelta time = base::Seconds(i / num_steps);
+    EXPECT_FLOAT_EQ(std::ceil(i), curve->GetValue(time));
+  }
+}
+
+// Tests a step timing function if the change of values occur at the end.
+TEST(KeyframedAnimationCurveTest, StepsTimingFunctionStepAtEnd) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  const int num_steps = 36;
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      StepsTimingFunction::Create(num_steps,
+                                  StepsTimingFunction::StepPosition::END)));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::Seconds(1.0), num_steps, nullptr));
+
+  const float time_threshold = 0.0001f;
+
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::TimeDelta()));
+  for (float i = 1.f; i <= num_steps; i += 1.f) {
+    const base::TimeDelta time1 = base::Seconds(i / num_steps - time_threshold);
+    const base::TimeDelta time2 = base::Seconds(i / num_steps + time_threshold);
+    EXPECT_FLOAT_EQ(std::floor(i) - 1.f, curve->GetValue(time1));
+    EXPECT_FLOAT_EQ(std::floor(i), curve->GetValue(time2));
+  }
+  EXPECT_FLOAT_EQ(num_steps, curve->GetValue(base::Seconds(1.0)));
+
+  for (float i = 0.5f; i <= num_steps; i += 1.0f) {
+    const base::TimeDelta time = base::Seconds(i / num_steps);
+    EXPECT_FLOAT_EQ(std::floor(i), curve->GetValue(time));
+  }
+}
+
+// Tests that maximum animation scale is computed as expected.
+TEST(KeyframedAnimationCurveTest, MaximumScale) {
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+
+  gfx::TransformOperations operations1;
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
+  operations1.AppendScale(2.f, -3.f, 1.f);
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::Seconds(1.f), operations1,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
+
+  constexpr float kArbitraryScale = 12345.f;
+  float maximum_scale = kArbitraryScale;
+  EXPECT_TRUE(curve->MaximumScale(&maximum_scale));
+  EXPECT_EQ(3.f, maximum_scale);
+
+  gfx::TransformOperations operations2;
+  operations2.AppendScale(6.f, 3.f, 2.f);
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::Seconds(2.f), operations2,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
+
+  maximum_scale = kArbitraryScale;
+  EXPECT_TRUE(curve->MaximumScale(&maximum_scale));
+  EXPECT_EQ(6.f, maximum_scale);
+
+  gfx::TransformOperations operations3;
+  operations3.AppendRotate(1.f, 0.f, 0.f, 90.f);
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::Seconds(3.f), operations3,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
+
+  maximum_scale = kArbitraryScale;
+  EXPECT_TRUE(curve->MaximumScale(&maximum_scale));
+  EXPECT_EQ(6.f, maximum_scale);
+
+  // All scales are used in computing the max.
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
+      KeyframedTransformAnimationCurve::Create());
+
+  gfx::TransformOperations operations5;
+  operations5.AppendScale(0.4f, 0.2f, 0.6f);
+  curve2->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta(), operations5,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
+  gfx::TransformOperations operations6;
+  operations6.AppendScale(0.5f, 0.3f, -0.8f);
+  curve2->AddKeyframe(TransformKeyframe::Create(
+      base::Seconds(1.f), operations6,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
+
+  maximum_scale = kArbitraryScale;
+  EXPECT_TRUE(curve2->MaximumScale(&maximum_scale));
+  EXPECT_EQ(0.8f, maximum_scale);
+}
+
+TEST(KeyframeAnimationCurveTest, NonCalculatableMaximumScale) {
+  auto curve = KeyframedTransformAnimationCurve::Create();
+  gfx::TransformOperations operations4;
+  operations4.AppendPerspective(3.f);
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::Seconds(1.f), operations4,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::Seconds(1.f), operations4,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
+
+  constexpr float kArbitraryScale = 12345.f;
+  float maximum_scale = kArbitraryScale;
+  EXPECT_FALSE(curve->MaximumScale(&maximum_scale));
+
+  // If the scale of any keyframe can be calculated, the keyframes with
+  // non-calculatable scale will be ignored.
+  gfx::TransformOperations operations;
+  operations.AppendScale(0.4f, 0.2f, 0.6f);
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta(), operations,
+      CubicBezierTimingFunction::CreatePreset(
+          CubicBezierTimingFunction::EaseType::EASE)));
+
+  maximum_scale = kArbitraryScale;
+  EXPECT_TRUE(curve->MaximumScale(&maximum_scale));
+  EXPECT_EQ(0.6f, maximum_scale);
+}
+
+// Tests that an animation with a curve timing function works as expected.
+TEST(KeyframedAnimationCurveTest, CurveTiming) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.f), 1.f, nullptr));
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.75f, 0.f, 0.25f, 1.f));
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_NEAR(0.05f, curve->GetValue(base::Seconds(0.25f)), 0.005f);
+  EXPECT_FLOAT_EQ(0.5f, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_NEAR(0.95f, curve->GetValue(base::Seconds(0.75f)), 0.005f);
+  EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that an animation with a curve and keyframe timing function works as
+// expected.
+TEST(KeyframedAnimationCurveTest, CurveAndKeyframeTiming) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      CubicBezierTimingFunction::Create(0.35f, 0.f, 0.65f, 1.f)));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.f), 1.f, nullptr));
+  // Curve timing function producing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f));
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_FLOAT_EQ(
+      0.f, curve->GetValue(base::Seconds(0.25f)));  // Clamped. c(.25) < 0
+  EXPECT_NEAR(0.17f, curve->GetValue(base::Seconds(0.42f)),
+              0.005f);  // c(.42)=.27, k(.27)=.17
+  EXPECT_FLOAT_EQ(0.5f, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_NEAR(0.83f, curve->GetValue(base::Seconds(0.58f)),
+              0.005f);  // c(.58)=.73, k(.73)=.83
+  EXPECT_FLOAT_EQ(
+      1.f, curve->GetValue(base::Seconds(0.75f)));  // Clamped. c(.75) > 1
+  EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_FLOAT_EQ(1.f, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a linear timing function works as expected for inputs outside of
+// range [0,1]
+TEST(KeyframedAnimationCurveTest, LinearTimingInputsOutsideZeroOneRange) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 2.f, nullptr));
+  // Curve timing function producing timing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f));
+
+  EXPECT_NEAR(-0.076f, curve->GetValue(base::Seconds(0.25f)), 0.001f);
+  EXPECT_NEAR(2.076f, curve->GetValue(base::Seconds(0.75f)), 0.001f);
+}
+
+// If a curve cubic-bezier timing function produces timing outputs outside
+// the range [0, 1] then a keyframe cubic-bezier timing function
+// should consume that input properly (using end-point gradients).
+TEST(KeyframedAnimationCurveTest, CurveTimingInputsOutsideZeroOneRange) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  // Keyframe timing function with 0.5 gradients at each end.
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      CubicBezierTimingFunction::Create(0.5f, 0.25f, 0.5f, 0.75f)));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.f), 1.f, nullptr));
+  // Curve timing function producing timing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f));
+
+  EXPECT_NEAR(-0.02f, curve->GetValue(base::Seconds(0.25f)),
+              0.002f);  // c(.25)=-.04, -.04*0.5=-0.02
+  EXPECT_NEAR(0.33f, curve->GetValue(base::Seconds(0.46f)),
+              0.002f);  // c(.46)=.38, k(.38)=.33
+
+  EXPECT_NEAR(0.67f, curve->GetValue(base::Seconds(0.54f)),
+              0.002f);  // c(.54)=.62, k(.62)=.67
+  EXPECT_NEAR(1.02f, curve->GetValue(base::Seconds(0.75f)),
+              0.002f);  // c(.75)=1.04 1+.04*0.5=1.02
+}
+
+// Tests that a step timing function works as expected for inputs outside of
+// range [0,1]
+TEST(KeyframedAnimationCurveTest, StepsTimingStartInputsOutsideZeroOneRange) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::TimeDelta(), 0.f,
+                            StepsTimingFunction::Create(
+                                4, StepsTimingFunction::StepPosition::START)));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 2.f, nullptr));
+  // Curve timing function producing timing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f));
+
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(0.25f)));
+  EXPECT_FLOAT_EQ(2.5f, curve->GetValue(base::Seconds(0.75f)));
+}
+
+TEST(KeyframedAnimationCurveTest, StepsTimingEndInputsOutsideZeroOneRange) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta(), 0.f,
+      StepsTimingFunction::Create(4, StepsTimingFunction::StepPosition::END)));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 2.f, nullptr));
+  // Curve timing function producing timing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f));
+
+  EXPECT_FLOAT_EQ(-0.5f, curve->GetValue(base::Seconds(0.25f)));
+  EXPECT_FLOAT_EQ(2.f, curve->GetValue(base::Seconds(0.75f)));
+}
+
+// Tests that an animation with a curve timing function and multiple keyframes
+// works as expected.
+TEST(KeyframedAnimationCurveTest, CurveTimingMultipleKeyframes) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.f), 1.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(2.f), 3.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(3.f), 6.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(4.f), 9.f, nullptr));
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, 0.f, 0.5f, 1.f));
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_NEAR(0.42f, curve->GetValue(base::Seconds(1.f)), 0.005f);
+  EXPECT_NEAR(1.f, curve->GetValue(base::Seconds(1.455f)), 0.005f);
+  EXPECT_FLOAT_EQ(3.f, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_NEAR(8.72f, curve->GetValue(base::Seconds(3.5f)), 0.01f);
+  EXPECT_FLOAT_EQ(9.f, curve->GetValue(base::Seconds(4.f)));
+  EXPECT_FLOAT_EQ(9.f, curve->GetValue(base::Seconds(5.f)));
+}
+
+// Tests that an animation with a curve timing function that overshoots works as
+// expected.
+TEST(KeyframedAnimationCurveTest, CurveTimingOvershootMultipeKeyframes) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.0), 1.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(2.0), 3.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(3.0), 6.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(4.0), 9.f, nullptr));
+  // Curve timing function producing outputs outside of range [0,1].
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, -0.5f, 0.5f, 1.5f));
+  EXPECT_LE(curve->GetValue(base::Seconds(1.f)),
+            0.f);  // c(.25) < 0
+  EXPECT_GE(curve->GetValue(base::Seconds(3.f)),
+            9.f);  // c(.75) > 1
+}
+
+// Tests that a float animation with multiple keys works with scaled duration.
+TEST(KeyframedAnimationCurveTest, ScaledDuration) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(1.f), 1.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(2.f), 3.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(3.f), 6.f, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(base::Seconds(4.f), 9.f, nullptr));
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.5f, 0.f, 0.5f, 1.f));
+
+  const double scale = 1000.0;
+  curve->set_scaled_duration(scale);
+
+  EXPECT_DOUBLE_EQ(scale * 4, curve->Duration().InSecondsF());
+
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(scale * -1.f)));
+  EXPECT_FLOAT_EQ(0.f, curve->GetValue(base::Seconds(scale * 0.f)));
+  EXPECT_NEAR(0.42f, curve->GetValue(base::Seconds(scale * 1.f)), 0.005f);
+  EXPECT_NEAR(1.f, curve->GetValue(base::Seconds(scale * 1.455f)), 0.005f);
+  EXPECT_FLOAT_EQ(3.f, curve->GetValue(base::Seconds(scale * 2.f)));
+  EXPECT_NEAR(8.72f, curve->GetValue(base::Seconds(scale * 3.5f)), 0.01f);
+  EXPECT_FLOAT_EQ(9.f, curve->GetValue(base::Seconds(scale * 4.f)));
+  EXPECT_FLOAT_EQ(9.f, curve->GetValue(base::Seconds(scale * 5.f)));
+}
+
+// Tests that a size animation with one keyframe works as expected.
+TEST(KeyframedAnimationCurveTest, OneSizeKeyFrame) {
+  gfx::SizeF size = gfx::SizeF(100, 100);
+  std::unique_ptr<KeyframedSizeAnimationCurve> curve(
+      KeyframedSizeAnimationCurve::Create());
+  curve->AddKeyframe(SizeKeyframe::Create(base::TimeDelta(), size, nullptr));
+
+  EXPECT_SIZEF_EQ(size, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_SIZEF_EQ(size, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_SIZEF_EQ(size, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_SIZEF_EQ(size, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_SIZEF_EQ(size, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a size animation with two keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, TwoSizeKeyFrame) {
+  gfx::SizeF size_a = gfx::SizeF(100, 100);
+  gfx::SizeF size_b = gfx::SizeF(100, 0);
+  gfx::SizeF size_midpoint = gfx::Tween::SizeFValueBetween(0.5, size_a, size_b);
+  std::unique_ptr<KeyframedSizeAnimationCurve> curve(
+      KeyframedSizeAnimationCurve::Create());
+  curve->AddKeyframe(SizeKeyframe::Create(base::TimeDelta(), size_a, nullptr));
+  curve->AddKeyframe(SizeKeyframe::Create(base::Seconds(1.0), size_b, nullptr));
+
+  EXPECT_SIZEF_EQ(size_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_SIZEF_EQ(size_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_SIZEF_EQ(size_midpoint, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_SIZEF_EQ(size_b, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_SIZEF_EQ(size_b, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a size animation with three keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, ThreeSizeKeyFrame) {
+  gfx::SizeF size_a = gfx::SizeF(100, 100);
+  gfx::SizeF size_b = gfx::SizeF(100, 0);
+  gfx::SizeF size_c = gfx::SizeF(200, 0);
+  gfx::SizeF size_midpoint1 =
+      gfx::Tween::SizeFValueBetween(0.5, size_a, size_b);
+  gfx::SizeF size_midpoint2 =
+      gfx::Tween::SizeFValueBetween(0.5, size_b, size_c);
+  std::unique_ptr<KeyframedSizeAnimationCurve> curve(
+      KeyframedSizeAnimationCurve::Create());
+  curve->AddKeyframe(SizeKeyframe::Create(base::TimeDelta(), size_a, nullptr));
+  curve->AddKeyframe(SizeKeyframe::Create(base::Seconds(1.0), size_b, nullptr));
+  curve->AddKeyframe(SizeKeyframe::Create(base::Seconds(2.0), size_c, nullptr));
+
+  EXPECT_SIZEF_EQ(size_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_SIZEF_EQ(size_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_SIZEF_EQ(size_midpoint1, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_SIZEF_EQ(size_b, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_SIZEF_EQ(size_midpoint2, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_SIZEF_EQ(size_c, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_SIZEF_EQ(size_c, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a size animation with multiple keys at a given time works sanely.
+TEST(KeyframedAnimationCurveTest, RepeatedSizeKeyFrame) {
+  gfx::SizeF size_a = gfx::SizeF(100, 64);
+  gfx::SizeF size_b = gfx::SizeF(100, 192);
+
+  std::unique_ptr<KeyframedSizeAnimationCurve> curve(
+      KeyframedSizeAnimationCurve::Create());
+  curve->AddKeyframe(SizeKeyframe::Create(base::TimeDelta(), size_a, nullptr));
+  curve->AddKeyframe(SizeKeyframe::Create(base::Seconds(1.0), size_a, nullptr));
+  curve->AddKeyframe(SizeKeyframe::Create(base::Seconds(1.0), size_b, nullptr));
+  curve->AddKeyframe(SizeKeyframe::Create(base::Seconds(2.0), size_b, nullptr));
+
+  EXPECT_SIZEF_EQ(size_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_SIZEF_EQ(size_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_SIZEF_EQ(size_a, curve->GetValue(base::Seconds(0.5f)));
+
+  gfx::SizeF value = curve->GetValue(base::Seconds(1.0f));
+  EXPECT_FLOAT_EQ(100.0f, value.width());
+  EXPECT_LE(64.0f, value.height());
+  EXPECT_GE(192.0f, value.height());
+
+  EXPECT_SIZEF_EQ(size_b, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_SIZEF_EQ(size_b, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_SIZEF_EQ(size_b, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a rect animation with one keyframe works as expected.
+TEST(KeyframedAnimationCurveTest, OneRectKeyFrame) {
+  gfx::Rect rect = gfx::Rect(1, 2, 101, 102);
+  std::unique_ptr<KeyframedRectAnimationCurve> curve(
+      KeyframedRectAnimationCurve::Create());
+  curve->AddKeyframe(RectKeyframe::Create(base::TimeDelta(), rect, nullptr));
+
+  EXPECT_EQ(rect, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_EQ(rect, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_EQ(rect, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_EQ(rect, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_EQ(rect, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a rect animation with two keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, TwoRectKeyFrame) {
+  gfx::Rect rect_a = gfx::Rect(1, 2, 100, 100);
+  gfx::Rect rect_b = gfx::Rect(11, 12, 100, 0);
+  gfx::Rect rect_midpoint = gfx::Tween::RectValueBetween(0.5, rect_a, rect_b);
+  std::unique_ptr<KeyframedRectAnimationCurve> curve(
+      KeyframedRectAnimationCurve::Create());
+  curve->AddKeyframe(RectKeyframe::Create(base::TimeDelta(), rect_a, nullptr));
+  curve->AddKeyframe(RectKeyframe::Create(base::Seconds(1.0), rect_b, nullptr));
+
+  EXPECT_EQ(rect_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_EQ(rect_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_EQ(rect_midpoint, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_EQ(rect_b, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_EQ(rect_b, curve->GetValue(base::Seconds(2.f)));
+}
+
+// Tests that a rect animation with three keyframes works as expected.
+TEST(KeyframedAnimationCurveTest, ThreeRectKeyFrame) {
+  gfx::Rect rect_a = gfx::Rect(1, 2, 100, 100);
+  gfx::Rect rect_b = gfx::Rect(11, 12, 100, 0);
+  gfx::Rect rect_c = gfx::Rect(101, 102, 200, 0);
+  gfx::Rect rect_midpoint1 = gfx::Tween::RectValueBetween(0.5, rect_a, rect_b);
+  gfx::Rect rect_midpoint2 = gfx::Tween::RectValueBetween(0.5, rect_b, rect_c);
+  std::unique_ptr<KeyframedRectAnimationCurve> curve(
+      KeyframedRectAnimationCurve::Create());
+  curve->AddKeyframe(RectKeyframe::Create(base::TimeDelta(), rect_a, nullptr));
+  curve->AddKeyframe(RectKeyframe::Create(base::Seconds(1.0), rect_b, nullptr));
+  curve->AddKeyframe(RectKeyframe::Create(base::Seconds(2.0), rect_c, nullptr));
+
+  EXPECT_EQ(rect_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_EQ(rect_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_EQ(rect_midpoint1, curve->GetValue(base::Seconds(0.5f)));
+  EXPECT_EQ(rect_b, curve->GetValue(base::Seconds(1.f)));
+  EXPECT_EQ(rect_midpoint2, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_EQ(rect_c, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_EQ(rect_c, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that a rect animation with multiple keys at a given time works sanely.
+TEST(KeyframedAnimationCurveTest, RepeatedRectKeyFrame) {
+  gfx::Rect rect_a = gfx::Rect(10, 20, 100, 64);
+  gfx::Rect rect_b = gfx::Rect(30, 40, 100, 192);
+
+  std::unique_ptr<KeyframedRectAnimationCurve> curve(
+      KeyframedRectAnimationCurve::Create());
+  curve->AddKeyframe(RectKeyframe::Create(base::TimeDelta(), rect_a, nullptr));
+  curve->AddKeyframe(RectKeyframe::Create(base::Seconds(1.0), rect_a, nullptr));
+  curve->AddKeyframe(RectKeyframe::Create(base::Seconds(1.0), rect_b, nullptr));
+  curve->AddKeyframe(RectKeyframe::Create(base::Seconds(2.0), rect_b, nullptr));
+
+  EXPECT_EQ(rect_a, curve->GetValue(base::Seconds(-1.f)));
+  EXPECT_EQ(rect_a, curve->GetValue(base::Seconds(0.f)));
+  EXPECT_EQ(rect_a, curve->GetValue(base::Seconds(0.5f)));
+
+  gfx::Rect value = curve->GetValue(base::Seconds(1.0f));
+  EXPECT_EQ(100, value.width());
+  EXPECT_LE(64, value.height());
+  EXPECT_GE(192, value.height());
+  EXPECT_LE(10, value.x());
+  EXPECT_GE(30, value.x());
+  EXPECT_LE(20, value.y());
+  EXPECT_GE(40, value.y());
+
+  EXPECT_EQ(rect_b, curve->GetValue(base::Seconds(1.5f)));
+  EXPECT_EQ(rect_b, curve->GetValue(base::Seconds(2.f)));
+  EXPECT_EQ(rect_b, curve->GetValue(base::Seconds(3.f)));
+}
+
+// Tests that the computing of tick interval for STEPS TimingFunction works
+// correctly.
+TEST(KeyFrameAnimationCurveTest, TickIntervalForStepsTimingFunction) {
+  double kDuration = 1.0;
+  int kNumSteps = 10;
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 2.0, nullptr));
+  curve->AddKeyframe(
+      FloatKeyframe::Create(base::Seconds(kDuration), 4.0, nullptr));
+  curve->SetTimingFunction(StepsTimingFunction::Create(
+      kNumSteps, StepsTimingFunction::StepPosition::START));
+  EXPECT_FLOAT_EQ(kDuration / kNumSteps, curve->TickInterval().InSecondsF());
+}
+
+// Tests that the computing of tick interval for CUBIC_BEZIER TimingFunction
+// works correctly.
+TEST(KeyFrameAnimationCurveTest, TickIntervalForCubicBezierTimingFunction) {
+  SkColor color_a = SkColorSetARGB(255, 255, 0, 0);
+  SkColor color_b = SkColorSetARGB(255, 0, 255, 0);
+  double kDuration = 1.0;
+  std::unique_ptr<KeyframedColorAnimationCurve> curve(
+      KeyframedColorAnimationCurve::Create());
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::TimeDelta(), color_a, nullptr));
+  curve->AddKeyframe(
+      ColorKeyframe::Create(base::Seconds(kDuration), color_b, nullptr));
+  curve->SetTimingFunction(
+      CubicBezierTimingFunction::Create(0.75f, 0.25f, 0.9f, 0.4f));
+  EXPECT_FLOAT_EQ(0, curve->TickInterval().InSecondsF());
+}
+
+// Tests that the computing of tick interval for LINEAR TimingFunction works
+// correctly.
+TEST(KeyFrameAnimationCurveTest, TickIntervalForLinearTimingFunction) {
+  gfx::SizeF size_a = gfx::SizeF(100, 64);
+  gfx::SizeF size_b = gfx::SizeF(100, 192);
+  gfx::SizeF size_c = gfx::SizeF(100, 218);
+  gfx::SizeF size_d = gfx::SizeF(100, 321);
+  double kDurationAB = 1.0;
+  double kDurationBC = 2.0;
+  double kDurationCD = 1.0;
+  int kNumStepsAB = 10;
+  int kNumStepsBC = 100;
+  std::unique_ptr<KeyframedSizeAnimationCurve> curve(
+      KeyframedSizeAnimationCurve::Create());
+  curve->AddKeyframe(SizeKeyframe::Create(
+      base::TimeDelta(), size_a,
+      StepsTimingFunction::Create(kNumStepsAB,
+                                  StepsTimingFunction::StepPosition::START)));
+  curve->AddKeyframe(SizeKeyframe::Create(
+      base::Seconds(kDurationAB), size_b,
+      StepsTimingFunction::Create(kNumStepsBC,
+                                  StepsTimingFunction::StepPosition::START)));
+  curve->AddKeyframe(SizeKeyframe::Create(
+      base::Seconds(kDurationAB + kDurationBC), size_c, nullptr));
+
+  // Without explicitly setting a timing function, the default is linear.
+  EXPECT_FLOAT_EQ(kDurationBC / kNumStepsBC,
+                  curve->TickInterval().InSecondsF());
+  curve->SetTimingFunction(LinearTimingFunction::Create());
+  EXPECT_FLOAT_EQ(kDurationBC / kNumStepsBC,
+                  curve->TickInterval().InSecondsF());
+
+  // Add a 4th keyframe.
+  // Now the 3rd keyframe's "easing" into the 4th isn't STEPS.
+  curve->AddKeyframe(SizeKeyframe::Create(
+      base::Seconds(kDurationAB + kDurationBC + kDurationCD), size_d, nullptr));
+  EXPECT_FLOAT_EQ(0, curve->TickInterval().InSecondsF());
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/target_property.h b/ui/gfx/animation/keyframe/target_property.h
new file mode 100644
index 0000000..1c76ab4
--- /dev/null
+++ b/ui/gfx/animation/keyframe/target_property.h
@@ -0,0 +1,19 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_TARGET_PROPERTY_H_
+#define UI_GFX_ANIMATION_KEYFRAME_TARGET_PROPERTY_H_
+
+#include <bitset>
+
+namespace gfx {
+
+static constexpr size_t kMaxTargetPropertyIndex = 32u;
+
+// A set of target properties.
+using TargetProperties = std::bitset<kMaxTargetPropertyIndex>;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_TARGET_PROPERTY_H_
diff --git a/ui/gfx/animation/keyframe/test/animation_utils.cc b/ui/gfx/animation/keyframe/test/animation_utils.cc
new file mode 100644
index 0000000..d0b7098
--- /dev/null
+++ b/ui/gfx/animation/keyframe/test/animation_utils.cc
@@ -0,0 +1,97 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/animation/keyframe/test/animation_utils.h"
+
+#include "ui/gfx/animation/keyframe/keyframed_animation_curve.h"
+
+namespace gfx {
+
+std::unique_ptr<KeyframeModel> CreateTransformAnimation(
+    TransformAnimationCurve::Target* target,
+    int id,
+    int property_id,
+    const TransformOperations& from,
+    const TransformOperations& to,
+    base::TimeDelta duration) {
+  std::unique_ptr<KeyframedTransformAnimationCurve> curve(
+      KeyframedTransformAnimationCurve::Create());
+  curve->AddKeyframe(
+      TransformKeyframe::Create(base::TimeDelta(), from, nullptr));
+  curve->AddKeyframe(TransformKeyframe::Create(duration, to, nullptr));
+  curve->set_target(target);
+  std::unique_ptr<KeyframeModel> keyframe_model(
+      KeyframeModel::Create(std::move(curve), id, property_id));
+  return keyframe_model;
+}
+
+std::unique_ptr<KeyframeModel> CreateSizeAnimation(
+    SizeAnimationCurve::Target* target,
+    int id,
+    int property_id,
+    const SizeF& from,
+    const SizeF& to,
+    base::TimeDelta duration) {
+  std::unique_ptr<KeyframedSizeAnimationCurve> curve(
+      KeyframedSizeAnimationCurve::Create());
+  curve->AddKeyframe(SizeKeyframe::Create(base::TimeDelta(), from, nullptr));
+  curve->AddKeyframe(SizeKeyframe::Create(duration, to, nullptr));
+  curve->set_target(target);
+  std::unique_ptr<KeyframeModel> keyframe_model(
+      KeyframeModel::Create(std::move(curve), id, property_id));
+  return keyframe_model;
+}
+
+std::unique_ptr<KeyframeModel> CreateFloatAnimation(
+    FloatAnimationCurve::Target* target,
+    int id,
+    int property_id,
+    float from,
+    float to,
+    base::TimeDelta duration) {
+  std::unique_ptr<KeyframedFloatAnimationCurve> curve(
+      KeyframedFloatAnimationCurve::Create());
+  curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), from, nullptr));
+  curve->AddKeyframe(FloatKeyframe::Create(duration, to, nullptr));
+  curve->set_target(target);
+  std::unique_ptr<KeyframeModel> keyframe_model(
+      KeyframeModel::Create(std::move(curve), id, property_id));
+  return keyframe_model;
+}
+
+std::unique_ptr<KeyframeModel> CreateColorAnimation(
+    ColorAnimationCurve::Target* target,
+    int id,
+    int property_id,
+    SkColor from,
+    SkColor to,
+    base::TimeDelta duration) {
+  std::unique_ptr<KeyframedColorAnimationCurve> curve(
+      KeyframedColorAnimationCurve::Create());
+  curve->AddKeyframe(ColorKeyframe::Create(base::TimeDelta(), from, nullptr));
+  curve->AddKeyframe(ColorKeyframe::Create(duration, to, nullptr));
+  curve->set_target(target);
+  std::unique_ptr<KeyframeModel> keyframe_model(
+      KeyframeModel::Create(std::move(curve), id, property_id));
+  return keyframe_model;
+}
+
+base::TimeTicks MicrosecondsToTicks(uint64_t us) {
+  base::TimeTicks to_return;
+  return base::Microseconds(us) + to_return;
+}
+
+base::TimeDelta MicrosecondsToDelta(uint64_t us) {
+  return base::Microseconds(us);
+}
+
+base::TimeTicks MsToTicks(uint64_t ms) {
+  return MicrosecondsToTicks(1000 * ms);
+}
+
+base::TimeDelta MsToDelta(uint64_t ms) {
+  return MicrosecondsToDelta(1000 * ms);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/test/animation_utils.h b/ui/gfx/animation/keyframe/test/animation_utils.h
new file mode 100644
index 0000000..355c3ed
--- /dev/null
+++ b/ui/gfx/animation/keyframe/test/animation_utils.h
@@ -0,0 +1,56 @@
+
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_TEST_ANIMATION_UTILS_H_
+#define UI_GFX_ANIMATION_KEYFRAME_TEST_ANIMATION_UTILS_H_
+
+#include <vector>
+
+#include "ui/gfx/animation/keyframe/keyframe_model.h"
+#include "ui/gfx/animation/keyframe/keyframed_animation_curve.h"
+
+namespace gfx {
+
+std::unique_ptr<KeyframeModel> CreateTransformAnimation(
+    TransformAnimationCurve::Target* target,
+    int id,
+    int property_id,
+    const TransformOperations& from,
+    const TransformOperations& to,
+    base::TimeDelta duration);
+
+std::unique_ptr<KeyframeModel> CreateSizeAnimation(
+    SizeAnimationCurve::Target* target,
+    int id,
+    int property_id,
+    const SizeF& from,
+    const SizeF& to,
+    base::TimeDelta duration);
+
+std::unique_ptr<KeyframeModel> CreateFloatAnimation(
+    FloatAnimationCurve::Target* target,
+    int id,
+    int property_id,
+    float from,
+    float to,
+    base::TimeDelta duration);
+
+std::unique_ptr<KeyframeModel> CreateColorAnimation(
+    ColorAnimationCurve::Target* target,
+    int id,
+    int property_id,
+    SkColor from,
+    SkColor to,
+    base::TimeDelta duration);
+
+base::TimeTicks MicrosecondsToTicks(uint64_t us);
+base::TimeDelta MicrosecondsToDelta(uint64_t us);
+
+base::TimeTicks MsToTicks(uint64_t us);
+base::TimeDelta MsToDelta(uint64_t us);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_TEST_ANIMATION_UTILS_H_
diff --git a/ui/gfx/animation/keyframe/timing_function.cc b/ui/gfx/animation/keyframe/timing_function.cc
new file mode 100644
index 0000000..9650a50
--- /dev/null
+++ b/ui/gfx/animation/keyframe/timing_function.cc
@@ -0,0 +1,182 @@
+// Copyright 2012 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.
+
+#include "ui/gfx/animation/keyframe/timing_function.h"
+
+#include <cmath>
+#include <memory>
+
+#include "base/check_op.h"
+#include "base/memory/ptr_util.h"
+#include "base/notreached.h"
+
+namespace gfx {
+
+TimingFunction::TimingFunction() = default;
+
+TimingFunction::~TimingFunction() = default;
+
+std::unique_ptr<CubicBezierTimingFunction>
+CubicBezierTimingFunction::CreatePreset(EaseType ease_type) {
+  // These numbers come from
+  // http://www.w3.org/TR/css3-transitions/#transition-timing-function_tag.
+  switch (ease_type) {
+    case EaseType::EASE:
+      return base::WrapUnique(
+          new CubicBezierTimingFunction(ease_type, 0.25, 0.1, 0.25, 1.0));
+    case EaseType::EASE_IN:
+      return base::WrapUnique(
+          new CubicBezierTimingFunction(ease_type, 0.42, 0.0, 1.0, 1.0));
+    case EaseType::EASE_OUT:
+      return base::WrapUnique(
+          new CubicBezierTimingFunction(ease_type, 0.0, 0.0, 0.58, 1.0));
+    case EaseType::EASE_IN_OUT:
+      return base::WrapUnique(
+          new CubicBezierTimingFunction(ease_type, 0.42, 0.0, 0.58, 1));
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
+}
+std::unique_ptr<CubicBezierTimingFunction>
+CubicBezierTimingFunction::Create(double x1, double y1, double x2, double y2) {
+  return base::WrapUnique(
+      new CubicBezierTimingFunction(EaseType::CUSTOM, x1, y1, x2, y2));
+}
+
+CubicBezierTimingFunction::CubicBezierTimingFunction(EaseType ease_type,
+                                                     double x1,
+                                                     double y1,
+                                                     double x2,
+                                                     double y2)
+    : bezier_(x1, y1, x2, y2), ease_type_(ease_type) {}
+
+CubicBezierTimingFunction::~CubicBezierTimingFunction() = default;
+
+TimingFunction::Type CubicBezierTimingFunction::GetType() const {
+  return Type::CUBIC_BEZIER;
+}
+
+double CubicBezierTimingFunction::GetValue(double x) const {
+  return bezier_.Solve(x);
+}
+
+double CubicBezierTimingFunction::Velocity(double x) const {
+  return bezier_.Slope(x);
+}
+
+std::unique_ptr<TimingFunction> CubicBezierTimingFunction::Clone() const {
+  return base::WrapUnique(new CubicBezierTimingFunction(*this));
+}
+
+std::unique_ptr<StepsTimingFunction> StepsTimingFunction::Create(
+    int steps,
+    StepPosition step_position) {
+  return base::WrapUnique(new StepsTimingFunction(steps, step_position));
+}
+
+StepsTimingFunction::StepsTimingFunction(int steps, StepPosition step_position)
+    : steps_(steps), step_position_(step_position) {}
+
+StepsTimingFunction::~StepsTimingFunction() = default;
+
+TimingFunction::Type StepsTimingFunction::GetType() const {
+  return Type::STEPS;
+}
+
+double StepsTimingFunction::GetValue(double t) const {
+  return GetPreciseValue(t, TimingFunction::LimitDirection::RIGHT);
+}
+
+std::unique_ptr<TimingFunction> StepsTimingFunction::Clone() const {
+  return base::WrapUnique(new StepsTimingFunction(*this));
+}
+
+double StepsTimingFunction::Velocity(double x) const {
+  return 0;
+}
+
+double StepsTimingFunction::GetPreciseValue(double t,
+                                            LimitDirection direction) const {
+  const double steps = static_cast<double>(steps_);
+  double current_step = std::floor((steps * t) + GetStepsStartOffset());
+  // Adjust step if using a left limit at a discontinuous step boundary.
+  if (direction == LimitDirection::LEFT &&
+      steps * t - std::floor(steps * t) == 0) {
+    current_step -= 1;
+  }
+  // Jumps may differ from steps based on the number of end-point
+  // discontinuities, which may be 0, 1 or 2.
+  int jumps = NumberOfJumps();
+  if (t >= 0 && current_step < 0)
+    current_step = 0;
+  if (t <= 1 && current_step > jumps)
+    current_step = jumps;
+  return current_step / jumps;
+}
+
+int StepsTimingFunction::NumberOfJumps() const {
+  switch (step_position_) {
+    case StepPosition::END:
+    case StepPosition::START:
+    case StepPosition::JUMP_END:
+    case StepPosition::JUMP_START:
+      return steps_;
+
+    case StepPosition::JUMP_BOTH:
+      return steps_ + 1;
+
+    case StepPosition::JUMP_NONE:
+      DCHECK_GT(steps_, 1);
+      return steps_ - 1;
+
+    default:
+      NOTREACHED();
+      return steps_;
+  }
+}
+
+float StepsTimingFunction::GetStepsStartOffset() const {
+  switch (step_position_) {
+    case StepPosition::JUMP_BOTH:
+    case StepPosition::JUMP_START:
+    case StepPosition::START:
+      return 1;
+
+    case StepPosition::JUMP_END:
+    case StepPosition::JUMP_NONE:
+    case StepPosition::END:
+      return 0;
+
+    default:
+      NOTREACHED();
+      return 1;
+  }
+}
+
+std::unique_ptr<LinearTimingFunction> LinearTimingFunction::Create() {
+  return base::WrapUnique(new LinearTimingFunction());
+}
+
+LinearTimingFunction::LinearTimingFunction() = default;
+
+LinearTimingFunction::~LinearTimingFunction() = default;
+
+TimingFunction::Type LinearTimingFunction::GetType() const {
+  return Type::LINEAR;
+}
+
+std::unique_ptr<TimingFunction> LinearTimingFunction::Clone() const {
+  return base::WrapUnique(new LinearTimingFunction(*this));
+}
+
+double LinearTimingFunction::Velocity(double x) const {
+  return 0;
+}
+
+double LinearTimingFunction::GetValue(double t) const {
+  return t;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/timing_function.h b/ui/gfx/animation/keyframe/timing_function.h
new file mode 100644
index 0000000..7ce7133
--- /dev/null
+++ b/ui/gfx/animation/keyframe/timing_function.h
@@ -0,0 +1,143 @@
+// Copyright 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_TIMING_FUNCTION_H_
+#define UI_GFX_ANIMATION_KEYFRAME_TIMING_FUNCTION_H_
+
+#include <memory>
+
+#include "ui/gfx/animation/keyframe/keyframe_animation_export.h"
+#include "ui/gfx/geometry/cubic_bezier.h"
+
+namespace gfx {
+
+// See http://www.w3.org/TR/css3-transitions/.
+class GFX_KEYFRAME_ANIMATION_EXPORT TimingFunction {
+ public:
+  virtual ~TimingFunction();
+
+  TimingFunction& operator=(const TimingFunction&) = delete;
+
+  // Note that LINEAR is a nullptr TimingFunction (for now).
+  enum class Type { LINEAR, CUBIC_BEZIER, STEPS };
+
+  // Which limit to apply at a discontinuous boundary.
+  enum class LimitDirection { LEFT, RIGHT };
+
+  virtual Type GetType() const = 0;
+  virtual double GetValue(double t) const = 0;
+  virtual double Velocity(double time) const = 0;
+  virtual std::unique_ptr<TimingFunction> Clone() const = 0;
+
+ protected:
+  TimingFunction();
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT CubicBezierTimingFunction
+    : public TimingFunction {
+ public:
+  enum class EaseType { EASE, EASE_IN, EASE_OUT, EASE_IN_OUT, CUSTOM };
+
+  static std::unique_ptr<CubicBezierTimingFunction> CreatePreset(
+      EaseType ease_type);
+  static std::unique_ptr<CubicBezierTimingFunction> Create(double x1,
+                                                           double y1,
+                                                           double x2,
+                                                           double y2);
+  ~CubicBezierTimingFunction() override;
+
+  CubicBezierTimingFunction& operator=(const CubicBezierTimingFunction&) =
+      delete;
+
+  // TimingFunction implementation.
+  Type GetType() const override;
+  double GetValue(double time) const override;
+  double Velocity(double time) const override;
+  std::unique_ptr<TimingFunction> Clone() const override;
+
+  EaseType ease_type() const { return ease_type_; }
+  const gfx::CubicBezier& bezier() const { return bezier_; }
+
+ private:
+  CubicBezierTimingFunction(EaseType ease_type,
+                            double x1,
+                            double y1,
+                            double x2,
+                            double y2);
+
+  gfx::CubicBezier bezier_;
+  EaseType ease_type_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT StepsTimingFunction
+    : public TimingFunction {
+ public:
+  // step-timing-function values
+  // https://drafts.csswg.org/css-easing-1/#typedef-step-timing-function
+  enum class StepPosition {
+    START,      // Discontinuity at progress = 0.
+                // Alias for jump-start. Maintaining a separate enumerated value
+                // for serialization.
+    END,        // Discontinuity at progress = 1.
+                // Alias for jump-end. Maintaining a separate enumerated value
+                // for serialization.
+    JUMP_BOTH,  // Discontinuities at progress = 0 and 1.
+    JUMP_END,   // Discontinuity at progress = 1.
+    JUMP_NONE,  // Continuous at progress = 0 and 1.
+    JUMP_START  // Discontinuity at progress = 0.
+  };
+
+  static std::unique_ptr<StepsTimingFunction> Create(
+      int steps,
+      StepPosition step_position);
+  ~StepsTimingFunction() override;
+
+  StepsTimingFunction& operator=(const StepsTimingFunction&) = delete;
+
+  // TimingFunction implementation.
+  Type GetType() const override;
+  double GetValue(double t) const override;
+  std::unique_ptr<TimingFunction> Clone() const override;
+  double Velocity(double time) const override;
+
+  int steps() const { return steps_; }
+  StepPosition step_position() const { return step_position_; }
+  double GetPreciseValue(double t, LimitDirection limit_direction) const;
+
+ private:
+  StepsTimingFunction(int steps, StepPosition step_position);
+
+  // The number of jumps is the number of discontinuities in the timing
+  // function. There is a subtle distinction between the number of steps and
+  // jumps. The number of steps is the number of intervals in the timing
+  // function. The number of jumps differs from the number of steps when either
+  // both or neither end point has a discontinuity.
+  // https://drafts.csswg.org/css-easing-1/#step-easing-functions
+  int NumberOfJumps() const;
+
+  float GetStepsStartOffset() const;
+
+  int steps_;
+  StepPosition step_position_;
+};
+
+class GFX_KEYFRAME_ANIMATION_EXPORT LinearTimingFunction
+    : public TimingFunction {
+ public:
+  static std::unique_ptr<LinearTimingFunction> Create();
+  ~LinearTimingFunction() override;
+
+  // TimingFunction implementation.
+  Type GetType() const override;
+  double GetValue(double t) const override;
+  std::unique_ptr<TimingFunction> Clone() const override;
+  double Velocity(double time) const override;
+
+ private:
+  LinearTimingFunction();
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_TIMING_FUNCTION_H_
diff --git a/ui/gfx/animation/keyframe/transition.cc b/ui/gfx/animation/keyframe/transition.cc
new file mode 100644
index 0000000..f2305f0
--- /dev/null
+++ b/ui/gfx/animation/keyframe/transition.cc
@@ -0,0 +1,20 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/animation/keyframe/transition.h"
+
+namespace gfx {
+
+namespace {
+static constexpr int kDefaultTransitionDurationMs = 225;
+}  // namespace
+
+Transition::Transition()
+    : duration(base::Milliseconds(kDefaultTransitionDurationMs)) {}
+
+Transition::Transition(const Transition&) = default;
+Transition::Transition(Transition&&) = default;
+Transition::~Transition() = default;
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/keyframe/transition.h b/ui/gfx/animation/keyframe/transition.h
new file mode 100644
index 0000000..d902f91
--- /dev/null
+++ b/ui/gfx/animation/keyframe/transition.h
@@ -0,0 +1,30 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_KEYFRAME_TRANSITION_H_
+#define UI_GFX_ANIMATION_KEYFRAME_TRANSITION_H_
+
+#include <set>
+
+#include "base/time/time.h"
+#include "ui/gfx/animation/keyframe/keyframe_animation_export.h"
+
+namespace gfx {
+
+struct GFX_KEYFRAME_ANIMATION_EXPORT Transition {
+  Transition();
+  Transition(const Transition&);
+  Transition(Transition&&);
+  ~Transition();
+
+  Transition& operator=(const Transition&) = default;
+  Transition& operator=(Transition&&) = default;
+
+  base::TimeDelta duration;
+  std::set<int> target_properties;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_KEYFRAME_TRANSITION_H_
diff --git a/ui/gfx/animation/linear_animation.cc b/ui/gfx/animation/linear_animation.cc
new file mode 100644
index 0000000..39f3671
--- /dev/null
+++ b/ui/gfx/animation/linear_animation.cc
@@ -0,0 +1,109 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/animation/linear_animation.h"
+
+#include <math.h>
+#include <stdint.h>
+
+#include <algorithm>
+
+#include "base/command_line.h"
+#include "base/cxx17_backports.h"
+#include "base/strings/string_number_conversions.h"
+#include "ui/gfx/animation/animation_container.h"
+#include "ui/gfx/animation/animation_delegate.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+
+static base::TimeDelta CalculateInterval(int frame_rate) {
+  int timer_interval = 1000000 / frame_rate;
+  if (timer_interval < 10000)
+    timer_interval = 10000;
+  return base::Microseconds(timer_interval);
+}
+
+const int LinearAnimation::kDefaultFrameRate = 60;
+
+LinearAnimation::LinearAnimation(AnimationDelegate* delegate, int frame_rate)
+    : LinearAnimation({}, frame_rate, delegate) {}
+
+LinearAnimation::LinearAnimation(base::TimeDelta duration,
+                                 int frame_rate,
+                                 AnimationDelegate* delegate)
+    : Animation(CalculateInterval(frame_rate)), state_(0.0), in_end_(false) {
+  set_delegate(delegate);
+  SetDuration(duration);
+}
+
+double LinearAnimation::GetCurrentValue() const {
+  // Default is linear relationship, subclass to adapt.
+  return state_;
+}
+
+void LinearAnimation::SetCurrentValue(double new_value) {
+  new_value = base::clamp(new_value, 0.0, 1.0);
+  const base::TimeDelta time_delta = duration_ * (new_value - state_);
+  SetStartTime(start_time() - time_delta);
+  state_ = new_value;
+}
+
+void LinearAnimation::End() {
+  if (!is_animating())
+    return;
+
+  // NOTE: We don't use AutoReset here as Stop may end up deleting us (by way
+  // of the delegate).
+  in_end_ = true;
+  Stop();
+}
+
+void LinearAnimation::SetDuration(base::TimeDelta duration) {
+  static const double duration_scale_factor = []() {
+    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+    double animation_duration_scale;
+    return (base::StringToDouble(command_line->GetSwitchValueASCII(
+                                     switches::kAnimationDurationScale),
+                                 &animation_duration_scale) &&
+            (animation_duration_scale >= 0.0))
+               ? animation_duration_scale
+               : 1.0;
+  }();
+  duration_ = std::max(duration * duration_scale_factor, timer_interval());
+  if (is_animating())
+    SetStartTime(container()->last_tick_time());
+}
+
+void LinearAnimation::Step(base::TimeTicks time_now) {
+  state_ = std::min((time_now - start_time()) / duration_, 1.0);
+
+  AnimateToState(state_);
+
+  if (delegate())
+    delegate()->AnimationProgressed(this);
+
+  if (state_ == 1.0)
+    Stop();
+}
+
+void LinearAnimation::AnimationStarted() {
+  state_ = 0.0;
+}
+
+void LinearAnimation::AnimationStopped() {
+  if (!in_end_)
+    return;
+
+  in_end_ = false;
+  // Set state_ to ensure we send ended to delegate and not canceled.
+  state_ = 1;
+  AnimateToState(1.0);
+}
+
+bool LinearAnimation::ShouldSendCanceledFromStop() {
+  return state_ != 1;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/linear_animation.h b/ui/gfx/animation/linear_animation.h
new file mode 100644
index 0000000..d313ecd
--- /dev/null
+++ b/ui/gfx/animation/linear_animation.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_LINEAR_ANIMATION_H_
+#define UI_GFX_ANIMATION_LINEAR_ANIMATION_H_
+
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "ui/gfx/animation/animation.h"
+
+namespace gfx {
+
+class AnimationDelegate;
+
+// Linear time bounded animation. As the animation progresses AnimateToState is
+// invoked.
+class ANIMATION_EXPORT LinearAnimation : public Animation {
+ public:
+  // Default frame rate (hz).
+  static const int kDefaultFrameRate;
+
+  // Initializes everything except the duration.
+  //
+  // Caller must make sure to call SetDuration() if they use this
+  // constructor; it is preferable to use the full one, but sometimes
+  // duration can change between calls to Start() and we need to
+  // expose this interface.
+  explicit LinearAnimation(AnimationDelegate* delegate,
+                           int frame_rate = kDefaultFrameRate);
+
+  // Initializes all fields.
+  LinearAnimation(base::TimeDelta duration,
+                  int frame_rate,
+                  AnimationDelegate* delegate);
+
+  LinearAnimation(const LinearAnimation&) = delete;
+  LinearAnimation& operator=(const LinearAnimation&) = delete;
+
+  // Gets the value for the current state, according to the animation curve in
+  // use. This class provides only for a linear relationship, however subclasses
+  // can override this to provide others.
+  double GetCurrentValue() const override;
+
+  // Change the current state of the animation to |new_value|.
+  void SetCurrentValue(double new_value);
+
+  // Skip to the end of the current animation.
+  void End();
+
+  // Changes the length of the animation. This resets the current
+  // state of the animation to the beginning. This value will be multiplied by
+  // the currently set scale factor.
+  void SetDuration(base::TimeDelta duration);
+
+ protected:
+  // Called when the animation progresses. Subclasses override this to
+  // efficiently update their state.
+  virtual void AnimateToState(double state) {}
+
+  // Invoked by the AnimationContainer when the animation is running to advance
+  // the animation. Use |time_now| rather than Time::Now to avoid multiple
+  // animations running at the same time diverging.
+  void Step(base::TimeTicks time_now) override;
+
+  // Overriden to initialize state.
+  void AnimationStarted() override;
+
+  // Overriden to advance to the end (if End was invoked).
+  void AnimationStopped() override;
+
+  // Overriden to return true if state is not 1.
+  bool ShouldSendCanceledFromStop() override;
+
+  base::TimeDelta duration() const { return duration_; }
+
+ private:
+  base::TimeDelta duration_;
+
+  // Current state, on a scale from 0.0 to 1.0.
+  double state_;
+
+  // If true, we're in end. This is used to determine if the animation should
+  // be advanced to the end from AnimationStopped.
+  bool in_end_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_LINEAR_ANIMATION_H_
diff --git a/ui/gfx/animation/multi_animation.cc b/ui/gfx/animation/multi_animation.cc
new file mode 100644
index 0000000..09b4423
--- /dev/null
+++ b/ui/gfx/animation/multi_animation.cc
@@ -0,0 +1,88 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/animation/multi_animation.h"
+
+#include <numeric>
+
+#include "base/check_op.h"
+#include "base/notreached.h"
+#include "ui/gfx/animation/animation_delegate.h"
+
+namespace gfx {
+
+static base::TimeDelta TotalTime(const MultiAnimation::Parts& parts) {
+  return std::accumulate(parts.cbegin(), parts.cend(), base::TimeDelta(),
+                         [](base::TimeDelta total, const auto& part) {
+                           return total + part.length;
+                         });
+}
+
+// static
+constexpr base::TimeDelta MultiAnimation::kDefaultTimerInterval;
+
+MultiAnimation::MultiAnimation(const Parts& parts,
+                               base::TimeDelta timer_interval)
+    : Animation(timer_interval), parts_(parts), cycle_time_(TotalTime(parts)) {
+  DCHECK(!parts_.empty());
+}
+
+MultiAnimation::~MultiAnimation() = default;
+
+double MultiAnimation::GetCurrentValue() const {
+  const Part& current_part = parts_[current_part_index_];
+  return Tween::DoubleValueBetween(
+      Tween::CalculateValue(current_part.type, current_part_state_),
+      current_part.start_value, current_part.end_value);
+}
+
+void MultiAnimation::Step(base::TimeTicks time_now) {
+  double last_value = GetCurrentValue();
+  size_t last_index = current_part_index_;
+
+  base::TimeDelta delta = time_now - start_time();
+  bool should_stop = delta >= cycle_time_ && !continuous_;
+  if (should_stop) {
+    current_part_index_ = parts_.size() - 1;
+    current_part_state_ = 1.0;
+  } else {
+    delta %= cycle_time_;
+    const Part& part = GetPart(&delta, &current_part_index_);
+    current_part_state_ = delta / part.length;
+    DCHECK_LE(current_part_state_, 1);
+  }
+
+  if ((GetCurrentValue() != last_value || current_part_index_ != last_index) &&
+      delegate()) {
+    // Run AnimationProgressed() even if the animation will be stopped, so that
+    // the animation runs its final frame.
+    delegate()->AnimationProgressed(this);
+  }
+  if (should_stop)
+    Stop();
+}
+
+void MultiAnimation::SetStartTime(base::TimeTicks start_time) {
+  Animation::SetStartTime(start_time);
+  current_part_state_ = 0.0;
+  current_part_index_ = 0;
+}
+
+const MultiAnimation::Part& MultiAnimation::GetPart(base::TimeDelta* time,
+                                                    size_t* part_index) {
+  DCHECK_LT(*time, cycle_time_);
+
+  for (size_t i = 0; i < parts_.size(); ++i) {
+    if (*time < parts_[i].length) {
+      *part_index = i;
+      return parts_[i];
+    }
+
+    *time -= parts_[i].length;
+  }
+  NOTREACHED();
+  return parts_[0];
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/multi_animation.h b/ui/gfx/animation/multi_animation.h
new file mode 100644
index 0000000..870e92f
--- /dev/null
+++ b/ui/gfx/animation/multi_animation.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_MULTI_ANIMATION_H_
+#define UI_GFX_ANIMATION_MULTI_ANIMATION_H_
+
+#include <stddef.h>
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "ui/gfx/animation/animation.h"
+#include "ui/gfx/animation/tween.h"
+
+namespace gfx {
+
+// MultiAnimation is an animation that consists of a number of sub animations.
+// To create a MultiAnimation pass in the parts, invoke Start() and the delegate
+// is notified as the animation progresses. By default MultiAnimation runs until
+// Stop is invoked, see |set_continuous()| for details.
+class ANIMATION_EXPORT MultiAnimation : public Animation {
+ public:
+  // Defines part of the animation. Each part consists of the following:
+  //
+  // part_length: the length of time the part runs.
+  // part_start: the amount of time to offset this part by when calculating the
+  // initial percentage.
+  // total_length: the total length used to calculate the percentange completed.
+  // start_value: the animation value at the beginning of this part of the
+  // animation. Defaults to 0.
+  // end_value: the animation value at the end of this part of the animation.
+  // Defaults to 1.
+  //
+  // In most cases |part_start| is empty and |total_length| = |part_length|. But
+  // you can adjust the start/total for different effects. For example, to run a
+  // part for 200ms with a % between .25 and .75 use the following three values:
+  // part_length = 200, part_start = 100, total_length = 400.
+  //
+  // |start_value| and |end_value| can be used to chain multiple animations into
+  // a single function. A common use case is a MultiAnimation that consists of
+  // these parts: 0->1 (fade-in), 1->1 (hold) and 1->0 (fade out).
+  struct Part {
+    Part(base::TimeDelta length,
+         Tween::Type type,
+         double start_value = 0.0,
+         double end_value = 1.0)
+        : length(length),
+          type(type),
+          start_value(start_value),
+          end_value(end_value) {}
+
+    base::TimeDelta length;
+    Tween::Type type;
+    double start_value;
+    double end_value;
+  };
+  using Parts = std::vector<Part>;
+
+  static constexpr auto kDefaultTimerInterval = base::Milliseconds(20);
+
+  explicit MultiAnimation(
+      const Parts& parts,
+      base::TimeDelta timer_interval = kDefaultTimerInterval);
+
+  MultiAnimation(const MultiAnimation&) = delete;
+  MultiAnimation& operator=(const MultiAnimation&) = delete;
+
+  ~MultiAnimation() override;
+
+  // Sets whether the animation continues after it reaches the end. If true, the
+  // animation runs until explicitly stopped. The default is true.
+  void set_continuous(bool continuous) { continuous_ = continuous; }
+
+  // Returns the current value. The current value for a MultiAnimation is
+  // determined from the tween type of the current part.
+  double GetCurrentValue() const override;
+
+  // Returns the index of the current part.
+  size_t current_part_index() const { return current_part_index_; }
+
+ protected:
+  // Animation overrides.
+  void Step(base::TimeTicks time_now) override;
+  void SetStartTime(base::TimeTicks start_time) override;
+
+ private:
+  // Returns the part containing the specified time. |time| is reset to be
+  // relative to the part containing the time and |part_index| the index of the
+  // part.
+  const Part& GetPart(base::TimeDelta* time, size_t* part_index);
+
+  // The parts that make up the animation.
+  const Parts parts_;
+
+  // Total time of all the parts.
+  const base::TimeDelta cycle_time_;
+
+  // Animation state for the current part.
+  double current_part_state_ = 0.0;
+
+  // Index of the current part.
+  size_t current_part_index_ = 0;
+
+  // See description above setter.
+  bool continuous_ = true;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_MULTI_ANIMATION_H_
diff --git a/ui/gfx/animation/multi_animation_unittest.cc b/ui/gfx/animation/multi_animation_unittest.cc
new file mode 100644
index 0000000..dec64d9
--- /dev/null
+++ b/ui/gfx/animation/multi_animation_unittest.cc
@@ -0,0 +1,135 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/animation/multi_animation.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/animation/animation_container_element.h"
+#include "ui/gfx/animation/animation_delegate.h"
+
+namespace gfx {
+
+TEST(MultiAnimationTest, Basic) {
+  // Create a MultiAnimation with two parts.
+  MultiAnimation::Parts parts;
+  parts.push_back(MultiAnimation::Part(base::Milliseconds(100), Tween::LINEAR));
+  parts.push_back(
+      MultiAnimation::Part(base::Milliseconds(100), Tween::EASE_OUT));
+
+  MultiAnimation animation(parts);
+  AnimationContainerElement* as_element =
+      static_cast<AnimationContainerElement*>(&animation);
+  as_element->SetStartTime(base::TimeTicks());
+
+  // Step to 50, which is half way through the first part.
+  as_element->Step(base::TimeTicks() + base::Milliseconds(50));
+  EXPECT_EQ(.5, animation.GetCurrentValue());
+
+  // Step to 120, which is 20% through the second part.
+  as_element->Step(base::TimeTicks() + base::Milliseconds(120));
+  EXPECT_DOUBLE_EQ(Tween::CalculateValue(Tween::EASE_OUT, .2),
+                   animation.GetCurrentValue());
+
+  // Step to 320, which is 20% through the second part.
+  as_element->Step(base::TimeTicks() + base::Milliseconds(320));
+  EXPECT_DOUBLE_EQ(Tween::CalculateValue(Tween::EASE_OUT, .2),
+                   animation.GetCurrentValue());
+}
+
+// Makes sure multi-animation stops if cycles is false.
+TEST(MultiAnimationTest, DontCycle) {
+  MultiAnimation::Parts parts;
+  parts.push_back(MultiAnimation::Part(base::Milliseconds(200), Tween::LINEAR));
+  MultiAnimation animation(parts);
+  AnimationContainerElement* as_element =
+      static_cast<AnimationContainerElement*>(&animation);
+  as_element->SetStartTime(base::TimeTicks());
+  animation.set_continuous(false);
+
+  // Step to 300, which is greater than the cycle time.
+  as_element->Step(base::TimeTicks() + base::Milliseconds(300));
+  EXPECT_EQ(1.0, animation.GetCurrentValue());
+  EXPECT_FALSE(animation.is_animating());
+}
+
+class CurrentValueDelegate : public AnimationDelegate {
+ public:
+  CurrentValueDelegate() = default;
+
+  double latest_current_value() { return latest_current_value_; }
+
+  // AnimationDelegate overrides:
+  void AnimationProgressed(const Animation* animation) override {
+    latest_current_value_ = animation->GetCurrentValue();
+  }
+
+ private:
+  double latest_current_value_ = 0.0;
+};
+
+// Makes sure multi-animation runs the final frame when exceeding the cycle time
+// and not running continuously.
+TEST(MultiAnimationTest, ExceedCycleNonContinuous) {
+  MultiAnimation::Parts parts;
+  parts.push_back(MultiAnimation::Part(base::Milliseconds(200), Tween::LINEAR));
+  MultiAnimation animation(parts);
+  CurrentValueDelegate delegate;
+  animation.set_delegate(&delegate);
+  animation.set_continuous(false);
+  AnimationContainerElement* as_element =
+      static_cast<AnimationContainerElement*>(&animation);
+  as_element->SetStartTime(base::TimeTicks());
+
+  // Step to 300, which is greater than the cycle time.
+  as_element->Step(base::TimeTicks() + base::Milliseconds(300));
+  EXPECT_EQ(1.0, delegate.latest_current_value());
+}
+
+// Makes sure multi-animation cycles correctly.
+TEST(MultiAnimationTest, Cycle) {
+  MultiAnimation::Parts parts;
+  parts.push_back(MultiAnimation::Part(base::Milliseconds(200), Tween::LINEAR));
+  MultiAnimation animation(parts);
+  AnimationContainerElement* as_element =
+      static_cast<AnimationContainerElement*>(&animation);
+  as_element->SetStartTime(base::TimeTicks());
+
+  // Step to 300, which is greater than the cycle time.
+  as_element->Step(base::TimeTicks() + base::Milliseconds(300));
+  EXPECT_EQ(.5, animation.GetCurrentValue());
+}
+
+// Make sure MultiAnimation::GetCurrentValue is derived from the start and end
+// of the current MultiAnimation::Part.
+TEST(MultiAnimationTest, GetCurrentValueDerivedFromStartAndEndOfCurrentPart) {
+  // Create a MultiAnimation with two parts. The second part goes from 0.8 to
+  // 0.4 instead of the default 0 -> 1.
+  constexpr double kSecondPartStart = 0.8;
+  constexpr double kSecondPartEnd = 0.4;
+  MultiAnimation::Parts parts;
+  parts.push_back(MultiAnimation::Part(base::Milliseconds(100), Tween::LINEAR));
+  parts.push_back(MultiAnimation::Part(base::Milliseconds(100), Tween::EASE_OUT,
+                                       kSecondPartStart, kSecondPartEnd));
+
+  MultiAnimation animation(parts);
+  animation.set_continuous(false);
+  AnimationContainerElement* as_element =
+      static_cast<AnimationContainerElement*>(&animation);
+  as_element->SetStartTime(base::TimeTicks());
+
+  // Step to 150, which is half way through the second part.
+  as_element->Step(base::TimeTicks() + base::Milliseconds(150));
+  const double current_animation_value =
+      Tween::CalculateValue(Tween::EASE_OUT, .5);
+  EXPECT_DOUBLE_EQ(Tween::DoubleValueBetween(current_animation_value,
+                                             kSecondPartStart, kSecondPartEnd),
+                   animation.GetCurrentValue());
+
+  // Step to 200 which is at the end. The final value should now be kPartEnd as
+  // the animation is not continuous.
+  as_element->Step(base::TimeTicks() + base::Milliseconds(200));
+  EXPECT_DOUBLE_EQ(kSecondPartEnd, animation.GetCurrentValue());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/slide_animation.cc b/ui/gfx/animation/slide_animation.cc
new file mode 100644
index 0000000..d525fbb
--- /dev/null
+++ b/ui/gfx/animation/slide_animation.cc
@@ -0,0 +1,89 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/animation/slide_animation.h"
+
+#include <math.h>
+
+#include "base/cxx17_backports.h"
+#include "ui/gfx/animation/animation_delegate.h"
+
+namespace gfx {
+
+SlideAnimation::SlideAnimation(AnimationDelegate* target)
+    : LinearAnimation(target), target_(target) {}
+
+SlideAnimation::~SlideAnimation() = default;
+
+void SlideAnimation::Reset(double value) {
+  direction_ = absl::nullopt;
+  value_current_ = value;
+  Stop();
+}
+
+void SlideAnimation::Show() {
+  BeginAnimating(Direction::kShowing);
+}
+
+void SlideAnimation::Hide() {
+  BeginAnimating(Direction::kHiding);
+}
+
+void SlideAnimation::SetSlideDuration(base::TimeDelta duration) {
+  slide_duration_ = duration;
+}
+
+void SlideAnimation::SetDampeningValue(double dampening_value) {
+  dampening_value_ = dampening_value;
+}
+
+double SlideAnimation::GetCurrentValue() const {
+  return value_current_;
+}
+
+base::TimeDelta SlideAnimation::GetDuration() {
+  const double current_progress =
+      direction_ == Direction::kShowing ? value_current_ : 1.0 - value_current_;
+
+  return slide_duration_ * (1 - pow(current_progress, dampening_value_));
+}
+
+void SlideAnimation::BeginAnimating(Direction direction) {
+  if (direction_ == direction)
+    return;
+
+  direction_ = direction;
+  value_start_ = value_current_;
+  value_end_ = (direction_ == Direction::kShowing) ? 1.0 : 0.0;
+
+  // Make sure we actually have something to do.
+  if (slide_duration_.is_zero()) {
+    AnimateToState(1.0);  // Skip to the end of the animation.
+    if (delegate()) {
+      delegate()->AnimationProgressed(this);
+      delegate()->AnimationEnded(this);
+    }
+  } else if (value_current_ != value_end_) {
+    // This will also reset the currently-occurring animation.
+    SetDuration(GetDuration());
+    Start();
+  }
+}
+
+void SlideAnimation::AnimateToState(double state) {
+  state = Tween::CalculateValue(tween_type_, base::clamp(state, 0.0, 1.0));
+  if (state == 1.0)
+    direction_ = absl::nullopt;
+
+  value_current_ = value_start_ + (value_end_ - value_start_) * state;
+
+  // Correct for any overshoot (while state may be capped at 1.0, let's not
+  // take any rounding error chances.
+  if ((value_end_ >= value_start_) ? (value_current_ > value_end_)
+                                   : (value_current_ < value_end_)) {
+    value_current_ = value_end_;
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/slide_animation.h b/ui/gfx/animation/slide_animation.h
new file mode 100644
index 0000000..35e86f6
--- /dev/null
+++ b/ui/gfx/animation/slide_animation.h
@@ -0,0 +1,134 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_SLIDE_ANIMATION_H_
+#define UI_GFX_ANIMATION_SLIDE_ANIMATION_H_
+
+#include "base/macros.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/animation/linear_animation.h"
+#include "ui/gfx/animation/tween.h"
+
+namespace gfx {
+
+// Slide Animation
+//
+// Used for reversible animations and as a general helper class. Typical usage:
+//
+// #include "ui/gfx/animation/slide_animation.h"
+//
+// class MyClass : public AnimationDelegate {
+//  public:
+//   MyClass() {
+//     animation_ = std::make_unique<SlideAnimation>(this);
+//     animation_->SetSlideDuration(base::Milliseconds(500));
+//   }
+//   void OnMouseOver() {
+//     animation_->Show();
+//   }
+//   void OnMouseOut() {
+//     animation_->Hide();
+//   }
+//   void AnimationProgressed(const Animation* animation) {
+//     if (animation == animation_.get()) {
+//       Layout();
+//       SchedulePaint();
+//     } else if (animation == other_animation_.get()) {
+//       ...
+//     }
+//   }
+//   void Layout() {
+//     if (animation_->is_animating()) {
+//       hover_image_.SetOpacity(animation_->GetCurrentValue());
+//     }
+//   }
+//  private:
+//   std::unique_ptr<SlideAnimation> animation_;
+// }
+class ANIMATION_EXPORT SlideAnimation : public LinearAnimation {
+ public:
+  explicit SlideAnimation(AnimationDelegate* target);
+
+  SlideAnimation(const SlideAnimation&) = delete;
+  SlideAnimation& operator=(const SlideAnimation&) = delete;
+
+  ~SlideAnimation() override;
+
+  // Set the animation to some state.
+  virtual void Reset(double value = 0);
+
+  // Begin a showing animation or reverse a hiding animation in progress.
+  // Animates GetCurrentValue() towards 1.
+  virtual void Show();
+
+  // Begin a hiding animation or reverse a showing animation in progress.
+  // Animates GetCurrentValue() towards 0.
+  virtual void Hide();
+
+  // Sets the time a slide will take. Note that this isn't actually
+  // the amount of time an animation will take as the current value of
+  // the slide is considered.
+  virtual void SetSlideDuration(base::TimeDelta duration);
+  base::TimeDelta GetSlideDuration() const { return slide_duration_; }
+  void SetTweenType(Tween::Type tween_type) { tween_type_ = tween_type; }
+
+  // Dampens the reduction in duration for an animation which starts partway.
+  // The default value of 1 has no effect.
+  void SetDampeningValue(double dampening_value);
+
+  double GetCurrentValue() const override;
+  // TODO(bruthig): Fix IsShowing() and IsClosing() to be consistent. e.g.
+  // IsShowing() will currently return true after the 'show' animation has been
+  // completed however IsClosing() will return false after the 'hide' animation
+  // has been completed.
+  bool IsShowing() const {
+    return direction_ == Direction::kShowing ||
+           (!direction_ && value_current_ == 1);
+  }
+  bool IsClosing() const {
+    return direction_ == Direction::kHiding && value_end_ < value_current_;
+  }
+
+  class TestApi;
+
+ private:
+  // Gets the duration based on the dampening factor and whether the animation
+  // is showing or hiding.
+  base::TimeDelta GetDuration();
+
+  enum class Direction {
+    kShowing,
+    kHiding,
+  };
+
+  // Implementation of Show() and Hide().
+  void BeginAnimating(Direction direction);
+
+  // Overridden from Animation.
+  void AnimateToState(double state) override;
+
+  AnimationDelegate* target_;
+
+  Tween::Type tween_type_ = Tween::EASE_OUT;
+
+  // Current animation direction, or nullopt if not animating.
+  absl::optional<Direction> direction_;
+
+  // Animation values. These are a layer on top of Animation::state_ to
+  // provide the reversability.
+  double value_start_ = 0;
+  double value_end_ = 0;
+  double value_current_ = 0;
+
+  // How long a hover in/out animation will last for. This can be overridden
+  // with SetSlideDuration().
+  base::TimeDelta slide_duration_ = base::Milliseconds(120);
+
+  // Dampens the reduction in duration for animations which start partway.
+  double dampening_value_ = 1.0;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_SLIDE_ANIMATION_H_
diff --git a/ui/gfx/animation/slide_animation_unittest.cc b/ui/gfx/animation/slide_animation_unittest.cc
new file mode 100644
index 0000000..9a53c86
--- /dev/null
+++ b/ui/gfx/animation/slide_animation_unittest.cc
@@ -0,0 +1,242 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/animation/slide_animation.h"
+
+#include <memory>
+
+#include "base/macros.h"
+#include "base/test/task_environment.h"
+#include "base/time/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/animation/animation_test_api.h"
+#include "ui/gfx/animation/test_animation_delegate.h"
+
+namespace gfx {
+
+////////////////////////////////////////////////////////////////////////////////
+// SlideAnimationTest
+class SlideAnimationTest : public testing::Test {
+ public:
+  void RunAnimationFor(base::TimeDelta duration) {
+    base::TimeTicks now = base::TimeTicks::Now();
+    animation_api_->SetStartTime(now);
+    animation_api_->Step(now + duration);
+  }
+
+  std::unique_ptr<AnimationTestApi> animation_api_;
+  std::unique_ptr<SlideAnimation> slide_animation_;
+
+ protected:
+  SlideAnimationTest()
+      : task_environment_(
+            base::test::SingleThreadTaskEnvironment::MainThreadType::UI) {
+    slide_animation_ = std::make_unique<SlideAnimation>(nullptr);
+    animation_api_ = std::make_unique<AnimationTestApi>(slide_animation_.get());
+  }
+
+ private:
+  base::test::SingleThreadTaskEnvironment task_environment_;
+};
+
+// Tests animation construction.
+TEST_F(SlideAnimationTest, InitialState) {
+  // By default, slide animations are 60 Hz, so the timer interval should be
+  // 1/60th of a second.
+  EXPECT_EQ(1000 / 60, slide_animation_->timer_interval().InMilliseconds());
+  // Duration defaults to 120 ms.
+  EXPECT_EQ(120, slide_animation_->GetSlideDuration().InMilliseconds());
+  // Slide is neither showing nor closing.
+  EXPECT_FALSE(slide_animation_->IsShowing());
+  EXPECT_FALSE(slide_animation_->IsClosing());
+  // Starts at 0.
+  EXPECT_EQ(0.0, slide_animation_->GetCurrentValue());
+}
+
+TEST_F(SlideAnimationTest, Basics) {
+  // Use linear tweening to make the math easier below.
+  slide_animation_->SetTweenType(Tween::LINEAR);
+
+  // Duration can be set after construction.
+  slide_animation_->SetSlideDuration(base::Milliseconds(100));
+  EXPECT_EQ(100, slide_animation_->GetSlideDuration().InMilliseconds());
+
+  // Show toggles the appropriate state.
+  slide_animation_->Show();
+  EXPECT_TRUE(slide_animation_->IsShowing());
+  EXPECT_FALSE(slide_animation_->IsClosing());
+
+  // Simulate running the animation.
+  RunAnimationFor(base::Milliseconds(50));
+  EXPECT_EQ(0.5, slide_animation_->GetCurrentValue());
+
+  // We can start hiding mid-way through the animation.
+  slide_animation_->Hide();
+  EXPECT_FALSE(slide_animation_->IsShowing());
+  EXPECT_TRUE(slide_animation_->IsClosing());
+
+  // Reset stops the animation.
+  slide_animation_->Reset();
+  EXPECT_EQ(0.0, slide_animation_->GetCurrentValue());
+  EXPECT_FALSE(slide_animation_->IsShowing());
+  EXPECT_FALSE(slide_animation_->IsClosing());
+}
+
+// Tests that delegate is not notified when animation is running and is deleted.
+// (Such a scenario would cause problems for BoundsAnimator).
+TEST_F(SlideAnimationTest, DontNotifyOnDelete) {
+  TestAnimationDelegate delegate;
+  std::unique_ptr<SlideAnimation> animation(new SlideAnimation(&delegate));
+
+  // Start the animation.
+  animation->Show();
+
+  // Delete the animation.
+  animation.reset();
+
+  // Make sure the delegate wasn't notified.
+  EXPECT_FALSE(delegate.finished());
+  EXPECT_FALSE(delegate.canceled());
+}
+
+// Tests that animations which are started partway and have a dampening factor
+// of 1 progress linearly.
+TEST_F(SlideAnimationTest,
+       AnimationWithPartialProgressAndDefaultDampeningFactor) {
+  slide_animation_->SetTweenType(Tween::LINEAR);
+  slide_animation_->SetSlideDuration(base::Milliseconds(100));
+  slide_animation_->Show();
+  EXPECT_EQ(slide_animation_->GetCurrentValue(), 0.0);
+
+  // Advance the animation to halfway done.
+  RunAnimationFor(base::Milliseconds(50));
+  EXPECT_EQ(0.5, slide_animation_->GetCurrentValue());
+
+  // Reverse the animation and run it for half of the remaining duration.
+  slide_animation_->Hide();
+  RunAnimationFor(base::Milliseconds(25));
+  EXPECT_EQ(0.25, slide_animation_->GetCurrentValue());
+
+  // Reverse the animation again and run it for half of the remaining duration.
+  slide_animation_->Show();
+  RunAnimationFor(base::Milliseconds(37.5));
+  EXPECT_EQ(0.625, slide_animation_->GetCurrentValue());
+}
+
+// Tests that animations which are started partway and have a dampening factor
+// of >1 progress sub-leanearly.
+TEST_F(SlideAnimationTest,
+       AnimationWithPartialProgressAndNonDefaultDampeningFactor) {
+  slide_animation_->SetTweenType(Tween::LINEAR);
+  slide_animation_->SetDampeningValue(2.0);
+  slide_animation_->SetSlideDuration(base::Milliseconds(100));
+  slide_animation_->Show();
+  // Advance the animation to halfway done.
+  RunAnimationFor(base::Milliseconds(50));
+  EXPECT_EQ(0.5, slide_animation_->GetCurrentValue());
+
+  // Reverse the animation and run it for the same duration, it should be
+  // sub-linear with dampening.
+  slide_animation_->Hide();
+  RunAnimationFor(base::Milliseconds(50));
+  EXPECT_GT(slide_animation_->GetCurrentValue(), 0);
+}
+
+// Tests that a mostly complete dampened animation takes a sub-linear
+// amount of time to complete.
+TEST_F(SlideAnimationTest, DampenedAnimationMostlyComplete) {
+  slide_animation_->SetTweenType(Tween::LINEAR);
+  slide_animation_->SetDampeningValue(2.0);
+  slide_animation_->SetSlideDuration(base::Milliseconds(100));
+  slide_animation_->Show();
+  // Advance the animation to 1/10th of the way done.
+  RunAnimationFor(base::Milliseconds(10));
+  EXPECT_EQ(0.1, slide_animation_->GetCurrentValue());
+
+  // Reverse the animation and run it for 1/10th of the duration, it should not
+  // be complete.
+  slide_animation_->Hide();
+  RunAnimationFor(base::Milliseconds(10));
+  EXPECT_GT(slide_animation_->GetCurrentValue(), 0);
+
+  // Finish the animation and set up the test for a mostly complete show
+  // animation.
+  RunAnimationFor(base::Milliseconds(100));
+  EXPECT_EQ(0, slide_animation_->GetCurrentValue());
+  slide_animation_->Show();
+  // Advance the animation to 9/10th of the way done.
+  RunAnimationFor(base::Milliseconds(90));
+  EXPECT_EQ(0.9, slide_animation_->GetCurrentValue());
+
+  // Hide and then Show the animation to force the duration to be recalculated,
+  // then show for 1/10th of the duration and test that the animation is not
+  // complete.
+  slide_animation_->Hide();
+  slide_animation_->Show();
+  RunAnimationFor(base::Milliseconds(10));
+  EXPECT_LT(slide_animation_->GetCurrentValue(), 1);
+
+  RunAnimationFor(base::Milliseconds(40));
+  EXPECT_EQ(1, slide_animation_->GetCurrentValue());
+}
+
+// Tests that a mostly incomplete dampened animation takes a sub-linear amount
+// of time to complete.
+TEST_F(SlideAnimationTest, DampenedAnimationMostlyIncomplete) {
+  slide_animation_->SetTweenType(Tween::LINEAR);
+  slide_animation_->SetDampeningValue(2.0);
+  slide_animation_->SetSlideDuration(base::Milliseconds(100));
+  slide_animation_->Show();
+  // Advance the animation to 1/10th of the way done.
+  RunAnimationFor(base::Milliseconds(10));
+  EXPECT_EQ(0.1, slide_animation_->GetCurrentValue());
+
+  // Hide and then Show the animation to force the duration to be recalculated,
+  // then show for 9/10th of the duration and test that the animation is not
+  // complete.
+  slide_animation_->Hide();
+  slide_animation_->Show();
+  RunAnimationFor(base::Milliseconds(90));
+  EXPECT_LT(slide_animation_->GetCurrentValue(), 1);
+
+  // Finish the animation and set up the test for a mostly incomplete hide
+  // animation.
+  RunAnimationFor(base::Milliseconds(100));
+  EXPECT_EQ(1, slide_animation_->GetCurrentValue());
+  slide_animation_->Hide();
+  RunAnimationFor(base::Milliseconds(10));
+  EXPECT_EQ(0.9, slide_animation_->GetCurrentValue());
+
+  // Show and then hide the animation to recompute the duration, then run the
+  // animation for 9/10ths of the duration and test that the animation is not
+  // complete.
+  slide_animation_->Show();
+  slide_animation_->Hide();
+  RunAnimationFor(base::Milliseconds(90));
+  EXPECT_GT(slide_animation_->GetCurrentValue(), 0);
+
+  RunAnimationFor(base::Milliseconds(100));
+  EXPECT_EQ(0, slide_animation_->GetCurrentValue());
+}
+
+TEST_F(SlideAnimationTest, HideFromHalfway) {
+  auto container = base::MakeRefCounted<AnimationContainer>();
+  AnimationContainerTestApi test_api(container.get());
+
+  slide_animation_->SetContainer(container.get());
+  slide_animation_->SetTweenType(Tween::LINEAR);
+  slide_animation_->SetSlideDuration(base::Milliseconds(100));
+
+  slide_animation_->Reset(0.5);
+  EXPECT_FALSE(slide_animation_->is_animating());
+  EXPECT_EQ(0.5, slide_animation_->GetCurrentValue());
+
+  slide_animation_->Hide();
+  ASSERT_TRUE(slide_animation_->is_animating());
+
+  test_api.IncrementTime(base::Milliseconds(100));
+  EXPECT_EQ(0.0, slide_animation_->GetCurrentValue());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/test_animation_delegate.h b/ui/gfx/animation/test_animation_delegate.h
new file mode 100644
index 0000000..99da556
--- /dev/null
+++ b/ui/gfx/animation/test_animation_delegate.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_TEST_ANIMATION_DELEGATE_H_
+#define UI_GFX_ANIMATION_TEST_ANIMATION_DELEGATE_H_
+
+#include "base/macros.h"
+#include "base/run_loop.h"
+#include "ui/gfx/animation/animation_delegate.h"
+
+namespace gfx {
+
+// Trivial AnimationDelegate implementation. AnimationEnded/Canceled quit the
+// message loop.
+class TestAnimationDelegate : public AnimationDelegate {
+ public:
+  TestAnimationDelegate() = default;
+
+  TestAnimationDelegate(const TestAnimationDelegate&) = delete;
+  TestAnimationDelegate& operator=(const TestAnimationDelegate&) = delete;
+
+  virtual void AnimationEnded(const Animation* animation) {
+    finished_ = true;
+    if (base::RunLoop::IsRunningOnCurrentThread())
+      base::RunLoop::QuitCurrentWhenIdleDeprecated();
+  }
+
+  virtual void AnimationCanceled(const Animation* animation) {
+    canceled_ = true;
+    AnimationEnded(animation);
+  }
+
+  bool finished() const { return finished_; }
+  bool canceled() const { return canceled_; }
+
+ private:
+  bool canceled_ = false;
+  bool finished_ = false;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_TEST_ANIMATION_DELEGATE_H_
diff --git a/ui/gfx/animation/throb_animation.cc b/ui/gfx/animation/throb_animation.cc
new file mode 100644
index 0000000..2c2f90c
--- /dev/null
+++ b/ui/gfx/animation/throb_animation.cc
@@ -0,0 +1,73 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/animation/throb_animation.h"
+
+#include <limits>
+
+namespace gfx {
+
+ThrobAnimation::ThrobAnimation(AnimationDelegate* target)
+    : SlideAnimation(target) {}
+
+void ThrobAnimation::StartThrobbing(int cycles_til_stop) {
+  if (cycles_til_stop < 0)
+    cycles_til_stop = std::numeric_limits<int>::max();
+  cycles_remaining_ = cycles_til_stop;
+  throbbing_ = true;
+  SlideAnimation::SetSlideDuration(throb_duration_);
+  if (is_animating())
+    return;  // We're already running, we'll cycle when current loop finishes.
+
+  if (IsShowing())
+    SlideAnimation::Hide();
+  else
+    SlideAnimation::Show();
+}
+
+void ThrobAnimation::Reset(double value) {
+  StopThrobbing();
+  SlideAnimation::Reset(value);
+}
+
+void ThrobAnimation::Show() {
+  StopThrobbing();
+  SlideAnimation::Show();
+}
+
+void ThrobAnimation::Hide() {
+  StopThrobbing();
+  SlideAnimation::Hide();
+}
+
+void ThrobAnimation::SetSlideDuration(base::TimeDelta duration) {
+  slide_duration_ = duration;
+}
+
+void ThrobAnimation::Step(base::TimeTicks time_now) {
+  LinearAnimation::Step(time_now);
+
+  if (!is_animating() && throbbing_) {
+    // Were throbbing a finished a cycle. Start the next cycle unless we're at
+    // the end of the cycles, in which case we stop.
+    cycles_remaining_--;
+    if (IsShowing()) {
+      // We want to stop hidden, hence this doesn't check cycles_remaining_.
+      SlideAnimation::Hide();
+    } else if (cycles_remaining_ > 0) {
+      SlideAnimation::Show();
+    } else {
+      // We're done throbbing.
+      throbbing_ = false;
+    }
+  }
+}
+
+void ThrobAnimation::StopThrobbing() {
+  SlideAnimation::SetSlideDuration(slide_duration_);
+  cycles_remaining_ = 0;
+  throbbing_ = false;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/throb_animation.h b/ui/gfx/animation/throb_animation.h
new file mode 100644
index 0000000..6e9d094
--- /dev/null
+++ b/ui/gfx/animation/throb_animation.h
@@ -0,0 +1,73 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_THROB_ANIMATION_H_
+#define UI_GFX_ANIMATION_THROB_ANIMATION_H_
+
+#include "base/macros.h"
+#include "ui/gfx/animation/slide_animation.h"
+
+namespace gfx {
+
+// A subclass of SlideAnimation that can continually slide. All of the Animation
+// methods behave like that of SlideAnimation: transition to the next state.
+// The StartThrobbing method causes the ThrobAnimation to cycle between hidden
+// and shown for a set number of cycles.
+//
+// A ThrobAnimation has two durations: the duration used when behavior like
+// a SlideAnimation, and the duration used when throbbing.
+class ANIMATION_EXPORT ThrobAnimation : public SlideAnimation {
+ public:
+  explicit ThrobAnimation(AnimationDelegate* target);
+
+  ThrobAnimation(const ThrobAnimation&) = delete;
+  ThrobAnimation& operator=(const ThrobAnimation&) = delete;
+
+  ~ThrobAnimation() override {}
+
+  // Starts throbbing. cycles_til_stop gives the number of cycles to do before
+  // stopping. A negative value means "throb indefinitely".
+  void StartThrobbing(int cycles_til_stop);
+
+  // Sets the duration of the slide animation when throbbing.
+  void SetThrobDuration(base::TimeDelta duration) {
+    throb_duration_ = duration;
+  }
+
+  // Overridden to reset to the slide duration.
+  void Reset(double value = 0) override;
+  void Show() override;
+  void Hide() override;
+
+  // Overridden to maintain the slide duration.
+  void SetSlideDuration(base::TimeDelta duration) override;
+
+  // The number of cycles remaining until the animation stops.
+  void set_cycles_remaining(int value) { cycles_remaining_ = value; }
+  int cycles_remaining() const { return cycles_remaining_; }
+
+ protected:
+  // Overriden to continually throb (assuming we're throbbing).
+  void Step(base::TimeTicks time_now) override;
+
+ private:
+  // Stops throbbing; as a result this will behave like a SlideAnimation.
+  void StopThrobbing();
+
+  // Duration of the slide animation.
+  base::TimeDelta slide_duration_ = GetSlideDuration();
+
+  // Duration of the slide animation when throbbing.
+  base::TimeDelta throb_duration_ = base::Milliseconds(400);
+
+  // If throbbing, this is the number of cycles left.
+  int cycles_remaining_ = 0;
+
+  // Are we throbbing?
+  bool throbbing_ = false;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_THROB_ANIMATION_H_
diff --git a/ui/gfx/animation/tween.cc b/ui/gfx/animation/tween.cc
new file mode 100644
index 0000000..928f5dd
--- /dev/null
+++ b/ui/gfx/animation/tween.cc
@@ -0,0 +1,260 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/animation/tween.h"
+
+#include <math.h>
+#include <stdint.h>
+
+#include <algorithm>
+
+#include "base/check_op.h"
+#include "base/notreached.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+#include "ui/gfx/geometry/cubic_bezier.h"
+
+#if defined(OS_WIN)
+#include <float.h>
+#endif
+
+namespace gfx {
+
+// static
+double Tween::CalculateValue(Tween::Type type, double state) {
+  DCHECK_GE(state, 0);
+  DCHECK_LE(state, 1);
+
+  switch (type) {
+    case EASE_IN:
+      return pow(state, 2);
+
+    case EASE_IN_2:
+      return pow(state, 4);
+
+    case EASE_IN_OUT:
+      if (state < 0.5)
+        return pow(state * 2, 2) / 2.0;
+      return 1.0 - (pow((state - 1.0) * 2, 2) / 2.0);
+
+    case EASE_IN_OUT_2:
+      return gfx::CubicBezier(0.33, 0, 0.67, 1).Solve(state);
+
+    case EASE_OUT_3:
+      return gfx::CubicBezier(0.6, 0, 0, 1).Solve(state);
+
+    case EASE_OUT_4:
+      return gfx::CubicBezier(1, 0, 0.8, 1).Solve(state);
+
+    case LINEAR:
+      return state;
+
+    case EASE_OUT:
+      return 1.0 - pow(1.0 - state, 2);
+
+    case EASE_OUT_2:
+      return gfx::CubicBezier(0.4, 0, 0, 1).Solve(state);
+
+    case SMOOTH_IN_OUT:
+      return sin(state);
+
+    case FAST_OUT_SLOW_IN:
+      return gfx::CubicBezier(0.4, 0, 0.2, 1).Solve(state);
+
+    case FAST_OUT_SLOW_IN_2:
+      return gfx::CubicBezier(0.2, 0, 0.2, 1).Solve(state);
+
+    case FAST_OUT_SLOW_IN_3:
+      return gfx::CubicBezier(0.2, 0, 0, 1).Solve(state);
+
+    case LINEAR_OUT_SLOW_IN:
+      return gfx::CubicBezier(0, 0, .2, 1).Solve(state);
+
+    case SLOW_OUT_LINEAR_IN:
+      return gfx::CubicBezier(0, 0, 1, .2).Solve(state);
+
+    case FAST_OUT_LINEAR_IN:
+      return gfx::CubicBezier(0.4, 0, 1, 1).Solve(state);
+
+    case ZERO:
+      return 0;
+
+    case ACCEL_LIN_DECEL_60:
+      return gfx::CubicBezier(0, 0, 0.4, 1).Solve(state);
+
+    case ACCEL_LIN_DECEL_100:
+      return gfx::CubicBezier(0, 0, 0, 1).Solve(state);
+
+    case ACCEL_20_DECEL_60:
+      return gfx::CubicBezier(0.2, 0, 0.4, 1).Solve(state);
+
+    case ACCEL_80_DECEL_20:
+      return gfx::CubicBezier(0.8, 0, 0.8, 1).Solve(state);
+
+    case ACCEL_0_40_DECEL_100:
+      return gfx::CubicBezier(0, 0.4, 0, 1).Solve(state);
+
+    case ACCEL_0_80_DECEL_80:
+      return gfx::CubicBezier(0, 0.8, 0.2, 1).Solve(state);
+  }
+
+  NOTREACHED();
+  return state;
+}
+
+namespace {
+
+uint8_t FloatToColorByte(float f) {
+  return base::ClampRound<uint8_t>(f * 255.0f);
+}
+
+uint8_t BlendColorComponents(uint8_t start,
+                             uint8_t target,
+                             float start_alpha,
+                             float target_alpha,
+                             float blended_alpha,
+                             double progress) {
+  // Since progress can be outside [0, 1], blending can produce a value outside
+  // [0, 255].
+  float blended_premultiplied = Tween::FloatValueBetween(
+      progress, start / 255.f * start_alpha, target / 255.f * target_alpha);
+  return FloatToColorByte(blended_premultiplied / blended_alpha);
+}
+
+}  // namespace
+
+// static
+SkColor Tween::ColorValueBetween(double value, SkColor start, SkColor target) {
+  float start_a = SkColorGetA(start) / 255.f;
+  float target_a = SkColorGetA(target) / 255.f;
+  float blended_a = FloatValueBetween(value, start_a, target_a);
+  if (blended_a <= 0.f)
+    return SK_ColorTRANSPARENT;
+  blended_a = std::min(blended_a, 1.f);
+
+  uint8_t blended_r =
+      BlendColorComponents(SkColorGetR(start), SkColorGetR(target), start_a,
+                           target_a, blended_a, value);
+  uint8_t blended_g =
+      BlendColorComponents(SkColorGetG(start), SkColorGetG(target), start_a,
+                           target_a, blended_a, value);
+  uint8_t blended_b =
+      BlendColorComponents(SkColorGetB(start), SkColorGetB(target), start_a,
+                           target_a, blended_a, value);
+
+  return SkColorSetARGB(
+      FloatToColorByte(blended_a), blended_r, blended_g, blended_b);
+}
+
+// static
+double Tween::DoubleValueBetween(double value, double start, double target) {
+  return start + (target - start) * value;
+}
+
+// static
+float Tween::FloatValueBetween(double value, float start, float target) {
+  return static_cast<float>(start + (target - start) * value);
+}
+
+// static
+float Tween::ClampedFloatValueBetween(const base::TimeTicks& time,
+                                      const base::TimeTicks& start_time,
+                                      float start,
+                                      const base::TimeTicks& target_time,
+                                      float target) {
+  if (time <= start_time)
+    return start;
+  if (time >= target_time)
+    return target;
+
+  const double progress = (time - start_time) / (target_time - start_time);
+  return FloatValueBetween(progress, start, target);
+}
+
+// static
+int Tween::IntValueBetween(double value, int start, int target) {
+  if (start == target)
+    return start;
+  double delta = static_cast<double>(target - start);
+  if (delta < 0)
+    delta--;
+  else
+    delta++;
+#if defined(OS_WIN)
+  return start + static_cast<int>(value * _nextafter(delta, 0));
+#else
+  return start + static_cast<int>(value * nextafter(delta, 0));
+#endif
+}
+
+// static
+int Tween::LinearIntValueBetween(double value, int start, int target) {
+  // NOTE: Do not use base::ClampRound()!  See comments on function declaration.
+  return base::ClampFloor(0.5 + DoubleValueBetween(value, start, target));
+}
+
+// static
+gfx::Rect Tween::RectValueBetween(double value,
+                                  const gfx::Rect& start,
+                                  const gfx::Rect& target) {
+  const int x = LinearIntValueBetween(value, start.x(), target.x());
+  const int y = LinearIntValueBetween(value, start.y(), target.y());
+  const int right = LinearIntValueBetween(value, start.right(), target.right());
+  const int bottom =
+      LinearIntValueBetween(value, start.bottom(), target.bottom());
+  return gfx::Rect(x, y, right - x, bottom - y);
+}
+
+// static
+gfx::RectF Tween::RectFValueBetween(double value,
+                                    const gfx::RectF& start,
+                                    const gfx::RectF& target) {
+  const float x = FloatValueBetween(value, start.x(), target.x());
+  const float y = FloatValueBetween(value, start.y(), target.y());
+  const float right = FloatValueBetween(value, start.right(), target.right());
+  const float bottom =
+      FloatValueBetween(value, start.bottom(), target.bottom());
+  return gfx::RectF(x, y, right - x, bottom - y);
+}
+
+// static
+gfx::Transform Tween::TransformValueBetween(double value,
+                                            const gfx::Transform& start,
+                                            const gfx::Transform& target) {
+  if (value >= 1.0)
+    return target;
+  if (value <= 0.0)
+    return start;
+
+  gfx::Transform to_return = target;
+  to_return.Blend(start, value);
+  return to_return;
+}
+
+// static
+gfx::TransformOperations Tween::TransformOperationsValueBetween(
+    double value,
+    const gfx::TransformOperations& start,
+    const gfx::TransformOperations& target) {
+  return target.Blend(start, value);
+}
+
+gfx::Size Tween::SizeValueBetween(double value,
+                                  const gfx::Size& start,
+                                  const gfx::Size& target) {
+  return gfx::Size(
+      Tween::LinearIntValueBetween(value, start.width(), target.width()),
+      Tween::LinearIntValueBetween(value, start.height(), target.height()));
+}
+
+gfx::SizeF Tween::SizeFValueBetween(double value,
+                                    const gfx::SizeF& start,
+                                    const gfx::SizeF& target) {
+  return gfx::SizeF(
+      Tween::FloatValueBetween(value, start.width(), target.width()),
+      Tween::FloatValueBetween(value, start.height(), target.height()));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/animation/tween.h b/ui/gfx/animation/tween.h
new file mode 100644
index 0000000..da3d12d
--- /dev/null
+++ b/ui/gfx/animation/tween.h
@@ -0,0 +1,144 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ANIMATION_TWEEN_H_
+#define UI_GFX_ANIMATION_TWEEN_H_
+
+#include "base/macros.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/animation/animation_export.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/geometry/transform_operations.h"
+
+namespace base {
+class TimeTicks;
+}
+
+namespace gfx {
+
+class ANIMATION_EXPORT Tween {
+ public:
+  enum Type {
+    LINEAR,            // Linear.
+    EASE_OUT,          // Fast in, slow out (default).
+    EASE_OUT_2,        // Variant of EASE_OUT that ends slower than EASE_OUT.
+    EASE_OUT_3,        // Variant of EASE_OUT that ends slower than EASE_OUT_2.
+    EASE_OUT_4,        // Variant of EASE_OUT that start slower than EASE_OUT_3,
+                       // and ends faster. Best used to lead into a bounce
+                       // animation.
+    EASE_IN,           // Slow in, fast out.
+    EASE_IN_2,         // Variant of EASE_IN that starts out slower than
+                       // EASE_IN.
+    EASE_IN_OUT,       // Slow in and out, fast in the middle.
+    EASE_IN_OUT_2,     // Variant of EASE_IN_OUT that starts and ends slower
+                       // than EASE_IN_OUT.
+    SMOOTH_IN_OUT,     // Smooth, consistent speeds in and out (sine wave).
+    FAST_OUT_SLOW_IN,  // Variant of EASE_IN_OUT which should be used in most
+                       // cases.
+    FAST_OUT_SLOW_IN_2,  // Variant of FAST_OUT_SLOW_IN that starts out quicker.
+    FAST_OUT_SLOW_IN_3,  // Variant of FAST_OUT_SLOW_IN that starts out quicker
+                         // than FAST_OUT_SLOW_IN_2. Best used for rebound in
+                         // bounce animation.
+    LINEAR_OUT_SLOW_IN,  // Variant of EASE_OUT which should be used for
+                         // fading in from 0% or motion when entering a scene.
+    SLOW_OUT_LINEAR_IN,  // Reverse of LINEAR_OUT_SLOW_IN which should be used
+                         // in reverse animation to create a rubberband effect.
+    FAST_OUT_LINEAR_IN,  // Variant of EASE_IN which should should be used for
+                         // fading out to 0% or motion when exiting a scene.
+    ZERO,                // Returns a value of 0 always.
+
+    // TODO(zxdan): New animation curve name convention will be used to resolve
+    // the confusion caused by "IN" and "OUT".
+
+    // The new name convention is below:
+    // ACCEL_<1>_DECEL_<2> where <1> and <2> are used to express the
+    // acceleration and deceleration speeds. The corresponding cubic bezier
+    // curve parameters would be ( 0.01 * <1>, 0, 1 - 0.01 * <2>, 1 ). Note that
+    // LIN means the speed is 0. For example,
+    // ACCEL_20_DECEL_20 = (0.2, 0, 0.8, 1): https://cubic-bezier.com/#.2,0,.8,1
+    // ACCEL_100_DECEL_100 = (1, 0, 0, 1): https://cubic-bezier.com/#1,0,0,1
+    // ACCEL_LIN_DECEL_LIN = (0, 0, 1, 1): https://cubic-bezier.com/#0,0,1,1
+    // ACCEL_40_DECEL_80 = (0.4, 0, 0.2, 1): https://cubic-bezier.com/#.4,0,.2,1
+    ACCEL_LIN_DECEL_60,   // Pulling a small to medium element into a place.
+    ACCEL_LIN_DECEL_100,  // Pulling a small to medium element into a place that
+                          // has very fast deceleration.
+    ACCEL_20_DECEL_60,  // Moving a small, low emphasis or responsive elements.
+    ACCEL_80_DECEL_20,  // Slow in and fast out with ease.
+
+    // ACCEL_0_<1>_DECEL_<2> where <1> and <2> are used to express the
+    // acceleration and deceleration speeds. The corresponding cubic bezier
+    // curve parameters would be ( 0, 0.01 * <1>, 1 - 0.01 * <2>, 1 ).
+    ACCEL_0_40_DECEL_100,  // Specialized curve with an emphasized deceleration
+                           // drift.
+    ACCEL_0_80_DECEL_80,   // Variant of ACCEL_0_40_DECEL_100 which drops in
+                           // value faster, but flattens out into the drift
+                           // sooner.
+  };
+
+  Tween(const Tween&) = delete;
+  Tween& operator=(const Tween&) = delete;
+
+  // Returns the value based on the tween type. |state| is from 0-1.
+  static double CalculateValue(Type type, double state);
+
+  // Conveniences for getting a value between a start and end point.
+  static SkColor ColorValueBetween(double value, SkColor start, SkColor target);
+  static double DoubleValueBetween(double value, double start, double target);
+  static float FloatValueBetween(double value, float start, float target);
+  static float ClampedFloatValueBetween(const base::TimeTicks& time,
+                                        const base::TimeTicks& start_time,
+                                        float start,
+                                        const base::TimeTicks& target_time,
+                                        float target);
+
+  // Interpolated between start and target, with every integer in this range
+  // given equal weight.
+  static int IntValueBetween(double value, int start, int target);
+
+  // Interpolates between start and target as real numbers, and rounds the
+  // result to the nearest integer, with ties broken by rounding towards
+  // positive infinity. This gives start and target half the weight of the
+  // other integers in the range. This is the integer interpolation approach
+  // specified by www.w3.org/TR/css3-transitions.
+  static int LinearIntValueBetween(double value, int start, int target);
+
+  // Interpolates between |start| and |target| rects, animating the rect corners
+  // (as opposed to animating the rect origin and size) to minimize rounding
+  // error accumulation at intermediate stages.
+  static gfx::Rect RectValueBetween(double value,
+                                    const gfx::Rect& start,
+                                    const gfx::Rect& target);
+
+  static gfx::RectF RectFValueBetween(double value,
+                                      const gfx::RectF& start,
+                                      const gfx::RectF& target);
+
+  static gfx::Transform TransformValueBetween(double value,
+                                              const gfx::Transform& start,
+                                              const gfx::Transform& target);
+
+  static gfx::TransformOperations TransformOperationsValueBetween(
+      double value,
+      const gfx::TransformOperations& start,
+      const gfx::TransformOperations& target);
+
+  static gfx::Size SizeValueBetween(double value,
+                                    const gfx::Size& start,
+                                    const gfx::Size& target);
+
+  static gfx::SizeF SizeFValueBetween(double value,
+                                      const gfx::SizeF& start,
+                                      const gfx::SizeF& target);
+
+ private:
+  Tween();
+  ~Tween();
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ANIMATION_TWEEN_H_
diff --git a/ui/gfx/animation/tween_unittest.cc b/ui/gfx/animation/tween_unittest.cc
new file mode 100644
index 0000000..19ff9eb
--- /dev/null
+++ b/ui/gfx/animation/tween_unittest.cc
@@ -0,0 +1,233 @@
+// 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.
+
+#include "ui/gfx/animation/tween.h"
+
+#include <math.h>
+
+#include "base/time/time.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/test/gfx_util.h"
+
+#if defined(OS_WIN)
+#include <float.h>
+#endif
+
+namespace gfx {
+namespace {
+
+double next_double(double d) {
+#if defined(OS_WIN)
+  return _nextafter(d, d + 1);
+#else
+  // Step two units of least precision towards positive infinity. On some 32
+  // bit x86 compilers a single step was not enough due to loss of precision in
+  // optimized code.
+  return nextafter(nextafter(d, d + 1), d + 1);
+#endif
+}
+
+// Validates that the same interpolations are made as in Blink.
+TEST(TweenTest, ColorValueBetween) {
+  // From blink's AnimatableColorTest.
+  EXPECT_SKCOLOR_EQ(0xFF00FF00,
+                  Tween::ColorValueBetween(-10.0, 0xFF00FF00, 0xFF00FF00));
+  EXPECT_SKCOLOR_EQ(0xFF00FF00,
+                  Tween::ColorValueBetween(-10.0, 0xFF00FF00, 0xFFFF00FF));
+  EXPECT_SKCOLOR_EQ(0xFF00FF00,
+                  Tween::ColorValueBetween(0.0, 0xFF00FF00, 0xFFFF00FF));
+  EXPECT_SKCOLOR_EQ(0xFF01FE01,
+                  Tween::ColorValueBetween(1.0 / 255, 0xFF00FF00, 0xFFFF00FF));
+  EXPECT_SKCOLOR_EQ(0xFF808080,
+                  Tween::ColorValueBetween(0.5, 0xFF00FF00, 0xFFFF00FF));
+  EXPECT_SKCOLOR_EQ(
+      0xFFFE01FE,
+      Tween::ColorValueBetween(254.0 / 255.0, 0xFF00FF00, 0xFFFF00FF));
+  EXPECT_SKCOLOR_EQ(0xFFFF00FF,
+                  Tween::ColorValueBetween(1.0, 0xFF00FF00, 0xFFFF00FF));
+  EXPECT_SKCOLOR_EQ(0xFFFF00FF,
+                  Tween::ColorValueBetween(10.0, 0xFF00FF00, 0xFFFF00FF));
+  EXPECT_SKCOLOR_EQ(0xFF0C253E,
+                  Tween::ColorValueBetween(3.0 / 16.0, 0xFF001020, 0xFF4080C0));
+  EXPECT_SKCOLOR_EQ(0x80FF00FF,
+                  Tween::ColorValueBetween(0.5, 0x0000FF00, 0xFFFF00FF));
+  EXPECT_SKCOLOR_EQ(0x60AA55AA,
+                  Tween::ColorValueBetween(0.5, 0x4000FF00, 0x80FF00FF));
+  EXPECT_SKCOLOR_EQ(0x60FFAAFF,
+                  Tween::ColorValueBetween(0.5, 0x40FF00FF, 0x80FFFFFF));
+  EXPECT_SKCOLOR_EQ(0x103060A0,
+                  Tween::ColorValueBetween(0.5, 0x10204080, 0x104080C0));
+}
+
+// Ensures that each of the 3 integers in [0, 1, 2] ae selected with equal
+// weight.
+TEST(TweenTest, IntValueBetween) {
+  EXPECT_EQ(0, Tween::IntValueBetween(0.0, 0, 2));
+  EXPECT_EQ(0, Tween::IntValueBetween(0.5 / 3.0, 0, 2));
+  EXPECT_EQ(0, Tween::IntValueBetween(1.0 / 3.0, 0, 2));
+
+  EXPECT_EQ(1, Tween::IntValueBetween(next_double(1.0 / 3.0), 0, 2));
+  EXPECT_EQ(1, Tween::IntValueBetween(1.5 / 3.0, 0, 2));
+  EXPECT_EQ(1, Tween::IntValueBetween(2.0 / 3.0, 0, 2));
+
+  EXPECT_EQ(2, Tween::IntValueBetween(next_double(2.0 / 3.0), 0, 2));
+  EXPECT_EQ(2, Tween::IntValueBetween(2.5 / 3.0, 0, 2));
+  EXPECT_EQ(2, Tween::IntValueBetween(3.0 / 3.0, 0, 2));
+}
+
+TEST(TweenTest, IntValueBetweenNegative) {
+  EXPECT_EQ(-2, Tween::IntValueBetween(0.0, -2, 0));
+  EXPECT_EQ(-2, Tween::IntValueBetween(0.5 / 3.0, -2, 0));
+  EXPECT_EQ(-2, Tween::IntValueBetween(1.0 / 3.0, -2, 0));
+
+  EXPECT_EQ(-1, Tween::IntValueBetween(next_double(1.0 / 3.0), -2, 0));
+  EXPECT_EQ(-1, Tween::IntValueBetween(1.5 / 3.0, -2, 0));
+  EXPECT_EQ(-1, Tween::IntValueBetween(2.0 / 3.0, -2, 0));
+
+  EXPECT_EQ(0, Tween::IntValueBetween(next_double(2.0 / 3.0), -2, 0));
+  EXPECT_EQ(0, Tween::IntValueBetween(2.5 / 3.0, -2, 0));
+  EXPECT_EQ(0, Tween::IntValueBetween(3.0 / 3.0, -2, 0));
+}
+
+TEST(TweenTest, IntValueBetweenReverse) {
+  EXPECT_EQ(2, Tween::IntValueBetween(0.0, 2, 0));
+  EXPECT_EQ(2, Tween::IntValueBetween(0.5 / 3.0, 2, 0));
+  EXPECT_EQ(2, Tween::IntValueBetween(1.0 / 3.0, 2, 0));
+
+  EXPECT_EQ(1, Tween::IntValueBetween(next_double(1.0 / 3.0), 2, 0));
+  EXPECT_EQ(1, Tween::IntValueBetween(1.5 / 3.0, 2, 0));
+  EXPECT_EQ(1, Tween::IntValueBetween(2.0 / 3.0, 2, 0));
+
+  EXPECT_EQ(0, Tween::IntValueBetween(next_double(2.0 / 3.0), 2, 0));
+  EXPECT_EQ(0, Tween::IntValueBetween(2.5 / 3.0, 2, 0));
+  EXPECT_EQ(0, Tween::IntValueBetween(3.0 / 3.0, 2, 0));
+}
+
+TEST(TweenTest, LinearIntValueBetween) {
+  EXPECT_EQ(0, Tween::LinearIntValueBetween(0.0, 0, 2));
+  EXPECT_EQ(0, Tween::LinearIntValueBetween(0.5 / 4.0, 0, 2));
+  EXPECT_EQ(0, Tween::LinearIntValueBetween(0.99 / 4.0, 0, 2));
+
+  EXPECT_EQ(1, Tween::LinearIntValueBetween(1.0 / 4.0, 0, 2));
+  EXPECT_EQ(1, Tween::LinearIntValueBetween(1.5 / 4.0, 0, 2));
+  EXPECT_EQ(1, Tween::LinearIntValueBetween(2.0 / 4.0, 0, 2));
+  EXPECT_EQ(1, Tween::LinearIntValueBetween(2.5 / 4.0, 0, 2));
+  EXPECT_EQ(1, Tween::LinearIntValueBetween(2.99 / 4.0, 0, 2));
+
+  EXPECT_EQ(2, Tween::LinearIntValueBetween(3.0 / 4.0, 0, 2));
+  EXPECT_EQ(2, Tween::LinearIntValueBetween(3.5 / 4.0, 0, 2));
+  EXPECT_EQ(2, Tween::LinearIntValueBetween(4.0 / 4.0, 0, 2));
+}
+
+TEST(TweenTest, LinearIntValueBetweenNegative) {
+  EXPECT_EQ(-2, Tween::LinearIntValueBetween(0.0, -2, 0));
+  EXPECT_EQ(-2, Tween::LinearIntValueBetween(0.5 / 4.0, -2, 0));
+  EXPECT_EQ(-2, Tween::LinearIntValueBetween(0.99 / 4.0, -2, 0));
+
+  EXPECT_EQ(-1, Tween::LinearIntValueBetween(1.0 / 4.0, -2, 0));
+  EXPECT_EQ(-1, Tween::LinearIntValueBetween(1.5 / 4.0, -2, 0));
+  EXPECT_EQ(-1, Tween::LinearIntValueBetween(2.0 / 4.0, -2, 0));
+  EXPECT_EQ(-1, Tween::LinearIntValueBetween(2.5 / 4.0, -2, 0));
+  EXPECT_EQ(-1, Tween::LinearIntValueBetween(2.99 / 4.0, -2, 0));
+
+  EXPECT_EQ(0, Tween::LinearIntValueBetween(3.0 / 4.0, -2, 0));
+  EXPECT_EQ(0, Tween::LinearIntValueBetween(3.5 / 4.0, -2, 0));
+  EXPECT_EQ(0, Tween::LinearIntValueBetween(4.0 / 4.0, -2, 0));
+}
+
+TEST(TweenTest, ClampedFloatValueBetweenTimeTicks) {
+  const float v1 = 10.0f;
+  const float v2 = 20.0f;
+
+  const auto t0 = base::TimeTicks();
+
+  base::TimeTicks from = t0 + base::Seconds(1);
+  base::TimeTicks to = t0 + base::Seconds(2);
+
+  base::TimeTicks t_before = t0 + base::Seconds(0.9);
+  base::TimeTicks t_between = t0 + base::Seconds(1.6);
+  base::TimeTicks t_after = t0 + base::Seconds(2.2);
+
+  EXPECT_EQ(v1, Tween::ClampedFloatValueBetween(t_before, from, v1, to, v2));
+  EXPECT_EQ(16.0, Tween::ClampedFloatValueBetween(t_between, from, v1, to, v2));
+  EXPECT_EQ(v2, Tween::ClampedFloatValueBetween(t_after, from, v1, to, v2));
+}
+
+// Verifies the corners of the rect are animated, rather than the origin/size
+// (which would result in different rounding).
+TEST(TweenTest, RectValueBetween) {
+  constexpr gfx::Rect r1(0, 0, 10, 10);
+  constexpr gfx::Rect r2(10, 10, 30, 30);
+
+  // TODO(pkasting): Move the geometry test helpers from
+  // cc/test/geometry_test_utils.h to ui/gfx/test/gfx_util.h or similar and use
+  // a rect-comparison function here.
+  const gfx::Rect tweened = Tween::RectValueBetween(0.08, r1, r2);
+  EXPECT_EQ(11, tweened.width());
+  EXPECT_EQ(11, tweened.height());
+}
+
+TEST(TweenTest, SizeValueBetween) {
+  constexpr gfx::Size kSize1(12, 24);
+  constexpr gfx::Size kSize2(36, 48);
+
+  constexpr double kBefore = -0.125;
+  constexpr double kFrom = 0.0;
+  constexpr double kBetween = 0.5;
+  constexpr double kTo = 1.0;
+  constexpr double kAfter = 1.125;
+
+  EXPECT_EQ(gfx::Size(9, 21), Tween::SizeValueBetween(kBefore, kSize1, kSize2));
+  EXPECT_EQ(kSize1, Tween::SizeValueBetween(kFrom, kSize1, kSize2));
+  EXPECT_EQ(gfx::Size(24, 36),
+            Tween::SizeValueBetween(kBetween, kSize1, kSize2));
+  EXPECT_EQ(kSize2, Tween::SizeValueBetween(kTo, kSize1, kSize2));
+  EXPECT_EQ(gfx::Size(39, 51), Tween::SizeValueBetween(kAfter, kSize1, kSize2));
+}
+
+TEST(TweenTest, SizeValueBetweenClampedExtrapolation) {
+  constexpr gfx::Size kSize1(0, 0);
+  constexpr gfx::Size kSize2(36, 48);
+
+  constexpr double kBefore = -1.0f;
+
+  // We should not extrapolate in this case as it would result in a negative and
+  // invalid size.
+  EXPECT_EQ(kSize1, Tween::SizeValueBetween(kBefore, kSize1, kSize2));
+}
+
+TEST(TweenTest, SizeFValueBetween) {
+  const gfx::SizeF s1(12.0f, 24.0f);
+  const gfx::SizeF s2(36.0f, 48.0f);
+
+  constexpr double kBefore = -0.125;
+  constexpr double kFrom = 0.0;
+  constexpr double kBetween = 0.5;
+  constexpr double kTo = 1.0;
+  constexpr double kAfter = 1.125;
+
+  EXPECT_SIZEF_EQ(gfx::SizeF(9.0f, 21.0f),
+                  Tween::SizeFValueBetween(kBefore, s1, s2));
+  EXPECT_SIZEF_EQ(s1, Tween::SizeFValueBetween(kFrom, s1, s2));
+  EXPECT_SIZEF_EQ(gfx::SizeF(24.0f, 36.0f),
+                  Tween::SizeFValueBetween(kBetween, s1, s2));
+  EXPECT_SIZEF_EQ(s2, Tween::SizeFValueBetween(kTo, s1, s2));
+  EXPECT_SIZEF_EQ(gfx::SizeF(39.0f, 51.0f),
+                  Tween::SizeFValueBetween(kAfter, s1, s2));
+}
+
+TEST(TweenTest, SizeFValueBetweenClampedExtrapolation) {
+  const gfx::SizeF s1(0.0f, 0.0f);
+  const gfx::SizeF s2(36.0f, 48.0f);
+
+  constexpr double kBefore = -1.0f;
+
+  // We should not extrapolate in this case as it would result in a negative and
+  // invalid size.
+  EXPECT_SIZEF_EQ(s1, Tween::SizeFValueBetween(kBefore, s1, s2));
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/bidi_line_iterator.cc b/ui/gfx/bidi_line_iterator.cc
new file mode 100644
index 0000000..cda076a
--- /dev/null
+++ b/ui/gfx/bidi_line_iterator.cc
@@ -0,0 +1,75 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/bidi_line_iterator.h"
+
+#include "base/check.h"
+#include "base/notreached.h"
+
+namespace ui {
+namespace gfx {
+
+namespace {
+
+UBiDiLevel GetParagraphLevelForDirection(base::i18n::TextDirection direction) {
+  switch (direction) {
+    case base::i18n::UNKNOWN_DIRECTION:
+      return UBIDI_DEFAULT_LTR;
+    case base::i18n::RIGHT_TO_LEFT:
+      return 1;  // Highest RTL level.
+    case base::i18n::LEFT_TO_RIGHT:
+      return 0;  // Highest LTR level.
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
+}  // namespace
+
+BiDiLineIterator::BiDiLineIterator() : bidi_(nullptr) {}
+
+BiDiLineIterator::~BiDiLineIterator() {
+  if (bidi_) {
+    ubidi_close(bidi_);
+    bidi_ = nullptr;
+  }
+}
+
+bool BiDiLineIterator::Open(const std::u16string& text,
+                            base::i18n::TextDirection direction) {
+  DCHECK(!bidi_);
+  UErrorCode error = U_ZERO_ERROR;
+  bidi_ = ubidi_openSized(static_cast<int>(text.length()), 0, &error);
+  if (U_FAILURE(error))
+    return false;
+
+  ubidi_setPara(bidi_, text.data(), static_cast<int>(text.length()),
+                GetParagraphLevelForDirection(direction), nullptr, &error);
+  return (U_SUCCESS(error));
+}
+
+int BiDiLineIterator::CountRuns() const {
+  DCHECK(bidi_ != nullptr);
+  UErrorCode error = U_ZERO_ERROR;
+  const int runs = ubidi_countRuns(bidi_, &error);
+  return U_SUCCESS(error) ? runs : 0;
+}
+
+UBiDiDirection BiDiLineIterator::GetVisualRun(int index,
+                                              int* start,
+                                              int* length) const {
+  DCHECK(bidi_ != nullptr);
+  return ubidi_getVisualRun(bidi_, index, start, length);
+}
+
+void BiDiLineIterator::GetLogicalRun(int start,
+                                     int* end,
+                                     UBiDiLevel* level) const {
+  DCHECK(bidi_ != nullptr);
+  ubidi_getLogicalRun(bidi_, start, end, level);
+}
+
+}  // namespace gfx
+}  // namespace ui
diff --git a/ui/gfx/bidi_line_iterator.h b/ui/gfx/bidi_line_iterator.h
new file mode 100644
index 0000000..cf18117
--- /dev/null
+++ b/ui/gfx/bidi_line_iterator.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_BIDI_LINE_ITERATOR_H_
+#define UI_GFX_BIDI_LINE_ITERATOR_H_
+
+#include <string>
+
+#include "base/i18n/rtl.h"
+#include "base/macros.h"
+#include "third_party/icu/source/common/unicode/ubidi.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace ui {
+namespace gfx {
+
+// A simple wrapper class for the bidirectional iterator of ICU.
+// This class uses the bidirectional iterator of ICU to split a line of
+// bidirectional texts into visual runs in its display order.
+class GFX_EXPORT BiDiLineIterator {
+ public:
+  BiDiLineIterator();
+
+  BiDiLineIterator(const BiDiLineIterator&) = delete;
+  BiDiLineIterator& operator=(const BiDiLineIterator&) = delete;
+
+  ~BiDiLineIterator();
+
+  // Initializes the bidirectional iterator with the specified text.  Returns
+  // whether initialization succeeded.
+  bool Open(const std::u16string& text, base::i18n::TextDirection direction);
+
+  // Returns the number of visual runs in the text, or zero on error.
+  int CountRuns() const;
+
+  // Gets the logical offset, length, and direction of the specified visual run.
+  UBiDiDirection GetVisualRun(int index, int* start, int* length) const;
+
+  // Given a start position, figure out where the run ends (and the BiDiLevel).
+  void GetLogicalRun(int start, int* end, UBiDiLevel* level) const;
+
+ private:
+  UBiDi* bidi_;
+};
+
+}  // namespace gfx
+}  // namespace ui
+
+#endif  // UI_GFX_BIDI_LINE_ITERATOR_H_
diff --git a/ui/gfx/bidi_line_iterator_unittest.cc b/ui/gfx/bidi_line_iterator_unittest.cc
new file mode 100644
index 0000000..8a8f392
--- /dev/null
+++ b/ui/gfx/bidi_line_iterator_unittest.cc
@@ -0,0 +1,152 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/bidi_line_iterator.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace ui {
+namespace gfx {
+namespace {
+
+class BiDiLineIteratorTest
+    : public testing::TestWithParam<base::i18n::TextDirection> {
+ public:
+  BiDiLineIteratorTest() = default;
+
+  BiDiLineIteratorTest(const BiDiLineIteratorTest&) = delete;
+  BiDiLineIteratorTest& operator=(const BiDiLineIteratorTest&) = delete;
+
+  BiDiLineIterator* iterator() { return &iterator_; }
+
+ private:
+  BiDiLineIterator iterator_;
+};
+
+TEST_P(BiDiLineIteratorTest, OnlyLTR) {
+  iterator()->Open(u"abc 😁 测试", GetParam());
+  ASSERT_EQ(1, iterator()->CountRuns());
+
+  int start, length;
+  EXPECT_EQ(UBIDI_LTR, iterator()->GetVisualRun(0, &start, &length));
+  EXPECT_EQ(0, start);
+  EXPECT_EQ(9, length);
+
+  int end;
+  UBiDiLevel level;
+  iterator()->GetLogicalRun(0, &end, &level);
+  EXPECT_EQ(9, end);
+  if (GetParam() == base::i18n::TextDirection::RIGHT_TO_LEFT)
+    EXPECT_EQ(2, level);
+  else
+    EXPECT_EQ(0, level);
+}
+
+TEST_P(BiDiLineIteratorTest, OnlyRTL) {
+  iterator()->Open(u"מה השעה", GetParam());
+  ASSERT_EQ(1, iterator()->CountRuns());
+
+  int start, length;
+  EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(0, &start, &length));
+  EXPECT_EQ(0, start);
+  EXPECT_EQ(7, length);
+
+  int end;
+  UBiDiLevel level;
+  iterator()->GetLogicalRun(0, &end, &level);
+  EXPECT_EQ(7, end);
+  EXPECT_EQ(1, level);
+}
+
+TEST_P(BiDiLineIteratorTest, Mixed) {
+  iterator()->Open(u"אני משתמש ב- Chrome כדפדפן האינטרנט שלי", GetParam());
+  ASSERT_EQ(3, iterator()->CountRuns());
+
+  // We'll get completely different results depending on the top-level paragraph
+  // direction.
+  if (GetParam() == base::i18n::TextDirection::RIGHT_TO_LEFT) {
+    // If para direction is RTL, expect the LTR substring "Chrome" to be nested
+    // within the surrounding RTL text.
+    int start, length;
+    EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(0, &start, &length));
+    EXPECT_EQ(19, start);
+    EXPECT_EQ(20, length);
+    EXPECT_EQ(UBIDI_LTR, iterator()->GetVisualRun(1, &start, &length));
+    EXPECT_EQ(13, start);
+    EXPECT_EQ(6, length);
+    EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(2, &start, &length));
+    EXPECT_EQ(0, start);
+    EXPECT_EQ(13, length);
+
+    int end;
+    UBiDiLevel level;
+    iterator()->GetLogicalRun(0, &end, &level);
+    EXPECT_EQ(13, end);
+    EXPECT_EQ(1, level);
+    iterator()->GetLogicalRun(13, &end, &level);
+    EXPECT_EQ(19, end);
+    EXPECT_EQ(2, level);
+    iterator()->GetLogicalRun(19, &end, &level);
+    EXPECT_EQ(39, end);
+    EXPECT_EQ(1, level);
+  } else {
+    // If the para direction is LTR, expect the LTR substring "- Chrome " to be
+    // at the top level, with two nested RTL runs on either side.
+    int start, length;
+    EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(0, &start, &length));
+    EXPECT_EQ(0, start);
+    EXPECT_EQ(11, length);
+    EXPECT_EQ(UBIDI_LTR, iterator()->GetVisualRun(1, &start, &length));
+    EXPECT_EQ(11, start);
+    EXPECT_EQ(9, length);
+    EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(2, &start, &length));
+    EXPECT_EQ(20, start);
+    EXPECT_EQ(19, length);
+
+    int end;
+    UBiDiLevel level;
+    iterator()->GetLogicalRun(0, &end, &level);
+    EXPECT_EQ(11, end);
+    EXPECT_EQ(1, level);
+    iterator()->GetLogicalRun(11, &end, &level);
+    EXPECT_EQ(20, end);
+    EXPECT_EQ(0, level);
+    iterator()->GetLogicalRun(20, &end, &level);
+    EXPECT_EQ(39, end);
+    EXPECT_EQ(1, level);
+  }
+}
+
+TEST_P(BiDiLineIteratorTest, RTLPunctuationNoCustomBehavior) {
+  // This string features Hebrew characters interleaved with ASCII punctuation.
+  iterator()->Open(
+      u"א!ב\"ג#ד$ה%ו&ז'ח(ט)י*ך+כ,ל-ם.מ/"
+      u"ן:נ;ס<ע=ף>פ?ץ@צ[ק\\ר]ש^ת_א`ב{ג|ד}ה~ו",
+      GetParam());
+
+  // Expect a single RTL run.
+  ASSERT_EQ(1, iterator()->CountRuns());
+
+  int start, length;
+  EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(0, &start, &length));
+  EXPECT_EQ(0, start);
+  EXPECT_EQ(65, length);
+
+  int end;
+  UBiDiLevel level;
+  iterator()->GetLogicalRun(0, &end, &level);
+  EXPECT_EQ(65, end);
+  EXPECT_EQ(1, level);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    All,
+    BiDiLineIteratorTest,
+    ::testing::Values(base::i18n::TextDirection::LEFT_TO_RIGHT,
+                      base::i18n::TextDirection::RIGHT_TO_LEFT));
+
+}  // namespace
+}  // namespace gfx
+}  // namespace ui
diff --git a/ui/gfx/blit.cc b/ui/gfx/blit.cc
new file mode 100644
index 0000000..d7d74a5
--- /dev/null
+++ b/ui/gfx/blit.cc
@@ -0,0 +1,99 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/blit.h"
+
+#include <stddef.h>
+
+#include "base/check.h"
+#include "build/build_config.h"
+#include "skia/ext/platform_canvas.h"
+#include "third_party/skia/include/core/SkPixmap.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/vector2d.h"
+
+namespace gfx {
+
+namespace {
+
+// Returns true if the given canvas has any part of itself clipped out or
+// any non-identity tranform.
+bool HasClipOrTransform(SkCanvas& canvas) {
+  if (!canvas.getTotalMatrix().isIdentity())
+    return true;
+
+  if (!canvas.isClipRect())
+    return true;
+
+  // Now we know the clip is a regular rectangle, make sure it covers the
+  // entire canvas.
+  SkIRect clip_bounds = canvas.getDeviceClipBounds();
+
+  SkImageInfo info;
+  size_t row_bytes;
+  void* pixels = canvas.accessTopLayerPixels(&info, &row_bytes);
+  DCHECK(pixels);
+  if (!pixels)
+    return true;
+
+  if (clip_bounds.fLeft != 0 || clip_bounds.fTop != 0 ||
+      clip_bounds.fRight != info.width() ||
+      clip_bounds.fBottom != info.height())
+    return true;
+
+  return false;
+}
+
+}  // namespace
+
+void ScrollCanvas(SkCanvas* canvas,
+                  const gfx::Rect& in_clip,
+                  const gfx::Vector2d& offset) {
+  DCHECK(!HasClipOrTransform(*canvas));  // Don't support special stuff.
+
+  SkPixmap pixmap;
+  bool success = skia::GetWritablePixels(canvas, &pixmap);
+  DCHECK(success);
+
+  // We expect all coords to be inside the canvas, so clip here.
+  gfx::Rect clip = gfx::IntersectRects(
+      in_clip, gfx::Rect(0, 0, pixmap.width(), pixmap.height()));
+
+  // Compute the set of pixels we'll actually end up painting.
+  gfx::Rect dest_rect = gfx::IntersectRects(clip + offset, clip);
+  if (dest_rect.size().IsEmpty())
+    return;  // Nothing to do.
+
+  // Compute the source pixels that will map to the dest_rect
+  gfx::Rect src_rect = dest_rect - offset;
+
+  size_t row_bytes = dest_rect.width() * 4;
+  if (offset.y() > 0) {
+    // Data is moving down, copy from the bottom up.
+    for (int y = dest_rect.height() - 1; y >= 0; y--) {
+      memcpy(pixmap.writable_addr32(dest_rect.x(), dest_rect.y() + y),
+             pixmap.addr32(src_rect.x(), src_rect.y() + y),
+             row_bytes);
+    }
+  } else if (offset.y() < 0) {
+    // Data is moving up, copy from the top down.
+    for (int y = 0; y < dest_rect.height(); y++) {
+      memcpy(pixmap.writable_addr32(dest_rect.x(), dest_rect.y() + y),
+             pixmap.addr32(src_rect.x(), src_rect.y() + y),
+             row_bytes);
+    }
+  } else if (offset.x() != 0) {
+    // Horizontal-only scroll. We can do it in either top-to-bottom or bottom-
+    // to-top, but have to be careful about the order for copying each row.
+    // Fortunately, memmove already handles this for us.
+    for (int y = 0; y < dest_rect.height(); y++) {
+      memmove(pixmap.writable_addr32(dest_rect.x(), dest_rect.y() + y),
+              pixmap.addr32(src_rect.x(), src_rect.y() + y),
+              row_bytes);
+    }
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/blit.h b/ui/gfx/blit.h
new file mode 100644
index 0000000..b4a76ae
--- /dev/null
+++ b/ui/gfx/blit.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_BLIT_H_
+#define UI_GFX_BLIT_H_
+
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/native_widget_types.h"
+
+class SkCanvas;
+
+namespace gfx {
+
+class Rect;
+class Vector2d;
+
+// Scrolls the given subset of the given canvas by the given offset.
+// The canvas should not have a clip or a transform applied, since platforms
+// may implement those operations differently.
+GFX_EXPORT void ScrollCanvas(SkCanvas* canvas,
+                             const Rect& clip,
+                             const Vector2d& offset);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_BLIT_H_
diff --git a/ui/gfx/blit_unittest.cc b/ui/gfx/blit_unittest.cc
new file mode 100644
index 0000000..1d70915
--- /dev/null
+++ b/ui/gfx/blit_unittest.cc
@@ -0,0 +1,176 @@
+// Copyright (c) 2010 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.
+
+#include <stdint.h>
+
+#include "base/memory/platform_shared_memory_region.h"
+#include "build/build_config.h"
+#include "skia/ext/platform_canvas.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/blit.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace {
+
+// Fills the given canvas with the values by duplicating the values into each
+// color channel for the corresponding pixel.
+//
+// Example values = {{0x0, 0x01}, {0x12, 0xFF}} would give a canvas with:
+//   0x00000000 0x01010101
+//   0x12121212 0xFFFFFFFF
+template <int w, int h>
+void SetToCanvas(SkCanvas* canvas, uint8_t values[h][w]) {
+  ASSERT_EQ(w, canvas->imageInfo().width());
+  ASSERT_EQ(h, canvas->imageInfo().height());
+
+  // This wouldn't be necessary if we extended the values in the inputs, but
+  // the uint8_t values are a little bit easier to read and maintain.
+  uint32_t extendedValues[w*h];
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      uint8_t value = values[y][x];
+      extendedValues[y*w+x] =
+          (value << 24) | (value << 16) | (value << 8) | value;
+    }
+  }
+
+  SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
+  canvas->writePixels(info, extendedValues, w*4, 0, 0);
+}
+
+// Checks each pixel in the given canvas and see if it is made up of the given
+// values, where each value has been duplicated into each channel of the given
+// bitmap (see SetToCanvas above).
+template <int w, int h>
+void VerifyCanvasValues(SkCanvas* canvas, uint8_t values[h][w]) {
+  SkBitmap bitmap = skia::ReadPixels(canvas);
+  ASSERT_EQ(w, bitmap.width());
+  ASSERT_EQ(h, bitmap.height());
+
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      uint8_t value = values[y][x];
+      uint32_t expected = (value << 24) | (value << 16) | (value << 8) | value;
+      ASSERT_EQ(expected, *bitmap.getAddr32(x, y));
+    }
+  }
+}
+
+}  // namespace
+
+TEST(Blit, ScrollCanvas) {
+  static const int kCanvasWidth = 5;
+  static const int kCanvasHeight = 5;
+  std::unique_ptr<SkCanvas> canvas =
+      skia::CreatePlatformCanvas(kCanvasWidth, kCanvasHeight, false);
+  uint8_t initial_values[kCanvasHeight][kCanvasWidth] = {
+      {0x00, 0x01, 0x02, 0x03, 0x04},
+      {0x10, 0x11, 0x12, 0x13, 0x14},
+      {0x20, 0x21, 0x22, 0x23, 0x24},
+      {0x30, 0x31, 0x32, 0x33, 0x34},
+      {0x40, 0x41, 0x42, 0x43, 0x44}};
+  SetToCanvas<5, 5>(canvas.get(), initial_values);
+
+  // Sanity check on input.
+  VerifyCanvasValues<5, 5>(canvas.get(), initial_values);
+
+  // Scroll none and make sure it's a NOP.
+  gfx::ScrollCanvas(canvas.get(),
+                    gfx::Rect(0, 0, kCanvasWidth, kCanvasHeight),
+                    gfx::Vector2d(0, 0));
+  VerifyCanvasValues<5, 5>(canvas.get(), initial_values);
+
+  // Scroll with a empty clip and make sure it's a NOP.
+  gfx::Rect empty_clip(1, 1, 0, 0);
+  gfx::ScrollCanvas(canvas.get(), empty_clip, gfx::Vector2d(0, 1));
+  VerifyCanvasValues<5, 5>(canvas.get(), initial_values);
+
+  // Scroll the center 3 pixels up one.
+  gfx::Rect center_three(1, 1, 3, 3);
+  gfx::ScrollCanvas(canvas.get(), center_three, gfx::Vector2d(0, -1));
+  uint8_t scroll_up_expected[kCanvasHeight][kCanvasWidth] = {
+      {0x00, 0x01, 0x02, 0x03, 0x04},
+      {0x10, 0x21, 0x22, 0x23, 0x14},
+      {0x20, 0x31, 0x32, 0x33, 0x24},
+      {0x30, 0x31, 0x32, 0x33, 0x34},
+      {0x40, 0x41, 0x42, 0x43, 0x44}};
+  VerifyCanvasValues<5, 5>(canvas.get(), scroll_up_expected);
+
+  // Reset and scroll the center 3 pixels down one.
+  SetToCanvas<5, 5>(canvas.get(), initial_values);
+  gfx::ScrollCanvas(canvas.get(), center_three, gfx::Vector2d(0, 1));
+  uint8_t scroll_down_expected[kCanvasHeight][kCanvasWidth] = {
+      {0x00, 0x01, 0x02, 0x03, 0x04},
+      {0x10, 0x11, 0x12, 0x13, 0x14},
+      {0x20, 0x11, 0x12, 0x13, 0x24},
+      {0x30, 0x21, 0x22, 0x23, 0x34},
+      {0x40, 0x41, 0x42, 0x43, 0x44}};
+  VerifyCanvasValues<5, 5>(canvas.get(), scroll_down_expected);
+
+  // Reset and scroll the center 3 pixels right one.
+  SetToCanvas<5, 5>(canvas.get(), initial_values);
+  gfx::ScrollCanvas(canvas.get(), center_three, gfx::Vector2d(1, 0));
+  uint8_t scroll_right_expected[kCanvasHeight][kCanvasWidth] = {
+      {0x00, 0x01, 0x02, 0x03, 0x04},
+      {0x10, 0x11, 0x11, 0x12, 0x14},
+      {0x20, 0x21, 0x21, 0x22, 0x24},
+      {0x30, 0x31, 0x31, 0x32, 0x34},
+      {0x40, 0x41, 0x42, 0x43, 0x44}};
+  VerifyCanvasValues<5, 5>(canvas.get(), scroll_right_expected);
+
+  // Reset and scroll the center 3 pixels left one.
+  SetToCanvas<5, 5>(canvas.get(), initial_values);
+  gfx::ScrollCanvas(canvas.get(), center_three, gfx::Vector2d(-1, 0));
+  uint8_t scroll_left_expected[kCanvasHeight][kCanvasWidth] = {
+      {0x00, 0x01, 0x02, 0x03, 0x04},
+      {0x10, 0x12, 0x13, 0x13, 0x14},
+      {0x20, 0x22, 0x23, 0x23, 0x24},
+      {0x30, 0x32, 0x33, 0x33, 0x34},
+      {0x40, 0x41, 0x42, 0x43, 0x44}};
+  VerifyCanvasValues<5, 5>(canvas.get(), scroll_left_expected);
+
+  // Diagonal scroll.
+  SetToCanvas<5, 5>(canvas.get(), initial_values);
+  gfx::ScrollCanvas(canvas.get(), center_three, gfx::Vector2d(2, 2));
+  uint8_t scroll_diagonal_expected[kCanvasHeight][kCanvasWidth] = {
+      {0x00, 0x01, 0x02, 0x03, 0x04},
+      {0x10, 0x11, 0x12, 0x13, 0x14},
+      {0x20, 0x21, 0x22, 0x23, 0x24},
+      {0x30, 0x31, 0x32, 0x11, 0x34},
+      {0x40, 0x41, 0x42, 0x43, 0x44}};
+  VerifyCanvasValues<5, 5>(canvas.get(), scroll_diagonal_expected);
+}
+
+#if defined(OS_WIN)
+
+TEST(Blit, WithSharedMemory) {
+  const int kCanvasWidth = 5;
+  const int kCanvasHeight = 5;
+  base::subtle::PlatformSharedMemoryRegion section =
+      base::subtle::PlatformSharedMemoryRegion::CreateWritable(kCanvasWidth *
+                                                               kCanvasHeight);
+  ASSERT_TRUE(section.IsValid());
+  std::unique_ptr<SkCanvas> canvas =
+      skia::CreatePlatformCanvasWithSharedSection(
+          kCanvasWidth, kCanvasHeight, false, section.GetPlatformHandle(),
+          skia::RETURN_NULL_ON_FAILURE);
+  ASSERT_TRUE(canvas);
+  // Closes a HANDLE associated with |section|, |canvas| must remain valid.
+  section = base::subtle::PlatformSharedMemoryRegion();
+
+  uint8_t initial_values[kCanvasHeight][kCanvasWidth] = {
+      {0x00, 0x01, 0x02, 0x03, 0x04},
+      {0x10, 0x11, 0x12, 0x13, 0x14},
+      {0x20, 0x21, 0x22, 0x23, 0x24},
+      {0x30, 0x31, 0x32, 0x33, 0x34},
+      {0x40, 0x41, 0x42, 0x43, 0x44}};
+  SetToCanvas<5, 5>(canvas.get(), initial_values);
+
+  // Sanity check on input.
+  VerifyCanvasValues<5, 5>(canvas.get(), initial_values);
+}
+
+#endif
+
diff --git a/ui/gfx/break_list.h b/ui/gfx/break_list.h
new file mode 100644
index 0000000..19c947f
--- /dev/null
+++ b/ui/gfx/break_list.h
@@ -0,0 +1,176 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_BREAK_LIST_H_
+#define UI_GFX_BREAK_LIST_H_
+
+#include <stddef.h>
+
+#include <utility>
+#include <vector>
+
+#include "base/check_op.h"
+#include "ui/gfx/range/range.h"
+
+namespace gfx {
+
+// BreakLists manage ordered, non-overlapping, and non-repeating ranged values.
+// These may be used to apply ranged colors and styles to text, for an example.
+//
+// Each break stores the start position and value of its associated range.
+// A solitary break at position 0 applies to the entire space [0, max_).
+// |max_| is initially 0 and should be set to match the available ranged space.
+// The first break always has position 0, to ensure all positions have a value.
+// The value of the terminal break applies to the range [break.first, max_).
+// The value of other breaks apply to the range [break.first, (break+1).first).
+template <typename T>
+class BreakList {
+ public:
+  // The break type and const iterator, typedef'ed for convenience.
+  typedef std::pair<size_t, T> Break;
+  typedef typename std::vector<Break>::const_iterator const_iterator;
+
+  // Initialize a break at position 0 with the default or supplied |value|.
+  BreakList();
+  explicit BreakList(T value);
+
+  const std::vector<Break>& breaks() const { return breaks_; }
+
+  // Clear the breaks and set a break at position 0 with the supplied |value|.
+  void SetValue(T value);
+
+  // Adjust the breaks to apply |value| over the supplied |range|.
+  void ApplyValue(T value, const Range& range);
+
+  // Set the max position and trim any breaks at or beyond that position.
+  void SetMax(size_t max);
+  size_t max() const { return max_; }
+
+  // Get the break applicable to |position| (at or preceeding |position|).
+  typename std::vector<Break>::iterator GetBreak(size_t position);
+  typename std::vector<Break>::const_iterator GetBreak(size_t position) const;
+
+  // Get the range of the supplied break; returns the break's start position and
+  // the next break's start position (or |max_| for the terminal break).
+  Range GetRange(const typename BreakList<T>::const_iterator& i) const;
+
+  // Comparison functions for testing purposes.
+  bool EqualsValueForTesting(T value) const;
+  bool EqualsForTesting(const std::vector<Break>& breaks) const;
+
+ private:
+#ifndef NDEBUG
+  // Check for ordered breaks [0, |max_|) with no adjacent equivalent values.
+  void CheckBreaks();
+#endif
+
+  std::vector<Break> breaks_;
+  size_t max_;
+};
+
+template<class T>
+BreakList<T>::BreakList() : breaks_(1, Break(0, T())), max_(0) {
+}
+
+template<class T>
+BreakList<T>::BreakList(T value) : breaks_(1, Break(0, value)), max_(0) {
+}
+
+template<class T>
+void BreakList<T>::SetValue(T value) {
+  breaks_.clear();
+  breaks_.push_back(Break(0, value));
+}
+
+template<class T>
+void BreakList<T>::ApplyValue(T value, const Range& range) {
+  if (!range.IsValid() || range.is_empty())
+    return;
+  DCHECK(!breaks_.empty());
+  DCHECK(!range.is_reversed());
+  DCHECK(Range(0, static_cast<uint32_t>(max_)).Contains(range));
+
+  // Erase any breaks in |range|, then add start and end breaks as needed.
+  typename std::vector<Break>::iterator start = GetBreak(range.start());
+  start += start->first < range.start() ? 1 : 0;
+  typename std::vector<Break>::iterator end = GetBreak(range.end());
+  T trailing_value = end->second;
+  typename std::vector<Break>::iterator i =
+      start == breaks_.end() ? start : breaks_.erase(start, end + 1);
+  if (range.start() == 0 || (i - 1)->second != value)
+    i = breaks_.insert(i, Break(range.start(), value)) + 1;
+  if (trailing_value != value && range.end() != max_)
+    breaks_.insert(i, Break(range.end(), trailing_value));
+
+#ifndef NDEBUG
+  CheckBreaks();
+#endif
+}
+
+template<class T>
+void BreakList<T>::SetMax(size_t max) {
+  typename std::vector<Break>::iterator i = GetBreak(max);
+  i += (i == breaks_.begin() || i->first < max) ? 1 : 0;
+  breaks_.erase(i, breaks_.end());
+  max_ = max;
+
+#ifndef NDEBUG
+  CheckBreaks();
+#endif
+}
+
+template<class T>
+typename std::vector<std::pair<size_t, T> >::iterator BreakList<T>::GetBreak(
+    size_t position) {
+  typename std::vector<Break>::iterator i = breaks_.end() - 1;
+  for (; i != breaks_.begin() && i->first > position; --i);
+  return i;
+}
+
+template<class T>
+typename std::vector<std::pair<size_t, T> >::const_iterator
+    BreakList<T>::GetBreak(size_t position) const {
+  typename std::vector<Break>::const_iterator i = breaks_.end() - 1;
+  for (; i != breaks_.begin() && i->first > position; --i);
+  return i;
+}
+
+template<class T>
+Range BreakList<T>::GetRange(
+    const typename BreakList<T>::const_iterator& i) const {
+  const typename BreakList<T>::const_iterator next = i + 1;
+  return Range(i->first, next == breaks_.end() ? max_ : next->first);
+}
+
+template<class T>
+bool BreakList<T>::EqualsValueForTesting(T value) const {
+  return breaks_.size() == 1 && breaks_[0] == Break(0, value);
+}
+
+template<class T>
+bool BreakList<T>::EqualsForTesting(const std::vector<Break>& breaks) const {
+  if (breaks_.size() != breaks.size())
+    return false;
+  for (size_t i = 0; i < breaks.size(); ++i)
+    if (breaks_[i] != breaks[i])
+      return false;
+  return true;
+}
+
+#ifndef NDEBUG
+template <class T>
+void BreakList<T>::CheckBreaks() {
+  DCHECK_EQ(breaks_[0].first, 0U) << "The first break must be at position 0.";
+  for (size_t i = 0; i < breaks_.size() - 1; ++i) {
+    DCHECK_LT(breaks_[i].first, breaks_[i + 1].first) << "Break out of order.";
+    DCHECK_NE(breaks_[i].second, breaks_[i + 1].second) << "Redundant break.";
+  }
+  if (max_ > 0)
+    DCHECK_LT(breaks_.back().first, max_) << "Break beyond max position.";
+}
+#endif
+
+}  // namespace gfx
+
+#endif  // UI_GFX_BREAK_LIST_H_
diff --git a/ui/gfx/break_list_unittest.cc b/ui/gfx/break_list_unittest.cc
new file mode 100644
index 0000000..81a6621
--- /dev/null
+++ b/ui/gfx/break_list_unittest.cc
@@ -0,0 +1,168 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/break_list.h"
+
+#include <stddef.h>
+
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/range/range.h"
+
+namespace gfx {
+
+class BreakListTest : public testing::Test {};
+
+TEST_F(BreakListTest, SetValue) {
+  // Check the default values applied to new instances.
+  BreakList<bool> style_breaks(false);
+  EXPECT_TRUE(style_breaks.EqualsValueForTesting(false));
+  style_breaks.SetValue(true);
+  EXPECT_TRUE(style_breaks.EqualsValueForTesting(true));
+
+  // Ensure that setting values works correctly.
+  BreakList<SkColor> color_breaks(SK_ColorRED);
+  EXPECT_TRUE(color_breaks.EqualsValueForTesting(SK_ColorRED));
+  color_breaks.SetValue(SK_ColorBLACK);
+  EXPECT_TRUE(color_breaks.EqualsValueForTesting(SK_ColorBLACK));
+}
+
+TEST_F(BreakListTest, ApplyValue) {
+  BreakList<bool> breaks(false);
+  const size_t max = 99;
+  breaks.SetMax(max);
+
+  // Ensure ApplyValue is a no-op on invalid and empty ranges.
+  breaks.ApplyValue(true, Range::InvalidRange());
+  EXPECT_TRUE(breaks.EqualsValueForTesting(false));
+  for (size_t i = 0; i < 3; ++i) {
+    breaks.ApplyValue(true, Range(i, i));
+    EXPECT_TRUE(breaks.EqualsValueForTesting(false));
+  }
+
+  // Apply a value to a valid range, check breaks; repeating should be no-op.
+  std::vector<std::pair<size_t, bool> > expected;
+  expected.push_back(std::pair<size_t, bool>(0, false));
+  expected.push_back(std::pair<size_t, bool>(2, true));
+  expected.push_back(std::pair<size_t, bool>(3, false));
+  for (size_t i = 0; i < 2; ++i) {
+    breaks.ApplyValue(true, Range(2, 3));
+    EXPECT_TRUE(breaks.EqualsForTesting(expected));
+  }
+
+  // Ensure setting a value overrides the ranged value.
+  breaks.SetValue(true);
+  EXPECT_TRUE(breaks.EqualsValueForTesting(true));
+
+  // Ensure applying a value over [0, |max|) is the same as setting a value.
+  breaks.ApplyValue(false, Range(0, max));
+  EXPECT_TRUE(breaks.EqualsValueForTesting(false));
+
+  // Ensure applying a value that is already applied has no effect.
+  breaks.ApplyValue(false, Range(0, 2));
+  breaks.ApplyValue(false, Range(3, 6));
+  breaks.ApplyValue(false, Range(7, max));
+  EXPECT_TRUE(breaks.EqualsValueForTesting(false));
+
+  // Ensure applying an identical neighboring value merges the ranges.
+  breaks.ApplyValue(true, Range(0, 3));
+  breaks.ApplyValue(true, Range(3, 6));
+  breaks.ApplyValue(true, Range(6, max));
+  EXPECT_TRUE(breaks.EqualsValueForTesting(true));
+
+  // Ensure applying a value with the same range overrides the ranged value.
+  breaks.ApplyValue(false, Range(2, 3));
+  breaks.ApplyValue(true, Range(2, 3));
+  EXPECT_TRUE(breaks.EqualsValueForTesting(true));
+
+  // Ensure applying a value with a containing range overrides contained values.
+  breaks.ApplyValue(false, Range(0, 1));
+  breaks.ApplyValue(false, Range(2, 3));
+  breaks.ApplyValue(true, Range(0, 3));
+  EXPECT_TRUE(breaks.EqualsValueForTesting(true));
+  breaks.ApplyValue(false, Range(4, 5));
+  breaks.ApplyValue(false, Range(6, 7));
+  breaks.ApplyValue(false, Range(8, 9));
+  breaks.ApplyValue(true, Range(4, 9));
+  EXPECT_TRUE(breaks.EqualsValueForTesting(true));
+
+  // Ensure applying various overlapping values yields the intended results.
+  breaks.ApplyValue(false, Range(1, 4));
+  breaks.ApplyValue(false, Range(5, 8));
+  breaks.ApplyValue(true, Range(0, 2));
+  breaks.ApplyValue(true, Range(3, 6));
+  breaks.ApplyValue(true, Range(7, max));
+  std::vector<std::pair<size_t, bool> > overlap;
+  overlap.push_back(std::pair<size_t, bool>(0, true));
+  overlap.push_back(std::pair<size_t, bool>(2, false));
+  overlap.push_back(std::pair<size_t, bool>(3, true));
+  overlap.push_back(std::pair<size_t, bool>(6, false));
+  overlap.push_back(std::pair<size_t, bool>(7, true));
+  EXPECT_TRUE(breaks.EqualsForTesting(overlap));
+}
+
+TEST_F(BreakListTest, SetMax) {
+  // Ensure values adjust to accommodate max position changes.
+  BreakList<bool> breaks(false);
+  breaks.SetMax(9);
+  breaks.ApplyValue(true, Range(0, 2));
+  breaks.ApplyValue(true, Range(3, 6));
+  breaks.ApplyValue(true, Range(7, 9));
+
+  std::vector<std::pair<size_t, bool> > expected;
+  expected.push_back(std::pair<size_t, bool>(0, true));
+  expected.push_back(std::pair<size_t, bool>(2, false));
+  expected.push_back(std::pair<size_t, bool>(3, true));
+  expected.push_back(std::pair<size_t, bool>(6, false));
+  expected.push_back(std::pair<size_t, bool>(7, true));
+  EXPECT_TRUE(breaks.EqualsForTesting(expected));
+
+  // Setting a smaller max should remove any corresponding breaks.
+  breaks.SetMax(7);
+  expected.resize(4);
+  EXPECT_TRUE(breaks.EqualsForTesting(expected));
+  breaks.SetMax(4);
+  expected.resize(3);
+  EXPECT_TRUE(breaks.EqualsForTesting(expected));
+  breaks.SetMax(4);
+  EXPECT_TRUE(breaks.EqualsForTesting(expected));
+
+  // Setting a larger max should not change any breaks.
+  breaks.SetMax(50);
+  EXPECT_TRUE(breaks.EqualsForTesting(expected));
+}
+
+TEST_F(BreakListTest, GetBreakAndRange) {
+  BreakList<bool> breaks(false);
+  breaks.SetMax(8);
+  breaks.ApplyValue(true, Range(1, 2));
+  breaks.ApplyValue(true, Range(4, 6));
+
+  struct {
+    size_t position;
+    size_t break_index;
+    Range range;
+  } cases[] = {
+    { 0, 0, Range(0, 1) },
+    { 1, 1, Range(1, 2) },
+    { 2, 2, Range(2, 4) },
+    { 3, 2, Range(2, 4) },
+    { 4, 3, Range(4, 6) },
+    { 5, 3, Range(4, 6) },
+    { 6, 4, Range(6, 8) },
+    { 7, 4, Range(6, 8) },
+    // Positions at or beyond the max simply return the last break and range.
+    { 8, 4, Range(6, 8) },
+    { 9, 4, Range(6, 8) },
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    BreakList<bool>::const_iterator it = breaks.GetBreak(cases[i].position);
+    EXPECT_EQ(breaks.breaks()[cases[i].break_index], *it);
+    EXPECT_EQ(breaks.GetRange(it), cases[i].range);
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/buffer_format_util.cc b/ui/gfx/buffer_format_util.cc
new file mode 100644
index 0000000..0ca68b9
--- /dev/null
+++ b/ui/gfx/buffer_format_util.cc
@@ -0,0 +1,322 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/buffer_format_util.h"
+
+#include "base/check_op.h"
+#include "base/cxx17_backports.h"
+#include "base/notreached.h"
+#include "base/numerics/safe_math.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+namespace {
+
+const BufferFormat kBufferFormats[] = {BufferFormat::R_8,
+                                       BufferFormat::R_16,
+                                       BufferFormat::RG_88,
+                                       BufferFormat::BGR_565,
+                                       BufferFormat::RGBA_4444,
+                                       BufferFormat::RGBX_8888,
+                                       BufferFormat::RGBA_8888,
+                                       BufferFormat::BGRX_8888,
+                                       BufferFormat::BGRA_1010102,
+                                       BufferFormat::RGBA_1010102,
+                                       BufferFormat::BGRA_8888,
+                                       BufferFormat::RGBA_F16,
+                                       BufferFormat::YUV_420_BIPLANAR,
+                                       BufferFormat::YVU_420,
+                                       BufferFormat::P010};
+
+static_assert(base::size(kBufferFormats) ==
+                  (static_cast<int>(BufferFormat::LAST) + 1),
+              "BufferFormat::LAST must be last value of kBufferFormats");
+
+}  // namespace
+
+std::vector<BufferFormat> GetBufferFormatsForTesting() {
+  return std::vector<BufferFormat>(kBufferFormats,
+                                   kBufferFormats + base::size(kBufferFormats));
+}
+
+size_t AlphaBitsForBufferFormat(BufferFormat format) {
+  switch (format) {
+    case BufferFormat::RGBA_4444:
+      return 4;
+    case BufferFormat::RGBA_8888:
+      return 8;
+    case BufferFormat::BGRA_1010102:
+    case BufferFormat::RGBA_1010102:
+      return 2;
+    case BufferFormat::BGRA_8888:
+      return 8;
+    case BufferFormat::RGBA_F16:
+      return 16;
+    case BufferFormat::R_8:
+    case BufferFormat::R_16:
+    case BufferFormat::RG_88:
+    case BufferFormat::BGR_565:
+    case BufferFormat::RGBX_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::YVU_420:
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::P010:
+      return 0;
+  }
+  NOTREACHED();
+  return 0;
+}
+
+size_t NumberOfPlanesForLinearBufferFormat(BufferFormat format) {
+  switch (format) {
+    case BufferFormat::R_8:
+    case BufferFormat::R_16:
+    case BufferFormat::RG_88:
+    case BufferFormat::BGR_565:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBX_8888:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::BGRA_1010102:
+    case BufferFormat::RGBA_1010102:
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::RGBA_F16:
+      return 1;
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::P010:
+      return 2;
+    case BufferFormat::YVU_420:
+      return 3;
+  }
+  NOTREACHED();
+  return 0;
+}
+
+size_t SubsamplingFactorForBufferFormat(BufferFormat format, size_t plane) {
+  switch (format) {
+    case BufferFormat::R_8:
+    case BufferFormat::R_16:
+    case BufferFormat::RG_88:
+    case BufferFormat::BGR_565:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBX_8888:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::BGRA_1010102:
+    case BufferFormat::RGBA_1010102:
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::RGBA_F16:
+      return 1;
+    case BufferFormat::YVU_420: {
+      static size_t factor[] = {1, 2, 2};
+      DCHECK_LT(static_cast<size_t>(plane), base::size(factor));
+      return factor[plane];
+    }
+    case BufferFormat::YUV_420_BIPLANAR:
+    case BufferFormat::P010: {
+      static size_t factor[] = {1, 2};
+      DCHECK_LT(static_cast<size_t>(plane), base::size(factor));
+      return factor[plane];
+    }
+  }
+  NOTREACHED();
+  return 0;
+}
+
+size_t RowSizeForBufferFormat(size_t width, BufferFormat format, size_t plane) {
+  size_t row_size = 0;
+  bool valid = RowSizeForBufferFormatChecked(width, format, plane, &row_size);
+  DCHECK(valid);
+  return row_size;
+}
+
+bool RowSizeForBufferFormatChecked(size_t width,
+                                   BufferFormat format,
+                                   size_t plane,
+                                   size_t* size_in_bytes) {
+  base::CheckedNumeric<size_t> checked_size = width;
+  switch (format) {
+    case BufferFormat::R_8:
+      checked_size += 3;
+      if (!checked_size.IsValid())
+        return false;
+      *size_in_bytes = (checked_size & ~0x3).ValueOrDie();
+      return true;
+    case BufferFormat::R_16:
+    case BufferFormat::RG_88:
+    case BufferFormat::BGR_565:
+    case BufferFormat::RGBA_4444:
+      checked_size *= 2;
+      checked_size += 3;
+      if (!checked_size.IsValid())
+        return false;
+      *size_in_bytes = (checked_size & ~0x3).ValueOrDie();
+      return true;
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::BGRA_1010102:
+    case BufferFormat::RGBA_1010102:
+    case BufferFormat::RGBX_8888:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRA_8888:
+      checked_size *= 4;
+      if (!checked_size.IsValid())
+        return false;
+      *size_in_bytes = checked_size.ValueOrDie();
+      return true;
+    case BufferFormat::RGBA_F16:
+      checked_size *= 8;
+      if (!checked_size.IsValid())
+        return false;
+      *size_in_bytes = checked_size.ValueOrDie();
+      return true;
+    case BufferFormat::YVU_420:
+      DCHECK_EQ(width % 2, 0u);
+      *size_in_bytes = width / SubsamplingFactorForBufferFormat(format, plane);
+      return true;
+    case BufferFormat::YUV_420_BIPLANAR:
+      DCHECK_EQ(width % 2, 0u);
+      *size_in_bytes = width;
+      return true;
+    case BufferFormat::P010:
+      DCHECK_EQ(width % 2, 0u);
+      *size_in_bytes = 2 * width;
+      return true;
+  }
+  NOTREACHED();
+  return false;
+}
+
+size_t BufferSizeForBufferFormat(const Size& size, BufferFormat format) {
+  size_t buffer_size = 0;
+  bool valid = BufferSizeForBufferFormatChecked(size, format, &buffer_size);
+  DCHECK(valid);
+  return buffer_size;
+}
+
+bool BufferSizeForBufferFormatChecked(const Size& size,
+                                      BufferFormat format,
+                                      size_t* size_in_bytes) {
+  base::CheckedNumeric<size_t> checked_size = 0;
+  size_t num_planes = NumberOfPlanesForLinearBufferFormat(format);
+  for (size_t i = 0; i < num_planes; ++i) {
+    size_t row_size = 0;
+    if (!RowSizeForBufferFormatChecked(size.width(), format, i, &row_size))
+      return false;
+    base::CheckedNumeric<size_t> checked_plane_size = row_size;
+    checked_plane_size *= size.height() /
+                          SubsamplingFactorForBufferFormat(format, i);
+    if (!checked_plane_size.IsValid())
+      return false;
+    checked_size += checked_plane_size.ValueOrDie();
+    if (!checked_size.IsValid())
+      return false;
+  }
+  *size_in_bytes = checked_size.ValueOrDie();
+  return true;
+}
+
+size_t BufferOffsetForBufferFormat(const Size& size,
+                                   BufferFormat format,
+                                   size_t plane) {
+  DCHECK_LT(plane, gfx::NumberOfPlanesForLinearBufferFormat(format));
+  switch (format) {
+    case BufferFormat::R_8:
+    case BufferFormat::R_16:
+    case BufferFormat::RG_88:
+    case BufferFormat::BGR_565:
+    case BufferFormat::RGBA_4444:
+    case BufferFormat::RGBX_8888:
+    case BufferFormat::RGBA_8888:
+    case BufferFormat::BGRX_8888:
+    case BufferFormat::BGRA_1010102:
+    case BufferFormat::RGBA_1010102:
+    case BufferFormat::BGRA_8888:
+    case BufferFormat::RGBA_F16:
+      return 0;
+    case BufferFormat::YVU_420: {
+      static size_t offset_in_2x2_sub_sampling_sizes[] = {0, 4, 5};
+      DCHECK_LT(plane, base::size(offset_in_2x2_sub_sampling_sizes));
+      return offset_in_2x2_sub_sampling_sizes[plane] * (size.width() / 2) *
+             (size.height() / 2);
+    }
+    case gfx::BufferFormat::YUV_420_BIPLANAR: {
+      static size_t offset_in_2x2_sub_sampling_sizes[] = {0, 4};
+      DCHECK_LT(plane, base::size(offset_in_2x2_sub_sampling_sizes));
+      return offset_in_2x2_sub_sampling_sizes[plane] * (size.width() / 2) *
+             (size.height() / 2);
+    }
+    case BufferFormat::P010: {
+      static size_t offset_in_2x2_sub_sampling_sizes[] = {0, 4};
+      DCHECK_LT(plane, base::size(offset_in_2x2_sub_sampling_sizes));
+      return 2 * offset_in_2x2_sub_sampling_sizes[plane] *
+             (size.width() / 2 + size.height() / 2);
+    }
+  }
+  NOTREACHED();
+  return 0;
+}
+
+const char* BufferFormatToString(BufferFormat format) {
+  switch (format) {
+    case BufferFormat::R_8:
+      return "R_8";
+    case BufferFormat::R_16:
+      return "R_16";
+    case BufferFormat::RG_88:
+      return "RG_88";
+    case BufferFormat::BGR_565:
+      return "BGR_565";
+    case BufferFormat::RGBA_4444:
+      return "RGBA_4444";
+    case BufferFormat::RGBX_8888:
+      return "RGBX_8888";
+    case BufferFormat::RGBA_8888:
+      return "RGBA_8888";
+    case BufferFormat::BGRX_8888:
+      return "BGRX_8888";
+    case BufferFormat::BGRA_1010102:
+      return "BGRA_1010102";
+    case BufferFormat::RGBA_1010102:
+      return "RGBA_1010102";
+    case BufferFormat::BGRA_8888:
+      return "BGRA_8888";
+    case BufferFormat::RGBA_F16:
+      return "RGBA_F16";
+    case BufferFormat::YVU_420:
+      return "YVU_420";
+    case BufferFormat::YUV_420_BIPLANAR:
+      return "YUV_420_BIPLANAR";
+    case BufferFormat::P010:
+      return "P010";
+  }
+  NOTREACHED()
+      << "Invalid BufferFormat: "
+      << static_cast<typename std::underlying_type<BufferFormat>::type>(format);
+  return "Invalid Format";
+}
+
+const char* BufferPlaneToString(BufferPlane format) {
+  switch (format) {
+    case BufferPlane::DEFAULT:
+      return "DEFAULT";
+    case BufferPlane::Y:
+      return "Y";
+    case BufferPlane::UV:
+      return "UV";
+    case BufferPlane::U:
+      return "U";
+    case BufferPlane::V:
+      return "V";
+  }
+  NOTREACHED() << "Invalid BufferPlane: "
+               << static_cast<typename std::underlying_type<BufferPlane>::type>(
+                      format);
+  return "Invalid Plane";
+}
+
+bool AllowOddHeightMultiPlanarBuffers() {
+  return base::FeatureList::IsEnabled(features::kOddHeightMultiPlanarBuffers);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/buffer_format_util.h b/ui/gfx/buffer_format_util.h
new file mode 100644
index 0000000..a73b264
--- /dev/null
+++ b/ui/gfx/buffer_format_util.h
@@ -0,0 +1,69 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_BUFFER_FORMAT_UTIL_H_
+#define UI_GFX_BUFFER_FORMAT_UTIL_H_
+
+#include <stddef.h>
+
+#include <vector>
+
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Returns a vector containing all buffer formats.
+GFX_EXPORT std::vector<BufferFormat> GetBufferFormatsForTesting();
+
+// Returns the number of bits of alpha for the specified format.
+GFX_EXPORT size_t AlphaBitsForBufferFormat(BufferFormat format);
+
+// Returns the number of planes for |format|.
+GFX_EXPORT size_t NumberOfPlanesForLinearBufferFormat(BufferFormat format);
+
+// Returns the subsampling factor applied to the given zero-indexed |plane| of
+// |format| both horizontally and vertically.
+GFX_EXPORT size_t SubsamplingFactorForBufferFormat(BufferFormat format,
+                                                   size_t plane);
+
+// Returns the number of bytes used to store a row of the given zero-indexed
+// |plane| of |format|.
+GFX_EXPORT size_t RowSizeForBufferFormat(size_t width,
+                                         BufferFormat format,
+                                         size_t plane);
+GFX_EXPORT bool RowSizeForBufferFormatChecked(size_t width,
+                                              BufferFormat format,
+                                              size_t plane,
+                                              size_t* size_in_bytes)
+    WARN_UNUSED_RESULT;
+
+// Returns the number of bytes used to store all the planes of a given |format|.
+GFX_EXPORT size_t BufferSizeForBufferFormat(const Size& size,
+                                            BufferFormat format);
+GFX_EXPORT bool BufferSizeForBufferFormatChecked(const Size& size,
+                                                 BufferFormat format,
+                                                 size_t* size_in_bytes)
+    WARN_UNUSED_RESULT;
+
+GFX_EXPORT size_t BufferOffsetForBufferFormat(const Size& size,
+                                           BufferFormat format,
+                                           size_t plane);
+
+// Returns the name of |format| as a string.
+GFX_EXPORT const char* BufferFormatToString(BufferFormat format);
+
+// Returns the name of |plane| as a string.
+GFX_EXPORT const char* BufferPlaneToString(BufferPlane plane);
+
+// Multiplanar buffer formats (e.g, YUV_420_BIPLANAR, YVU_420, P010) can be
+// tricky when the size of the primary plane is odd, because the subsampled
+// planes will have a size that is not a divisor of the primary plane's size.
+// This indicates that odd height multiplanar formats are supported.
+GFX_EXPORT bool AllowOddHeightMultiPlanarBuffers();
+
+}  // namespace gfx
+
+#endif  // UI_GFX_BUFFER_FORMAT_UTIL_H_
diff --git a/ui/gfx/buffer_types.h b/ui/gfx/buffer_types.h
new file mode 100644
index 0000000..1ae77fc
--- /dev/null
+++ b/ui/gfx/buffer_types.h
@@ -0,0 +1,99 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_BUFFER_TYPES_H_
+#define UI_GFX_BUFFER_TYPES_H_
+
+#include <stdint.h>
+
+#include <tuple>
+
+namespace gfx {
+
+// The format needs to be taken into account when mapping a buffer into the
+// client's address space.
+enum class BufferFormat {
+  R_8,
+  R_16,
+  RG_88,
+  BGR_565,
+  RGBA_4444,
+  RGBX_8888,
+  RGBA_8888,
+  BGRX_8888,
+  BGRA_1010102,
+  RGBA_1010102,
+  BGRA_8888,
+  RGBA_F16,
+  YVU_420,
+  YUV_420_BIPLANAR,
+  P010,
+
+  LAST = P010
+};
+
+// The usage mode affects how a buffer can be used. Only buffers created with
+// *_CPU_READ_WRITE_* can be mapped into the client's address space and accessed
+// by the CPU. SCANOUT implies GPU_READ_WRITE.
+// *_VDA_WRITE is for cases where a video decode accellerator writes into
+// the buffers.
+// PROTECTED_* are for HW protected buffers that cannot be read by the CPU and
+// can only be read in protected GPU contexts or scanned out to overlays.
+
+// TODO(reveman): Add GPU_READ_WRITE for use-cases where SCANOUT is not
+// required.
+enum class BufferUsage {
+  GPU_READ,
+  SCANOUT,
+  // SCANOUT_CAMERA_READ_WRITE implies CPU_READ_WRITE.
+  SCANOUT_CAMERA_READ_WRITE,
+  CAMERA_AND_CPU_READ_WRITE,
+  SCANOUT_CPU_READ_WRITE,
+  SCANOUT_VDA_WRITE,
+  PROTECTED_SCANOUT_VDA_WRITE,
+  GPU_READ_CPU_READ_WRITE,
+  SCANOUT_VEA_CPU_READ,
+  SCANOUT_FRONT_RENDERING,
+  VEA_READ_CAMERA_AND_CPU_READ_WRITE,
+
+  LAST = VEA_READ_CAMERA_AND_CPU_READ_WRITE
+};
+
+struct BufferUsageAndFormat {
+  BufferUsageAndFormat()
+      : usage(BufferUsage::GPU_READ), format(BufferFormat::RGBA_8888) {}
+  BufferUsageAndFormat(BufferUsage usage, BufferFormat format)
+      : usage(usage), format(format) {}
+
+  bool operator==(const BufferUsageAndFormat& other) const {
+    return std::tie(usage, format) == std::tie(other.usage, other.format);
+  }
+
+  BufferUsage usage;
+  BufferFormat format;
+};
+
+// Used to identify the plane of a GpuMemoryBuffer to use when creating a
+// SharedImage.
+enum class BufferPlane {
+  // For single-plane GpuMemoryBuffer, this refers to that single plane. For
+  // YUV_420, YUV_420_BIPLANAR, and P010 GpuMemoryBuffers, this refers to an
+  // RGB representation of the planes (either bound directly as a texture or
+  // created through an extra copy).
+  DEFAULT,
+  // The Y plane for YUV_420, YUV_420_BIPLANAR, and P010.
+  Y,
+  // The UV plane for YUV_420_BIPLANAR and P010.
+  UV,
+  // The U plane for YUV_420.
+  U,
+  // The V plane for YUV_420.
+  V,
+
+  LAST = V
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_BUFFER_TYPES_H_
diff --git a/ui/gfx/buffer_usage_util.cc b/ui/gfx/buffer_usage_util.cc
new file mode 100644
index 0000000..d2a66f6
--- /dev/null
+++ b/ui/gfx/buffer_usage_util.cc
@@ -0,0 +1,37 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/buffer_usage_util.h"
+
+namespace gfx {
+
+const char* BufferUsageToString(BufferUsage usage) {
+  switch (usage) {
+    case BufferUsage::GPU_READ:
+      return "GPU_READ";
+    case BufferUsage::SCANOUT:
+      return "SCANOUT";
+    case BufferUsage::SCANOUT_CAMERA_READ_WRITE:
+      return "SCANOUT_CAMERA_READ_WRITE";
+    case BufferUsage::CAMERA_AND_CPU_READ_WRITE:
+      return "CAMERA_AND_CPU_READ_WRITE";
+    case BufferUsage::SCANOUT_CPU_READ_WRITE:
+      return "SCANOUT_CPU_READ_WRITE";
+    case BufferUsage::SCANOUT_VDA_WRITE:
+      return "SCANOUT_VDA_WRITE";
+    case BufferUsage::PROTECTED_SCANOUT_VDA_WRITE:
+      return "PROTECTED_SCANOUT_VDA_WRITE";
+    case BufferUsage::GPU_READ_CPU_READ_WRITE:
+      return "GPU_READ_CPU_READ_WRITE";
+    case BufferUsage::SCANOUT_VEA_CPU_READ:
+      return "SCANOUT_VEA_CPU_READ";
+    case BufferUsage::VEA_READ_CAMERA_AND_CPU_READ_WRITE:
+      return "VEA_READ_CAMERA_AND_CPU_READ_WRITE";
+    case BufferUsage::SCANOUT_FRONT_RENDERING:
+      return "SCANOUT_FRONT_RENDERING";
+  }
+  return "Invalid Usage";
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/buffer_usage_util.h b/ui/gfx/buffer_usage_util.h
new file mode 100644
index 0000000..cf3c41b
--- /dev/null
+++ b/ui/gfx/buffer_usage_util.h
@@ -0,0 +1,18 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_BUFFER_USAGE_UTIL_H_
+#define UI_GFX_BUFFER_USAGE_UTIL_H_
+
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Returns the name of |usage| as a string.
+GFX_EXPORT const char* BufferUsageToString(BufferUsage usage);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_BUFFER_USAGE_UTIL_H_
diff --git a/ui/gfx/ca_layer_params.cc b/ui/gfx/ca_layer_params.cc
new file mode 100644
index 0000000..1824bc5
--- /dev/null
+++ b/ui/gfx/ca_layer_params.cc
@@ -0,0 +1,16 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/ca_layer_params.h"
+
+namespace gfx {
+
+CALayerParams::CALayerParams() {}
+CALayerParams::~CALayerParams() = default;
+CALayerParams::CALayerParams(CALayerParams&& params) = default;
+CALayerParams::CALayerParams(const CALayerParams& params) = default;
+CALayerParams& CALayerParams::operator=(CALayerParams&& params) = default;
+CALayerParams& CALayerParams::operator=(const CALayerParams& params) = default;
+
+}  // namespace gfx
diff --git a/ui/gfx/ca_layer_params.h b/ui/gfx/ca_layer_params.h
new file mode 100644
index 0000000..64af450
--- /dev/null
+++ b/ui/gfx/ca_layer_params.h
@@ -0,0 +1,51 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CA_LAYER_PARAMS_H_
+#define UI_GFX_CA_LAYER_PARAMS_H_
+
+#include "build/build_config.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+
+#if defined(OS_MAC)
+#include "ui/gfx/mac/io_surface.h"
+#endif
+
+namespace gfx {
+
+// The parameters required to add a composited frame to a CALayer. This
+// is used only on macOS.
+struct GFX_EXPORT CALayerParams {
+  CALayerParams();
+  CALayerParams(CALayerParams&& params);
+  CALayerParams(const CALayerParams& params);
+  CALayerParams& operator=(CALayerParams&& params);
+  CALayerParams& operator=(const CALayerParams& params);
+  ~CALayerParams();
+
+  // The |is_empty| flag is used to short-circuit code to handle CALayerParams
+  // on non-macOS platforms.
+  bool is_empty = true;
+
+  // Can be used to instantiate a CALayerTreeHost in the browser process, which
+  // will display a CALayerTree rooted in the GPU process. This is non-zero when
+  // using remote CoreAnimation.
+  uint32_t ca_context_id = 0;
+
+  // Used to set the contents of a CALayer in the browser to an IOSurface that
+  // is specified by the GPU process. This is non-null iff |ca_context_id| is
+  // zero.
+#if defined(OS_MAC)
+  gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port;
+#endif
+
+  // The geometry of the frame.
+  gfx::Size pixel_size;
+  float scale_factor = 1.f;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_CA_LAYER_PARAMS_H_
diff --git a/ui/gfx/canvas.cc b/ui/gfx/canvas.cc
new file mode 100644
index 0000000..b462f08
--- /dev/null
+++ b/ui/gfx/canvas.cc
@@ -0,0 +1,550 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/canvas.h"
+
+#include <cmath>
+#include <limits>
+
+#include "base/i18n/rtl.h"
+#include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
+#include "cc/paint/paint_flags.h"
+#include "cc/paint/paint_shader.h"
+#include "cc/paint/skottie_wrapper.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
+#include "third_party/skia/include/effects/SkDashPathEffect.h"
+#include "third_party/skia/include/effects/SkGradientShader.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/scoped_canvas.h"
+#include "ui/gfx/skia_paint_util.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+
+Canvas::Canvas(const Size& size, float image_scale, bool is_opaque)
+    : image_scale_(image_scale) {
+  Size pixel_size = ScaleToCeiledSize(size, image_scale);
+  canvas_ = CreateOwnedCanvas(pixel_size, is_opaque);
+
+  SkScalar scale_scalar = SkFloatToScalar(image_scale);
+  canvas_->scale(scale_scalar, scale_scalar);
+}
+
+Canvas::Canvas()
+    : image_scale_(1.f), canvas_(CreateOwnedCanvas({0, 0}, false)) {}
+
+Canvas::Canvas(cc::PaintCanvas* canvas, float image_scale)
+    : image_scale_(image_scale), canvas_(canvas) {
+  DCHECK(canvas_);
+}
+
+Canvas::~Canvas() {
+}
+
+void Canvas::RecreateBackingCanvas(const Size& size,
+                                   float image_scale,
+                                   bool is_opaque) {
+  image_scale_ = image_scale;
+  Size pixel_size = ScaleToFlooredSize(size, image_scale);
+  canvas_ = CreateOwnedCanvas(pixel_size, is_opaque);
+
+  SkScalar scale_scalar = SkFloatToScalar(image_scale);
+  canvas_->scale(scale_scalar, scale_scalar);
+}
+
+// static
+void Canvas::SizeStringInt(const std::u16string& text,
+                           const FontList& font_list,
+                           int* width,
+                           int* height,
+                           int line_height,
+                           int flags) {
+  float fractional_width = static_cast<float>(*width);
+  float factional_height = static_cast<float>(*height);
+  SizeStringFloat(text, font_list, &fractional_width, &factional_height,
+                  line_height, flags);
+  *width = base::ClampCeil(fractional_width);
+  *height = base::ClampCeil(factional_height);
+}
+
+// static
+int Canvas::GetStringWidth(const std::u16string& text,
+                           const FontList& font_list) {
+  int width = 0, height = 0;
+  SizeStringInt(text, font_list, &width, &height, 0, NO_ELLIPSIS);
+  return width;
+}
+
+// static
+float Canvas::GetStringWidthF(const std::u16string& text,
+                              const FontList& font_list) {
+  float width = 0, height = 0;
+  SizeStringFloat(text, font_list, &width, &height, 0, NO_ELLIPSIS);
+  return width;
+}
+
+// static
+int Canvas::DefaultCanvasTextAlignment() {
+  return base::i18n::IsRTL() ? TEXT_ALIGN_RIGHT : TEXT_ALIGN_LEFT;
+}
+
+float Canvas::UndoDeviceScaleFactor() {
+  SkScalar scale_factor = 1.0f / image_scale_;
+  canvas_->scale(scale_factor, scale_factor);
+  return image_scale_;
+}
+
+void Canvas::Save() {
+  canvas_->save();
+}
+
+void Canvas::SaveLayerAlpha(uint8_t alpha) {
+  canvas_->saveLayerAlpha(NULL, alpha);
+}
+
+void Canvas::SaveLayerAlpha(uint8_t alpha, const Rect& layer_bounds) {
+  SkRect bounds(RectToSkRect(layer_bounds));
+  canvas_->saveLayerAlpha(&bounds, alpha);
+}
+
+void Canvas::SaveLayerWithFlags(const cc::PaintFlags& flags) {
+  canvas_->saveLayer(nullptr /* bounds */, &flags);
+}
+
+void Canvas::Restore() {
+  canvas_->restore();
+}
+
+void Canvas::ClipRect(const Rect& rect, SkClipOp op) {
+  canvas_->clipRect(RectToSkRect(rect), op);
+}
+
+void Canvas::ClipRect(const RectF& rect, SkClipOp op) {
+  canvas_->clipRect(RectFToSkRect(rect), op);
+}
+
+void Canvas::ClipPath(const SkPath& path, bool do_anti_alias) {
+  canvas_->clipPath(path, SkClipOp::kIntersect, do_anti_alias);
+}
+
+bool Canvas::GetClipBounds(Rect* bounds) {
+  SkRect out;
+  if (canvas_->getLocalClipBounds(&out)) {
+    *bounds = ToEnclosingRect(SkRectToRectF(out));
+    return true;
+  }
+  *bounds = gfx::Rect();
+  return false;
+}
+
+void Canvas::Translate(const Vector2d& offset) {
+  canvas_->translate(SkIntToScalar(offset.x()), SkIntToScalar(offset.y()));
+}
+
+void Canvas::Scale(float x_scale, float y_scale) {
+  canvas_->scale(SkFloatToScalar(x_scale), SkFloatToScalar(y_scale));
+}
+
+void Canvas::DrawColor(SkColor color) {
+  DrawColor(color, SkBlendMode::kSrcOver);
+}
+
+void Canvas::DrawColor(SkColor color, SkBlendMode mode) {
+  canvas_->drawColor(color, mode);
+}
+
+void Canvas::FillRect(const Rect& rect, SkColor color) {
+  FillRect(rect, color, SkBlendMode::kSrcOver);
+}
+
+void Canvas::FillRect(const Rect& rect, SkColor color, SkBlendMode mode) {
+  cc::PaintFlags flags;
+  flags.setColor(color);
+  flags.setStyle(cc::PaintFlags::kFill_Style);
+  flags.setBlendMode(mode);
+  DrawRect(rect, flags);
+}
+
+void Canvas::DrawRect(const RectF& rect, SkColor color) {
+  DrawRect(rect, color, SkBlendMode::kSrcOver);
+}
+
+void Canvas::DrawRect(const RectF& rect, SkColor color, SkBlendMode mode) {
+  cc::PaintFlags flags;
+  flags.setColor(color);
+  flags.setStyle(cc::PaintFlags::kStroke_Style);
+  // Set a stroke width of 0, which will put us down the stroke rect path.  If
+  // we set a stroke width of 1, for example, this will internally create a
+  // path and fill it, which causes problems near the edge of the canvas.
+  flags.setStrokeWidth(SkIntToScalar(0));
+  flags.setBlendMode(mode);
+
+  DrawRect(rect, flags);
+}
+
+void Canvas::DrawRect(const Rect& rect, const cc::PaintFlags& flags) {
+  DrawRect(RectF(rect), flags);
+}
+
+void Canvas::DrawRect(const RectF& rect, const cc::PaintFlags& flags) {
+  canvas_->drawRect(RectFToSkRect(rect), flags);
+}
+
+void Canvas::DrawLine(const Point& p1, const Point& p2, SkColor color) {
+  DrawLine(PointF(p1), PointF(p2), color);
+}
+
+void Canvas::DrawLine(const PointF& p1, const PointF& p2, SkColor color) {
+  cc::PaintFlags flags;
+  flags.setColor(color);
+  flags.setStrokeWidth(SkIntToScalar(1));
+  DrawLine(p1, p2, flags);
+}
+
+void Canvas::DrawLine(const Point& p1,
+                      const Point& p2,
+                      const cc::PaintFlags& flags) {
+  DrawLine(PointF(p1), PointF(p2), flags);
+}
+
+void Canvas::DrawLine(const PointF& p1,
+                      const PointF& p2,
+                      const cc::PaintFlags& flags) {
+  canvas_->drawLine(SkFloatToScalar(p1.x()), SkFloatToScalar(p1.y()),
+                    SkFloatToScalar(p2.x()), SkFloatToScalar(p2.y()), flags);
+}
+
+void Canvas::DrawSharpLine(PointF p1, PointF p2, SkColor color) {
+  ScopedCanvas scoped(this);
+  float dsf = UndoDeviceScaleFactor();
+  p1.Scale(dsf);
+  p2.Scale(dsf);
+
+  cc::PaintFlags flags;
+  flags.setColor(color);
+  flags.setStrokeWidth(SkFloatToScalar(std::floor(dsf)));
+
+  DrawLine(p1, p2, flags);
+}
+
+void Canvas::Draw1pxLine(PointF p1, PointF p2, SkColor color) {
+  ScopedCanvas scoped(this);
+  float dsf = UndoDeviceScaleFactor();
+  p1.Scale(dsf);
+  p2.Scale(dsf);
+
+  DrawLine(p1, p2, color);
+}
+
+void Canvas::DrawCircle(const Point& center_point,
+                        int radius,
+                        const cc::PaintFlags& flags) {
+  canvas_->drawOval(
+      SkRect::MakeLTRB(center_point.x() - radius, center_point.y() - radius,
+                       center_point.x() + radius, center_point.y() + radius),
+      flags);
+}
+
+void Canvas::DrawCircle(const PointF& center_point,
+                        float radius,
+                        const cc::PaintFlags& flags) {
+  canvas_->drawOval(
+      SkRect::MakeLTRB(center_point.x() - radius, center_point.y() - radius,
+                       center_point.x() + radius, center_point.y() + radius),
+      flags);
+}
+
+void Canvas::DrawRoundRect(const Rect& rect,
+                           int radius,
+                           const cc::PaintFlags& flags) {
+  DrawRoundRect(RectF(rect), radius, flags);
+}
+
+void Canvas::DrawRoundRect(const RectF& rect,
+                           float radius,
+                           const cc::PaintFlags& flags) {
+  canvas_->drawRoundRect(RectFToSkRect(rect), SkFloatToScalar(radius),
+                         SkFloatToScalar(radius), flags);
+}
+
+void Canvas::DrawPath(const SkPath& path, const cc::PaintFlags& flags) {
+  canvas_->drawPath(path, flags);
+}
+
+void Canvas::DrawSolidFocusRect(RectF rect, SkColor color, int thickness) {
+  cc::PaintFlags flags;
+  flags.setColor(color);
+  const float adjusted_thickness =
+      std::floor(thickness * image_scale_) / image_scale_;
+  flags.setStrokeWidth(SkFloatToScalar(adjusted_thickness));
+  flags.setStyle(cc::PaintFlags::kStroke_Style);
+  rect.Inset(gfx::InsetsF(adjusted_thickness / 2));
+  DrawRect(rect, flags);
+}
+
+void Canvas::DrawImageInt(const ImageSkia& image, int x, int y) {
+  cc::PaintFlags flags;
+  DrawImageInt(image, x, y, flags);
+}
+
+void Canvas::DrawImageInt(const ImageSkia& image, int x, int y, uint8_t a) {
+  cc::PaintFlags flags;
+  flags.setAlpha(a);
+  DrawImageInt(image, x, y, flags);
+}
+
+void Canvas::DrawImageInt(const ImageSkia& image,
+                          int x,
+                          int y,
+                          const cc::PaintFlags& flags) {
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
+  if (image_rep.is_null())
+    return;
+  float bitmap_scale = image_rep.scale();
+
+  ScopedCanvas scoper(this);
+  canvas_->scale(SkFloatToScalar(1.0f / bitmap_scale),
+                 SkFloatToScalar(1.0f / bitmap_scale));
+  canvas_->translate(SkFloatToScalar(std::round(x * bitmap_scale)),
+                     SkFloatToScalar(std::round(y * bitmap_scale)));
+  canvas_->saveLayer(nullptr, &flags);
+  canvas_->drawPicture(image_rep.GetPaintRecord());
+  canvas_->restore();
+}
+
+void Canvas::DrawImageInt(const ImageSkia& image,
+                          int src_x,
+                          int src_y,
+                          int src_w,
+                          int src_h,
+                          int dest_x,
+                          int dest_y,
+                          int dest_w,
+                          int dest_h,
+                          bool filter) {
+  cc::PaintFlags flags;
+  DrawImageInt(image, src_x, src_y, src_w, src_h, dest_x, dest_y, dest_w,
+               dest_h, filter, flags);
+}
+
+void Canvas::DrawImageInt(const ImageSkia& image,
+                          int src_x,
+                          int src_y,
+                          int src_w,
+                          int src_h,
+                          int dest_x,
+                          int dest_y,
+                          int dest_w,
+                          int dest_h,
+                          bool filter,
+                          const cc::PaintFlags& flags) {
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
+  if (image_rep.is_null())
+    return;
+  bool remove_image_scale = true;
+  DrawImageIntHelper(image_rep, src_x, src_y, src_w, src_h, dest_x, dest_y,
+                     dest_w, dest_h, filter, flags, remove_image_scale);
+}
+
+void Canvas::DrawImageIntInPixel(const ImageSkiaRep& image_rep,
+                                 int dest_x,
+                                 int dest_y,
+                                 int dest_w,
+                                 int dest_h,
+                                 bool filter,
+                                 const cc::PaintFlags& flags) {
+  int src_x = 0;
+  int src_y = 0;
+  int src_w = image_rep.pixel_width();
+  int src_h = image_rep.pixel_height();
+  // Don't remove image scale here, this function is used to draw the
+  // (already scaled) |image_rep| at a 1:1 scale with the canvas.
+  bool remove_image_scale = false;
+  DrawImageIntHelper(image_rep, src_x, src_y, src_w, src_h, dest_x, dest_y,
+                     dest_w, dest_h, filter, flags, remove_image_scale);
+}
+
+void Canvas::DrawImageInPath(const ImageSkia& image,
+                             int x,
+                             int y,
+                             const SkPath& path,
+                             const cc::PaintFlags& original_flags) {
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
+  if (image_rep.is_null())
+    return;
+
+  SkMatrix matrix;
+  matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
+  cc::PaintFlags flags(original_flags);
+  flags.setShader(CreateImageRepShader(image_rep, SkTileMode::kRepeat,
+                                       SkTileMode::kRepeat, matrix));
+  canvas_->drawPath(path, flags);
+}
+
+void Canvas::DrawSkottie(scoped_refptr<cc::SkottieWrapper> skottie,
+                         const Rect& dst,
+                         float t) {
+  canvas_->drawSkottie(std::move(skottie), RectToSkRect(dst), t);
+}
+
+void Canvas::DrawStringRect(const std::u16string& text,
+                            const FontList& font_list,
+                            SkColor color,
+                            const Rect& display_rect) {
+  DrawStringRectWithFlags(text, font_list, color, display_rect,
+                          DefaultCanvasTextAlignment());
+}
+
+void Canvas::TileImageInt(const ImageSkia& image,
+                          int x,
+                          int y,
+                          int w,
+                          int h) {
+  TileImageInt(image, 0, 0, x, y, w, h);
+}
+
+void Canvas::TileImageInt(const ImageSkia& image,
+                          int src_x,
+                          int src_y,
+                          int dest_x,
+                          int dest_y,
+                          int w,
+                          int h,
+                          float tile_scale,
+                          SkTileMode tile_mode_x,
+                          SkTileMode tile_mode_y,
+                          cc::PaintFlags* flags) {
+  SkRect dest_rect = { SkIntToScalar(dest_x),
+                       SkIntToScalar(dest_y),
+                       SkIntToScalar(dest_x + w),
+                       SkIntToScalar(dest_y + h) };
+  if (!IntersectsClipRect(dest_rect))
+    return;
+
+  cc::PaintFlags paint_flags;
+  if (!flags)
+    flags = &paint_flags;
+
+  if (InitPaintFlagsForTiling(image, src_x, src_y, tile_scale, tile_scale,
+                              dest_x, dest_y, tile_mode_x, tile_mode_y, flags))
+    canvas_->drawRect(dest_rect, *flags);
+}
+
+bool Canvas::InitPaintFlagsForTiling(const ImageSkia& image,
+                                     int src_x,
+                                     int src_y,
+                                     float tile_scale_x,
+                                     float tile_scale_y,
+                                     int dest_x,
+                                     int dest_y,
+                                     SkTileMode tile_mode_x,
+                                     SkTileMode tile_mode_y,
+                                     cc::PaintFlags* flags) {
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
+  if (image_rep.is_null())
+    return false;
+
+  SkMatrix shader_scale;
+  shader_scale.setScale(SkFloatToScalar(tile_scale_x),
+                        SkFloatToScalar(tile_scale_y));
+  shader_scale.preTranslate(SkIntToScalar(-src_x), SkIntToScalar(-src_y));
+  shader_scale.postTranslate(SkIntToScalar(dest_x), SkIntToScalar(dest_y));
+
+  flags->setShader(CreateImageRepShader(image_rep, tile_mode_x, tile_mode_y,
+                                        shader_scale));
+  return true;
+}
+
+void Canvas::Transform(const gfx::Transform& transform) {
+  canvas_->concat(SkMatrix(transform.matrix()));
+}
+
+SkBitmap Canvas::GetBitmap() const {
+  DCHECK(bitmap_);
+  return bitmap_.value();
+}
+
+bool Canvas::IntersectsClipRect(const SkRect& rect) {
+  SkRect clip;
+  return canvas_->getLocalClipBounds(&clip) && clip.intersects(rect);
+}
+
+void Canvas::DrawImageIntHelper(const ImageSkiaRep& image_rep,
+                                int src_x,
+                                int src_y,
+                                int src_w,
+                                int src_h,
+                                int dest_x,
+                                int dest_y,
+                                int dest_w,
+                                int dest_h,
+                                bool filter,
+                                const cc::PaintFlags& original_flags,
+                                bool remove_image_scale) {
+  DLOG_ASSERT(src_x + src_w < std::numeric_limits<int16_t>::max() &&
+              src_y + src_h < std::numeric_limits<int16_t>::max());
+  if (src_w <= 0 || src_h <= 0) {
+    NOTREACHED() << "Attempting to draw bitmap from an empty rect!";
+    return;
+  }
+
+  SkRect dest_rect = { SkIntToScalar(dest_x),
+                       SkIntToScalar(dest_y),
+                       SkIntToScalar(dest_x + dest_w),
+                       SkIntToScalar(dest_y + dest_h) };
+  if (!IntersectsClipRect(dest_rect))
+    return;
+
+  float user_scale_x = static_cast<float>(dest_w) / src_w;
+  float user_scale_y = static_cast<float>(dest_h) / src_h;
+
+  // Make a bitmap shader that contains the bitmap we want to draw. This is
+  // basically what SkCanvas.drawBitmap does internally, but it gives us
+  // more control over quality and will use the mipmap in the source image if
+  // it has one, whereas drawBitmap won't.
+  SkMatrix shader_scale;
+  shader_scale.setScale(SkFloatToScalar(user_scale_x),
+                        SkFloatToScalar(user_scale_y));
+  shader_scale.preTranslate(SkIntToScalar(-src_x), SkIntToScalar(-src_y));
+  shader_scale.postTranslate(SkIntToScalar(dest_x), SkIntToScalar(dest_y));
+
+  cc::PaintFlags flags(original_flags);
+  flags.setFilterQuality(filter ? cc::PaintFlags::FilterQuality::kLow
+                                : cc::PaintFlags::FilterQuality::kNone);
+  flags.setShader(CreateImageRepShaderForScale(
+      image_rep, SkTileMode::kRepeat, SkTileMode::kRepeat, shader_scale,
+      remove_image_scale ? image_rep.scale() : 1.f));
+
+  // The rect will be filled by the bitmap.
+  canvas_->drawRect(dest_rect, flags);
+}
+
+cc::PaintCanvas* Canvas::CreateOwnedCanvas(const Size& size, bool is_opaque) {
+  // SkBitmap cannot be zero-sized, but clients of Canvas sometimes request
+  // that (and then later resize).
+  int width = std::max(size.width(), 1);
+  int height = std::max(size.height(), 1);
+  SkAlphaType alpha = is_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
+  SkImageInfo info = SkImageInfo::MakeN32(width, height, alpha);
+
+  bitmap_.emplace();
+  bitmap_->allocPixels(info);
+  // Ensure that the bitmap is zeroed, since the code expects that.
+  memset(bitmap_->getPixels(), 0, bitmap_->computeByteSize());
+
+  owned_canvas_.emplace(bitmap_.value());
+  return &owned_canvas_.value();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/canvas.h b/ui/gfx/canvas.h
new file mode 100644
index 0000000..207a44e
--- /dev/null
+++ b/ui/gfx/canvas.h
@@ -0,0 +1,470 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CANVAS_H_
+#define UI_GFX_CANVAS_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_flags.h"
+#include "cc/paint/skia_paint_canvas.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/gfx/text_constants.h"
+
+namespace cc {
+class SkottieWrapper;
+}  // namespace cc
+
+namespace gfx {
+
+class Rect;
+class RectF;
+class FontList;
+class Point;
+class PointF;
+class Size;
+class Transform;
+class Vector2d;
+
+// Canvas is a PaintCanvas wrapper that provides a number of methods for
+// common operations used throughout an application built using ui/gfx.
+//
+// All methods that take integer arguments (as is used throughout views)
+// end with Int. If you need to use methods provided by PaintCanvas, you'll
+// need to do a conversion. In particular you'll need to use |SkIntToScalar()|,
+// or if converting from a scalar to an integer |SkScalarRound()|.
+//
+// A handful of methods in this class are overloaded providing an additional
+// argument of type SkBlendMode. SkBlendMode specifies how the
+// source and destination colors are combined. Unless otherwise specified,
+// the variant that does not take a SkBlendMode uses a transfer mode
+// of kSrcOver_Mode.
+class GFX_EXPORT Canvas {
+ public:
+  enum {
+    // Specifies the alignment for text rendered with the DrawStringRect method.
+    TEXT_ALIGN_LEFT = 1 << 0,
+    TEXT_ALIGN_CENTER = 1 << 1,
+    TEXT_ALIGN_RIGHT = 1 << 2,
+    TEXT_ALIGN_TO_HEAD = 1 << 3,
+
+    // Specifies the text consists of multiple lines.
+    MULTI_LINE = 1 << 4,
+
+    // By default DrawStringRect does not process the prefix ('&') character
+    // specially. That is, the string "&foo" is rendered as "&foo". When
+    // rendering text from a resource that uses the prefix character for
+    // mnemonics, the prefix should be processed and can be rendered as an
+    // underline (SHOW_PREFIX), or not rendered at all (HIDE_PREFIX).
+    SHOW_PREFIX = 1 << 5,
+    HIDE_PREFIX = 1 << 6,
+
+    // Prevent ellipsizing
+    NO_ELLIPSIS = 1 << 7,
+
+    // Specifies if words can be split by new lines.
+    // This only works with MULTI_LINE.
+    CHARACTER_BREAKABLE = 1 << 8,
+
+    // Instructs DrawStringRect() to not use subpixel rendering.  This is useful
+    // when rendering text onto a fully- or partially-transparent background
+    // that will later be blended with another image.
+    NO_SUBPIXEL_RENDERING = 1 << 9,
+  };
+
+  // Creates an empty canvas with image_scale of 1x.
+  Canvas();
+
+  // Creates canvas with provided DIP |size| and |image_scale|.
+  // If this canvas is not opaque, it's explicitly cleared to transparent before
+  // being returned.
+  Canvas(const Size& size, float image_scale, bool is_opaque);
+
+  // Creates a Canvas backed by an |sk_canvas| with |image_scale_|.
+  // |sk_canvas| is assumed to be already scaled based on |image_scale|
+  // so no additional scaling is applied.
+  // Note: the caller must ensure that sk_canvas outlives this object, or until
+  // RecreateBackingCanvas is called.
+  Canvas(cc::PaintCanvas* sk_canvas, float image_scale);
+
+  Canvas(const Canvas&) = delete;
+  Canvas& operator=(const Canvas&) = delete;
+
+  virtual ~Canvas();
+
+  // Recreates the backing platform canvas with DIP |size| and |image_scale_|.
+  // If the canvas is not opaque, it is explicitly cleared.
+  // This method is public so that canvas_skia_paint can recreate the platform
+  // canvas after having initialized the canvas.
+  // TODO(pkotwicz): Push the image_scale into skia::PlatformCanvas such that
+  // this method can be private.
+  void RecreateBackingCanvas(const Size& size,
+                             float image_scale,
+                             bool is_opaque);
+
+  // Compute the size required to draw some text with the provided fonts.
+  // Attempts to fit the text with the provided width and height. Increases
+  // height and then width as needed to make the text fit. This method
+  // supports multiple lines. On Skia only a line_height can be specified and
+  // specifying a 0 value for it will cause the default height to be used.
+  static void SizeStringInt(const std::u16string& text,
+                            const FontList& font_list,
+                            int* width,
+                            int* height,
+                            int line_height,
+                            int flags);
+
+  // This is same as SizeStringInt except that fractional size is returned.
+  // See comment in GetStringWidthF for its usage.
+  static void SizeStringFloat(const std::u16string& text,
+                              const FontList& font_list,
+                              float* width,
+                              float* height,
+                              int line_height,
+                              int flags);
+
+  // Returns the number of horizontal pixels needed to display the specified
+  // |text| with |font_list|.
+  static int GetStringWidth(const std::u16string& text,
+                            const FontList& font_list);
+
+  // This is same as GetStringWidth except that fractional width is returned.
+  // Use this method for the scenario that multiple string widths need to be
+  // summed up. This is because GetStringWidth returns the ceiled width and
+  // adding multiple ceiled widths could cause more precision loss for certain
+  // platform like Mac where the fractional width is used.
+  static float GetStringWidthF(const std::u16string& text,
+                               const FontList& font_list);
+
+  // Returns the default text alignment to be used when drawing text on a
+  // Canvas based on the directionality of the system locale language.
+  // This function is used by Canvas::DrawStringRect when the text alignment
+  // is not specified.
+  //
+  // This function returns either Canvas::TEXT_ALIGN_LEFT or
+  // Canvas::TEXT_ALIGN_RIGHT.
+  static int DefaultCanvasTextAlignment();
+
+  // Unscales by the image scale factor (aka device scale factor), and returns
+  // that factor.  This is useful when callers want to draw directly in the
+  // native scale.
+  float UndoDeviceScaleFactor();
+
+  // Saves a copy of the drawing state onto a stack, operating on this copy
+  // until a balanced call to Restore() is made.
+  void Save();
+
+  // As with Save(), except draws to a layer that is blended with the canvas
+  // at the specified alpha once Restore() is called.
+  // |layer_bounds| are the bounds of the layer relative to the current
+  // transform.
+  void SaveLayerAlpha(uint8_t alpha);
+  void SaveLayerAlpha(uint8_t alpha, const Rect& layer_bounds);
+
+  // Like SaveLayerAlpha but draws the layer with an arbitrary set of
+  // PaintFlags once Restore() is called.
+  void SaveLayerWithFlags(const cc::PaintFlags& flags);
+
+  // Restores the drawing state after a call to Save*(). It is an error to
+  // call Restore() more times than Save*().
+  void Restore();
+
+  // Applies |rect| to the current clip using the specified region |op|.
+  void ClipRect(const Rect& rect, SkClipOp op = SkClipOp::kIntersect);
+  void ClipRect(const RectF& rect, SkClipOp op = SkClipOp::kIntersect);
+
+  // Adds |path| to the current clip. |do_anti_alias| is true if the clip
+  // should be antialiased.
+  void ClipPath(const SkPath& path, bool do_anti_alias);
+
+  // Returns the bounds of the current clip (in local coordinates) in the
+  // |bounds| parameter, and returns true if it is non empty.
+  bool GetClipBounds(Rect* bounds);
+
+  void Translate(const Vector2d& offset);
+
+  void Scale(float x_scale, float y_scale);
+
+  // Fills the entire canvas' bitmap (restricted to current clip) with
+  // specified |color| using a transfer mode of SkBlendMode::kSrcOver.
+  void DrawColor(SkColor color);
+
+  // Fills the entire canvas' bitmap (restricted to current clip) with
+  // specified |color| and |mode|.
+  void DrawColor(SkColor color, SkBlendMode mode);
+
+  // Fills |rect| with |color| using a transfer mode of
+  // SkBlendMode::kSrcOver.
+  void FillRect(const Rect& rect, SkColor color);
+
+  // Fills |rect| with the specified |color| and |mode|.
+  void FillRect(const Rect& rect, SkColor color, SkBlendMode mode);
+
+  // Draws a single pixel rect in the specified region with the specified
+  // color, using a transfer mode of SkBlendMode::kSrcOver.
+  //
+  // NOTE: if you need a single pixel line, use DrawLine.
+  void DrawRect(const RectF& rect, SkColor color);
+
+  // Draws a single pixel rect in the specified region with the specified
+  // color and transfer mode.
+  //
+  // NOTE: if you need a single pixel line, use DrawLine.
+  void DrawRect(const RectF& rect, SkColor color, SkBlendMode mode);
+
+  // Draws the given rectangle with the given |flags| parameters.
+  // DEPRECATED in favor of the RectF version below.
+  // TODO(funkysidd): Remove this (http://crbug.com/553726)
+  void DrawRect(const Rect& rect, const cc::PaintFlags& flags);
+
+  // Draws the given rectangle with the given |flags| parameters.
+  void DrawRect(const RectF& rect, const cc::PaintFlags& flags);
+
+  // Draws a single pixel line with the specified color.
+  // DEPRECATED in favor of the RectF version below.
+  // TODO(funkysidd): Remove this (http://crbug.com/553726)
+  void DrawLine(const Point& p1, const Point& p2, SkColor color);
+
+  // Draws a single dip line with the specified color.
+  void DrawLine(const PointF& p1, const PointF& p2, SkColor color);
+
+  // Draws a line with the given |flags| parameters.
+  // DEPRECATED in favor of the RectF version below.
+  // TODO(funkysidd): Remove this (http://crbug.com/553726)
+  void DrawLine(const Point& p1, const Point& p2, const cc::PaintFlags& flags);
+
+  // Draws a line with the given |flags| parameters.
+  void DrawLine(const PointF& p1,
+                const PointF& p2,
+                const cc::PaintFlags& flags);
+
+  // Draws a line that's a single DIP. At fractional scale factors, this is
+  // floored to the nearest integral number of pixels.
+  void DrawSharpLine(PointF p1, PointF p2, SkColor color);
+
+  // As above, but draws a single pixel at all scale factors.
+  void Draw1pxLine(PointF p1, PointF p2, SkColor color);
+
+  // Draws a circle with the given |flags| parameters.
+  // DEPRECATED in favor of the RectF version below.
+  // TODO(funkysidd): Remove this (http://crbug.com/553726)
+  void DrawCircle(const Point& center_point,
+                  int radius,
+                  const cc::PaintFlags& flags);
+
+  // Draws a circle with the given |flags| parameters.
+  void DrawCircle(const PointF& center_point,
+                  float radius,
+                  const cc::PaintFlags& flags);
+
+  // Draws the given rectangle with rounded corners of |radius| using the
+  // given |flags| parameters. DEPRECATED in favor of the RectF version below.
+  // TODO(mgiuca): Remove this (http://crbug.com/553726).
+  void DrawRoundRect(const Rect& rect, int radius, const cc::PaintFlags& flags);
+
+  // Draws the given rectangle with rounded corners of |radius| using the
+  // given |flags| parameters.
+  void DrawRoundRect(const RectF& rect,
+                     float radius,
+                     const cc::PaintFlags& flags);
+
+  // Draws the given path using the given |flags| parameters.
+  void DrawPath(const SkPath& path, const cc::PaintFlags& flags);
+
+  // Draws an image with the origin at the specified location. The upper left
+  // corner of the bitmap is rendered at the specified location.
+  // Parameters are specified relative to current canvas scale not in pixels.
+  // Thus, x is 2 pixels if canvas scale = 2 & |x| = 1.
+  void DrawImageInt(const ImageSkia&, int x, int y);
+
+  // Helper for DrawImageInt(..., flags) that constructs a temporary flags and
+  // calls flags.setAlpha(alpha).
+  void DrawImageInt(const ImageSkia&, int x, int y, uint8_t alpha);
+
+  // Draws an image with the origin at the specified location, using the
+  // specified flags. The upper left corner of the bitmap is rendered at the
+  // specified location.
+  // Parameters are specified relative to current canvas scale not in pixels.
+  // Thus, |x| is 2 pixels if canvas scale = 2 & |x| = 1.
+  void DrawImageInt(const ImageSkia& image,
+                    int x,
+                    int y,
+                    const cc::PaintFlags& flags);
+
+  // Draws a portion of an image in the specified location. The src parameters
+  // correspond to the region of the bitmap to draw in the region defined
+  // by the dest coordinates.
+  //
+  // If the width or height of the source differs from that of the destination,
+  // the image will be scaled. When scaling down, a mipmap will be generated.
+  // Set |filter| to use filtering for images, otherwise the nearest-neighbor
+  // algorithm is used for resampling.
+  //
+  // An optional custom cc::PaintFlags can be provided.
+  // Parameters are specified relative to current canvas scale not in pixels.
+  // Thus, |x| is 2 pixels if canvas scale = 2 & |x| = 1.
+  void DrawImageInt(const ImageSkia& image,
+                    int src_x,
+                    int src_y,
+                    int src_w,
+                    int src_h,
+                    int dest_x,
+                    int dest_y,
+                    int dest_w,
+                    int dest_h,
+                    bool filter);
+  void DrawImageInt(const ImageSkia& image,
+                    int src_x,
+                    int src_y,
+                    int src_w,
+                    int src_h,
+                    int dest_x,
+                    int dest_y,
+                    int dest_w,
+                    int dest_h,
+                    bool filter,
+                    const cc::PaintFlags& flags);
+
+  // Same as the DrawImageInt functions above. Difference being this does not
+  // do any scaling, i.e. it does not scale the output by the device scale
+  // factor (the internal image_scale_). It takes an ImageSkiaRep instead of
+  // an ImageSkia as the caller chooses the exact scale/pixel representation to
+  // use, which will not be scaled while drawing it into the canvas.
+  void DrawImageIntInPixel(const ImageSkiaRep& image_rep,
+                           int dest_x,
+                           int dest_y,
+                           int dest_w,
+                           int dest_h,
+                           bool filter,
+                           const cc::PaintFlags& flags);
+
+  // Draws an |image| with the top left corner at |x| and |y|, clipped to
+  // |path|.
+  // Parameters are specified relative to current canvas scale not in pixels.
+  // Thus, x is 2 pixels if canvas scale = 2 & |x| = 1.
+  void DrawImageInPath(const ImageSkia& image,
+                       int x,
+                       int y,
+                       const SkPath& path,
+                       const cc::PaintFlags& flags);
+
+  // Draws the frame of the |skottie| animation specified by the normalized time
+  // instant t [0->first frame .. 1->last frame] onto the region corresponded by
+  // |dst| in the canvas.
+  void DrawSkottie(scoped_refptr<cc::SkottieWrapper> skottie,
+                   const Rect& dst,
+                   float t);
+
+  // Draws text with the specified color, fonts and location. The text is
+  // aligned to the left, vertically centered, clipped to the region. If the
+  // text is too big, it is truncated and '...' is added to the end.
+  void DrawStringRect(const std::u16string& text,
+                      const FontList& font_list,
+                      SkColor color,
+                      const Rect& display_rect);
+
+  // Draws text with the specified color, fonts and location. The last argument
+  // specifies flags for how the text should be rendered. It can be one of
+  // TEXT_ALIGN_CENTER, TEXT_ALIGN_RIGHT or TEXT_ALIGN_LEFT.
+  void DrawStringRectWithFlags(const std::u16string& text,
+                               const FontList& font_list,
+                               SkColor color,
+                               const Rect& display_rect,
+                               int flags);
+
+  // Draws a |rect| in the specified region with the specified |color|. The
+  // width of the stroke is |thickness| dip, but the actual pixel width will be
+  // floored to ensure an integral value.
+  void DrawSolidFocusRect(RectF rect, SkColor color, int thickness);
+
+  // Tiles the image in the specified region.
+  // Parameters are specified relative to current canvas scale not in pixels.
+  // Thus, |x| is 2 pixels if canvas scale = 2 & |x| = 1.
+  void TileImageInt(const ImageSkia& image,
+                    int x,
+                    int y,
+                    int w,
+                    int h);
+  void TileImageInt(const ImageSkia& image,
+                    int src_x,
+                    int src_y,
+                    int dest_x,
+                    int dest_y,
+                    int w,
+                    int h,
+                    float tile_scale = 1.0f,
+                    SkTileMode tile_mode_x = SkTileMode::kRepeat,
+                    SkTileMode tile_mode_y = SkTileMode::kRepeat,
+                    cc::PaintFlags* flags = nullptr);
+
+  // Helper for TileImageInt().  Initializes |flags| for tiling |image| with the
+  // given parameters.  Returns false if the provided image does not have a
+  // representation for the current scale.
+  bool InitPaintFlagsForTiling(const ImageSkia& image,
+                               int src_x,
+                               int src_y,
+                               float tile_scale_x,
+                               float tile_scale_y,
+                               int dest_x,
+                               int dest_y,
+                               SkTileMode tile_mode_x,
+                               SkTileMode tile_mode_y,
+                               cc::PaintFlags* flags);
+
+  // Apply transformation on the canvas.
+  void Transform(const Transform& transform);
+
+  // Note that writing to this bitmap will modify pixels stored in this canvas.
+  SkBitmap GetBitmap() const;
+
+  // TODO(enne): rename sk_canvas members and interface.
+  cc::PaintCanvas* sk_canvas() { return canvas_; }
+  float image_scale() const { return image_scale_; }
+
+ private:
+  // Tests whether the provided rectangle intersects the current clip rect.
+  bool IntersectsClipRect(const SkRect& rect);
+
+  // Helper for the DrawImageInt functions declared above. The
+  // |remove_image_scale| parameter indicates if the scale of the |image_rep|
+  // should be removed when drawing the image, to avoid double-scaling it.
+  void DrawImageIntHelper(const ImageSkiaRep& image_rep,
+                          int src_x,
+                          int src_y,
+                          int src_w,
+                          int src_h,
+                          int dest_x,
+                          int dest_y,
+                          int dest_w,
+                          int dest_h,
+                          bool filter,
+                          const cc::PaintFlags& flags,
+                          bool remove_image_scale);
+  cc::PaintCanvas* CreateOwnedCanvas(const Size& size, bool is_opaque);
+
+  // The device scale factor at which drawing on this canvas occurs.
+  // An additional scale can be applied via Canvas::Scale(). However,
+  // Canvas::Scale() does not affect |image_scale_|.
+  float image_scale_;
+
+  // canvas_ is our active canvas object. Sometimes we are also the owner,
+  // in which case bitmap_ and owned_canvas_ will be set. Other times we are
+  // just borrowing someone else's canvas, in which case canvas_ will point
+  // there but bitmap_ and owned_canvas_ will not exist.
+  absl::optional<SkBitmap> bitmap_;
+  absl::optional<cc::SkiaPaintCanvas> owned_canvas_;
+  cc::PaintCanvas* canvas_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_CANVAS_H_
diff --git a/ui/gfx/canvas_paint_mac.h b/ui/gfx/canvas_paint_mac.h
new file mode 100644
index 0000000..1623b4ba
--- /dev/null
+++ b/ui/gfx/canvas_paint_mac.h
@@ -0,0 +1,58 @@
+
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CANVAS_PAINT_MAC_H_
+#define UI_GFX_CANVAS_PAINT_MAC_H_
+
+#include "skia/ext/platform_canvas.h"
+#include "ui/gfx/canvas.h"
+
+#import <Cocoa/Cocoa.h>
+
+namespace gfx {
+
+// A class designed to translate skia painting into a region to the current
+// graphics context.  On construction, it will set up a context for painting
+// into, and on destruction, it will commit it to the current context.
+// Note: The created context is always inialized to (0, 0, 0, 0).
+class GFX_EXPORT CanvasSkiaPaint : public Canvas {
+ public:
+  // This constructor assumes the result is opaque.
+  explicit CanvasSkiaPaint(NSRect dirtyRect);
+  CanvasSkiaPaint(NSRect dirtyRect, bool opaque);
+  ~CanvasSkiaPaint() override;
+
+  // If true, the data painted into the CanvasSkiaPaint is blended onto the
+  // current context, else it is copied.
+  void set_composite_alpha(bool composite_alpha) {
+    composite_alpha_ = composite_alpha;
+  }
+
+  // Returns true if the invalid region is empty. The caller should call this
+  // function to determine if anything needs painting.
+  bool is_empty() const {
+    return NSIsEmptyRect(rectangle_);
+  }
+
+  const NSRect& rectangle() const {
+    return rectangle_;
+  }
+
+ private:
+  void Init(bool opaque);
+
+  NSRect rectangle_;
+  // See description above setter.
+  bool composite_alpha_;
+
+  // Disallow copy and assign.
+  CanvasSkiaPaint(const CanvasSkiaPaint&);
+  CanvasSkiaPaint& operator=(const CanvasSkiaPaint&);
+};
+
+}  // namespace gfx
+
+
+#endif  // UI_GFX_CANVAS_PAINT_MAC_H_
diff --git a/ui/gfx/canvas_paint_mac.mm b/ui/gfx/canvas_paint_mac.mm
new file mode 100644
index 0000000..cf22d3a
--- /dev/null
+++ b/ui/gfx/canvas_paint_mac.mm
@@ -0,0 +1,75 @@
+// Copyright (c) 2012 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.
+
+#include "base/mac/mac_util.h"
+#include "third_party/skia/include/utils/mac/SkCGUtils.h"
+#include "ui/gfx/canvas_paint_mac.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace gfx {
+
+CanvasSkiaPaint::CanvasSkiaPaint(NSRect dirtyRect)
+    : rectangle_(dirtyRect),
+      composite_alpha_(false) {
+  Init(true);
+}
+
+CanvasSkiaPaint::CanvasSkiaPaint(NSRect dirtyRect, bool opaque)
+    : rectangle_(dirtyRect),
+      composite_alpha_(false) {
+  Init(opaque);
+}
+
+CanvasSkiaPaint::~CanvasSkiaPaint() {
+  if (!is_empty()) {
+    sk_canvas()->restoreToCount(1);
+
+    // Blit the dirty rect to the current context.
+    CGImageRef image = SkCreateCGImageRefWithColorspace(
+        GetBitmap(), base::mac::GetSystemColorSpace());
+    CGRect dest_rect = NSRectToCGRect(rectangle_);
+
+    CGContextRef destination_context =
+        (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];
+    CGContextSaveGState(destination_context);
+    CGContextSetBlendMode(
+        destination_context,
+        composite_alpha_ ? kCGBlendModeNormal : kCGBlendModeCopy);
+
+    if ([[NSGraphicsContext currentContext] isFlipped]) {
+      // Mirror context on the target's rect middle scanline.
+      CGContextTranslateCTM(destination_context, 0.0, NSMidY(rectangle_));
+      CGContextScaleCTM(destination_context, 1.0, -1.0);
+      CGContextTranslateCTM(destination_context, 0.0, -NSMidY(rectangle_));
+    }
+
+    CGContextDrawImage(destination_context, dest_rect, image);
+    CGContextRestoreGState(destination_context);
+
+    CFRelease(image);
+  }
+}
+
+void CanvasSkiaPaint::Init(bool opaque) {
+  CGContextRef destination_context =
+        (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];
+  CGRect scaled_unit_rect = CGContextConvertRectToDeviceSpace(
+        destination_context, CGRectMake(0, 0, 1, 1));
+    // Assume that the x scale and the y scale are the same.
+  CGFloat scale = scaled_unit_rect.size.width;
+
+  gfx::Size size(NSWidth(rectangle_), NSHeight(rectangle_));
+  RecreateBackingCanvas(size, scale, opaque);
+  cc::PaintCanvas* canvas = sk_canvas();
+  canvas->clear(SK_ColorTRANSPARENT);
+
+  // Need to translate so that the dirty region appears at the origin of the
+  // surface.
+  canvas->translate(-SkDoubleToScalar(NSMinX(rectangle_)),
+                    -SkDoubleToScalar(NSMinY(rectangle_)));
+}
+
+}  // namespace skia
+
+
diff --git a/ui/gfx/canvas_skia.cc b/ui/gfx/canvas_skia.cc
new file mode 100644
index 0000000..f0ee5bf
--- /dev/null
+++ b/ui/gfx/canvas_skia.cc
@@ -0,0 +1,240 @@
+// Copyright (c) 2012 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.
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+
+#include "build/build_config.h"
+#include "cc/paint/paint_canvas.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/render_text.h"
+#include "ui/gfx/text_elider.h"
+#include "ui/gfx/text_utils.h"
+
+namespace gfx {
+
+namespace {
+
+// Strips accelerator character prefixes in |text| if needed, based on |flags|.
+// Returns a range in |text| to underline or Range::InvalidRange() if
+// underlining is not needed.
+Range StripAcceleratorChars(int flags, std::u16string* text) {
+  if (flags & Canvas::SHOW_PREFIX) {
+    int char_pos = -1;
+    int char_span = 0;
+    *text = LocateAndRemoveAcceleratorChar(*text, &char_pos, &char_span);
+    if (char_pos != -1)
+      return Range(char_pos, char_pos + char_span);
+  } else if (flags & Canvas::HIDE_PREFIX) {
+    *text = RemoveAccelerator(*text);
+  }
+
+  return Range::InvalidRange();
+}
+
+// Elides |text| and adjusts |range| appropriately. If eliding causes |range|
+// to no longer point to the same character in |text|, |range| is made invalid.
+void ElideTextAndAdjustRange(const FontList& font_list,
+                             float width,
+                             std::u16string* text,
+                             Range* range) {
+  const char16_t start_char =
+      (range->IsValid() ? text->at(range->start()) : u'\0');
+  *text = ElideText(*text, font_list, width, ELIDE_TAIL);
+  if (!range->IsValid())
+    return;
+  if (range->start() >= text->length() ||
+      text->at(range->start()) != start_char) {
+    *range = Range::InvalidRange();
+  }
+}
+
+// Updates |render_text| from the specified parameters.
+void UpdateRenderText(const Rect& rect,
+                      const std::u16string& text,
+                      const FontList& font_list,
+                      int flags,
+                      SkColor color,
+                      RenderText* render_text) {
+  render_text->SetFontList(font_list);
+  render_text->SetText(text);
+  render_text->SetCursorEnabled(false);
+  render_text->SetDisplayRect(rect);
+
+  // Set the text alignment explicitly based on the directionality of the UI,
+  // if not specified.
+  if (!(flags & (Canvas::TEXT_ALIGN_CENTER |
+                 Canvas::TEXT_ALIGN_RIGHT |
+                 Canvas::TEXT_ALIGN_LEFT |
+                 Canvas::TEXT_ALIGN_TO_HEAD))) {
+    flags |= Canvas::DefaultCanvasTextAlignment();
+  }
+
+  if (flags & Canvas::TEXT_ALIGN_TO_HEAD)
+    render_text->SetHorizontalAlignment(ALIGN_TO_HEAD);
+  else if (flags & Canvas::TEXT_ALIGN_RIGHT)
+    render_text->SetHorizontalAlignment(ALIGN_RIGHT);
+  else if (flags & Canvas::TEXT_ALIGN_CENTER)
+    render_text->SetHorizontalAlignment(ALIGN_CENTER);
+  else
+    render_text->SetHorizontalAlignment(ALIGN_LEFT);
+
+  render_text->set_subpixel_rendering_suppressed(
+      (flags & Canvas::NO_SUBPIXEL_RENDERING) != 0);
+
+  render_text->SetColor(color);
+  const int font_style = font_list.GetFontStyle();
+  render_text->SetStyle(TEXT_STYLE_ITALIC, (font_style & Font::ITALIC) != 0);
+  render_text->SetStyle(TEXT_STYLE_UNDERLINE,
+                        (font_style & Font::UNDERLINE) != 0);
+  render_text->SetWeight(font_list.GetFontWeight());
+}
+
+}  // namespace
+
+// static
+void Canvas::SizeStringFloat(const std::u16string& text,
+                             const FontList& font_list,
+                             float* width,
+                             float* height,
+                             int line_height,
+                             int flags) {
+  DCHECK_GE(*width, 0);
+  DCHECK_GE(*height, 0);
+
+  if ((flags & MULTI_LINE) && *width != 0) {
+    WordWrapBehavior wrap_behavior = TRUNCATE_LONG_WORDS;
+    if (flags & CHARACTER_BREAKABLE)
+      wrap_behavior = WRAP_LONG_WORDS;
+    else if (!(flags & NO_ELLIPSIS))
+      wrap_behavior = ELIDE_LONG_WORDS;
+
+    std::vector<std::u16string> strings;
+    ElideRectangleText(text, font_list, *width, INT_MAX, wrap_behavior,
+                       &strings);
+    Rect rect(base::saturated_cast<int>(*width), INT_MAX);
+
+    std::unique_ptr<RenderText> render_text = RenderText::CreateRenderText();
+
+    UpdateRenderText(rect, std::u16string(), font_list, flags, 0,
+                     render_text.get());
+
+    float h = 0;
+    float w = 0;
+    for (size_t i = 0; i < strings.size(); ++i) {
+      StripAcceleratorChars(flags, &strings[i]);
+      render_text->SetText(strings[i]);
+      const SizeF& string_size = render_text->GetStringSizeF();
+      w = std::max(w, string_size.width());
+      h += (i > 0 && line_height > 0) ?
+               std::max(static_cast<float>(line_height), string_size.height())
+                   : string_size.height();
+    }
+    *width = w;
+    *height = h;
+  } else {
+    std::unique_ptr<RenderText> render_text = RenderText::CreateRenderText();
+
+    Rect rect(base::saturated_cast<int>(*width),
+              base::saturated_cast<int>(*height));
+    std::u16string adjusted_text = text;
+    StripAcceleratorChars(flags, &adjusted_text);
+    UpdateRenderText(rect, adjusted_text, font_list, flags, 0,
+                     render_text.get());
+    const SizeF& string_size = render_text->GetStringSizeF();
+    *width = string_size.width();
+    *height = string_size.height();
+  }
+}
+
+void Canvas::DrawStringRectWithFlags(const std::u16string& text,
+                                     const FontList& font_list,
+                                     SkColor color,
+                                     const Rect& text_bounds,
+                                     int flags) {
+  if (!IntersectsClipRect(RectToSkRect(text_bounds)))
+    return;
+
+  canvas_->save();
+  ClipRect(text_bounds);
+
+  Rect rect(text_bounds);
+
+  std::unique_ptr<RenderText> render_text = RenderText::CreateRenderText();
+
+  if (flags & MULTI_LINE) {
+    WordWrapBehavior wrap_behavior = IGNORE_LONG_WORDS;
+    if (flags & CHARACTER_BREAKABLE)
+      wrap_behavior = WRAP_LONG_WORDS;
+    else if (!(flags & NO_ELLIPSIS))
+      wrap_behavior = ELIDE_LONG_WORDS;
+
+    std::vector<std::u16string> strings;
+    ElideRectangleText(text, font_list,
+                       static_cast<float>(text_bounds.width()),
+                       text_bounds.height(), wrap_behavior, &strings);
+
+    for (size_t i = 0; i < strings.size(); i++) {
+      Range range = StripAcceleratorChars(flags, &strings[i]);
+      UpdateRenderText(rect, strings[i], font_list, flags, color,
+                       render_text.get());
+      int line_padding = 0;
+      const int line_height = render_text->GetStringSize().height();
+
+      // TODO(msw|asvitkine): Center Windows multi-line text: crbug.com/107357
+#if !defined(OS_WIN)
+      if (i == 0) {
+        // TODO(msw|asvitkine): Support multi-line text with varied heights.
+        const int text_height = strings.size() * line_height - line_padding;
+        rect += Vector2d(0, (text_bounds.height() - text_height) / 2);
+      }
+#endif
+
+      rect.set_height(line_height - line_padding);
+
+      if (range.IsValid())
+        render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, range);
+      render_text->SetDisplayRect(rect);
+      render_text->Draw(this);
+      rect += Vector2d(0, line_height);
+    }
+  } else {
+    std::u16string adjusted_text = text;
+    Range range = StripAcceleratorChars(flags, &adjusted_text);
+    bool elide_text = ((flags & NO_ELLIPSIS) == 0);
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+    // On Linux, eliding really means fading the end of the string. But only
+    // for LTR text. RTL text is still elided (on the left) with "...".
+    if (elide_text) {
+      render_text->SetText(adjusted_text);
+      if (render_text->GetDisplayTextDirection() == base::i18n::LEFT_TO_RIGHT) {
+        render_text->SetElideBehavior(FADE_TAIL);
+        elide_text = false;
+      }
+    }
+#endif
+
+    if (elide_text) {
+      ElideTextAndAdjustRange(font_list,
+                              static_cast<float>(text_bounds.width()),
+                              &adjusted_text, &range);
+    }
+
+    UpdateRenderText(rect, adjusted_text, font_list, flags, color,
+                     render_text.get());
+    if (range.IsValid())
+      render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, range);
+    render_text->Draw(this);
+  }
+
+  canvas_->restore();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/canvas_skia_paint.h b/ui/gfx/canvas_skia_paint.h
new file mode 100644
index 0000000..01b366a
--- /dev/null
+++ b/ui/gfx/canvas_skia_paint.h
@@ -0,0 +1,17 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CANVAS_SKIA_PAINT_H_
+#define UI_GFX_CANVAS_SKIA_PAINT_H_
+
+// This file provides an easy way to include the appropriate CanvasPaint
+// header file on your platform.
+
+#if defined(__APPLE__)
+#include "ui/gfx/canvas_paint_mac.h"
+#else
+#error "No canvas paint for this platform"
+#endif
+
+#endif  // UI_GFX_CANVAS_SKIA_PAINT_H_
diff --git a/ui/gfx/canvas_unittest.cc b/ui/gfx/canvas_unittest.cc
new file mode 100644
index 0000000..c2e1615
--- /dev/null
+++ b/ui/gfx/canvas_unittest.cc
@@ -0,0 +1,71 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/canvas.h"
+
+#include <limits>
+
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+
+namespace gfx {
+
+class CanvasTest : public testing::Test {
+ protected:
+  int GetStringWidth(const char *text) {
+    return Canvas::GetStringWidth(base::UTF8ToUTF16(text), font_list_);
+  }
+
+  gfx::Size SizeStringInt(const char *text, int width, int line_height) {
+    std::u16string text16 = base::UTF8ToUTF16(text);
+    int height = 0;
+    int flags =
+        (text16.find('\n') != std::u16string::npos) ? Canvas::MULTI_LINE : 0;
+    Canvas::SizeStringInt(text16, font_list_, &width, &height, line_height,
+                          flags);
+    return gfx::Size(width, height);
+  }
+
+ private:
+  FontList font_list_;
+};
+
+TEST_F(CanvasTest, StringWidth) {
+  EXPECT_GT(GetStringWidth("Test"), 0);
+}
+
+TEST_F(CanvasTest, StringWidthEmptyString) {
+  EXPECT_EQ(0, GetStringWidth(""));
+}
+
+TEST_F(CanvasTest, StringSizeEmptyString) {
+  gfx::Size size = SizeStringInt("", 0, 0);
+  EXPECT_EQ(0, size.width());
+  EXPECT_GT(size.height(), 0);
+}
+
+// Verifies GetClipBounds() returns the correct value.
+TEST_F(CanvasTest, ClipRectWithScaling) {
+  Canvas canvas(gfx::Size(200, 100), 2.25, true);
+  canvas.ClipRect(gfx::RectF(100, 0, 20, 1.7f));
+  gfx::Rect clip_rect;
+  ASSERT_TRUE(canvas.GetClipBounds(&clip_rect));
+  // Use Contains() rather than Equals() as skia may extend the rect in certain
+  // directions. None-the-less the clip must contain the region we damaged.
+  EXPECT_TRUE(clip_rect.Contains(gfx::Rect(100, 0, 20, 2)));
+}
+
+TEST_F(CanvasTest, StringSizeWithLineHeight) {
+  gfx::Size one_line_size = SizeStringInt("Q", 0, 0);
+  gfx::Size four_line_size = SizeStringInt("Q\nQ\nQ\nQ", 1000000, 1000);
+  EXPECT_EQ(one_line_size.width(), four_line_size.width());
+  EXPECT_EQ(3 * 1000 + one_line_size.height(), four_line_size.height());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/client_native_pixmap.h b/ui/gfx/client_native_pixmap.h
new file mode 100644
index 0000000..07cee49
--- /dev/null
+++ b/ui/gfx/client_native_pixmap.h
@@ -0,0 +1,34 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CLIENT_NATIVE_PIXMAP_H_
+#define UI_GFX_CLIENT_NATIVE_PIXMAP_H_
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+struct NativePixmapHandle;
+
+// This represents a buffer that can be written to directly by regular CPU code,
+// but can also be read by the GPU.
+// NativePixmap is its counterpart in GPU process.
+class GFX_EXPORT ClientNativePixmap {
+ public:
+  virtual ~ClientNativePixmap() {}
+
+  // Map each plane in the client address space.
+  // Return false on error.
+  virtual bool Map() = 0;
+  virtual void Unmap() = 0;
+
+  virtual size_t GetNumberOfPlanes() const = 0;
+  virtual void* GetMemoryAddress(size_t plane) const = 0;
+  virtual int GetStride(size_t plane) const = 0;
+  virtual NativePixmapHandle CloneHandleForIPC() const = 0;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_CLIENT_NATIVE_PIXMAP_H_
diff --git a/ui/gfx/client_native_pixmap_factory.h b/ui/gfx/client_native_pixmap_factory.h
new file mode 100644
index 0000000..96aede0
--- /dev/null
+++ b/ui/gfx/client_native_pixmap_factory.h
@@ -0,0 +1,40 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CLIENT_NATIVE_PIXMAP_FACTORY_H_
+#define UI_GFX_CLIENT_NATIVE_PIXMAP_FACTORY_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/files/scoped_file.h"
+#include "base/macros.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/client_native_pixmap.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+struct NativePixmapHandle;
+class Size;
+
+// The Ozone interface allows external implementations to hook into Chromium to
+// provide a client pixmap for non-GPU processes.
+class GFX_EXPORT ClientNativePixmapFactory {
+ public:
+  virtual ~ClientNativePixmapFactory() {}
+
+  // Import the native pixmap from |handle| to be used in non-GPU processes.
+  // Implementations must verify that the buffer in |handle| fits an image of
+  // the specified |size| and |format|. Otherwise nullptr is returned.
+  virtual std::unique_ptr<ClientNativePixmap> ImportFromHandle(
+      gfx::NativePixmapHandle handle,
+      const gfx::Size& size,
+      gfx::BufferFormat format,
+      gfx::BufferUsage usage) = 0;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_CLIENT_NATIVE_PIXMAP_FACTORY_H_
diff --git a/ui/gfx/codec/BUILD.gn b/ui/gfx/codec/BUILD.gn
new file mode 100644
index 0000000..44401dc
--- /dev/null
+++ b/ui/gfx/codec/BUILD.gn
@@ -0,0 +1,44 @@
+# Copyright 2017 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.
+
+import("//build/config/ui.gni")
+
+component("codec") {
+  sources = [
+    "codec_export.h",
+    "jpeg_codec.cc",
+    "jpeg_codec.h",
+    "png_codec.cc",
+    "png_codec.h",
+    "vector_wstream.cc",
+    "vector_wstream.h",
+    "webp_codec.cc",
+    "webp_codec.h",
+  ]
+
+  deps = [
+    "//base",
+    "//skia",
+    "//third_party/libpng",
+    "//ui/gfx:gfx_export",
+    "//ui/gfx:gfx_skia",
+    "//ui/gfx/geometry",
+  ]
+
+  if (is_ios) {
+    sources -= [
+      "jpeg_codec.cc",
+      "jpeg_codec.h",
+    ]
+  } else {
+    deps += [ "//third_party:jpeg" ]
+  }
+
+  if (is_win) {
+    cflags = [ "/wd4324" ]  # Structure was padded due to __declspec(align()),
+                            # which is uninteresting.
+  }
+
+  defines = [ "CODEC_IMPLEMENTATION" ]
+}
diff --git a/ui/gfx/codec/DEPS b/ui/gfx/codec/DEPS
new file mode 100644
index 0000000..6a58de3
--- /dev/null
+++ b/ui/gfx/codec/DEPS
@@ -0,0 +1,7 @@
+include_rules = [
+  "+skia",
+  "+third_party/libjpeg",
+  "+third_party/libjpeg_turbo",
+  "+third_party/libpng",
+  "+third_party/zlib",
+]
diff --git a/ui/gfx/codec/OWNERS b/ui/gfx/codec/OWNERS
new file mode 100644
index 0000000..254c0ec
--- /dev/null
+++ b/ui/gfx/codec/OWNERS
@@ -0,0 +1,2 @@
+dcheng@chromium.org
+scroggo@google.com
diff --git a/ui/gfx/codec/codec_export.h b/ui/gfx/codec/codec_export.h
new file mode 100644
index 0000000..c56a070
--- /dev/null
+++ b/ui/gfx/codec/codec_export.h
@@ -0,0 +1,29 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CODEC_CODEC_EXPORT_H_
+#define UI_GFX_CODEC_CODEC_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(CODEC_IMPLEMENTATION)
+#define CODEC_EXPORT __declspec(dllexport)
+#else
+#define CODEC_EXPORT __declspec(dllimport)
+#endif  // defined(CODEC_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(CODEC_IMPLEMENTATION)
+#define CODEC_EXPORT __attribute__((visibility("default")))
+#else
+#define CODEC_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define CODEC_EXPORT
+#endif
+
+#endif  // UI_GFX_CODEC_CODEC_EXPORT_H_
diff --git a/ui/gfx/codec/jpeg_codec.cc b/ui/gfx/codec/jpeg_codec.cc
new file mode 100644
index 0000000..d1fbdd7
--- /dev/null
+++ b/ui/gfx/codec/jpeg_codec.cc
@@ -0,0 +1,280 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/codec/jpeg_codec.h"
+
+#include <setjmp.h>
+
+#include <memory>
+#include <ostream>
+
+#include "base/notreached.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkColorPriv.h"
+#include "ui/gfx/codec/vector_wstream.h"
+
+extern "C" {
+#if defined(USE_SYSTEM_LIBJPEG)
+#include <jpeglib.h>
+#elif defined(USE_LIBJPEG_TURBO)
+#include "third_party/libjpeg_turbo/jpeglib.h"
+#else
+#include "third_party/libjpeg/jpeglib.h"
+#endif
+}
+
+namespace gfx {
+
+// Encoder/decoder shared stuff ------------------------------------------------
+
+namespace {
+
+// used to pass error info through the JPEG library
+struct CoderErrorMgr {
+  jpeg_error_mgr pub;
+  jmp_buf setjmp_buffer;
+};
+
+void ErrorExit(jpeg_common_struct* cinfo) {
+  CoderErrorMgr *err = reinterpret_cast<CoderErrorMgr*>(cinfo->err);
+
+  // Return control to the setjmp point.
+  longjmp(err->setjmp_buffer, false);
+}
+
+}  // namespace
+
+// Encoder ---------------------------------------------------------------------
+
+bool JPEGCodec::Encode(const SkPixmap& input,
+                       int quality,
+                       SkJpegEncoder::Downsample downsample,
+                       std::vector<unsigned char>* output) {
+  output->clear();
+  VectorWStream dst(output);
+
+  SkJpegEncoder::Options options;
+  options.fQuality = quality;
+  options.fDownsample = downsample;
+  return SkJpegEncoder::Encode(&dst, input, options);
+}
+
+bool JPEGCodec::Encode(const SkPixmap& input,
+                       int quality,
+                       std::vector<unsigned char>* output) {
+  return Encode(input, quality, SkJpegEncoder::Downsample::k420, output);
+}
+
+bool JPEGCodec::Encode(const SkBitmap& src,
+                       int quality,
+                       std::vector<unsigned char>* output) {
+  SkPixmap pixmap;
+  if (!src.peekPixels(&pixmap)) {
+    return false;
+  }
+
+  return JPEGCodec::Encode(pixmap, quality, output);
+}
+
+// Decoder --------------------------------------------------------------------
+
+namespace {
+
+struct JpegDecoderState {
+  JpegDecoderState(const unsigned char* in, size_t len)
+      : input_buffer(in), input_buffer_length(len) {
+  }
+
+  const unsigned char* input_buffer;
+  size_t input_buffer_length;
+};
+
+// Callback to initialize the source.
+//
+// From the JPEG library:
+//  "Initialize source. This is called by jpeg_read_header() before any data is
+//   actually read. May leave bytes_in_buffer set to 0 (in which case a
+//   fill_input_buffer() call will occur immediately)."
+void InitSource(j_decompress_ptr cinfo) {
+  JpegDecoderState* state = static_cast<JpegDecoderState*>(cinfo->client_data);
+  cinfo->src->next_input_byte = state->input_buffer;
+  cinfo->src->bytes_in_buffer = state->input_buffer_length;
+}
+
+// Callback to fill the buffer. Since our buffer already contains all the data,
+// we should never need to provide more data. If libjpeg thinks it needs more
+// data, our input is probably corrupt.
+//
+// From the JPEG library:
+//  "This is called whenever bytes_in_buffer has reached zero and more data is
+//   wanted. In typical applications, it should read fresh data into the buffer
+//   (ignoring the current state of next_input_byte and bytes_in_buffer), reset
+//   the pointer & count to the start of the buffer, and return TRUE indicating
+//   that the buffer has been reloaded. It is not necessary to fill the buffer
+//   entirely, only to obtain at least one more byte. bytes_in_buffer MUST be
+//   set to a positive value if TRUE is returned. A FALSE return should only
+//   be used when I/O suspension is desired."
+boolean FillInputBuffer(j_decompress_ptr cinfo) {
+  return false;
+}
+
+// Skip data in the buffer. Since we have all the data at once, this operation
+// is easy. It is not clear if this ever gets called because the JPEG library
+// should be able to do the skip itself (it has all the data).
+//
+// From the JPEG library:
+//  "Skip num_bytes worth of data. The buffer pointer and count should be
+//   advanced over num_bytes input bytes, refilling the buffer as needed. This
+//   is used to skip over a potentially large amount of uninteresting data
+//   (such as an APPn marker). In some applications it may be possible to
+//   optimize away the reading of the skipped data, but it's not clear that
+//   being smart is worth much trouble; large skips are uncommon.
+//   bytes_in_buffer may be zero on return. A zero or negative skip count
+//   should be treated as a no-op."
+void SkipInputData(j_decompress_ptr cinfo, long num_bytes) {
+  if (num_bytes > static_cast<long>(cinfo->src->bytes_in_buffer)) {
+    // Since all our data should be in the buffer, trying to skip beyond it
+    // means that there is some kind of error or corrupt input data. A 0 for
+    // bytes left means it will call FillInputBuffer which will then fail.
+    cinfo->src->next_input_byte += cinfo->src->bytes_in_buffer;
+    cinfo->src->bytes_in_buffer = 0;
+  } else if (num_bytes > 0) {
+    cinfo->src->bytes_in_buffer -= static_cast<size_t>(num_bytes);
+    cinfo->src->next_input_byte += num_bytes;
+  }
+}
+
+// Our source doesn't need any cleanup, so this is a NOP.
+//
+// From the JPEG library:
+//  "Terminate source --- called by jpeg_finish_decompress() after all data has
+//   been read to clean up JPEG source manager. NOT called by jpeg_abort() or
+//   jpeg_destroy()."
+void TermSource(j_decompress_ptr cinfo) {}
+
+// jpeg_decompress_struct Deleter.
+struct JpegDecompressStructDeleter {
+  void operator()(jpeg_decompress_struct* ptr) {
+    jpeg_destroy_decompress(ptr);
+    delete ptr;
+  }
+};
+
+}  // namespace
+
+bool JPEGCodec::Decode(const unsigned char* input, size_t input_size,
+                       ColorFormat format, std::vector<unsigned char>* output,
+                       int* w, int* h) {
+  std::unique_ptr<jpeg_decompress_struct, JpegDecompressStructDeleter> cinfo(
+      new jpeg_decompress_struct);
+  output->clear();
+
+  // We set up the normal JPEG error routines, then override error_exit.
+  // This must be done before the call to jpeg_create_decompress.
+  CoderErrorMgr errmgr;
+  cinfo->err = jpeg_std_error(&errmgr.pub);
+  errmgr.pub.error_exit = ErrorExit;
+  // Establish the setjmp return context for ErrorExit to use.
+  if (setjmp(errmgr.setjmp_buffer)) {
+    // If we get here, the JPEG code has signaled an error.
+    // Release |cinfo| by hand to avoid use-after-free of |errmgr|.
+    cinfo.reset();
+    return false;
+  }
+
+  // The destroyer will destroy() cinfo on exit.  We don't want to set the
+  // destroyer's object until cinfo is initialized.
+  jpeg_create_decompress(cinfo.get());
+
+  // set up the source manager
+  jpeg_source_mgr srcmgr;
+  srcmgr.init_source = InitSource;
+  srcmgr.fill_input_buffer = FillInputBuffer;
+  srcmgr.skip_input_data = SkipInputData;
+  srcmgr.resync_to_restart = jpeg_resync_to_restart;  // use default routine
+  srcmgr.term_source = TermSource;
+  cinfo->src = &srcmgr;
+
+  JpegDecoderState state(input, input_size);
+  cinfo->client_data = &state;
+
+  // fill the file metadata into our buffer
+  if (jpeg_read_header(cinfo.get(), true) != JPEG_HEADER_OK)
+    return false;
+
+  // we want to always get RGB data out
+  switch (cinfo->jpeg_color_space) {
+    case JCS_GRAYSCALE:
+    case JCS_RGB:
+    case JCS_YCbCr:
+      // Choose an output colorspace and return if it is an unsupported one.
+      // Same as JPEGCodec::Encode(), libjpeg-turbo supports all input formats
+      // used by Chromium (i.e. RGBA and BGRA) and we just map the input
+      // parameters to a colorspace.
+      if (format == FORMAT_RGBA ||
+          (format == FORMAT_SkBitmap && SK_R32_SHIFT == 0)) {
+        cinfo->out_color_space = JCS_EXT_RGBX;
+        cinfo->output_components = 4;
+      } else if (format == FORMAT_BGRA ||
+                 (format == FORMAT_SkBitmap && SK_B32_SHIFT == 0)) {
+        cinfo->out_color_space = JCS_EXT_BGRX;
+        cinfo->output_components = 4;
+      } else {
+        NOTREACHED() << "Invalid pixel format";
+        return false;
+      }
+      break;
+    case JCS_CMYK:
+    case JCS_YCCK:
+    default:
+      // Mozilla errors out on these color spaces, so I presume that the jpeg
+      // library can't do automatic color space conversion for them. We don't
+      // care about these anyway.
+      return false;
+  }
+
+  jpeg_calc_output_dimensions(cinfo.get());
+  *w = cinfo->output_width;
+  *h = cinfo->output_height;
+
+  jpeg_start_decompress(cinfo.get());
+
+  // FIXME(brettw) we may want to allow the capability for callers to request
+  // how to align row lengths as we do for the compressor.
+  int row_read_stride = cinfo->output_width * cinfo->output_components;
+
+  // Create memory for a decoded image and write decoded lines to the memory
+  // without conversions same as JPEGCodec::Encode().
+  int row_write_stride = row_read_stride;
+  output->resize(row_write_stride * cinfo->output_height);
+
+  for (int row = 0; row < static_cast<int>(cinfo->output_height); row++) {
+    unsigned char* rowptr = &(*output)[row * row_write_stride];
+    if (!jpeg_read_scanlines(cinfo.get(), &rowptr, 1))
+      return false;
+  }
+
+  jpeg_finish_decompress(cinfo.get());
+  return true;
+}
+
+// static
+std::unique_ptr<SkBitmap> JPEGCodec::Decode(const unsigned char* input,
+                                            size_t input_size) {
+  int w, h;
+  std::vector<unsigned char> data_vector;
+  if (!Decode(input, input_size, FORMAT_SkBitmap, &data_vector, &w, &h))
+    return nullptr;
+
+  // Skia only handles 32 bit images.
+  int data_length = w * h * 4;
+
+  std::unique_ptr<SkBitmap> bitmap(new SkBitmap());
+  bitmap->allocN32Pixels(w, h);
+  memcpy(bitmap->getAddr32(0, 0), &data_vector[0], data_length);
+
+  return bitmap;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/codec/jpeg_codec.h b/ui/gfx/codec/jpeg_codec.h
new file mode 100644
index 0000000..14f8879
--- /dev/null
+++ b/ui/gfx/codec/jpeg_codec.h
@@ -0,0 +1,91 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CODEC_JPEG_CODEC_H_
+#define UI_GFX_CODEC_JPEG_CODEC_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <vector>
+
+#include "third_party/skia/include/core/SkImageInfo.h"
+#include "third_party/skia/include/core/SkPixmap.h"
+#include "third_party/skia/include/encode/SkJpegEncoder.h"
+#include "ui/gfx/codec/codec_export.h"
+
+class SkBitmap;
+
+namespace gfx {
+
+// Interface for encoding/decoding JPEG data. This is a wrapper around libjpeg,
+// which has an inconvenient interface for callers. This is only used for UI
+// elements, WebKit has its own more complicated JPEG decoder which handles,
+// among other things, partially downloaded data.
+class CODEC_EXPORT JPEGCodec {
+ public:
+  enum ColorFormat {
+    // 4 bytes per pixel, in RGBA order in mem regardless of endianness.
+    FORMAT_RGBA,
+
+    // 4 bytes per pixel, in BGRA order in mem regardless of endianness.
+    // This is the default Windows DIB order.
+    FORMAT_BGRA,
+
+    // 4 bytes per pixel, it can be either RGBA or BGRA. It depends on the bit
+    // order in kARGB_8888_Config skia bitmap.
+    FORMAT_SkBitmap
+  };
+
+  // Encodes the given raw 'input' pixmap, which includes a pointer to pixels
+  // as well as information describing the pixel format. The encoded JPEG data
+  // will be written into the supplied vector and true will be returned on
+  // success. On failure (false), the contents of the output buffer are
+  // undefined.
+  //
+  // downsample: specifies how pixels will be sampled in the encoded JPEG image,
+  //             can be either k420, k422 or k444.
+  // quality: an integer in the range 0-100, where 100 is the highest quality.
+  static bool Encode(const SkPixmap& input,
+                     int quality,
+                     SkJpegEncoder::Downsample downsample,
+                     std::vector<unsigned char>* output);
+
+  // Encodes the given raw 'input' pixmap, which includes a pointer to pixels
+  // as well as information describing the pixel format. The encoded JPEG data
+  // will be written into the supplied vector and true will be returned on
+  // success. On failure (false), the contents of the output buffer are
+  // undefined.
+  //
+  // quality: an integer in the range 0-100, where 100 is the highest quality.
+  static bool Encode(const SkPixmap& input,
+                     int quality,
+                     std::vector<unsigned char>* output);
+
+  // Encodes the 'input' bitmap.  The encoded JPEG data will be written into
+  // the supplied vector and true will be returned on success. On failure
+  // (false), the contents of the output buffer are undefined.
+  //
+  // quality: an integer in the range 0-100, where 100 is the highest quality.
+  static bool Encode(const SkBitmap& input,
+                     int quality,
+                     std::vector<unsigned char>* output);
+
+  // Decodes the JPEG data contained in input of length input_size. The
+  // decoded data will be placed in *output with the dimensions in *w and *h
+  // on success (returns true). This data will be written in the'format'
+  // format. On failure, the values of these output variables is undefined.
+  static bool Decode(const unsigned char* input, size_t input_size,
+                     ColorFormat format, std::vector<unsigned char>* output,
+                     int* w, int* h);
+
+  // Decodes the JPEG data contained in input of length input_size. If
+  // successful, a SkBitmap is created and returned.
+  static std::unique_ptr<SkBitmap> Decode(const unsigned char* input,
+                                          size_t input_size);
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_CODEC_JPEG_CODEC_H_
diff --git a/ui/gfx/codec/jpeg_codec_unittest.cc b/ui/gfx/codec/jpeg_codec_unittest.cc
new file mode 100644
index 0000000..2d0748e
--- /dev/null
+++ b/ui/gfx/codec/jpeg_codec_unittest.cc
@@ -0,0 +1,214 @@
+// Copyright (c) 2011 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.
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/barrier_closure.h"
+#include "base/cxx17_backports.h"
+#include "base/run_loop.h"
+#include "base/task/thread_pool.h"
+#include "base/test/bind.h"
+#include "base/test/task_environment.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/codec/jpeg_codec.h"
+
+namespace {
+
+// A JPEG image used by TopSitesMigrationTest, whose size is 1x1.
+// This image causes an invalid-read error to libjpeg-turbo 1.0.1.
+const uint8_t kTopSitesMigrationTestImage[] =
+    "\xff\xd8\xff\xe0\x00\x10\x4a\x46\x49\x46\x00\x01\x01\x00\x00\x01"
+    "\x00\x01\x00\x00\xff\xdb\x00\x43\x00\x03\x02\x02\x03\x02\x02\x03"
+    "\x03\x03\x03\x04\x03\x03\x04\x05\x08\x05\x05\x04\x04\x05\x0a\x07"
+    "\x07\x06\x08\x0c\x0a\x0c\x0c\x0b\x0a\x0b\x0b\x0d\x0e\x12\x10\x0d"
+    "\x0e\x11\x0e\x0b\x0b\x10\x16\x10\x11\x13\x14\x15\x15\x15\x0c\x0f"
+    "\x17\x18\x16\x14\x18\x12\x14\x15\x14\xff\xdb\x00\x43\x01\x03\x04"
+    "\x04\x05\x04\x05\x09\x05\x05\x09\x14\x0d\x0b\x0d\x14\x14\x14\x14"
+    "\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14"
+    "\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14"
+    "\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\xff\xc0"
+    "\x00\x11\x08\x00\x01\x00\x01\x03\x01\x22\x00\x02\x11\x01\x03\x11"
+    "\x01\xff\xc4\x00\x1f\x00\x00\x01\x05\x01\x01\x01\x01\x01\x01\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09"
+    "\x0a\x0b\xff\xc4\x00\xb5\x10\x00\x02\x01\x03\x03\x02\x04\x03\x05"
+    "\x05\x04\x04\x00\x00\x01\x7d\x01\x02\x03\x00\x04\x11\x05\x12\x21"
+    "\x31\x41\x06\x13\x51\x61\x07\x22\x71\x14\x32\x81\x91\xa1\x08\x23"
+    "\x42\xb1\xc1\x15\x52\xd1\xf0\x24\x33\x62\x72\x82\x09\x0a\x16\x17"
+    "\x18\x19\x1a\x25\x26\x27\x28\x29\x2a\x34\x35\x36\x37\x38\x39\x3a"
+    "\x43\x44\x45\x46\x47\x48\x49\x4a\x53\x54\x55\x56\x57\x58\x59\x5a"
+    "\x63\x64\x65\x66\x67\x68\x69\x6a\x73\x74\x75\x76\x77\x78\x79\x7a"
+    "\x83\x84\x85\x86\x87\x88\x89\x8a\x92\x93\x94\x95\x96\x97\x98\x99"
+    "\x9a\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xb2\xb3\xb4\xb5\xb6\xb7"
+    "\xb8\xb9\xba\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xd2\xd3\xd4\xd5"
+    "\xd6\xd7\xd8\xd9\xda\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xf1"
+    "\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xff\xc4\x00\x1f\x01\x00\x03"
+    "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x01"
+    "\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\xff\xc4\x00\xb5\x11\x00"
+    "\x02\x01\x02\x04\x04\x03\x04\x07\x05\x04\x04\x00\x01\x02\x77\x00"
+    "\x01\x02\x03\x11\x04\x05\x21\x31\x06\x12\x41\x51\x07\x61\x71\x13"
+    "\x22\x32\x81\x08\x14\x42\x91\xa1\xb1\xc1\x09\x23\x33\x52\xf0\x15"
+    "\x62\x72\xd1\x0a\x16\x24\x34\xe1\x25\xf1\x17\x18\x19\x1a\x26\x27"
+    "\x28\x29\x2a\x35\x36\x37\x38\x39\x3a\x43\x44\x45\x46\x47\x48\x49"
+    "\x4a\x53\x54\x55\x56\x57\x58\x59\x5a\x63\x64\x65\x66\x67\x68\x69"
+    "\x6a\x73\x74\x75\x76\x77\x78\x79\x7a\x82\x83\x84\x85\x86\x87\x88"
+    "\x89\x8a\x92\x93\x94\x95\x96\x97\x98\x99\x9a\xa2\xa3\xa4\xa5\xa6"
+    "\xa7\xa8\xa9\xaa\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xc2\xc3\xc4"
+    "\xc5\xc6\xc7\xc8\xc9\xca\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xe2"
+    "\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9"
+    "\xfa\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11\x00\x3f\x00\xf9"
+    "\xd2\x8a\x28\xaf\xc3\x0f\xf5\x4c\xff\xd9";
+
+}  // namespace
+
+namespace gfx {
+
+// out of 100, this indicates how compressed it will be, this should be changed
+// with jpeg equality threshold
+// static int jpeg_quality = 75;  // FIXME(brettw)
+static int jpeg_quality = 100;
+
+// The threshold of average color differences where we consider two images
+// equal. This number was picked to be a little above the observed difference
+// using the above quality.
+static double jpeg_equality_threshold = 1.0;
+
+// Computes the average difference between each value in a and b. A and b
+// should be the same size. Used to see if two images are approximately equal
+// in the presence of compression.
+static double AveragePixelDelta(const std::vector<unsigned char>& a,
+                                const std::vector<unsigned char>& b) {
+  // if the sizes are different, say the average difference is the maximum
+  if (a.size() != b.size())
+    return 255.0;
+  if (a.empty())
+    return 0;  // prevent divide by 0 below
+
+  double acc = 0.0;
+  for (size_t i = 0; i < a.size(); i++)
+    acc += fabs(static_cast<double>(a[i]) - static_cast<double>(b[i]));
+
+  return acc / static_cast<double>(a.size());
+}
+
+static void MakeRGBAImage(int w, int h, std::vector<unsigned char>* dat) {
+  dat->resize(w * h * 4);
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      unsigned char* org_px = &(*dat)[(y * w + x) * 4];
+      org_px[0] = x * 3;      // r
+      org_px[1] = x * 3 + 1;  // g
+      org_px[2] = x * 3 + 2;  // b
+      org_px[3] = 0xFF;       // a
+    }
+  }
+}
+
+TEST(JPEGCodec, EncodeDecodeRGBA) {
+  int w = 20, h = 20;
+
+  // create an image with known values, a must be opaque because it will be
+  // lost during compression
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, &original);
+
+  // encode, making sure it was compressed some
+  std::vector<unsigned char> encoded;
+  SkImageInfo info =
+      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
+  SkPixmap src(info, &original[0], w * 4);
+  EXPECT_TRUE(JPEGCodec::Encode(src, jpeg_quality, &encoded));
+  EXPECT_GT(original.size(), encoded.size());
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  EXPECT_TRUE(JPEGCodec::Decode(&encoded[0], encoded.size(),
+                                JPEGCodec::FORMAT_RGBA, &decoded,
+                                &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be approximately equal (compression will have introduced some
+  // minor artifacts).
+  ASSERT_GE(jpeg_equality_threshold, AveragePixelDelta(original, decoded));
+}
+
+// Test that corrupted data decompression causes failures.
+TEST(JPEGCodec, DecodeCorrupted) {
+  int w = 20, h = 20;
+
+  // some random data (an uncompressed image)
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, &original);
+
+  // it should fail when given non-JPEG compressed data
+  std::vector<unsigned char> output;
+  int outw, outh;
+  ASSERT_FALSE(JPEGCodec::Decode(&original[0], original.size(),
+                                 JPEGCodec::FORMAT_RGBA, &output, &outw,
+                                 &outh));
+
+  // make some compressed data
+  std::vector<unsigned char> compressed;
+  SkImageInfo info =
+      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
+  SkPixmap src(info, &original[0], w * 4);
+  ASSERT_TRUE(JPEGCodec::Encode(src, jpeg_quality, &compressed));
+
+  // try decompressing a truncated version
+  ASSERT_FALSE(JPEGCodec::Decode(&compressed[0], compressed.size() / 2,
+                                 JPEGCodec::FORMAT_RGBA, &output, &outw,
+                                 &outh));
+
+  // corrupt it and try decompressing that
+  for (int i = 10; i < 30; i++)
+    compressed[i] = i;
+  ASSERT_FALSE(JPEGCodec::Decode(&compressed[0], compressed.size(),
+                                 JPEGCodec::FORMAT_RGBA, &output, &outw,
+                                 &outh));
+}
+
+// Test that we can decode JPEG images without invalid-read errors on valgrind.
+// This test decodes a 1x1 JPEG image and writes the decoded RGB (or RGBA) pixel
+// to the output buffer without OOB reads.
+TEST(JPEGCodec, InvalidRead) {
+  std::vector<unsigned char> output;
+  int outw, outh;
+  JPEGCodec::Decode(kTopSitesMigrationTestImage,
+                    base::size(kTopSitesMigrationTestImage),
+                    JPEGCodec::FORMAT_RGBA, &output, &outw, &outh);
+}
+
+// Coverage for data races in JPEG encoding when run with TSan.
+// Regression test for crbug.com/1056011.
+TEST(JPEGCodec, ParallelEncoding) {
+  constexpr int kImageSize = 32;
+  std::vector<unsigned char> image_data;
+  MakeRGBAImage(kImageSize, kImageSize, &image_data);
+  SkImageInfo info = SkImageInfo::Make(
+      kImageSize, kImageSize, kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
+  SkPixmap src(info, &image_data[0], kImageSize * 4);
+
+  base::test::TaskEnvironment task_environment;
+  base::RunLoop encode_loop;
+
+  constexpr int kNumCopies = 100;
+  base::RepeatingClosure encode_completion_closure =
+      base::BarrierClosure(kNumCopies, encode_loop.QuitClosure());
+  for (int i = 0; i < kNumCopies; ++i) {
+    base::ThreadPool::PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&] {
+          std::vector<unsigned char> output;
+          EXPECT_TRUE(JPEGCodec::Encode(src, jpeg_quality, &output));
+          encode_completion_closure.Run();
+        }));
+  }
+
+  encode_loop.Run();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/codec/png_codec.cc b/ui/gfx/codec/png_codec.cc
new file mode 100644
index 0000000..0782945
--- /dev/null
+++ b/ui/gfx/codec/png_codec.cc
@@ -0,0 +1,538 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/codec/png_codec.h"
+
+#include <stdint.h>
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/notreached.h"
+#include "base/strings/string_util.h"
+#include "third_party/libpng/png.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkColorPriv.h"
+#include "third_party/skia/include/core/SkUnPreMultiply.h"
+#include "third_party/skia/include/encode/SkPngEncoder.h"
+#include "third_party/zlib/zlib.h"
+#include "ui/gfx/codec/vector_wstream.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace gfx {
+
+// Decoder --------------------------------------------------------------------
+//
+// This code is based on WebKit libpng interface (PNGImageDecoder), which is
+// in turn based on the Mozilla png decoder.
+
+namespace {
+
+// Gamma constants: We assume we're on Windows which uses a gamma of 2.2.
+const double kMaxGamma = 21474.83;  // Maximum gamma accepted by png library.
+const double kDefaultGamma = 2.2;
+const double kInverseGamma = 1.0 / kDefaultGamma;
+
+class PngDecoderState {
+ public:
+  // Output is a vector<unsigned char>.
+  PngDecoderState(PNGCodec::ColorFormat ofmt, std::vector<unsigned char>* o)
+      : output_format(ofmt),
+        output_channels(0),
+        bitmap(nullptr),
+        is_opaque(true),
+        output(o),
+        width(0),
+        height(0),
+        done(false) {}
+
+  // Output is an SkBitmap.
+  explicit PngDecoderState(SkBitmap* skbitmap)
+      : output_format(PNGCodec::FORMAT_SkBitmap),
+        output_channels(0),
+        bitmap(skbitmap),
+        is_opaque(true),
+        output(nullptr),
+        width(0),
+        height(0),
+        done(false) {}
+
+  PngDecoderState(const PngDecoderState&) = delete;
+  PngDecoderState& operator=(const PngDecoderState&) = delete;
+
+  PNGCodec::ColorFormat output_format;
+  int output_channels;
+
+  // An incoming SkBitmap to write to. If NULL, we write to output instead.
+  SkBitmap* bitmap;
+
+  // Used during the reading of an SkBitmap. Defaults to true until we see a
+  // pixel with anything other than an alpha of 255.
+  bool is_opaque;
+
+  // The other way to decode output, where we write into an intermediary buffer
+  // instead of directly to an SkBitmap.
+  std::vector<unsigned char>* output;
+
+  // Size of the image, set in the info callback.
+  int width;
+  int height;
+
+  // Set to true when we've found the end of the data.
+  bool done;
+};
+
+// User transform (passed to libpng) which converts a row decoded by libpng to
+// Skia format. Expects the row to have 4 channels, otherwise there won't be
+// enough room in |data|.
+void ConvertRGBARowToSkia(png_structp png_ptr,
+                          png_row_infop row_info,
+                          png_bytep data) {
+  const int channels = row_info->channels;
+  DCHECK_EQ(channels, 4);
+
+  PngDecoderState* state =
+      static_cast<PngDecoderState*>(png_get_user_transform_ptr(png_ptr));
+  DCHECK(state) << "LibPNG user transform pointer is NULL";
+
+  unsigned char* const end = data + row_info->rowbytes;
+  for (unsigned char* p = data; p < end; p += channels) {
+    uint32_t* sk_pixel = reinterpret_cast<uint32_t*>(p);
+    const unsigned char alpha = p[channels - 1];
+    if (alpha != 255) {
+      state->is_opaque = false;
+      *sk_pixel = SkPreMultiplyARGB(alpha, p[0], p[1], p[2]);
+    } else {
+      *sk_pixel = SkPackARGB32(alpha, p[0], p[1], p[2]);
+    }
+  }
+}
+
+// Called when the png header has been read. This code is based on the WebKit
+// PNGImageDecoder
+void DecodeInfoCallback(png_struct* png_ptr, png_info* info_ptr) {
+  PngDecoderState* state = static_cast<PngDecoderState*>(
+      png_get_progressive_ptr(png_ptr));
+
+  int bit_depth, color_type, interlace_type, compression_type;
+  int filter_type;
+  png_uint_32 w, h;
+  png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type,
+               &interlace_type, &compression_type, &filter_type);
+
+  // Bounds check. When the image is unreasonably big, we'll error out and
+  // end up back at the setjmp call when we set up decoding.  "Unreasonably big"
+  // means "big enough that w * h * 32bpp might overflow an int"; we choose this
+  // threshold to match WebKit and because a number of places in code assume
+  // that an image's size (in bytes) fits in a (signed) int.
+  unsigned long long total_size =
+      static_cast<unsigned long long>(w) * static_cast<unsigned long long>(h);
+  if (total_size > ((1 << 29) - 1))
+    longjmp(png_jmpbuf(png_ptr), 1);
+  state->width = static_cast<int>(w);
+  state->height = static_cast<int>(h);
+
+  // The following png_set_* calls have to be done in the order dictated by
+  // the libpng docs. Please take care if you have to move any of them. This
+  // is also why certain things are done outside of the switch, even though
+  // they look like they belong there.
+
+  // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
+  if (color_type == PNG_COLOR_TYPE_PALETTE ||
+      (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8))
+    png_set_expand(png_ptr);
+
+  // The '!= 0' is for silencing a Windows compiler warning.
+  bool input_has_alpha = ((color_type & PNG_COLOR_MASK_ALPHA) != 0);
+
+  // Transparency for paletted images.
+  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+    png_set_expand(png_ptr);
+    input_has_alpha = true;
+  }
+
+  // Convert 16-bit to 8-bit.
+  if (bit_depth == 16)
+    png_set_strip_16(png_ptr);
+
+  // Pick our row format converter necessary for this data.
+  if (!input_has_alpha) {
+    switch (state->output_format) {
+      case PNGCodec::FORMAT_RGBA:
+        state->output_channels = 4;
+        png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
+        break;
+      case PNGCodec::FORMAT_BGRA:
+        state->output_channels = 4;
+        png_set_bgr(png_ptr);
+        png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
+        break;
+      case PNGCodec::FORMAT_SkBitmap:
+        state->output_channels = 4;
+        png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
+        break;
+    }
+  } else {
+    switch (state->output_format) {
+      case PNGCodec::FORMAT_RGBA:
+        state->output_channels = 4;
+        break;
+      case PNGCodec::FORMAT_BGRA:
+        state->output_channels = 4;
+        png_set_bgr(png_ptr);
+        break;
+      case PNGCodec::FORMAT_SkBitmap:
+        state->output_channels = 4;
+        break;
+    }
+  }
+
+  // Expand grayscale to RGB.
+  if (color_type == PNG_COLOR_TYPE_GRAY ||
+      color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+    png_set_gray_to_rgb(png_ptr);
+
+  // Deal with gamma and keep it under our control.
+  double gamma;
+  if (png_get_gAMA(png_ptr, info_ptr, &gamma)) {
+    if (gamma <= 0.0 || gamma > kMaxGamma) {
+      gamma = kInverseGamma;
+      png_set_gAMA(png_ptr, info_ptr, gamma);
+    }
+    png_set_gamma(png_ptr, kDefaultGamma, gamma);
+  } else {
+    png_set_gamma(png_ptr, kDefaultGamma, kInverseGamma);
+  }
+
+  // Setting the user transforms here (as opposed to inside the switch above)
+  // because all png_set_* calls need to be done in the specific order
+  // mandated by libpng.
+  if (state->output_format == PNGCodec::FORMAT_SkBitmap) {
+    png_set_read_user_transform_fn(png_ptr, ConvertRGBARowToSkia);
+    png_set_user_transform_info(png_ptr, state, 0, 0);
+  }
+
+  // Tell libpng to send us rows for interlaced pngs.
+  if (interlace_type == PNG_INTERLACE_ADAM7)
+    png_set_interlace_handling(png_ptr);
+
+  png_read_update_info(png_ptr, info_ptr);
+
+  if (state->bitmap) {
+    state->bitmap->allocN32Pixels(state->width, state->height);
+  } else if (state->output) {
+    state->output->resize(
+        state->width * state->output_channels * state->height);
+  }
+}
+
+void DecodeRowCallback(png_struct* png_ptr, png_byte* new_row,
+                       png_uint_32 row_num, int pass) {
+  if (!new_row)
+    return;  // Interlaced image; row didn't change this pass.
+
+  PngDecoderState* state = static_cast<PngDecoderState*>(
+      png_get_progressive_ptr(png_ptr));
+
+  if (static_cast<int>(row_num) > state->height) {
+    NOTREACHED() << "Invalid row";
+    return;
+  }
+
+  unsigned char* base = NULL;
+  if (state->bitmap)
+    base = reinterpret_cast<unsigned char*>(state->bitmap->getAddr32(0, 0));
+  else if (state->output)
+    base = &state->output->front();
+
+  unsigned char* dest = &base[state->width * state->output_channels * row_num];
+  png_progressive_combine_row(png_ptr, dest, new_row);
+}
+
+void DecodeEndCallback(png_struct* png_ptr, png_info* info) {
+  PngDecoderState* state = static_cast<PngDecoderState*>(
+      png_get_progressive_ptr(png_ptr));
+
+  // Mark the image as complete, this will tell the Decode function that we
+  // have successfully found the end of the data.
+  state->done = true;
+}
+
+// Holds png struct and info ensuring the proper destruction.
+class PngReadStructInfo {
+ public:
+  PngReadStructInfo(): png_ptr_(nullptr), info_ptr_(nullptr) {
+  }
+
+  PngReadStructInfo(const PngReadStructInfo&) = delete;
+  PngReadStructInfo& operator=(const PngReadStructInfo&) = delete;
+
+  ~PngReadStructInfo() {
+    png_destroy_read_struct(&png_ptr_, &info_ptr_, NULL);
+  }
+
+  bool Build(const unsigned char* input, size_t input_size) {
+    if (input_size < 8)
+      return false;  // Input data too small to be a png
+
+    // Have libpng check the signature, it likes the first 8 bytes.
+    if (png_sig_cmp(const_cast<unsigned char*>(input), 0, 8) != 0)
+      return false;
+
+    png_ptr_ = png_create_read_struct(
+        PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (!png_ptr_)
+      return false;
+
+    info_ptr_ = png_create_info_struct(png_ptr_);
+    if (!info_ptr_) {
+      return false;
+    }
+    return true;
+  }
+
+  png_struct* png_ptr_;
+  png_info* info_ptr_;
+};
+
+// Holds png struct and info ensuring the proper destruction.
+class PngWriteStructInfo {
+ public:
+  PngWriteStructInfo() : png_ptr_(nullptr), info_ptr_(nullptr) {
+  }
+
+  PngWriteStructInfo(const PngWriteStructInfo&) = delete;
+  PngWriteStructInfo& operator=(const PngWriteStructInfo&) = delete;
+
+  ~PngWriteStructInfo() {
+    png_destroy_write_struct(&png_ptr_, &info_ptr_);
+  }
+
+  png_struct* png_ptr_;
+  png_info* info_ptr_;
+};
+
+// Libpng user error and warning functions which allows us to print libpng
+// errors and warnings using Chrome's logging facilities instead of stderr.
+
+void LogLibPNGDecodeError(png_structp png_ptr, png_const_charp error_msg) {
+  DLOG(ERROR) << "libpng decode error: " << error_msg;
+  longjmp(png_jmpbuf(png_ptr), 1);
+}
+
+void LogLibPNGDecodeWarning(png_structp png_ptr, png_const_charp warning_msg) {
+  DLOG(ERROR) << "libpng decode warning: " << warning_msg;
+}
+
+}  // namespace
+
+// static
+bool PNGCodec::Decode(const unsigned char* input, size_t input_size,
+                      ColorFormat format, std::vector<unsigned char>* output,
+                      int* w, int* h) {
+  PngReadStructInfo si;
+  if (!si.Build(input, input_size))
+    return false;
+
+  if (setjmp(png_jmpbuf(si.png_ptr_))) {
+    // The destroyer will ensure that the structures are cleaned up in this
+    // case, even though we may get here as a jump from random parts of the
+    // PNG library called below.
+    return false;
+  }
+
+  PngDecoderState state(format, output);
+
+  png_set_error_fn(si.png_ptr_, NULL,
+                   LogLibPNGDecodeError, LogLibPNGDecodeWarning);
+  png_set_progressive_read_fn(si.png_ptr_, &state, &DecodeInfoCallback,
+                              &DecodeRowCallback, &DecodeEndCallback);
+  png_process_data(si.png_ptr_,
+                   si.info_ptr_,
+                   const_cast<unsigned char*>(input),
+                   input_size);
+
+  if (!state.done) {
+    // Fed it all the data but the library didn't think we got all the data, so
+    // this file must be truncated.
+    output->clear();
+    return false;
+  }
+
+  *w = state.width;
+  *h = state.height;
+  return true;
+}
+
+// static
+bool PNGCodec::Decode(const unsigned char* input, size_t input_size,
+                      SkBitmap* bitmap) {
+  DCHECK(bitmap);
+  PngReadStructInfo si;
+  if (!si.Build(input, input_size))
+    return false;
+
+  if (setjmp(png_jmpbuf(si.png_ptr_))) {
+    // The destroyer will ensure that the structures are cleaned up in this
+    // case, even though we may get here as a jump from random parts of the
+    // PNG library called below.
+    return false;
+  }
+
+  PngDecoderState state(bitmap);
+
+  png_set_progressive_read_fn(si.png_ptr_, &state, &DecodeInfoCallback,
+                              &DecodeRowCallback, &DecodeEndCallback);
+  png_process_data(si.png_ptr_,
+                   si.info_ptr_,
+                   const_cast<unsigned char*>(input),
+                   input_size);
+
+  if (!state.done) {
+    return false;
+  }
+
+  // Set the bitmap's opaqueness based on what we saw.
+  bitmap->setAlphaType(state.is_opaque ?
+                       kOpaque_SkAlphaType : kPremul_SkAlphaType);
+
+  return true;
+}
+
+// Encoder --------------------------------------------------------------------
+
+namespace {
+
+static void AddComments(SkPngEncoder::Options& options,
+                        const std::vector<PNGCodec::Comment>& comments) {
+  std::vector<const char*> comment_pointers;
+  std::vector<size_t> comment_sizes;
+  for (const auto& comment : comments) {
+    comment_pointers.push_back(comment.key.c_str());
+    comment_pointers.push_back(comment.text.c_str());
+    comment_sizes.push_back(comment.key.length() + 1);
+    comment_sizes.push_back(comment.text.length() + 1);
+  }
+  options.fComments = SkDataTable::MakeCopyArrays(
+      (void const* const*)comment_pointers.data(), comment_sizes.data(),
+      static_cast<int>(comment_pointers.size()));
+}
+
+}  // namespace
+
+static bool EncodeSkPixmap(const SkPixmap& src,
+                           const std::vector<PNGCodec::Comment>& comments,
+                           std::vector<unsigned char>* output,
+                           int zlib_level) {
+  output->clear();
+  VectorWStream dst(output);
+
+  SkPngEncoder::Options options;
+  AddComments(options, comments);
+  options.fZLibLevel = zlib_level;
+  return SkPngEncoder::Encode(&dst, src, options);
+}
+
+static bool EncodeSkPixmap(const SkPixmap& src,
+                           bool discard_transparency,
+                           const std::vector<PNGCodec::Comment>& comments,
+                           std::vector<unsigned char>* output,
+                           int zlib_level) {
+  if (discard_transparency) {
+    SkImageInfo opaque_info = src.info().makeAlphaType(kOpaque_SkAlphaType);
+    SkBitmap copy;
+    if (!copy.tryAllocPixels(opaque_info)) {
+      return false;
+    }
+    SkPixmap opaque_pixmap;
+    bool success = copy.peekPixels(&opaque_pixmap);
+    DCHECK(success);
+    // The following step does the unpremul as we set the dst alpha type to be
+    // kUnpremul_SkAlphaType. Later, because opaque_pixmap has
+    // kOpaque_SkAlphaType, we'll discard the transparency as required.
+    success =
+        src.readPixels(opaque_info.makeAlphaType(kUnpremul_SkAlphaType),
+                       opaque_pixmap.writable_addr(), opaque_pixmap.rowBytes());
+    DCHECK(success);
+    return EncodeSkPixmap(opaque_pixmap, comments, output, zlib_level);
+  }
+  return EncodeSkPixmap(src, comments, output, zlib_level);
+}
+
+// static
+bool PNGCodec::Encode(const unsigned char* input,
+                      ColorFormat format,
+                      const Size& size,
+                      int row_byte_width,
+                      bool discard_transparency,
+                      const std::vector<Comment>& comments,
+                      std::vector<unsigned char>* output) {
+  // Initialization required for Windows although the switch covers all cases.
+  SkColorType colorType = kN32_SkColorType;
+  switch (format) {
+    case FORMAT_RGBA:
+      colorType = kRGBA_8888_SkColorType;
+      break;
+    case FORMAT_BGRA:
+      colorType = kBGRA_8888_SkColorType;
+      break;
+    case FORMAT_SkBitmap:
+      colorType = kN32_SkColorType;
+      break;
+  }
+  auto alphaType =
+      format == FORMAT_SkBitmap ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
+  SkImageInfo info =
+      SkImageInfo::Make(size.width(), size.height(), colorType, alphaType);
+  SkPixmap src(info, input, row_byte_width);
+  return EncodeSkPixmap(src, discard_transparency, comments, output,
+                        DEFAULT_ZLIB_COMPRESSION);
+}
+
+static bool EncodeSkBitmap(const SkBitmap& input,
+                           bool discard_transparency,
+                           std::vector<unsigned char>* output,
+                           int zlib_level) {
+  SkPixmap src;
+  if (!input.peekPixels(&src)) {
+    return false;
+  }
+  return EncodeSkPixmap(src, discard_transparency,
+                        std::vector<PNGCodec::Comment>(), output, zlib_level);
+}
+
+// static
+bool PNGCodec::EncodeBGRASkBitmap(const SkBitmap& input,
+                                  bool discard_transparency,
+                                  std::vector<unsigned char>* output) {
+  return EncodeSkBitmap(input, discard_transparency, output,
+                        DEFAULT_ZLIB_COMPRESSION);
+}
+
+// static
+bool PNGCodec::EncodeA8SkBitmap(const SkBitmap& input,
+                                std::vector<unsigned char>* output) {
+  DCHECK_EQ(input.colorType(), kAlpha_8_SkColorType);
+  auto info = input.info()
+                  .makeColorType(kGray_8_SkColorType)
+                  .makeAlphaType(kOpaque_SkAlphaType);
+  SkPixmap src(info, input.getAddr(0, 0), input.rowBytes());
+  return EncodeSkPixmap(src, std::vector<PNGCodec::Comment>(), output,
+                        DEFAULT_ZLIB_COMPRESSION);
+}
+
+// static
+bool PNGCodec::FastEncodeBGRASkBitmap(const SkBitmap& input,
+                                      bool discard_transparency,
+                                      std::vector<unsigned char>* output) {
+  return EncodeSkBitmap(input, discard_transparency, output, Z_BEST_SPEED);
+}
+
+PNGCodec::Comment::Comment(const std::string& k, const std::string& t)
+    : key(k), text(t) {
+}
+
+PNGCodec::Comment::~Comment() {
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/codec/png_codec.h b/ui/gfx/codec/png_codec.h
new file mode 100644
index 0000000..f5d4eb9
--- /dev/null
+++ b/ui/gfx/codec/png_codec.h
@@ -0,0 +1,132 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CODEC_PNG_CODEC_H_
+#define UI_GFX_CODEC_PNG_CODEC_H_
+
+#include <stddef.h>
+
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "ui/gfx/codec/codec_export.h"
+
+class SkBitmap;
+
+namespace gfx {
+
+class Size;
+
+// Interface for encoding and decoding PNG data. This is a wrapper around
+// libpng, which has an inconvenient interface for callers. This is currently
+// designed for use in tests only (where we control the files), so the handling
+// isn't as robust as would be required for a browser (see Decode() for more).
+// WebKit has its own more complicated PNG decoder which handles, among other
+// things, partially downloaded data.
+class CODEC_EXPORT PNGCodec {
+ public:
+  static constexpr int DEFAULT_ZLIB_COMPRESSION = 6;
+
+  enum ColorFormat {
+    // 4 bytes per pixel, in RGBA order in memory regardless of endianness.
+    FORMAT_RGBA,
+
+    // 4 bytes per pixel, in BGRA order in memory regardless of endianness.
+    // This is the default Windows DIB order.
+    FORMAT_BGRA,
+
+    // SkBitmap format. For Encode() kN32_SkColorType (4 bytes per pixel) and
+    // kAlpha_8_SkColorType (1 byte per pixel) formats are supported.
+    // kAlpha_8_SkColorType gets encoded into a grayscale PNG treating alpha as
+    // the color intensity. For Decode() kN32_SkColorType is always used.
+    FORMAT_SkBitmap
+  };
+
+  // Represents a comment in the tEXt ancillary chunk of the png.
+  struct CODEC_EXPORT Comment {
+    Comment(const std::string& k, const std::string& t);
+    ~Comment();
+
+    std::string key;
+    std::string text;
+  };
+
+  PNGCodec(const PNGCodec&) = delete;
+  PNGCodec& operator=(const PNGCodec&) = delete;
+
+  // Encodes the given raw 'input' data, with each pixel being represented as
+  // given in 'format'. The encoded PNG data will be written into the supplied
+  // vector and true will be returned on success. On failure (false), the
+  // contents of the output buffer are undefined.
+  //
+  // When writing alpha values, the input colors are assumed to be post
+  // multiplied.
+  //
+  // size: dimensions of the image
+  // row_byte_width: the width in bytes of each row. This may be greater than
+  //   w * bytes_per_pixel if there is extra padding at the end of each row
+  //   (often, each row is padded to the next machine word).
+  // discard_transparency: when true, and when the input data format includes
+  //   alpha values, these alpha values will be discarded and only RGB will be
+  //   written to the resulting file. Otherwise, alpha values in the input
+  //   will be preserved.
+  // comments: comments to be written in the png's metadata.
+  static bool Encode(const unsigned char* input,
+                     ColorFormat format,
+                     const Size& size,
+                     int row_byte_width,
+                     bool discard_transparency,
+                     const std::vector<Comment>& comments,
+                     std::vector<unsigned char>* output);
+
+  // Call PNGCodec::Encode on the supplied SkBitmap |input|, which is assumed to
+  // be kN32_SkColorType, 32 bits per pixel. The params |discard_transparency|
+  // and |output| are passed directly to Encode; refer to Encode for more
+  // information.
+  static bool EncodeBGRASkBitmap(const SkBitmap& input,
+                                 bool discard_transparency,
+                                 std::vector<unsigned char>* output);
+
+  // Call PNGCodec::Encode on the supplied SkBitmap |input|. The difference
+  // between this and the previous method is that this restricts compression to
+  // zlib q1, which is just rle encoding.
+  static bool FastEncodeBGRASkBitmap(const SkBitmap& input,
+                                     bool discard_transparency,
+                                     std::vector<unsigned char>* output);
+
+  // Call PNGCodec::Encode on the supplied SkBitmap |input|, which is assumed to
+  // be kAlpha_8_SkColorType, 8 bits per pixel. The bitmap is encoded as a
+  // grayscale PNG with alpha used for color intensity. The |output| param is
+  // passed directly to Encode; refer to Encode for more information.
+  static bool EncodeA8SkBitmap(const SkBitmap& input,
+                               std::vector<unsigned char>* output);
+
+  // Decodes the PNG data contained in input of length input_size. The
+  // decoded data will be placed in *output with the dimensions in *w and *h
+  // on success (returns true). This data will be written in the 'format'
+  // format. On failure, the values of these output variables are undefined.
+  //
+  // This function may not support all PNG types, and it hasn't been tested
+  // with a large number of images, so assume a new format may not work. It's
+  // really designed to be able to read in something written by Encode() above.
+  static bool Decode(const unsigned char* input, size_t input_size,
+                     ColorFormat format, std::vector<unsigned char>* output,
+                     int* w, int* h);
+
+  // Decodes the PNG data directly into the passed in SkBitmap. This is
+  // significantly faster than the vector<unsigned char> version of Decode()
+  // above when dealing with PNG files that are >500K, which a lot of theme
+  // images are. (There are a lot of themes that have a NTP image of about ~1
+  // megabyte, and those require a 7-10 megabyte side buffer.)
+  //
+  // Returns true if data is non-null and can be decoded as a png, false
+  // otherwise.
+  static bool Decode(const unsigned char* input, size_t input_size,
+                     SkBitmap* bitmap);
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_CODEC_PNG_CODEC_H_
diff --git a/ui/gfx/codec/png_codec_unittest.cc b/ui/gfx/codec/png_codec_unittest.cc
new file mode 100644
index 0000000..083c6a8
--- /dev/null
+++ b/ui/gfx/codec/png_codec_unittest.cc
@@ -0,0 +1,969 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <cmath>
+
+#include "base/cxx17_backports.h"
+#include "base/logging.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/libpng/png.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkColorPriv.h"
+#include "third_party/skia/include/core/SkUnPreMultiply.h"
+#include "third_party/zlib/zlib.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/skia_util.h"
+
+namespace gfx {
+
+namespace {
+
+void MakeRGBImage(int w, int h, std::vector<unsigned char>* data) {
+  data->resize(w * h * 3);
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      unsigned char* org_px = &(*data)[(y * w + x) * 3];
+      org_px[0] = x * 3;      // r
+      org_px[1] = x * 3 + 1;  // g
+      org_px[2] = x * 3 + 2;  // b
+    }
+  }
+}
+
+// Set use_transparency to write data into the alpha channel, otherwise it will
+// be filled with 0xff. With the alpha channel stripped, this should yield the
+// same image as MakeRGBImage above, so the code below can make reference
+// images for conversion testing.
+void MakeRGBAImage(int w, int h, bool use_transparency,
+                   std::vector<unsigned char>* data) {
+  data->resize(w * h * 4);
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      unsigned char* org_px = &(*data)[(y * w + x) * 4];
+      org_px[0] = x * 3;      // r
+      org_px[1] = x * 3 + 1;  // g
+      org_px[2] = x * 3 + 2;  // b
+      if (use_transparency)
+        org_px[3] = x*3 + 3;  // a
+      else
+        org_px[3] = 0xFF;     // a (opaque)
+    }
+  }
+}
+
+// Creates a palette-based image.
+void MakePaletteImage(int w, int h,
+                      std::vector<unsigned char>* data,
+                      std::vector<png_color>* palette,
+                      std::vector<unsigned char>* trans_chunk = 0) {
+  data->resize(w * h);
+  palette->resize(w);
+  for (int i = 0; i < w; ++i) {
+    png_color& color = (*palette)[i];
+    color.red = i * 3;
+    color.green = color.red + 1;
+    color.blue = color.red + 2;
+  }
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      (*data)[y * w + x] = x;  // palette index
+    }
+  }
+  if (trans_chunk) {
+    trans_chunk->resize(palette->size());
+    for (std::size_t i = 0; i < trans_chunk->size(); ++i) {
+      (*trans_chunk)[i] = i % 256;
+    }
+  }
+}
+
+// Creates a grayscale image without an alpha channel.
+void MakeGrayscaleImage(int w, int h,
+                        std::vector<unsigned char>* data) {
+  data->resize(w * h);
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      (*data)[y * w + x] = x;  // gray value
+    }
+  }
+}
+
+// Creates a grayscale image with an alpha channel.
+void MakeGrayscaleAlphaImage(int w, int h,
+                             std::vector<unsigned char>* data) {
+  data->resize(w * h * 2);
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      unsigned char* px = &(*data)[(y * w + x) * 2];
+      px[0] = x;        // gray value
+      px[1] = x % 256;  // alpha
+    }
+  }
+}
+
+// User write function (to be passed to libpng by EncodeImage) which writes
+// into a buffer instead of to a file.
+void WriteImageData(png_structp png_ptr,
+                    png_bytep data,
+                    png_size_t length) {
+  std::vector<unsigned char>& v =
+      *static_cast<std::vector<unsigned char>*>(png_get_io_ptr(png_ptr));
+  v.resize(v.size() + length);
+  memcpy(&v[v.size() - length], data, length);
+}
+
+// User flush function; goes with WriteImageData, above.
+void FlushImageData(png_structp /*png_ptr*/) {
+}
+
+// Libpng user error function which allows us to print libpng errors using
+// Chrome's logging facilities instead of stderr.
+void LogLibPNGError(png_structp png_ptr,
+                    png_const_charp error_msg) {
+  DLOG(ERROR) << "libpng encode error: " << error_msg;
+  longjmp(png_jmpbuf(png_ptr), 1);
+}
+
+// Goes with LogLibPNGError, above.
+void LogLibPNGWarning(png_structp png_ptr,
+                      png_const_charp warning_msg) {
+  DLOG(ERROR) << "libpng encode warning: " << warning_msg;
+}
+
+// Color types supported by EncodeImage. Required because neither libpng nor
+// PNGCodec::Encode supports all of the required values.
+enum ColorType {
+  COLOR_TYPE_GRAY = PNG_COLOR_TYPE_GRAY,
+  COLOR_TYPE_GRAY_ALPHA = PNG_COLOR_TYPE_GRAY_ALPHA,
+  COLOR_TYPE_PALETTE = PNG_COLOR_TYPE_PALETTE,
+  COLOR_TYPE_RGB = PNG_COLOR_TYPE_RGB,
+  COLOR_TYPE_RGBA = PNG_COLOR_TYPE_RGBA,
+  COLOR_TYPE_BGR,
+  COLOR_TYPE_BGRA
+};
+
+// PNG encoder used for testing. Required because PNGCodec::Encode doesn't do
+// interlaced, palette-based, or grayscale images, but PNGCodec::Decode is
+// actually asked to decode these types of images by Chrome.
+bool EncodeImage(const std::vector<unsigned char>& input,
+                 const int width,
+                 const int height,
+                 ColorType output_color_type,
+                 std::vector<unsigned char>* output,
+                 const int interlace_type = PNG_INTERLACE_NONE,
+                 std::vector<png_color>* palette = 0,
+                 std::vector<unsigned char>* palette_alpha = 0) {
+  DCHECK(output);
+
+  int input_rowbytes = 0;
+  int transforms = PNG_TRANSFORM_IDENTITY;
+
+  switch (output_color_type) {
+    case COLOR_TYPE_GRAY:
+      input_rowbytes = width;
+      break;
+    case COLOR_TYPE_GRAY_ALPHA:
+      input_rowbytes = width * 2;
+      break;
+    case COLOR_TYPE_PALETTE:
+      if (!palette)
+        return false;
+      input_rowbytes = width;
+      break;
+    case COLOR_TYPE_RGB:
+      input_rowbytes = width * 3;
+      break;
+    case COLOR_TYPE_RGBA:
+      input_rowbytes = width * 4;
+      break;
+    case COLOR_TYPE_BGR:
+      input_rowbytes = width * 3;
+      output_color_type = static_cast<ColorType>(PNG_COLOR_TYPE_RGB);
+      transforms |= PNG_TRANSFORM_BGR;
+      break;
+    case COLOR_TYPE_BGRA:
+      input_rowbytes = width * 4;
+      output_color_type = static_cast<ColorType>(PNG_COLOR_TYPE_RGBA);
+      transforms |= PNG_TRANSFORM_BGR;
+      break;
+  };
+
+  png_struct* png_ptr =
+      png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (!png_ptr)
+    return false;
+  png_infop info_ptr = png_create_info_struct(png_ptr);
+  if (!info_ptr) {
+    png_destroy_write_struct(&png_ptr, NULL);
+    return false;
+  }
+
+  std::vector<png_bytep> row_pointers(height);
+  for (int y = 0 ; y < height; ++y) {
+    row_pointers[y] = const_cast<unsigned char*>(&input[y * input_rowbytes]);
+  }
+
+  if (setjmp(png_jmpbuf(png_ptr))) {
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+    return false;
+  }
+
+  png_set_error_fn(png_ptr, NULL, LogLibPNGError, LogLibPNGWarning);
+  png_set_rows(png_ptr, info_ptr, &row_pointers[0]);
+  png_set_write_fn(png_ptr, output, WriteImageData, FlushImageData);
+  png_set_IHDR(png_ptr, info_ptr, width, height, 8, output_color_type,
+               interlace_type, PNG_COMPRESSION_TYPE_DEFAULT,
+               PNG_FILTER_TYPE_DEFAULT);
+  if (output_color_type == COLOR_TYPE_PALETTE) {
+    png_set_PLTE(png_ptr, info_ptr, &palette->front(), palette->size());
+    if (palette_alpha) {
+      unsigned char* alpha_data = &palette_alpha->front();
+      size_t alpha_size = palette_alpha->size();
+      png_set_tRNS(png_ptr, info_ptr, alpha_data, alpha_size, NULL);
+    }
+  }
+
+  png_write_png(png_ptr, info_ptr, transforms, NULL);
+
+  png_destroy_write_struct(&png_ptr, &info_ptr);
+  return true;
+}
+
+}  // namespace
+
+// Returns true if each channel of the given two colors are "close." This is
+// used for comparing colors where rounding errors may cause off-by-one.
+bool ColorsClose(uint32_t a, uint32_t b) {
+  return abs(static_cast<int>(SkColorGetB(a) - SkColorGetB(b))) < 2 &&
+         abs(static_cast<int>(SkColorGetG(a) - SkColorGetG(b))) < 2 &&
+         abs(static_cast<int>(SkColorGetR(a) - SkColorGetR(b))) < 2 &&
+         abs(static_cast<int>(SkColorGetA(a) - SkColorGetA(b))) < 2;
+}
+
+// Returns true if the RGB components are "close."
+bool NonAlphaColorsClose(uint32_t a, uint32_t b) {
+  return abs(static_cast<int>(SkColorGetB(a) - SkColorGetB(b))) < 2 &&
+         abs(static_cast<int>(SkColorGetG(a) - SkColorGetG(b))) < 2 &&
+         abs(static_cast<int>(SkColorGetR(a) - SkColorGetR(b))) < 2;
+}
+
+// Returns true if the BGRA 32-bit SkColor specified by |a| is equivalent to the
+// 8-bit Gray color specified by |b|.
+bool BGRAGrayEqualsA8Gray(uint32_t a, uint8_t b) {
+  return SkColorGetB(a) == b && SkColorGetG(a) ==  b &&
+         SkColorGetR(a) == b && SkColorGetA(a) == 255;
+}
+
+void MakeTestBGRASkBitmap(int w, int h, SkBitmap* bmp) {
+  bmp->allocN32Pixels(w, h);
+
+  uint32_t* src_data = bmp->getAddr32(0, 0);
+  for (int i = 0; i < w * h; i++)
+    src_data[i] = SkPreMultiplyARGB(i % 255, i % 250, i % 245, i % 240);
+}
+
+void MakeTestA8SkBitmap(int w, int h, SkBitmap* bmp) {
+  bmp->allocPixels(SkImageInfo::MakeA8(w, h));
+
+  uint8_t* src_data = bmp->getAddr8(0, 0);
+  for (int i = 0; i < w * h; i++)
+    src_data[i] = i % 255;
+}
+
+TEST(PNGCodec, EncodeDecodeRGBA) {
+  const int w = 20, h = 20;
+
+  // create an image with known values, a must be opaque because it will be
+  // lost during encoding
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, true, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA,
+                               Size(w, h), w * 4, false,
+                               std::vector<PNGCodec::Comment>(),
+                               &encoded));
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be exactly equal
+  ASSERT_TRUE(original == decoded);
+}
+
+TEST(PNGCodec, EncodeDecodeBGRA) {
+  const int w = 20, h = 20;
+
+  // Create an image with known values, alpha must be opaque because it will be
+  // lost during encoding.
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, true, &original);
+
+  // Encode.
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_BGRA,
+                               Size(w, h), w * 4, false,
+                               std::vector<PNGCodec::Comment>(),
+                               &encoded));
+
+  // Decode, it should have the same size as the original.
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_BGRA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be exactly equal.
+  ASSERT_TRUE(original == decoded);
+}
+
+TEST(PNGCodec, DecodePalette) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  std::vector<png_color> original_palette;
+  std::vector<unsigned char> original_trans_chunk;
+  MakePaletteImage(w, h, &original, &original_palette, &original_trans_chunk);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_PALETTE,
+                          &encoded,
+                          PNG_INTERLACE_NONE,
+                          &original_palette,
+                          &original_trans_chunk));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), w * h * 4U);
+
+  // Images must be equal
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      unsigned char palette_pixel = original[y * w + x];
+      png_color& palette_color = original_palette[palette_pixel];
+      int alpha = original_trans_chunk[palette_pixel];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
+
+      EXPECT_EQ(palette_color.red, rgba_pixel[0]);
+      EXPECT_EQ(palette_color.green, rgba_pixel[1]);
+      EXPECT_EQ(palette_color.blue, rgba_pixel[2]);
+      EXPECT_EQ(alpha, rgba_pixel[3]);
+    }
+  }
+}
+
+TEST(PNGCodec, DecodeInterlacedPalette) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  std::vector<png_color> original_palette;
+  std::vector<unsigned char> original_trans_chunk;
+  MakePaletteImage(w, h, &original, &original_palette, &original_trans_chunk);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_PALETTE,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7,
+                          &original_palette,
+                          &original_trans_chunk));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), w * h * 4U);
+
+  // Images must be equal
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      unsigned char palette_pixel = original[y * w + x];
+      png_color& palette_color = original_palette[palette_pixel];
+      int alpha = original_trans_chunk[palette_pixel];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
+
+      EXPECT_EQ(palette_color.red, rgba_pixel[0]);
+      EXPECT_EQ(palette_color.green, rgba_pixel[1]);
+      EXPECT_EQ(palette_color.blue, rgba_pixel[2]);
+      EXPECT_EQ(alpha, rgba_pixel[3]);
+    }
+  }
+}
+
+TEST(PNGCodec, DecodeGrayscale) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeGrayscaleImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original, w, h, COLOR_TYPE_GRAY, &encoded));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded, &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), original.size() * 4);
+
+  // Images must be equal
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      unsigned char gray_pixel = original[(y * w + x)];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
+      EXPECT_EQ(rgba_pixel[0], gray_pixel);
+      EXPECT_EQ(rgba_pixel[1], gray_pixel);
+      EXPECT_EQ(rgba_pixel[2], gray_pixel);
+      EXPECT_EQ(rgba_pixel[3], 0xff);
+    }
+  }
+}
+
+TEST(PNGCodec, DecodeGrayscaleWithAlpha) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeGrayscaleAlphaImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_GRAY_ALPHA,
+                          &encoded));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), original.size() * 2);
+
+  // Images must be equal
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      unsigned char* gray_pixel = &original[(y * w + x) * 2];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
+      EXPECT_EQ(rgba_pixel[0], gray_pixel[0]);
+      EXPECT_EQ(rgba_pixel[1], gray_pixel[0]);
+      EXPECT_EQ(rgba_pixel[2], gray_pixel[0]);
+      EXPECT_EQ(rgba_pixel[3], gray_pixel[1]);
+    }
+  }
+}
+
+TEST(PNGCodec, DecodeInterlacedGrayscale) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeGrayscaleImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_GRAY,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), original.size() * 4);
+
+  // Images must be equal
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      unsigned char gray_pixel = original[(y * w + x)];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
+      EXPECT_EQ(rgba_pixel[0], gray_pixel);
+      EXPECT_EQ(rgba_pixel[1], gray_pixel);
+      EXPECT_EQ(rgba_pixel[2], gray_pixel);
+      EXPECT_EQ(rgba_pixel[3], 0xFF);
+    }
+  }
+}
+
+TEST(PNGCodec, DecodeInterlacedGrayscaleWithAlpha) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeGrayscaleAlphaImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_GRAY_ALPHA,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), original.size() * 2);
+
+  // Images must be equal
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      unsigned char* gray_pixel = &original[(y * w + x) * 2];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
+      EXPECT_EQ(rgba_pixel[0], gray_pixel[0]);
+      EXPECT_EQ(rgba_pixel[1], gray_pixel[0]);
+      EXPECT_EQ(rgba_pixel[2], gray_pixel[0]);
+      EXPECT_EQ(rgba_pixel[3], gray_pixel[1]);
+    }
+  }
+}
+
+TEST(PNGCodec, DecodeInterlacedRGBA) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, false, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_RGBA,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be equal
+  ASSERT_EQ(original, decoded);
+}
+
+TEST(PNGCodec, DecodeInterlacedBGR) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_BGR,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_BGRA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), w * h * 4U);
+
+  // Images must be equal
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      unsigned char* orig_px = &original[(y * w + x) * 3];
+      unsigned char* dec_px = &decoded[(y * w + x) * 4];
+      EXPECT_EQ(dec_px[0], orig_px[0]);
+      EXPECT_EQ(dec_px[1], orig_px[1]);
+      EXPECT_EQ(dec_px[2], orig_px[2]);
+    }
+  }
+}
+
+TEST(PNGCodec, DecodeInterlacedBGRA) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, false, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_BGRA,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_BGRA, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be equal
+  ASSERT_EQ(original, decoded);
+}
+
+// Not encoding an interlaced PNG from SkBitmap because we don't do it
+// anywhere, and the ability to do that requires more code changes.
+TEST(PNGCodec, DecodeInterlacedRGBtoSkBitmap) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_RGB,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // Decode the encoded string.
+  SkBitmap decoded_bitmap;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
+                               &decoded_bitmap));
+
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      const unsigned char* original_pixel = &original[(y * w + x) * 3];
+      const uint32_t original_pixel_sk = SkPackARGB32(0xFF,
+                                                      original_pixel[0],
+                                                      original_pixel[1],
+                                                      original_pixel[2]);
+      const uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
+      EXPECT_EQ(original_pixel_sk, decoded_pixel);
+    }
+  }
+}
+
+TEST(PNGCodec, DecodeInterlacedRGBAtoSkBitmap) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, false, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_RGBA,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // Decode the encoded string.
+  SkBitmap decoded_bitmap;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
+                               &decoded_bitmap));
+
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      const unsigned char* original_pixel = &original[(y * w + x) * 4];
+      const uint32_t original_pixel_sk = SkPackARGB32(original_pixel[3],
+                                                      original_pixel[0],
+                                                      original_pixel[1],
+                                                      original_pixel[2]);
+      const uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
+      EXPECT_EQ(original_pixel_sk, decoded_pixel);
+    }
+  }
+}
+
+// Test that corrupted data decompression causes failures.
+TEST(PNGCodec, DecodeCorrupted) {
+  int w = 20, h = 20;
+
+  // Make some random data (an uncompressed image).
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, false, &original);
+
+  // It should fail when given non-PNG compressed data.
+  std::vector<unsigned char> output;
+  int outw, outh;
+  EXPECT_FALSE(PNGCodec::Decode(&original[0], original.size(),
+                                PNGCodec::FORMAT_RGBA, &output, &outw, &outh));
+
+  // Make some compressed data.
+  std::vector<unsigned char> compressed;
+  ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA, Size(w, h),
+                               w * 4, false, std::vector<PNGCodec::Comment>(),
+                               &compressed));
+
+  // Try decompressing a truncated version.
+  EXPECT_FALSE(PNGCodec::Decode(&compressed[0], compressed.size() / 2,
+                                PNGCodec::FORMAT_RGBA, &output, &outw, &outh));
+
+  // Corrupt it and try decompressing that.
+  for (int i = 10; i < 30; i++)
+    compressed[i] = i;
+  EXPECT_FALSE(PNGCodec::Decode(&compressed[0], compressed.size(),
+                                PNGCodec::FORMAT_RGBA, &output, &outw, &outh));
+}
+
+TEST(PNGCodec, EncodeBGRASkBitmapStridePadded) {
+  const int kWidth = 20;
+  const int kHeight = 20;
+  const int kPaddedWidth = 32;
+  const int kBytesPerPixel = 4;
+  const int kRowBytes = kPaddedWidth * kBytesPerPixel;
+
+  SkImageInfo info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
+  SkBitmap original_bitmap;
+  original_bitmap.setInfo(info, kRowBytes);
+  original_bitmap.allocPixels();
+
+  // Write data over the source bitmap.
+  // We write on the pad area here too.
+  // The encoder should ignore the pad area.
+  uint32_t* src_data = original_bitmap.getAddr32(0, 0);
+  const int count =
+      original_bitmap.computeByteSize() / original_bitmap.bytesPerPixel();
+  for (int i = 0; i < count; i++) {
+    src_data[i] = SkPreMultiplyARGB(i % 255, i % 250, i % 245, i % 240);
+  }
+
+  // Encode the bitmap.
+  std::vector<unsigned char> encoded;
+  PNGCodec::EncodeBGRASkBitmap(original_bitmap, false, &encoded);
+
+  // Decode the encoded string.
+  SkBitmap decoded_bitmap;
+  EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
+                               &decoded_bitmap));
+
+  // Compare the original bitmap and the output bitmap. We use ColorsClose
+  // as SkBitmaps are considered to be pre-multiplied, the unpremultiplication
+  // (in Encode) and repremultiplication (in Decode) can be lossy.
+  for (int x = 0; x < kWidth; x++) {
+    for (int y = 0; y < kHeight; y++) {
+      uint32_t original_pixel = original_bitmap.getAddr32(0, y)[x];
+      uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
+      EXPECT_TRUE(ColorsClose(original_pixel, decoded_pixel));
+    }
+  }
+}
+
+TEST(PNGCodec, EncodeBGRASkBitmap) {
+  const int w = 20, h = 20;
+
+  SkBitmap original_bitmap;
+  MakeTestBGRASkBitmap(w, h, &original_bitmap);
+
+  // Encode the bitmap.
+  std::vector<unsigned char> encoded;
+  PNGCodec::EncodeBGRASkBitmap(original_bitmap, false, &encoded);
+
+  // Decode the encoded string.
+  SkBitmap decoded_bitmap;
+  EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
+                               &decoded_bitmap));
+
+  // Compare the original bitmap and the output bitmap. We use ColorsClose
+  // as SkBitmaps are considered to be pre-multiplied, the unpremultiplication
+  // (in Encode) and repremultiplication (in Decode) can be lossy.
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      uint32_t original_pixel = original_bitmap.getAddr32(0, y)[x];
+      uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
+      EXPECT_TRUE(ColorsClose(original_pixel, decoded_pixel));
+    }
+  }
+}
+
+TEST(PNGCodec, EncodeA8SkBitmap) {
+  const int w = 20, h = 20;
+
+  SkBitmap original_bitmap;
+  MakeTestA8SkBitmap(w, h, &original_bitmap);
+
+  // Encode the bitmap.
+  std::vector<unsigned char> encoded;
+  EXPECT_TRUE(PNGCodec::EncodeA8SkBitmap(original_bitmap, &encoded));
+
+  // Decode the encoded string.
+  SkBitmap decoded_bitmap;
+  EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
+                               &decoded_bitmap));
+
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      uint8_t original_pixel = *original_bitmap.getAddr8(x, y);
+      uint32_t decoded_pixel = *decoded_bitmap.getAddr32(x, y);
+      EXPECT_TRUE(BGRAGrayEqualsA8Gray(decoded_pixel, original_pixel));
+    }
+  }
+}
+
+TEST(PNGCodec, EncodeBGRASkBitmapDiscardTransparency) {
+  const int w = 20, h = 20;
+
+  SkBitmap original_bitmap;
+  MakeTestBGRASkBitmap(w, h, &original_bitmap);
+
+  // Encode the bitmap.
+  std::vector<unsigned char> encoded;
+  PNGCodec::EncodeBGRASkBitmap(original_bitmap, true, &encoded);
+
+  // Decode the encoded string.
+  SkBitmap decoded_bitmap;
+  EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
+                               &decoded_bitmap));
+
+  // Compare the original bitmap and the output bitmap. We need to
+  // unpremultiply original_pixel, as the decoded bitmap doesn't have an alpha
+  // channel.
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      uint32_t original_pixel = original_bitmap.getAddr32(0, y)[x];
+      uint32_t unpremultiplied =
+          SkUnPreMultiply::PMColorToColor(original_pixel);
+      uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
+      uint32_t unpremultiplied_decoded =
+          SkUnPreMultiply::PMColorToColor(decoded_pixel);
+
+      EXPECT_TRUE(NonAlphaColorsClose(unpremultiplied, unpremultiplied_decoded))
+          << "Original_pixel: ("
+          << SkColorGetR(unpremultiplied) << ", "
+          << SkColorGetG(unpremultiplied) << ", "
+          << SkColorGetB(unpremultiplied) << "), "
+          << "Decoded pixel: ("
+          << SkColorGetR(unpremultiplied_decoded) << ", "
+          << SkColorGetG(unpremultiplied_decoded) << ", "
+          << SkColorGetB(unpremultiplied_decoded) << ")";
+    }
+  }
+}
+
+TEST(PNGCodec, EncodeWithComment) {
+  const int w = 10, h = 10;
+
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, true, &original);
+
+  std::vector<unsigned char> encoded;
+  std::vector<PNGCodec::Comment> comments;
+  comments.push_back(PNGCodec::Comment("key", "text"));
+  comments.push_back(PNGCodec::Comment("test", "something"));
+  comments.push_back(PNGCodec::Comment("have some", "spaces in both"));
+  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA, Size(w, h),
+                               w * 4, false, comments, &encoded));
+
+  // Each chunk is of the form length (4 bytes), chunk type (tEXt), data,
+  // checksum (4 bytes).  Make sure we find all of them in the encoded
+  // results.
+  const unsigned char kExpected1[] =
+      "\x00\x00\x00\x08tEXtkey\x00text\x9e\xe7\x66\x51";
+  const unsigned char kExpected2[] =
+      "\x00\x00\x00\x0etEXttest\x00something\x29\xba\xef\xac";
+  const unsigned char kExpected3[] =
+      "\x00\x00\x00\x18tEXthave some\x00spaces in both\x8d\x69\x34\x2d";
+
+  EXPECT_NE(std::search(encoded.begin(), encoded.end(), kExpected1,
+                        kExpected1 + base::size(kExpected1)),
+            encoded.end());
+  EXPECT_NE(std::search(encoded.begin(), encoded.end(), kExpected2,
+                        kExpected2 + base::size(kExpected2)),
+            encoded.end());
+  EXPECT_NE(std::search(encoded.begin(), encoded.end(), kExpected3,
+                        kExpected3 + base::size(kExpected3)),
+            encoded.end());
+}
+
+TEST(PNGCodec, EncodeDecodeWithVaryingCompressionLevels) {
+  const int w = 20, h = 20;
+
+  // create an image with known values, a must be opaque because it will be
+  // lost during encoding
+  SkBitmap original_bitmap;
+  MakeTestBGRASkBitmap(w, h, &original_bitmap);
+
+  // encode
+  std::vector<unsigned char> encoded_normal;
+  EXPECT_TRUE(
+      PNGCodec::EncodeBGRASkBitmap(original_bitmap, false, &encoded_normal));
+
+  std::vector<unsigned char> encoded_fast;
+  EXPECT_TRUE(
+      PNGCodec::FastEncodeBGRASkBitmap(original_bitmap, false, &encoded_fast));
+
+  // Make sure the different compression settings actually do something; the
+  // sizes should be different.
+  EXPECT_NE(encoded_normal.size(), encoded_fast.size());
+
+  // decode, they should be identical to the original.
+  SkBitmap decoded;
+  EXPECT_TRUE(
+      PNGCodec::Decode(&encoded_normal[0], encoded_normal.size(), &decoded));
+  EXPECT_TRUE(BitmapsAreEqual(decoded, original_bitmap));
+
+  EXPECT_TRUE(
+      PNGCodec::Decode(&encoded_fast[0], encoded_fast.size(), &decoded));
+  EXPECT_TRUE(BitmapsAreEqual(decoded, original_bitmap));
+}
+
+
+}  // namespace gfx
diff --git a/ui/gfx/codec/vector_wstream.cc b/ui/gfx/codec/vector_wstream.cc
new file mode 100644
index 0000000..6d485a2
--- /dev/null
+++ b/ui/gfx/codec/vector_wstream.cc
@@ -0,0 +1,19 @@
+// Copyright (c) 2017 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.
+
+#include "ui/gfx/codec/vector_wstream.h"
+
+namespace gfx {
+
+bool VectorWStream::write(const void* buffer, size_t size) {
+  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(buffer);
+  dst_->insert(dst_->end(), ptr, ptr + size);
+  return true;
+}
+
+size_t VectorWStream::bytesWritten() const {
+  return dst_->size();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/codec/vector_wstream.h b/ui/gfx/codec/vector_wstream.h
new file mode 100644
index 0000000..b740e7e
--- /dev/null
+++ b/ui/gfx/codec/vector_wstream.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CODEC_VECTOR_WSTREAM_H_
+#define UI_GFX_CODEC_VECTOR_WSTREAM_H_
+
+#include <stddef.h>
+
+#include <vector>
+
+#include "base/check_op.h"
+#include "third_party/skia/include/core/SkStream.h"
+
+namespace gfx {
+
+class VectorWStream : public SkWStream {
+ public:
+  // We do not take ownership of dst
+  VectorWStream(std::vector<unsigned char>* dst) : dst_(dst) {
+    DCHECK(dst_);
+    DCHECK_EQ(0UL, dst_->size());
+  }
+
+  bool write(const void* buffer, size_t size) override;
+
+  size_t bytesWritten() const override;
+
+ private:
+  // Does not have ownership.
+  std::vector<unsigned char>* dst_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_CODEC_VECTOR_WSTREAM_H_
diff --git a/ui/gfx/codec/webp_codec.cc b/ui/gfx/codec/webp_codec.cc
new file mode 100644
index 0000000..d325fe1
--- /dev/null
+++ b/ui/gfx/codec/webp_codec.cc
@@ -0,0 +1,36 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/codec/webp_codec.h"
+
+#include "third_party/skia/include/encode/SkWebpEncoder.h"
+#include "ui/gfx/codec/vector_wstream.h"
+
+namespace gfx {
+
+// Encoder ---------------------------------------------------------------------
+
+bool WebpCodec::Encode(const SkPixmap& input,
+                       int quality,
+                       std::vector<unsigned char>* output) {
+  output->clear();
+  VectorWStream dst(output);
+
+  SkWebpEncoder::Options options;
+  options.fQuality = quality;
+  return SkWebpEncoder::Encode(&dst, input, options);
+}
+
+bool WebpCodec::Encode(const SkBitmap& src,
+                       int quality,
+                       std::vector<unsigned char>* output) {
+  SkPixmap pixmap;
+  if (!src.peekPixels(&pixmap)) {
+    return false;
+  }
+
+  return WebpCodec::Encode(pixmap, quality, output);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/codec/webp_codec.h b/ui/gfx/codec/webp_codec.h
new file mode 100644
index 0000000..ce4e0aa
--- /dev/null
+++ b/ui/gfx/codec/webp_codec.h
@@ -0,0 +1,56 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_CODEC_WEBP_CODEC_H_
+#define UI_GFX_CODEC_WEBP_CODEC_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkPixmap.h"
+#include "ui/gfx/codec/codec_export.h"
+
+class SkBitmap;
+
+namespace gfx {
+
+class Size;
+
+// Interface for encoding WebP data. This is currently only used
+// in the devtools protocol to encode screenshots, so currently only minimally
+// supports lossy encoding.
+class CODEC_EXPORT WebpCodec {
+ public:
+  WebpCodec(const WebpCodec&) = delete;
+  WebpCodec& operator=(const WebpCodec&) = delete;
+
+  // Encodes (lossy) the given raw 'input' pixmap, which includes a pointer to
+  // pixels as well as information describing the pixel format. The encoded WebP
+  // data will be written into the supplied vector and true will be returned on
+  // success. On failure (false), the contents of the output buffer are
+  // undefined.
+  //
+  // quality: an integer in the range 0-100, where 100 is the highest quality.
+  //          Since this currently only supports lossy encoding, a higher
+  //          quality means a higher visual quality.
+  static bool Encode(const SkPixmap& input,
+                     int quality,
+                     std::vector<unsigned char>* output);
+
+  // Encodes (lossy) the 'input' bitmap. The encoded WebP data will be written
+  // into the supplied vector and true will be returned on success. On failure
+  // (false), the contents of the output buffer are undefined.
+  //
+  // quality: an integer in the range 0-100, where 100 is the highest quality.
+  //          Since this currently only supports lossy encoding, a higher
+  //          quality means a higher visual quality.
+  static bool Encode(const SkBitmap& input,
+                     int quality,
+                     std::vector<unsigned char>* output);
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_CODEC_WEBP_CODEC_H_
diff --git a/ui/gfx/color_analysis.cc b/ui/gfx/color_analysis.cc
new file mode 100644
index 0000000..8a74f0b
--- /dev/null
+++ b/ui/gfx/color_analysis.cc
@@ -0,0 +1,967 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/color_analysis.h"
+
+#include <limits.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <unordered_map>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/check_op.h"
+#include "base/cxx17_backports.h"
+#include "base/notreached.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkUnPreMultiply.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/range/range.h"
+
+namespace color_utils {
+namespace {
+
+// RGBA KMean Constants
+const int kNumberOfClusters = 4;
+const int kNumberOfIterations = 50;
+
+const HSL kDefaultLowerHSLBound = {-1, -1, 0.15};
+const HSL kDefaultUpperHSLBound = {-1, -1, 0.85};
+
+// Background Color Modification Constants
+const SkColor kDefaultBgColor = SK_ColorWHITE;
+
+// Support class to hold information about each cluster of pixel data in
+// the KMean algorithm. While this class does not contain all of the points
+// that exist in the cluster, it keeps track of the aggregate sum so it can
+// compute the new center appropriately.
+class KMeanCluster {
+ public:
+  KMeanCluster() {
+    Reset();
+  }
+
+  void Reset() {
+    centroid_[0] = centroid_[1] = centroid_[2] = 0;
+    aggregate_[0] = aggregate_[1] = aggregate_[2] = 0;
+    counter_ = 0;
+    weight_ = 0;
+  }
+
+  inline void SetCentroid(uint8_t r, uint8_t g, uint8_t b) {
+    centroid_[0] = r;
+    centroid_[1] = g;
+    centroid_[2] = b;
+  }
+
+  inline void GetCentroid(uint8_t* r, uint8_t* g, uint8_t* b) {
+    *r = centroid_[0];
+    *g = centroid_[1];
+    *b = centroid_[2];
+  }
+
+  inline bool IsAtCentroid(uint8_t r, uint8_t g, uint8_t b) {
+    return r == centroid_[0] && g == centroid_[1] && b == centroid_[2];
+  }
+
+  // Recomputes the centroid of the cluster based on the aggregate data. The
+  // number of points used to calculate this center is stored for weighting
+  // purposes. The aggregate and counter are then cleared to be ready for the
+  // next iteration.
+  inline void RecomputeCentroid() {
+    if (counter_ > 0) {
+      centroid_[0] = static_cast<uint8_t>(aggregate_[0] / counter_);
+      centroid_[1] = static_cast<uint8_t>(aggregate_[1] / counter_);
+      centroid_[2] = static_cast<uint8_t>(aggregate_[2] / counter_);
+
+      aggregate_[0] = aggregate_[1] = aggregate_[2] = 0;
+      weight_ = counter_;
+      counter_ = 0;
+    }
+  }
+
+  inline void AddPoint(uint8_t r, uint8_t g, uint8_t b) {
+    aggregate_[0] += r;
+    aggregate_[1] += g;
+    aggregate_[2] += b;
+    ++counter_;
+  }
+
+  // Just returns the distance^2. Since we are comparing relative distances
+  // there is no need to perform the expensive sqrt() operation.
+  inline uint32_t GetDistanceSqr(uint8_t r, uint8_t g, uint8_t b) {
+    return (r - centroid_[0]) * (r - centroid_[0]) +
+           (g - centroid_[1]) * (g - centroid_[1]) +
+           (b - centroid_[2]) * (b - centroid_[2]);
+  }
+
+  // In order to determine if we have hit convergence or not we need to see
+  // if the centroid of the cluster has moved. This determines whether or
+  // not the centroid is the same as the aggregate sum of points that will be
+  // used to generate the next centroid.
+  inline bool CompareCentroidWithAggregate() {
+    if (counter_ == 0)
+      return false;
+
+    return aggregate_[0] / counter_ == centroid_[0] &&
+           aggregate_[1] / counter_ == centroid_[1] &&
+           aggregate_[2] / counter_ == centroid_[2];
+  }
+
+  // Returns the previous counter, which is used to determine the weight
+  // of the cluster for sorting.
+  inline uint32_t GetWeight() const {
+    return weight_;
+  }
+
+  static bool SortKMeanClusterByWeight(const KMeanCluster& a,
+                                       const KMeanCluster& b) {
+    return a.GetWeight() > b.GetWeight();
+  }
+
+ private:
+  uint8_t centroid_[3];
+
+  // Holds the sum of all the points that make up this cluster. Used to
+  // generate the next centroid as well as to check for convergence.
+  uint32_t aggregate_[3];
+  uint32_t counter_;
+
+  // The weight of the cluster, determined by how many points were used
+  // to generate the previous centroid.
+  uint32_t weight_;
+};
+
+// Prominent color utilities ---------------------------------------------------
+
+// A |ColorBox| represents a 3-dimensional region in a color space (an ordered
+// set of colors). It is a range in the ordered set, with a low index and a high
+// index. The diversity (volume) of the box is computed by looking at the range
+// of color values it spans, where r, g, and b components are considered
+// separately.
+class ColorBox {
+ public:
+  explicit ColorBox(std::vector<SkColor>* color_space)
+      : ColorBox(color_space, gfx::Range(0, color_space->size())) {}
+  ColorBox(const ColorBox& other) = default;
+  ColorBox& operator=(const ColorBox& other) = default;
+  ~ColorBox() {}
+
+  // Can't split if there's only one color in the box.
+  bool CanSplit() const { return color_range_.length() > 1; }
+
+  // Splits |this| in two and returns the other half.
+  ColorBox Split() {
+    // Calculate which component has the largest range...
+    const uint8_t r_dimension = max_r_ - min_r_;
+    const uint8_t g_dimension = max_g_ - min_g_;
+    const uint8_t b_dimension = max_b_ - min_b_;
+    const uint8_t long_dimension =
+        std::max({r_dimension, g_dimension, b_dimension});
+    const enum {
+      RED,
+      GREEN,
+      BLUE,
+    } channel = long_dimension == r_dimension
+                    ? RED
+                    : long_dimension == g_dimension ? GREEN : BLUE;
+
+    // ... and sort along that axis.
+    auto sort_function = [channel](SkColor a, SkColor b) {
+      switch (channel) {
+        case RED:
+          return SkColorGetR(a) < SkColorGetR(b);
+        case GREEN:
+          return SkColorGetG(a) < SkColorGetG(b);
+        case BLUE:
+          return SkColorGetB(a) < SkColorGetB(b);
+      }
+      NOTREACHED();
+      return SkColorGetB(a) < SkColorGetB(b);
+    };
+    // Just the portion of |color_space_| that's covered by this box should be
+    // sorted.
+    std::sort(color_space_->begin() + color_range_.start(),
+              color_space_->begin() + color_range_.end(), sort_function);
+
+    // Split at the first color value that's not less than the midpoint (mean of
+    // the start and values).
+    uint32_t split_point = color_range_.end() - 1;
+    for (uint32_t i = color_range_.start() + 1; i < color_range_.end() - 1;
+         ++i) {
+      bool past_midpoint = false;
+      switch (channel) {
+        case RED:
+          past_midpoint =
+              static_cast<uint8_t>(SkColorGetR((*color_space_)[i])) >
+              (min_r_ + max_r_) / 2;
+          break;
+        case GREEN:
+          past_midpoint =
+              static_cast<uint8_t>(SkColorGetG((*color_space_)[i])) >
+              (min_g_ + max_g_) / 2;
+          break;
+        case BLUE:
+          past_midpoint =
+              static_cast<uint8_t>(SkColorGetB((*color_space_)[i])) >
+              (min_b_ + max_b_) / 2;
+          break;
+      }
+      if (past_midpoint) {
+        split_point = i;
+        break;
+      }
+    }
+
+    // Break off half and return it.
+    gfx::Range other_range = color_range_;
+    other_range.set_end(split_point);
+    ColorBox other_box(color_space_, other_range);
+
+    // Keep the other half in |this| and recalculate our color bounds.
+    color_range_.set_start(split_point);
+    RecomputeBounds();
+    return other_box;
+  }
+
+  // Returns the average color of this box, weighted by its popularity in
+  // |color_counts|.
+  Swatch GetWeightedAverageColor(
+      const std::unordered_map<SkColor, int>& color_counts) const {
+    size_t sum_r = 0;
+    size_t sum_g = 0;
+    size_t sum_b = 0;
+    size_t total_count_in_box = 0;
+
+    for (size_t i = color_range_.start(); i < color_range_.end(); ++i) {
+      const SkColor color = (*color_space_)[i];
+      const auto color_count_iter = color_counts.find(color);
+      DCHECK(color_count_iter != color_counts.end());
+      const size_t color_count = color_count_iter->second;
+
+      total_count_in_box += color_count;
+      sum_r += color_count * SkColorGetR(color);
+      sum_g += color_count * SkColorGetG(color);
+      sum_b += color_count * SkColorGetB(color);
+    }
+
+    return Swatch(
+        SkColorSetRGB(
+            std::round(static_cast<double>(sum_r) / total_count_in_box),
+            std::round(static_cast<double>(sum_g) / total_count_in_box),
+            std::round(static_cast<double>(sum_b) / total_count_in_box)),
+        total_count_in_box);
+  }
+
+  static bool CompareByVolume(const ColorBox& a, const ColorBox& b) {
+    return a.volume_ < b.volume_;
+  }
+
+ private:
+  ColorBox(std::vector<SkColor>* color_space, const gfx::Range& color_range)
+      : color_space_(color_space), color_range_(color_range) {
+    RecomputeBounds();
+  }
+
+  void RecomputeBounds() {
+    DCHECK(!color_range_.is_reversed());
+    DCHECK(!color_range_.is_empty());
+    DCHECK_LE(color_range_.end(), color_space_->size());
+
+    min_r_ = 0xFF;
+    min_g_ = 0xFF;
+    min_b_ = 0xFF;
+    max_r_ = 0;
+    max_g_ = 0;
+    max_b_ = 0;
+
+    for (uint32_t i = color_range_.start(); i < color_range_.end(); ++i) {
+      SkColor color = (*color_space_)[i];
+      min_r_ = std::min<uint8_t>(SkColorGetR(color), min_r_);
+      min_g_ = std::min<uint8_t>(SkColorGetG(color), min_g_);
+      min_b_ = std::min<uint8_t>(SkColorGetB(color), min_b_);
+      max_r_ = std::max<uint8_t>(SkColorGetR(color), max_r_);
+      max_g_ = std::max<uint8_t>(SkColorGetG(color), max_g_);
+      max_b_ = std::max<uint8_t>(SkColorGetB(color), max_b_);
+    }
+
+    volume_ =
+        (max_r_ - min_r_ + 1) * (max_g_ - min_g_ + 1) * (max_b_ - min_b_ + 1);
+  }
+
+  // The set of colors of which this box captures a subset. This vector is not
+  // owned but may be modified during the split operation.
+  std::vector<SkColor>* color_space_;
+
+  // The range of indexes into |color_space_| that are part of this box.
+  gfx::Range color_range_;
+
+  // Cached min and max color component values for the colors in this box.
+  uint8_t min_r_ = 0;
+  uint8_t min_g_ = 0;
+  uint8_t min_b_ = 0;
+  uint8_t max_r_ = 0;
+  uint8_t max_g_ = 0;
+  uint8_t max_b_ = 0;
+
+  // Cached volume value, which is the product of the range of each color
+  // component.
+  int volume_ = 0;
+};
+
+// Some color values should be ignored for the purposes of determining prominent
+// colors.
+bool IsInterestingColor(const SkColor& color) {
+  const float average_channel_value =
+      (SkColorGetR(color) + SkColorGetG(color) + SkColorGetB(color)) / 3.0f;
+  // If a color is too close to white or black, ignore it.
+  if (average_channel_value >= 237 || average_channel_value <= 22)
+    return false;
+
+  HSL hsl;
+  SkColorToHSL(color, &hsl);
+  return !(hsl.h >= 0.028f && hsl.h <= 0.10f && hsl.s <= 0.82f);
+}
+
+// Used to group lower_bound, upper_bound, goal HSL color together for prominent
+// color calculation.
+struct ColorBracket {
+  HSL lower_bound = {-1};
+  HSL upper_bound = {-1};
+  HSL goal = {-1};
+};
+
+std::vector<Swatch> CalculateProminentColors(
+    const SkBitmap& bitmap,
+    const std::vector<ColorBracket>& color_brackets,
+    const gfx::Rect& region,
+    absl::optional<ColorSwatchFilter> filter) {
+  DCHECK(!bitmap.empty());
+  DCHECK(!bitmap.isNull());
+
+  std::vector<Swatch> box_colors =
+      CalculateColorSwatches(bitmap, 12, region, filter);
+
+  std::vector<Swatch> best_colors(color_brackets.size(), Swatch());
+  if (box_colors.empty())
+    return best_colors;
+
+  size_t max_weight = 0;
+  for (auto& weighted : box_colors)
+    max_weight = std::max(max_weight, weighted.population);
+
+  // Given these box average colors, find the best one for each desired color
+  // profile. "Best" in this case means the color which fits in the provided
+  // bounds and comes closest to |goal|. It's possible that no color will fit in
+  // the provided bounds, in which case we'll return an empty color.
+  for (size_t i = 0; i < color_brackets.size(); ++i) {
+    double best_suitability = 0;
+    for (const auto& box_color : box_colors) {
+      HSL hsl;
+      SkColorToHSL(box_color.color, &hsl);
+      if (!IsWithinHSLRange(hsl, color_brackets[i].lower_bound,
+                            color_brackets[i].upper_bound)) {
+        continue;
+      }
+
+      double suitability =
+          (1 - std::abs(hsl.s - color_brackets[i].goal.s)) * 3 +
+          (1 - std::abs(hsl.l - color_brackets[i].goal.l)) * 6.5 +
+          (box_color.population / static_cast<float>(max_weight)) * 0.5;
+      if (suitability > best_suitability) {
+        best_suitability = suitability;
+        best_colors[i] = box_color;
+      }
+    }
+  }
+
+  return best_colors;
+}
+
+} // namespace
+
+KMeanImageSampler::KMeanImageSampler() {
+}
+
+KMeanImageSampler::~KMeanImageSampler() {
+}
+
+GridSampler::GridSampler() : calls_(0) {
+}
+
+GridSampler::~GridSampler() {
+}
+
+int GridSampler::GetSample(int width, int height) {
+  // Hand-drawn bitmaps often have special outlines or feathering at the edges.
+  // Start our sampling inset from the top and left edges. For example, a 10x10
+  // image with 4 clusters would be sampled like this:
+  // ..........
+  // .0.4.8....
+  // ..........
+  // .1.5.9....
+  // ..........
+  // .2.6......
+  // ..........
+  // .3.7......
+  // ..........
+  // But don't inset if the image is too narrow or too short.
+  const int kInsetX = (width > 2 ? 1 : 0);
+  const int kInsetY = (height > 2 ? 1 : 0);
+  int x = kInsetX + (calls_ / kNumberOfClusters) *
+                        ((width - 2 * kInsetX) / kNumberOfClusters);
+  int y = kInsetY + (calls_ % kNumberOfClusters) *
+                        ((height - 2 * kInsetY) / kNumberOfClusters);
+  int index = x + (y * width);
+  ++calls_;
+  return index % (width * height);
+}
+
+SkColor FindClosestColor(const uint8_t* image,
+                         int width,
+                         int height,
+                         SkColor color) {
+  uint8_t in_r = SkColorGetR(color);
+  uint8_t in_g = SkColorGetG(color);
+  uint8_t in_b = SkColorGetB(color);
+  // Search using distance-squared to avoid expensive sqrt() operations.
+  int best_distance_squared = std::numeric_limits<int32_t>::max();
+  SkColor best_color = color;
+  const uint8_t* byte = image;
+  for (int i = 0; i < width * height; ++i) {
+    uint8_t b = *(byte++);
+    uint8_t g = *(byte++);
+    uint8_t r = *(byte++);
+    uint8_t a = *(byte++);
+    // Ignore fully transparent pixels.
+    if (a == 0)
+      continue;
+    int distance_squared =
+        (in_b - b) * (in_b - b) +
+        (in_g - g) * (in_g - g) +
+        (in_r - r) * (in_r - r);
+    if (distance_squared < best_distance_squared) {
+      best_distance_squared = distance_squared;
+      best_color = SkColorSetRGB(r, g, b);
+    }
+  }
+  return best_color;
+}
+
+// For a 16x16 icon on an Intel Core i5 this function takes approximately
+// 0.5 ms to run.
+// TODO(port): This code assumes the CPU architecture is little-endian.
+SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_data,
+                                    int img_width,
+                                    int img_height,
+                                    const HSL& lower_bound,
+                                    const HSL& upper_bound,
+                                    KMeanImageSampler* sampler,
+                                    bool find_closest) {
+  SkColor color = kDefaultBgColor;
+  if (img_width > 0 && img_height > 0) {
+    std::vector<KMeanCluster> clusters;
+    clusters.resize(static_cast<size_t>(kNumberOfClusters), KMeanCluster());
+
+    // Pick a starting point for each cluster
+    auto new_cluster = clusters.begin();
+    while (new_cluster != clusters.end()) {
+      // Try up to 10 times to find a unique color. If no unique color can be
+      // found, destroy this cluster.
+      bool color_unique = false;
+      for (int i = 0; i < 10; ++i) {
+        int pixel_pos = sampler->GetSample(img_width, img_height) %
+            (img_width * img_height);
+
+        uint8_t b = decoded_data[pixel_pos * 4];
+        uint8_t g = decoded_data[pixel_pos * 4 + 1];
+        uint8_t r = decoded_data[pixel_pos * 4 + 2];
+        uint8_t a = decoded_data[pixel_pos * 4 + 3];
+        // Skip fully transparent pixels as they usually contain black in their
+        // RGB channels but do not contribute to the visual image.
+        if (a == 0)
+          continue;
+
+        // Loop through the previous clusters and check to see if we have seen
+        // this color before.
+        color_unique = true;
+        for (auto cluster = clusters.begin(); cluster != new_cluster;
+             ++cluster) {
+          if (cluster->IsAtCentroid(r, g, b)) {
+            color_unique = false;
+            break;
+          }
+        }
+
+        // If we have a unique color set the center of the cluster to
+        // that color.
+        if (color_unique) {
+          new_cluster->SetCentroid(r, g, b);
+          break;
+        }
+      }
+
+      // If we don't have a unique color erase this cluster.
+      if (!color_unique) {
+        new_cluster = clusters.erase(new_cluster);
+      } else {
+        // Have to increment the iterator here, otherwise the increment in the
+        // for loop will skip a cluster due to the erase if the color wasn't
+        // unique.
+        ++new_cluster;
+      }
+    }
+
+    // If all pixels in the image are transparent we will have no clusters.
+    if (clusters.empty())
+      return color;
+
+    bool convergence = false;
+    for (int iteration = 0;
+        iteration < kNumberOfIterations && !convergence;
+        ++iteration) {
+
+      // Loop through each pixel so we can place it in the appropriate cluster.
+      uint8_t* pixel = decoded_data;
+      uint8_t* decoded_data_end = decoded_data + (img_width * img_height * 4);
+      while (pixel < decoded_data_end) {
+        uint8_t b = *(pixel++);
+        uint8_t g = *(pixel++);
+        uint8_t r = *(pixel++);
+        uint8_t a = *(pixel++);
+        // Skip transparent pixels, see above.
+        if (a == 0)
+          continue;
+
+        uint32_t distance_sqr_to_closest_cluster = UINT_MAX;
+        auto closest_cluster = clusters.begin();
+
+        // Figure out which cluster this color is closest to in RGB space.
+        for (auto cluster = clusters.begin(); cluster != clusters.end();
+             ++cluster) {
+          uint32_t distance_sqr = cluster->GetDistanceSqr(r, g, b);
+
+          if (distance_sqr < distance_sqr_to_closest_cluster) {
+            distance_sqr_to_closest_cluster = distance_sqr;
+            closest_cluster = cluster;
+          }
+        }
+
+        closest_cluster->AddPoint(r, g, b);
+      }
+
+      // Calculate the new cluster centers and see if we've converged or not.
+      convergence = true;
+      for (auto cluster = clusters.begin(); cluster != clusters.end();
+           ++cluster) {
+        convergence &= cluster->CompareCentroidWithAggregate();
+
+        cluster->RecomputeCentroid();
+      }
+    }
+
+    // Sort the clusters by population so we can tell what the most popular
+    // color is.
+    std::sort(clusters.begin(), clusters.end(),
+              KMeanCluster::SortKMeanClusterByWeight);
+
+    // Loop through the clusters to figure out which cluster has an appropriate
+    // color. Skip any that are too bright/dark and go in order of weight.
+    for (auto cluster = clusters.begin(); cluster != clusters.end();
+         ++cluster) {
+      uint8_t r, g, b;
+      cluster->GetCentroid(&r, &g, &b);
+
+      SkColor current_color = SkColorSetARGB(SK_AlphaOPAQUE, r, g, b);
+      HSL hsl;
+      SkColorToHSL(current_color, &hsl);
+      if (IsWithinHSLRange(hsl, lower_bound, upper_bound)) {
+        // If we found a valid color just set it and break. We don't want to
+        // check the other ones.
+        color = current_color;
+        break;
+      } else if (cluster == clusters.begin()) {
+        // We haven't found a valid color, but we are at the first color so
+        // set the color anyway to make sure we at least have a value here.
+        color = current_color;
+      }
+    }
+  }
+
+  // The K-mean cluster center will not usually be a color that appears in the
+  // image.  If desired, find a color that actually appears.
+  return find_closest
+             ? FindClosestColor(decoded_data, img_width, img_height, color)
+             : color;
+}
+
+SkColor CalculateKMeanColorOfPNG(scoped_refptr<base::RefCountedMemory> png,
+                                 const HSL& lower_bound,
+                                 const HSL& upper_bound,
+                                 KMeanImageSampler* sampler) {
+  int img_width = 0;
+  int img_height = 0;
+  std::vector<uint8_t> decoded_data;
+  SkColor color = kDefaultBgColor;
+
+  if (png.get() && png->size() &&
+      gfx::PNGCodec::Decode(png->front(), png->size(),
+                            gfx::PNGCodec::FORMAT_BGRA, &decoded_data,
+                            &img_width, &img_height)) {
+    return CalculateKMeanColorOfBuffer(&decoded_data[0], img_width, img_height,
+                                       lower_bound, upper_bound, sampler, true);
+  }
+  return color;
+}
+
+SkColor CalculateKMeanColorOfPNG(scoped_refptr<base::RefCountedMemory> png) {
+  GridSampler sampler;
+  return CalculateKMeanColorOfPNG(
+      png, kDefaultLowerHSLBound, kDefaultUpperHSLBound, &sampler);
+}
+
+SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap,
+                                    int height,
+                                    const HSL& lower_bound,
+                                    const HSL& upper_bound,
+                                    bool find_closest) {
+  // Clamp the height being used to the height of the provided image (otherwise,
+  // we can end up creating a larger buffer than we have data for, and the end
+  // of the buffer will remain uninitialized after we copy/UnPreMultiply the
+  // image data into it).
+  height = base::clamp(height, 0, bitmap.height());
+
+  // SkBitmap uses pre-multiplied alpha but the KMean clustering function
+  // above uses non-pre-multiplied alpha. Transform the bitmap before we
+  // analyze it because the function reads each pixel multiple times.
+  int pixel_count = bitmap.width() * height;
+  std::unique_ptr<uint32_t[]> image(new uint32_t[pixel_count]);
+
+  // Un-premultiplies each pixel in bitmap into the buffer. Requires
+  // approximately 10 microseconds for a 16x16 icon on an Intel Core i5.
+  uint32_t* in = static_cast<uint32_t*>(bitmap.getPixels());
+  uint32_t* out = image.get();
+  for (int i = 0; i < pixel_count; ++i)
+    *out++ = SkUnPreMultiply::PMColorToColor(*in++);
+
+  GridSampler sampler;
+  return CalculateKMeanColorOfBuffer(reinterpret_cast<uint8_t*>(image.get()),
+                                     bitmap.width(), height, lower_bound,
+                                     upper_bound, &sampler, find_closest);
+}
+
+SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap) {
+  return CalculateKMeanColorOfBitmap(
+      bitmap, bitmap.height(), kDefaultLowerHSLBound, kDefaultUpperHSLBound,
+      true);
+}
+
+const int kMaxConsideredPixelsForSwatches = 10007;
+
+// This algorithm is a port of Android's Palette API. Compare to package
+// android.support.v7.graphics and see that code for additional high-level
+// explanation of this algorithm. There are some minor differences:
+//   * This code doesn't exclude the same color from being used for
+//   different color profiles.
+//   * This code doesn't try to heuristically derive missing colors from
+//   existing colors.
+std::vector<Swatch> CalculateColorSwatches(
+    const SkBitmap& bitmap,
+    size_t max_swatches,
+    const gfx::Rect& region,
+    absl::optional<ColorSwatchFilter> filter) {
+  DCHECK(!bitmap.empty());
+  DCHECK(!bitmap.isNull());
+  DCHECK(!region.IsEmpty());
+  DCHECK_LE(region.width(), bitmap.width());
+  DCHECK_LE(region.height(), bitmap.height());
+
+  const int pixel_count = region.width() * region.height();
+
+  // For better performance, only consider at most 10k pixels (evenly
+  // distributed throughout the image). This has a very minor impact on the
+  // outcome but improves runtime substantially for large images. 10,007 is a
+  // prime number to reduce the chance of picking an unrepresentative sample.
+  const int pixel_increment =
+      std::max(1, pixel_count / kMaxConsideredPixelsForSwatches);
+  std::unordered_map<SkColor, int> color_counts(
+      kMaxConsideredPixelsForSwatches);
+
+  // First extract all colors into counts.
+  for (int i = 0; i < pixel_count; i += pixel_increment) {
+    const int x = region.x() + (i % region.width());
+    const int y = region.y() + (i / region.width());
+
+    const SkColor pixel = bitmap.getColor(x, y);
+    if (SkColorGetA(pixel) == SK_AlphaTRANSPARENT)
+      continue;
+
+    color_counts[pixel]++;
+  }
+
+  // Now throw out some uninteresting colors if there is a filter.
+  std::vector<SkColor> interesting_colors;
+  interesting_colors.reserve(color_counts.size());
+  for (auto color_count : color_counts) {
+    SkColor color = color_count.first;
+    if (!filter || filter->Run(color))
+      interesting_colors.push_back(color);
+  }
+
+  if (interesting_colors.empty())
+    return {};
+
+  // Group the colors into "boxes" and repeatedly split the most voluminous box.
+  // We stop the process when a box can no longer be split (there's only one
+  // color in it) or when the number of color boxes reaches |max_colors|.
+  //
+  // Boxes are sorted by volume with the most voluminous at the front of the PQ.
+  std::priority_queue<ColorBox, std::vector<ColorBox>,
+                      bool (*)(const ColorBox&, const ColorBox&)>
+      boxes(&ColorBox::CompareByVolume);
+  boxes.emplace(&interesting_colors);
+  while (boxes.size() < max_swatches) {
+    auto box = boxes.top();
+    if (!box.CanSplit())
+      break;
+    boxes.pop();
+    boxes.push(box.Split());
+    boxes.push(box);
+  }
+
+  // Now extract a single color to represent each box. This is the average color
+  // in the box, weighted by the frequency of that color in the source image.
+  size_t max_weight = 0;
+  std::vector<Swatch> box_colors;
+  box_colors.reserve(max_swatches);
+  while (!boxes.empty()) {
+    box_colors.push_back(boxes.top().GetWeightedAverageColor(color_counts));
+    boxes.pop();
+    max_weight = std::max(max_weight, box_colors.back().population);
+  }
+
+  return box_colors;
+}
+
+std::vector<color_utils::Swatch> CalculateProminentColorsOfBitmap(
+    const SkBitmap& bitmap,
+    const std::vector<ColorProfile>& color_profiles,
+    gfx::Rect* region,
+    ColorSwatchFilter filter) {
+  if (color_profiles.empty())
+    return std::vector<Swatch>();
+
+  size_t size = color_profiles.size();
+  if (bitmap.empty() || bitmap.isNull())
+    return std::vector<Swatch>(size, Swatch());
+
+  // The hue is not relevant to our bounds or goal colors.
+  std::vector<ColorBracket> color_brackets(size);
+  for (size_t i = 0; i < size; ++i) {
+    switch (color_profiles[i].luma) {
+      case LumaRange::ANY:
+        color_brackets[i].lower_bound.l = 0;
+        color_brackets[i].upper_bound.l = 1;
+        color_brackets[i].goal.l = 0.5f;
+        break;
+      case LumaRange::LIGHT:
+        color_brackets[i].lower_bound.l = 0.55f;
+        color_brackets[i].upper_bound.l = 1;
+        color_brackets[i].goal.l = 0.74f;
+        break;
+      case LumaRange::NORMAL:
+        color_brackets[i].lower_bound.l = 0.3f;
+        color_brackets[i].upper_bound.l = 0.7f;
+        color_brackets[i].goal.l = 0.5f;
+        break;
+      case LumaRange::DARK:
+        color_brackets[i].lower_bound.l = 0;
+        color_brackets[i].upper_bound.l = 0.45f;
+        color_brackets[i].goal.l = 0.26f;
+        break;
+    }
+
+    switch (color_profiles[i].saturation) {
+      case SaturationRange::ANY:
+        color_brackets[i].lower_bound.s = 0;
+        color_brackets[i].upper_bound.s = 1;
+        color_brackets[i].goal.s = 0.5f;
+        break;
+      case SaturationRange::VIBRANT:
+        color_brackets[i].lower_bound.s = 0.35f;
+        color_brackets[i].upper_bound.s = 1;
+        color_brackets[i].goal.s = 1;
+        break;
+      case SaturationRange::MUTED:
+        color_brackets[i].lower_bound.s = 0;
+        color_brackets[i].upper_bound.s = 0.4f;
+        color_brackets[i].goal.s = 0.3f;
+        break;
+    }
+  }
+
+  return CalculateProminentColors(
+      bitmap, color_brackets,
+      region ? *region : gfx::Rect(bitmap.width(), bitmap.height()),
+      filter.is_null() ? base::BindRepeating(&IsInterestingColor) : filter);
+}
+
+gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap) {
+  // First need basic stats to normalize each channel separately.
+  gfx::Matrix3F covariance = gfx::Matrix3F::Zeros();
+  if (!bitmap.getPixels())
+    return covariance;
+
+  // Assume ARGB_8888 format.
+  DCHECK(bitmap.colorType() == kN32_SkColorType);
+
+  int64_t r_sum = 0;
+  int64_t g_sum = 0;
+  int64_t b_sum = 0;
+  int64_t rr_sum = 0;
+  int64_t gg_sum = 0;
+  int64_t bb_sum = 0;
+  int64_t rg_sum = 0;
+  int64_t rb_sum = 0;
+  int64_t gb_sum = 0;
+
+  for (int y = 0; y < bitmap.height(); ++y) {
+    SkPMColor* current_color = static_cast<uint32_t*>(bitmap.getAddr32(0, y));
+    for (int x = 0; x < bitmap.width(); ++x, ++current_color) {
+      SkColor c = SkUnPreMultiply::PMColorToColor(*current_color);
+      SkColor r = SkColorGetR(c);
+      SkColor g = SkColorGetG(c);
+      SkColor b = SkColorGetB(c);
+
+      r_sum += r;
+      g_sum += g;
+      b_sum += b;
+      rr_sum += r * r;
+      gg_sum += g * g;
+      bb_sum += b * b;
+      rg_sum += r * g;
+      rb_sum += r * b;
+      gb_sum += g * b;
+    }
+  }
+
+  // Covariance (not normalized) is E(X*X.t) - m * m.t and this is how it
+  // is calculated below.
+  // Each row below represents a row of the matrix describing (co)variances
+  // of R, G and B channels with (R, G, B)
+  int pixel_n = bitmap.width() * bitmap.height();
+  covariance.set(
+      static_cast<float>(
+          static_cast<double>(rr_sum) / pixel_n -
+              static_cast<double>(r_sum * r_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(rg_sum) / pixel_n -
+              static_cast<double>(r_sum * g_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(rb_sum) / pixel_n -
+              static_cast<double>(r_sum * b_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(rg_sum) / pixel_n -
+              static_cast<double>(r_sum * g_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(gg_sum) / pixel_n -
+              static_cast<double>(g_sum * g_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(gb_sum) / pixel_n -
+              static_cast<double>(g_sum * b_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(rb_sum) / pixel_n -
+              static_cast<double>(r_sum * b_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(gb_sum) / pixel_n -
+              static_cast<double>(g_sum * b_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(bb_sum) / pixel_n -
+              static_cast<double>(b_sum * b_sum) / pixel_n / pixel_n));
+  return covariance;
+}
+
+bool ApplyColorReduction(const SkBitmap& source_bitmap,
+                         const gfx::Vector3dF& color_transform,
+                         bool fit_to_range,
+                         SkBitmap* target_bitmap) {
+  DCHECK(target_bitmap);
+  DCHECK(source_bitmap.getPixels());
+  DCHECK(target_bitmap->getPixels());
+  DCHECK_EQ(kN32_SkColorType, source_bitmap.colorType());
+  DCHECK_EQ(kAlpha_8_SkColorType, target_bitmap->colorType());
+  DCHECK_EQ(source_bitmap.height(), target_bitmap->height());
+  DCHECK_EQ(source_bitmap.width(), target_bitmap->width());
+  DCHECK(!source_bitmap.empty());
+
+  // Elements of color_transform are explicitly off-loaded to local values for
+  // efficiency reasons. Note that in practice images may correspond to entire
+  // tab captures.
+  float t0 = 0.0;
+  float tr = color_transform.x();
+  float tg = color_transform.y();
+  float tb = color_transform.z();
+
+  if (fit_to_range) {
+    // We will figure out min/max in a preprocessing step and adjust
+    // actual_transform as required.
+    float max_val = std::numeric_limits<float>::min();
+    float min_val = std::numeric_limits<float>::max();
+    for (int y = 0; y < source_bitmap.height(); ++y) {
+      const SkPMColor* source_color_row = static_cast<SkPMColor*>(
+          source_bitmap.getAddr32(0, y));
+      for (int x = 0; x < source_bitmap.width(); ++x) {
+        SkColor c = SkUnPreMultiply::PMColorToColor(source_color_row[x]);
+        uint8_t r = SkColorGetR(c);
+        uint8_t g = SkColorGetG(c);
+        uint8_t b = SkColorGetB(c);
+        float gray_level = tr * r + tg * g + tb * b;
+        max_val = std::max(max_val, gray_level);
+        min_val = std::min(min_val, gray_level);
+      }
+    }
+
+    // Adjust the transform so that the result is scaling.
+    float scale = 0.0;
+    t0 = -min_val;
+    if (max_val > min_val)
+      scale = 255.0f / (max_val - min_val);
+    t0 *= scale;
+    tr *= scale;
+    tg *= scale;
+    tb *= scale;
+  }
+
+  for (int y = 0; y < source_bitmap.height(); ++y) {
+    const SkPMColor* source_color_row = static_cast<SkPMColor*>(
+        source_bitmap.getAddr32(0, y));
+    uint8_t* target_color_row = target_bitmap->getAddr8(0, y);
+    for (int x = 0; x < source_bitmap.width(); ++x) {
+      SkColor c = SkUnPreMultiply::PMColorToColor(source_color_row[x]);
+      uint8_t r = SkColorGetR(c);
+      uint8_t g = SkColorGetG(c);
+      uint8_t b = SkColorGetB(c);
+
+      float gl = t0 + tr * r + tg * g + tb * b;
+      if (gl < 0)
+        gl = 0;
+      if (gl > 0xFF)
+        gl = 0xFF;
+      target_color_row[x] = static_cast<uint8_t>(gl);
+    }
+  }
+
+  return true;
+}
+
+}  // color_utils
diff --git a/ui/gfx/color_analysis.h b/ui/gfx/color_analysis.h
new file mode 100644
index 0000000..fdaa8f3
--- /dev/null
+++ b/ui/gfx/color_analysis.h
@@ -0,0 +1,212 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_COLOR_ANALYSIS_H_
+#define UI_GFX_COLOR_ANALYSIS_H_
+
+#include <stdint.h>
+
+#include "base/callback_forward.h"
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/ref_counted_memory.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/geometry/matrix3_f.h"
+#include "ui/gfx/gfx_export.h"
+
+class SkBitmap;
+
+namespace gfx {
+class Rect;
+}  // namespace gfx
+
+namespace color_utils {
+
+struct HSL;
+
+// This class exposes the sampling method to the caller, which allows
+// stubbing out for things like unit tests. Might be useful to pass more
+// arguments into the GetSample method in the future (such as which
+// cluster is being worked on, etc.).
+//
+// Note: Samplers should be deterministic, as the same image may be analyzed
+// twice with two sampler instances and the results displayed side-by-side
+// to the user.
+class GFX_EXPORT KMeanImageSampler {
+ public:
+  virtual int GetSample(int width, int height) = 0;
+
+ protected:
+  KMeanImageSampler();
+  virtual ~KMeanImageSampler();
+};
+
+// This sampler will pick pixels from an evenly spaced grid.
+class GFX_EXPORT GridSampler : public KMeanImageSampler {
+  public:
+   GridSampler();
+   ~GridSampler() override;
+
+   int GetSample(int width, int height) override;
+
+  private:
+   // The number of times GetSample has been called.
+   int calls_;
+};
+
+// Returns the color in an ARGB |image| that is closest in RGB-space to the
+// provided |color|. Exported for testing.
+GFX_EXPORT SkColor FindClosestColor(const uint8_t* image, int width, int height,
+                                    SkColor color);
+
+// Returns an SkColor that represents the calculated dominant color in the
+// image. This uses a KMean clustering algorithm to find clusters of pixel
+// colors in RGB space.
+// |png|/|bitmap| represents the data of a png/bitmap encoded image.
+// |lower_bound| represents the minimum bound of HSL values to allow.
+// |upper_bound| represents the maximum bound of HSL values to allow.
+// See color_utils::IsWithinHSLRange() for description of these bounds.
+//
+// RGB KMean Algorithm (N clusters, M iterations):
+// 1.Pick N starting colors by randomly sampling the pixels. If you see a
+//   color you already saw keep sampling. After a certain number of tries
+//   just remove the cluster and continue with N = N-1 clusters (for an image
+//   with just one color this should devolve to N=1). These colors are the
+//   centers of your N clusters.
+// 2.For each pixel in the image find the cluster that it is closest to in RGB
+//   space. Add that pixel's color to that cluster (we keep a sum and a count
+//   of all of the pixels added to the space, so just add it to the sum and
+//   increment count).
+// 3.Calculate the new cluster centroids by getting the average color of all of
+//   the pixels in each cluster (dividing the sum by the count).
+// 4.See if the new centroids are the same as the old centroids.
+//     a) If this is the case for all N clusters than we have converged and
+//        can move on.
+//     b) If any centroid moved, repeat step 2 with the new centroids for up
+//        to M iterations.
+// 5.Once the clusters have converged or M iterations have been tried, sort
+//   the clusters by weight (where weight is the number of pixels that make up
+//   this cluster).
+// 6.Going through the sorted list of clusters, pick the first cluster with the
+//   largest weight that's centroid falls between |lower_bound| and
+//   |upper_bound|. Return that color.
+//   If no color fulfills that requirement return the color with the largest
+//   weight regardless of whether or not it fulfills the equation above.
+GFX_EXPORT SkColor
+    CalculateKMeanColorOfPNG(scoped_refptr<base::RefCountedMemory> png,
+                             const HSL& lower_bound,
+                             const HSL& upper_bound,
+                             KMeanImageSampler* sampler);
+// Computes a dominant color using the above algorithm and reasonable defaults
+// for |lower_bound|, |upper_bound| and |sampler|.
+GFX_EXPORT SkColor CalculateKMeanColorOfPNG(
+    scoped_refptr<base::RefCountedMemory> png);
+
+// Computes a dominant color for the first |height| rows of |bitmap| using the
+// above algorithm and a reasonable default sampler. If |find_closest| is true,
+// the returned color will be the closest color to the true K-mean color that
+// actually appears in the image; if false, the true color is returned
+// regardless of whether it actually appears.
+GFX_EXPORT SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap,
+                                               int height,
+                                               const HSL& lower_bound,
+                                               const HSL& upper_bound,
+                                               bool find_closest);
+
+// Computes a dominant color using the above algorithm and reasonable defaults
+// for |lower_bound|, |upper_bound| and |sampler|.
+GFX_EXPORT SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap);
+
+// These enums specify general values to look for when calculating prominent
+// colors from an image. For example, a "light vibrant" prominent color would
+// tend to be brighter and more saturated. The best combination of color
+// attributes depends on how you plan to apply the color.
+enum class LumaRange {
+  ANY,
+  LIGHT,
+  NORMAL,
+  DARK,
+};
+
+enum class SaturationRange {
+  ANY,
+  VIBRANT,
+  MUTED,
+};
+
+struct ColorProfile {
+  ColorProfile() = default;
+  ColorProfile(LumaRange l, SaturationRange s) : luma(l), saturation(s) {}
+
+  LumaRange luma = LumaRange::DARK;
+  SaturationRange saturation = SaturationRange::MUTED;
+};
+
+// A color value with an associated weight.
+struct Swatch {
+  Swatch() : Swatch(SK_ColorTRANSPARENT, 0) {}
+
+  Swatch(SkColor color, size_t population)
+      : color(color), population(population) {}
+
+  SkColor color;
+
+  // The population correlates to a count, so it should be 1 or greater.
+  size_t population;
+
+  bool operator==(const Swatch& other) const {
+    return color == other.color && population == other.population;
+  }
+};
+
+// Used to filter colors from swatches. Called with the candidate color and will
+// return true if the color should be allowed.
+using ColorSwatchFilter = base::RepeatingCallback<bool(const SkColor&)>;
+
+// The maximum number of pixels to consider when generating swatches.
+GFX_EXPORT extern const int kMaxConsideredPixelsForSwatches;
+
+// Returns a vector of |Swatch| that represent the prominent colors of the
+// bitmap within |region|. The |max_swatches| is the maximum number of swatches.
+// For landscapes, good values are in the range 12-16. For images which are
+// largely made up of people's faces then this value should be increased to
+// 24-32. |filter| is an optional filter that can filter out unwanted colors.
+// This is an implementation of the Android Palette API:
+// https://developer.android.com/reference/android/support/v7/graphics/Palette
+GFX_EXPORT std::vector<Swatch> CalculateColorSwatches(
+    const SkBitmap& bitmap,
+    size_t max_swatches,
+    const gfx::Rect& region,
+    absl::optional<ColorSwatchFilter> filter);
+
+// Returns a vector of RGB colors that represents the bitmap based on the
+// |color_profiles| provided. For each value, if a value is succesfully
+// calculated, the calculated value is fully opaque. For failure, the calculated
+// value is transparent. |region| can be provided to select a specific area of
+// the bitmap. |filter| is an optional filter that can filter out unwanted
+// colors. If |filter| is not provided then we will filter out uninteresting
+// colors.
+GFX_EXPORT std::vector<Swatch> CalculateProminentColorsOfBitmap(
+    const SkBitmap& bitmap,
+    const std::vector<ColorProfile>& color_profiles,
+    gfx::Rect* region,
+    ColorSwatchFilter filter);
+
+// Compute color covariance matrix for the input bitmap.
+GFX_EXPORT gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap);
+
+// Apply a color reduction transform defined by |color_transform| vector to
+// |source_bitmap|. The result is put into |target_bitmap|, which is expected
+// to be initialized to the required size and type (SkBitmap::kA8_Config).
+// If |fit_to_range|, result is transfored linearly to fit 0-0xFF range.
+// Otherwise, data is clipped.
+// Returns true if the target has been computed.
+GFX_EXPORT bool ApplyColorReduction(const SkBitmap& source_bitmap,
+                                   const gfx::Vector3dF& color_transform,
+                                   bool fit_to_range,
+                                   SkBitmap* target_bitmap);
+
+}  // namespace color_utils
+
+#endif  // UI_GFX_COLOR_ANALYSIS_H_
diff --git a/ui/gfx/color_analysis_fuzzer.cc b/ui/gfx/color_analysis_fuzzer.cc
new file mode 100644
index 0000000..ef2f6d8
--- /dev/null
+++ b/ui/gfx/color_analysis_fuzzer.cc
@@ -0,0 +1,52 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <fuzzer/FuzzedDataProvider.h>
+#include <vector>
+
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/color_analysis.h"
+#include "ui/gfx/color_utils.h"
+
+double ConsumeDouble(FuzzedDataProvider* provider) {
+  std::vector<uint8_t> v = provider->ConsumeBytes<uint8_t>(sizeof(double));
+  if (v.size() == sizeof(double))
+    return reinterpret_cast<double*>(v.data())[0];
+
+  return 0;
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  FuzzedDataProvider provider(data, size);
+
+  // Limit width and height for performance.
+  int width = provider.ConsumeIntegralInRange<int>(1, 100);
+  int height = provider.ConsumeIntegralInRange<int>(1, 100);
+  SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
+  size_t expected_size = info.computeMinByteSize();
+
+  color_utils::HSL upper_bound = {ConsumeDouble(&provider),
+                                  ConsumeDouble(&provider),
+                                  ConsumeDouble(&provider)};
+  color_utils::HSL lower_bound = {ConsumeDouble(&provider),
+                                  ConsumeDouble(&provider),
+                                  ConsumeDouble(&provider)};
+
+  bool find_closest = provider.ConsumeBool();
+
+  // Ensure that we have enough data for this image.
+  std::vector<uint8_t> image_data =
+      provider.ConsumeBytes<uint8_t>(expected_size);
+  if (image_data.size() < expected_size)
+    return 0;
+
+  SkBitmap bitmap;
+  bitmap.installPixels(info, image_data.data(), info.minRowBytes());
+
+  color_utils::CalculateKMeanColorOfBitmap(
+      bitmap, provider.ConsumeIntegralInRange<int>(-1, height + 2), lower_bound,
+      upper_bound, find_closest);
+
+  return 0;
+}
diff --git a/ui/gfx/color_analysis_unittest.cc b/ui/gfx/color_analysis_unittest.cc
new file mode 100644
index 0000000..bbf1e87
--- /dev/null
+++ b/ui/gfx/color_analysis_unittest.cc
@@ -0,0 +1,620 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/color_analysis.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <exception>
+#include <vector>
+
+#include "base/bind.h"
+#include "skia/ext/platform_canvas.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/image/image.h"
+
+namespace color_utils {
+
+const unsigned char k1x1White[] = {
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+  0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+  0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
+  0xde, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47,
+  0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00,
+  0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00,
+  0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13, 0x01, 0x00,
+  0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74,
+  0x49, 0x4d, 0x45, 0x07, 0xdb, 0x02, 0x11, 0x15,
+  0x16, 0x1b, 0xaa, 0x58, 0x38, 0x76, 0x00, 0x00,
+  0x00, 0x19, 0x74, 0x45, 0x58, 0x74, 0x43, 0x6f,
+  0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x43, 0x72,
+  0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69,
+  0x74, 0x68, 0x20, 0x47, 0x49, 0x4d, 0x50, 0x57,
+  0x81, 0x0e, 0x17, 0x00, 0x00, 0x00, 0x0c, 0x49,
+  0x44, 0x41, 0x54, 0x08, 0xd7, 0x63, 0xf8, 0xff,
+  0xff, 0x3f, 0x00, 0x05, 0xfe, 0x02, 0xfe, 0xdc,
+  0xcc, 0x59, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x49,
+  0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
+};
+
+const unsigned char k1x3BlueWhite[] = {
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+  0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+  0x08, 0x02, 0x00, 0x00, 0x00, 0xdd, 0xbf, 0xf2,
+  0xd5, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47,
+  0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00,
+  0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00,
+  0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13, 0x01, 0x00,
+  0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74,
+  0x49, 0x4d, 0x45, 0x07, 0xdb, 0x02, 0x12, 0x01,
+  0x0a, 0x2c, 0xfd, 0x08, 0x64, 0x66, 0x00, 0x00,
+  0x00, 0x19, 0x74, 0x45, 0x58, 0x74, 0x43, 0x6f,
+  0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x43, 0x72,
+  0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69,
+  0x74, 0x68, 0x20, 0x47, 0x49, 0x4d, 0x50, 0x57,
+  0x81, 0x0e, 0x17, 0x00, 0x00, 0x00, 0x14, 0x49,
+  0x44, 0x41, 0x54, 0x08, 0xd7, 0x63, 0xf8, 0xff,
+  0xff, 0x3f, 0x13, 0x03, 0x03, 0x03, 0x03, 0x03,
+  0xc3, 0x7f, 0x00, 0x1e, 0xfd, 0x03, 0xff, 0xde,
+  0x72, 0x58, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x49,
+  0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
+};
+
+const unsigned char k1x3BlueRed[] = {
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+  0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+  0x08, 0x02, 0x00, 0x00, 0x00, 0xdd, 0xbf, 0xf2,
+  0xd5, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47,
+  0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00,
+  0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00,
+  0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13, 0x01, 0x00,
+  0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74,
+  0x49, 0x4d, 0x45, 0x07, 0xdb, 0x02, 0x12, 0x01,
+  0x07, 0x09, 0x03, 0xa2, 0xce, 0x6c, 0x00, 0x00,
+  0x00, 0x19, 0x74, 0x45, 0x58, 0x74, 0x43, 0x6f,
+  0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x43, 0x72,
+  0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69,
+  0x74, 0x68, 0x20, 0x47, 0x49, 0x4d, 0x50, 0x57,
+  0x81, 0x0e, 0x17, 0x00, 0x00, 0x00, 0x14, 0x49,
+  0x44, 0x41, 0x54, 0x08, 0xd7, 0x63, 0xf8, 0xcf,
+  0xc0, 0xc0, 0xc4, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
+  0xf0, 0x1f, 0x00, 0x0c, 0x10, 0x02, 0x01, 0x2c,
+  0x8f, 0x8b, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x49,
+  0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
+};
+
+const HSL kDefaultLowerBound = {-1, -1, 0.15};
+const HSL kDefaultUpperBound = {-1, -1, 0.85};
+
+// Creates a 1-dimensional png of the pixel colors found in |colors|.
+scoped_refptr<base::RefCountedMemory> CreateTestPNG(
+    const std::vector<SkColor>& colors) {
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(colors.size(), 1);
+
+  for (size_t i = 0; i < colors.size(); ++i) {
+    bitmap.eraseArea(SkIRect::MakeXYWH(i, 0, 1, 1), colors[i]);
+  }
+  return gfx::Image::CreateFrom1xBitmap(bitmap).As1xPNGBytes();
+}
+
+class MockKMeanImageSampler : public KMeanImageSampler {
+ public:
+  MockKMeanImageSampler() : current_result_index_(0) {
+  }
+
+  explicit MockKMeanImageSampler(const std::vector<int>& samples)
+      : prebaked_sample_results_(samples),
+        current_result_index_(0) {
+  }
+
+  ~MockKMeanImageSampler() override {}
+
+  void AddSample(int sample) {
+    prebaked_sample_results_.push_back(sample);
+  }
+
+  int GetSample(int width, int height) override {
+    if (current_result_index_ >= prebaked_sample_results_.size()) {
+      current_result_index_ = 0;
+    }
+
+    if (prebaked_sample_results_.empty()) {
+      return 0;
+    }
+
+    return prebaked_sample_results_[current_result_index_++];
+  }
+
+ protected:
+  std::vector<int> prebaked_sample_results_;
+  size_t current_result_index_;
+};
+
+// Return true if a color channel is approximately equal to an expected value.
+bool ChannelApproximatelyEqual(int expected, uint8_t channel) {
+  return (abs(expected - static_cast<int>(channel)) <= 1);
+}
+
+// Compute minimal and maximal graylevel (or alphalevel) of the input |bitmap|.
+// |bitmap| has to be allocated and configured to kA8_Config.
+void Calculate8bitBitmapMinMax(const SkBitmap& bitmap,
+                               uint8_t* min_gl,
+                               uint8_t* max_gl) {
+  DCHECK(bitmap.getPixels());
+  DCHECK_EQ(bitmap.colorType(), kAlpha_8_SkColorType);
+  DCHECK(min_gl);
+  DCHECK(max_gl);
+  *min_gl = std::numeric_limits<uint8_t>::max();
+  *max_gl = std::numeric_limits<uint8_t>::min();
+  for (int y = 0; y < bitmap.height(); ++y) {
+    uint8_t* current_color = bitmap.getAddr8(0, y);
+    for (int x = 0; x < bitmap.width(); ++x, ++current_color) {
+      *min_gl = std::min(*min_gl, *current_color);
+      *max_gl = std::max(*max_gl, *current_color);
+    }
+  }
+}
+
+class ColorAnalysisTest : public testing::Test {
+};
+
+TEST_F(ColorAnalysisTest, CalculatePNGKMeanAllWhite) {
+  MockKMeanImageSampler test_sampler;
+  test_sampler.AddSample(0);
+
+  scoped_refptr<base::RefCountedBytes> png(
+      new base::RefCountedBytes(
+          std::vector<unsigned char>(
+              k1x1White,
+              k1x1White + sizeof(k1x1White) / sizeof(unsigned char))));
+
+  SkColor color = CalculateKMeanColorOfPNG(
+      png, kDefaultLowerBound, kDefaultUpperBound, &test_sampler);
+
+  EXPECT_EQ(color, SK_ColorWHITE);
+}
+
+TEST_F(ColorAnalysisTest, CalculatePNGKMeanIgnoreWhiteLightness) {
+  MockKMeanImageSampler test_sampler;
+  test_sampler.AddSample(0);
+  test_sampler.AddSample(1);
+  test_sampler.AddSample(2);
+
+  scoped_refptr<base::RefCountedBytes> png(
+     new base::RefCountedBytes(
+         std::vector<unsigned char>(
+             k1x3BlueWhite,
+             k1x3BlueWhite + sizeof(k1x3BlueWhite) / sizeof(unsigned char))));
+
+  SkColor color = CalculateKMeanColorOfPNG(
+      png, kDefaultLowerBound, kDefaultUpperBound, &test_sampler);
+
+  EXPECT_EQ(SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF), color);
+}
+
+TEST_F(ColorAnalysisTest, CalculatePNGKMeanPickMostCommon) {
+  MockKMeanImageSampler test_sampler;
+  test_sampler.AddSample(0);
+  test_sampler.AddSample(1);
+  test_sampler.AddSample(2);
+
+  scoped_refptr<base::RefCountedBytes> png(
+     new base::RefCountedBytes(
+         std::vector<unsigned char>(
+             k1x3BlueRed,
+             k1x3BlueRed + sizeof(k1x3BlueRed) / sizeof(unsigned char))));
+
+  SkColor color = CalculateKMeanColorOfPNG(
+      png, kDefaultLowerBound, kDefaultUpperBound, &test_sampler);
+
+  EXPECT_EQ(SkColorSetARGB(0xFF, 0xFF, 0x00, 0x00), color);
+}
+
+TEST_F(ColorAnalysisTest, CalculatePNGKMeanIgnoreRedHue) {
+  MockKMeanImageSampler test_sampler;
+  test_sampler.AddSample(0);
+  test_sampler.AddSample(1);
+  test_sampler.AddSample(2);
+
+  std::vector<SkColor> colors(4, SK_ColorRED);
+  colors[1] = SK_ColorBLUE;
+
+  scoped_refptr<base::RefCountedMemory> png = CreateTestPNG(colors);
+
+  HSL lower = {0.2, -1, 0.15};
+  HSL upper = {0.8, -1, 0.85};
+  SkColor color = CalculateKMeanColorOfPNG(
+      png, lower, upper, &test_sampler);
+
+  EXPECT_EQ(SK_ColorBLUE, color);
+}
+
+TEST_F(ColorAnalysisTest, CalculatePNGKMeanIgnoreGreySaturation) {
+  MockKMeanImageSampler test_sampler;
+  test_sampler.AddSample(0);
+  test_sampler.AddSample(1);
+  test_sampler.AddSample(2);
+
+  std::vector<SkColor> colors(4, SK_ColorGRAY);
+  colors[1] = SK_ColorBLUE;
+
+  scoped_refptr<base::RefCountedMemory> png = CreateTestPNG(colors);
+  HSL lower = {-1, 0.3, -1};
+  HSL upper = {-1, 1, -1};
+  SkColor color = CalculateKMeanColorOfPNG(
+      png, lower, upper, &test_sampler);
+
+  EXPECT_EQ(SK_ColorBLUE, color);
+}
+
+TEST_F(ColorAnalysisTest, GridSampler) {
+  GridSampler sampler;
+  const int kWidth = 16;
+  const int kHeight = 16;
+  // Sample starts at 1,1.
+  EXPECT_EQ(1 + 1 * kWidth, sampler.GetSample(kWidth, kHeight));
+  EXPECT_EQ(1 + 4 * kWidth, sampler.GetSample(kWidth, kHeight));
+  EXPECT_EQ(1 + 7 * kWidth, sampler.GetSample(kWidth, kHeight));
+  EXPECT_EQ(1 + 10 * kWidth, sampler.GetSample(kWidth, kHeight));
+  // Step over by 3.
+  EXPECT_EQ(4 + 1 * kWidth, sampler.GetSample(kWidth, kHeight));
+  EXPECT_EQ(4 + 4 * kWidth, sampler.GetSample(kWidth, kHeight));
+  EXPECT_EQ(4 + 7 * kWidth, sampler.GetSample(kWidth, kHeight));
+  EXPECT_EQ(4 + 10 * kWidth, sampler.GetSample(kWidth, kHeight));
+}
+
+TEST_F(ColorAnalysisTest, FindClosestColor) {
+  // Empty image returns input color.
+  SkColor color = FindClosestColor(NULL, 0, 0, SK_ColorRED);
+  EXPECT_EQ(SK_ColorRED, color);
+
+  // Single color image returns that color.
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(16, 16);
+  bitmap.eraseColor(SK_ColorWHITE);
+  color = FindClosestColor(static_cast<uint8_t*>(bitmap.getPixels()),
+                           bitmap.width(),
+                           bitmap.height(),
+                           SK_ColorRED);
+  EXPECT_EQ(SK_ColorWHITE, color);
+
+  // Write a black pixel into the image. A dark grey input pixel should match
+  // the black one in the image.
+  uint32_t* pixel = bitmap.getAddr32(0, 0);
+  *pixel = SK_ColorBLACK;
+  color = FindClosestColor(static_cast<uint8_t*>(bitmap.getPixels()),
+                           bitmap.width(),
+                           bitmap.height(),
+                           SK_ColorDKGRAY);
+  EXPECT_EQ(SK_ColorBLACK, color);
+}
+
+TEST_F(ColorAnalysisTest, CalculateKMeanColorOfBitmap) {
+  // Create a 16x16 bitmap to represent a favicon.
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(16, 16);
+  bitmap.eraseARGB(255, 100, 150, 200);
+
+  SkColor color = CalculateKMeanColorOfBitmap(bitmap);
+  EXPECT_EQ(255u, SkColorGetA(color));
+  // Color values are not exactly equal due to reversal of premultiplied alpha.
+  EXPECT_TRUE(ChannelApproximatelyEqual(100, SkColorGetR(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(150, SkColorGetG(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(200, SkColorGetB(color)));
+
+  // Test a bitmap with an alpha channel.
+  bitmap.eraseARGB(128, 100, 150, 200);
+  color = CalculateKMeanColorOfBitmap(bitmap);
+
+  // Alpha channel should be ignored for dominant color calculation.
+  EXPECT_EQ(255u, SkColorGetA(color));
+  EXPECT_TRUE(ChannelApproximatelyEqual(100, SkColorGetR(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(150, SkColorGetG(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(200, SkColorGetB(color)));
+}
+
+// Regression test for heap-buffer-underflow. https://crbug.com/970343
+TEST_F(ColorAnalysisTest, CalculateKMeanColorOfSmallImage) {
+  SkBitmap bitmap;
+
+  // Create a 1x41 bitmap, so it is not wide enough to have 1 pixel of padding
+  // on both sides.
+  bitmap.allocN32Pixels(1, 41);
+  bitmap.eraseARGB(255, 100, 150, 200);
+
+  SkColor color = CalculateKMeanColorOfBitmap(bitmap);
+  EXPECT_EQ(255u, SkColorGetA(color));
+  EXPECT_TRUE(ChannelApproximatelyEqual(100, SkColorGetR(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(150, SkColorGetG(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(200, SkColorGetB(color)));
+
+  // Test a wide but narrow bitmap.
+  bitmap.allocN32Pixels(41, 1);
+  bitmap.eraseARGB(255, 100, 150, 200);
+  color = CalculateKMeanColorOfBitmap(bitmap);
+  EXPECT_EQ(255u, SkColorGetA(color));
+  EXPECT_TRUE(ChannelApproximatelyEqual(100, SkColorGetR(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(150, SkColorGetG(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(200, SkColorGetB(color)));
+
+  // Test a tiny bitmap.
+  bitmap.allocN32Pixels(1, 1);
+  bitmap.eraseARGB(255, 100, 150, 200);
+  color = CalculateKMeanColorOfBitmap(bitmap);
+  EXPECT_EQ(255u, SkColorGetA(color));
+  EXPECT_TRUE(ChannelApproximatelyEqual(100, SkColorGetR(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(150, SkColorGetG(color)));
+  EXPECT_TRUE(ChannelApproximatelyEqual(200, SkColorGetB(color)));
+}
+
+TEST_F(ColorAnalysisTest, ComputeColorCovarianceTrivial) {
+  SkBitmap bitmap;
+  bitmap.setInfo(SkImageInfo::MakeN32Premul(100, 200));
+
+  EXPECT_EQ(gfx::Matrix3F::Zeros(), ComputeColorCovariance(bitmap));
+  bitmap.allocPixels();
+  bitmap.eraseARGB(255, 50, 150, 200);
+  gfx::Matrix3F covariance = ComputeColorCovariance(bitmap);
+  // The answer should be all zeros.
+  EXPECT_TRUE(covariance == gfx::Matrix3F::Zeros());
+}
+
+TEST_F(ColorAnalysisTest, ComputeColorCovarianceWithCanvas) {
+  gfx::Canvas canvas(gfx::Size(250, 200), 1.0f, true);
+  // The image consists of vertical stripes, with color bands set to 100
+  // in overlapping stripes 150 pixels wide.
+  canvas.FillRect(gfx::Rect(0, 0, 50, 200), SkColorSetRGB(100, 0, 0));
+  canvas.FillRect(gfx::Rect(50, 0, 50, 200), SkColorSetRGB(100, 100, 0));
+  canvas.FillRect(gfx::Rect(100, 0, 50, 200), SkColorSetRGB(100, 100, 100));
+  canvas.FillRect(gfx::Rect(150, 0, 50, 200), SkColorSetRGB(0, 100, 100));
+  canvas.FillRect(gfx::Rect(200, 0, 50, 200), SkColorSetRGB(0, 0, 100));
+
+  gfx::Matrix3F covariance = ComputeColorCovariance(canvas.GetBitmap());
+
+  gfx::Matrix3F expected_covariance = gfx::Matrix3F::Zeros();
+  expected_covariance.set(2400, 400, -1600,
+                          400, 2400, 400,
+                          -1600, 400, 2400);
+  EXPECT_EQ(expected_covariance, covariance);
+}
+
+TEST_F(ColorAnalysisTest, ApplyColorReductionSingleColor) {
+  // The test runs color reduction on a single-colot image, where results are
+  // bound to be uninteresting. This is an important edge case, though.
+  SkBitmap source, result;
+  source.allocN32Pixels(300, 200);
+  result.allocPixels(SkImageInfo::MakeA8(300, 200));
+
+  source.eraseARGB(255, 50, 150, 200);
+
+  gfx::Vector3dF transform(1.0f, .5f, 0.1f);
+  // This transform, if not scaled, should result in GL=145.
+  EXPECT_TRUE(ApplyColorReduction(source, transform, false, &result));
+
+  uint8_t min_gl = 0;
+  uint8_t max_gl = 0;
+  Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
+  EXPECT_EQ(145, min_gl);
+  EXPECT_EQ(145, max_gl);
+
+  // Now scan requesting rescale. Expect all 0.
+  EXPECT_TRUE(ApplyColorReduction(source, transform, true, &result));
+  Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
+  EXPECT_EQ(0, min_gl);
+  EXPECT_EQ(0, max_gl);
+
+  // Test cliping to upper limit.
+  transform.set_z(1.1f);
+  EXPECT_TRUE(ApplyColorReduction(source, transform, false, &result));
+  Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
+  EXPECT_EQ(0xFF, min_gl);
+  EXPECT_EQ(0xFF, max_gl);
+
+  // Test cliping to upper limit.
+  transform.Scale(-1.0f);
+  EXPECT_TRUE(ApplyColorReduction(source, transform, false, &result));
+  Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
+  EXPECT_EQ(0x0, min_gl);
+  EXPECT_EQ(0x0, max_gl);
+}
+
+TEST_F(ColorAnalysisTest, ApplyColorReductionBlackAndWhite) {
+  // Check with images with multiple colors. This is really different only when
+  // the result is scaled.
+  gfx::Canvas canvas(gfx::Size(300, 200), 1.0f, true);
+
+  // The image consists of vertical non-overlapping stripes 150 pixels wide.
+  canvas.FillRect(gfx::Rect(0, 0, 150, 200), SkColorSetRGB(0, 0, 0));
+  canvas.FillRect(gfx::Rect(150, 0, 150, 200), SkColorSetRGB(255, 255, 255));
+  SkBitmap source = canvas.GetBitmap();
+  SkBitmap result;
+  result.allocPixels(SkImageInfo::MakeA8(300, 200));
+
+  gfx::Vector3dF transform(1.0f, 0.5f, 0.1f);
+  EXPECT_TRUE(ApplyColorReduction(source, transform, true, &result));
+  uint8_t min_gl = 0;
+  uint8_t max_gl = 0;
+  Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
+
+  EXPECT_EQ(0, min_gl);
+  EXPECT_EQ(255, max_gl);
+  EXPECT_EQ(min_gl, SkColorGetA(result.getColor(0, 0)));
+  EXPECT_EQ(max_gl, SkColorGetA(result.getColor(299, 199)));
+
+  // Reverse test.
+  transform.Scale(-1.0f);
+  EXPECT_TRUE(ApplyColorReduction(source, transform, true, &result));
+  min_gl = 0;
+  max_gl = 0;
+  Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
+
+  EXPECT_EQ(0, min_gl);
+  EXPECT_EQ(255, max_gl);
+  EXPECT_EQ(max_gl, SkColorGetA(result.getColor(0, 0)));
+  EXPECT_EQ(min_gl, SkColorGetA(result.getColor(299, 199)));
+}
+
+TEST_F(ColorAnalysisTest, ApplyColorReductionMultiColor) {
+  // Check with images with multiple colors. This is really different only when
+  // the result is scaled.
+  gfx::Canvas canvas(gfx::Size(300, 200), 1.0f, true);
+
+  // The image consists of vertical non-overlapping stripes 100 pixels wide.
+  canvas.FillRect(gfx::Rect(0, 0, 100, 200), SkColorSetRGB(100, 0, 0));
+  canvas.FillRect(gfx::Rect(100, 0, 100, 200), SkColorSetRGB(0, 255, 0));
+  canvas.FillRect(gfx::Rect(200, 0, 100, 200), SkColorSetRGB(0, 0, 128));
+  SkBitmap source = canvas.GetBitmap();
+  SkBitmap result;
+  result.allocPixels(SkImageInfo::MakeA8(300, 200));
+
+  gfx::Vector3dF transform(1.0f, 0.5f, 0.1f);
+  EXPECT_TRUE(ApplyColorReduction(source, transform, false, &result));
+  uint8_t min_gl = 0;
+  uint8_t max_gl = 0;
+  Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
+  EXPECT_EQ(12, min_gl);
+  EXPECT_EQ(127, max_gl);
+  EXPECT_EQ(min_gl, SkColorGetA(result.getColor(299, 199)));
+  EXPECT_EQ(max_gl, SkColorGetA(result.getColor(150, 0)));
+  EXPECT_EQ(100U, SkColorGetA(result.getColor(0, 0)));
+
+  EXPECT_TRUE(ApplyColorReduction(source, transform, true, &result));
+  Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
+  EXPECT_EQ(0, min_gl);
+  EXPECT_EQ(255, max_gl);
+  EXPECT_EQ(min_gl, SkColorGetA(result.getColor(299, 199)));
+  EXPECT_EQ(max_gl, SkColorGetA(result.getColor(150, 0)));
+  EXPECT_EQ(193U, SkColorGetA(result.getColor(0, 0)));
+}
+
+TEST_F(ColorAnalysisTest, ComputeProminentColors) {
+  LumaRange lumas[] = {LumaRange::DARK, LumaRange::NORMAL, LumaRange::LIGHT};
+  SaturationRange saturations[] = {SaturationRange::VIBRANT,
+                                   SaturationRange::MUTED};
+  std::vector<ColorProfile> color_profiles;
+  for (auto s : saturations) {
+    for (auto l : lumas)
+      color_profiles.emplace_back(l, s);
+  }
+
+  // A totally dark gray image, which yields no prominent color as it's too
+  // close to black.
+  gfx::Canvas canvas(gfx::Size(300, 200), 1.0f, true);
+  canvas.FillRect(gfx::Rect(0, 0, 300, 200), SkColorSetRGB(10, 10, 10));
+  SkBitmap bitmap = canvas.GetBitmap();
+
+  // All expectations start at SK_ColorTRANSPARENT (i.e. 0).
+  std::vector<Swatch> expectations(color_profiles.size(),
+                                   Swatch(SK_ColorTRANSPARENT, 0));
+  std::vector<Swatch> computations = CalculateProminentColorsOfBitmap(
+      bitmap, color_profiles, nullptr /* region */, ColorSwatchFilter());
+  EXPECT_EQ(expectations, computations);
+
+  // Add a green that could hit a couple values.
+  const SkColor kVibrantGreen = SkColorSetRGB(25, 200, 25);
+  canvas.FillRect(gfx::Rect(0, 1, 300, 1), kVibrantGreen);
+  bitmap = canvas.GetBitmap();
+  expectations[0] = Swatch(kVibrantGreen, 60);
+  expectations[1] = Swatch(kVibrantGreen, 60);
+  computations = CalculateProminentColorsOfBitmap(
+      bitmap, color_profiles, nullptr /* region */, ColorSwatchFilter());
+  EXPECT_EQ(expectations, computations);
+
+  // Add a stripe of a dark, muted green (saturation .33, luma .29).
+  const SkColor kDarkGreen = SkColorSetRGB(50, 100, 50);
+  canvas.FillRect(gfx::Rect(0, 2, 300, 1), kDarkGreen);
+  bitmap = canvas.GetBitmap();
+  expectations[3] = Swatch(kDarkGreen, 60);
+  computations = CalculateProminentColorsOfBitmap(
+      bitmap, color_profiles, nullptr /* region */, ColorSwatchFilter());
+  EXPECT_EQ(expectations, computations);
+
+  // Now draw a little bit of pure green. That should be closer to the goal for
+  // normal vibrant, but is out of range for other color profiles.
+  const SkColor kPureGreen = SkColorSetRGB(0, 255, 0);
+  canvas.FillRect(gfx::Rect(0, 3, 300, 1), kPureGreen);
+  bitmap = canvas.GetBitmap();
+  expectations[1] = Swatch(kPureGreen, 60);
+  computations = CalculateProminentColorsOfBitmap(
+      bitmap, color_profiles, nullptr /* region */, ColorSwatchFilter());
+  EXPECT_EQ(expectations, computations);
+}
+
+TEST_F(ColorAnalysisTest, ComputeColorSwatches) {
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(100, 100);
+  bitmap.eraseColor(SK_ColorMAGENTA);
+  bitmap.erase(SK_ColorGREEN, {10, 10, 90, 90});
+  bitmap.erase(SK_ColorYELLOW, {40, 40, 60, 60});
+
+  const Swatch kYellowSwatch = Swatch(SK_ColorYELLOW, (20u * 20u));
+  const Swatch kGreenSwatch =
+      Swatch(SK_ColorGREEN, (80u * 80u) - kYellowSwatch.population);
+  const Swatch kMagentaSwatch =
+      Swatch(SK_ColorMAGENTA, (100u * 100u) - kGreenSwatch.population -
+                                  kYellowSwatch.population);
+
+  {
+    std::vector<Swatch> colors =
+        CalculateColorSwatches(bitmap, 10, gfx::Rect(100, 100), absl::nullopt);
+    EXPECT_EQ(3u, colors.size());
+    EXPECT_EQ(kGreenSwatch, colors[0]);
+    EXPECT_EQ(kMagentaSwatch, colors[1]);
+    EXPECT_EQ(kYellowSwatch, colors[2]);
+  }
+
+  {
+    std::vector<Swatch> colors = CalculateColorSwatches(
+        bitmap, 10, gfx::Rect(10, 10, 80, 80), absl::nullopt);
+    EXPECT_EQ(2u, colors.size());
+    EXPECT_EQ(kGreenSwatch, colors[0]);
+    EXPECT_EQ(kYellowSwatch, colors[1]);
+  }
+}
+
+TEST_F(ColorAnalysisTest, ComputeColorSwatches_Filter) {
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(100, 100);
+  bitmap.eraseColor(SK_ColorMAGENTA);
+  bitmap.erase(SK_ColorBLACK, {10, 10, 90, 90});
+  bitmap.erase(SK_ColorWHITE, {40, 40, 60, 60});
+
+  const Swatch kWhiteSwatch = Swatch(SK_ColorWHITE, (20u * 20u));
+  const Swatch kBlackSwatch =
+      Swatch(SK_ColorBLACK, (80u * 80u) - kWhiteSwatch.population);
+  const Swatch kMagentaSwatch =
+      Swatch(SK_ColorMAGENTA,
+             (100u * 100u) - kBlackSwatch.population - kWhiteSwatch.population);
+
+  {
+    std::vector<Swatch> colors = CalculateColorSwatches(
+        bitmap, 10, gfx::Rect(100, 100),
+        base::BindRepeating([](const SkColor& candidate) {
+          return candidate != SK_ColorBLACK;
+        }));
+    EXPECT_EQ(2u, colors.size());
+    EXPECT_EQ(kMagentaSwatch, colors[0]);
+    EXPECT_EQ(kWhiteSwatch, colors[1]);
+  }
+
+  {
+    std::vector<Swatch> colors =
+        CalculateColorSwatches(bitmap, 10, gfx::Rect(100, 100), absl::nullopt);
+    EXPECT_EQ(3u, colors.size());
+    EXPECT_EQ(kBlackSwatch, colors[0]);
+    EXPECT_EQ(kMagentaSwatch, colors[1]);
+    EXPECT_EQ(kWhiteSwatch, colors[2]);
+  }
+}
+
+}  // namespace color_utils
diff --git a/ui/gfx/color_palette.h b/ui/gfx/color_palette.h
new file mode 100644
index 0000000..ebf2cde
--- /dev/null
+++ b/ui/gfx/color_palette.h
@@ -0,0 +1,154 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_COLOR_PALETTE_H_
+#define UI_GFX_COLOR_PALETTE_H_
+
+#include "third_party/skia/include/core/SkColor.h"
+
+namespace gfx {
+
+// A placeholder value for unset colors. This should never be visible and is red
+// as a visual flag for misbehaving code.
+constexpr SkColor kPlaceholderColor = SK_ColorRED;
+
+// The number refers to the shade of darkness. Each color in the MD
+// palette ranges from 050-900.
+constexpr SkColor kGoogleBlue050 = SkColorSetRGB(0xE8, 0xF0, 0xFE);
+constexpr SkColor kGoogleBlue100 = SkColorSetRGB(0xD2, 0xE3, 0xFC);
+constexpr SkColor kGoogleBlue200 = SkColorSetRGB(0xAE, 0xCB, 0xFA);
+constexpr SkColor kGoogleBlue300 = SkColorSetRGB(0x8A, 0xB4, 0xF8);
+constexpr SkColor kGoogleBlue400 = SkColorSetRGB(0x66, 0x9D, 0xF6);
+constexpr SkColor kGoogleBlue500 = SkColorSetRGB(0x42, 0x85, 0xF4);
+constexpr SkColor kGoogleBlue600 = SkColorSetRGB(0x1A, 0x73, 0xE8);
+constexpr SkColor kGoogleBlue700 = SkColorSetRGB(0x19, 0x67, 0xD2);
+constexpr SkColor kGoogleBlue800 = SkColorSetRGB(0x18, 0x5A, 0xBC);
+constexpr SkColor kGoogleBlue900 = SkColorSetRGB(0x17, 0x4E, 0xA6);
+
+constexpr SkColor kGoogleBlueDark400 = SkColorSetRGB(0x6B, 0xA5, 0xED);
+constexpr SkColor kGoogleBlueDark600 = SkColorSetRGB(0x25, 0x81, 0xDF);
+
+constexpr SkColor kGoogleRed050 = SkColorSetRGB(0xFC, 0xE8, 0xE6);
+constexpr SkColor kGoogleRed100 = SkColorSetRGB(0xFA, 0xD2, 0xCF);
+constexpr SkColor kGoogleRed200 = SkColorSetRGB(0xF6, 0xAE, 0xA9);
+constexpr SkColor kGoogleRed300 = SkColorSetRGB(0xF2, 0x8B, 0x82);
+constexpr SkColor kGoogleRed400 = SkColorSetRGB(0xEE, 0x67, 0x5C);
+constexpr SkColor kGoogleRed500 = SkColorSetRGB(0xEA, 0x43, 0x35);
+constexpr SkColor kGoogleRed600 = SkColorSetRGB(0xD9, 0x30, 0x25);
+constexpr SkColor kGoogleRed700 = SkColorSetRGB(0xC5, 0x22, 0x1F);
+constexpr SkColor kGoogleRed800 = SkColorSetRGB(0xB3, 0x14, 0x12);
+constexpr SkColor kGoogleRed900 = SkColorSetRGB(0xA5, 0x0E, 0x0E);
+
+constexpr SkColor kGoogleRedDark500 = SkColorSetRGB(0xE6, 0x6A, 0x5E);
+constexpr SkColor kGoogleRedDark600 = SkColorSetRGB(0xD3, 0x3B, 0x30);
+constexpr SkColor kGoogleRedDark800 = SkColorSetRGB(0xB4, 0x1B, 0x1A);
+
+constexpr SkColor kGoogleGreen050 = SkColorSetRGB(0xE6, 0xF4, 0xEA);
+constexpr SkColor kGoogleGreen100 = SkColorSetRGB(0xCE, 0xEA, 0xD6);
+constexpr SkColor kGoogleGreen200 = SkColorSetRGB(0xA8, 0xDA, 0xB5);
+constexpr SkColor kGoogleGreen300 = SkColorSetRGB(0x81, 0xC9, 0x95);
+constexpr SkColor kGoogleGreen400 = SkColorSetRGB(0x5B, 0xB9, 0x74);
+constexpr SkColor kGoogleGreen500 = SkColorSetRGB(0x34, 0xA8, 0x53);
+constexpr SkColor kGoogleGreen600 = SkColorSetRGB(0x1E, 0x8E, 0x3E);
+constexpr SkColor kGoogleGreen700 = SkColorSetRGB(0x18, 0x80, 0x38);
+constexpr SkColor kGoogleGreen800 = SkColorSetRGB(0x13, 0x73, 0x33);
+constexpr SkColor kGoogleGreen900 = SkColorSetRGB(0x0D, 0x65, 0x2D);
+
+constexpr SkColor kGoogleGreenDark500 = SkColorSetRGB(0x41, 0xAF, 0x6A);
+constexpr SkColor kGoogleGreenDark600 = SkColorSetRGB(0x28, 0x99, 0x4F);
+
+constexpr SkColor kGoogleYellow050 = SkColorSetRGB(0xFE, 0xF7, 0xE0);
+constexpr SkColor kGoogleYellow100 = SkColorSetRGB(0xFE, 0xEF, 0xC3);
+constexpr SkColor kGoogleYellow200 = SkColorSetRGB(0xFD, 0xE2, 0x93);
+constexpr SkColor kGoogleYellow300 = SkColorSetRGB(0xFD, 0xD6, 0x63);
+constexpr SkColor kGoogleYellow400 = SkColorSetRGB(0xFC, 0xC9, 0x34);
+constexpr SkColor kGoogleYellow500 = SkColorSetRGB(0xFB, 0xBC, 0x04);
+constexpr SkColor kGoogleYellow600 = SkColorSetRGB(0xF9, 0xAB, 0x00);
+constexpr SkColor kGoogleYellow700 = SkColorSetRGB(0xF2, 0x99, 0x00);
+constexpr SkColor kGoogleYellow800 = SkColorSetRGB(0xEA, 0x86, 0x00);
+constexpr SkColor kGoogleYellow900 = SkColorSetRGB(0xE3, 0x74, 0x00);
+
+constexpr SkColor kGoogleGrey050 = SkColorSetRGB(0xF8, 0xF9, 0xFA);
+constexpr SkColor kGoogleGrey100 = SkColorSetRGB(0xF1, 0xF3, 0xF4);
+constexpr SkColor kGoogleGrey200 = SkColorSetRGB(0xE8, 0xEA, 0xED);
+constexpr SkColor kGoogleGrey300 = SkColorSetRGB(0xDA, 0xDC, 0xE0);
+constexpr SkColor kGoogleGrey400 = SkColorSetRGB(0xBD, 0xC1, 0xC6);
+constexpr SkColor kGoogleGrey500 = SkColorSetRGB(0x9A, 0xA0, 0xA6);
+constexpr SkColor kGoogleGrey600 = SkColorSetRGB(0x80, 0x86, 0x8B);
+constexpr SkColor kGoogleGrey700 = SkColorSetRGB(0x5F, 0x63, 0x68);
+constexpr SkColor kGoogleGrey800 = SkColorSetRGB(0x3C, 0x40, 0x43);
+constexpr SkColor kGoogleGrey900 = SkColorSetRGB(0x20, 0x21, 0x24);
+
+constexpr SkColor kGoogleOrange050 = SkColorSetRGB(0xFE, 0xEF, 0xE3);
+constexpr SkColor kGoogleOrange100 = SkColorSetRGB(0xFE, 0xDF, 0xC8);
+constexpr SkColor kGoogleOrange200 = SkColorSetRGB(0xFD, 0xC6, 0x9C);
+constexpr SkColor kGoogleOrange300 = SkColorSetRGB(0xFC, 0xAD, 0x70);
+constexpr SkColor kGoogleOrange400 = SkColorSetRGB(0xFA, 0x90, 0x3E);
+constexpr SkColor kGoogleOrange500 = SkColorSetRGB(0xFA, 0x7B, 0x17);
+constexpr SkColor kGoogleOrange600 = SkColorSetRGB(0xE8, 0x71, 0x0A);
+constexpr SkColor kGoogleOrange700 = SkColorSetRGB(0xD5, 0x6E, 0x0C);
+constexpr SkColor kGoogleOrange800 = SkColorSetRGB(0xC2, 0x64, 0x01);
+constexpr SkColor kGoogleOrange900 = SkColorSetRGB(0xB0, 0x60, 0x00);
+
+constexpr SkColor kGooglePink050 = SkColorSetRGB(0xFD, 0xE7, 0xF3);
+constexpr SkColor kGooglePink100 = SkColorSetRGB(0xFD, 0xCF, 0xE8);
+constexpr SkColor kGooglePink200 = SkColorSetRGB(0xFB, 0xA9, 0xD6);
+constexpr SkColor kGooglePink300 = SkColorSetRGB(0xFF, 0x8B, 0xCB);
+constexpr SkColor kGooglePink400 = SkColorSetRGB(0xFF, 0x63, 0xB8);
+constexpr SkColor kGooglePink500 = SkColorSetRGB(0xF4, 0x39, 0xA0);
+constexpr SkColor kGooglePink600 = SkColorSetRGB(0xE5, 0x25, 0x92);
+constexpr SkColor kGooglePink700 = SkColorSetRGB(0xD0, 0x18, 0x84);
+constexpr SkColor kGooglePink800 = SkColorSetRGB(0xB8, 0x06, 0x72);
+constexpr SkColor kGooglePink900 = SkColorSetRGB(0x9C, 0x16, 0x6B);
+
+constexpr SkColor kGooglePurple050 = SkColorSetRGB(0xF3, 0xE8, 0xFD);
+constexpr SkColor kGooglePurple100 = SkColorSetRGB(0xE9, 0xD2, 0xFD);
+constexpr SkColor kGooglePurple200 = SkColorSetRGB(0xD7, 0xAE, 0xFB);
+constexpr SkColor kGooglePurple300 = SkColorSetRGB(0xC5, 0x8A, 0xF9);
+constexpr SkColor kGooglePurple400 = SkColorSetRGB(0xAF, 0x5C, 0xF7);
+constexpr SkColor kGooglePurple500 = SkColorSetRGB(0xA1, 0x42, 0xF4);
+constexpr SkColor kGooglePurple600 = SkColorSetRGB(0x93, 0x34, 0xE6);
+constexpr SkColor kGooglePurple700 = SkColorSetRGB(0x84, 0x30, 0xCE);
+constexpr SkColor kGooglePurple800 = SkColorSetRGB(0x76, 0x27, 0xBB);
+constexpr SkColor kGooglePurple900 = SkColorSetRGB(0x68, 0x1D, 0xA8);
+
+constexpr SkColor kGoogleCyan050 = SkColorSetRGB(0xE4, 0xF7, 0xFB);
+constexpr SkColor kGoogleCyan100 = SkColorSetRGB(0xCB, 0xF0, 0xF8);
+constexpr SkColor kGoogleCyan200 = SkColorSetRGB(0xA1, 0xE4, 0xF2);
+constexpr SkColor kGoogleCyan300 = SkColorSetRGB(0x78, 0xD9, 0xEC);
+constexpr SkColor kGoogleCyan400 = SkColorSetRGB(0x4E, 0xCD, 0xE6);
+constexpr SkColor kGoogleCyan500 = SkColorSetRGB(0x24, 0xC1, 0xE0);
+constexpr SkColor kGoogleCyan600 = SkColorSetRGB(0x12, 0xB5, 0xCB);
+constexpr SkColor kGoogleCyan700 = SkColorSetRGB(0x12, 0x9E, 0xAF);
+constexpr SkColor kGoogleCyan800 = SkColorSetRGB(0x09, 0x85, 0x91);
+constexpr SkColor kGoogleCyan900 = SkColorSetRGB(0x00, 0x7B, 0x83);
+
+// The following are the values that correspond to the above kGoogleGreyXXX
+// values, which are the opaque colors created from the following alpha values
+// applied to kGoogleGrey900 on a white background.
+// These values are from the palette of greys specified in the Material Refresh
+// spec.
+constexpr SkAlpha kGoogleGreyAlpha050 = 0x08;  //   3%
+constexpr SkAlpha kGoogleGreyAlpha100 = 0x0F;  //   6%
+constexpr SkAlpha kGoogleGreyAlpha200 = 0x1A;  //  10%
+constexpr SkAlpha kGoogleGreyAlpha300 = 0x29;  //  16%
+constexpr SkAlpha kGoogleGreyAlpha400 = 0x47;  //  28%
+constexpr SkAlpha kGoogleGreyAlpha500 = 0x6E;  //  43%
+constexpr SkAlpha kGoogleGreyAlpha600 = 0x8C;  //  55%
+constexpr SkAlpha kGoogleGreyAlpha700 = 0xB5;  //  71%
+constexpr SkAlpha kGoogleGreyAlpha800 = 0xDB;  //  86%
+
+// kChromeIconGrey is subject to change in the future, kGoogleGrey700 is set in
+// stone. If you're semantically looking for "the icon color Chrome uses" then
+// use kChromeIconGrey, if you're looking for GG700 grey specifically, use the
+// Google-grey constant directly.
+constexpr SkColor kChromeIconGrey = kGoogleGrey700;
+
+// An alpha value for designating a control's disabled state. In specs this is
+// sometimes listed as 0.38a.
+constexpr SkAlpha kDisabledControlAlpha = 0x61;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_COLOR_PALETTE_H_
diff --git a/ui/gfx/color_space.cc b/ui/gfx/color_space.cc
new file mode 100644
index 0000000..02a4fee
--- /dev/null
+++ b/ui/gfx/color_space.cc
@@ -0,0 +1,1286 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/color_space.h"
+
+#include <iomanip>
+#include <limits>
+#include <map>
+#include <sstream>
+
+#include "base/atomic_sequence_num.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/synchronization/lock.h"
+#include "third_party/skia/include/core/SkColorSpace.h"
+#include "third_party/skia/include/core/SkData.h"
+#include "third_party/skia/include/core/SkICC.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
+#include "ui/gfx/display_color_spaces.h"
+#include "ui/gfx/icc_profile.h"
+#include "ui/gfx/skia_color_space_util.h"
+
+namespace gfx {
+
+namespace {
+
+static bool IsAlmostZero(float value) {
+  return std::abs(value) < std::numeric_limits<float>::epsilon();
+}
+
+static bool FloatsEqualWithinTolerance(const float* a,
+                                       const float* b,
+                                       int n,
+                                       float tol) {
+  for (int i = 0; i < n; ++i) {
+    if (std::abs(a[i] - b[i]) > tol) {
+      return false;
+    }
+  }
+  return true;
+}
+
+skcms_TransferFunction GetPQSkTransferFunction(float sdr_white_level) {
+  // Note that SkColorSpace doesn't have the notion of an unspecified SDR white
+  // level.
+  if (sdr_white_level == 0.f)
+    sdr_white_level = ColorSpace::kDefaultSDRWhiteLevel;
+
+  // The generic PQ transfer function produces normalized luminance values i.e.
+  // the range 0-1 represents 0-10000 nits for the reference display, but we
+  // want to map 1.0 to |sdr_white_level| nits so we need to scale accordingly.
+  const double w = 10000. / sdr_white_level;
+  // Distribute scaling factor W by scaling A and B with X ^ (1/F):
+  // ((A + Bx^C) / (D + Ex^C))^F * W = ((A + Bx^C) / (D + Ex^C) * W^(1/F))^F
+  // See https://crbug.com/1058580#c32 for discussion.
+  skcms_TransferFunction fn = SkNamedTransferFn::kPQ;
+  const double ws = pow(w, 1. / fn.f);
+  fn.a = ws * fn.a;
+  fn.b = ws * fn.b;
+  return fn;
+}
+
+skcms_TransferFunction GetHLGSkTransferFunction(float sdr_white_level) {
+  // Note that SkColorSpace doesn't have the notion of an unspecified SDR white
+  // level.
+  if (sdr_white_level == 0.f)
+    sdr_white_level = ColorSpace::kDefaultSDRWhiteLevel;
+
+  // The reference white level for HLG is 100 nits. We want to setup the
+  // returned transfer function such that output values are scaled by the white
+  // level; Skia uses the |f| transfer function parameter for this.
+  skcms_TransferFunction fn = SkNamedTransferFn::kHLG;
+  fn.f = ColorSpace::kDefaultSDRWhiteLevel / sdr_white_level - 1;
+  return fn;
+}
+
+float GetSDRWhiteLevelFromPQSkTransferFunction(
+    const skcms_TransferFunction& fn) {
+  DCHECK_EQ(fn.g, SkNamedTransferFn::kPQ.g);
+  const double ws_a = static_cast<double>(fn.a) / SkNamedTransferFn::kPQ.a;
+  const double w_a = pow(ws_a, fn.f);
+  const double sdr_white_level_a = 10000.0f / w_a;
+  return sdr_white_level_a;
+}
+
+float GetSDRWhiteLevelFromHLGSkTransferFunction(
+    const skcms_TransferFunction& fn) {
+  DCHECK_EQ(fn.g, SkNamedTransferFn::kHLG.g);
+  if (fn.f == 0)
+    return ColorSpace::kDefaultSDRWhiteLevel;
+  return 1.0f / ((fn.f + 1) / ColorSpace::kDefaultSDRWhiteLevel);
+}
+
+bool PrimaryIdContainsSRGB(ColorSpace::PrimaryID id) {
+  DCHECK(id != ColorSpace::PrimaryID::INVALID &&
+         id != ColorSpace::PrimaryID::CUSTOM);
+
+  switch (id) {
+    case ColorSpace::PrimaryID::BT709:
+    case ColorSpace::PrimaryID::BT2020:
+    case ColorSpace::PrimaryID::SMPTEST428_1:
+    case ColorSpace::PrimaryID::SMPTEST431_2:
+    case ColorSpace::PrimaryID::SMPTEST432_1:
+    case ColorSpace::PrimaryID::XYZ_D50:
+    case ColorSpace::PrimaryID::ADOBE_RGB:
+    case ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace
+
+// static
+constexpr float ColorSpace::kDefaultSDRWhiteLevel;
+
+ColorSpace::ColorSpace(PrimaryID primaries,
+                       TransferID transfer,
+                       MatrixID matrix,
+                       RangeID range,
+                       const skcms_Matrix3x3* custom_primary_matrix,
+                       const skcms_TransferFunction* custom_transfer_fn)
+    : primaries_(primaries),
+      transfer_(transfer),
+      matrix_(matrix),
+      range_(range) {
+  if (custom_primary_matrix) {
+    DCHECK_EQ(PrimaryID::CUSTOM, primaries_);
+    SetCustomPrimaries(*custom_primary_matrix);
+  }
+  if (custom_transfer_fn)
+    SetCustomTransferFunction(*custom_transfer_fn);
+}
+
+ColorSpace::ColorSpace(const SkColorSpace& sk_color_space)
+    : ColorSpace(PrimaryID::INVALID,
+                 TransferID::INVALID,
+                 MatrixID::RGB,
+                 RangeID::FULL) {
+  skcms_TransferFunction fn;
+  if (sk_color_space.isNumericalTransferFn(&fn)) {
+    transfer_ = TransferID::CUSTOM;
+    SetCustomTransferFunction(fn);
+  } else if (skcms_TransferFunction_isHLGish(&fn)) {
+    transfer_ = TransferID::ARIB_STD_B67;
+    transfer_params_[0] = GetSDRWhiteLevelFromHLGSkTransferFunction(fn);
+  } else if (skcms_TransferFunction_isPQish(&fn)) {
+    transfer_ = TransferID::SMPTEST2084;
+    transfer_params_[0] = GetSDRWhiteLevelFromPQSkTransferFunction(fn);
+  } else {
+    // Construct an invalid result: Unable to extract necessary parameters
+    return;
+  }
+
+  skcms_Matrix3x3 to_XYZD50;
+  if (!sk_color_space.toXYZD50(&to_XYZD50)) {
+    // Construct an invalid result: Unable to extract necessary parameters
+    return;
+  }
+  SetCustomPrimaries(to_XYZD50);
+}
+
+bool ColorSpace::IsValid() const {
+  return primaries_ != PrimaryID::INVALID && transfer_ != TransferID::INVALID &&
+         matrix_ != MatrixID::INVALID && range_ != RangeID::INVALID;
+}
+
+// static
+ColorSpace ColorSpace::CreateSCRGBLinear(float sdr_white_level) {
+  skcms_TransferFunction fn = {0};
+  fn.g = 1.0f;
+  fn.a = kDefaultScrgbLinearSdrWhiteLevel / sdr_white_level;
+  return ColorSpace(PrimaryID::BT709, TransferID::CUSTOM_HDR, MatrixID::RGB,
+                    RangeID::FULL, nullptr, &fn);
+}
+
+// static
+ColorSpace ColorSpace::CreateHDR10(float sdr_white_level) {
+  ColorSpace result(PrimaryID::BT2020, TransferID::SMPTEST2084, MatrixID::RGB,
+                    RangeID::FULL);
+  result.transfer_params_[0] = sdr_white_level;
+  return result;
+}
+
+// static
+ColorSpace ColorSpace::CreateHLG() {
+  return ColorSpace(PrimaryID::BT2020, TransferID::ARIB_STD_B67, MatrixID::RGB,
+                    RangeID::FULL);
+}
+
+// static
+ColorSpace ColorSpace::CreatePiecewiseHDR(
+    PrimaryID primaries,
+    float sdr_joint,
+    float hdr_level,
+    const skcms_Matrix3x3* custom_primary_matrix) {
+  // If |sdr_joint| is 1, then this is just sRGB (and so |hdr_level| must be 1).
+  // An |sdr_joint| higher than 1 breaks.
+  DCHECK_LE(sdr_joint, 1.f);
+  if (sdr_joint == 1.f)
+    DCHECK_EQ(hdr_level, 1.f);
+  // An |hdr_level| of 1 has no HDR. An |hdr_level| less than 1 breaks.
+  DCHECK_GE(hdr_level, 1.f);
+  ColorSpace result(primaries, TransferID::PIECEWISE_HDR, MatrixID::RGB,
+                    RangeID::FULL, custom_primary_matrix, nullptr);
+  result.transfer_params_[0] = sdr_joint;
+  result.transfer_params_[1] = hdr_level;
+  return result;
+}
+
+// static
+ColorSpace ColorSpace::CreateCustom(const skcms_Matrix3x3& to_XYZD50,
+                                    const skcms_TransferFunction& fn) {
+  ColorSpace result(ColorSpace::PrimaryID::CUSTOM,
+                    ColorSpace::TransferID::CUSTOM, ColorSpace::MatrixID::RGB,
+                    ColorSpace::RangeID::FULL, &to_XYZD50, &fn);
+  return result;
+}
+
+// static
+ColorSpace ColorSpace::CreateCustom(const skcms_Matrix3x3& to_XYZD50,
+                                    TransferID transfer) {
+  ColorSpace result(ColorSpace::PrimaryID::CUSTOM, transfer,
+                    ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL,
+                    &to_XYZD50, nullptr);
+  return result;
+}
+
+void ColorSpace::SetCustomPrimaries(const skcms_Matrix3x3& to_XYZD50) {
+  const PrimaryID kIDsToCheck[] = {
+      PrimaryID::BT709,
+      PrimaryID::BT470M,
+      PrimaryID::BT470BG,
+      PrimaryID::SMPTE170M,
+      PrimaryID::SMPTE240M,
+      PrimaryID::FILM,
+      PrimaryID::BT2020,
+      PrimaryID::SMPTEST428_1,
+      PrimaryID::SMPTEST431_2,
+      PrimaryID::SMPTEST432_1,
+      PrimaryID::XYZ_D50,
+      PrimaryID::ADOBE_RGB,
+      PrimaryID::APPLE_GENERIC_RGB,
+      PrimaryID::WIDE_GAMUT_COLOR_SPIN,
+  };
+  for (PrimaryID id : kIDsToCheck) {
+    skcms_Matrix3x3 matrix;
+    GetPrimaryMatrix(id, &matrix);
+    if (FloatsEqualWithinTolerance(&to_XYZD50.vals[0][0], &matrix.vals[0][0], 9,
+                                   0.001f)) {
+      primaries_ = id;
+      return;
+    }
+  }
+
+  memcpy(custom_primary_matrix_, &to_XYZD50, 9 * sizeof(float));
+  primaries_ = PrimaryID::CUSTOM;
+}
+
+void ColorSpace::SetCustomTransferFunction(const skcms_TransferFunction& fn) {
+  DCHECK(transfer_ == TransferID::CUSTOM ||
+         transfer_ == TransferID::CUSTOM_HDR);
+  // These are all TransferIDs that will return a transfer function from
+  // GetTransferFunction. When multiple ids map to the same function, this list
+  // prioritizes the most common name (eg IEC61966_2_1). This applies only to
+  // SDR transfer functions.
+  if (transfer_ == TransferID::CUSTOM) {
+    const TransferID kIDsToCheck[] = {
+        TransferID::IEC61966_2_1, TransferID::LINEAR,
+        TransferID::GAMMA18,      TransferID::GAMMA22,
+        TransferID::GAMMA24,      TransferID::GAMMA28,
+        TransferID::SMPTE240M,    TransferID::BT709_APPLE,
+        TransferID::SMPTEST428_1,
+    };
+    for (TransferID id : kIDsToCheck) {
+      skcms_TransferFunction id_fn;
+      GetTransferFunction(id, &id_fn);
+      if (FloatsEqualWithinTolerance(&fn.g, &id_fn.g, 7, 0.001f)) {
+        transfer_ = id;
+        return;
+      }
+    }
+  }
+  transfer_params_[0] = fn.a;
+  transfer_params_[1] = fn.b;
+  transfer_params_[2] = fn.c;
+  transfer_params_[3] = fn.d;
+  transfer_params_[4] = fn.e;
+  transfer_params_[5] = fn.f;
+  transfer_params_[6] = fn.g;
+}
+
+// static
+size_t ColorSpace::TransferParamCount(TransferID transfer) {
+  switch (transfer) {
+    case TransferID::CUSTOM:
+      return 7;
+    case TransferID::CUSTOM_HDR:
+      return 7;
+    case TransferID::PIECEWISE_HDR:
+      return 2;
+    case TransferID::SMPTEST2084:
+    case TransferID::ARIB_STD_B67:
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+bool ColorSpace::operator==(const ColorSpace& other) const {
+  if (primaries_ != other.primaries_ || transfer_ != other.transfer_ ||
+      matrix_ != other.matrix_ || range_ != other.range_) {
+    return false;
+  }
+  if (primaries_ == PrimaryID::CUSTOM) {
+    if (memcmp(custom_primary_matrix_, other.custom_primary_matrix_,
+               sizeof(custom_primary_matrix_))) {
+      return false;
+    }
+  }
+  if (size_t param_count = TransferParamCount(transfer_)) {
+    if (memcmp(transfer_params_, other.transfer_params_,
+               param_count * sizeof(float))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool ColorSpace::IsWide() const {
+  // These HDR transfer functions are always wide
+  if (transfer_ == TransferID::IEC61966_2_1_HDR ||
+      transfer_ == TransferID::LINEAR_HDR ||
+      transfer_ == TransferID::CUSTOM_HDR)
+    return true;
+
+  if (primaries_ == PrimaryID::BT2020 ||
+      primaries_ == PrimaryID::SMPTEST431_2 ||
+      primaries_ == PrimaryID::SMPTEST432_1 ||
+      primaries_ == PrimaryID::ADOBE_RGB ||
+      primaries_ == PrimaryID::WIDE_GAMUT_COLOR_SPIN ||
+      // TODO(cblume/ccameron): Compute if the custom primaries actually are
+      // wide. For now, assume so.
+      primaries_ == PrimaryID::CUSTOM)
+    return true;
+
+  return false;
+}
+
+bool ColorSpace::IsHDR() const {
+  return transfer_ == TransferID::SMPTEST2084 ||
+         transfer_ == TransferID::ARIB_STD_B67 ||
+         transfer_ == TransferID::LINEAR_HDR ||
+         transfer_ == TransferID::IEC61966_2_1_HDR ||
+         transfer_ == TransferID::CUSTOM_HDR ||
+         transfer_ == TransferID::PIECEWISE_HDR;
+}
+
+bool ColorSpace::FullRangeEncodedValues() const {
+  return transfer_ == TransferID::LINEAR_HDR ||
+         transfer_ == TransferID::IEC61966_2_1_HDR ||
+         transfer_ == TransferID::CUSTOM_HDR ||
+         transfer_ == TransferID::PIECEWISE_HDR ||
+         transfer_ == TransferID::BT1361_ECG ||
+         transfer_ == TransferID::IEC61966_2_4;
+}
+
+bool ColorSpace::operator!=(const ColorSpace& other) const {
+  return !(*this == other);
+}
+
+bool ColorSpace::operator<(const ColorSpace& other) const {
+  if (primaries_ < other.primaries_)
+    return true;
+  if (primaries_ > other.primaries_)
+    return false;
+  if (transfer_ < other.transfer_)
+    return true;
+  if (transfer_ > other.transfer_)
+    return false;
+  if (matrix_ < other.matrix_)
+    return true;
+  if (matrix_ > other.matrix_)
+    return false;
+  if (range_ < other.range_)
+    return true;
+  if (range_ > other.range_)
+    return false;
+  if (primaries_ == PrimaryID::CUSTOM) {
+    int primary_result =
+        memcmp(custom_primary_matrix_, other.custom_primary_matrix_,
+               sizeof(custom_primary_matrix_));
+    if (primary_result < 0)
+      return true;
+    if (primary_result > 0)
+      return false;
+  }
+  if (size_t param_count = TransferParamCount(transfer_)) {
+    int transfer_result = memcmp(transfer_params_, other.transfer_params_,
+                                 param_count * sizeof(float));
+    if (transfer_result < 0)
+      return true;
+    if (transfer_result > 0)
+      return false;
+  }
+  return false;
+}
+
+size_t ColorSpace::GetHash() const {
+  size_t result = (static_cast<size_t>(primaries_) << 0) |
+                  (static_cast<size_t>(transfer_) << 8) |
+                  (static_cast<size_t>(matrix_) << 16) |
+                  (static_cast<size_t>(range_) << 24);
+  if (primaries_ == PrimaryID::CUSTOM) {
+    const uint32_t* params =
+        reinterpret_cast<const uint32_t*>(custom_primary_matrix_);
+    result ^= params[0];
+    result ^= params[4];
+    result ^= params[8];
+  }
+  {
+    // Note that |transfer_params_| must be zero when they are unused.
+    const uint32_t* params =
+        reinterpret_cast<const uint32_t*>(transfer_params_);
+    result ^= params[3];
+    result ^= params[6];
+  }
+  return result;
+}
+
+#define PRINT_ENUM_CASE(TYPE, NAME) \
+  case TYPE::NAME:                  \
+    ss << #NAME;                    \
+    break;
+
+std::string ColorSpace::ToString() const {
+  std::stringstream ss;
+  ss << std::fixed << std::setprecision(4);
+  if (primaries_ != PrimaryID::CUSTOM)
+    ss << "{primaries:";
+  switch (primaries_) {
+    PRINT_ENUM_CASE(PrimaryID, INVALID)
+    PRINT_ENUM_CASE(PrimaryID, BT709)
+    PRINT_ENUM_CASE(PrimaryID, BT470M)
+    PRINT_ENUM_CASE(PrimaryID, BT470BG)
+    PRINT_ENUM_CASE(PrimaryID, SMPTE170M)
+    PRINT_ENUM_CASE(PrimaryID, SMPTE240M)
+    PRINT_ENUM_CASE(PrimaryID, FILM)
+    PRINT_ENUM_CASE(PrimaryID, BT2020)
+    PRINT_ENUM_CASE(PrimaryID, SMPTEST428_1)
+    PRINT_ENUM_CASE(PrimaryID, SMPTEST431_2)
+    PRINT_ENUM_CASE(PrimaryID, SMPTEST432_1)
+    PRINT_ENUM_CASE(PrimaryID, XYZ_D50)
+    PRINT_ENUM_CASE(PrimaryID, ADOBE_RGB)
+    PRINT_ENUM_CASE(PrimaryID, APPLE_GENERIC_RGB)
+    PRINT_ENUM_CASE(PrimaryID, WIDE_GAMUT_COLOR_SPIN)
+    case PrimaryID::CUSTOM:
+      // |custom_primary_matrix_| is in row-major order.
+      const float sum_R = custom_primary_matrix_[0] +
+                          custom_primary_matrix_[3] + custom_primary_matrix_[6];
+      const float sum_G = custom_primary_matrix_[1] +
+                          custom_primary_matrix_[4] + custom_primary_matrix_[7];
+      const float sum_B = custom_primary_matrix_[2] +
+                          custom_primary_matrix_[5] + custom_primary_matrix_[8];
+      if (IsAlmostZero(sum_R) || IsAlmostZero(sum_G) || IsAlmostZero(sum_B))
+        break;
+
+      ss << "{primaries_d50_referred: [[" << (custom_primary_matrix_[0] / sum_R)
+         << ", " << (custom_primary_matrix_[3] / sum_R) << "], "
+         << " [" << (custom_primary_matrix_[1] / sum_G) << ", "
+         << (custom_primary_matrix_[4] / sum_G) << "], "
+         << " [" << (custom_primary_matrix_[2] / sum_B) << ", "
+         << (custom_primary_matrix_[5] / sum_B) << "]]";
+      break;
+  }
+  ss << ", transfer:";
+  switch (transfer_) {
+    PRINT_ENUM_CASE(TransferID, INVALID)
+    PRINT_ENUM_CASE(TransferID, BT709)
+    PRINT_ENUM_CASE(TransferID, BT709_APPLE)
+    PRINT_ENUM_CASE(TransferID, GAMMA18)
+    PRINT_ENUM_CASE(TransferID, GAMMA22)
+    PRINT_ENUM_CASE(TransferID, GAMMA24)
+    PRINT_ENUM_CASE(TransferID, GAMMA28)
+    PRINT_ENUM_CASE(TransferID, SMPTE170M)
+    PRINT_ENUM_CASE(TransferID, SMPTE240M)
+    PRINT_ENUM_CASE(TransferID, LINEAR)
+    PRINT_ENUM_CASE(TransferID, LOG)
+    PRINT_ENUM_CASE(TransferID, LOG_SQRT)
+    PRINT_ENUM_CASE(TransferID, IEC61966_2_4)
+    PRINT_ENUM_CASE(TransferID, BT1361_ECG)
+    PRINT_ENUM_CASE(TransferID, IEC61966_2_1)
+    PRINT_ENUM_CASE(TransferID, BT2020_10)
+    PRINT_ENUM_CASE(TransferID, BT2020_12)
+    PRINT_ENUM_CASE(TransferID, SMPTEST428_1)
+    PRINT_ENUM_CASE(TransferID, IEC61966_2_1_HDR)
+    PRINT_ENUM_CASE(TransferID, LINEAR_HDR)
+    case TransferID::ARIB_STD_B67:
+      ss << "HLG (SDR white point ";
+      if (transfer_params_[0] == 0.f)
+        ss << "default " << kDefaultSDRWhiteLevel;
+      else
+        ss << transfer_params_[0];
+      ss << " nits)";
+      break;
+    case TransferID::SMPTEST2084:
+      ss << "PQ (SDR white point ";
+      if (transfer_params_[0] == 0.f)
+        ss << "default " << kDefaultSDRWhiteLevel;
+      else
+        ss << transfer_params_[0];
+      ss << " nits)";
+      break;
+    case TransferID::CUSTOM: {
+      skcms_TransferFunction fn;
+      GetTransferFunction(&fn);
+      ss << fn.c << "*x + " << fn.f << " if x < " << fn.d << " else (" << fn.a
+         << "*x + " << fn.b << ")**" << fn.g << " + " << fn.e;
+      break;
+    }
+    case TransferID::CUSTOM_HDR: {
+      skcms_TransferFunction fn;
+      GetTransferFunction(&fn);
+      if (fn.g == 1.0f && fn.a > 0.0f && fn.b == 0.0f && fn.c == 0.0f &&
+          fn.d == 0.0f && fn.e == 0.0f && fn.f == 0.0f) {
+        ss << "LINEAR_HDR (slope " << fn.a << ", SDR white point "
+           << kDefaultScrgbLinearSdrWhiteLevel / fn.a << " nits)";
+        break;
+      }
+      ss << fn.c << "*x + " << fn.f << " if |x| < " << fn.d << " else sign(x)*("
+         << fn.a << "*|x| + " << fn.b << ")**" << fn.g << " + " << fn.e;
+      break;
+    }
+    case TransferID::PIECEWISE_HDR: {
+      skcms_TransferFunction fn;
+      GetTransferFunction(&fn);
+      ss << "sRGB to 1 at " << transfer_params_[0] << ", linear to "
+         << transfer_params_[1] << " at 1";
+      break;
+    }
+  }
+  ss << ", matrix:";
+  switch (matrix_) {
+    PRINT_ENUM_CASE(MatrixID, INVALID)
+    PRINT_ENUM_CASE(MatrixID, RGB)
+    PRINT_ENUM_CASE(MatrixID, BT709)
+    PRINT_ENUM_CASE(MatrixID, FCC)
+    PRINT_ENUM_CASE(MatrixID, BT470BG)
+    PRINT_ENUM_CASE(MatrixID, SMPTE170M)
+    PRINT_ENUM_CASE(MatrixID, SMPTE240M)
+    PRINT_ENUM_CASE(MatrixID, YCOCG)
+    PRINT_ENUM_CASE(MatrixID, BT2020_NCL)
+    PRINT_ENUM_CASE(MatrixID, BT2020_CL)
+    PRINT_ENUM_CASE(MatrixID, YDZDX)
+    PRINT_ENUM_CASE(MatrixID, GBR)
+  }
+  ss << ", range:";
+  switch (range_) {
+    PRINT_ENUM_CASE(RangeID, INVALID)
+    PRINT_ENUM_CASE(RangeID, LIMITED)
+    PRINT_ENUM_CASE(RangeID, FULL)
+    PRINT_ENUM_CASE(RangeID, DERIVED)
+  }
+  ss << "}";
+  return ss.str();
+}
+
+#undef PRINT_ENUM_CASE
+
+ColorSpace ColorSpace::GetAsFullRangeRGB() const {
+  ColorSpace result(*this);
+  if (!IsValid())
+    return result;
+  result.matrix_ = MatrixID::RGB;
+  result.range_ = RangeID::FULL;
+  return result;
+}
+
+ContentColorUsage ColorSpace::GetContentColorUsage() const {
+  if (IsHDR())
+    return ContentColorUsage::kHDR;
+  if (IsWide())
+    return ContentColorUsage::kWideColorGamut;
+  return ContentColorUsage::kSRGB;
+}
+
+ColorSpace ColorSpace::GetAsRGB() const {
+  ColorSpace result(*this);
+  if (IsValid())
+    result.matrix_ = MatrixID::RGB;
+  return result;
+}
+
+ColorSpace ColorSpace::GetScaledColorSpace(float factor) const {
+  ColorSpace result(*this);
+  skcms_Matrix3x3 to_XYZD50;
+  GetPrimaryMatrix(&to_XYZD50);
+  for (int row = 0; row < 3; ++row) {
+    for (int col = 0; col < 3; ++col) {
+      to_XYZD50.vals[row][col] *= factor;
+    }
+  }
+  result.SetCustomPrimaries(to_XYZD50);
+  return result;
+}
+
+bool ColorSpace::IsSuitableForBlending() const {
+  switch (transfer_) {
+    case TransferID::SMPTEST2084:
+      // PQ is not an acceptable space to do blending in -- blending 0 and 1
+      // evenly will get a result of sRGB 0.259 (instead of 0.5).
+      return false;
+    case TransferID::ARIB_STD_B67:
+    case TransferID::LINEAR_HDR:
+      // If the color space is nearly-linear, then it is not suitable for
+      // blending -- blending 0 and 1 evenly will get a result of sRGB 0.735
+      // (instead of 0.5).
+      return false;
+    case TransferID::CUSTOM_HDR: {
+      // A gamma close enough to linear is treated as linear.
+      skcms_TransferFunction fn;
+      if (GetTransferFunction(&fn)) {
+        constexpr float kMinGamma = 1.25;
+        if (fn.g < kMinGamma)
+          return false;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return true;
+}
+
+ColorSpace ColorSpace::GetWithMatrixAndRange(MatrixID matrix,
+                                             RangeID range) const {
+  ColorSpace result(*this);
+  if (!IsValid())
+    return result;
+
+  result.matrix_ = matrix;
+  result.range_ = range;
+  return result;
+}
+
+ColorSpace ColorSpace::GetWithSDRWhiteLevel(float sdr_white_level) const {
+  ColorSpace result = *this;
+  if (transfer_ == TransferID::SMPTEST2084 ||
+      transfer_ == TransferID::ARIB_STD_B67) {
+    result.transfer_params_[0] = sdr_white_level;
+  } else if (transfer_ == TransferID::LINEAR_HDR) {
+    result.transfer_ = TransferID::CUSTOM_HDR;
+    skcms_TransferFunction fn = {0};
+    fn.g = 1.f;
+    fn.a = kDefaultScrgbLinearSdrWhiteLevel / sdr_white_level;
+    result.SetCustomTransferFunction(fn);
+  }
+  return result;
+}
+
+sk_sp<SkColorSpace> ColorSpace::ToSkColorSpace() const {
+  // Unspecified color spaces correspond to the null SkColorSpace.
+  if (!IsValid())
+    return nullptr;
+
+  // Handle only full-range RGB spaces.
+  if (matrix_ != MatrixID::RGB) {
+    DLOG(ERROR) << "Not creating non-RGB SkColorSpace";
+    return nullptr;
+  }
+  if (range_ != RangeID::FULL) {
+    DLOG(ERROR) << "Not creating non-full-range SkColorSpace";
+    return nullptr;
+  }
+
+  // Use the named SRGB and linear-SRGB instead of the generic constructors.
+  if (primaries_ == PrimaryID::BT709) {
+    if (transfer_ == TransferID::IEC61966_2_1)
+      return SkColorSpace::MakeSRGB();
+    if (transfer_ == TransferID::LINEAR || transfer_ == TransferID::LINEAR_HDR)
+      return SkColorSpace::MakeSRGBLinear();
+  }
+
+  skcms_TransferFunction transfer_fn = SkNamedTransferFn::kSRGB;
+  switch (transfer_) {
+    case TransferID::IEC61966_2_1:
+      break;
+    case TransferID::LINEAR:
+    case TransferID::LINEAR_HDR:
+      transfer_fn = SkNamedTransferFn::kLinear;
+      break;
+    case TransferID::ARIB_STD_B67:
+      transfer_fn = GetHLGSkTransferFunction(transfer_params_[0]);
+      break;
+    case TransferID::SMPTEST2084:
+      transfer_fn = GetPQSkTransferFunction(transfer_params_[0]);
+      break;
+    default:
+      if (!GetTransferFunction(&transfer_fn)) {
+        DLOG(ERROR) << "Failed to get transfer function for SkColorSpace";
+        return nullptr;
+      }
+      break;
+  }
+  skcms_Matrix3x3 gamut = SkNamedGamut::kSRGB;
+  switch (primaries_) {
+    case PrimaryID::BT709:
+      break;
+    case PrimaryID::ADOBE_RGB:
+      gamut = SkNamedGamut::kAdobeRGB;
+      break;
+    case PrimaryID::SMPTEST432_1:
+      gamut = SkNamedGamut::kDisplayP3;
+      break;
+    case PrimaryID::BT2020:
+      gamut = SkNamedGamut::kRec2020;
+      break;
+    default:
+      GetPrimaryMatrix(&gamut);
+      break;
+  }
+
+  sk_sp<SkColorSpace> sk_color_space =
+      SkColorSpace::MakeRGB(transfer_fn, gamut);
+  if (!sk_color_space)
+    DLOG(ERROR) << "SkColorSpace::MakeRGB failed.";
+
+  return sk_color_space;
+}
+
+const struct _GLcolorSpace* ColorSpace::AsGLColorSpace() const {
+  return reinterpret_cast<const struct _GLcolorSpace*>(this);
+}
+
+ColorSpace::PrimaryID ColorSpace::GetPrimaryID() const {
+  return primaries_;
+}
+
+ColorSpace::TransferID ColorSpace::GetTransferID() const {
+  return transfer_;
+}
+
+ColorSpace::MatrixID ColorSpace::GetMatrixID() const {
+  return matrix_;
+}
+
+ColorSpace::RangeID ColorSpace::GetRangeID() const {
+  return range_;
+}
+
+bool ColorSpace::HasExtendedSkTransferFn() const {
+  return transfer_ == TransferID::LINEAR_HDR ||
+         transfer_ == TransferID::IEC61966_2_1_HDR;
+}
+
+bool ColorSpace::Contains(const ColorSpace& other) const {
+  if (primaries_ == PrimaryID::INVALID ||
+      other.primaries_ == PrimaryID::INVALID)
+    return false;
+
+  // Contains() is commonly used to check if a color space contains sRGB. The
+  // computation can be bypassed for known primary IDs.
+  if (primaries_ != PrimaryID::CUSTOM && other.primaries_ == PrimaryID::BT709)
+    return PrimaryIdContainsSRGB(primaries_);
+
+  // |matrix| is the primary transform matrix from |other| to this color space.
+  skcms_Matrix3x3 other_to_xyz;
+  skcms_Matrix3x3 this_to_xyz;
+  skcms_Matrix3x3 xyz_to_this;
+  other.GetPrimaryMatrix(&other_to_xyz);
+  GetPrimaryMatrix(&this_to_xyz);
+  skcms_Matrix3x3_invert(&this_to_xyz, &xyz_to_this);
+  skcms_Matrix3x3 matrix = skcms_Matrix3x3_concat(&xyz_to_this, &other_to_xyz);
+
+  // Return true iff each primary is in the range [0, 1] after transforming.
+  // Transforming a primary vector by |matrix| always results in a column of
+  // |matrix|. So the multiplication can be skipped, and we can just check if
+  // each value in the matrix is in the range [0, 1].
+  constexpr float epsilon = 0.001f;
+  for (int r = 0; r < 3; r++) {
+    for (int c = 0; c < 3; c++) {
+      if (matrix.vals[r][c] < -epsilon || matrix.vals[r][c] > 1 + epsilon)
+        return false;
+    }
+  }
+  return true;
+}
+
+// static
+void ColorSpace::GetPrimaryMatrix(PrimaryID primary_id,
+                                  skcms_Matrix3x3* to_XYZD50) {
+  SkColorSpacePrimaries primaries = {0};
+  switch (primary_id) {
+    case ColorSpace::PrimaryID::CUSTOM:
+    case ColorSpace::PrimaryID::INVALID:
+      *to_XYZD50 = SkNamedGamut::kXYZ;  // Identity
+      return;
+
+    case ColorSpace::PrimaryID::BT709:
+      // BT709 is our default case. Put it after the switch just
+      // in case we somehow get an id which is not listed in the switch.
+      // (We don't want to use "default", because we want the compiler
+      //  to tell us if we forgot some enum values.)
+      primaries.fRX = 0.640f;
+      primaries.fRY = 0.330f;
+      primaries.fGX = 0.300f;
+      primaries.fGY = 0.600f;
+      primaries.fBX = 0.150f;
+      primaries.fBY = 0.060f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::BT470M:
+      primaries.fRX = 0.67f;
+      primaries.fRY = 0.33f;
+      primaries.fGX = 0.21f;
+      primaries.fGY = 0.71f;
+      primaries.fBX = 0.14f;
+      primaries.fBY = 0.08f;
+      primaries.fWX = 0.31f;
+      primaries.fWY = 0.316f;
+      break;
+
+    case ColorSpace::PrimaryID::BT470BG:
+      primaries.fRX = 0.64f;
+      primaries.fRY = 0.33f;
+      primaries.fGX = 0.29f;
+      primaries.fGY = 0.60f;
+      primaries.fBX = 0.15f;
+      primaries.fBY = 0.06f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::SMPTE170M:
+    case ColorSpace::PrimaryID::SMPTE240M:
+      primaries.fRX = 0.630f;
+      primaries.fRY = 0.340f;
+      primaries.fGX = 0.310f;
+      primaries.fGY = 0.595f;
+      primaries.fBX = 0.155f;
+      primaries.fBY = 0.070f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::APPLE_GENERIC_RGB:
+      primaries.fRX = 0.63002f;
+      primaries.fRY = 0.34000f;
+      primaries.fGX = 0.29505f;
+      primaries.fGY = 0.60498f;
+      primaries.fBX = 0.15501f;
+      primaries.fBY = 0.07701f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN:
+      primaries.fRX = 0.01f;
+      primaries.fRY = 0.98f;
+      primaries.fGX = 0.01f;
+      primaries.fGY = 0.01f;
+      primaries.fBX = 0.98f;
+      primaries.fBY = 0.01f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::FILM:
+      primaries.fRX = 0.681f;
+      primaries.fRY = 0.319f;
+      primaries.fGX = 0.243f;
+      primaries.fGY = 0.692f;
+      primaries.fBX = 0.145f;
+      primaries.fBY = 0.049f;
+      primaries.fWX = 0.310f;
+      primaries.fWY = 0.136f;
+      break;
+
+    case ColorSpace::PrimaryID::BT2020:
+      primaries.fRX = 0.708f;
+      primaries.fRY = 0.292f;
+      primaries.fGX = 0.170f;
+      primaries.fGY = 0.797f;
+      primaries.fBX = 0.131f;
+      primaries.fBY = 0.046f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::SMPTEST428_1:
+      primaries.fRX = 1.0f;
+      primaries.fRY = 0.0f;
+      primaries.fGX = 0.0f;
+      primaries.fGY = 1.0f;
+      primaries.fBX = 0.0f;
+      primaries.fBY = 0.0f;
+      primaries.fWX = 1.0f / 3.0f;
+      primaries.fWY = 1.0f / 3.0f;
+      break;
+
+    case ColorSpace::PrimaryID::SMPTEST431_2:
+      primaries.fRX = 0.680f;
+      primaries.fRY = 0.320f;
+      primaries.fGX = 0.265f;
+      primaries.fGY = 0.690f;
+      primaries.fBX = 0.150f;
+      primaries.fBY = 0.060f;
+      primaries.fWX = 0.314f;
+      primaries.fWY = 0.351f;
+      break;
+
+    case ColorSpace::PrimaryID::SMPTEST432_1:
+      primaries.fRX = 0.680f;
+      primaries.fRY = 0.320f;
+      primaries.fGX = 0.265f;
+      primaries.fGY = 0.690f;
+      primaries.fBX = 0.150f;
+      primaries.fBY = 0.060f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+
+    case ColorSpace::PrimaryID::XYZ_D50:
+      primaries.fRX = 1.0f;
+      primaries.fRY = 0.0f;
+      primaries.fGX = 0.0f;
+      primaries.fGY = 1.0f;
+      primaries.fBX = 0.0f;
+      primaries.fBY = 0.0f;
+      primaries.fWX = 0.34567f;
+      primaries.fWY = 0.35850f;
+      break;
+
+    case ColorSpace::PrimaryID::ADOBE_RGB:
+      primaries.fRX = 0.6400f;
+      primaries.fRY = 0.3300f;
+      primaries.fGX = 0.2100f;
+      primaries.fGY = 0.7100f;
+      primaries.fBX = 0.1500f;
+      primaries.fBY = 0.0600f;
+      primaries.fWX = 0.3127f;
+      primaries.fWY = 0.3290f;
+      break;
+  }
+  primaries.toXYZD50(to_XYZD50);
+}
+
+void ColorSpace::GetPrimaryMatrix(skcms_Matrix3x3* to_XYZD50) const {
+  if (primaries_ == PrimaryID::CUSTOM) {
+    memcpy(to_XYZD50, custom_primary_matrix_, 9 * sizeof(float));
+  } else {
+    GetPrimaryMatrix(primaries_, to_XYZD50);
+  }
+}
+
+void ColorSpace::GetPrimaryMatrix(skia::Matrix44* to_XYZD50) const {
+  skcms_Matrix3x3 toXYZ_3x3;
+  GetPrimaryMatrix(&toXYZ_3x3);
+  to_XYZD50->set3x3RowMajorf(&toXYZ_3x3.vals[0][0]);
+}
+
+// static
+bool ColorSpace::GetTransferFunction(TransferID transfer,
+                                     skcms_TransferFunction* fn) {
+  // Default to F(x) = pow(x, 1)
+  fn->a = 1;
+  fn->b = 0;
+  fn->c = 0;
+  fn->d = 0;
+  fn->e = 0;
+  fn->f = 0;
+  fn->g = 1;
+
+  switch (transfer) {
+    case ColorSpace::TransferID::LINEAR:
+    case ColorSpace::TransferID::LINEAR_HDR:
+      return true;
+    case ColorSpace::TransferID::GAMMA18:
+      fn->g = 1.801f;
+      return true;
+    case ColorSpace::TransferID::GAMMA22:
+      fn->g = 2.2f;
+      return true;
+    case ColorSpace::TransferID::GAMMA24:
+      fn->g = 2.4f;
+      return true;
+    case ColorSpace::TransferID::GAMMA28:
+      fn->g = 2.8f;
+      return true;
+    case ColorSpace::TransferID::SMPTE240M:
+      fn->a = 0.899626676224f;
+      fn->b = 0.100373323776f;
+      fn->c = 0.250000000000f;
+      fn->d = 0.091286342118f;
+      fn->g = 2.222222222222f;
+      return true;
+    case ColorSpace::TransferID::BT709:
+    case ColorSpace::TransferID::SMPTE170M:
+    case ColorSpace::TransferID::BT2020_10:
+    case ColorSpace::TransferID::BT2020_12:
+    // With respect to rendering BT709
+    //  * SMPTE 1886 suggests that we should be using gamma 2.4.
+    //  * Most displays actually use a gamma of 2.2, and most media playing
+    //    software uses the sRGB transfer function.
+    //  * User studies shows that users don't really care.
+    //  * Apple's CoreVideo uses gamma=1.961.
+    // Bearing all of that in mind, use the same transfer function as sRGB,
+    // which will allow more optimization, and will more closely match other
+    // media players.
+    case ColorSpace::TransferID::IEC61966_2_1:
+    case ColorSpace::TransferID::IEC61966_2_1_HDR:
+      fn->a = 0.947867345704f;
+      fn->b = 0.052132654296f;
+      fn->c = 0.077399380805f;
+      fn->d = 0.040449937172f;
+      fn->g = 2.400000000000f;
+      return true;
+    case ColorSpace::TransferID::BT709_APPLE:
+      fn->g = 1.961000000000f;
+      return true;
+    case ColorSpace::TransferID::SMPTEST428_1:
+      fn->a = 1.034080527699f;  // (52.37 / 48.0) ^ (1.0 / 2.6) per ITU-T H.273.
+      fn->g = 2.600000000000f;
+      return true;
+    case ColorSpace::TransferID::IEC61966_2_4:
+      // This could potentially be represented the same as IEC61966_2_1, but
+      // it handles negative values differently.
+      break;
+    case ColorSpace::TransferID::ARIB_STD_B67:
+    case ColorSpace::TransferID::BT1361_ECG:
+    case ColorSpace::TransferID::LOG:
+    case ColorSpace::TransferID::LOG_SQRT:
+    case ColorSpace::TransferID::SMPTEST2084:
+    case ColorSpace::TransferID::CUSTOM:
+    case ColorSpace::TransferID::CUSTOM_HDR:
+    case ColorSpace::TransferID::PIECEWISE_HDR:
+    case ColorSpace::TransferID::INVALID:
+      break;
+  }
+
+  return false;
+}
+
+bool ColorSpace::GetTransferFunction(skcms_TransferFunction* fn) const {
+  if (transfer_ == TransferID::CUSTOM || transfer_ == TransferID::CUSTOM_HDR) {
+    fn->a = transfer_params_[0];
+    fn->b = transfer_params_[1];
+    fn->c = transfer_params_[2];
+    fn->d = transfer_params_[3];
+    fn->e = transfer_params_[4];
+    fn->f = transfer_params_[5];
+    fn->g = transfer_params_[6];
+    return true;
+  } else {
+    return GetTransferFunction(transfer_, fn);
+  }
+}
+
+bool ColorSpace::GetInverseTransferFunction(skcms_TransferFunction* fn) const {
+  if (!GetTransferFunction(fn))
+    return false;
+  *fn = SkTransferFnInverse(*fn);
+  return true;
+}
+
+bool ColorSpace::GetSDRWhiteLevel(float* sdr_white_level) const {
+  if (transfer_ != TransferID::SMPTEST2084 &&
+      transfer_ != TransferID::ARIB_STD_B67) {
+    return false;
+  }
+  if (transfer_params_[0] == 0.0f)
+    *sdr_white_level = kDefaultSDRWhiteLevel;
+  else
+    *sdr_white_level = transfer_params_[0];
+  return true;
+}
+
+bool ColorSpace::GetPiecewiseHDRParams(float* sdr_joint,
+                                       float* hdr_level) const {
+  if (transfer_ != TransferID::PIECEWISE_HDR)
+    return false;
+  *sdr_joint = transfer_params_[0];
+  *hdr_level = transfer_params_[1];
+  return true;
+}
+
+void ColorSpace::GetTransferMatrix(int bit_depth,
+                                   skia::Matrix44* matrix) const {
+  DCHECK_GE(bit_depth, 8);
+  // If chroma samples are real numbers in the range of −0.5 to 0.5, an offset
+  // of 0.5 is added to get real numbers in the range of 0 to 1. When
+  // represented as an unsigned |bit_depth|-bit integer, this 0.5 offset is
+  // approximated by 1 << (bit_depth - 1). chroma_0_5 is this approximate value
+  // converted to a real number in the range of 0 to 1.
+  //
+  // TODO(wtc): For now chroma_0_5 is only used for YCgCo. It should also be
+  // used for YUV.
+  const float chroma_0_5 =
+      static_cast<float>(1 << (bit_depth - 1)) / ((1 << bit_depth) - 1);
+  float Kr = 0;
+  float Kb = 0;
+  switch (matrix_) {
+    case ColorSpace::MatrixID::RGB:
+    case ColorSpace::MatrixID::INVALID:
+      matrix->setIdentity();
+      return;
+
+    case ColorSpace::MatrixID::BT709:
+      Kr = 0.2126f;
+      Kb = 0.0722f;
+      break;
+
+    case ColorSpace::MatrixID::FCC:
+      Kr = 0.30f;
+      Kb = 0.11f;
+      break;
+
+    case ColorSpace::MatrixID::BT470BG:
+    case ColorSpace::MatrixID::SMPTE170M:
+      Kr = 0.299f;
+      Kb = 0.114f;
+      break;
+
+    case ColorSpace::MatrixID::SMPTE240M:
+      Kr = 0.212f;
+      Kb = 0.087f;
+      break;
+
+    case ColorSpace::MatrixID::YCOCG: {
+      float data[16] = {0.25f,  0.5f, 0.25f,  0.0f,        // Y
+                        -0.25f, 0.5f, -0.25f, chroma_0_5,  // Cg
+                        0.5f,   0.0f, -0.5f,  chroma_0_5,  // Co
+                        0.0f,   0.0f, 0.0f,   1.0f};
+      matrix->setRowMajorf(data);
+      return;
+    }
+
+    // BT2020_CL is a special case.
+    // Basically we return a matrix that transforms RYB values
+    // to YUV values. (Note that the green component have been replaced
+    // with the luminance.)
+    case ColorSpace::MatrixID::BT2020_CL: {
+      Kr = 0.2627f;
+      Kb = 0.0593f;
+      float data[16] = {1.0f, 0.0f,           0.0f, 0.0f,  // R
+                        Kr,   1.0f - Kr - Kb, Kb,   0.0f,  // Y
+                        0.0f, 0.0f,           1.0f, 0.0f,  // B
+                        0.0f, 0.0f,           0.0f, 1.0f};
+      matrix->setRowMajorf(data);
+      return;
+    }
+
+    case ColorSpace::MatrixID::BT2020_NCL:
+      Kr = 0.2627f;
+      Kb = 0.0593f;
+      break;
+
+    case ColorSpace::MatrixID::YDZDX: {
+      // clang-format off
+      float data[16] = {
+          0.0f,              1.0f,             0.0f, 0.0f,  // Y
+          0.0f,             -0.5f, 0.986566f / 2.0f, 0.5f,  // DX or DZ
+          0.5f, -0.991902f / 2.0f,             0.0f, 0.5f,  // DZ or DX
+          0.0f,              0.0f,             0.0f, 1.0f,
+      };
+      // clang-format on
+      matrix->setRowMajorf(data);
+      return;
+    }
+    case ColorSpace::MatrixID::GBR: {
+      float data[16] = {0.0f, 1.0f, 0.0f, 0.0f,  // G
+                        0.0f, 0.0f, 1.0f, 0.0f,  // B
+                        1.0f, 0.0f, 0.0f, 0.0f,  // R
+                        0.0f, 0.0f, 0.0f, 1.0f};
+      matrix->setRowMajorf(data);
+      return;
+    }
+  }
+  float Kg = 1.0f - Kr - Kb;
+  float u_m = 0.5f / (1.0f - Kb);
+  float v_m = 0.5f / (1.0f - Kr);
+  // clang-format off
+  float data[16] = {
+                     Kr,        Kg,                Kb, 0.0f,  // Y
+              u_m * -Kr, u_m * -Kg, u_m * (1.0f - Kb), 0.5f,  // U
+      v_m * (1.0f - Kr), v_m * -Kg,         v_m * -Kb, 0.5f,  // V
+                   0.0f,      0.0f,              0.0f, 1.0f,
+  };
+  // clang-format on
+  matrix->setRowMajorf(data);
+}
+
+void ColorSpace::GetRangeAdjustMatrix(int bit_depth,
+                                      skia::Matrix44* matrix) const {
+  DCHECK_GE(bit_depth, 8);
+  switch (range_) {
+    case RangeID::FULL:
+    case RangeID::INVALID:
+      matrix->setIdentity();
+      return;
+
+    case RangeID::DERIVED:
+    case RangeID::LIMITED:
+      break;
+  }
+
+  // See ITU-T H.273 (2016), Section 8.3. The following is derived from
+  // Equations 20-31.
+  const int shift = bit_depth - 8;
+  const float a_y = 219 << shift;
+  const float c = (1 << bit_depth) - 1;
+  const float scale_y = c / a_y;
+  switch (matrix_) {
+    case MatrixID::RGB:
+    case MatrixID::GBR:
+    case MatrixID::INVALID:
+    case MatrixID::YCOCG: {
+      matrix->setScale(scale_y, scale_y, scale_y);
+      matrix->postTranslate(-16.0f / 219.0f, -16.0f / 219.0f, -16.0f / 219.0f);
+      break;
+    }
+
+    case MatrixID::BT709:
+    case MatrixID::FCC:
+    case MatrixID::BT470BG:
+    case MatrixID::SMPTE170M:
+    case MatrixID::SMPTE240M:
+    case MatrixID::BT2020_NCL:
+    case MatrixID::BT2020_CL:
+    case MatrixID::YDZDX: {
+      const float a_uv = 224 << shift;
+      const float scale_uv = c / a_uv;
+      const float translate_uv = (a_uv - c) / (2.0f * a_uv);
+      matrix->setScale(scale_y, scale_uv, scale_uv);
+      matrix->postTranslate(-16.0f / 219.0f, translate_uv, translate_uv);
+      break;
+    }
+  }
+}
+
+bool ColorSpace::ToSkYUVColorSpace(int bit_depth, SkYUVColorSpace* out) const {
+  switch (matrix_) {
+    case MatrixID::BT709:
+      *out = range_ == RangeID::FULL ? kRec709_Full_SkYUVColorSpace
+                                     : kRec709_Limited_SkYUVColorSpace;
+      return true;
+
+    case MatrixID::BT470BG:
+    case MatrixID::SMPTE170M:
+      *out = range_ == RangeID::FULL ? kJPEG_SkYUVColorSpace
+                                     : kRec601_Limited_SkYUVColorSpace;
+      return true;
+
+    case MatrixID::BT2020_NCL:
+      if (bit_depth == 8) {
+        *out = range_ == RangeID::FULL ? kBT2020_8bit_Full_SkYUVColorSpace
+                                       : kBT2020_8bit_Limited_SkYUVColorSpace;
+        return true;
+      }
+      if (bit_depth == 10) {
+        *out = range_ == RangeID::FULL ? kBT2020_10bit_Full_SkYUVColorSpace
+                                       : kBT2020_10bit_Limited_SkYUVColorSpace;
+        return true;
+      }
+      if (bit_depth == 12) {
+        *out = range_ == RangeID::FULL ? kBT2020_12bit_Full_SkYUVColorSpace
+                                       : kBT2020_12bit_Limited_SkYUVColorSpace;
+        return true;
+      }
+      return false;
+
+    default:
+      break;
+  }
+  return false;
+}
+
+std::ostream& operator<<(std::ostream& out, const ColorSpace& color_space) {
+  return out << color_space.ToString();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/color_space.h b/ui/gfx/color_space.h
new file mode 100644
index 0000000..169ef2f
--- /dev/null
+++ b/ui/gfx/color_space.h
@@ -0,0 +1,417 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_COLOR_SPACE_H_
+#define UI_GFX_COLOR_SPACE_H_
+
+#include <stdint.h>
+
+#include <iosfwd>
+#include <string>
+
+#include "base/gtest_prod_util.h"
+#include "build/build_config.h"
+#if !defined(STARBOARD)
+#include "third_party/skia/include/core/SkRefCnt.h"
+#endif  // !defined(STARBOARD)
+#include "ui/gfx/color_space_export.h"
+
+struct skcms_Matrix3x3;
+struct skcms_TransferFunction;
+class SkColorSpace;
+#if !defined(STARBOARD)
+enum SkYUVColorSpace : int;
+#endif  // !defined(STARBOARD)
+
+namespace skia {
+class Matrix44;
+}  // namespace skia
+
+// These forward declarations are used to give IPC code friend access to private
+// fields of gfx::ColorSpace for the purpose of serialization and
+// deserialization.
+namespace IPC {
+template <class P>
+struct ParamTraits;
+}  // namespace IPC
+
+namespace mojo {
+template <class T, class U>
+struct StructTraits;
+}  // namespace mojo
+
+// Used to serialize a gfx::ColorSpace through the GPU command buffer.
+struct _GLcolorSpace;
+
+namespace gfx {
+
+enum class ContentColorUsage : uint8_t;
+
+namespace mojom {
+class ColorSpaceDataView;
+}  // namespace mojom
+
+// Used to represet a color space for the purpose of color conversion.
+// This is designed to be safe and compact enough to send over IPC
+// between any processes.
+class COLOR_SPACE_EXPORT ColorSpace {
+ public:
+  enum class PrimaryID : uint8_t {
+    INVALID,
+    BT709,
+    BT470M,
+    BT470BG,
+    SMPTE170M,
+    SMPTE240M,
+    FILM,
+    BT2020,
+    SMPTEST428_1,
+    SMPTEST431_2,
+    SMPTEST432_1,
+    XYZ_D50,
+    ADOBE_RGB,
+    // Corresponds the the primaries of the "Generic RGB" profile used in the
+    // Apple ColorSync application, used by layout tests on Mac.
+    APPLE_GENERIC_RGB,
+    // A very wide gamut space with rotated primaries. Used by layout tests.
+    WIDE_GAMUT_COLOR_SPIN,
+    // Primaries defined by the primary matrix |custom_primary_matrix_|.
+    CUSTOM,
+    kMaxValue = CUSTOM,
+  };
+
+  enum class TransferID : uint8_t {
+    INVALID,
+    BT709,
+    // On macOS, BT709 hardware decoded video frames, when displayed as
+    // overlays, will have a transfer function of gamma=1.961.
+    BT709_APPLE,
+    GAMMA18,
+    GAMMA22,
+    GAMMA24,
+    GAMMA28,
+    SMPTE170M,
+    SMPTE240M,
+    LINEAR,
+    LOG,
+    LOG_SQRT,
+    IEC61966_2_4,
+    BT1361_ECG,
+    IEC61966_2_1,
+    BT2020_10,
+    BT2020_12,
+    SMPTEST2084,
+    SMPTEST428_1,
+    ARIB_STD_B67,  // AKA hybrid-log gamma, HLG.
+    // The same as IEC61966_2_1 on the interval [0, 1], with the nonlinear
+    // segment continuing beyond 1 and point symmetry defining values below 0.
+    IEC61966_2_1_HDR,
+    // The same as LINEAR but is defined for all real values.
+    LINEAR_HDR,
+    // A parametric transfer function defined by |transfer_params_|.
+    CUSTOM,
+    // An HDR parametric transfer function defined by |transfer_params_|.
+    CUSTOM_HDR,
+    // An HDR transfer function that is piecewise sRGB, and piecewise linear.
+    PIECEWISE_HDR,
+    kMaxValue = PIECEWISE_HDR,
+  };
+
+  enum class MatrixID : uint8_t {
+    INVALID,
+    RGB,
+    BT709,
+    FCC,
+    BT470BG,
+    SMPTE170M,
+    SMPTE240M,
+    YCOCG,
+    BT2020_NCL,
+    BT2020_CL,
+    YDZDX,
+    GBR,
+    kMaxValue = GBR,
+  };
+
+  enum class RangeID : uint8_t {
+    INVALID,
+    // Limited Rec. 709 color range with RGB values ranging from 16 to 235.
+    LIMITED,
+    // Full RGB color range with RGB valees from 0 to 255.
+    FULL,
+    // Range is defined by TransferID/MatrixID.
+    DERIVED,
+    kMaxValue = DERIVED,
+  };
+
+  constexpr ColorSpace() {}
+  constexpr ColorSpace(PrimaryID primaries, TransferID transfer)
+      : ColorSpace(primaries, transfer, MatrixID::RGB, RangeID::FULL) {}
+  constexpr ColorSpace(PrimaryID primaries,
+                       TransferID transfer,
+                       MatrixID matrix,
+                       RangeID range)
+      : primaries_(primaries),
+        transfer_(transfer),
+        matrix_(matrix),
+        range_(range) {}
+  ColorSpace(PrimaryID primaries,
+             TransferID transfer,
+             MatrixID matrix,
+             RangeID range,
+             const skcms_Matrix3x3* custom_primary_matrix,
+             const skcms_TransferFunction* cunstom_transfer_fn);
+
+  explicit ColorSpace(const SkColorSpace& sk_color_space);
+
+  // Returns true if this is not the default-constructor object.
+  bool IsValid() const;
+
+  static constexpr ColorSpace CreateSRGB() {
+    return ColorSpace(PrimaryID::BT709, TransferID::IEC61966_2_1, MatrixID::RGB,
+                      RangeID::FULL);
+  }
+
+  static constexpr ColorSpace CreateDisplayP3D65() {
+    return ColorSpace(PrimaryID::SMPTEST432_1, TransferID::IEC61966_2_1,
+                      MatrixID::RGB, RangeID::FULL);
+  }
+  static ColorSpace CreateCustom(const skcms_Matrix3x3& to_XYZD50,
+                                 const skcms_TransferFunction& fn);
+  static ColorSpace CreateCustom(const skcms_Matrix3x3& to_XYZD50,
+                                 TransferID transfer);
+  static constexpr ColorSpace CreateXYZD50() {
+    return ColorSpace(PrimaryID::XYZ_D50, TransferID::LINEAR, MatrixID::RGB,
+                      RangeID::FULL);
+  }
+
+  // Extended sRGB matches sRGB for values in [0, 1], and extends the transfer
+  // function to all real values.
+  static constexpr ColorSpace CreateExtendedSRGB() {
+    return ColorSpace(PrimaryID::BT709, TransferID::IEC61966_2_1_HDR,
+                      MatrixID::RGB, RangeID::FULL);
+  }
+
+  // scRGB uses the same primaries as sRGB but has a linear transfer function
+  // for all real values, and a white point of kDefaultScrgbLinearSdrWhiteLevel.
+  static constexpr ColorSpace CreateSCRGBLinear() {
+    return ColorSpace(PrimaryID::BT709, TransferID::LINEAR_HDR, MatrixID::RGB,
+                      RangeID::FULL);
+  }
+  // Allows specifying a custom SDR white level.  Only used on Windows.
+  static ColorSpace CreateSCRGBLinear(float sdr_white_level);
+
+  // HDR10 uses BT.2020 primaries with SMPTE ST 2084 PQ transfer function.
+  static constexpr ColorSpace CreateHDR10() {
+    return ColorSpace(PrimaryID::BT2020, TransferID::SMPTEST2084, MatrixID::RGB,
+                      RangeID::FULL);
+  }
+  // Allows specifying a custom SDR white level.  Only used on Windows.
+  static ColorSpace CreateHDR10(float sdr_white_level);
+
+  // HLG uses the BT.2020 primaries with the ARIB_STD_B67 transfer function.
+  static ColorSpace CreateHLG();
+
+  // Create a piecewise-HDR color space.
+  // - If |primaries| is CUSTOM, then |custom_primary_matrix| must be
+  //   non-nullptr.
+  // - The SDR joint is the encoded pixel value where the SDR portion reaches 1,
+  //   usually 0.25 or 0.5, corresponding to giving 8 or 9 of 10 bits to SDR.
+  //   This must be in the open interval (0, 1).
+  // - The HDR level the value that the transfer function will evaluate to at 1,
+  //   and represents the maximum HDR brightness relative to the maximum SDR
+  //   brightness. This must be strictly greater than 1.
+  static ColorSpace CreatePiecewiseHDR(
+      PrimaryID primaries,
+      float sdr_joint,
+      float hdr_level,
+      const skcms_Matrix3x3* custom_primary_matrix = nullptr);
+
+  // TODO(ccameron): Remove these, and replace with more generic constructors.
+  static constexpr ColorSpace CreateJpeg() {
+    // TODO(ccameron): Determine which primaries and transfer function were
+    // intended here.
+    return ColorSpace(PrimaryID::BT709, TransferID::IEC61966_2_1,
+                      MatrixID::SMPTE170M, RangeID::FULL);
+  }
+  static constexpr ColorSpace CreateREC601() {
+    return ColorSpace(PrimaryID::SMPTE170M, TransferID::SMPTE170M,
+                      MatrixID::SMPTE170M, RangeID::LIMITED);
+  }
+  static constexpr ColorSpace CreateREC709() {
+    return ColorSpace(PrimaryID::BT709, TransferID::BT709, MatrixID::BT709,
+                      RangeID::LIMITED);
+  }
+
+  // On macOS and on ChromeOS, sRGB's (1,1,1) always coincides with PQ's 100
+  // nits (which may not be 100 physical nits). On Windows, sRGB's (1,1,1)
+  // maps to scRGB linear's (1,1,1) when the SDR white level is set to 80 nits.
+  // See also kDefaultScrgbLinearSdrWhiteLevel.
+  static constexpr float kDefaultSDRWhiteLevel = 100.f;
+
+  // The default white level in nits for scRGB linear color space. On Windows,
+  // sRGB's (1,1,1) maps to scRGB linear's (1,1,1) when the SDR white level is
+  // set to 80 nits. On Mac and ChromeOS, sRGB's (1,1,1) maps to PQ's 100 nits.
+  // Using a platform specific value here satisfies both constraints.
+#if defined(OS_WIN)
+  static constexpr float kDefaultScrgbLinearSdrWhiteLevel = 80.0f;
+#else
+  static constexpr float kDefaultScrgbLinearSdrWhiteLevel =
+      kDefaultSDRWhiteLevel;
+#endif  // OS_WIN
+
+  bool operator==(const ColorSpace& other) const;
+  bool operator!=(const ColorSpace& other) const;
+  bool operator<(const ColorSpace& other) const;
+  size_t GetHash() const;
+  std::string ToString() const {
+    // TODO: Refine ColorSpace::ToString().
+    return "";
+  }
+
+  bool IsWide() const;
+
+  // Returns true if the transfer function is an HDR one (SMPTE 2084, HLG, etc).
+  bool IsHDR() const {
+    // TODO: Refine ColorSpace::IsHDR().
+    return false;
+  }
+
+  // Returns true if the encoded values can be outside of the 0.0-1.0 range.
+  bool FullRangeEncodedValues() const;
+
+  // Returns the color space's content color usage category (sRGB, WCG, or HDR).
+  ContentColorUsage GetContentColorUsage() const;
+
+  // Return this color space with any YUV to RGB conversion stripped off.
+  ColorSpace GetAsRGB() const;
+
+  // Return this color space with any range adjust or YUV to RGB conversion
+  // stripped off.
+  ColorSpace GetAsFullRangeRGB() const;
+
+  // Return a color space where all values are bigger/smaller by the given
+  // factor. If you convert colors from SRGB to SRGB.GetScaledColorSpace(2.0)
+  // everything will be half as bright in linear lumens.
+  ColorSpace GetScaledColorSpace(float factor) const;
+
+  // Return true if blending in |this| is close enough to blending in sRGB to
+  // be considered acceptable (only PQ and nearly-linear transfer functions
+  // return false).
+  bool IsSuitableForBlending() const;
+
+  // Return a combined color space with has the same primary and transfer than
+  // the caller but replacing the matrix and range with the given values.
+  ColorSpace GetWithMatrixAndRange(MatrixID matrix, RangeID range) const;
+
+  // If this color space has a PQ or scRGB linear transfer function, then return
+  // |this| with its SDR white level set to |sdr_white_level|. Otherwise return
+  // |this| unmodified.
+  ColorSpace GetWithSDRWhiteLevel(float sdr_white_level) const;
+
+#if !defined(STARBOARD)
+  // This will return nullptr for non-RGB spaces, spaces with non-FULL
+  // range, and unspecified spaces.
+  sk_sp<SkColorSpace> ToSkColorSpace() const;
+#endif  // !defined(STARBOARD)
+
+  // Return a GLcolorSpace value that is valid for the lifetime of |this|. This
+  // function is used to serialize ColorSpace objects across the GPU command
+  // buffer.
+  const _GLcolorSpace* AsGLColorSpace() const;
+
+#if !defined(STARBOARD)
+  // For YUV color spaces, return the closest SkYUVColorSpace. Returns true if a
+  // close match is found. Otherwise, leaves *out unchanged and returns false.
+  // If |matrix_id| is MatrixID::BT2020_NCL and |bit_depth| is provided, a bit
+  // depth appropriate SkYUVColorSpace will be provided.
+  bool ToSkYUVColorSpace(int bit_depth, SkYUVColorSpace* out) const;
+  bool ToSkYUVColorSpace(SkYUVColorSpace* out) const {
+    return ToSkYUVColorSpace(kDefaultBitDepth, out);
+  }
+#endif  // !defined(STARBOARD)
+
+  void GetPrimaryMatrix(skcms_Matrix3x3* to_XYZD50) const;
+  void GetPrimaryMatrix(skia::Matrix44* to_XYZD50) const;
+  bool GetTransferFunction(skcms_TransferFunction* fn) const;
+  bool GetInverseTransferFunction(skcms_TransferFunction* fn) const;
+
+  // Returns the SDR white level specified for the PQ or HLG transfer functions.
+  // If no value was specified, then use kDefaultSDRWhiteLevel. If the transfer
+  // function is not PQ then return false.
+  bool GetSDRWhiteLevel(float* sdr_white_level) const;
+
+  // Returns the parameters for a PIECEWISE_HDR transfer function. See
+  // CreatePiecewiseHDR for parameter meanings.
+  bool GetPiecewiseHDRParams(float* sdr_point, float* hdr_level) const;
+
+  // Returns the transfer matrix for |bit_depth|. For most formats, this is the
+  // RGB to YUV matrix.
+  void GetTransferMatrix(int bit_depth, skia::Matrix44* matrix) const;
+
+  // Returns the range adjust matrix that converts from |range_| to full range
+  // for |bit_depth|.
+  void GetRangeAdjustMatrix(int bit_depth, skia::Matrix44* matrix) const;
+
+  // Returns the current primary ID.
+  // Note: if SetCustomPrimaries() has been used, the primary ID returned
+  // may have been set to PrimaryID::CUSTOM, or been coerced to another
+  // PrimaryID if it was very close.
+  PrimaryID GetPrimaryID() const;
+
+  // Returns the current transfer ID.
+  TransferID GetTransferID() const;
+
+  // Returns the current matrix ID.
+  MatrixID GetMatrixID() const;
+
+  // Returns the current range ID.
+  RangeID GetRangeID() const;
+
+  // Returns true if the transfer function is defined by an
+  // skcms_TransferFunction which is extended to all real values.
+  bool HasExtendedSkTransferFn() const;
+
+  // Returns true if each color in |other| can be expressed in this color space.
+  bool Contains(const ColorSpace& other) const;
+
+ private:
+  // The default bit depth assumed by ToSkYUVColorSpace().
+  static constexpr int kDefaultBitDepth = 8;
+
+  static void GetPrimaryMatrix(PrimaryID, skcms_Matrix3x3* to_XYZD50);
+  static bool GetTransferFunction(TransferID, skcms_TransferFunction* fn);
+  static size_t TransferParamCount(TransferID);
+
+  void SetCustomTransferFunction(const skcms_TransferFunction& fn);
+  void SetCustomPrimaries(const skcms_Matrix3x3& to_XYZD50);
+
+  PrimaryID primaries_ = PrimaryID::INVALID;
+  TransferID transfer_ = TransferID::INVALID;
+  MatrixID matrix_ = MatrixID::INVALID;
+  RangeID range_ = RangeID::INVALID;
+
+  // Only used if primaries_ is PrimaryID::CUSTOM.
+  float custom_primary_matrix_[9] = {0, 0, 0, 0, 0, 0, 0, 0};
+
+  // Parameters for the transfer function. The interpretation depends on
+  // |transfer_|. Only TransferParamCount() of these parameters are used, all
+  // others must be zero.
+  // - CUSTOM and CUSTOM_HDR: Entries A through G of the skcms_TransferFunction
+  //   structure in alphabetical order.
+  // - SMPTEST2084: SDR white point.
+  float transfer_params_[7] = {0, 0, 0, 0, 0, 0, 0};
+
+  friend struct IPC::ParamTraits<gfx::ColorSpace>;
+  friend struct mojo::StructTraits<gfx::mojom::ColorSpaceDataView,
+                                   gfx::ColorSpace>;
+};
+
+// Stream operator so ColorSpace can be used in assertion statements.
+COLOR_SPACE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                            const ColorSpace& color_space);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_COLOR_SPACE_H_
diff --git a/ui/gfx/color_space_export.h b/ui/gfx/color_space_export.h
new file mode 100644
index 0000000..a0402b7
--- /dev/null
+++ b/ui/gfx/color_space_export.h
@@ -0,0 +1,29 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_COLOR_SPACE_EXPORT_H_
+#define UI_GFX_COLOR_SPACE_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(COLOR_SPACE_IMPLEMENTATION)
+#define COLOR_SPACE_EXPORT __declspec(dllexport)
+#else
+#define COLOR_SPACE_EXPORT __declspec(dllimport)
+#endif  // defined(COLOR_SPACE_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(COLOR_SPACE_IMPLEMENTATION)
+#define COLOR_SPACE_EXPORT __attribute__((visibility("default")))
+#else
+#define COLOR_SPACE_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define COLOR_SPACE_EXPORT
+#endif
+
+#endif  // UI_GFX_COLOR_SPACE_EXPORT_H_
diff --git a/ui/gfx/color_space_unittest.cc b/ui/gfx/color_space_unittest.cc
new file mode 100644
index 0000000..2fcff5f
--- /dev/null
+++ b/ui/gfx/color_space_unittest.cc
@@ -0,0 +1,435 @@
+// Copyright 2017 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.
+
+#include <algorithm>
+#include <cmath>
+#include <tuple>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/skia_color_space_util.h"
+
+namespace gfx {
+namespace {
+
+// Returns the L-infty difference of u and v.
+float Diff(const skia::Vector4& u, const skia::Vector4& v) {
+  float result = 0;
+  for (size_t i = 0; i < 4; ++i)
+    result = std::max(result, std::abs(u.fData[i] - v.fData[i]));
+  return result;
+}
+
+TEST(ColorSpace, RGBToYUV) {
+  const float kEpsilon = 1.0e-3f;
+  const size_t kNumTestRGBs = 3;
+  skia::Vector4 test_rgbs[kNumTestRGBs] = {
+      skia::Vector4(1.f, 0.f, 0.f, 1.f),
+      skia::Vector4(0.f, 1.f, 0.f, 1.f),
+      skia::Vector4(0.f, 0.f, 1.f, 1.f),
+  };
+
+  const size_t kNumColorSpaces = 4;
+  gfx::ColorSpace color_spaces[kNumColorSpaces] = {
+      gfx::ColorSpace::CreateREC601(),
+      gfx::ColorSpace::CreateREC709(),
+      gfx::ColorSpace::CreateJpeg(),
+      gfx::ColorSpace::CreateXYZD50(),
+  };
+
+  skia::Vector4 expected_yuvs[kNumColorSpaces][kNumTestRGBs] = {
+      // REC601
+      {
+          skia::Vector4(0.3195f, 0.3518f, 0.9392f, 1.0000f),
+          skia::Vector4(0.5669f, 0.2090f, 0.1322f, 1.0000f),
+          skia::Vector4(0.1607f, 0.9392f, 0.4286f, 1.0000f),
+      },
+      // REC709
+      {
+          skia::Vector4(0.2453f, 0.3994f, 0.9392f, 1.0000f),
+          skia::Vector4(0.6770f, 0.1614f, 0.1011f, 1.0000f),
+          skia::Vector4(0.1248f, 0.9392f, 0.4597f, 1.0000f),
+      },
+      // Jpeg
+      {
+          skia::Vector4(0.2990f, 0.3313f, 1.0000f, 1.0000f),
+          skia::Vector4(0.5870f, 0.1687f, 0.0813f, 1.0000f),
+          skia::Vector4(0.1140f, 1.0000f, 0.4187f, 1.0000f),
+      },
+      // XYZD50
+      {
+          skia::Vector4(1.0000f, 0.0000f, 0.0000f, 1.0000f),
+          skia::Vector4(0.0000f, 1.0000f, 0.0000f, 1.0000f),
+          skia::Vector4(0.0000f, 0.0000f, 1.0000f, 1.0000f),
+      },
+  };
+
+  for (size_t i = 0; i < kNumColorSpaces; ++i) {
+    skia::Matrix44 transfer;
+    color_spaces[i].GetTransferMatrix(/*bit_depth=*/8, &transfer);
+
+    skia::Matrix44 range_adjust;
+    color_spaces[i].GetRangeAdjustMatrix(/*bit_depth=*/8, &range_adjust);
+
+    skia::Matrix44 range_adjust_inv;
+    range_adjust.invert(&range_adjust_inv);
+
+    for (size_t j = 0; j < kNumTestRGBs; ++j) {
+      skia::Vector4 yuv = range_adjust_inv * transfer * test_rgbs[j];
+      EXPECT_LT(Diff(yuv, expected_yuvs[i][j]), kEpsilon);
+    }
+  }
+}
+
+TEST(ColorSpace, RangeAdjust) {
+  const float kEpsilon = 1.0e-3f;
+  const size_t kNumTestYUVs = 2;
+  skia::Vector4 test_yuvs[kNumTestYUVs] = {
+      skia::Vector4(1.f, 1.f, 1.f, 1.f),
+      skia::Vector4(0.f, 0.f, 0.f, 1.f),
+  };
+
+  const size_t kNumBitDepths = 3;
+  int bit_depths[kNumBitDepths] = {8, 10, 12};
+
+  const size_t kNumColorSpaces = 3;
+  ColorSpace color_spaces[kNumColorSpaces] = {
+      ColorSpace::CreateREC601(),
+      ColorSpace::CreateJpeg(),
+      ColorSpace(ColorSpace::PrimaryID::INVALID,
+                 ColorSpace::TransferID::INVALID, ColorSpace::MatrixID::YCOCG,
+                 ColorSpace::RangeID::LIMITED),
+  };
+
+  skia::Vector4 expected_yuvs[kNumColorSpaces][kNumBitDepths][kNumTestYUVs] = {
+      // REC601
+      {
+          // 8bpc
+          {
+              skia::Vector4(235.f / 255.f, 239.5f / 255.f, 239.5f / 255.f,
+                            1.0000f),
+              skia::Vector4(16.f / 255.f, 15.5f / 255.f, 15.5f / 255.f,
+                            1.0000f),
+          },
+          // 10bpc
+          {
+              skia::Vector4(940.f / 1023.f, 959.5f / 1023.f, 959.5f / 1023.f,
+                            1.0000f),
+              skia::Vector4(64.f / 1023.f, 63.5f / 1023.f, 63.5f / 1023.f,
+                            1.0000f),
+          },
+          // 12bpc
+          {
+              skia::Vector4(3760.f / 4095.f, 3839.5f / 4095.f, 3839.5f / 4095.f,
+                            1.0000f),
+              skia::Vector4(256.f / 4095.f, 255.5f / 4095.f, 255.5f / 4095.f,
+                            1.0000f),
+          },
+      },
+      // Jpeg
+      {
+          // 8bpc
+          {
+              skia::Vector4(1.0000f, 1.0000f, 1.0000f, 1.0000f),
+              skia::Vector4(0.0000f, 0.0000f, 0.0000f, 1.0000f),
+          },
+          // 10bpc
+          {
+              skia::Vector4(1.0000f, 1.0000f, 1.0000f, 1.0000f),
+              skia::Vector4(0.0000f, 0.0000f, 0.0000f, 1.0000f),
+          },
+          // 12bpc
+          {
+              skia::Vector4(1.0000f, 1.0000f, 1.0000f, 1.0000f),
+              skia::Vector4(0.0000f, 0.0000f, 0.0000f, 1.0000f),
+          },
+      },
+      // YCoCg
+      {
+          // 8bpc
+          {
+              skia::Vector4(235.f / 255.f, 235.f / 255.f, 235.f / 255.f,
+                            1.0000f),
+              skia::Vector4(16.f / 255.f, 16.f / 255.f, 16.f / 255.f, 1.0000f),
+          },
+          // 10bpc
+          {
+              skia::Vector4(940.f / 1023.f, 940.f / 1023.f, 940.f / 1023.f,
+                            1.0000f),
+              skia::Vector4(64.f / 1023.f, 64.f / 1023.f, 64.f / 1023.f,
+                            1.0000f),
+          },
+          // 12bpc
+          {
+              skia::Vector4(3760.f / 4095.f, 3760.f / 4095.f, 3760.f / 4095.f,
+                            1.0000f),
+              skia::Vector4(256.f / 4095.f, 256.f / 4095.f, 256.f / 4095.f,
+                            1.0000f),
+          },
+      },
+  };
+
+  for (size_t i = 0; i < kNumColorSpaces; ++i) {
+    for (size_t j = 0; j < kNumBitDepths; ++j) {
+      skia::Matrix44 range_adjust;
+      color_spaces[i].GetRangeAdjustMatrix(bit_depths[j], &range_adjust);
+
+      skia::Matrix44 range_adjust_inv;
+      range_adjust.invert(&range_adjust_inv);
+
+      for (size_t k = 0; k < kNumTestYUVs; ++k) {
+        skia::Vector4 yuv = range_adjust_inv * test_yuvs[k];
+        EXPECT_LT(Diff(yuv, expected_yuvs[i][j][k]), kEpsilon);
+      }
+    }
+  }
+}
+
+TEST(ColorSpace, Blending) {
+  ColorSpace display_color_space;
+
+  // A linear transfer function being used for HDR should be blended using an
+  // sRGB-like transfer function.
+  display_color_space = ColorSpace::CreateSCRGBLinear();
+  EXPECT_FALSE(display_color_space.IsSuitableForBlending());
+
+  // If not used for HDR, a linear transfer function should be left unchanged.
+  display_color_space = ColorSpace::CreateXYZD50();
+  EXPECT_TRUE(display_color_space.IsSuitableForBlending());
+}
+
+TEST(ColorSpace, ConversionToAndFromSkColorSpace) {
+  const size_t kNumTests = 5;
+  skcms_Matrix3x3 primary_matrix = {{
+      {0.205276f, 0.625671f, 0.060867f},
+      {0.149185f, 0.063217f, 0.744553f},
+      {0.609741f, 0.311111f, 0.019470f},
+  }};
+  skcms_TransferFunction transfer_fn = {2.1f, 1.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+
+  ColorSpace color_spaces[kNumTests] = {
+      ColorSpace(ColorSpace::PrimaryID::BT709,
+                 ColorSpace::TransferID::IEC61966_2_1),
+      ColorSpace(ColorSpace::PrimaryID::ADOBE_RGB,
+                 ColorSpace::TransferID::IEC61966_2_1),
+      ColorSpace(ColorSpace::PrimaryID::SMPTEST432_1,
+                 ColorSpace::TransferID::LINEAR),
+      ColorSpace(ColorSpace::PrimaryID::BT2020,
+                 ColorSpace::TransferID::IEC61966_2_1),
+      ColorSpace::CreateCustom(primary_matrix, transfer_fn),
+  };
+  sk_sp<SkColorSpace> sk_color_spaces[kNumTests] = {
+      SkColorSpace::MakeSRGB(),
+      SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB),
+      SkColorSpace::MakeRGB(SkNamedTransferFn::kLinear,
+                            SkNamedGamut::kDisplayP3),
+      SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kRec2020),
+      SkColorSpace::MakeRGB(transfer_fn, primary_matrix),
+  };
+
+  // Test that converting from ColorSpace to SkColorSpace is producing an
+  // equivalent representation.
+  for (size_t i = 0; i < kNumTests; ++i) {
+    EXPECT_TRUE(SkColorSpace::Equals(color_spaces[i].ToSkColorSpace().get(),
+                                     sk_color_spaces[i].get()))
+        << " on iteration i = " << i;
+  }
+
+  // Invariant test: Test that converting a SkColorSpace to a ColorSpace is
+  // producing an equivalent representation; and then converting the converted
+  // ColorSpace back to SkColorSpace is also producing an equivalent
+  // representation.
+  for (size_t i = 0; i < kNumTests; ++i) {
+    const ColorSpace from_sk_color_space(*sk_color_spaces[i]);
+    EXPECT_EQ(color_spaces[i], from_sk_color_space);
+    EXPECT_TRUE(SkColorSpace::Equals(
+        sk_color_spaces[i].get(), from_sk_color_space.ToSkColorSpace().get()));
+  }
+}
+
+TEST(ColorSpace, PQToSkColorSpace) {
+  ColorSpace color_space;
+  ColorSpace roundtrip_color_space;
+  float roundtrip_sdr_white_level;
+  const float kEpsilon = 1.e-5f;
+
+  // We expect that when a white point is specified, the conversion from
+  // ColorSpace -> SkColorSpace -> ColorSpace be the identity. Because of
+  // rounding error, this will not quite be the case.
+  color_space = ColorSpace::CreateHDR10(50.f);
+  roundtrip_color_space = ColorSpace(*color_space.ToSkColorSpace());
+  EXPECT_TRUE(
+      roundtrip_color_space.GetSDRWhiteLevel(&roundtrip_sdr_white_level));
+  EXPECT_NEAR(50.f, roundtrip_sdr_white_level, kEpsilon);
+  EXPECT_EQ(ColorSpace::TransferID::SMPTEST2084,
+            roundtrip_color_space.GetTransferID());
+
+  // When no white level is specified, we should get an SkColorSpace that
+  // specifies the default white level. Of note is that in the roundtrip, the
+  // value of kDefaultSDRWhiteLevel gets baked in.
+  color_space = ColorSpace::CreateHDR10();
+  roundtrip_color_space = ColorSpace(*color_space.ToSkColorSpace());
+  EXPECT_TRUE(
+      roundtrip_color_space.GetSDRWhiteLevel(&roundtrip_sdr_white_level));
+  EXPECT_NEAR(ColorSpace::kDefaultSDRWhiteLevel, roundtrip_sdr_white_level,
+              kEpsilon);
+}
+
+TEST(ColorSpace, HLGToSkColorSpace) {
+  ColorSpace color_space;
+  ColorSpace roundtrip_color_space;
+  float roundtrip_sdr_white_level;
+  const float kEpsilon = 1.0e-3f;
+
+  // We expect that when a white point is specified, the conversion from
+  // ColorSpace -> SkColorSpace -> ColorSpace be the identity. Because of
+  // rounding error, this will not quite be the case.
+  constexpr float kSDRWhiteLevel = 50.0f;
+  color_space = ColorSpace::CreateHLG().GetWithSDRWhiteLevel(kSDRWhiteLevel);
+  roundtrip_color_space = ColorSpace(*color_space.ToSkColorSpace());
+  EXPECT_TRUE(
+      roundtrip_color_space.GetSDRWhiteLevel(&roundtrip_sdr_white_level));
+  EXPECT_FLOAT_EQ(kSDRWhiteLevel, roundtrip_sdr_white_level);
+  EXPECT_EQ(ColorSpace::TransferID::ARIB_STD_B67,
+            roundtrip_color_space.GetTransferID());
+
+  // When no white level is specified, we should get an SkColorSpace that
+  // specifies the default white level. Of note is that in the roundtrip, the
+  // value of kDefaultSDRWhiteLevel gets baked in.
+  color_space = ColorSpace::CreateHLG();
+  roundtrip_color_space = ColorSpace(*color_space.ToSkColorSpace());
+  EXPECT_TRUE(
+      roundtrip_color_space.GetSDRWhiteLevel(&roundtrip_sdr_white_level));
+  EXPECT_NEAR(ColorSpace::kDefaultSDRWhiteLevel, roundtrip_sdr_white_level,
+              kEpsilon);
+}
+
+TEST(ColorSpace, MixedInvalid) {
+  ColorSpace color_space;
+  color_space = color_space.GetWithMatrixAndRange(ColorSpace::MatrixID::INVALID,
+                                                  ColorSpace::RangeID::INVALID);
+  EXPECT_TRUE(!color_space.IsValid());
+  color_space = color_space.GetWithMatrixAndRange(
+      ColorSpace::MatrixID::SMPTE170M, ColorSpace::RangeID::LIMITED);
+  EXPECT_TRUE(!color_space.IsValid());
+}
+
+TEST(ColorSpace, MixedSRGBWithRec601) {
+  const ColorSpace expected_color_space = ColorSpace(
+      ColorSpace::PrimaryID::BT709, ColorSpace::TransferID::IEC61966_2_1,
+      ColorSpace::MatrixID::SMPTE170M, ColorSpace::RangeID::LIMITED);
+  ColorSpace color_space = ColorSpace::CreateSRGB();
+  color_space = color_space.GetWithMatrixAndRange(
+      ColorSpace::MatrixID::SMPTE170M, ColorSpace::RangeID::LIMITED);
+  EXPECT_TRUE(expected_color_space.IsValid());
+  EXPECT_EQ(color_space, expected_color_space);
+}
+
+TEST(ColorSpace, MixedHDR10WithRec709) {
+  const ColorSpace expected_color_space = ColorSpace(
+      ColorSpace::PrimaryID::BT2020, ColorSpace::TransferID::SMPTEST2084,
+      ColorSpace::MatrixID::BT709, ColorSpace::RangeID::LIMITED);
+  ColorSpace color_space = ColorSpace::CreateHDR10();
+  color_space = color_space.GetWithMatrixAndRange(ColorSpace::MatrixID::BT709,
+                                                  ColorSpace::RangeID::LIMITED);
+  EXPECT_TRUE(expected_color_space.IsValid());
+  EXPECT_EQ(color_space, expected_color_space);
+}
+
+TEST(ColorSpace, GetsPrimariesTransferMatrixAndRange) {
+  ColorSpace color_space(
+      ColorSpace::PrimaryID::BT709, ColorSpace::TransferID::BT709,
+      ColorSpace::MatrixID::BT709, ColorSpace::RangeID::LIMITED);
+  EXPECT_EQ(color_space.GetPrimaryID(), ColorSpace::PrimaryID::BT709);
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::BT709);
+  EXPECT_EQ(color_space.GetMatrixID(), ColorSpace::MatrixID::BT709);
+  EXPECT_EQ(color_space.GetRangeID(), ColorSpace::RangeID::LIMITED);
+}
+
+TEST(ColorSpace, PQWhiteLevel) {
+  constexpr float kCustomWhiteLevel = 200.f;
+
+  ColorSpace color_space = ColorSpace::CreateHDR10(kCustomWhiteLevel);
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::SMPTEST2084);
+  float sdr_white_level;
+  EXPECT_TRUE(color_space.GetSDRWhiteLevel(&sdr_white_level));
+  EXPECT_EQ(sdr_white_level, kCustomWhiteLevel);
+
+  color_space = ColorSpace::CreateHDR10();
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::SMPTEST2084);
+  EXPECT_TRUE(color_space.GetSDRWhiteLevel(&sdr_white_level));
+  EXPECT_EQ(sdr_white_level, ColorSpace::kDefaultSDRWhiteLevel);
+
+  color_space = color_space.GetWithSDRWhiteLevel(kCustomWhiteLevel);
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::SMPTEST2084);
+  EXPECT_TRUE(color_space.GetSDRWhiteLevel(&sdr_white_level));
+  EXPECT_EQ(sdr_white_level, kCustomWhiteLevel);
+
+  constexpr float kCustomWhiteLevel2 = kCustomWhiteLevel * 2;
+  color_space = color_space.GetWithSDRWhiteLevel(kCustomWhiteLevel2);
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::SMPTEST2084);
+  EXPECT_TRUE(color_space.GetSDRWhiteLevel(&sdr_white_level));
+  EXPECT_EQ(sdr_white_level, kCustomWhiteLevel2);
+}
+
+TEST(ColorSpace, LinearHDRWhiteLevel) {
+  constexpr float kCustomWhiteLevel = 200.f;
+  constexpr float kCustomSlope =
+      ColorSpace::kDefaultScrgbLinearSdrWhiteLevel / kCustomWhiteLevel;
+
+  ColorSpace color_space = ColorSpace::CreateSCRGBLinear(kCustomWhiteLevel);
+  skcms_TransferFunction fn;
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::CUSTOM_HDR);
+  EXPECT_TRUE(color_space.GetTransferFunction(&fn));
+  EXPECT_EQ(std::make_tuple(fn.g, fn.a, fn.b, fn.c, fn.d, fn.e, fn.f),
+            std::make_tuple(1.f, kCustomSlope, 0.f, 0.f, 0.f, 0.f, 0.f));
+
+  color_space = ColorSpace::CreateSCRGBLinear();
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::LINEAR_HDR);
+  EXPECT_TRUE(color_space.GetTransferFunction(&fn));
+  EXPECT_EQ(std::make_tuple(fn.g, fn.a, fn.b, fn.c, fn.d, fn.e, fn.f),
+            std::make_tuple(1.f, 1.f, 0.f, 0.f, 0.f, 0.f, 0.f));
+
+  color_space = color_space.GetWithSDRWhiteLevel(kCustomWhiteLevel);
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::CUSTOM_HDR);
+  EXPECT_TRUE(color_space.GetTransferFunction(&fn));
+  EXPECT_EQ(std::make_tuple(fn.g, fn.a, fn.b, fn.c, fn.d, fn.e, fn.f),
+            std::make_tuple(1.f, kCustomSlope, 0.f, 0.f, 0.f, 0.f, 0.f));
+}
+
+TEST(ColorSpace, ExpectationsMatchSRGB) {
+  ColorSpace::PrimaryID primary_ids[] = {
+      ColorSpace::PrimaryID::BT709,
+      ColorSpace::PrimaryID::BT470M,
+      ColorSpace::PrimaryID::BT470BG,
+      ColorSpace::PrimaryID::SMPTE170M,
+      ColorSpace::PrimaryID::SMPTE240M,
+      ColorSpace::PrimaryID::FILM,
+      ColorSpace::PrimaryID::BT2020,
+      ColorSpace::PrimaryID::SMPTEST428_1,
+      ColorSpace::PrimaryID::SMPTEST431_2,
+      ColorSpace::PrimaryID::SMPTEST432_1,
+      ColorSpace::PrimaryID::XYZ_D50,
+      ColorSpace::PrimaryID::ADOBE_RGB,
+      ColorSpace::PrimaryID::APPLE_GENERIC_RGB,
+      ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN,
+  };
+
+  // Create a custom color space with the sRGB primary matrix.
+  ColorSpace srgb = ColorSpace::CreateSRGB();
+  skcms_Matrix3x3 to_XYZD50;
+  srgb.GetPrimaryMatrix(&to_XYZD50);
+  ColorSpace custom_srgb =
+      ColorSpace::CreateCustom(to_XYZD50, ColorSpace::TransferID::IEC61966_2_1);
+
+  for (auto id : primary_ids) {
+    ColorSpace color_space(id, ColorSpace::TransferID::IEC61966_2_1);
+    // The precomputed results for Contains(sRGB) should match the calculation
+    // performed on a custom color space with sRGB primaries.
+    EXPECT_EQ(color_space.Contains(srgb), color_space.Contains(custom_srgb));
+  }
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/color_space_win.cc b/ui/gfx/color_space_win.cc
new file mode 100644
index 0000000..03886d4
--- /dev/null
+++ b/ui/gfx/color_space_win.cc
@@ -0,0 +1,285 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/color_space_win.h"
+
+#include "base/logging.h"
+#include "third_party/skia/include/third_party/skcms/skcms.h"
+
+namespace gfx {
+
+DXVA2_ExtendedFormat ColorSpaceWin::GetExtendedFormat(
+    const ColorSpace& color_space) {
+  DXVA2_ExtendedFormat format;
+  memset(&format, 0, sizeof(format));
+  format.SampleFormat = DXVA2_SampleProgressiveFrame;
+  format.VideoLighting = DXVA2_VideoLighting_dim;
+  format.NominalRange = DXVA2_NominalRange_16_235;
+  format.VideoTransferMatrix = DXVA2_VideoTransferMatrix_BT709;
+  format.VideoPrimaries = DXVA2_VideoPrimaries_BT709;
+  format.VideoTransferFunction = DXVA2_VideoTransFunc_709;
+
+  switch (color_space.GetRangeID()) {
+    case gfx::ColorSpace::RangeID::LIMITED:
+      format.NominalRange = DXVA2_NominalRange_16_235;
+      break;
+    case gfx::ColorSpace::RangeID::FULL:
+      format.NominalRange = DXVA2_NominalRange_0_255;
+      break;
+
+    case gfx::ColorSpace::RangeID::DERIVED:
+    case gfx::ColorSpace::RangeID::INVALID:
+      // Not handled
+      break;
+  }
+
+  switch (color_space.GetMatrixID()) {
+    case gfx::ColorSpace::MatrixID::BT709:
+      format.VideoTransferMatrix = DXVA2_VideoTransferMatrix_BT709;
+      break;
+    case gfx::ColorSpace::MatrixID::BT470BG:
+    case gfx::ColorSpace::MatrixID::SMPTE170M:
+      format.VideoTransferMatrix = DXVA2_VideoTransferMatrix_BT601;
+      break;
+    case gfx::ColorSpace::MatrixID::SMPTE240M:
+      format.VideoTransferMatrix = DXVA2_VideoTransferMatrix_SMPTE240M;
+      break;
+
+    case gfx::ColorSpace::MatrixID::RGB:
+    case gfx::ColorSpace::MatrixID::GBR:
+    case gfx::ColorSpace::MatrixID::FCC:
+    case gfx::ColorSpace::MatrixID::YCOCG:
+    case gfx::ColorSpace::MatrixID::BT2020_NCL:
+    case gfx::ColorSpace::MatrixID::BT2020_CL:
+    case gfx::ColorSpace::MatrixID::YDZDX:
+    case gfx::ColorSpace::MatrixID::INVALID:
+      // Not handled
+      break;
+  }
+
+  switch (color_space.GetPrimaryID()) {
+    case gfx::ColorSpace::PrimaryID::BT709:
+      format.VideoPrimaries = DXVA2_VideoPrimaries_BT709;
+      break;
+    case gfx::ColorSpace::PrimaryID::BT470M:
+      format.VideoPrimaries = DXVA2_VideoPrimaries_BT470_2_SysM;
+      break;
+    case gfx::ColorSpace::PrimaryID::BT470BG:
+      format.VideoPrimaries = DXVA2_VideoPrimaries_BT470_2_SysBG;
+      break;
+    case gfx::ColorSpace::PrimaryID::SMPTE170M:
+      format.VideoPrimaries = DXVA2_VideoPrimaries_SMPTE170M;
+      break;
+    case gfx::ColorSpace::PrimaryID::SMPTE240M:
+      format.VideoPrimaries = DXVA2_VideoPrimaries_SMPTE240M;
+      break;
+
+    case gfx::ColorSpace::PrimaryID::FILM:
+    case gfx::ColorSpace::PrimaryID::BT2020:
+    case gfx::ColorSpace::PrimaryID::SMPTEST428_1:
+    case gfx::ColorSpace::PrimaryID::SMPTEST431_2:
+    case gfx::ColorSpace::PrimaryID::SMPTEST432_1:
+    case gfx::ColorSpace::PrimaryID::XYZ_D50:
+    case gfx::ColorSpace::PrimaryID::ADOBE_RGB:
+    case gfx::ColorSpace::PrimaryID::APPLE_GENERIC_RGB:
+    case gfx::ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN:
+    case gfx::ColorSpace::PrimaryID::CUSTOM:
+    case gfx::ColorSpace::PrimaryID::INVALID:
+      // Not handled
+      break;
+  }
+
+  switch (color_space.GetTransferID()) {
+    case gfx::ColorSpace::TransferID::BT709:
+    case gfx::ColorSpace::TransferID::SMPTE170M:
+      format.VideoTransferFunction = DXVA2_VideoTransFunc_709;
+      break;
+    case gfx::ColorSpace::TransferID::SMPTE240M:
+      format.VideoTransferFunction = DXVA2_VideoTransFunc_240M;
+      break;
+    case gfx::ColorSpace::TransferID::GAMMA22:
+      format.VideoTransferFunction = DXVA2_VideoTransFunc_22;
+      break;
+    case gfx::ColorSpace::TransferID::GAMMA28:
+      format.VideoTransferFunction = DXVA2_VideoTransFunc_28;
+      break;
+    case gfx::ColorSpace::TransferID::LINEAR:
+    case gfx::ColorSpace::TransferID::LINEAR_HDR:
+      format.VideoTransferFunction = DXVA2_VideoTransFunc_10;
+      break;
+    case gfx::ColorSpace::TransferID::IEC61966_2_1:
+    case gfx::ColorSpace::TransferID::IEC61966_2_1_HDR:
+      format.VideoTransferFunction = DXVA2_VideoTransFunc_sRGB;
+      break;
+
+    case gfx::ColorSpace::TransferID::LOG:
+    case gfx::ColorSpace::TransferID::LOG_SQRT:
+    case gfx::ColorSpace::TransferID::IEC61966_2_4:
+    case gfx::ColorSpace::TransferID::BT1361_ECG:
+    case gfx::ColorSpace::TransferID::BT2020_10:
+    case gfx::ColorSpace::TransferID::BT2020_12:
+    case gfx::ColorSpace::TransferID::SMPTEST2084:
+    case gfx::ColorSpace::TransferID::SMPTEST428_1:
+    case gfx::ColorSpace::TransferID::ARIB_STD_B67:
+    case gfx::ColorSpace::TransferID::BT709_APPLE:
+    case gfx::ColorSpace::TransferID::GAMMA18:
+    case gfx::ColorSpace::TransferID::GAMMA24:
+    case gfx::ColorSpace::TransferID::CUSTOM:
+    case gfx::ColorSpace::TransferID::CUSTOM_HDR:
+    case gfx::ColorSpace::TransferID::PIECEWISE_HDR:
+    case gfx::ColorSpace::TransferID::INVALID:
+      // Not handled
+      break;
+  }
+
+  return format;
+}
+
+DXGI_COLOR_SPACE_TYPE ColorSpaceWin::GetDXGIColorSpace(
+    const ColorSpace& color_space,
+    bool force_yuv) {
+  // Treat invalid color space as sRGB.
+  if (!color_space.IsValid())
+    return DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709;
+
+  if (color_space.GetMatrixID() == gfx::ColorSpace::MatrixID::RGB &&
+      !force_yuv) {
+    // For RGB, we default to FULL
+    if (color_space.GetRangeID() == gfx::ColorSpace::RangeID::LIMITED) {
+      if (color_space.GetPrimaryID() == gfx::ColorSpace::PrimaryID::BT2020) {
+        if (color_space.GetTransferID() ==
+            gfx::ColorSpace::TransferID::SMPTEST2084) {
+          return DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020;
+        } else {
+          return DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020;
+        }
+      } else {
+        return DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709;
+      }
+    } else {
+      if (color_space.GetPrimaryID() == gfx::ColorSpace::PrimaryID::BT2020) {
+        if (color_space.GetTransferID() ==
+            gfx::ColorSpace::TransferID::SMPTEST2084) {
+          return DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020;
+        } else {
+          return DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020;
+        }
+      } else {
+        if (color_space.GetTransferID() ==
+                gfx::ColorSpace::TransferID::LINEAR ||
+            color_space.GetTransferID() ==
+                gfx::ColorSpace::TransferID::LINEAR_HDR) {
+          return DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709;
+        } else if (color_space.GetTransferID() ==
+                   gfx::ColorSpace::TransferID::CUSTOM_HDR) {
+          skcms_TransferFunction fn;
+          color_space.GetTransferFunction(&fn);
+          if (fn.g == 1.f)
+            return DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709;
+          else
+            DLOG(ERROR) << "Windows HDR only supports gamma=1.0.";
+        }
+        return DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709;
+      }
+    }
+  } else {
+    if (color_space.GetPrimaryID() == gfx::ColorSpace::PrimaryID::BT2020) {
+      if (color_space.GetTransferID() ==
+          gfx::ColorSpace::TransferID::SMPTEST2084) {
+        return DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020;
+        // Could also be:
+        // DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020
+      } else if (color_space.GetTransferID() ==
+                 gfx::ColorSpace::TransferID::ARIB_STD_B67) {
+        // Note: This may not always work. See https://crbug.com/1144260#c6.
+        return DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020;
+      } else {
+        // For YUV, we default to LIMITED
+        if (color_space.GetRangeID() == gfx::ColorSpace::RangeID::FULL) {
+          return DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020;
+
+        } else {
+          return DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020;
+          // Could also be:
+          // DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020
+        }
+      }
+    } else if (color_space.GetPrimaryID() ==
+                   gfx::ColorSpace::PrimaryID::BT470BG ||
+               color_space.GetPrimaryID() ==
+                   gfx::ColorSpace::PrimaryID::SMPTE170M) {
+      // For YUV, we default to LIMITED
+      if (color_space.GetRangeID() == gfx::ColorSpace::RangeID::FULL) {
+        return DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601;
+      } else {
+        return DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601;
+      }
+    } else {
+      // For YUV, we default to LIMITED
+      if (color_space.GetRangeID() == gfx::ColorSpace::RangeID::FULL) {
+        // TODO(hubbe): Check if this is correct.
+        if (color_space.GetTransferID() ==
+            gfx::ColorSpace::TransferID::SMPTE170M) {
+          return DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601;
+        } else {
+          return DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709;
+        }
+      } else {
+        return DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709;
+      }
+    }
+  }
+}
+
+DXGI_FORMAT ColorSpaceWin::GetDXGIFormat(const gfx::ColorSpace& color_space) {
+  // The PQ transfer function needs 10 bits.
+  if (color_space.GetTransferID() == gfx::ColorSpace::TransferID::SMPTEST2084)
+    return DXGI_FORMAT_R10G10B10A2_UNORM;
+
+  // Non-PQ HDR color spaces use half-float.
+  if (color_space.IsHDR())
+    return DXGI_FORMAT_R16G16B16A16_FLOAT;
+
+  // For now just give everything else 8 bits. We will want to use 10 or 16 bits
+  // for BT2020 gamuts.
+  return DXGI_FORMAT_B8G8R8A8_UNORM;
+}
+
+D3D11_VIDEO_PROCESSOR_COLOR_SPACE ColorSpaceWin::GetD3D11ColorSpace(
+    const ColorSpace& color_space) {
+  D3D11_VIDEO_PROCESSOR_COLOR_SPACE ret = {0};
+  if (color_space.GetRangeID() == gfx::ColorSpace::RangeID::FULL) {
+    ret.RGB_Range = 0;  // FULL
+    ret.Nominal_Range = D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_0_255;
+  } else {
+    ret.RGB_Range = 1;  // LIMITED
+    ret.Nominal_Range = D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_16_235;
+  }
+
+  switch (color_space.GetMatrixID()) {
+    case gfx::ColorSpace::MatrixID::BT709:
+      ret.YCbCr_Matrix = 1;
+      break;
+
+    case gfx::ColorSpace::MatrixID::BT470BG:
+    case gfx::ColorSpace::MatrixID::SMPTE170M:
+      ret.YCbCr_Matrix = 0;
+      break;
+
+    case gfx::ColorSpace::MatrixID::SMPTE240M:
+    case gfx::ColorSpace::MatrixID::RGB:
+    case gfx::ColorSpace::MatrixID::GBR:
+    case gfx::ColorSpace::MatrixID::FCC:
+    case gfx::ColorSpace::MatrixID::YCOCG:
+    case gfx::ColorSpace::MatrixID::BT2020_NCL:
+    case gfx::ColorSpace::MatrixID::BT2020_CL:
+    case gfx::ColorSpace::MatrixID::YDZDX:
+    case gfx::ColorSpace::MatrixID::INVALID:
+      // Not handled
+      break;
+  }
+  return ret;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/color_space_win.h b/ui/gfx/color_space_win.h
new file mode 100644
index 0000000..1c71891
--- /dev/null
+++ b/ui/gfx/color_space_win.h
@@ -0,0 +1,47 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_COLOR_SPACE_WIN_H_
+#define UI_GFX_COLOR_SPACE_WIN_H_
+
+#include <d3d11.h>
+#include <d3d9.h>
+
+// Must be included after d3d headers, use #if to avoid lint errors.
+#if 1
+#include <DXGIType.h>
+#endif
+
+// Work around bug in this header by disabling the relevant warning for it.
+// https://connect.microsoft.com/VisualStudio/feedback/details/911260/dxva2api-h-in-win8-sdk-triggers-c4201-with-w4
+#pragma warning(push)
+#pragma warning(disable : 4201)
+#include <dxva2api.h>
+#pragma warning(pop)
+
+#include "ui/gfx/color_space.h"
+
+namespace gfx {
+
+class COLOR_SPACE_EXPORT ColorSpaceWin {
+ public:
+  static DXVA2_ExtendedFormat GetExtendedFormat(const ColorSpace& color_space);
+
+  // Returns a DXGI_COLOR_SPACE value based on the primaries and transfer
+  // function of |color_space|. If the color space's MatrixID is RGB, then the
+  // returned color space is also RGB unless |force_yuv| is true in which case
+  // it is a YUV color space.
+  static DXGI_COLOR_SPACE_TYPE GetDXGIColorSpace(const ColorSpace& color_space,
+                                                 bool force_yuv = false);
+
+  // Get DXGI format for swap chain. This will default to 8-bit, but will use
+  // 10-bit or half-float for HDR color spaces.
+  static DXGI_FORMAT GetDXGIFormat(const gfx::ColorSpace& color_space);
+
+  static D3D11_VIDEO_PROCESSOR_COLOR_SPACE GetD3D11ColorSpace(
+      const ColorSpace& color_space);
+};
+
+}  // namespace gfx
+#endif  // UI_GFX_COLOR_SPACE_WIN_H_
diff --git a/ui/gfx/color_transform.cc b/ui/gfx/color_transform.cc
new file mode 100644
index 0000000..f53eb60
--- /dev/null
+++ b/ui/gfx/color_transform.cc
@@ -0,0 +1,1139 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/color_transform.h"
+
+#include <algorithm>
+#include <cmath>
+#include <list>
+#include <memory>
+#include <sstream>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/notreached.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/third_party/skcms/skcms.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/icc_profile.h"
+#include "ui/gfx/skia_color_space_util.h"
+
+using std::abs;
+using std::copysign;
+using std::endl;
+using std::exp;
+using std::log;
+using std::max;
+using std::min;
+using std::pow;
+using std::sqrt;
+
+namespace gfx {
+
+namespace {
+
+void InitStringStream(std::stringstream* ss) {
+  ss->imbue(std::locale::classic());
+  ss->precision(8);
+  *ss << std::scientific;
+}
+
+std::string Str(float f) {
+  std::stringstream ss;
+  InitStringStream(&ss);
+  ss << f;
+  return ss.str();
+}
+
+Transform Invert(const Transform& t) {
+  Transform ret = t;
+  if (!t.GetInverse(&ret)) {
+    LOG(ERROR) << "Inverse should always be possible.";
+  }
+  return ret;
+}
+
+float FromLinear(ColorSpace::TransferID id, float v) {
+  switch (id) {
+    case ColorSpace::TransferID::LOG:
+      if (v < 0.01f)
+        return 0.0f;
+      return 1.0f + log(v) / log(10.0f) / 2.0f;
+
+    case ColorSpace::TransferID::LOG_SQRT:
+      if (v < sqrt(10.0f) / 1000.0f)
+        return 0.0f;
+      return 1.0f + log(v) / log(10.0f) / 2.5f;
+
+    case ColorSpace::TransferID::IEC61966_2_4: {
+      float a = 1.099296826809442f;
+      float b = 0.018053968510807f;
+      if (v < -b)
+        return -a * pow(-v, 0.45f) + (a - 1.0f);
+      else if (v <= b)
+        return 4.5f * v;
+      return a * pow(v, 0.45f) - (a - 1.0f);
+    }
+
+    case ColorSpace::TransferID::BT1361_ECG: {
+      float a = 1.099f;
+      float b = 0.018f;
+      float l = 0.0045f;
+      if (v < -l)
+        return -(a * pow(-4.0f * v, 0.45f) + (a - 1.0f)) / 4.0f;
+      else if (v <= b)
+        return 4.5f * v;
+      else
+        return a * pow(v, 0.45f) - (a - 1.0f);
+    }
+
+    default:
+      // Handled by skcms_TransferFunction.
+      break;
+  }
+  NOTREACHED();
+  return 0;
+}
+
+float ToLinear(ColorSpace::TransferID id, float v) {
+  switch (id) {
+    case ColorSpace::TransferID::LOG:
+      if (v < 0.0f)
+        return 0.0f;
+      return pow(10.0f, (v - 1.0f) * 2.0f);
+
+    case ColorSpace::TransferID::LOG_SQRT:
+      if (v < 0.0f)
+        return 0.0f;
+      return pow(10.0f, (v - 1.0f) * 2.5f);
+
+    case ColorSpace::TransferID::IEC61966_2_4: {
+      float a = 1.099296826809442f;
+      // Equal to FromLinear(ColorSpace::TransferID::IEC61966_2_4, -a).
+      float from_linear_neg_a = -1.047844f;
+      // Equal to FromLinear(ColorSpace::TransferID::IEC61966_2_4, b).
+      float from_linear_b = 0.081243f;
+      if (v < from_linear_neg_a)
+        return -pow((a - 1.0f - v) / a, 1.0f / 0.45f);
+      else if (v <= from_linear_b)
+        return v / 4.5f;
+      return pow((v + a - 1.0f) / a, 1.0f / 0.45f);
+    }
+
+    case ColorSpace::TransferID::BT1361_ECG: {
+      float a = 1.099f;
+      // Equal to FromLinear(ColorSpace::TransferID::BT1361_ECG, -l).
+      float from_linear_neg_l = -0.020250f;
+      // Equal to FromLinear(ColorSpace::TransferID::BT1361_ECG, b).
+      float from_linear_b = 0.081000f;
+      if (v < from_linear_neg_l)
+        return -pow((1.0f - a - v * 4.0f) / a, 1.0f / 0.45f) / 4.0f;
+      else if (v <= from_linear_b)
+        return v / 4.5f;
+      return pow((v + a - 1.0f) / a, 1.0f / 0.45f);
+    }
+
+    default:
+      // Handled by skcms_TransferFunction.
+      break;
+  }
+  NOTREACHED();
+  return 0;
+}
+
+Transform GetTransferMatrix(const gfx::ColorSpace& color_space, int bit_depth) {
+  skia::Matrix44 transfer_matrix;
+  color_space.GetTransferMatrix(bit_depth, &transfer_matrix);
+  return Transform(transfer_matrix);
+}
+
+Transform GetRangeAdjustMatrix(const gfx::ColorSpace& color_space,
+                               int bit_depth) {
+  skia::Matrix44 range_adjust_matrix;
+  color_space.GetRangeAdjustMatrix(bit_depth, &range_adjust_matrix);
+  return Transform(range_adjust_matrix);
+}
+
+Transform GetPrimaryTransform(const gfx::ColorSpace& color_space) {
+  skia::Matrix44 primary_matrix;
+  color_space.GetPrimaryMatrix(&primary_matrix);
+  return Transform(primary_matrix);
+}
+
+}  // namespace
+
+class ColorTransformMatrix;
+class ColorTransformSkTransferFn;
+class ColorTransformFromLinear;
+class ColorTransformFromBT2020CL;
+class ColorTransformNull;
+
+class ColorTransformStep {
+ public:
+  ColorTransformStep() {}
+
+  ColorTransformStep(const ColorTransformStep&) = delete;
+  ColorTransformStep& operator=(const ColorTransformStep&) = delete;
+
+  virtual ~ColorTransformStep() {}
+  virtual ColorTransformFromLinear* GetFromLinear() { return nullptr; }
+  virtual ColorTransformFromBT2020CL* GetFromBT2020CL() { return nullptr; }
+  virtual ColorTransformSkTransferFn* GetSkTransferFn() { return nullptr; }
+  virtual ColorTransformMatrix* GetMatrix() { return nullptr; }
+  virtual ColorTransformNull* GetNull() { return nullptr; }
+
+  // Join methods, returns true if the |next| transform was successfully
+  // assimilated into |this|.
+  // If Join() returns true, |next| is no longer needed and can be deleted.
+  virtual bool Join(ColorTransformStep* next) { return false; }
+
+  // Return true if this is a null transform.
+  virtual bool IsNull() { return false; }
+  virtual void Transform(ColorTransform::TriStim* color, size_t num) const = 0;
+  // In the shader, |hdr| will appear before |src|, so any helper functions that
+  // are created should be put in |hdr|. Any helper functions should have
+  // |step_index| included in the function name, to ensure that there are no
+  // naming conflicts.
+  virtual void AppendShaderSource(std::stringstream* hdr,
+                                  std::stringstream* src,
+                                  size_t step_index) const = 0;
+  virtual void AppendSkShaderSource(std::stringstream* src) const = 0;
+};
+
+class ColorTransformInternal : public ColorTransform {
+ public:
+  ColorTransformInternal(const ColorSpace& src,
+                         const ColorSpace& dst,
+                         const Options& options);
+  ~ColorTransformInternal() override;
+
+  gfx::ColorSpace GetSrcColorSpace() const override { return src_; }
+  gfx::ColorSpace GetDstColorSpace() const override { return dst_; }
+
+  void Transform(TriStim* colors, size_t num) const override {
+    for (const auto& step : steps_) {
+      step->Transform(colors, num);
+    }
+  }
+  std::string GetShaderSource() const override;
+  std::string GetSkShaderSource() const override;
+  bool IsIdentity() const override { return steps_.empty(); }
+  size_t NumberOfStepsForTesting() const override { return steps_.size(); }
+
+ private:
+  void AppendColorSpaceToColorSpaceTransform(const ColorSpace& src,
+                                             const ColorSpace& dst,
+                                             const Options& options);
+  void Simplify();
+
+  std::list<std::unique_ptr<ColorTransformStep>> steps_;
+  gfx::ColorSpace src_;
+  gfx::ColorSpace dst_;
+};
+
+class ColorTransformNull : public ColorTransformStep {
+ public:
+  ColorTransformNull* GetNull() override { return this; }
+  bool IsNull() override { return true; }
+  void Transform(ColorTransform::TriStim* color, size_t num) const override {}
+  void AppendShaderSource(std::stringstream* hdr,
+                          std::stringstream* src,
+                          size_t step_index) const override {}
+  void AppendSkShaderSource(std::stringstream* src) const override {}
+};
+
+class ColorTransformMatrix : public ColorTransformStep {
+ public:
+  explicit ColorTransformMatrix(const class Transform& matrix)
+      : matrix_(matrix) {}
+  ColorTransformMatrix* GetMatrix() override { return this; }
+  bool Join(ColorTransformStep* next_untyped) override {
+    ColorTransformMatrix* next = next_untyped->GetMatrix();
+    if (!next)
+      return false;
+    class Transform tmp = next->matrix_;
+    tmp *= matrix_;
+    matrix_ = tmp;
+    return true;
+  }
+
+  bool IsNull() override {
+    return SkMatrixIsApproximatelyIdentity(matrix_.matrix());
+  }
+
+  void Transform(ColorTransform::TriStim* colors, size_t num) const override {
+    for (size_t i = 0; i < num; i++)
+      matrix_.TransformPoint(colors + i);
+  }
+
+  void AppendShaderSource(std::stringstream* hdr,
+                          std::stringstream* src,
+                          size_t step_index) const override {
+    const skia::Matrix44& m = matrix_.matrix();
+    *src << "  color = mat3(";
+    *src << m.get(0, 0) << ", " << m.get(1, 0) << ", " << m.get(2, 0) << ",";
+    *src << endl;
+    *src << "               ";
+    *src << m.get(0, 1) << ", " << m.get(1, 1) << ", " << m.get(2, 1) << ",";
+    *src << endl;
+    *src << "               ";
+    *src << m.get(0, 2) << ", " << m.get(1, 2) << ", " << m.get(2, 2) << ")";
+    *src << " * color;" << endl;
+
+    // Only print the translational component if it isn't the identity.
+    if (m.get(0, 3) != 0.f || m.get(1, 3) != 0.f || m.get(2, 3) != 0.f) {
+      *src << "  color += vec3(";
+      *src << m.get(0, 3) << ", " << m.get(1, 3) << ", " << m.get(2, 3);
+      *src << ");" << endl;
+    }
+  }
+
+  void AppendSkShaderSource(std::stringstream* src) const override {
+    const skia::Matrix44& m = matrix_.matrix();
+    *src << "  color = half4x4(";
+    *src << m.get(0, 0) << ", " << m.get(1, 0) << ", " << m.get(2, 0) << ", 0,";
+    *src << endl;
+    *src << "               ";
+    *src << m.get(0, 1) << ", " << m.get(1, 1) << ", " << m.get(2, 1) << ", 0,";
+    *src << endl;
+    *src << "               ";
+    *src << m.get(0, 2) << ", " << m.get(1, 2) << ", " << m.get(2, 2) << ", 0,";
+    *src << endl;
+    *src << "0, 0, 0, 1)";
+    *src << " * color;" << endl;
+
+    // Only print the translational component if it isn't the identity.
+    if (m.get(0, 3) != 0.f || m.get(1, 3) != 0.f || m.get(2, 3) != 0.f) {
+      *src << "  color += half4(";
+      *src << m.get(0, 3) << ", " << m.get(1, 3) << ", " << m.get(2, 3);
+      *src << ", 0);" << endl;
+    }
+  }
+
+ private:
+  class Transform matrix_;
+};
+
+class ColorTransformPerChannelTransferFn : public ColorTransformStep {
+ public:
+  explicit ColorTransformPerChannelTransferFn(bool extended)
+      : extended_(extended) {}
+
+  void Transform(ColorTransform::TriStim* colors, size_t num) const override {
+    for (size_t i = 0; i < num; i++) {
+      ColorTransform::TriStim& c = colors[i];
+      if (extended_) {
+        c.set_x(copysign(Evaluate(abs(c.x())), c.x()));
+        c.set_y(copysign(Evaluate(abs(c.y())), c.y()));
+        c.set_z(copysign(Evaluate(abs(c.z())), c.z()));
+      } else {
+        c.set_x(Evaluate(c.x()));
+        c.set_y(Evaluate(c.y()));
+        c.set_z(Evaluate(c.z()));
+      }
+    }
+  }
+
+  void AppendShaderSource(std::stringstream* hdr,
+                          std::stringstream* src,
+                          size_t step_index) const override {
+    *hdr << "float TransferFn" << step_index << "(float v) {" << endl;
+    AppendTransferShaderSource(hdr, true /* is_glsl */);
+    *hdr << "  return v;" << endl;
+    *hdr << "}" << endl;
+    if (extended_) {
+      *src << "  color.r = sign(color.r) * TransferFn" << step_index
+           << "(abs(color.r));" << endl;
+      *src << "  color.g = sign(color.g) * TransferFn" << step_index
+           << "(abs(color.g));" << endl;
+      *src << "  color.b = sign(color.b) * TransferFn" << step_index
+           << "(abs(color.b));" << endl;
+    } else {
+      *src << "  color.r = TransferFn" << step_index << "(color.r);" << endl;
+      *src << "  color.g = TransferFn" << step_index << "(color.g);" << endl;
+      *src << "  color.b = TransferFn" << step_index << "(color.b);" << endl;
+    }
+  }
+
+  void AppendSkShaderSource(std::stringstream* src) const override {
+    if (extended_) {
+      *src << "{  half v = abs(color.r);" << endl;
+      AppendTransferShaderSource(src, false /* is_glsl */);
+      *src << "  color.r = sign(color.r) * v; }" << endl;
+      *src << "{  half v = abs(color.g);" << endl;
+      AppendTransferShaderSource(src, false /* is_glsl */);
+      *src << "  color.g = sign(color.g) * v; }" << endl;
+      *src << "{  half v = abs(color.b);" << endl;
+      AppendTransferShaderSource(src, false /* is_glsl */);
+      *src << "  color.b = sign(color.b) * v; }" << endl;
+    } else {
+      *src << "{  half v = color.r;" << endl;
+      AppendTransferShaderSource(src, false /* is_glsl */);
+      *src << "  color.r = v; }" << endl;
+      *src << "{  half v = color.g;" << endl;
+      AppendTransferShaderSource(src, false /* is_glsl */);
+      *src << "  color.g = v; }" << endl;
+      *src << "{  half v = color.b;" << endl;
+      AppendTransferShaderSource(src, false /* is_glsl */);
+      *src << "  color.b = v; }" << endl;
+    }
+  }
+
+  virtual float Evaluate(float x) const = 0;
+  virtual void AppendTransferShaderSource(std::stringstream* src,
+                                          bool is_glsl) const = 0;
+
+ protected:
+  // True if the transfer function is extended to be defined for all real
+  // values by point symmetry.
+  bool extended_ = false;
+};
+
+// This class represents the piecewise-HDR function using three new parameters,
+// P, Q, and R. The function is defined as:
+//            0         : x < 0
+//     T(x) = sRGB(x/P) : x < P
+//            Q*x+R     : x >= P
+// This then expands to
+//            0                : x < 0
+//     T(x) = C*x/P+F          : x < P*D
+//            (A*x/P+B)**G + E : x < P
+//            Q*x+R            : else
+class ColorTransformPiecewiseHDR : public ColorTransformPerChannelTransferFn {
+ public:
+  static void GetParams(const gfx::ColorSpace color_space,
+                        skcms_TransferFunction* fn,
+                        float* p,
+                        float* q,
+                        float* r) {
+    float sdr_joint = 1;
+    float hdr_level = 1;
+    color_space.GetPiecewiseHDRParams(&sdr_joint, &hdr_level);
+
+    // P is exactly |sdr_joint|.
+    *p = sdr_joint;
+
+    if (sdr_joint < 1.f) {
+      // Q and R are computed such that |sdr_joint| maps to 1 and 1) maps to
+      // |hdr_level|.
+      *q = (hdr_level - 1.f) / (1.f - sdr_joint);
+      *r = (1.f - hdr_level * sdr_joint) / (1.f - sdr_joint);
+    } else {
+      // If |sdr_joint| is exactly 1, then just saturate at 1 (there is no HDR).
+      *q = 0;
+      *r = 1;
+    }
+
+    // Compute |fn| so that, at x, it evaluates to sRGB(x*P).
+    ColorSpace::CreateSRGB().GetTransferFunction(fn);
+    fn->d *= sdr_joint;
+    if (sdr_joint != 0) {
+      // If |sdr_joint| is 0, then we will never evaluate |fn| anyway.
+      fn->a /= sdr_joint;
+      fn->c /= sdr_joint;
+    }
+  }
+  static void InvertParams(skcms_TransferFunction* fn,
+                           float* p,
+                           float* q,
+                           float* r) {
+    *fn = SkTransferFnInverse(*fn);
+    float old_p = *p;
+    float old_q = *q;
+    float old_r = *r;
+    *p = old_q * old_p + old_r;
+    if (old_q != 0.f) {
+      *q = 1.f / old_q;
+      *r = -old_r / old_q;
+    } else {
+      *q = 0.f;
+      *r = 1.f;
+    }
+  }
+
+  ColorTransformPiecewiseHDR(const skcms_TransferFunction fn,
+                             float p,
+                             float q,
+                             float r)
+      : ColorTransformPerChannelTransferFn(false),
+        fn_(fn),
+        p_(p),
+        q_(q),
+        r_(r) {}
+
+  // ColorTransformPerChannelTransferFn implementation:
+  float Evaluate(float v) const override {
+    if (v < 0)
+      return 0;
+    else if (v < fn_.d)
+      return fn_.c * v + fn_.f;
+    else if (v < p_)
+      return std::pow(fn_.a * v + fn_.b, fn_.g) + fn_.e;
+    else
+      return q_ * v + r_;
+  }
+  void AppendTransferShaderSource(std::stringstream* result,
+                                  bool is_glsl) const override {
+    *result << "  if (v < 0.0) {\n";
+    *result << "    v = 0.0;\n";
+    *result << "  } else if (v < " << Str(fn_.d) << ") {\n";
+    *result << "    v = " << Str(fn_.c) << " * v + " << Str(fn_.f) << ";"
+            << endl;
+    *result << "  } else if (v < " << Str(p_) << ") {\n";
+    *result << "    v = pow(" << Str(fn_.a) << " * v + " << Str(fn_.b) << ", "
+            << Str(fn_.g) << ") + " << Str(fn_.e) << ";\n";
+    *result << "  } else {\n";
+    *result << "    v = " << Str(q_) << " * v + " << Str(r_) << ";\n";
+    *result << "  }\n";
+  }
+
+ private:
+  // Parameters of the SDR part.
+  const skcms_TransferFunction fn_;
+  // The SDR joint. Below this value in the domain, the function is defined by
+  // |fn_|.
+  const float p_;
+  // The slope of the linear HDR part.
+  const float q_;
+  // The intercept of the linear HDR part.
+  const float r_;
+};
+
+class ColorTransformSkTransferFn : public ColorTransformPerChannelTransferFn {
+ public:
+  explicit ColorTransformSkTransferFn(const skcms_TransferFunction& fn,
+                                      bool extended)
+      : ColorTransformPerChannelTransferFn(extended), fn_(fn) {}
+  // ColorTransformStep implementation.
+  ColorTransformSkTransferFn* GetSkTransferFn() override { return this; }
+  bool Join(ColorTransformStep* next_untyped) override {
+    ColorTransformSkTransferFn* next = next_untyped->GetSkTransferFn();
+    if (!next)
+      return false;
+    if (!extended_ && !next->extended_ &&
+        SkTransferFnsApproximatelyCancel(fn_, next->fn_)) {
+      // Set to be the identity.
+      fn_.a = 1;
+      fn_.b = 0;
+      fn_.c = 1;
+      fn_.d = 0;
+      fn_.e = 0;
+      fn_.f = 0;
+      fn_.g = 1;
+      return true;
+    }
+    return false;
+  }
+  bool IsNull() override { return SkTransferFnIsApproximatelyIdentity(fn_); }
+
+  // ColorTransformPerChannelTransferFn implementation:
+  float Evaluate(float v) const override {
+    // Note that the sign-extension is performed by the caller.
+    return SkTransferFnEvalUnclamped(fn_, v);
+  }
+  void AppendTransferShaderSource(std::stringstream* result,
+                                  bool is_glsl) const override {
+    const float kEpsilon = 1.f / 1024.f;
+
+    // Construct the linear segment
+    //   linear = C * x + F
+    // Elide operations that will be close to the identity.
+    std::string linear = "v";
+    if (std::abs(fn_.c - 1.f) > kEpsilon)
+      linear = Str(fn_.c) + " * " + linear;
+    if (std::abs(fn_.f) > kEpsilon)
+      linear = linear + " + " + Str(fn_.f);
+
+    // Construct the nonlinear segment.
+    //   nonlinear = pow(A * x + B, G) + E
+    // Elide operations (especially the pow) that will be close to the
+    // identity.
+    std::string nonlinear = "v";
+    if (std::abs(fn_.a - 1.f) > kEpsilon)
+      nonlinear = Str(fn_.a) + " * " + nonlinear;
+    if (std::abs(fn_.b) > kEpsilon)
+      nonlinear = nonlinear + " + " + Str(fn_.b);
+    if (std::abs(fn_.g - 1.f) > kEpsilon)
+      nonlinear = "pow(" + nonlinear + ", " + Str(fn_.g) + ")";
+    if (std::abs(fn_.e) > kEpsilon)
+      nonlinear = nonlinear + " + " + Str(fn_.e);
+
+    *result << "  if (v < " << Str(fn_.d) << ")" << endl;
+    *result << "    v = " << linear << ";" << endl;
+    *result << "  else" << endl;
+    *result << "    v = " << nonlinear << ";" << endl;
+  }
+
+ private:
+  skcms_TransferFunction fn_;
+};
+
+class ColorTransformHLGFromLinear : public ColorTransformPerChannelTransferFn {
+ public:
+  explicit ColorTransformHLGFromLinear(float sdr_white_level)
+      : ColorTransformPerChannelTransferFn(false),
+        sdr_scale_factor_(sdr_white_level /
+                          gfx::ColorSpace::kDefaultSDRWhiteLevel) {}
+
+  // ColorTransformPerChannelTransferFn implementation:
+  float Evaluate(float v) const override {
+    v *= sdr_scale_factor_;
+
+    // Spec: http://www.arib.or.jp/english/html/overview/doc/2-STD-B67v1_0.pdf
+    constexpr float a = 0.17883277f;
+    constexpr float b = 0.28466892f;
+    constexpr float c = 0.55991073f;
+    v = max(0.0f, v);
+    if (v <= 1)
+      return 0.5f * sqrt(v);
+    return a * log(v - b) + c;
+  }
+
+  void AppendTransferShaderSource(std::stringstream* src,
+                                  bool is_glsl) const override {
+    std::string scalar_type = is_glsl ? "float" : "half";
+    *src << "  v = v * " << sdr_scale_factor_ << ";\n"
+         << "  v = max(0.0, v);\n"
+         << "  " << scalar_type << " a = 0.17883277;\n"
+         << "  " << scalar_type << " b = 0.28466892;\n"
+         << "  " << scalar_type << " c = 0.55991073;\n"
+         << "  if (v <= 1.0)\n"
+            "    v = 0.5 * sqrt(v);\n"
+            "  else\n"
+            "    v = a * log(v - b) + c;\n";
+  }
+
+ private:
+  const float sdr_scale_factor_;
+};
+
+class ColorTransformPQFromLinear : public ColorTransformPerChannelTransferFn {
+ public:
+  explicit ColorTransformPQFromLinear(float sdr_white_level)
+      : ColorTransformPerChannelTransferFn(false),
+        sdr_white_level_(sdr_white_level) {}
+
+  // ColorTransformPerChannelTransferFn implementation:
+  float Evaluate(float v) const override {
+    v *= sdr_white_level_ / 10000.0f;
+    v = max(0.0f, v);
+    float m1 = (2610.0f / 4096.0f) / 4.0f;
+    float m2 = (2523.0f / 4096.0f) * 128.0f;
+    float c1 = 3424.0f / 4096.0f;
+    float c2 = (2413.0f / 4096.0f) * 32.0f;
+    float c3 = (2392.0f / 4096.0f) * 32.0f;
+    float p = powf(v, m1);
+    return powf((c1 + c2 * p) / (1.0f + c3 * p), m2);
+  }
+  void AppendTransferShaderSource(std::stringstream* src,
+                                  bool is_glsl) const override {
+    std::string scalar_type = is_glsl ? "float" : "half";
+    *src << "  v *= " << sdr_white_level_
+         << " / 10000.0;\n"
+            "  v = max(0.0, v);\n"
+         << "  " << scalar_type << " m1 = (2610.0 / 4096.0) / 4.0;\n"
+         << "  " << scalar_type << " m2 = (2523.0 / 4096.0) * 128.0;\n"
+         << "  " << scalar_type << " c1 = 3424.0 / 4096.0;\n"
+         << "  " << scalar_type << " c2 = (2413.0 / 4096.0) * 32.0;\n"
+         << "  " << scalar_type
+         << " c3 = (2392.0 / 4096.0) * 32.0;\n"
+            "  v =  pow((c1 + c2 * pow(v, m1)) / \n"
+            "           (1.0 + c3 * pow(v, m1)), m2);\n";
+  }
+
+ private:
+  const float sdr_white_level_;
+};
+
+class ColorTransformHLGToLinear : public ColorTransformPerChannelTransferFn {
+ public:
+  explicit ColorTransformHLGToLinear(float sdr_white_level)
+      : ColorTransformPerChannelTransferFn(false),
+        sdr_scale_factor_(gfx::ColorSpace::kDefaultSDRWhiteLevel /
+                          sdr_white_level) {}
+
+  // ColorTransformPerChannelTransferFn implementation:
+  float Evaluate(float v) const override {
+    // Spec: http://www.arib.or.jp/english/html/overview/doc/2-STD-B67v1_0.pdf
+    v = max(0.0f, v);
+    constexpr float a = 0.17883277f;
+    constexpr float b = 0.28466892f;
+    constexpr float c = 0.55991073f;
+    if (v <= 0.5f)
+      v = v * v * 4.0f;
+    else
+      v = exp((v - c) / a) + b;
+    return v * sdr_scale_factor_;
+  }
+
+  void AppendTransferShaderSource(std::stringstream* src,
+                                  bool is_glsl) const override {
+    std::string scalar_type = is_glsl ? "float" : "half";
+
+    *src << "  v = max(0.0, v);\n"
+         << "  " << scalar_type << " a = 0.17883277;\n"
+         << "  " << scalar_type << " b = 0.28466892;\n"
+         << "  " << scalar_type << " c = 0.55991073;\n"
+         << "  if (v <= 0.5)\n"
+            "    v = v * v * 4.0;\n"
+            "  else\n"
+            "    v = exp((v - c) / a) + b;\n"
+            "  v = v * "
+         << sdr_scale_factor_ << ";\n";
+  }
+
+ private:
+  const float sdr_scale_factor_;
+};
+
+class ColorTransformPQToLinear : public ColorTransformPerChannelTransferFn {
+ public:
+  explicit ColorTransformPQToLinear(float sdr_white_level)
+      : ColorTransformPerChannelTransferFn(false),
+        sdr_white_level_(sdr_white_level) {}
+
+  // ColorTransformPerChannelTransferFn implementation:
+  float Evaluate(float v) const override {
+    v = max(0.0f, v);
+    float m1 = (2610.0f / 4096.0f) / 4.0f;
+    float m2 = (2523.0f / 4096.0f) * 128.0f;
+    float c1 = 3424.0f / 4096.0f;
+    float c2 = (2413.0f / 4096.0f) * 32.0f;
+    float c3 = (2392.0f / 4096.0f) * 32.0f;
+    float p = pow(v, 1.0f / m2);
+    v = powf(max(p - c1, 0.0f) / (c2 - c3 * p), 1.0f / m1);
+    v *= 10000.0f / sdr_white_level_;
+    return v;
+  }
+  void AppendTransferShaderSource(std::stringstream* src,
+                                  bool is_glsl) const override {
+    std::string scalar_type = is_glsl ? "float" : "half";
+    *src << "  v = max(0.0, v);\n"
+         << "  " << scalar_type << " m1 = (2610.0 / 4096.0) / 4.0;\n"
+         << "  " << scalar_type << " m2 = (2523.0 / 4096.0) * 128.0;\n"
+         << "  " << scalar_type << " c1 = 3424.0 / 4096.0;\n"
+         << "  " << scalar_type << " c2 = (2413.0 / 4096.0) * 32.0;\n"
+         << "  " << scalar_type << " c3 = (2392.0 / 4096.0) * 32.0;\n";
+    if (is_glsl) {
+      *src << "  #ifdef GL_FRAGMENT_PRECISION_HIGH\n"
+              "  highp float v2 = v;\n"
+              "  #else\n"
+              "  float v2 = v;\n"
+              "  #endif\n";
+    } else {
+      *src << "  " << scalar_type << " v2 = v;\n";
+    }
+    *src << "  v2 = pow(max(pow(v2, 1.0 / m2) - c1, 0.0) /\n"
+            "              (c2 - c3 * pow(v2, 1.0 / m2)), 1.0 / m1);\n"
+            "  v = v2 * 10000.0 / "
+         << sdr_white_level_ << ";\n";
+  }
+
+ private:
+  const float sdr_white_level_;
+};
+
+class ColorTransformFromLinear : public ColorTransformPerChannelTransferFn {
+ public:
+  // ColorTransformStep implementation.
+  explicit ColorTransformFromLinear(ColorSpace::TransferID transfer)
+      : ColorTransformPerChannelTransferFn(false), transfer_(transfer) {}
+  ColorTransformFromLinear* GetFromLinear() override { return this; }
+  bool IsNull() override { return transfer_ == ColorSpace::TransferID::LINEAR; }
+
+  // ColorTransformPerChannelTransferFn implementation:
+  float Evaluate(float v) const override { return FromLinear(transfer_, v); }
+  void AppendTransferShaderSource(std::stringstream* src,
+                                  bool is_glsl) const override {
+    std::string scalar_type = is_glsl ? "float" : "half";
+    // This is a string-ized copy-paste from FromLinear.
+    switch (transfer_) {
+      case ColorSpace::TransferID::LOG:
+        *src << "  if (v < 0.01)\n"
+                "    v = 0.0;\n"
+                "  else\n"
+                "    v =  1.0 + log(v) / log(10.0) / 2.0;\n";
+        return;
+      case ColorSpace::TransferID::LOG_SQRT:
+        *src << "  if (v < sqrt(10.0) / 1000.0)\n"
+                "    v = 0.0;\n"
+                "  else\n"
+                "    v = 1.0 + log(v) / log(10.0) / 2.5;\n";
+        return;
+      case ColorSpace::TransferID::IEC61966_2_4:
+        *src << "  " << scalar_type << " a = 1.099296826809442;\n"
+             << "  " << scalar_type << " b = 0.018053968510807;\n"
+             << "  if (v < -b)\n"
+                "    v = -a * pow(-v, 0.45) + (a - 1.0);\n"
+                "  else if (v <= b)\n"
+                "    v = 4.5 * v;\n"
+                "  else\n"
+                "    v = a * pow(v, 0.45) - (a - 1.0);\n";
+        return;
+      case ColorSpace::TransferID::BT1361_ECG:
+        *src << "  " << scalar_type << " a = 1.099;\n"
+             << "  " << scalar_type << " b = 0.018;\n"
+             << "  " << scalar_type << " l = 0.0045;\n"
+             << "  if (v < -l)\n"
+                "    v = -(a * pow(-4.0 * v, 0.45) + (a - 1.0)) / 4.0;\n"
+                "  else if (v <= b)\n"
+                "    v = 4.5 * v;\n"
+                "  else\n"
+                "    v = a * pow(v, 0.45) - (a - 1.0);\n";
+        return;
+      default:
+        break;
+    }
+    NOTREACHED();
+  }
+
+ private:
+  friend class ColorTransformToLinear;
+  ColorSpace::TransferID transfer_;
+};
+
+class ColorTransformToLinear : public ColorTransformPerChannelTransferFn {
+ public:
+  explicit ColorTransformToLinear(ColorSpace::TransferID transfer)
+      : ColorTransformPerChannelTransferFn(false), transfer_(transfer) {}
+  // ColorTransformStep implementation:
+  bool Join(ColorTransformStep* next_untyped) override {
+    ColorTransformFromLinear* next = next_untyped->GetFromLinear();
+    if (!next)
+      return false;
+    if (transfer_ == next->transfer_) {
+      transfer_ = ColorSpace::TransferID::LINEAR;
+      return true;
+    }
+    return false;
+  }
+  bool IsNull() override { return transfer_ == ColorSpace::TransferID::LINEAR; }
+
+  // ColorTransformPerChannelTransferFn implementation:
+  float Evaluate(float v) const override { return ToLinear(transfer_, v); }
+
+  // This is a string-ized copy-paste from ToLinear.
+  void AppendTransferShaderSource(std::stringstream* src,
+                                  bool is_glsl) const override {
+    std::string scalar_type = is_glsl ? "float" : "half";
+    switch (transfer_) {
+      case ColorSpace::TransferID::LOG:
+        *src << "  if (v < 0.0)\n"
+                "    v = 0.0;\n"
+                "  else\n"
+                "    v = pow(10.0, (v - 1.0) * 2.0);\n";
+        return;
+      case ColorSpace::TransferID::LOG_SQRT:
+        *src << "  if (v < 0.0)\n"
+                "    v = 0.0;\n"
+                "  else\n"
+                "    v = pow(10.0, (v - 1.0) * 2.5);\n";
+        return;
+      case ColorSpace::TransferID::IEC61966_2_4:
+        *src << "  " << scalar_type << " a = 1.099296826809442;\n"
+             << "  " << scalar_type << " from_linear_neg_a = -1.047844;\n"
+             << "  " << scalar_type << " from_linear_b = 0.081243;\n"
+             << "  if (v < from_linear_neg_a)\n"
+                "    v = -pow((a - 1.0 - v) / a, 1.0 / 0.45);\n"
+                "  else if (v <= from_linear_b)\n"
+                "    v = v / 4.5;\n"
+                "  else\n"
+                "    v = pow((v + a - 1.0) / a, 1.0 / 0.45);\n";
+        return;
+      case ColorSpace::TransferID::BT1361_ECG:
+        *src << "  " << scalar_type << " a = 1.099;\n"
+             << "  " << scalar_type << " from_linear_neg_l = -0.020250;\n"
+             << "  " << scalar_type << " from_linear_b = 0.081000;\n"
+             << "  if (v < from_linear_neg_l)\n"
+                "    v = -pow((1.0 - a - v * 4.0) / a, 1.0 / 0.45) / 4.0;\n"
+                "  else if (v <= from_linear_b)\n"
+                "    v = v / 4.5;\n"
+                "  else\n"
+                "    v = pow((v + a - 1.0) / a, 1.0 / 0.45);\n";
+        return;
+      default:
+        break;
+    }
+    NOTREACHED();
+  }
+
+ private:
+  ColorSpace::TransferID transfer_;
+};
+
+// BT2020 Constant Luminance is different than most other
+// ways to encode RGB values as YUV. The basic idea is that
+// transfer functions are applied on the Y value instead of
+// on the RGB values. However, running the transfer function
+// on the U and V values doesn't make any sense since they
+// are centered at 0.5. To work around this, the transfer function
+// is applied to the Y, R and B values, and then the U and V
+// values are calculated from that.
+// In our implementation, the YUV->RGB matrix is used to
+// convert YUV to RYB (the G value is replaced with an Y value.)
+// Then we run the transfer function like normal, and finally
+// this class is inserted as an extra step which takes calculates
+// the U and V values.
+class ColorTransformFromBT2020CL : public ColorTransformStep {
+ public:
+  void Transform(ColorTransform::TriStim* YUV, size_t num) const override {
+    for (size_t i = 0; i < num; i++) {
+      float Y = YUV[i].x();
+      float U = YUV[i].y() - 0.5;
+      float V = YUV[i].z() - 0.5;
+      float B_Y, R_Y;
+      if (U <= 0) {
+        B_Y = U * (-2.0 * -0.9702);
+      } else {
+        B_Y = U * (2.0 * 0.7910);
+      }
+      if (V <= 0) {
+        R_Y = V * (-2.0 * -0.8591);
+      } else {
+        R_Y = V * (2.0 * 0.4969);
+      }
+      // Return an RYB value, later steps will fix it.
+      YUV[i] = ColorTransform::TriStim(R_Y + Y, Y, B_Y + Y);
+    }
+  }
+  void AppendShaderSource(std::stringstream* hdr,
+                          std::stringstream* src,
+                          size_t step_index) const override {
+    *hdr << "vec3 BT2020_YUV_to_RYB_Step" << step_index << "(vec3 color) {"
+         << endl;
+    *hdr << "  float Y = color.x;" << endl;
+    *hdr << "  float U = color.y - 0.5;" << endl;
+    *hdr << "  float V = color.z - 0.5;" << endl;
+    *hdr << "  float B_Y = 0.0;" << endl;
+    *hdr << "  float R_Y = 0.0;" << endl;
+    *hdr << "  if (U <= 0.0) {" << endl;
+    *hdr << "    B_Y = U * (-2.0 * -0.9702);" << endl;
+    *hdr << "  } else {" << endl;
+    *hdr << "    B_Y = U * (2.0 * 0.7910);" << endl;
+    *hdr << "  }" << endl;
+    *hdr << "  if (V <= 0.0) {" << endl;
+    *hdr << "    R_Y = V * (-2.0 * -0.8591);" << endl;
+    *hdr << "  } else {" << endl;
+    *hdr << "    R_Y = V * (2.0 * 0.4969);" << endl;
+    *hdr << "  }" << endl;
+    *hdr << "  return vec3(R_Y + Y, Y, B_Y + Y);" << endl;
+    *hdr << "}" << endl;
+
+    *src << "  color.rgb = BT2020_YUV_to_RYB_Step" << step_index
+         << "(color.rgb);" << endl;
+  }
+
+  void AppendSkShaderSource(std::stringstream* src) const override {
+    NOTREACHED();
+  }
+};
+
+void ColorTransformInternal::AppendColorSpaceToColorSpaceTransform(
+    const ColorSpace& src,
+    const ColorSpace& dst,
+    const Options& options) {
+  // ITU-T H.273: If MatrixCoefficients is equal to 0 (Identity) or 8 (YCgCo),
+  // range adjustment is performed on R,G,B samples rather than Y,U,V samples.
+  const bool src_matrix_is_identity_or_ycgco =
+      src.GetMatrixID() == ColorSpace::MatrixID::GBR ||
+      src.GetMatrixID() == ColorSpace::MatrixID::YCOCG;
+  auto src_range_adjust_matrix = std::make_unique<ColorTransformMatrix>(
+      GetRangeAdjustMatrix(src, options.src_bit_depth));
+
+  if (!src_matrix_is_identity_or_ycgco)
+    steps_.push_back(std::move(src_range_adjust_matrix));
+
+  if (src.GetMatrixID() == ColorSpace::MatrixID::BT2020_CL) {
+    // BT2020 CL is a special case.
+    steps_.push_back(std::make_unique<ColorTransformFromBT2020CL>());
+  } else {
+    steps_.push_back(std::make_unique<ColorTransformMatrix>(
+        Invert(GetTransferMatrix(src, options.src_bit_depth))));
+  }
+
+  if (src_matrix_is_identity_or_ycgco)
+    steps_.push_back(std::move(src_range_adjust_matrix));
+
+  // If the target color space is not defined, just apply the adjust and
+  // tranfer matrices. This path is used by YUV to RGB color conversion
+  // when full color conversion is not enabled.
+  if (!dst.IsValid())
+    return;
+
+  skcms_TransferFunction src_to_linear_fn;
+  if (src.GetTransferFunction(&src_to_linear_fn)) {
+    steps_.push_back(std::make_unique<ColorTransformSkTransferFn>(
+        src_to_linear_fn, src.HasExtendedSkTransferFn()));
+  } else if (src.GetTransferID() == ColorSpace::TransferID::ARIB_STD_B67) {
+    float sdr_white_level = 0.f;
+    src.GetSDRWhiteLevel(&sdr_white_level);
+    steps_.push_back(
+        std::make_unique<ColorTransformHLGToLinear>(sdr_white_level));
+  } else if (src.GetTransferID() == ColorSpace::TransferID::SMPTEST2084) {
+    float sdr_white_level = 0.f;
+    src.GetSDRWhiteLevel(&sdr_white_level);
+    steps_.push_back(
+        std::make_unique<ColorTransformPQToLinear>(sdr_white_level));
+  } else if (src.GetTransferID() == ColorSpace::TransferID::PIECEWISE_HDR) {
+    skcms_TransferFunction fn;
+    float p, q, r;
+    ColorTransformPiecewiseHDR::GetParams(src, &fn, &p, &q, &r);
+    steps_.push_back(std::make_unique<ColorTransformPiecewiseHDR>(fn, p, q, r));
+  } else {
+    steps_.push_back(
+        std::make_unique<ColorTransformToLinear>(src.GetTransferID()));
+  }
+
+  if (src.GetMatrixID() == ColorSpace::MatrixID::BT2020_CL) {
+    // BT2020 CL is a special case.
+    steps_.push_back(std::make_unique<ColorTransformMatrix>(
+        Invert(GetTransferMatrix(src, options.src_bit_depth))));
+  }
+  steps_.push_back(
+      std::make_unique<ColorTransformMatrix>(GetPrimaryTransform(src)));
+
+  steps_.push_back(
+      std::make_unique<ColorTransformMatrix>(Invert(GetPrimaryTransform(dst))));
+  if (dst.GetMatrixID() == ColorSpace::MatrixID::BT2020_CL) {
+    // BT2020 CL is a special case.
+    steps_.push_back(std::make_unique<ColorTransformMatrix>(
+        GetTransferMatrix(dst, options.dst_bit_depth)));
+  }
+
+  skcms_TransferFunction dst_from_linear_fn;
+  if (dst.GetInverseTransferFunction(&dst_from_linear_fn)) {
+    steps_.push_back(std::make_unique<ColorTransformSkTransferFn>(
+        dst_from_linear_fn, dst.HasExtendedSkTransferFn()));
+  } else if (dst.GetTransferID() == ColorSpace::TransferID::ARIB_STD_B67) {
+    float sdr_white_level = 0.f;
+    dst.GetSDRWhiteLevel(&sdr_white_level);
+    steps_.push_back(
+        std::make_unique<ColorTransformHLGFromLinear>(sdr_white_level));
+  } else if (dst.GetTransferID() == ColorSpace::TransferID::SMPTEST2084) {
+    float sdr_white_level = 0.f;
+    dst.GetSDRWhiteLevel(&sdr_white_level);
+    steps_.push_back(
+        std::make_unique<ColorTransformPQFromLinear>(sdr_white_level));
+  } else if (dst.GetTransferID() == ColorSpace::TransferID::PIECEWISE_HDR) {
+    skcms_TransferFunction fn;
+    float p, q, r;
+    ColorTransformPiecewiseHDR::GetParams(dst, &fn, &p, &q, &r);
+    ColorTransformPiecewiseHDR::InvertParams(&fn, &p, &q, &r);
+    steps_.push_back(std::make_unique<ColorTransformPiecewiseHDR>(fn, p, q, r));
+  } else {
+    steps_.push_back(
+        std::make_unique<ColorTransformFromLinear>(dst.GetTransferID()));
+  }
+
+  // ITU-T H.273: If MatrixCoefficients is equal to 0 (Identity) or 8 (YCgCo),
+  // range adjustment is performed on R,G,B samples rather than Y,U,V samples.
+  const bool dst_matrix_is_identity_or_ycgco =
+      dst.GetMatrixID() == ColorSpace::MatrixID::GBR ||
+      dst.GetMatrixID() == ColorSpace::MatrixID::YCOCG;
+  auto dst_range_adjust_matrix = std::make_unique<ColorTransformMatrix>(
+      Invert(GetRangeAdjustMatrix(dst, options.dst_bit_depth)));
+
+  if (dst_matrix_is_identity_or_ycgco)
+    steps_.push_back(std::move(dst_range_adjust_matrix));
+
+  if (dst.GetMatrixID() == ColorSpace::MatrixID::BT2020_CL) {
+    NOTREACHED();
+  } else {
+    steps_.push_back(std::make_unique<ColorTransformMatrix>(
+        GetTransferMatrix(dst, options.dst_bit_depth)));
+  }
+
+  if (!dst_matrix_is_identity_or_ycgco)
+    steps_.push_back(std::move(dst_range_adjust_matrix));
+}
+
+ColorTransformInternal::ColorTransformInternal(const ColorSpace& src,
+                                               const ColorSpace& dst,
+                                               const Options& options)
+    : src_(src), dst_(dst) {
+  // If no source color space is specified, do no transformation.
+  // TODO(ccameron): We may want dst assume sRGB at some point in the future.
+  if (!src_.IsValid())
+    return;
+  AppendColorSpaceToColorSpaceTransform(src_, dst_, options);
+  if (!options.disable_optimizations)
+    Simplify();
+}
+
+std::string ColorTransformInternal::GetShaderSource() const {
+  std::stringstream hdr;
+  std::stringstream src;
+  InitStringStream(&hdr);
+  InitStringStream(&src);
+  src << "vec3 DoColorConversion(vec3 color) {" << endl;
+  size_t step_index = 0;
+  for (const auto& step : steps_)
+    step->AppendShaderSource(&hdr, &src, step_index++);
+  src << "  return color;" << endl;
+  src << "}" << endl;
+  return hdr.str() + src.str();
+}
+
+std::string ColorTransformInternal::GetSkShaderSource() const {
+  std::stringstream src;
+  InitStringStream(&src);
+  for (const auto& step : steps_)
+    step->AppendSkShaderSource(&src);
+  return src.str();
+}
+
+ColorTransformInternal::~ColorTransformInternal() {}
+
+void ColorTransformInternal::Simplify() {
+  for (auto iter = steps_.begin(); iter != steps_.end();) {
+    std::unique_ptr<ColorTransformStep>& this_step = *iter;
+
+    // Try to Join |next_step| into |this_step|. If successful, re-visit the
+    // step before |this_step|.
+    auto iter_next = iter;
+    iter_next++;
+    if (iter_next != steps_.end()) {
+      std::unique_ptr<ColorTransformStep>& next_step = *iter_next;
+      if (this_step->Join(next_step.get())) {
+        steps_.erase(iter_next);
+        if (iter != steps_.begin())
+          --iter;
+        continue;
+      }
+    }
+
+    // If |this_step| step is a no-op, remove it, and re-visit the step before
+    // |this_step|.
+    if (this_step->IsNull()) {
+      iter = steps_.erase(iter);
+      if (iter != steps_.begin())
+        --iter;
+      continue;
+    }
+
+    ++iter;
+  }
+}
+
+// static
+std::unique_ptr<ColorTransform> ColorTransform::NewColorTransform(
+    const ColorSpace& src,
+    const ColorSpace& dst) {
+  Options options;
+  return std::make_unique<ColorTransformInternal>(src, dst, options);
+}
+
+// static
+std::unique_ptr<ColorTransform> ColorTransform::NewColorTransform(
+    const ColorSpace& src,
+    const ColorSpace& dst,
+    const Options& options) {
+  return std::make_unique<ColorTransformInternal>(src, dst, options);
+}
+
+ColorTransform::ColorTransform() {}
+ColorTransform::~ColorTransform() {}
+
+}  // namespace gfx
diff --git a/ui/gfx/color_transform.h b/ui/gfx/color_transform.h
new file mode 100644
index 0000000..62bc935
--- /dev/null
+++ b/ui/gfx/color_transform.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_COLOR_TRANSFORM_H_
+#define UI_GFX_COLOR_TRANSFORM_H_
+
+#include <memory>
+#include <string>
+
+#include "base/macros.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class GFX_EXPORT ColorTransform {
+ public:
+  struct Options {
+    // Used in testing to verify that optimizations have no effect.
+    bool disable_optimizations = false;
+
+    // Used to adjust the transfer and range adjust matrices.
+    uint32_t src_bit_depth = kDefaultBitDepth;
+    uint32_t dst_bit_depth = kDefaultBitDepth;
+  };
+
+  // TriStimulus is a color coordinate in any color space.
+  // Channel order is XYZ, RGB or YUV.
+  typedef Point3F TriStim;
+
+  ColorTransform();
+
+  ColorTransform(const ColorTransform&) = delete;
+  ColorTransform& operator=(const ColorTransform&) = delete;
+
+  virtual ~ColorTransform();
+  virtual gfx::ColorSpace GetSrcColorSpace() const = 0;
+  virtual gfx::ColorSpace GetDstColorSpace() const = 0;
+
+  // Perform transformation of colors, |colors| is both input and output.
+  virtual void Transform(TriStim* colors, size_t num) const = 0;
+
+  // Return GLSL shader source that defines a function DoColorConversion that
+  // converts a vec3 according to this transform.
+  virtual std::string GetShaderSource() const = 0;
+
+  // Return SKSL shader sources that modifies an "inout half4 color" according
+  // to this transform. Input and output are non-premultiplied alpha.
+  virtual std::string GetSkShaderSource() const = 0;
+
+  // Returns true if this transform is the identity.
+  virtual bool IsIdentity() const = 0;
+
+  virtual size_t NumberOfStepsForTesting() const = 0;
+
+  // Two special cases:
+  // 1. If no source color space is specified (i.e., src.IsValid() is false), do
+  // no transformation.
+  // 2. If the target color space is not defined (i.e., dst.IsValid() is false),
+  // just apply the range adjust and inverse transfer matrices. This can be used
+  // for YUV to RGB color conversion.
+  static std::unique_ptr<ColorTransform> NewColorTransform(
+      const ColorSpace& src,
+      const ColorSpace& dst);
+
+  static std::unique_ptr<ColorTransform> NewColorTransform(
+      const ColorSpace& src,
+      const ColorSpace& dst,
+      const Options& options);
+
+ private:
+  // The default bit depth assumed by NewColorTransform().
+  static constexpr int kDefaultBitDepth = 8;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_COLOR_TRANSFORM_H_
diff --git a/ui/gfx/color_transform_fuzzer.cc b/ui/gfx/color_transform_fuzzer.cc
new file mode 100644
index 0000000..c3f8a93
--- /dev/null
+++ b/ui/gfx/color_transform_fuzzer.cc
@@ -0,0 +1,87 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <stddef.h>
+#include <stdint.h>
+#include <random>
+
+#include "base/at_exit.h"
+#include "base/logging.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/color_transform.h"
+#include "ui/gfx/icc_profile.h"
+
+static constexpr size_t kPixels = 256;
+
+static gfx::ColorTransform::TriStim pixels[kPixels];
+
+static void GeneratePixels(size_t hash) {
+  static std::uniform_real_distribution<float> uniform(-0.1f, 1.1f);
+
+  std::mt19937_64 random(hash);
+  for (size_t i = 0; i < kPixels; ++i)
+    pixels[i].SetPoint(uniform(random), uniform(random), uniform(random));
+}
+
+static gfx::ColorSpace test;
+static gfx::ColorSpace srgb;
+
+static void ColorTransform(size_t hash) {
+  const gfx::ColorTransform::Options options;
+
+  std::unique_ptr<gfx::ColorTransform> transform;
+  if (hash & 2) {
+    transform = gfx::ColorTransform::NewColorTransform(test, srgb, options);
+  } else {
+    transform = gfx::ColorTransform::NewColorTransform(srgb, test, options);
+  }
+
+  transform->Transform(pixels, kPixels);
+}
+
+static gfx::ColorSpace CreateRGBColorSpace(size_t hash) {
+  auto primaries = static_cast<gfx::ColorSpace::PrimaryID>(
+      1 + ((hash >> 0) % (size_t)gfx::ColorSpace::PrimaryID::kMaxValue));
+  auto transfer = static_cast<gfx::ColorSpace::TransferID>(
+      1 + ((hash >> 8) % (size_t)gfx::ColorSpace::TransferID::kMaxValue));
+  auto matrix = static_cast<gfx::ColorSpace::MatrixID>(
+      1 + ((hash >> 16) % (size_t)gfx::ColorSpace::MatrixID::kMaxValue));
+  auto range = static_cast<gfx::ColorSpace::RangeID>(
+      1 + ((hash >> 24) % (size_t)gfx::ColorSpace::RangeID::kMaxValue));
+
+  return gfx::ColorSpace(primaries, transfer, matrix, range);
+}
+
+inline size_t Hash(const char* data, size_t size, size_t hash = ~0) {
+  for (size_t i = 0; i < size; ++i)
+    hash = hash * 131 + *data++;
+  return hash;
+}
+
+struct Environment {
+  Environment() { logging::SetMinLogLevel(logging::LOG_FATAL); }
+};
+
+Environment* environment = new Environment();
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  base::AtExitManager at_exit;
+
+  constexpr size_t kSizeLimit = 4 * 1024 * 1024;
+  if (size < 128 || size > kSizeLimit)
+    return 0;
+
+  gfx::ICCProfile profile =
+      gfx::ICCProfile::FromData(reinterpret_cast<const char*>(data), size);
+  if (!profile.GetColorSpace().IsValid())
+    return 0;
+  test = profile.GetColorSpace();
+
+  const size_t hash = Hash(reinterpret_cast<const char*>(data), size);
+  srgb = CreateRGBColorSpace(hash);
+  GeneratePixels(hash);
+
+  ColorTransform(hash);
+  return 0;
+}
diff --git a/ui/gfx/color_transform_unittest.cc b/ui/gfx/color_transform_unittest.cc
new file mode 100644
index 0000000..d8fac5b
--- /dev/null
+++ b/ui/gfx/color_transform_unittest.cc
@@ -0,0 +1,928 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <tuple>
+#include <vector>
+
+#include "base/logging.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/effects/SkRuntimeEffect.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/color_transform.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/icc_profile.h"
+#include "ui/gfx/skia_color_space_util.h"
+#include "ui/gfx/test/icc_profiles.h"
+
+namespace gfx {
+
+// Allowed math error.
+const float kMathEpsilon = 0.001f;
+
+// Internal functions, exposted for testing.
+GFX_EXPORT Transform GetTransferMatrix(ColorSpace::MatrixID id);
+
+ColorSpace::PrimaryID all_primaries[] = {
+    ColorSpace::PrimaryID::BT709,        ColorSpace::PrimaryID::BT470M,
+    ColorSpace::PrimaryID::BT470BG,      ColorSpace::PrimaryID::SMPTE170M,
+    ColorSpace::PrimaryID::SMPTE240M,    ColorSpace::PrimaryID::FILM,
+    ColorSpace::PrimaryID::BT2020,       ColorSpace::PrimaryID::SMPTEST428_1,
+    ColorSpace::PrimaryID::SMPTEST431_2, ColorSpace::PrimaryID::SMPTEST432_1,
+};
+
+ColorSpace::TransferID simple_transfers[] = {
+    ColorSpace::TransferID::BT709,
+    ColorSpace::TransferID::GAMMA22,
+    ColorSpace::TransferID::GAMMA28,
+    ColorSpace::TransferID::SMPTE170M,
+    ColorSpace::TransferID::SMPTE240M,
+    ColorSpace::TransferID::SMPTEST428_1,
+    ColorSpace::TransferID::LINEAR,
+    ColorSpace::TransferID::LOG,
+    ColorSpace::TransferID::LOG_SQRT,
+    ColorSpace::TransferID::IEC61966_2_4,
+    ColorSpace::TransferID::BT1361_ECG,
+    ColorSpace::TransferID::IEC61966_2_1,
+    ColorSpace::TransferID::BT2020_10,
+    ColorSpace::TransferID::BT2020_12,
+    ColorSpace::TransferID::SMPTEST2084,
+    ColorSpace::TransferID::ARIB_STD_B67,
+    ColorSpace::TransferID::IEC61966_2_1_HDR,
+};
+
+ColorSpace::TransferID extended_transfers[] = {
+    ColorSpace::TransferID::LINEAR_HDR,
+    ColorSpace::TransferID::IEC61966_2_1_HDR,
+};
+
+ColorSpace::MatrixID all_matrices[] = {
+    ColorSpace::MatrixID::RGB,       ColorSpace::MatrixID::BT709,
+    ColorSpace::MatrixID::FCC,       ColorSpace::MatrixID::BT470BG,
+    ColorSpace::MatrixID::SMPTE170M, ColorSpace::MatrixID::SMPTE240M,
+    ColorSpace::MatrixID::YCOCG,     ColorSpace::MatrixID::BT2020_NCL,
+    ColorSpace::MatrixID::YDZDX,
+};
+
+ColorSpace::RangeID all_ranges[] = {ColorSpace::RangeID::FULL,
+                                    ColorSpace::RangeID::LIMITED,
+                                    ColorSpace::RangeID::DERIVED};
+
+bool optimizations[] = {true, false};
+
+TEST(SimpleColorSpace, BT709toSRGB) {
+  ColorSpace bt709 = ColorSpace::CreateREC709();
+  ColorSpace sRGB = ColorSpace::CreateSRGB();
+  std::unique_ptr<ColorTransform> t(
+      ColorTransform::NewColorTransform(bt709, sRGB));
+
+  ColorTransform::TriStim tmp(16.0f / 255.0f, 0.5f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 0.0f, kMathEpsilon);
+
+  tmp = ColorTransform::TriStim(235.0f / 255.0f, 0.5f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 1.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 1.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 1.0f, kMathEpsilon);
+
+  // Test a blue color
+  tmp = ColorTransform::TriStim(128.0f / 255.0f, 240.0f / 255.0f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_GT(tmp.z(), tmp.x());
+  EXPECT_GT(tmp.z(), tmp.y());
+}
+
+TEST(SimpleColorSpace, BT2020CLtoBT2020RGB) {
+  ColorSpace bt2020cl(
+      ColorSpace::PrimaryID::BT2020, ColorSpace::TransferID::BT2020_10,
+      ColorSpace::MatrixID::BT2020_CL, ColorSpace::RangeID::LIMITED);
+  ColorSpace bt2020rgb(ColorSpace::PrimaryID::BT2020,
+                       ColorSpace::TransferID::BT2020_10,
+                       ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+  std::unique_ptr<ColorTransform> t(
+      ColorTransform::NewColorTransform(bt2020cl, bt2020rgb));
+
+  ColorTransform::TriStim tmp(16.0f / 255.0f, 0.5f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 0.0f, kMathEpsilon);
+
+  tmp = ColorTransform::TriStim(235.0f / 255.0f, 0.5f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 1.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 1.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 1.0f, kMathEpsilon);
+
+  // Test a blue color
+  tmp = ColorTransform::TriStim(128.0f / 255.0f, 240.0f / 255.0f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_GT(tmp.z(), tmp.x());
+  EXPECT_GT(tmp.z(), tmp.y());
+}
+
+TEST(SimpleColorSpace, YCOCGLimitedToSRGB) {
+  ColorSpace ycocg(ColorSpace::PrimaryID::BT709,
+                   ColorSpace::TransferID::IEC61966_2_1,
+                   ColorSpace::MatrixID::YCOCG, ColorSpace::RangeID::LIMITED);
+  ColorSpace sRGB = ColorSpace::CreateSRGB();
+  std::unique_ptr<ColorTransform> t(
+      ColorTransform::NewColorTransform(ycocg, sRGB));
+
+  ColorTransform::TriStim tmp(16.0f / 255.0f, 128.0f / 255.0f, 128.0f / 255.0f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 0.0f, kMathEpsilon);
+
+  tmp = ColorTransform::TriStim(235.0f / 255.0f, 128.0f / 255.0f,
+                                128.0f / 255.0f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 1.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 1.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 1.0f, kMathEpsilon);
+
+  // Test a blue color
+  // Use the equations for MatrixCoefficients 8 and VideoFullRangeFlag 0 in
+  // ITU-T H.273:
+  // Equations 11-13: E'_R = 0.0, E'_G = 0.0, E'_B = 1.0
+  // Equations 20-22: R = 16, G = 16, B = 219 + 16 = 235
+  // Equations 44-46:
+  //   Y = Round(0.5 * 16 + 0.25 * (16 + 235)) = Round(70.75) = 71
+  //   Cb = Round(0.5 * 16 - 0.25 * (16 + 235)) + 128 = Round(-54.75) + 128 = 73
+  //   Cr = Round(0.5 * (16 - 235)) + 128 = Round(-109.5) + 128 = 18
+  // In this test we omit the Round() calls to avoid rounding errors.
+  //   Y = 0.5 * 16 + 0.25 * (16 + 235) = 70.75
+  //   Cb = 0.5 * 16 - 0.25 * (16 + 235) + 128 = -54.75 + 128 = 73.25
+  //   Cr = 0.5 * (16 - 235) + 128 = -109.5 + 128 = 18.5
+  tmp =
+      ColorTransform::TriStim(70.75f / 255.0f, 73.25f / 255.0f, 18.5f / 255.0f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 1.0f, kMathEpsilon);
+}
+
+TEST(SimpleColorSpace, TransferFnCancel) {
+  ColorSpace::PrimaryID primary = ColorSpace::PrimaryID::BT709;
+  ColorSpace::MatrixID matrix = ColorSpace::MatrixID::RGB;
+  ColorSpace::RangeID range = ColorSpace::RangeID::FULL;
+
+  // BT709 has a gamma of 2.2222 (with some adjustments)
+  ColorSpace bt709(primary, ColorSpace::TransferID::BT709, matrix, range);
+
+  // IEC61966_2_1 has the sRGB gamma of 2.4 (with some adjustments)
+  ColorSpace srgb(primary, ColorSpace::TransferID::IEC61966_2_1, matrix, range);
+
+  // gamma28 is a simple exponential
+  ColorSpace gamma28(primary, ColorSpace::TransferID::GAMMA28, matrix, range);
+
+  // gamma24 is a simple exponential
+  ColorSpace gamma24(primary, ColorSpace::TransferID::GAMMA24, matrix, range);
+
+  // BT709 source is common for video and sRGB destination is common for
+  // monitors. The two transfer functions are very close, and should cancel
+  // out (so the transfer between them should be the identity). This particular
+  // case is important for power reasons.
+  std::unique_ptr<ColorTransform> bt709_to_srgb(
+      ColorTransform::NewColorTransform(bt709, srgb));
+  EXPECT_EQ(bt709_to_srgb->NumberOfStepsForTesting(), 0u);
+
+  // Gamma 2.8 isn't even close to BT709 and won't cancel out (so we will have
+  // two steps in the transform -- to-linear and from-linear).
+  std::unique_ptr<ColorTransform> bt709_to_gamma28(
+      ColorTransform::NewColorTransform(bt709, gamma28));
+  EXPECT_EQ(bt709_to_gamma28->NumberOfStepsForTesting(), 2u);
+
+  // Gamma 2.4 is closer to BT709, but not close enough to actually cancel out.
+  std::unique_ptr<ColorTransform> bt709_to_gamma24(
+      ColorTransform::NewColorTransform(bt709, gamma24));
+  EXPECT_EQ(bt709_to_gamma24->NumberOfStepsForTesting(), 2u);
+
+  // Rec 601 YUV to RGB conversion should have a single step.
+  gfx::ColorSpace rec601 = gfx::ColorSpace::CreateREC601();
+  std::unique_ptr<ColorTransform> rec601_yuv_to_rgb(
+      ColorTransform::NewColorTransform(rec601, rec601.GetAsFullRangeRGB()));
+  EXPECT_EQ(rec601_yuv_to_rgb->NumberOfStepsForTesting(), 1u);
+}
+
+TEST(SimpleColorSpace, SRGBFromICCAndNotICC) {
+  float kPixelEpsilon = kMathEpsilon;
+  ColorTransform::TriStim value_fromicc;
+  ColorTransform::TriStim value_default;
+
+  ICCProfile srgb_icc_profile = ICCProfileForTestingSRGB();
+  ColorSpace srgb_fromicc = srgb_icc_profile.GetColorSpace();
+  ColorSpace srgb_default = gfx::ColorSpace::CreateSRGB();
+  ColorSpace xyzd50 = gfx::ColorSpace::CreateXYZD50();
+
+  value_fromicc = value_default = ColorTransform::TriStim(0.1f, 0.5f, 0.9f);
+
+  std::unique_ptr<ColorTransform> toxyzd50_fromicc(
+      ColorTransform::NewColorTransform(srgb_fromicc, xyzd50));
+  // This will be converted to a transfer function and then linear transform.
+  EXPECT_EQ(toxyzd50_fromicc->NumberOfStepsForTesting(), 2u);
+  toxyzd50_fromicc->Transform(&value_fromicc, 1);
+
+  std::unique_ptr<ColorTransform> toxyzd50_default(
+      ColorTransform::NewColorTransform(srgb_default, xyzd50));
+  // This will have a transfer function and then linear transform.
+  EXPECT_EQ(toxyzd50_default->NumberOfStepsForTesting(), 2u);
+  toxyzd50_default->Transform(&value_default, 1);
+
+  EXPECT_NEAR(value_fromicc.x(), value_default.x(), kPixelEpsilon);
+  EXPECT_NEAR(value_fromicc.y(), value_default.y(), kPixelEpsilon);
+  EXPECT_NEAR(value_fromicc.z(), value_default.z(), kPixelEpsilon);
+
+  value_fromicc = value_default = ColorTransform::TriStim(0.1f, 0.5f, 0.9f);
+
+  std::unique_ptr<ColorTransform> fromxyzd50_fromicc(
+      ColorTransform::NewColorTransform(xyzd50, srgb_fromicc));
+  fromxyzd50_fromicc->Transform(&value_fromicc, 1);
+
+  std::unique_ptr<ColorTransform> fromxyzd50_default(
+      ColorTransform::NewColorTransform(xyzd50, srgb_default));
+  fromxyzd50_default->Transform(&value_default, 1);
+
+  EXPECT_NEAR(value_fromicc.x(), value_default.x(), kPixelEpsilon);
+  EXPECT_NEAR(value_fromicc.y(), value_default.y(), kPixelEpsilon);
+  EXPECT_NEAR(value_fromicc.z(), value_default.z(), kPixelEpsilon);
+}
+
+TEST(SimpleColorSpace, BT709toSRGBICC) {
+  ICCProfile srgb_icc = ICCProfileForTestingSRGB();
+  ColorSpace bt709 = ColorSpace::CreateREC709();
+  ColorSpace sRGB = srgb_icc.GetColorSpace();
+  std::unique_ptr<ColorTransform> t(
+      ColorTransform::NewColorTransform(bt709, sRGB));
+
+  ColorTransform::TriStim tmp(16.0f / 255.0f, 0.5f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 0.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 0.0f, kMathEpsilon);
+
+  tmp = ColorTransform::TriStim(235.0f / 255.0f, 0.5f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 1.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.y(), 1.0f, kMathEpsilon);
+  EXPECT_NEAR(tmp.z(), 1.0f, kMathEpsilon);
+
+  // Test a blue color
+  tmp = ColorTransform::TriStim(128.0f / 255.0f, 240.0f / 255.0f, 0.5f);
+  t->Transform(&tmp, 1);
+  EXPECT_GT(tmp.z(), tmp.x());
+  EXPECT_GT(tmp.z(), tmp.y());
+}
+
+TEST(SimpleColorSpace, ICCProfileOnlyXYZ) {
+  const float kPixelEpsilon = 2.5f / 255.f;
+  ICCProfile icc_profile = ICCProfileForTestingNoAnalyticTrFn();
+  ColorSpace icc_space = icc_profile.GetColorSpace();
+  ColorSpace xyzd50 = ColorSpace::CreateXYZD50();
+
+  ColorTransform::TriStim input_value(127.f / 255, 187.f / 255, 157.f / 255);
+  ColorTransform::TriStim transformed_value = input_value;
+  ColorTransform::TriStim expected_transformed_value(
+      0.34090986847877502f, 0.42633286118507385f, 0.3408740758895874f);
+
+  // Two steps should be needed, transfer fn and matrix.
+  std::unique_ptr<ColorTransform> icc_to_xyzd50(
+      ColorTransform::NewColorTransform(icc_space, xyzd50));
+  EXPECT_EQ(icc_to_xyzd50->NumberOfStepsForTesting(), 2u);
+  icc_to_xyzd50->Transform(&transformed_value, 1);
+  EXPECT_NEAR(transformed_value.x(), expected_transformed_value.x(),
+              kPixelEpsilon);
+  EXPECT_NEAR(transformed_value.y(), expected_transformed_value.y(),
+              kPixelEpsilon);
+  EXPECT_NEAR(transformed_value.z(), expected_transformed_value.z(),
+              kPixelEpsilon);
+
+  // Two steps should be needed, matrix and transfer fn.
+  std::unique_ptr<ColorTransform> xyzd50_to_icc(
+      ColorTransform::NewColorTransform(xyzd50, icc_space));
+  EXPECT_EQ(xyzd50_to_icc->NumberOfStepsForTesting(), 2u);
+  xyzd50_to_icc->Transform(&transformed_value, 1);
+  EXPECT_NEAR(input_value.x(), transformed_value.x(), kPixelEpsilon);
+  EXPECT_NEAR(input_value.y(), transformed_value.y(), kPixelEpsilon);
+  EXPECT_NEAR(input_value.z(), transformed_value.z(), kPixelEpsilon);
+}
+
+TEST(SimpleColorSpace, ICCProfileOnlyColorSpin) {
+  const float kPixelEpsilon = 3.0f / 255.f;
+  ICCProfile icc_profile = ICCProfileForTestingNoAnalyticTrFn();
+  ColorSpace icc_space = icc_profile.GetColorSpace();
+  ColorSpace colorspin = ICCProfileForTestingColorSpin().GetColorSpace();
+
+  ColorTransform::TriStim input_value(0.25f, 0.5f, 0.75f);
+  ColorTransform::TriStim transformed_value = input_value;
+  ColorTransform::TriStim expected_transformed_value(
+      0.49694931507110596f, 0.74937951564788818f, 0.31359460949897766f);
+
+  // Three steps will be needed.
+  std::unique_ptr<ColorTransform> icc_to_colorspin(
+      ColorTransform::NewColorTransform(icc_space, colorspin));
+  EXPECT_EQ(icc_to_colorspin->NumberOfStepsForTesting(), 3u);
+  icc_to_colorspin->Transform(&transformed_value, 1);
+  EXPECT_NEAR(transformed_value.x(), expected_transformed_value.x(),
+              kPixelEpsilon);
+  EXPECT_NEAR(transformed_value.y(), expected_transformed_value.y(),
+              kPixelEpsilon);
+  EXPECT_NEAR(transformed_value.z(), expected_transformed_value.z(),
+              kPixelEpsilon);
+
+  transformed_value = expected_transformed_value;
+  std::unique_ptr<ColorTransform> colorspin_to_icc(
+      ColorTransform::NewColorTransform(colorspin, icc_space));
+  EXPECT_EQ(colorspin_to_icc->NumberOfStepsForTesting(), 3u);
+  transformed_value = expected_transformed_value;
+  colorspin_to_icc->Transform(&transformed_value, 1);
+  EXPECT_NEAR(input_value.x(), transformed_value.x(), kPixelEpsilon);
+  EXPECT_NEAR(input_value.y(), transformed_value.y(), kPixelEpsilon);
+  EXPECT_NEAR(input_value.z(), transformed_value.z(), kPixelEpsilon);
+}
+
+TEST(SimpleColorSpace, GetColorSpace) {
+  const float kPixelEpsilon = 1.5f / 255.f;
+  ICCProfile srgb_icc = ICCProfileForTestingSRGB();
+  ColorSpace sRGB = srgb_icc.GetColorSpace();
+  ColorSpace sRGB2 = sRGB;
+
+  std::unique_ptr<ColorTransform> t(
+      ColorTransform::NewColorTransform(sRGB, sRGB2));
+
+  ColorTransform::TriStim tmp(1.0f, 1.0f, 1.0f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 1.0f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.y(), 1.0f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.z(), 1.0f, kPixelEpsilon);
+
+  tmp = ColorTransform::TriStim(1.0f, 0.0f, 0.0f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 1.0f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.y(), 0.0f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.z(), 0.0f, kPixelEpsilon);
+
+  tmp = ColorTransform::TriStim(0.0f, 1.0f, 0.0f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 0.0f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.y(), 1.0f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.z(), 0.0f, kPixelEpsilon);
+
+  tmp = ColorTransform::TriStim(0.0f, 0.0f, 1.0f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 0.0f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.y(), 0.0f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.z(), 1.0f, kPixelEpsilon);
+}
+
+TEST(SimpleColorSpace, Scale) {
+  const float kPixelEpsilon = 1.5f / 255.f;
+  ColorSpace srgb = ColorSpace::CreateSRGB();
+  ColorSpace srgb_scaled = srgb.GetScaledColorSpace(2.0f);
+  std::unique_ptr<ColorTransform> t(
+      ColorTransform::NewColorTransform(srgb, srgb_scaled));
+
+  ColorTransform::TriStim tmp(1.0f, 1.0f, 1.0f);
+  t->Transform(&tmp, 1);
+  EXPECT_NEAR(tmp.x(), 0.735356983052449f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.y(), 0.735356983052449f, kPixelEpsilon);
+  EXPECT_NEAR(tmp.z(), 0.735356983052449f, kPixelEpsilon);
+}
+
+TEST(SimpleColorSpace, ToUndefined) {
+  ColorSpace null;
+  ColorSpace nonnull = gfx::ColorSpace::CreateSRGB();
+  // Video should have 1 step: YUV to RGB.
+  // Anything else should have 0 steps.
+  ColorSpace video = gfx::ColorSpace::CreateREC709();
+  std::unique_ptr<ColorTransform> video_to_null(
+      ColorTransform::NewColorTransform(video, null));
+  EXPECT_EQ(video_to_null->NumberOfStepsForTesting(), 1u);
+  // Without optimization, video should have 2 steps: limited range to full
+  // range, and YUV to RGB.
+  ColorTransform::Options options;
+  options.disable_optimizations = true;
+  std::unique_ptr<ColorTransform> video_to_null_no_opt(
+      ColorTransform::NewColorTransform(video, null, options));
+  EXPECT_EQ(video_to_null_no_opt->NumberOfStepsForTesting(), 2u);
+
+  // Test with an ICC profile that can't be represented as matrix+transfer.
+  ColorSpace luttrcicc = ICCProfileForTestingNoAnalyticTrFn().GetColorSpace();
+  std::unique_ptr<ColorTransform> luttrcicc_to_null(
+      ColorTransform::NewColorTransform(luttrcicc, null));
+  EXPECT_EQ(luttrcicc_to_null->NumberOfStepsForTesting(), 0u);
+  std::unique_ptr<ColorTransform> luttrcicc_to_nonnull(
+      ColorTransform::NewColorTransform(luttrcicc, nonnull));
+  EXPECT_GT(luttrcicc_to_nonnull->NumberOfStepsForTesting(), 0u);
+
+  // Test with an ICC profile that can.
+  ColorSpace adobeicc = ICCProfileForTestingAdobeRGB().GetColorSpace();
+  std::unique_ptr<ColorTransform> adobeicc_to_null(
+      ColorTransform::NewColorTransform(adobeicc, null));
+  EXPECT_EQ(adobeicc_to_null->NumberOfStepsForTesting(), 0u);
+  std::unique_ptr<ColorTransform> adobeicc_to_nonnull(
+      ColorTransform::NewColorTransform(adobeicc, nonnull));
+  EXPECT_GT(adobeicc_to_nonnull->NumberOfStepsForTesting(), 0u);
+
+  // And with something analytic.
+  ColorSpace xyzd50 = gfx::ColorSpace::CreateXYZD50();
+  std::unique_ptr<ColorTransform> xyzd50_to_null(
+      ColorTransform::NewColorTransform(xyzd50, null));
+  EXPECT_EQ(xyzd50_to_null->NumberOfStepsForTesting(), 0u);
+  std::unique_ptr<ColorTransform> xyzd50_to_nonnull(
+      ColorTransform::NewColorTransform(xyzd50, nonnull));
+  EXPECT_GT(xyzd50_to_nonnull->NumberOfStepsForTesting(), 0u);
+}
+
+TEST(SimpleColorSpace, DefaultToSRGB) {
+  // The default value should do no transformation, regardless of destination.
+  ColorSpace unknown;
+  std::unique_ptr<ColorTransform> t1(
+      ColorTransform::NewColorTransform(unknown, ColorSpace::CreateSRGB()));
+  EXPECT_EQ(t1->NumberOfStepsForTesting(), 0u);
+  std::unique_ptr<ColorTransform> t2(
+      ColorTransform::NewColorTransform(unknown, ColorSpace::CreateXYZD50()));
+  EXPECT_EQ(t2->NumberOfStepsForTesting(), 0u);
+}
+
+// This tests to make sure that we don't emit "pow" parts of a
+// transfer function unless necessary.
+TEST(SimpleColorSpace, ShaderSourceTrFnOptimizations) {
+  skcms_Matrix3x3 primaries;
+  gfx::ColorSpace::CreateSRGB().GetPrimaryMatrix(&primaries);
+
+  skcms_TransferFunction fn_no_pow = {
+      1.f, 2.f, 0.f, 1.f, 0.f, 0.f, 0.f,
+  };
+  skcms_TransferFunction fn_yes_pow = {
+      2.f, 2.f, 0.f, 1.f, 0.f, 0.f, 0.f,
+  };
+  gfx::ColorSpace src;
+  gfx::ColorSpace dst = gfx::ColorSpace::CreateXYZD50();
+  std::string shader_string;
+
+  src = gfx::ColorSpace::CreateCustom(primaries, fn_no_pow);
+  shader_string =
+      ColorTransform::NewColorTransform(src, dst)->GetShaderSource();
+  EXPECT_EQ(shader_string.find("pow("), std::string::npos);
+
+  src = gfx::ColorSpace::CreateCustom(primaries, fn_yes_pow);
+  shader_string =
+      ColorTransform::NewColorTransform(src, dst)->GetShaderSource();
+  EXPECT_NE(shader_string.find("pow("), std::string::npos);
+}
+
+// Note: This is not actually "testing" anything -- the goal of this test is to
+// to make reviewing shader code simpler by giving an example of the resulting
+// shader source. This should be updated whenever shader generation is updated.
+// This test produces slightly different results on Android.
+TEST(SimpleColorSpace, SampleShaderSource) {
+  ColorSpace bt709 = ColorSpace::CreateREC709();
+  ColorSpace output(ColorSpace::PrimaryID::BT2020,
+                    ColorSpace::TransferID::GAMMA28);
+  std::string source =
+      ColorTransform::NewColorTransform(bt709, output)->GetShaderSource();
+  std::string expected =
+      "float TransferFn1(float v) {\n"
+      "  if (v < 4.04499359e-02)\n"
+      "    v = 7.73993805e-02 * v;\n"
+      "  else\n"
+      "    v = pow(9.47867334e-01 * v + 5.21326549e-02, 2.40000010e+00);\n"
+      "  return v;\n"
+      "}\n"
+      "float TransferFn3(float v) {\n"
+      "  if (v < 0.00000000e+00)\n"
+      "    v = 0.00000000e+00 * v;\n"
+      "  else\n"
+      "    v = pow(v, 3.57142866e-01);\n"
+      "  return v;\n"
+      "}\n"
+      "vec3 DoColorConversion(vec3 color) {\n"
+      "  color = mat3(1.16438353e+00, 1.16438353e+00, 1.16438353e+00,\n"
+      "               -2.28029018e-09, -2.13248596e-01, 2.11240172e+00,\n"
+      "               1.79274118e+00, -5.32909274e-01, -5.96049432e-10) "
+      "* color;\n"
+      "  color += vec3(-9.69429970e-01, 3.00019622e-01, -1.12926030e+00);\n"
+      "  color.r = TransferFn1(color.r);\n"
+      "  color.g = TransferFn1(color.g);\n"
+      "  color.b = TransferFn1(color.b);\n"
+      "  color = mat3(6.27404153e-01, 6.90974146e-02, 1.63914431e-02,\n"
+      "               3.29283088e-01, 9.19540644e-01, 8.80132765e-02,\n"
+      "               4.33131084e-02, 1.13623096e-02, 8.95595253e-01) "
+      "* color;\n"
+      "  color.r = TransferFn3(color.r);\n"
+      "  color.g = TransferFn3(color.g);\n"
+      "  color.b = TransferFn3(color.b);\n"
+      "  return color;\n"
+      "}\n";
+  EXPECT_EQ(source, expected);
+}
+
+// Checks that the generated SkSL fragment shaders can be parsed by
+// SkSL::Compiler.
+TEST(SimpleColorSpace, CanParseSkShaderSource) {
+  std::vector<ColorSpace> common_color_spaces = {
+      ColorSpace::CreateSRGB(),         ColorSpace::CreateDisplayP3D65(),
+      ColorSpace::CreateExtendedSRGB(), ColorSpace::CreateSCRGBLinear(),
+      ColorSpace::CreateJpeg(),         ColorSpace::CreateREC601(),
+      ColorSpace::CreateREC709()};
+  for (const auto& src : common_color_spaces) {
+    for (const auto& dst : common_color_spaces) {
+      auto transform = ColorTransform::NewColorTransform(src, dst);
+      std::string source = "half4 main(half4 color) {\n" +
+                           transform->GetSkShaderSource() + " return color; }";
+      SkRuntimeEffect::Result result = SkRuntimeEffect::MakeForColorFilter(
+          SkString(source.c_str(), source.length()), /*options=*/{});
+      EXPECT_NE(result.effect, nullptr);
+      EXPECT_STREQ(result.errorText.c_str(), "");
+    }
+  }
+}
+
+class TransferTest : public testing::TestWithParam<ColorSpace::TransferID> {};
+
+TEST_P(TransferTest, basicTest) {
+  gfx::ColorSpace space_with_transfer(ColorSpace::PrimaryID::BT709, GetParam(),
+                                      ColorSpace::MatrixID::RGB,
+                                      ColorSpace::RangeID::FULL);
+  gfx::ColorSpace space_linear(
+      ColorSpace::PrimaryID::BT709, ColorSpace::TransferID::LINEAR,
+      ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+
+  std::unique_ptr<ColorTransform> to_linear(
+      ColorTransform::NewColorTransform(space_with_transfer, space_linear));
+
+  std::unique_ptr<ColorTransform> from_linear(
+      ColorTransform::NewColorTransform(space_linear, space_with_transfer));
+
+  // The transforms will have 1 or 0 steps (0 for linear).
+  size_t expected_steps = 1u;
+  if (GetParam() == ColorSpace::TransferID::LINEAR)
+    expected_steps = 0u;
+  EXPECT_EQ(to_linear->NumberOfStepsForTesting(), expected_steps);
+  EXPECT_EQ(from_linear->NumberOfStepsForTesting(), expected_steps);
+
+  for (float x = 0.0f; x <= 1.0f; x += 1.0f / 128.0f) {
+    ColorTransform::TriStim tristim(x, x, x);
+    to_linear->Transform(&tristim, 1);
+    from_linear->Transform(&tristim, 1);
+    EXPECT_NEAR(x, tristim.x(), kMathEpsilon);
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(ColorSpace,
+                         TransferTest,
+                         testing::ValuesIn(simple_transfers));
+
+class ExtendedTransferTest
+    : public testing::TestWithParam<ColorSpace::TransferID> {};
+
+TEST_P(ExtendedTransferTest, extendedTest) {
+  gfx::ColorSpace space_with_transfer(ColorSpace::PrimaryID::BT709, GetParam(),
+                                      ColorSpace::MatrixID::RGB,
+                                      ColorSpace::RangeID::FULL);
+  gfx::ColorSpace space_linear(
+      ColorSpace::PrimaryID::BT709, ColorSpace::TransferID::LINEAR,
+      ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+
+  std::unique_ptr<ColorTransform> to_linear(
+      ColorTransform::NewColorTransform(space_with_transfer, space_linear));
+
+  std::unique_ptr<ColorTransform> from_linear(
+      ColorTransform::NewColorTransform(space_linear, space_with_transfer));
+
+  for (float x = -2.0f; x <= 2.0f; x += 1.0f / 32.0f) {
+    ColorTransform::TriStim tristim(x, x, x);
+    to_linear->Transform(&tristim, 1);
+    from_linear->Transform(&tristim, 1);
+    EXPECT_NEAR(x, tristim.x(), kMathEpsilon);
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(ColorSpace,
+                         ExtendedTransferTest,
+                         testing::ValuesIn(extended_transfers));
+
+typedef std::tuple<ColorSpace::PrimaryID,
+                   ColorSpace::TransferID,
+                   ColorSpace::MatrixID,
+                   ColorSpace::RangeID,
+                   bool>
+    ColorSpaceTestData;
+
+class ColorSpaceTest : public testing::TestWithParam<ColorSpaceTestData> {
+ public:
+  ColorSpaceTest()
+      : color_space_(std::get<0>(GetParam()),
+                     std::get<1>(GetParam()),
+                     std::get<2>(GetParam()),
+                     std::get<3>(GetParam())) {
+    options_.disable_optimizations = std::get<4>(GetParam());
+  }
+
+ protected:
+  ColorSpace color_space_;
+  ColorTransform::Options options_;
+};
+
+TEST_P(ColorSpaceTest, testNullTransform) {
+  std::unique_ptr<ColorTransform> t(
+      ColorTransform::NewColorTransform(color_space_, color_space_, options_));
+  ColorTransform::TriStim tristim(0.4f, 0.5f, 0.6f);
+  t->Transform(&tristim, 1);
+  EXPECT_NEAR(tristim.x(), 0.4f, kMathEpsilon);
+  EXPECT_NEAR(tristim.y(), 0.5f, kMathEpsilon);
+  EXPECT_NEAR(tristim.z(), 0.6f, kMathEpsilon);
+}
+
+TEST_P(ColorSpaceTest, toXYZandBack) {
+  std::unique_ptr<ColorTransform> t1(ColorTransform::NewColorTransform(
+      color_space_, ColorSpace::CreateXYZD50(), options_));
+  std::unique_ptr<ColorTransform> t2(ColorTransform::NewColorTransform(
+      ColorSpace::CreateXYZD50(), color_space_, options_));
+  ColorTransform::TriStim tristim(0.4f, 0.5f, 0.6f);
+  t1->Transform(&tristim, 1);
+  t2->Transform(&tristim, 1);
+  EXPECT_NEAR(tristim.x(), 0.4f, kMathEpsilon);
+  EXPECT_NEAR(tristim.y(), 0.5f, kMathEpsilon);
+  EXPECT_NEAR(tristim.z(), 0.6f, kMathEpsilon);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    A,
+    ColorSpaceTest,
+    testing::Combine(testing::ValuesIn(all_primaries),
+                     testing::ValuesIn(simple_transfers),
+                     testing::Values(ColorSpace::MatrixID::BT709),
+                     testing::Values(ColorSpace::RangeID::LIMITED),
+                     testing::ValuesIn(optimizations)));
+
+INSTANTIATE_TEST_SUITE_P(
+    B,
+    ColorSpaceTest,
+    testing::Combine(testing::Values(ColorSpace::PrimaryID::BT709),
+                     testing::ValuesIn(simple_transfers),
+                     testing::ValuesIn(all_matrices),
+                     testing::ValuesIn(all_ranges),
+                     testing::ValuesIn(optimizations)));
+
+INSTANTIATE_TEST_SUITE_P(
+    C,
+    ColorSpaceTest,
+    testing::Combine(testing::ValuesIn(all_primaries),
+                     testing::Values(ColorSpace::TransferID::BT709),
+                     testing::ValuesIn(all_matrices),
+                     testing::ValuesIn(all_ranges),
+                     testing::ValuesIn(optimizations)));
+
+TEST(ColorSpaceTest, ExtendedSRGBScale) {
+  ColorSpace space_unscaled = ColorSpace::CreateSRGB();
+  float scale = 3.14;
+  skcms_TransferFunction scaled_trfn =
+      SkTransferFnScaled(*skcms_sRGB_TransferFunction(), scale);
+  ColorSpace space_scaled(ColorSpace::PrimaryID::BT709,
+                          ColorSpace::TransferID::CUSTOM_HDR,
+                          ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL,
+                          nullptr, &scaled_trfn);
+  ColorSpace space_target(ColorSpace::PrimaryID::BT709,
+                          ColorSpace::TransferID::LINEAR,
+                          ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+
+  std::unique_ptr<ColorTransform> xform_scaled(
+      ColorTransform::NewColorTransform(space_scaled, space_target));
+  std::unique_ptr<ColorTransform> xform_unscaled(
+      ColorTransform::NewColorTransform(space_unscaled, space_target));
+
+  // Make sure that we're testing something in the linear (0.001) and nonlinear
+  // (the rest) segments of the function.
+  ColorTransform::TriStim val_scaled(0.001, 0.5, 0.7);
+  ColorTransform::TriStim val_unscaled = val_scaled;
+
+  xform_scaled->Transform(&val_scaled, 1);
+  xform_unscaled->Transform(&val_unscaled, 1);
+
+  EXPECT_NEAR(val_scaled.x() / val_unscaled.x(), scale, kMathEpsilon);
+  EXPECT_NEAR(val_scaled.y() / val_unscaled.y(), scale, kMathEpsilon);
+  EXPECT_NEAR(val_scaled.z() / val_unscaled.z(), scale, kMathEpsilon);
+}
+
+TEST(ColorSpaceTest, PQSDRWhiteLevel) {
+  // The PQ function maps |pq_encoded_nits| to |nits|. We mangle it a bit with
+  // the SDR white level.
+  float pq_encoded_nits[] = {
+      0.485857f,
+      0.508078f,
+      0.579133f,
+  };
+  float nits[] = {80.f, 100.f, 200.f};
+
+  for (size_t i = 0; i < 4; ++i) {
+    // We'll set the SDR white level to the values in |nits| and also the
+    // default.
+    ColorSpace hdr10 =
+        i < 3 ? ColorSpace::CreateHDR10(nits[i]) : ColorSpace::CreateHDR10();
+    float white_level = 0;
+    EXPECT_TRUE(hdr10.GetSDRWhiteLevel(&white_level));
+    if (i < 3)
+      EXPECT_EQ(white_level, nits[i]);
+    else
+      EXPECT_EQ(white_level, ColorSpace::kDefaultSDRWhiteLevel);
+
+    // Transform to the same color space, but with the LINEAR_HDR transfer
+    // function.
+    ColorSpace target(ColorSpace::PrimaryID::BT2020,
+                      ColorSpace::TransferID::LINEAR_HDR,
+                      ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+    std::unique_ptr<ColorTransform> xform(
+        ColorTransform::NewColorTransform(hdr10, target));
+
+    // Do the transform to the values in |pq_encoded_nits|.
+    ColorTransform::TriStim val(pq_encoded_nits[0], pq_encoded_nits[1],
+                                pq_encoded_nits[2]);
+    xform->Transform(&val, 1);
+
+    // The white level should be mapped to 1.
+    switch (i) {
+      case 0:
+        EXPECT_NEAR(val.x(), 1.f, kMathEpsilon);
+        break;
+      case 1:
+        EXPECT_NEAR(val.y(), 1.f, kMathEpsilon);
+        break;
+      case 2:
+        EXPECT_NEAR(val.z(), 1.f, kMathEpsilon);
+        break;
+      case 3:
+        // Check that the default white level is 100 nits.
+        EXPECT_NEAR(val.y(), 1.f, kMathEpsilon);
+        break;
+    }
+
+    // The nit ratios should be preserved by the transform.
+    EXPECT_NEAR(val.y() / val.x(), nits[1] / nits[0], kMathEpsilon);
+    EXPECT_NEAR(val.z() / val.x(), nits[2] / nits[0], kMathEpsilon);
+
+    // Test the inverse transform.
+    std::unique_ptr<ColorTransform> xform_inv(
+        ColorTransform::NewColorTransform(target, hdr10));
+    xform_inv->Transform(&val, 1);
+    EXPECT_NEAR(val.x(), pq_encoded_nits[0], kMathEpsilon);
+    EXPECT_NEAR(val.y(), pq_encoded_nits[1], kMathEpsilon);
+    EXPECT_NEAR(val.z(), pq_encoded_nits[2], kMathEpsilon);
+  }
+}
+
+TEST(ColorSpaceTest, HLGSDRWhiteLevel) {
+  // These values are (1.0f * nits[i] / kDefaultSDRWhiteLevel) converted to
+  // LINEAR_HDR via the HLG transfer function.
+  constexpr float hlg_encoded_nits[] = {
+      0.447214f,  // 0.5 * sqrt(1.0 * 80 / 100)
+      0.5f,       // 0.5 * sqrt(1.0 * 100 / 100)
+      0.65641f,   // 0.17883277 * ln(1.0 * 200 / 100 - 0.28466892) + 0.55991073
+  };
+  constexpr float nits[] = {80.f, 100.f, 200.f};
+
+  for (size_t i = 0; i < 4; ++i) {
+    // We'll set the SDR white level to the values in |nits| and also the
+    // default.
+    ColorSpace hlg = i < 3
+                         ? ColorSpace::CreateHLG().GetWithSDRWhiteLevel(nits[i])
+                         : ColorSpace::CreateHLG();
+    float white_level = 0;
+    EXPECT_TRUE(hlg.GetSDRWhiteLevel(&white_level));
+    if (i < 3)
+      EXPECT_EQ(white_level, nits[i]);
+    else
+      EXPECT_EQ(white_level, ColorSpace::kDefaultSDRWhiteLevel);
+
+    // Transform to the same color space, but with the LINEAR_HDR transfer
+    // function.
+    ColorSpace target(ColorSpace::PrimaryID::BT2020,
+                      ColorSpace::TransferID::LINEAR_HDR,
+                      ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+    std::unique_ptr<ColorTransform> xform(
+        ColorTransform::NewColorTransform(hlg, target));
+
+    // Do the transform to the values in |hlg_encoded_nits|.
+    ColorTransform::TriStim val(hlg_encoded_nits[0], hlg_encoded_nits[1],
+                                hlg_encoded_nits[2]);
+    xform->Transform(&val, 1);
+
+    // Each |hlg_encoded_nits| value should map back to 1.0f after conversion
+    // via a ColorSpace with the right SDR white level.
+    switch (i) {
+      case 0:
+        EXPECT_NEAR(val.x(), 1.f, kMathEpsilon);
+        break;
+      case 1:
+        EXPECT_NEAR(val.y(), 1.f, kMathEpsilon);
+        break;
+      case 2:
+        EXPECT_NEAR(val.z(), 1.f, kMathEpsilon);
+        break;
+      case 3:
+        // Check that the default white level is 100 nits.
+        EXPECT_NEAR(val.y(), 1.f, kMathEpsilon);
+        break;
+    }
+
+    // The nit ratios should be preserved by the transform.
+    EXPECT_NEAR(val.y() / val.x(), nits[1] / nits[0], kMathEpsilon);
+    EXPECT_NEAR(val.z() / val.x(), nits[2] / nits[0], kMathEpsilon);
+
+    // Test the inverse transform.
+    std::unique_ptr<ColorTransform> xform_inv(
+        ColorTransform::NewColorTransform(target, hlg));
+    xform_inv->Transform(&val, 1);
+    EXPECT_NEAR(val.x(), hlg_encoded_nits[0], kMathEpsilon);
+    EXPECT_NEAR(val.y(), hlg_encoded_nits[1], kMathEpsilon);
+    EXPECT_NEAR(val.z(), hlg_encoded_nits[2], kMathEpsilon);
+  }
+}
+
+TEST(ColorSpaceTest, PiecewiseHDR) {
+  // The sRGB function evaluated at a couple of test points.
+  const float srgb_x0 = 0.01;
+  const float srgb_y0 = 0.00077399380805;
+  const float srgb_x1 = 0.5;
+  const float srgb_y1 = 0.2140411174732872;
+
+  // Parameters for CreatePiecewiseHDR to test.
+  const std::vector<float> test_sdr_joints = {
+      0.25f,
+      0.5f,
+      0.75f,
+  };
+  const std::vector<float> test_hdr_levels = {
+      1.5f,
+      2.0f,
+      5.0f,
+  };
+
+  // Go through all combinations.
+  for (float sdr_joint : test_sdr_joints) {
+    for (float hdr_level : test_hdr_levels) {
+      ColorSpace hdr = ColorSpace::CreatePiecewiseHDR(
+          ColorSpace::PrimaryID::BT709, sdr_joint, hdr_level);
+      ColorSpace linear(ColorSpace::PrimaryID::BT709,
+                        ColorSpace::TransferID::LINEAR_HDR);
+      std::unique_ptr<ColorTransform> xform_to(
+          ColorTransform::NewColorTransform(hdr, linear));
+      std::unique_ptr<ColorTransform> xform_from(
+          ColorTransform::NewColorTransform(linear, hdr));
+
+      // We're going to to test both sides of the joint points. Use this
+      // epsilon, which is much smaller than kMathEpsilon, to make that
+      // adjustment.
+      const float kSideEpsilon = kMathEpsilon / 100;
+
+      const size_t kTestPointCount = 8;
+      const float test_x[kTestPointCount] = {
+          // Test the linear segment of the sRGB function.
+          srgb_x0 * sdr_joint,
+          // Test the exponential segment of the sRGB function.
+          srgb_x1 * sdr_joint,
+          // Test epsilon before the HDR joint
+          sdr_joint - kSideEpsilon,
+          // Test the HDR joint
+          sdr_joint,
+          // Test epsilon after the HDR joint
+          sdr_joint + kSideEpsilon,
+          // Test the middle of the linear HDR segment
+          sdr_joint + 0.5f * (1.f - sdr_joint),
+          // Test just before the end of the linear HDR segment.
+          1.f - kSideEpsilon,
+          // Test the endpoint of the linear HDR segment.
+          1.f,
+      };
+      const float test_y[kTestPointCount] = {
+          srgb_y0,
+          srgb_y1,
+          1.f - kSideEpsilon,
+          1.f,
+          1.f + kSideEpsilon,
+          0.5f * (1.f + hdr_level),
+          hdr_level - kSideEpsilon,
+          hdr_level,
+      };
+      for (size_t i = 0; i < kTestPointCount; ++i) {
+        ColorTransform::TriStim val;
+        val.set_x(test_x[i]);
+        xform_to->Transform(&val, 1);
+        EXPECT_NEAR(val.x(), test_y[i], kMathEpsilon)
+            << " test_x[i] is " << test_x[i];
+
+        val.set_x(test_y[i]);
+        xform_from->Transform(&val, 1);
+        EXPECT_NEAR(val.x(), test_x[i], kMathEpsilon)
+            << " test_y[i] is " << test_y[i];
+      }
+    }
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/color_utils.cc b/ui/gfx/color_utils.cc
new file mode 100644
index 0000000..06aaaf8
--- /dev/null
+++ b/ui/gfx/color_utils.cc
@@ -0,0 +1,528 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/color_utils.h"
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <cmath>
+
+#include "base/check_op.h"
+#include "base/notreached.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "build/build_config.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/color_palette.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#include "skia/ext/skia_utils_win.h"
+#endif
+
+namespace color_utils {
+
+namespace {
+
+// The darkest reference color in color_utils.
+SkColor g_darkest_color = gfx::kGoogleGrey900;
+
+// The luminance midpoint for determining if a color is light or dark.  This is
+// the value where white and g_darkest_color contrast equally.  This default
+// value is the midpoint given kGoogleGrey900 as the darkest color.
+float g_luminance_midpoint = 0.211692036f;
+
+constexpr float kWhiteLuminance = 1.0f;
+
+int calcHue(float temp1, float temp2, float hue) {
+  if (hue < 0.0f)
+    ++hue;
+  else if (hue > 1.0f)
+    --hue;
+
+  float result = temp1;
+  if (hue * 6.0f < 1.0f)
+    result = temp1 + (temp2 - temp1) * hue * 6.0f;
+  else if (hue * 2.0f < 1.0f)
+    result = temp2;
+  else if (hue * 3.0f < 2.0f)
+    result = temp1 + (temp2 - temp1) * (2.0f / 3.0f - hue) * 6.0f;
+
+  return base::ClampRound(result * 255);
+}
+
+// Assumes sRGB.
+float Linearize(float eight_bit_component) {
+  const float component = eight_bit_component / 255.0f;
+  // The W3C link in the header uses 0.03928 here.  See
+  // https://en.wikipedia.org/wiki/SRGB#Theory_of_the_transformation for
+  // discussion of why we use this value rather than that one.
+  return (component <= 0.04045f) ? (component / 12.92f)
+                                 : pow((component + 0.055f) / 1.055f, 2.4f);
+}
+
+constexpr size_t kNumGoogleColors = 10;
+constexpr SkColor kGrey[kNumGoogleColors] = {
+    gfx::kGoogleGrey050, gfx::kGoogleGrey100, gfx::kGoogleGrey200,
+    gfx::kGoogleGrey300, gfx::kGoogleGrey400, gfx::kGoogleGrey500,
+    gfx::kGoogleGrey600, gfx::kGoogleGrey700, gfx::kGoogleGrey800,
+    gfx::kGoogleGrey900,
+};
+
+constexpr SkColor kRed[kNumGoogleColors] = {
+    gfx::kGoogleRed050, gfx::kGoogleRed100, gfx::kGoogleRed200,
+    gfx::kGoogleRed300, gfx::kGoogleRed400, gfx::kGoogleRed500,
+    gfx::kGoogleRed600, gfx::kGoogleRed700, gfx::kGoogleRed800,
+    gfx::kGoogleRed900,
+};
+
+constexpr SkColor kOrange[kNumGoogleColors] = {
+    gfx::kGoogleOrange050, gfx::kGoogleOrange100, gfx::kGoogleOrange200,
+    gfx::kGoogleOrange300, gfx::kGoogleOrange400, gfx::kGoogleOrange500,
+    gfx::kGoogleOrange600, gfx::kGoogleOrange700, gfx::kGoogleOrange800,
+    gfx::kGoogleOrange900,
+};
+
+constexpr SkColor kYellow[kNumGoogleColors] = {
+    gfx::kGoogleYellow050, gfx::kGoogleYellow100, gfx::kGoogleYellow200,
+    gfx::kGoogleYellow300, gfx::kGoogleYellow400, gfx::kGoogleYellow500,
+    gfx::kGoogleYellow600, gfx::kGoogleYellow700, gfx::kGoogleYellow800,
+    gfx::kGoogleYellow900,
+};
+
+constexpr SkColor kGreen[kNumGoogleColors] = {
+    gfx::kGoogleGreen050, gfx::kGoogleGreen100, gfx::kGoogleGreen200,
+    gfx::kGoogleGreen300, gfx::kGoogleGreen400, gfx::kGoogleGreen500,
+    gfx::kGoogleGreen600, gfx::kGoogleGreen700, gfx::kGoogleGreen800,
+    gfx::kGoogleGreen900,
+};
+
+constexpr SkColor kBlue[kNumGoogleColors] = {
+    gfx::kGoogleBlue050, gfx::kGoogleBlue100, gfx::kGoogleBlue200,
+    gfx::kGoogleBlue300, gfx::kGoogleBlue400, gfx::kGoogleBlue500,
+    gfx::kGoogleBlue600, gfx::kGoogleBlue700, gfx::kGoogleBlue800,
+    gfx::kGoogleBlue900,
+};
+
+constexpr SkColor kPurple[kNumGoogleColors] = {
+    gfx::kGooglePurple050, gfx::kGooglePurple100, gfx::kGooglePurple200,
+    gfx::kGooglePurple300, gfx::kGooglePurple400, gfx::kGooglePurple500,
+    gfx::kGooglePurple600, gfx::kGooglePurple700, gfx::kGooglePurple800,
+    gfx::kGooglePurple900,
+};
+
+constexpr SkColor kPink[kNumGoogleColors] = {
+    gfx::kGooglePink050, gfx::kGooglePink100, gfx::kGooglePink200,
+    gfx::kGooglePink300, gfx::kGooglePink400, gfx::kGooglePink500,
+    gfx::kGooglePink600, gfx::kGooglePink700, gfx::kGooglePink800,
+    gfx::kGooglePink900,
+};
+
+SkColor PickGoogleColor(const SkColor (&colors)[kNumGoogleColors],
+                        SkColor background_color,
+                        float min_contrast) {
+  // For dark backgrounds we start at 500 and go down (toward brighter colors).
+  constexpr size_t kDarkBackgroundStartIndex = 5;
+  static_assert(kBlue[kDarkBackgroundStartIndex] == gfx::kGoogleBlue500,
+                "The start index needs to match kGoogleBlue500");
+  const float background_luminance = GetRelativeLuminance(background_color);
+  if (IsDark(background_color)) {
+    for (size_t i = kDarkBackgroundStartIndex; i > 0; --i) {
+      if (GetContrastRatio(GetRelativeLuminance(colors[i]),
+                           background_luminance) > min_contrast) {
+        return colors[i];
+      }
+    }
+    return colors[0];
+  }
+
+  // For light backgrounds we start at 400 and go up (toward darker colors).
+  constexpr size_t kLightBackgroundStartIndex = 4;
+  static_assert(kBlue[kLightBackgroundStartIndex] == gfx::kGoogleBlue400,
+                "The start index needs to match kGoogleBlue400");
+  for (size_t i = kLightBackgroundStartIndex; i < kNumGoogleColors - 1; ++i) {
+    if (GetContrastRatio(GetRelativeLuminance(colors[i]),
+                         background_luminance) > min_contrast) {
+      return colors[i];
+    }
+  }
+  return colors[kNumGoogleColors - 1];
+}
+
+}  // namespace
+
+SkColor PickGoogleColor(SkColor color,
+                        SkColor background_color,
+                        float min_contrast) {
+  HSL hsl;
+  SkColorToHSL(color, &hsl);
+  if (hsl.s < 0.1) {
+    // Low saturation, let this be a grey.
+    return PickGoogleColor(kGrey, background_color, min_contrast);
+  }
+
+  // Map hue to angles for readability.
+  const float color_angle = hsl.h * 360;
+
+  // Hues in comments below are accent colors from MacOS 11.3.1 light mode as
+  // point of reference.
+  // TODO(pbos): Complement this with more Google colors and verify the hue
+  // ranges, this currently knows about enough colors to pick a corresponding
+  // color correctly from MacOS accent colors.
+  // RED: 357.654
+  if (color_angle < 20)
+    return PickGoogleColor(kRed, background_color, min_contrast);
+  // ORANGE: 28.0687
+  if (color_angle < 40)
+    return PickGoogleColor(kOrange, background_color, min_contrast);
+  // YELLOW: 44.4156
+  if (color_angle < 70)
+    return PickGoogleColor(kYellow, background_color, min_contrast);
+  // GREEN: 105.484
+  if (color_angle < 160)
+    return PickGoogleColor(kGreen, background_color, min_contrast);
+  // BLUE: 214.672
+  if (color_angle < 250)
+    return PickGoogleColor(kBlue, background_color, min_contrast);
+  // PURPLE: 299.362
+  if (color_angle < 310)
+    return PickGoogleColor(kPurple, background_color, min_contrast);
+  // PINK: 331.685
+  if (color_angle < 345)
+    return PickGoogleColor(kPink, background_color, min_contrast);
+
+  // End of hue wheel is red.
+  return PickGoogleColor(kRed, background_color, min_contrast);
+}
+
+float GetContrastRatio(SkColor color_a, SkColor color_b) {
+  return GetContrastRatio(GetRelativeLuminance(color_a),
+                          GetRelativeLuminance(color_b));
+}
+
+float GetContrastRatio(float luminance_a, float luminance_b) {
+  DCHECK_GE(luminance_a, 0.0f);
+  DCHECK_GE(luminance_b, 0.0f);
+  luminance_a += 0.05f;
+  luminance_b += 0.05f;
+  return (luminance_a > luminance_b) ? (luminance_a / luminance_b)
+                                     : (luminance_b / luminance_a);
+}
+
+float GetRelativeLuminance(SkColor color) {
+  return (0.2126f * Linearize(SkColorGetR(color))) +
+         (0.7152f * Linearize(SkColorGetG(color))) +
+         (0.0722f * Linearize(SkColorGetB(color)));
+}
+
+uint8_t GetLuma(SkColor color) {
+  return base::ClampRound<uint8_t>(0.299f * SkColorGetR(color) +
+                                   0.587f * SkColorGetG(color) +
+                                   0.114f * SkColorGetB(color));
+}
+
+void SkColorToHSL(SkColor c, HSL* hsl) {
+  float r = SkColorGetR(c) / 255.0f;
+  float g = SkColorGetG(c) / 255.0f;
+  float b = SkColorGetB(c) / 255.0f;
+  float vmax = std::max({r, g, b});
+  float vmin = std::min({r, g, b});
+  float delta = vmax - vmin;
+  hsl->l = (vmax + vmin) / 2;
+  if (SkColorGetR(c) == SkColorGetG(c) && SkColorGetR(c) == SkColorGetB(c)) {
+    hsl->h = hsl->s = 0;
+  } else {
+    float dr = (((vmax - r) / 6.0f) + (delta / 2.0f)) / delta;
+    float dg = (((vmax - g) / 6.0f) + (delta / 2.0f)) / delta;
+    float db = (((vmax - b) / 6.0f) + (delta / 2.0f)) / delta;
+    // We need to compare for the max value because comparing vmax to r, g, or b
+    // can sometimes result in values overflowing registers.
+    if (r >= g && r >= b)
+      hsl->h = db - dg;
+    else if (g >= r && g >= b)
+      hsl->h = (1.0f / 3.0f) + dr - db;
+    else  // (b >= r && b >= g)
+      hsl->h = (2.0f / 3.0f) + dg - dr;
+
+    if (hsl->h < 0.0f)
+      ++hsl->h;
+    else if (hsl->h > 1.0f)
+      --hsl->h;
+
+    hsl->s = delta / ((hsl->l < 0.5f) ? (vmax + vmin) : (2 - vmax - vmin));
+  }
+}
+
+SkColor HSLToSkColor(const HSL& hsl, SkAlpha alpha) {
+  float hue = hsl.h;
+  float saturation = hsl.s;
+  float lightness = hsl.l;
+
+  // If there's no color, we don't care about hue and can do everything based on
+  // brightness.
+  if (!saturation) {
+    const uint8_t light = base::ClampRound<uint8_t>(lightness * 255);
+    return SkColorSetARGB(alpha, light, light, light);
+  }
+
+  float temp2 = (lightness < 0.5f)
+                    ? (lightness * (1.0f + saturation))
+                    : (lightness + saturation - (lightness * saturation));
+  float temp1 = 2.0f * lightness - temp2;
+  return SkColorSetARGB(alpha, calcHue(temp1, temp2, hue + 1.0f / 3.0f),
+                        calcHue(temp1, temp2, hue),
+                        calcHue(temp1, temp2, hue - 1.0f / 3.0f));
+}
+
+bool IsWithinHSLRange(const HSL& hsl,
+                      const HSL& lower_bound,
+                      const HSL& upper_bound) {
+  DCHECK(hsl.h >= 0 && hsl.h <= 1) << hsl.h;
+  DCHECK(hsl.s >= 0 && hsl.s <= 1) << hsl.s;
+  DCHECK(hsl.l >= 0 && hsl.l <= 1) << hsl.l;
+  DCHECK(lower_bound.h < 0 || upper_bound.h < 0 ||
+         (lower_bound.h <= 1 && upper_bound.h <= lower_bound.h + 1))
+      << "lower_bound.h: " << lower_bound.h
+      << ", upper_bound.h: " << upper_bound.h;
+  DCHECK(lower_bound.s < 0 || upper_bound.s < 0 ||
+         (lower_bound.s <= upper_bound.s && upper_bound.s <= 1))
+      << "lower_bound.s: " << lower_bound.s
+      << ", upper_bound.s: " << upper_bound.s;
+  DCHECK(lower_bound.l < 0 || upper_bound.l < 0 ||
+         (lower_bound.l <= upper_bound.l && upper_bound.l <= 1))
+      << "lower_bound.l: " << lower_bound.l
+      << ", upper_bound.l: " << upper_bound.l;
+
+  // If the upper hue is >1, the given hue bounds wrap around at 1.
+  bool matches_hue = upper_bound.h > 1
+                         ? hsl.h >= lower_bound.h || hsl.h <= upper_bound.h - 1
+                         : hsl.h >= lower_bound.h && hsl.h <= upper_bound.h;
+  return (upper_bound.h < 0 || lower_bound.h < 0 || matches_hue) &&
+         (upper_bound.s < 0 || lower_bound.s < 0 ||
+          (hsl.s >= lower_bound.s && hsl.s <= upper_bound.s)) &&
+         (upper_bound.l < 0 || lower_bound.l < 0 ||
+          (hsl.l >= lower_bound.l && hsl.l <= upper_bound.l));
+}
+
+void MakeHSLShiftValid(HSL* hsl) {
+  if (hsl->h < 0 || hsl->h > 1)
+    hsl->h = -1;
+  if (hsl->s < 0 || hsl->s > 1)
+    hsl->s = -1;
+  if (hsl->l < 0 || hsl->l > 1)
+    hsl->l = -1;
+}
+
+bool IsHSLShiftMeaningful(const HSL& hsl) {
+  // -1 in any channel has no effect, and 0.5 has no effect for S/L.  A shift
+  // with an effective value in ANY channel is meaningful.
+  return hsl.h != -1 || (hsl.s != -1 && hsl.s != 0.5) ||
+         (hsl.l != -1 && hsl.l != 0.5);
+}
+
+SkColor HSLShift(SkColor color, const HSL& shift) {
+  SkAlpha alpha = SkColorGetA(color);
+
+  if (shift.h >= 0 || shift.s >= 0) {
+    HSL hsl;
+    SkColorToHSL(color, &hsl);
+
+    // Replace the hue with the tint's hue.
+    if (shift.h >= 0)
+      hsl.h = shift.h;
+
+    // Change the saturation.
+    if (shift.s >= 0) {
+      if (shift.s <= 0.5f)
+        hsl.s *= shift.s * 2.0f;
+      else
+        hsl.s += (1.0f - hsl.s) * ((shift.s - 0.5f) * 2.0f);
+    }
+
+    color = HSLToSkColor(hsl, alpha);
+  }
+
+  if (shift.l < 0)
+    return color;
+
+  // Lightness shifts in the style of popular image editors aren't actually
+  // represented in HSL - the L value does have some effect on saturation.
+  float r = static_cast<float>(SkColorGetR(color));
+  float g = static_cast<float>(SkColorGetG(color));
+  float b = static_cast<float>(SkColorGetB(color));
+  if (shift.l <= 0.5f) {
+    r *= (shift.l * 2.0f);
+    g *= (shift.l * 2.0f);
+    b *= (shift.l * 2.0f);
+  } else {
+    r += (255.0f - r) * ((shift.l - 0.5f) * 2.0f);
+    g += (255.0f - g) * ((shift.l - 0.5f) * 2.0f);
+    b += (255.0f - b) * ((shift.l - 0.5f) * 2.0f);
+  }
+  return SkColorSetARGB(alpha, base::ClampRound<U8CPU>(r),
+                        base::ClampRound<U8CPU>(g), base::ClampRound<U8CPU>(b));
+}
+
+SkColor AlphaBlend(SkColor foreground, SkColor background, SkAlpha alpha) {
+  return AlphaBlend(foreground, background, alpha / 255.0f);
+}
+
+SkColor AlphaBlend(SkColor foreground, SkColor background, float alpha) {
+  DCHECK_GE(alpha, 0.0f);
+  DCHECK_LE(alpha, 1.0f);
+
+  if (alpha == 0.0f)
+    return background;
+  if (alpha == 1.0f)
+    return foreground;
+
+  int f_alpha = SkColorGetA(foreground);
+  int b_alpha = SkColorGetA(background);
+
+  float normalizer = f_alpha * alpha + b_alpha * (1.0f - alpha);
+  if (normalizer == 0.0f)
+    return SK_ColorTRANSPARENT;
+
+  float f_weight = f_alpha * alpha / normalizer;
+  float b_weight = b_alpha * (1.0f - alpha) / normalizer;
+
+  float r =
+      SkColorGetR(foreground) * f_weight + SkColorGetR(background) * b_weight;
+  float g =
+      SkColorGetG(foreground) * f_weight + SkColorGetG(background) * b_weight;
+  float b =
+      SkColorGetB(foreground) * f_weight + SkColorGetB(background) * b_weight;
+
+  return SkColorSetARGB(base::ClampRound<U8CPU>(normalizer),
+                        base::ClampRound<U8CPU>(r), base::ClampRound<U8CPU>(g),
+                        base::ClampRound<U8CPU>(b));
+}
+
+SkColor GetResultingPaintColor(SkColor foreground, SkColor background) {
+  return AlphaBlend(SkColorSetA(foreground, SK_AlphaOPAQUE), background,
+                    static_cast<SkAlpha>(SkColorGetA(foreground)));
+}
+
+bool IsDark(SkColor color) {
+  return GetRelativeLuminance(color) < g_luminance_midpoint;
+}
+
+SkColor GetColorWithMaxContrast(SkColor color) {
+  return IsDark(color) ? SK_ColorWHITE : g_darkest_color;
+}
+
+SkColor GetEndpointColorWithMinContrast(SkColor color) {
+  return IsDark(color) ? g_darkest_color : SK_ColorWHITE;
+}
+
+SkColor BlendTowardMaxContrast(SkColor color, SkAlpha alpha) {
+  SkAlpha original_alpha = SkColorGetA(color);
+  SkColor blended_color = AlphaBlend(GetColorWithMaxContrast(color),
+                                     SkColorSetA(color, SK_AlphaOPAQUE), alpha);
+  return SkColorSetA(blended_color, original_alpha);
+}
+
+SkColor PickContrastingColor(SkColor foreground1,
+                             SkColor foreground2,
+                             SkColor background) {
+  const float background_luminance = GetRelativeLuminance(background);
+  return (GetContrastRatio(GetRelativeLuminance(foreground1),
+                           background_luminance) >=
+          GetContrastRatio(GetRelativeLuminance(foreground2),
+                           background_luminance)) ?
+      foreground1 : foreground2;
+}
+
+BlendResult BlendForMinContrast(
+    SkColor default_foreground,
+    SkColor background,
+    absl::optional<SkColor> high_contrast_foreground,
+    float contrast_ratio) {
+  DCHECK_EQ(SkColorGetA(background), SK_AlphaOPAQUE);
+  default_foreground = GetResultingPaintColor(default_foreground, background);
+  if (GetContrastRatio(default_foreground, background) >= contrast_ratio)
+    return {SK_AlphaTRANSPARENT, default_foreground};
+  const SkColor target_foreground = GetResultingPaintColor(
+      high_contrast_foreground.value_or(GetColorWithMaxContrast(background)),
+      background);
+
+  const float background_luminance = GetRelativeLuminance(background);
+
+  SkAlpha best_alpha = SK_AlphaOPAQUE;
+  SkColor best_color = target_foreground;
+  // Use int for inclusive lower bound and exclusive upper bound, reserving
+  // conversion to SkAlpha for the end (reduces casts).
+  for (int low = SK_AlphaTRANSPARENT, high = SK_AlphaOPAQUE + 1; low < high;) {
+    const SkAlpha alpha = (low + high) / 2;
+    const SkColor color =
+        AlphaBlend(target_foreground, default_foreground, alpha);
+    const float luminance = GetRelativeLuminance(color);
+    const float contrast = GetContrastRatio(luminance, background_luminance);
+    if (contrast >= contrast_ratio) {
+      best_alpha = alpha;
+      best_color = color;
+      high = alpha;
+    } else {
+      low = alpha + 1;
+    }
+  }
+  return {best_alpha, best_color};
+}
+
+SkColor InvertColor(SkColor color) {
+  return SkColorSetARGB(SkColorGetA(color), 255 - SkColorGetR(color),
+                        255 - SkColorGetG(color), 255 - SkColorGetB(color));
+}
+
+SkColor GetSysSkColor(int which) {
+#if defined(OS_WIN)
+  return skia::COLORREFToSkColor(GetSysColor(which));
+#else
+  NOTIMPLEMENTED();
+  return SK_ColorLTGRAY;
+#endif
+}
+
+SkColor DeriveDefaultIconColor(SkColor text_color) {
+  // Lighten dark colors and brighten light colors. The alpha value here (0x4c)
+  // is chosen to generate a value close to GoogleGrey700 from GoogleGrey900.
+  return BlendTowardMaxContrast(text_color, 0x4c);
+}
+
+std::string SkColorToRgbaString(SkColor color) {
+  // We convert the alpha using NumberToString because StringPrintf will use
+  // locale specific formatters (e.g., use , instead of . in German).
+  return base::StringPrintf(
+      "rgba(%s,%s)", SkColorToRgbString(color).c_str(),
+      base::NumberToString(SkColorGetA(color) / 255.0).c_str());
+}
+
+std::string SkColorToRgbString(SkColor color) {
+  return base::StringPrintf("%d,%d,%d", SkColorGetR(color), SkColorGetG(color),
+                            SkColorGetB(color));
+}
+
+SkColor SetDarkestColorForTesting(SkColor color) {
+  const SkColor previous_darkest_color = g_darkest_color;
+  g_darkest_color = color;
+
+  const float dark_luminance = GetRelativeLuminance(color);
+  // We want to compute |g_luminance_midpoint| such that
+  // GetContrastRatio(dark_luminance, g_luminance_midpoint) ==
+  // GetContrastRatio(kWhiteLuminance, g_luminance_midpoint).  The formula below
+  // can be verified by plugging it into how GetContrastRatio() operates.
+  g_luminance_midpoint =
+      std::sqrt((dark_luminance + 0.05f) * (kWhiteLuminance + 0.05f)) - 0.05f;
+
+  return previous_darkest_color;
+}
+
+std::tuple<float, float, float> GetLuminancesForTesting() {
+  return std::make_tuple(GetRelativeLuminance(g_darkest_color),
+                         g_luminance_midpoint, kWhiteLuminance);
+}
+
+}  // namespace color_utils
diff --git a/ui/gfx/color_utils.h b/ui/gfx/color_utils.h
new file mode 100644
index 0000000..5d5c430
--- /dev/null
+++ b/ui/gfx/color_utils.h
@@ -0,0 +1,183 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_COLOR_UTILS_H_
+#define UI_GFX_COLOR_UTILS_H_
+
+#include <string>
+#include <tuple>
+
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace color_utils {
+
+// Represents an HSL color.
+struct HSL {
+  double h;
+  double s;
+  double l;
+};
+
+// The blend alpha and resulting color when blending to achieve a desired
+// contrast raio.
+struct BlendResult {
+  SkAlpha alpha;
+  SkColor color;
+};
+
+// The minimum contrast between text and background that is still readable.
+// This value is taken from w3c accessibility guidelines.
+constexpr float kMinimumReadableContrastRatio = 4.5f;
+
+// The minimum contrast between button glyphs, focus indicators, large text, or
+// other "have to see it but perhaps don't have to read fine detail" cases and
+// background.
+constexpr float kMinimumVisibleContrastRatio = 3.0f;
+
+// Determines the contrast ratio of two colors or two relative luminance values
+// (as computed by RelativeLuminance()), calculated according to
+// http://www.w3.org/TR/WCAG20/#contrast-ratiodef .
+GFX_EXPORT float GetContrastRatio(SkColor color_a, SkColor color_b);
+GFX_EXPORT float GetContrastRatio(float luminance_a, float luminance_b);
+
+// The relative luminance of |color|, that is, the weighted sum of the
+// linearized RGB components, normalized to 0..1, per BT.709.  See
+// http://www.w3.org/TR/WCAG20/#relativeluminancedef .
+GFX_EXPORT float GetRelativeLuminance(SkColor color);
+
+// The luma of |color|, that is, the weighted sum of the gamma-compressed R'G'B'
+// components, per BT.601, a.k.a. the Y' in Y'UV.  See
+// https://en.wikipedia.org/wiki/Luma_(video).
+GFX_EXPORT uint8_t GetLuma(SkColor color);
+
+// Note: these transformations assume sRGB as the source color space
+GFX_EXPORT void SkColorToHSL(SkColor c, HSL* hsl);
+GFX_EXPORT SkColor HSLToSkColor(const HSL& hsl, SkAlpha alpha);
+
+// Determines whether the given |hsl| falls within the given range for each
+// component. All components of |hsl| are expected to be in the range [0, 1].
+//
+// If a component is negative in either |lower_bound| or |upper_bound|, that
+// component will be ignored.
+//
+// For hue, the lower bound should be in the range [0, 1] and the upper bound
+// should be in the range [(lower bound), (lower bound + 1)].
+// For saturation and value, bounds should be specified in the range [0, 1],
+// with the lower bound less than the upper bound.
+GFX_EXPORT bool IsWithinHSLRange(const HSL& hsl,
+                                 const HSL& lower_bound,
+                                 const HSL& upper_bound);
+
+// Makes |hsl| valid input for HSLShift(). Sets values of hue, saturation
+// and lightness which are outside of the valid range [0, 1] to -1.  -1 is a
+// special value which indicates 'no change'.
+GFX_EXPORT void MakeHSLShiftValid(HSL* hsl);
+
+// Returns whether pasing |hsl| to HSLShift() would have any effect.  Assumes
+// |hsl| is a valid shift (as defined by MakeHSLShiftValid()).
+GFX_EXPORT bool IsHSLShiftMeaningful(const HSL& hsl);
+
+// HSL-Shift an SkColor. The shift values are in the range of 0-1, with the
+// option to specify -1 for 'no change'. The shift values are defined as:
+// hsl_shift[0] (hue): The absolute hue value - 0 and 1 map
+//    to 0 and 360 on the hue color wheel (red).
+// hsl_shift[1] (saturation): A saturation shift, with the
+//    following key values:
+//    0 = remove all color.
+//    0.5 = leave unchanged.
+//    1 = fully saturate the image.
+// hsl_shift[2] (lightness): A lightness shift, with the
+//    following key values:
+//    0 = remove all lightness (make all pixels black).
+//    0.5 = leave unchanged.
+//    1 = full lightness (make all pixels white).
+GFX_EXPORT SkColor HSLShift(SkColor color, const HSL& shift);
+
+// Returns a blend of the supplied colors, ranging from |background| (for
+// |alpha| == 0) to |foreground| (for |alpha| == 255). The alpha channels of
+// the supplied colors are also taken into account, so the returned color may
+// be partially transparent.
+GFX_EXPORT SkColor AlphaBlend(SkColor foreground,
+                              SkColor background,
+                              SkAlpha alpha);
+
+// As above, but with alpha specified as 0..1.
+GFX_EXPORT SkColor AlphaBlend(SkColor foreground,
+                              SkColor background,
+                              float alpha);
+
+// Returns the color that results from painting |foreground| on top of
+// |background|.
+GFX_EXPORT SkColor GetResultingPaintColor(SkColor foreground,
+                                          SkColor background);
+
+// Returns true if |color| contrasts more with white than the darkest color.
+GFX_EXPORT bool IsDark(SkColor color);
+
+// Returns whichever of white or the darkest available color contrasts more with
+// |color|.
+GFX_EXPORT SkColor GetColorWithMaxContrast(SkColor color);
+
+// Returns whichever of white or the darkest available color contrasts less with
+// |color|.
+GFX_EXPORT SkColor GetEndpointColorWithMinContrast(SkColor color);
+
+// Blends towards the color with max contrast by |alpha|. The alpha of
+// the original color is preserved.
+GFX_EXPORT SkColor BlendTowardMaxContrast(SkColor color, SkAlpha alpha);
+
+// Returns whichever of |foreground1| or |foreground2| has higher contrast with
+// |background|.
+GFX_EXPORT SkColor PickContrastingColor(SkColor foreground1,
+                                        SkColor foreground2,
+                                        SkColor background);
+
+// Alpha-blends |default_foreground| toward either |high_contrast_foreground|
+// (if specified) or the color with max contrast with |background| until either
+// the result has a contrast ratio against |background| of at least
+// |contrast_ratio| or the blend can go no further.  Returns the blended color
+// and the alpha used to achieve that blend.  If |default_foreground| already
+// has sufficient contrast, returns an alpha of 0 and color of
+// |default_foreground|.
+GFX_EXPORT BlendResult BlendForMinContrast(
+    SkColor default_foreground,
+    SkColor background,
+    absl::optional<SkColor> high_contrast_foreground = absl::nullopt,
+    float contrast_ratio = kMinimumReadableContrastRatio);
+
+// Invert a color.
+GFX_EXPORT SkColor InvertColor(SkColor color);
+
+// Gets a Windows system color as a SkColor
+GFX_EXPORT SkColor GetSysSkColor(int which);
+
+// Derives a color for icons on a UI surface based on the text color on the same
+// surface.
+GFX_EXPORT SkColor DeriveDefaultIconColor(SkColor text_color);
+
+// Gets a Google color that matches the hue of `color` and contrasts well
+// enough against `background_color` to meet `min_contrast`. If `color` isn't
+// very saturated, grey will be used instead.
+GFX_EXPORT SkColor PickGoogleColor(SkColor color,
+                                   SkColor background_color,
+                                   float min_contrast);
+
+// Creates an rgba string for an SkColor. For example: 'rgba(255,0,255,0.5)'.
+GFX_EXPORT std::string SkColorToRgbaString(SkColor color);
+
+// Creates an rgb string for an SkColor. For example: '255,0,255'.
+GFX_EXPORT std::string SkColorToRgbString(SkColor color);
+
+// Sets the darkest available color to |color|.  Returns the previous darkest
+// color.
+GFX_EXPORT SkColor SetDarkestColorForTesting(SkColor color);
+
+// Returns the luminance of the darkest, midpoint, and lightest colors.
+GFX_EXPORT std::tuple<float, float, float> GetLuminancesForTesting();
+
+}  // namespace color_utils
+
+#endif  // UI_GFX_COLOR_UTILS_H_
diff --git a/ui/gfx/color_utils_unittest.cc b/ui/gfx/color_utils_unittest.cc
new file mode 100644
index 0000000..d3d35e1
--- /dev/null
+++ b/ui/gfx/color_utils_unittest.cc
@@ -0,0 +1,313 @@
+// Copyright (c) 2006-2008 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.
+
+#include <stdlib.h>
+
+#include "skia/ext/platform_canvas.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkColorPriv.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace color_utils {
+
+TEST(ColorUtils, SkColorToHSLRed) {
+  HSL hsl = {0, 0, 0};
+  SkColorToHSL(SK_ColorRED, &hsl);
+  EXPECT_DOUBLE_EQ(hsl.h, 0);
+  EXPECT_DOUBLE_EQ(hsl.s, 1);
+  EXPECT_DOUBLE_EQ(hsl.l, 0.5);
+}
+
+TEST(ColorUtils, SkColorToHSLGrey) {
+  HSL hsl = {0, 0, 0};
+  SkColorToHSL(SkColorSetARGB(255, 128, 128, 128), &hsl);
+  EXPECT_DOUBLE_EQ(hsl.h, 0);
+  EXPECT_DOUBLE_EQ(hsl.s, 0);
+  EXPECT_EQ(static_cast<int>(hsl.l * 100),
+            static_cast<int>(0.5 * 100));  // Accurate to two decimal places.
+}
+
+TEST(ColorUtils, HSLToSkColorWithAlpha) {
+  SkColor red = SkColorSetARGB(128, 255, 0, 0);
+  HSL hsl = {0, 1, 0.5};
+  SkColor result = HSLToSkColor(hsl, 128);
+  EXPECT_EQ(SkColorGetA(red), SkColorGetA(result));
+  EXPECT_EQ(SkColorGetR(red), SkColorGetR(result));
+  EXPECT_EQ(SkColorGetG(red), SkColorGetG(result));
+  EXPECT_EQ(SkColorGetB(red), SkColorGetB(result));
+}
+
+TEST(ColorUtils, RGBtoHSLRoundTrip) {
+  // Just spot check values near the edges.
+  for (int r = 0; r < 10; ++r) {
+    for (int g = 0; g < 10; ++g) {
+      for (int b = 0; b < 10; ++b) {
+        SkColor rgb = SkColorSetARGB(255, r, g, b);
+        HSL hsl = {0, 0, 0};
+        SkColorToHSL(rgb, &hsl);
+        SkColor out = HSLToSkColor(hsl, 255);
+        EXPECT_EQ(SkColorGetR(out), SkColorGetR(rgb));
+        EXPECT_EQ(SkColorGetG(out), SkColorGetG(rgb));
+        EXPECT_EQ(SkColorGetB(out), SkColorGetB(rgb));
+      }
+    }
+  }
+  for (int r = 240; r < 256; ++r) {
+    for (int g = 240; g < 256; ++g) {
+      for (int b = 240; b < 256; ++b) {
+        SkColor rgb = SkColorSetARGB(255, r, g, b);
+        HSL hsl = {0, 0, 0};
+        SkColorToHSL(rgb, &hsl);
+        SkColor out = HSLToSkColor(hsl, 255);
+        EXPECT_EQ(SkColorGetR(out), SkColorGetR(rgb));
+        EXPECT_EQ(SkColorGetG(out), SkColorGetG(rgb));
+        EXPECT_EQ(SkColorGetB(out), SkColorGetB(rgb));
+      }
+    }
+  }
+}
+
+TEST(ColorUtils, IsWithinHSLRange) {
+  HSL hsl = {0.3, 0.4, 0.5};
+  HSL lower = {0.2, 0.3, 0.4};
+  HSL upper = {0.4, 0.5, 0.6};
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+  // Bounds are inclusive.
+  hsl.h = 0.2;
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+  hsl.h = 0.4;
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+  hsl.s = 0.3;
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+  hsl.s = 0.5;
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+  hsl.l = 0.4;
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+  hsl.l = 0.6;
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+}
+
+TEST(ColorUtils, IsWithinHSLRangeHueWrapAround) {
+  HSL hsl = {0.3, 0.4, 0.5};
+  HSL lower = {0.8, -1, -1};
+  HSL upper = {1.2, -1, -1};
+  hsl.h = 0.1;
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+  hsl.h = 0.9;
+  EXPECT_TRUE(IsWithinHSLRange(hsl, lower, upper));
+  hsl.h = 0.3;
+  EXPECT_FALSE(IsWithinHSLRange(hsl, lower, upper));
+}
+
+TEST(ColorUtils, IsHSLShiftMeaningful) {
+  HSL noop_all_neg_one{-1.0, -1.0, -1.0};
+  HSL noop_s_point_five{-1.0, 0.5, -1.0};
+  HSL noop_l_point_five{-1.0, -1.0, 0.5};
+
+  HSL only_h{0.1, -1.0, -1.0};
+  HSL only_s{-1.0, 0.1, -1.0};
+  HSL only_l{-1.0, -1.0, 0.1};
+  HSL only_hs{0.1, 0.1, -1.0};
+  HSL only_hl{0.1, -1.0, 0.1};
+  HSL only_sl{-1.0, 0.1, 0.1};
+  HSL all_set{0.1, 0.2, 0.3};
+
+  EXPECT_FALSE(IsHSLShiftMeaningful(noop_all_neg_one));
+  EXPECT_FALSE(IsHSLShiftMeaningful(noop_s_point_five));
+  EXPECT_FALSE(IsHSLShiftMeaningful(noop_l_point_five));
+
+  EXPECT_TRUE(IsHSLShiftMeaningful(only_h));
+  EXPECT_TRUE(IsHSLShiftMeaningful(only_s));
+  EXPECT_TRUE(IsHSLShiftMeaningful(only_l));
+  EXPECT_TRUE(IsHSLShiftMeaningful(only_hs));
+  EXPECT_TRUE(IsHSLShiftMeaningful(only_hl));
+  EXPECT_TRUE(IsHSLShiftMeaningful(only_sl));
+  EXPECT_TRUE(IsHSLShiftMeaningful(all_set));
+}
+
+TEST(ColorUtils, ColorToHSLRegisterSpill) {
+  // In a opt build on Linux, this was causing a register spill on my laptop
+  // (Pentium M) when converting from SkColor to HSL.
+  SkColor input = SkColorSetARGB(255, 206, 154, 89);
+  HSL hsl = {-1, -1, -1};
+  SkColor result = HSLShift(input, hsl);
+  // |result| should be the same as |input| since we passed in a value meaning
+  // no color shift.
+  EXPECT_EQ(SkColorGetA(input), SkColorGetA(result));
+  EXPECT_EQ(SkColorGetR(input), SkColorGetR(result));
+  EXPECT_EQ(SkColorGetG(input), SkColorGetG(result));
+  EXPECT_EQ(SkColorGetB(input), SkColorGetB(result));
+}
+
+TEST(ColorUtils, AlphaBlend) {
+  SkColor fore = SkColorSetARGB(255, 200, 200, 200);
+  SkColor back = SkColorSetARGB(255, 100, 100, 100);
+
+  EXPECT_TRUE(AlphaBlend(fore, back, 1.0f) == fore);
+  EXPECT_TRUE(AlphaBlend(fore, back, 0.0f) == back);
+
+  // One is fully transparent, result is partially transparent.
+  back = SkColorSetA(back, 0);
+  EXPECT_EQ(136U, SkColorGetA(AlphaBlend(fore, back, SkAlpha{136})));
+
+  // Both are fully transparent, result is fully transparent.
+  fore = SkColorSetA(fore, 0);
+  EXPECT_EQ(0U, SkColorGetA(AlphaBlend(fore, back, 1.0f)));
+}
+
+TEST(ColorUtils, SkColorToRgbaString) {
+  SkColor color = SkColorSetARGB(153, 100, 150, 200);
+  std::string color_string = SkColorToRgbaString(color);
+  EXPECT_EQ(color_string, "rgba(100,150,200,0.6)");
+}
+
+TEST(ColorUtils, SkColorToRgbString) {
+  SkColor color = SkColorSetARGB(200, 50, 100, 150);
+  std::string color_string = SkColorToRgbString(color);
+  EXPECT_EQ(color_string, "50,100,150");
+}
+
+TEST(ColorUtils, IsDarkDarkestColorChange) {
+  ASSERT_FALSE(IsDark(SK_ColorLTGRAY));
+  const SkColor old_darkest_color = SetDarkestColorForTesting(SK_ColorLTGRAY);
+  EXPECT_TRUE(IsDark(SK_ColorLTGRAY));
+
+  SetDarkestColorForTesting(old_darkest_color);
+}
+
+TEST(ColorUtils, MidpointLuminanceMatches) {
+  const SkColor old_darkest_color = SetDarkestColorForTesting(SK_ColorBLACK);
+  float darkest, midpoint, lightest;
+  std::tie(darkest, midpoint, lightest) = GetLuminancesForTesting();
+  EXPECT_FLOAT_EQ(GetContrastRatio(darkest, midpoint),
+                  GetContrastRatio(midpoint, lightest));
+
+  SetDarkestColorForTesting(old_darkest_color);
+  std::tie(darkest, midpoint, lightest) = GetLuminancesForTesting();
+  EXPECT_FLOAT_EQ(GetContrastRatio(darkest, midpoint),
+                  GetContrastRatio(midpoint, lightest));
+}
+
+TEST(ColorUtils, GetColorWithMaxContrast) {
+  const SkColor old_darkest_color = SetDarkestColorForTesting(SK_ColorBLACK);
+  EXPECT_EQ(SK_ColorWHITE, GetColorWithMaxContrast(SK_ColorBLACK));
+  EXPECT_EQ(SK_ColorWHITE,
+            GetColorWithMaxContrast(SkColorSetRGB(0x75, 0x75, 0x75)));
+  EXPECT_EQ(SK_ColorBLACK, GetColorWithMaxContrast(SK_ColorWHITE));
+  EXPECT_EQ(SK_ColorBLACK,
+            GetColorWithMaxContrast(SkColorSetRGB(0x76, 0x76, 0x76)));
+
+  SetDarkestColorForTesting(old_darkest_color);
+  EXPECT_EQ(old_darkest_color, GetColorWithMaxContrast(SK_ColorWHITE));
+}
+
+TEST(ColorUtils, GetEndpointColorWithMinContrast) {
+  const SkColor old_darkest_color = SetDarkestColorForTesting(SK_ColorBLACK);
+  EXPECT_EQ(SK_ColorBLACK, GetEndpointColorWithMinContrast(SK_ColorBLACK));
+  EXPECT_EQ(SK_ColorBLACK,
+            GetEndpointColorWithMinContrast(SkColorSetRGB(0x75, 0x75, 0x75)));
+  EXPECT_EQ(SK_ColorWHITE, GetEndpointColorWithMinContrast(SK_ColorWHITE));
+  EXPECT_EQ(SK_ColorWHITE,
+            GetEndpointColorWithMinContrast(SkColorSetRGB(0x76, 0x76, 0x76)));
+
+  SetDarkestColorForTesting(old_darkest_color);
+  EXPECT_EQ(old_darkest_color,
+            GetEndpointColorWithMinContrast(old_darkest_color));
+}
+
+TEST(ColorUtils, BlendForMinContrast_ForegroundAlreadyMeetsMinimum) {
+  const auto result = BlendForMinContrast(SK_ColorBLACK, SK_ColorWHITE);
+  EXPECT_EQ(SK_AlphaTRANSPARENT, result.alpha);
+  EXPECT_EQ(SK_ColorBLACK, result.color);
+}
+
+TEST(ColorUtils, BlendForMinContrast_BlendDarker) {
+  const SkColor foreground = SkColorSetRGB(0xAA, 0xAA, 0xAA);
+  const auto result = BlendForMinContrast(foreground, SK_ColorWHITE);
+  EXPECT_NE(SK_AlphaTRANSPARENT, result.alpha);
+  EXPECT_NE(foreground, result.color);
+  EXPECT_GE(GetContrastRatio(result.color, SK_ColorWHITE),
+            kMinimumReadableContrastRatio);
+}
+
+TEST(ColorUtils, BlendForMinContrast_BlendLighter) {
+  const SkColor foreground = SkColorSetRGB(0x33, 0x33, 0x33);
+  const auto result = BlendForMinContrast(foreground, SK_ColorBLACK);
+  EXPECT_NE(SK_AlphaTRANSPARENT, result.alpha);
+  EXPECT_NE(foreground, result.color);
+  EXPECT_GE(GetContrastRatio(result.color, SK_ColorBLACK),
+            kMinimumReadableContrastRatio);
+}
+
+TEST(ColorUtils, BlendForMinContrast_StopsAtDarkestColor) {
+  const SkColor darkest_color = SkColorSetRGB(0x44, 0x44, 0x44);
+  const SkColor old_darkest_color = SetDarkestColorForTesting(darkest_color);
+  EXPECT_EQ(darkest_color, BlendForMinContrast(SkColorSetRGB(0x55, 0x55, 0x55),
+                                               SkColorSetRGB(0xAA, 0xAA, 0xAA))
+                               .color);
+
+  SetDarkestColorForTesting(old_darkest_color);
+}
+
+TEST(ColorUtils, BlendForMinContrast_ComputesExpectedOpacities) {
+  const SkColor source = SkColorSetRGB(0xDE, 0xE1, 0xE6);
+  const SkColor target = SkColorSetRGB(0xFF, 0xFF, 0xFF);
+  const SkColor base = source;
+  SkAlpha alpha = BlendForMinContrast(source, base, target, 1.11f).alpha;
+  EXPECT_NEAR(alpha / 255.0f, 0.4f, 0.03f);
+  alpha = BlendForMinContrast(source, base, target, 1.19f).alpha;
+  EXPECT_NEAR(alpha / 255.0f, 0.65f, 0.03f);
+  alpha = BlendForMinContrast(source, base, target, 1.13728f).alpha;
+  EXPECT_NEAR(alpha / 255.0f, 0.45f, 0.03f);
+}
+
+TEST(ColorUtils, BlendTowardMaxContrast_PreservesAlpha) {
+  SkColor test_colors[] = {SK_ColorBLACK,      SK_ColorWHITE,
+                           SK_ColorRED,        SK_ColorYELLOW,
+                           SK_ColorMAGENTA,    gfx::kGoogleGreen500,
+                           gfx::kGoogleRed050, gfx::kGoogleBlue800};
+  SkAlpha test_alphas[] = {SK_AlphaTRANSPARENT, 0x0F,
+                           gfx::kDisabledControlAlpha, 0xDD};
+  SkAlpha blend_alpha = 0x7F;
+  for (const SkColor color : test_colors) {
+    SkColor opaque_result =
+        color_utils::BlendTowardMaxContrast(color, blend_alpha);
+    for (const SkAlpha alpha : test_alphas) {
+      SkColor input = SkColorSetA(color, alpha);
+      SkColor result = color_utils::BlendTowardMaxContrast(input, blend_alpha);
+      // Alpha was preserved.
+      EXPECT_EQ(SkColorGetA(result), alpha);
+      // RGB channels unaffected by alpha of input.
+      EXPECT_EQ(SkColorSetA(result, SK_AlphaOPAQUE), opaque_result);
+    }
+  }
+}
+
+TEST(ColorUtils, BlendForMinContrast_MatchesNaiveImplementation) {
+  constexpr SkColor default_foreground = SkColorSetRGB(0xDE, 0xE1, 0xE6);
+  constexpr SkColor high_contrast_foreground = SK_ColorWHITE;
+  constexpr SkColor background = default_foreground;
+  constexpr float kContrastRatio = 1.11f;
+  const auto result = BlendForMinContrast(
+      default_foreground, background, high_contrast_foreground, kContrastRatio);
+
+  // Naive implementation is direct translation of function description.
+  SkAlpha alpha = SK_AlphaTRANSPARENT;
+  SkColor color = default_foreground;
+  for (int i = SK_AlphaTRANSPARENT; i <= SK_AlphaOPAQUE; ++i) {
+    alpha = static_cast<SkAlpha>(i);
+    color = AlphaBlend(high_contrast_foreground, default_foreground, alpha);
+    if (GetContrastRatio(color, background) >= kContrastRatio)
+      break;
+  }
+
+  EXPECT_EQ(alpha, result.alpha);
+  EXPECT_EQ(color, result.color);
+}
+
+}  // namespace color_utils
diff --git a/ui/gfx/decorated_text.cc b/ui/gfx/decorated_text.cc
new file mode 100644
index 0000000..f8b2fd1
--- /dev/null
+++ b/ui/gfx/decorated_text.cc
@@ -0,0 +1,17 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/decorated_text.h"
+
+namespace gfx {
+
+DecoratedText::RangedAttribute::RangedAttribute(const gfx::Range& range,
+                                                const gfx::Font& font)
+    : range(range), font(font), strike(false) {}
+
+DecoratedText::DecoratedText() {}
+
+DecoratedText::~DecoratedText() {}
+
+}  // namespace gfx
diff --git a/ui/gfx/decorated_text.h b/ui/gfx/decorated_text.h
new file mode 100644
index 0000000..9d53d05
--- /dev/null
+++ b/ui/gfx/decorated_text.h
@@ -0,0 +1,45 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_DECORATED_TEXT_H_
+#define UI_GFX_DECORATED_TEXT_H_
+
+#include <string>
+#include <vector>
+
+#include "ui/gfx/font.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/range/range.h"
+
+namespace gfx {
+
+// Encapsulates styling information for some given text.
+struct GFX_EXPORT DecoratedText {
+  // Describes the various text decoration attributes applicable to a given
+  // range of text.
+  struct GFX_EXPORT RangedAttribute {
+    // Disallow default construction of Font, since that's slow.
+    RangedAttribute() = delete;
+    RangedAttribute(const Range& range, const Font& font);
+
+    // The range in |text|, this RangedAttribute corresponds to. Should not be
+    // reversed and should lie within the bounds of |text|.
+    Range range;
+    Font font;
+    bool strike;
+  };
+
+  DecoratedText();
+  ~DecoratedText();
+
+  std::u16string text;
+
+  // Vector of RangedAttribute describing styling of non-overlapping ranges
+  // in |text|.
+  std::vector<RangedAttribute> attributes;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_DECORATED_TEXT_H_
diff --git a/ui/gfx/decorated_text_mac.h b/ui/gfx/decorated_text_mac.h
new file mode 100644
index 0000000..ad1aa59
--- /dev/null
+++ b/ui/gfx/decorated_text_mac.h
@@ -0,0 +1,22 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_DECORATED_TEXT_MAC_H_
+#define UI_GFX_DECORATED_TEXT_MAC_H_
+
+#include "ui/gfx/gfx_export.h"
+
+@class NSAttributedString;
+
+namespace gfx {
+
+struct DecoratedText;
+
+// Returns a NSAttributedString from |decorated_text|.
+GFX_EXPORT NSAttributedString* GetAttributedStringFromDecoratedText(
+    const DecoratedText& decorated_text);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_DECORATED_TEXT_MAC_H_
\ No newline at end of file
diff --git a/ui/gfx/decorated_text_mac.mm b/ui/gfx/decorated_text_mac.mm
new file mode 100644
index 0000000..80942a6
--- /dev/null
+++ b/ui/gfx/decorated_text_mac.mm
@@ -0,0 +1,51 @@
+// Copyright 2018 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.
+
+#import "ui/gfx/decorated_text_mac.h"
+
+#import <Cocoa/Cocoa.h>
+
+#import "base/mac/scoped_nsobject.h"
+#include "base/strings/sys_string_conversions.h"
+#include "ui/gfx/decorated_text.h"
+
+namespace gfx {
+
+NSAttributedString* GetAttributedStringFromDecoratedText(
+    const DecoratedText& decorated_text) {
+  base::scoped_nsobject<NSMutableAttributedString> str(
+      [[NSMutableAttributedString alloc]
+          initWithString:base::SysUTF16ToNSString(decorated_text.text)]);
+  [str beginEditing];
+
+  NSValue* const line_style =
+      @(NSUnderlineStyleSingle | NSUnderlinePatternSolid);
+
+  for (const auto& attribute : decorated_text.attributes) {
+    DCHECK(!attribute.range.is_reversed());
+    DCHECK_LE(attribute.range.end(), [str length]);
+
+    NSMutableDictionary* attrs = [NSMutableDictionary dictionary];
+    NSRange range = attribute.range.ToNSRange();
+
+    if (attribute.font.GetNativeFont())
+      attrs[NSFontAttributeName] = attribute.font.GetNativeFont();
+
+    // NSFont does not have underline as an attribute. Hence handle it
+    // separately.
+    const bool underline = attribute.font.GetStyle() & gfx::Font::UNDERLINE;
+    if (underline)
+      attrs[NSUnderlineStyleAttributeName] = line_style;
+
+    if (attribute.strike)
+      attrs[NSStrikethroughStyleAttributeName] = line_style;
+
+    [str setAttributes:attrs range:range];
+  }
+
+  [str endEditing];
+  return str.autorelease();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/delegated_ink_metadata.cc b/ui/gfx/delegated_ink_metadata.cc
new file mode 100644
index 0000000..eea84b1
--- /dev/null
+++ b/ui/gfx/delegated_ink_metadata.cc
@@ -0,0 +1,24 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/delegated_ink_metadata.h"
+
+#include <inttypes.h>
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+std::string DelegatedInkMetadata::ToString() const {
+  std::string str = base::StringPrintf(
+      "point: %s, diameter: %f, color: %u, timestamp: %" PRId64
+      ", presentation_area: %s, frame_time: %" PRId64 ", is_hovering: %d",
+      point_.ToString().c_str(), diameter_, color_,
+      timestamp_.since_origin().InMicroseconds(),
+      presentation_area_.ToString().c_str(),
+      frame_time_.since_origin().InMicroseconds(), is_hovering_);
+  return str;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/delegated_ink_metadata.h b/ui/gfx/delegated_ink_metadata.h
new file mode 100644
index 0000000..04b8c7c
--- /dev/null
+++ b/ui/gfx/delegated_ink_metadata.h
@@ -0,0 +1,95 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_DELEGATED_INK_METADATA_H_
+#define UI_GFX_DELEGATED_INK_METADATA_H_
+
+#include <string>
+
+#include "base/time/time.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// This class stores all the metadata that is gathered when the WebAPI
+// updateInkTrailStartPoint is called. This metadata flows from blink,
+// through cc, and into viz in order to produce a delegated ink trail on the
+// end of what was already rendered.
+//
+// Explainer for the feature:
+// https://github.com/WICG/ink-enhancement/blob/master/README.md
+class GFX_EXPORT DelegatedInkMetadata {
+ public:
+  DelegatedInkMetadata() = default;
+  DelegatedInkMetadata(const PointF& pt,
+                       double diameter,
+                       SkColor color,
+                       base::TimeTicks timestamp,
+                       const RectF& area,
+                       bool hovering)
+      : point_(pt),
+        diameter_(diameter),
+        color_(color),
+        timestamp_(timestamp),
+        presentation_area_(area),
+        is_hovering_(hovering) {}
+  DelegatedInkMetadata(const PointF& pt,
+                       double diameter,
+                       SkColor color,
+                       base::TimeTicks timestamp,
+                       const RectF& area,
+                       base::TimeTicks frame_time,
+                       bool hovering)
+      : point_(pt),
+        diameter_(diameter),
+        color_(color),
+        timestamp_(timestamp),
+        presentation_area_(area),
+        frame_time_(frame_time),
+        is_hovering_(hovering) {}
+  DelegatedInkMetadata(const DelegatedInkMetadata& other) = default;
+  DelegatedInkMetadata& operator=(const DelegatedInkMetadata& other) = default;
+
+  const PointF& point() const { return point_; }
+  double diameter() const { return diameter_; }
+  SkColor color() const { return color_; }
+  base::TimeTicks timestamp() const { return timestamp_; }
+  const RectF& presentation_area() const { return presentation_area_; }
+  base::TimeTicks frame_time() const { return frame_time_; }
+  bool is_hovering() const { return is_hovering_; }
+
+  void set_frame_time(base::TimeTicks frame_time) { frame_time_ = frame_time; }
+
+  std::string ToString() const;
+
+ private:
+  // Location of the pointerevent relative to the root frame.
+  PointF point_;
+
+  // Width of the trail, in physical pixels.
+  double diameter_ = 0;
+
+  // Color to draw the ink trail.
+  SkColor color_ = 0;
+
+  // Timestamp from the pointerevent for the ink point.
+  base::TimeTicks timestamp_;
+
+  // The rect to clip the ink trail to, defaults to the containing viewport.
+  RectF presentation_area_;
+
+  // Frame time of the layer tree that this metadata is on.
+  base::TimeTicks frame_time_;
+
+  // True if the left mouse button is up or if a stylus with hovering
+  // capabilities is hovering over the screen when updateInkTrailStartPoint is
+  // called.
+  bool is_hovering_ = false;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_DELEGATED_INK_METADATA_H_
diff --git a/ui/gfx/delegated_ink_point.cc b/ui/gfx/delegated_ink_point.cc
new file mode 100644
index 0000000..6240c27
--- /dev/null
+++ b/ui/gfx/delegated_ink_point.cc
@@ -0,0 +1,38 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/delegated_ink_point.h"
+
+#include <inttypes.h>
+
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/delegated_ink_metadata.h"
+
+namespace gfx {
+
+bool DelegatedInkPoint::MatchesDelegatedInkMetadata(
+    const DelegatedInkMetadata* metadata) const {
+  // The maximum difference allowed when comparing a DelegatedInkPoint |point_|
+  // to the |point_| on a DelegatedInkMetadata. Some precision loss can occur
+  // when moving between coordinate spaces in the browser and renderer,
+  // particularly when the device scale factor is not a whole number. This can
+  // result in a DelegatedInkMetadata and DelegatedInkPoint having been created
+  // from the same point, but having a very small difference. When this occurs,
+  // we can safely ignore that they are slightly different and use the point for
+  // a delegated ink trail anyway, since it is a very small difference and will
+  // only be visible for a single frame.
+  constexpr float kEpsilon = 0.05f;
+
+  return metadata && timestamp_ == metadata->timestamp() &&
+         point_.IsWithinDistance(metadata->point(), kEpsilon);
+}
+
+std::string DelegatedInkPoint::ToString() const {
+  return base::StringPrintf("point: %s, timestamp: %" PRId64 ", pointer_id: %d",
+                            point_.ToString().c_str(),
+                            timestamp_.since_origin().InMicroseconds(),
+                            pointer_id_);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/delegated_ink_point.h b/ui/gfx/delegated_ink_point.h
new file mode 100644
index 0000000..92d1178
--- /dev/null
+++ b/ui/gfx/delegated_ink_point.h
@@ -0,0 +1,68 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_DELEGATED_INK_POINT_H_
+#define UI_GFX_DELEGATED_INK_POINT_H_
+
+#include <limits>
+#include <string>
+
+#include "base/time/time.h"
+#include "mojo/public/cpp/bindings/struct_traits.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class DelegatedInkMetadata;
+namespace mojom {
+class DelegatedInkPointDataView;
+}  // namespace mojom
+
+// This class stores the information required to draw a single point of a
+// delegated ink trail. When the WebAPI |updateInkTrailStartPoint| is called,
+// the renderer requests that the browser begin sending these to viz. Viz
+// will collect them, and then during |DrawAndSwap| will use the
+// DelegatedInkPoints that have arrived from the browser along with the
+// DelegatedInkMetadata that the renderer sent to draw a delegated ink trail on
+// the screen, connected to the end of the already rendered ink stroke.
+//
+// Explainer for the feature:
+// https://github.com/WICG/ink-enhancement/blob/master/README.md
+class GFX_EXPORT DelegatedInkPoint {
+ public:
+  DelegatedInkPoint() = default;
+  DelegatedInkPoint(const PointF& pt,
+                    base::TimeTicks timestamp,
+                    int32_t pointer_id = std::numeric_limits<int32_t>::min())
+      : point_(pt), timestamp_(timestamp), pointer_id_(pointer_id) {}
+
+  const PointF& point() const { return point_; }
+  base::TimeTicks timestamp() const { return timestamp_; }
+  int32_t pointer_id() const { return pointer_id_; }
+  std::string ToString() const;
+
+  bool MatchesDelegatedInkMetadata(const DelegatedInkMetadata* metadata) const;
+
+ private:
+  friend struct mojo::StructTraits<mojom::DelegatedInkPointDataView,
+                                   DelegatedInkPoint>;
+
+  // Location of the input event relative to the root window in device pixels.
+  // Scale is device scale factor at time of input.
+  PointF point_;
+
+  // Timestamp from the input event.
+  base::TimeTicks timestamp_;
+
+  // Pointer ID from the input event. Used to store all DelegatedInkPoints from
+  // the same source together in viz so that they are all candidates for a
+  // single delegated ink trail and DelegatedInkPoints from other sources are
+  // not.
+  int32_t pointer_id_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_DELEGATED_INK_POINT_H_
diff --git a/ui/gfx/delegated_ink_unittest.cc b/ui/gfx/delegated_ink_unittest.cc
new file mode 100644
index 0000000..455d4bf
--- /dev/null
+++ b/ui/gfx/delegated_ink_unittest.cc
@@ -0,0 +1,83 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/delegated_ink_metadata.h"
+#include "ui/gfx/delegated_ink_point.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+
+// Test confirms that DelegatedInkPoint and DelegatedInkMetadata will both
+// report that they match each other if the timestamp and point are the same,
+// regardless of any other members.
+TEST(DelegatedInkTest, PointAndMetadataMatch) {
+  const gfx::PointF point(10, 40);
+  const base::TimeTicks timestamp = base::TimeTicks::Now();
+
+  DelegatedInkPoint ink_point(point, timestamp, /*pointer_id=*/1);
+  DelegatedInkMetadata metadata(point, /*diameter=*/10, SK_ColorBLACK,
+                                timestamp, gfx::RectF(10, 10, 100, 100),
+                                /*hovering=*/false);
+
+  EXPECT_TRUE(ink_point.MatchesDelegatedInkMetadata(&metadata));
+
+  DelegatedInkPoint point_no_pointer_id(point, timestamp);
+
+  EXPECT_TRUE(point_no_pointer_id.MatchesDelegatedInkMetadata(&metadata));
+
+  DelegatedInkMetadata metadata_with_frame_time(
+      point, /*diameter=*/7.777f, SK_ColorCYAN, timestamp,
+      gfx::RectF(6, 14, 240, 307), base::TimeTicks::Now(), /*hovering=*/true);
+
+  EXPECT_TRUE(ink_point.MatchesDelegatedInkMetadata(&metadata_with_frame_time));
+  EXPECT_TRUE(point_no_pointer_id.MatchesDelegatedInkMetadata(
+      &metadata_with_frame_time));
+}
+
+// Confirms that if the timestamps are the same and point locations are within
+// |kEpsilon|, then they will be considered matching.
+TEST(DelegatedInkTest, PointAndMetadataAreClose) {
+  const base::TimeTicks timestamp = base::TimeTicks::Now();
+  const gfx::PointF point_location(34, 95.002f);
+  const gfx::PointF metadata_location(33.994f, 94.9524f);
+
+  DelegatedInkPoint ink_point(point_location, timestamp);
+  DelegatedInkMetadata metadata(
+      metadata_location, /*diameter=*/3.5f, SK_ColorRED, timestamp,
+      gfx::RectF(0, 3, 14.6f, 78.2f), /*hovering=*/false);
+
+  EXPECT_TRUE(ink_point.MatchesDelegatedInkMetadata(&metadata));
+}
+
+// Confirms that if timestamps or points are different (or the metadata is null)
+// the DelegatedInkPoint and DelegatedInkMetadata are not considered matching.
+TEST(DelegatedInkTest, PointAndMetadataDoNotMatch) {
+  const base::TimeTicks timestamp = base::TimeTicks::Now();
+  const gfx::PointF point_location(34, 95.002f);
+  const gfx::PointF metadata_location_close(33.994f, 94.9523f);
+
+  DelegatedInkPoint ink_point(point_location, timestamp);
+  EXPECT_FALSE(ink_point.MatchesDelegatedInkMetadata(nullptr));
+
+  DelegatedInkMetadata close_metadata(
+      metadata_location_close, /*diameter=*/5, SK_ColorWHITE, timestamp,
+      gfx::RectF(40, 30.6f, 43, 7.2f), /*hovering=*/true);
+  EXPECT_FALSE(ink_point.MatchesDelegatedInkMetadata(&close_metadata));
+
+  const gfx::PointF metadata_location_far(23.789f, 20);
+  DelegatedInkMetadata far_metadata(
+      metadata_location_far, /*diameter=*/1, SK_ColorYELLOW, timestamp,
+      gfx::RectF(12.44f, 3, 1000, 1000.1f), /*hovering=*/false);
+  EXPECT_FALSE(ink_point.MatchesDelegatedInkMetadata(&far_metadata));
+
+  DelegatedInkMetadata metadata_different_timestamp(
+      point_location, /*diameter=*/10, SK_ColorGREEN,
+      timestamp + base::Milliseconds(10), gfx::RectF(0, 0, 0, 0),
+      /*hovering*/ true);
+  EXPECT_FALSE(
+      ink_point.MatchesDelegatedInkMetadata(&metadata_different_timestamp));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/display_color_spaces.cc b/ui/gfx/display_color_spaces.cc
new file mode 100644
index 0000000..a5b8e14
--- /dev/null
+++ b/ui/gfx/display_color_spaces.cc
@@ -0,0 +1,202 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/display_color_spaces.h"
+
+#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
+
+namespace gfx {
+
+namespace {
+
+const ContentColorUsage kAllColorUsages[] = {
+    ContentColorUsage::kSRGB,
+    ContentColorUsage::kWideColorGamut,
+    ContentColorUsage::kHDR,
+};
+
+gfx::BufferFormat DefaultBufferFormat() {
+  // ChromeOS expects the default buffer format be BGRA_8888 in several places.
+  // https://crbug.com/1057501, https://crbug.com/1073237
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+  return gfx::BufferFormat::BGRA_8888;
+#else
+  return gfx::BufferFormat::RGBA_8888;
+#endif
+}
+
+size_t GetIndex(ContentColorUsage color_usage, bool needs_alpha) {
+  switch (color_usage) {
+    case ContentColorUsage::kSRGB:
+      return 0 + needs_alpha;
+    case ContentColorUsage::kWideColorGamut:
+      return 2 + needs_alpha;
+    case ContentColorUsage::kHDR:
+      return 4 + needs_alpha;
+  }
+}
+
+}  // namespace
+
+DisplayColorSpaces::DisplayColorSpaces() {
+  for (auto& color_space : color_spaces_)
+    color_space = gfx::ColorSpace::CreateSRGB();
+  for (auto& buffer_format : buffer_formats_)
+    buffer_format = DefaultBufferFormat();
+}
+
+DisplayColorSpaces::DisplayColorSpaces(const gfx::DisplayColorSpaces&) =
+    default;
+
+DisplayColorSpaces& DisplayColorSpaces::operator=(
+    const gfx::DisplayColorSpaces&) = default;
+
+DisplayColorSpaces::DisplayColorSpaces(const gfx::ColorSpace& c)
+    : DisplayColorSpaces() {
+  if (!c.IsValid())
+    return;
+  for (auto& color_space : color_spaces_)
+    color_space = c;
+}
+
+DisplayColorSpaces::DisplayColorSpaces(const ColorSpace& c, BufferFormat f) {
+  for (auto& color_space : color_spaces_)
+    color_space = c.IsValid() ? c : gfx::ColorSpace::CreateSRGB();
+  for (auto& buffer_format : buffer_formats_)
+    buffer_format = f;
+}
+
+void DisplayColorSpaces::SetOutputBufferFormats(
+    gfx::BufferFormat buffer_format_no_alpha,
+    gfx::BufferFormat buffer_format_needs_alpha) {
+  for (const auto& color_usage : kAllColorUsages) {
+    size_t i_no_alpha = GetIndex(color_usage, false);
+    size_t i_needs_alpha = GetIndex(color_usage, true);
+    buffer_formats_[i_no_alpha] = buffer_format_no_alpha;
+    buffer_formats_[i_needs_alpha] = buffer_format_needs_alpha;
+  }
+}
+
+void DisplayColorSpaces::SetOutputColorSpaceAndBufferFormat(
+    ContentColorUsage color_usage,
+    bool needs_alpha,
+    const gfx::ColorSpace& color_space,
+    gfx::BufferFormat buffer_format) {
+  size_t i = GetIndex(color_usage, needs_alpha);
+  color_spaces_[i] = color_space;
+  buffer_formats_[i] = buffer_format;
+}
+
+ColorSpace DisplayColorSpaces::GetOutputColorSpace(
+    ContentColorUsage color_usage,
+    bool needs_alpha) const {
+  return color_spaces_[GetIndex(color_usage, needs_alpha)];
+}
+
+BufferFormat DisplayColorSpaces::GetOutputBufferFormat(
+    ContentColorUsage color_usage,
+    bool needs_alpha) const {
+  return buffer_formats_[GetIndex(color_usage, needs_alpha)];
+}
+
+gfx::ColorSpace DisplayColorSpaces::GetRasterColorSpace() const {
+  return GetOutputColorSpace(ContentColorUsage::kHDR, false /* needs_alpha */);
+}
+
+gfx::ColorSpace DisplayColorSpaces::GetCompositingColorSpace(
+    bool needs_alpha,
+    ContentColorUsage color_usage) const {
+  gfx::ColorSpace result = GetOutputColorSpace(color_usage, needs_alpha);
+  if (!result.IsSuitableForBlending())
+    result = gfx::ColorSpace::CreateExtendedSRGB();
+  return result;
+}
+
+bool DisplayColorSpaces::SupportsHDR() const {
+  return GetOutputColorSpace(ContentColorUsage::kHDR, false).IsHDR() ||
+         GetOutputColorSpace(ContentColorUsage::kHDR, true).IsHDR();
+}
+
+ColorSpace DisplayColorSpaces::GetScreenInfoColorSpace() const {
+  return GetOutputColorSpace(ContentColorUsage::kHDR, false /* needs_alpha */);
+}
+
+void DisplayColorSpaces::ToStrings(
+    std::vector<std::string>* out_names,
+    std::vector<gfx::ColorSpace>* out_color_spaces,
+    std::vector<gfx::BufferFormat>* out_buffer_formats) const {
+  // The names of the configurations.
+  const char* config_names[kConfigCount] = {
+      "sRGB/no-alpha", "sRGB/alpha",   "WCG/no-alpha",
+      "WCG/alpha",     "HDR/no-alpha", "HDR/alpha",
+  };
+  // Names for special configuration subsets (e.g, all sRGB, all WCG, etc).
+  constexpr size_t kSpecialConfigCount = 5;
+  const char* special_config_names[kSpecialConfigCount] = {
+      "sRGB", "WCG", "SDR", "HDR", "all",
+  };
+  const size_t special_config_indices[kSpecialConfigCount][2] = {
+      {0, 2}, {2, 4}, {0, 4}, {4, 6}, {0, 6},
+  };
+
+  // We don't want to take up 6 lines (one for each config) if we don't need to.
+  // To avoid this, build up half-open intervals [i, j) which have the same
+  // color space and buffer formats, and group them together. The above "special
+  // configs" give groups that have a common name.
+  size_t i = 0;
+  size_t j = 0;
+  while (i != kConfigCount) {
+    // Keep growing the interval [i, j) until entry j is different, or past the
+    // end.
+    if (color_spaces_[i] == color_spaces_[j] &&
+        buffer_formats_[i] == buffer_formats_[j] && j != kConfigCount) {
+      j += 1;
+      continue;
+    }
+
+    // Populate the name for the group from the "special config" names.
+    std::string name;
+    for (size_t k = 0; k < kSpecialConfigCount; ++k) {
+      if (i == special_config_indices[k][0] &&
+          j == special_config_indices[k][1]) {
+        name = special_config_names[k];
+        break;
+      }
+    }
+    // If that didn't work, just list the configs.
+    if (name.empty()) {
+      for (size_t k = i; k < j; ++k) {
+        name += std::string(config_names[k]);
+        if (k != j - 1)
+          name += ",";
+      }
+    }
+
+    // Add an entry, and continue with the interval [j, j).
+    out_names->push_back(name);
+    out_buffer_formats->push_back(buffer_formats_[i]);
+    out_color_spaces->push_back(color_spaces_[i]);
+    i = j;
+  };
+}
+
+bool DisplayColorSpaces::operator==(const DisplayColorSpaces& other) const {
+  for (size_t i = 0; i < kConfigCount; ++i) {
+    if (color_spaces_[i] != other.color_spaces_[i])
+      return false;
+    if (buffer_formats_[i] != other.buffer_formats_[i])
+      return false;
+  }
+  if (sdr_white_level_ != other.sdr_white_level_)
+    return false;
+
+  return true;
+}
+
+bool DisplayColorSpaces::operator!=(const DisplayColorSpaces& other) const {
+  return !(*this == other);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/display_color_spaces.h b/ui/gfx/display_color_spaces.h
new file mode 100644
index 0000000..85d3d8e
--- /dev/null
+++ b/ui/gfx/display_color_spaces.h
@@ -0,0 +1,138 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_DISPLAY_COLOR_SPACES_H_
+#define UI_GFX_DISPLAY_COLOR_SPACES_H_
+
+#include <string>
+#include <vector>
+
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/color_space_export.h"
+#include "ui/gfx/hdr_static_metadata.h"
+
+namespace mojo {
+template <class T, class U>
+struct StructTraits;
+}  // namespace mojo
+
+namespace gfx {
+
+namespace mojom {
+class DisplayColorSpacesDataView;
+}  // namespace mojom
+
+// The values are set so std::max() can be used to find the widest.
+enum class ContentColorUsage : uint8_t {
+  // These values are histogrammed over time; do not change their ordinal
+  // values.  When deleting a color usage replace it with a dummy value; when
+  // adding a color usage, do so at the bottom (and update kMaxValue).
+  kSRGB = 0,
+  kWideColorGamut = 1,
+  kHDR = 2,
+  kMaxValue = kHDR,
+};
+
+// This structure is used by a display::Display to specify the color space that
+// should be used to display content of various types. This lives in here, as
+// opposed to in ui/display because it is used directly by components/viz.
+class COLOR_SPACE_EXPORT DisplayColorSpaces {
+ public:
+  static constexpr size_t kConfigCount = 6;
+
+  // Initialize as sRGB-only.
+  DisplayColorSpaces();
+  DisplayColorSpaces(const DisplayColorSpaces& display_color_space);
+  DisplayColorSpaces& operator=(const DisplayColorSpaces& display_color_space);
+
+  // Initialize as |color_space| for all settings. If |color_space| is the
+  // default (invalid) color space, then initialize to sRGB. The BufferFormat
+  // will be set to a default value (BGRA_8888 or RGBA_8888) depending on
+  // build configuration.
+  explicit DisplayColorSpaces(const ColorSpace& color_space);
+
+  // Initialize as |color_space| and |buffer_format| for all settings. If
+  // |color_space| is the default (invalid) color space, then initialize to
+  // sRGB.
+  DisplayColorSpaces(const ColorSpace& color_space, BufferFormat buffer_format);
+
+  // Set the color space and buffer format for the final output surface when the
+  // specified content is being displayed.
+  void SetOutputColorSpaceAndBufferFormat(ContentColorUsage color_usage,
+                                          bool needs_alpha,
+                                          const gfx::ColorSpace& color_space,
+                                          gfx::BufferFormat buffer_format);
+
+  // Set the buffer format for all color usages to |buffer_format_no_alpha| when
+  // alpha is not needed and |buffer_format_with_alpha| when alpha is needed.
+  void SetOutputBufferFormats(gfx::BufferFormat buffer_format_no_alpha,
+                              gfx::BufferFormat buffer_format_with_alpha);
+
+  // Retrieve parameters for a specific usage and alpha.
+  ColorSpace GetOutputColorSpace(ContentColorUsage color_usage,
+                                 bool needs_alpha) const;
+  BufferFormat GetOutputBufferFormat(ContentColorUsage color_usage,
+                                     bool needs_alpha) const;
+
+  // Set the custom SDR white level, in nits. This is a non-default value only
+  // on Windows.
+  void SetSDRWhiteLevel(float sdr_white_level) {
+    sdr_white_level_ = sdr_white_level;
+  }
+  float GetSDRWhiteLevel() const { return sdr_white_level_; }
+
+  void set_hdr_static_metadata(
+      absl::optional<HDRStaticMetadata> hdr_static_metadata) {
+    hdr_static_metadata_ = hdr_static_metadata;
+  }
+  const absl::optional<HDRStaticMetadata>& hdr_static_metadata() const {
+    return hdr_static_metadata_;
+  }
+
+  // TODO(https://crbug.com/1116870): These helper functions exist temporarily
+  // to handle the transition of display::ScreenInfo off of ColorSpace. All
+  // calls to these functions are to be eliminated.
+  ColorSpace GetScreenInfoColorSpace() const;
+
+  // Return the color space that should be used for rasterization.
+  // TODO: This will eventually need to take a ContentColorUsage.
+  gfx::ColorSpace GetRasterColorSpace() const;
+
+  // Return the color space in which compositing (and, in particular, blending,
+  // should be performed). This space may not (on Windows) be suitable for
+  // output.
+  gfx::ColorSpace GetCompositingColorSpace(bool needs_alpha,
+                                           ContentColorUsage color_usage) const;
+
+  // Return true if the HDR color spaces are, indeed, HDR.
+  bool SupportsHDR() const;
+
+  // Output as a vector of strings. This is a helper function for printing in
+  // about:gpu. All output vectors will be the same length. Each entry will be
+  // the configuration name, its buffer format, and its color space.
+  void ToStrings(std::vector<std::string>* out_names,
+                 std::vector<gfx::ColorSpace>* out_color_spaces,
+                 std::vector<gfx::BufferFormat>* out_buffer_formats) const;
+
+  bool operator==(const DisplayColorSpaces& other) const;
+  bool operator!=(const DisplayColorSpaces& other) const;
+
+ private:
+  // Serialization of DisplayColorSpaces directly accesses members.
+  friend struct IPC::ParamTraits<gfx::DisplayColorSpaces>;
+  friend struct mojo::StructTraits<gfx::mojom::DisplayColorSpacesDataView,
+                                   gfx::DisplayColorSpaces>;
+
+  gfx::ColorSpace color_spaces_[kConfigCount];
+  gfx::BufferFormat buffer_formats_[kConfigCount];
+  float sdr_white_level_ = ColorSpace::kDefaultSDRWhiteLevel;
+  // By definition this only applies to ContentColorUsage::kHDR.
+  absl::optional<HDRStaticMetadata> hdr_static_metadata_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_DISPLAY_COLOR_SPACES_H_
diff --git a/ui/gfx/extension_set.cc b/ui/gfx/extension_set.cc
new file mode 100644
index 0000000..d61e600
--- /dev/null
+++ b/ui/gfx/extension_set.cc
@@ -0,0 +1,27 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/extension_set.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+
+namespace gfx {
+
+ExtensionSet MakeExtensionSet(const base::StringPiece& extensions_string) {
+  return ExtensionSet(SplitStringPiece(
+      extensions_string, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL));
+}
+
+bool HasExtension(const ExtensionSet& extension_set,
+                  const base::StringPiece& extension) {
+  return extension_set.find(extension) != extension_set.end();
+}
+
+std::string MakeExtensionString(const ExtensionSet& extension_set) {
+  std::vector<base::StringPiece> extension_list(extension_set.begin(),
+                                                extension_set.end());
+  return base::JoinString(extension_list, " ");
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/extension_set.h b/ui/gfx/extension_set.h
new file mode 100644
index 0000000..3a699f4
--- /dev/null
+++ b/ui/gfx/extension_set.h
@@ -0,0 +1,32 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_EXTENSION_SET_H_
+#define UI_GFX_EXTENSION_SET_H_
+
+#include "base/containers/flat_set.h"
+#include "base/strings/string_piece.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+using ExtensionSet = base::flat_set<base::StringPiece>;
+
+GFX_EXPORT ExtensionSet
+MakeExtensionSet(const base::StringPiece& extensions_string);
+
+GFX_EXPORT bool HasExtension(const ExtensionSet& extension_set,
+                             const base::StringPiece& extension);
+
+template <size_t N>
+inline bool HasExtension(const ExtensionSet& extension_set,
+                         const char (&extension)[N]) {
+  return HasExtension(extension_set, base::StringPiece(extension, N - 1));
+}
+
+GFX_EXPORT std::string MakeExtensionString(const ExtensionSet& extension_set);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_EXTENSION_SET_H_
diff --git a/ui/gfx/favicon_size.cc b/ui/gfx/favicon_size.cc
new file mode 100644
index 0000000..d0ba48a
--- /dev/null
+++ b/ui/gfx/favicon_size.cc
@@ -0,0 +1,25 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/favicon_size.h"
+
+namespace gfx {
+
+const int kFaviconSize = 16;
+
+void CalculateFaviconTargetSize(int* width, int* height) {
+  if (*width > kFaviconSize || *height > kFaviconSize) {
+    // Too big, resize it maintaining the aspect ratio.
+    float aspect_ratio = static_cast<float>(*width) /
+                         static_cast<float>(*height);
+    *height = kFaviconSize;
+    *width = static_cast<int>(aspect_ratio * *height);
+    if (*width > kFaviconSize) {
+      *width = kFaviconSize;
+      *height = static_cast<int>(*width / aspect_ratio);
+    }
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/favicon_size.h b/ui/gfx/favicon_size.h
new file mode 100644
index 0000000..ad51a9b
--- /dev/null
+++ b/ui/gfx/favicon_size.h
@@ -0,0 +1,22 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FAVICON_SIZE_H_
+#define UI_GFX_FAVICON_SIZE_H_
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Size (along each axis) of the favicon.
+GFX_EXPORT extern const int kFaviconSize;
+
+// If the width or height is bigger than the favicon size, a new width/height
+// is calculated and returned in width/height that maintains the aspect
+// ratio of the supplied values.
+GFX_EXPORT void CalculateFaviconTargetSize(int* width, int* height);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FAVICON_SIZE_H_
diff --git a/ui/gfx/font.cc b/ui/gfx/font.cc
new file mode 100644
index 0000000..50a071a
--- /dev/null
+++ b/ui/gfx/font.cc
@@ -0,0 +1,122 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/font.h"
+
+#include <algorithm>
+
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+
+////////////////////////////////////////////////////////////////////////////////
+// Font, public:
+
+Font::Font() : platform_font_(PlatformFont::CreateDefault()) {
+}
+
+Font::Font(const Font& other) : platform_font_(other.platform_font_) {
+}
+
+Font& Font::operator=(const Font& other) {
+  platform_font_ = other.platform_font_;
+  return *this;
+}
+
+#if defined(OS_APPLE)
+Font::Font(NativeFont native_font)
+    : platform_font_(PlatformFont::CreateFromNativeFont(native_font)) {
+}
+#endif
+
+Font::Font(PlatformFont* platform_font) : platform_font_(platform_font) {
+}
+
+Font::Font(const std::string& font_name, int font_size)
+    : platform_font_(PlatformFont::CreateFromNameAndSize(font_name,
+                                                         font_size)) {
+}
+
+Font::~Font() {
+}
+
+Font Font::Derive(int size_delta, int style, Font::Weight weight) const {
+  if (size_delta == 0 && style == GetStyle() && weight == GetWeight())
+    return *this;
+
+  return platform_font_->DeriveFont(size_delta, style, weight);
+}
+
+int Font::GetHeight() const {
+  return platform_font_->GetHeight();
+}
+
+int Font::GetBaseline() const {
+  return platform_font_->GetBaseline();
+}
+
+int Font::GetCapHeight() const {
+  return platform_font_->GetCapHeight();
+}
+
+int Font::GetExpectedTextWidth(int length) const {
+  return platform_font_->GetExpectedTextWidth(length);
+}
+
+int Font::GetStyle() const {
+  return platform_font_->GetStyle();
+}
+
+const std::string& Font::GetFontName() const {
+  return platform_font_->GetFontName();
+}
+
+std::string Font::GetActualFontName() const {
+  return platform_font_->GetActualFontName();
+}
+
+int Font::GetFontSize() const {
+  return platform_font_->GetFontSize();
+}
+
+Font::Weight Font::GetWeight() const {
+  return platform_font_->GetWeight();
+}
+
+const FontRenderParams& Font::GetFontRenderParams() const {
+  return platform_font_->GetFontRenderParams();
+}
+
+#if defined(OS_APPLE)
+NativeFont Font::GetNativeFont() const {
+  return platform_font_->GetNativeFont();
+}
+#endif
+
+#ifndef NDEBUG
+std::ostream& operator<<(std::ostream& stream, const Font::Weight weight) {
+  return stream << static_cast<int>(weight);
+}
+#endif
+
+Font::Weight FontWeightFromInt(int weight) {
+  static const Font::Weight weights[] = {
+      Font::Weight::INVALID,  Font::Weight::THIN,   Font::Weight::EXTRA_LIGHT,
+      Font::Weight::LIGHT,    Font::Weight::NORMAL, Font::Weight::MEDIUM,
+      Font::Weight::SEMIBOLD, Font::Weight::BOLD,   Font::Weight::EXTRA_BOLD,
+      Font::Weight::BLACK};
+
+  const Font::Weight* next_bigger_weight = std::lower_bound(
+      std::begin(weights), std::end(weights), weight,
+      [](const Font::Weight& a, const int& b) {
+        return static_cast<std::underlying_type<Font::Weight>::type>(a) < b;
+      });
+  if (next_bigger_weight != std::end(weights))
+    return *next_bigger_weight;
+  return Font::Weight::INVALID;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font.h b/ui/gfx/font.h
new file mode 100644
index 0000000..f797b0d
--- /dev/null
+++ b/ui/gfx/font.h
@@ -0,0 +1,144 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_H_
+#define UI_GFX_FONT_H_
+
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "build/build_config.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/native_widget_types.h"
+
+namespace gfx {
+
+struct FontRenderParams;
+class PlatformFont;
+
+// Font provides a wrapper around an underlying font. Copy and assignment
+// operators are explicitly allowed, and cheap.
+//
+// Figure of font metrics:
+//   +--------+-------------------+------------------+
+//   |        |                   | internal leading |
+//   |        | ascent (baseline) +------------------+
+//   | height |                   | cap height       |
+//   |        |-------------------+------------------+
+//   |        | descent (height - baseline)          |
+//   +--------+--------------------------------------+
+class GFX_EXPORT Font {
+ public:
+  // The following constants indicate the font style.
+  enum FontStyle {
+    NORMAL = 0,
+    ITALIC = 1,
+    UNDERLINE = 2,
+  };
+
+  // Standard font weights as used in Pango and Windows. The values must match
+  // https://msdn.microsoft.com/en-us/library/system.windows.fontweights(v=vs.110).aspx
+  enum class Weight {
+    INVALID = -1,
+    THIN = 100,
+    EXTRA_LIGHT = 200,
+    LIGHT = 300,
+    NORMAL = 400,
+    MEDIUM = 500,
+    SEMIBOLD = 600,
+    BOLD = 700,
+    EXTRA_BOLD = 800,
+    BLACK = 900,
+  };
+
+  // Creates a font with the default name and style.
+  Font();
+
+  // Creates a font that is a clone of another font object.
+  Font(const Font& other);
+  Font& operator=(const Font& other);
+
+#if defined(OS_APPLE)
+  // Creates a font from the specified native font.
+  explicit Font(NativeFont native_font);
+#endif
+
+  // Constructs a Font object with the specified PlatformFont object. The Font
+  // object takes ownership of the PlatformFont object.
+  explicit Font(PlatformFont* platform_font);
+
+  // Creates a font with the specified name in UTF-8 and size in pixels.
+  Font(const std::string& font_name, int font_size);
+
+  ~Font();
+
+  // Returns a new Font derived from the existing font.
+  // |size_delta| is the size in pixels to add to the current font. For example,
+  // a value of 5 results in a font 5 pixels bigger than this font.
+  // The style parameter specifies the new style for the font, and is a
+  // bitmask of the values: ITALIC and UNDERLINE.
+  Font Derive(int size_delta, int style, Font::Weight weight) const;
+
+  // Returns the number of vertical pixels needed to display characters from
+  // the specified font.  This may include some leading, i.e. height may be
+  // greater than just ascent + descent.  Specifically, the Windows and Mac
+  // implementations include leading and the Linux one does not.  This may
+  // need to be revisited in the future.
+  int GetHeight() const;
+
+  // Returns the font weight.
+  Font::Weight GetWeight() const;
+
+  // Returns the baseline, or ascent, of the font.
+  int GetBaseline() const;
+
+  // Returns the cap height of the font.
+  int GetCapHeight() const;
+
+  // Returns the expected number of horizontal pixels needed to display the
+  // specified length of characters. Call gfx::GetStringWidth() to retrieve the
+  // actual number.
+  int GetExpectedTextWidth(int length) const;
+
+  // Returns the style of the font.
+  int GetStyle() const;
+
+  // Returns the specified font name in UTF-8, without font mapping.
+  const std::string& GetFontName() const;
+
+  // Returns the actually used font name in UTF-8 after font mapping.
+  std::string GetActualFontName() const;
+
+  // Returns the font size in pixels.
+  int GetFontSize() const;
+
+  // Returns an object describing how the font should be rendered.
+  const FontRenderParams& GetFontRenderParams() const;
+
+#if defined(OS_APPLE)
+  // Returns the native font handle.
+  // Lifetime lore:
+  // Mac:     The object is owned by the system and should not be released.
+  NativeFont GetNativeFont() const;
+#endif
+
+  // Raw access to the underlying platform font implementation.
+  PlatformFont* platform_font() const { return platform_font_.get(); }
+
+ private:
+  // Wrapped platform font implementation.
+  scoped_refptr<PlatformFont> platform_font_;
+};
+
+#ifndef NDEBUG
+GFX_EXPORT std::ostream& operator<<(std::ostream& stream,
+                                    const Font::Weight weight);
+#endif
+
+// Returns the Font::Weight that matches |weight| or the next bigger one.
+GFX_EXPORT Font::Weight FontWeightFromInt(int weight);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FONT_H_
diff --git a/ui/gfx/font_fallback.h b/ui/gfx/font_fallback.h
new file mode 100644
index 0000000..001ec40
--- /dev/null
+++ b/ui/gfx/font_fallback.h
@@ -0,0 +1,32 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_FALLBACK_H_
+#define UI_GFX_FONT_FALLBACK_H_
+
+#include <string>
+#include <vector>
+
+#include "build/build_config.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class Font;
+
+// Given a font, returns the fonts that are suitable for fallback.
+GFX_EXPORT std::vector<Font> GetFallbackFonts(const Font& font);
+
+// Finds a fallback font to render the specified |text| with respect to an
+// initial |font|. Returns the resulting font via out param |result|. Returns
+// |true| if a fallback font was found.
+bool GFX_EXPORT GetFallbackFont(const Font& font,
+                                const std::string& locale,
+                                base::StringPiece16 text,
+                                Font* result);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FONT_FALLBACK_H_
diff --git a/ui/gfx/font_fallback_linux.cc b/ui/gfx/font_fallback_linux.cc
new file mode 100644
index 0000000..5f3240c
--- /dev/null
+++ b/ui/gfx/font_fallback_linux.cc
@@ -0,0 +1,531 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/font_fallback_linux.h"
+
+#include <fontconfig/fontconfig.h>
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "base/containers/mru_cache.h"
+#include "base/files/file_path.h"
+#include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
+#include "base/no_destructor.h"
+#include "base/trace_event/trace_event.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "third_party/icu/source/common/unicode/utf16.h"
+#include "third_party/skia/include/core/SkFontMgr.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_fallback.h"
+#include "ui/gfx/linux/fontconfig_util.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+
+namespace {
+
+const char kFontFormatTrueType[] = "TrueType";
+const char kFontFormatCFF[] = "CFF";
+
+bool IsValidFontFromPattern(FcPattern* pattern) {
+  // Ignore any bitmap fonts users may still have installed from last
+  // century.
+  if (!IsFontScalable(pattern))
+    return false;
+
+  // Take only supported font formats on board.
+  std::string format = GetFontFormat(pattern);
+  if (format != kFontFormatTrueType && format != kFontFormatCFF)
+    return false;
+
+  // Ignore any fonts FontConfig knows about, but that we don't have
+  // permission to read.
+  base::FilePath font_path = GetFontPath(pattern);
+  if (font_path.empty() || access(font_path.AsUTF8Unsafe().c_str(), R_OK))
+    return false;
+
+  return true;
+}
+
+// This class uniquely identified a typeface. A typeface can be identified by
+// its file path and it's ttc index.
+class TypefaceCacheKey {
+ public:
+  TypefaceCacheKey(const base::FilePath& font_path, int ttc_index)
+      : font_path_(font_path), ttc_index_(ttc_index) {}
+  TypefaceCacheKey(const TypefaceCacheKey&) = default;
+  TypefaceCacheKey& operator=(const TypefaceCacheKey&) = default;
+
+  const base::FilePath& font_path() const { return font_path_; }
+  int ttc_index() const { return ttc_index_; }
+
+  bool operator<(const TypefaceCacheKey& other) const {
+    return std::tie(ttc_index_, font_path_) <
+           std::tie(other.ttc_index_, other.font_path_);
+  }
+
+ private:
+  base::FilePath font_path_;
+  int ttc_index_;
+};
+
+// Returns a SkTypeface for a given font path and ttc_index. The typeface is
+// cached to avoid reloading the font from file. SkTypeface is not caching
+// these requests.
+sk_sp<SkTypeface> GetSkTypefaceFromPathAndIndex(const base::FilePath& font_path,
+                                                int ttc_index) {
+  using TypefaceCache = std::map<TypefaceCacheKey, sk_sp<SkTypeface>>;
+  static base::NoDestructor<TypefaceCache> typeface_cache;
+
+  if (font_path.empty())
+    return nullptr;
+
+  TypefaceCache* cache = typeface_cache.get();
+  TypefaceCacheKey key(font_path, ttc_index);
+  TypefaceCache::iterator entry = cache->find(key);
+  if (entry != cache->end())
+    return sk_sp<SkTypeface>(entry->second);
+
+  sk_sp<SkFontMgr> font_mgr = SkFontMgr::RefDefault();
+  std::string filename = font_path.AsUTF8Unsafe();
+  sk_sp<SkTypeface> typeface =
+      font_mgr->makeFromFile(filename.c_str(), ttc_index);
+  (*cache)[key] = typeface;
+
+  return sk_sp<SkTypeface>(typeface);
+}
+
+// Implements a fallback font cache over FontConfig API.
+//
+// A MRU cache is kept from a font to its potential fallback fonts.
+// The key (e.g. FallbackFontEntry) contains the font for which
+// fallback font must be returned.
+//
+// For each key, the cache is keeping a set (e.g. FallbackFontEntries) of
+// potential fallback font (e.g. FallbackFontEntry). Each fallback font entry
+// contains the supported codepoints (e.g. charset). The fallback font returned
+// by GetFallbackFont(...) depends on the input text and is using the charset
+// to determine the best candidate.
+class FallbackFontKey {
+ public:
+  FallbackFontKey(std::string locale, Font font)
+      : locale_(locale), font_(font) {}
+
+  FallbackFontKey(const FallbackFontKey&) = default;
+
+  FallbackFontKey& operator=(const FallbackFontKey&) = delete;
+
+  ~FallbackFontKey() = default;
+
+  bool operator<(const FallbackFontKey& other) const {
+    if (font_.GetFontSize() != other.font_.GetFontSize())
+      return font_.GetFontSize() < other.font_.GetFontSize();
+    if (font_.GetStyle() != other.font_.GetStyle())
+      return font_.GetStyle() < other.font_.GetStyle();
+    if (font_.GetFontName() != other.font_.GetFontName())
+      return font_.GetFontName() < other.font_.GetFontName();
+    return locale_ < other.locale_;
+  }
+
+ private:
+  std::string locale_;
+  Font font_;
+};
+
+class FallbackFontEntry {
+ public:
+  FallbackFontEntry(const base::FilePath& font_path,
+                    int ttc_index,
+                    FontRenderParams font_params,
+                    FcCharSet* charset)
+      : font_path_(font_path),
+        ttc_index_(ttc_index),
+        font_params_(font_params),
+        charset_(FcCharSetCopy(charset)) {}
+
+  FallbackFontEntry(const FallbackFontEntry& other)
+      : font_path_(other.font_path_),
+        ttc_index_(other.ttc_index_),
+        font_params_(other.font_params_),
+        charset_(FcCharSetCopy(other.charset_)) {}
+
+  FallbackFontEntry& operator=(const FallbackFontEntry&) = delete;
+
+  ~FallbackFontEntry() { FcCharSetDestroy(charset_); }
+
+  const base::FilePath& font_path() const { return font_path_; }
+  int ttc_index() const { return ttc_index_; }
+  FontRenderParams font_params() const { return font_params_; }
+
+  // Returns whether the fallback font support the codepoint.
+  bool HasGlyphForCharacter(UChar32 c) const {
+    return FcCharSetHasChar(charset_, static_cast<FcChar32>(c));
+  }
+
+ private:
+  // Font identity fields.
+  base::FilePath font_path_;
+  int ttc_index_;
+
+  // Font rendering parameters.
+  FontRenderParams font_params_;
+
+  // Font code points coverage.
+  FcCharSet* charset_;
+};
+
+using FallbackFontEntries = std::vector<FallbackFontEntry>;
+using FallbackFontEntriesCache =
+    base::MRUCache<FallbackFontKey, FallbackFontEntries>;
+
+// The fallback font cache is a mapping from a font to the potential fallback
+// fonts with their codepoint coverage.
+FallbackFontEntriesCache* GetFallbackFontEntriesCacheInstance() {
+  constexpr int kFallbackFontCacheSize = 256;
+  static base::NoDestructor<FallbackFontEntriesCache> cache(
+      kFallbackFontCacheSize);
+  return cache.get();
+}
+
+// The fallback fonts cache is a mapping from a font family name to its
+// potential fallback fonts.
+using FallbackFontList = std::vector<Font>;
+using FallbackFontListCache = base::MRUCache<std::string, FallbackFontList>;
+
+FallbackFontListCache* GetFallbackFontListCacheInstance() {
+  constexpr int kFallbackCacheSize = 64;
+  static base::NoDestructor<FallbackFontListCache> fallback_cache(
+      kFallbackCacheSize);
+  return fallback_cache.get();
+}
+
+}  // namespace
+
+size_t GetFallbackFontEntriesCacheSizeForTesting() {
+  return GetFallbackFontEntriesCacheInstance()->size();
+}
+
+size_t GetFallbackFontListCacheSizeForTesting() {
+  return GetFallbackFontListCacheInstance()->size();
+}
+
+void ClearAllFontFallbackCachesForTesting() {
+  GetFallbackFontEntriesCacheInstance()->Clear();
+  GetFallbackFontListCacheInstance()->Clear();
+}
+
+bool GetFallbackFont(const Font& font,
+                     const std::string& locale,
+                     base::StringPiece16 text,
+                     Font* result) {
+  TRACE_EVENT0("fonts", "gfx::GetFallbackFont");
+
+  // The text passed must be at least length 1.
+  if (text.empty())
+    return false;
+
+  FallbackFontEntriesCache* cache = GetFallbackFontEntriesCacheInstance();
+  FallbackFontKey key(locale, font);
+  FallbackFontEntriesCache::iterator cache_entry = cache->Get(key);
+
+  // The cache entry for this font is missing, build it.
+  if (cache_entry == cache->end()) {
+    ScopedFcPattern pattern(FcPatternCreate());
+
+    // Add pattern for family name.
+    std::string font_family = font.GetFontName();
+    FcPatternAddString(pattern.get(), FC_FAMILY,
+                       reinterpret_cast<const FcChar8*>(font_family.c_str()));
+
+    // Prefer scalable font.
+    FcPatternAddBool(pattern.get(), FC_SCALABLE, FcTrue);
+
+    // Add pattern for locale.
+    FcPatternAddString(pattern.get(), FC_LANG,
+                       reinterpret_cast<const FcChar8*>(locale.c_str()));
+
+    // Add pattern for font style.
+    if ((font.GetStyle() & gfx::Font::ITALIC) != 0)
+      FcPatternAddInteger(pattern.get(), FC_SLANT, FC_SLANT_ITALIC);
+
+    // Match a font fallback.
+    FcConfig* config = GetGlobalFontConfig();
+    FcConfigSubstitute(config, pattern.get(), FcMatchPattern);
+    FcDefaultSubstitute(pattern.get());
+
+    FallbackFontEntries fallback_font_entries;
+    FcResult fc_result;
+    FcFontSet* fonts =
+        FcFontSort(config, pattern.get(), FcTrue, nullptr, &fc_result);
+    if (fonts) {
+      // Add each potential fallback font returned by font-config to the
+      // set of fallback fonts and keep track of their codepoints coverage.
+      for (int i = 0; i < fonts->nfont; ++i) {
+        FcPattern* current_font = fonts->fonts[i];
+        if (!IsValidFontFromPattern(current_font))
+          continue;
+
+        // Retrieve the font identity fields.
+        base::FilePath font_path = GetFontPath(current_font);
+        int font_ttc_index = GetFontTtcIndex(current_font);
+
+        // Retrieve the charset of the current font.
+        FcCharSet* char_set = nullptr;
+        fc_result = FcPatternGetCharSet(current_font, FC_CHARSET, 0, &char_set);
+        if (fc_result != FcResultMatch || char_set == nullptr)
+          continue;
+
+        // Retrieve the font render params.
+        FontRenderParams font_params;
+        GetFontRenderParamsFromFcPattern(current_font, &font_params);
+
+        fallback_font_entries.push_back(FallbackFontEntry(
+            font_path, font_ttc_index, font_params, char_set));
+      }
+      FcFontSetDestroy(fonts);
+    }
+
+    cache_entry = cache->Put(key, std::move(fallback_font_entries));
+  }
+
+  // Try each font in the cache to find the one with the highest coverage.
+  size_t fewest_missing_glyphs = text.length() + 1;
+  const FallbackFontEntry* prefered_entry = nullptr;
+
+  for (const auto& entry : cache_entry->second) {
+    // Validate that every character has a known glyph in the font.
+    size_t missing_glyphs = 0;
+    size_t matching_glyphs = 0;
+    size_t i = 0;
+    while (i < text.length()) {
+      UChar32 c = 0;
+      U16_NEXT(text.data(), i, text.length(), c);
+      if (entry.HasGlyphForCharacter(c)) {
+        ++matching_glyphs;
+      } else {
+        ++missing_glyphs;
+      }
+    }
+
+    if (matching_glyphs > 0 && missing_glyphs < fewest_missing_glyphs) {
+      fewest_missing_glyphs = missing_glyphs;
+      prefered_entry = &entry;
+    }
+
+    // The font has coverage for the given text and is a valid fallback font.
+    if (missing_glyphs == 0)
+      break;
+  }
+
+  // No fonts can be used as font fallback.
+  if (!prefered_entry)
+    return false;
+
+  sk_sp<SkTypeface> typeface = GetSkTypefaceFromPathAndIndex(
+      prefered_entry->font_path(), prefered_entry->ttc_index());
+  // The file can't be parsed (e.g. corrupt). This font can't be used as a
+  // fallback font.
+  if (!typeface)
+    return false;
+
+  Font fallback_font(PlatformFont::CreateFromSkTypeface(
+      typeface, font.GetFontSize(), prefered_entry->font_params()));
+
+  *result = fallback_font;
+  return true;
+}
+
+std::vector<Font> GetFallbackFonts(const Font& font) {
+  TRACE_EVENT0("fonts", "gfx::GetFallbackFonts");
+
+  std::string font_family = font.GetFontName();
+
+  // Lookup in the cache for already processed family.
+  FallbackFontListCache* font_cache = GetFallbackFontListCacheInstance();
+  auto cached_fallback_fonts = font_cache->Get(font_family);
+  if (cached_fallback_fonts != font_cache->end()) {
+    // Already in cache.
+    return cached_fallback_fonts->second;
+  }
+
+  // Retrieve the font fallbacks for a given family name.
+  FallbackFontList fallback_fonts;
+  FcPattern* pattern = FcPatternCreate();
+  FcPatternAddString(pattern, FC_FAMILY,
+                     reinterpret_cast<const FcChar8*>(font_family.c_str()));
+
+  FcConfig* config = GetGlobalFontConfig();
+  if (FcConfigSubstitute(config, pattern, FcMatchPattern) == FcTrue) {
+    FcDefaultSubstitute(pattern);
+    FcResult result;
+    FcFontSet* fonts = FcFontSort(config, pattern, FcTrue, nullptr, &result);
+    if (fonts) {
+      std::set<std::string> fallback_names;
+      for (int i = 0; i < fonts->nfont; ++i) {
+        std::string name_str = GetFontName(fonts->fonts[i]);
+        if (name_str.empty())
+          continue;
+
+        // FontConfig returns multiple fonts with the same family name and
+        // different configurations. Check to prevent duplicate family names.
+        if (fallback_names.insert(name_str).second)
+          fallback_fonts.push_back(Font(name_str, 13));
+      }
+      FcFontSetDestroy(fonts);
+    }
+  }
+  FcPatternDestroy(pattern);
+
+  // Store the font fallbacks to the cache.
+  font_cache->Put(font_family, fallback_fonts);
+
+  return fallback_fonts;
+}
+
+namespace {
+
+class CachedFont {
+ public:
+  // Note: We pass the charset explicitly as callers
+  // should not create CachedFont entries without knowing
+  // that the FcPattern contains a valid charset.
+  CachedFont(FcPattern* pattern, FcCharSet* char_set)
+      : supported_characters_(char_set) {
+    DCHECK(pattern);
+    DCHECK(char_set);
+    fallback_font_.name = GetFontName(pattern);
+    fallback_font_.filepath = GetFontPath(pattern);
+    fallback_font_.ttc_index = GetFontTtcIndex(pattern);
+    fallback_font_.is_bold = IsFontBold(pattern);
+    fallback_font_.is_italic = IsFontItalic(pattern);
+  }
+
+  const FallbackFontData& fallback_font() const { return fallback_font_; }
+
+  bool HasGlyphForCharacter(UChar32 c) const {
+    return supported_characters_ && FcCharSetHasChar(supported_characters_, c);
+  }
+
+ private:
+  FallbackFontData fallback_font_;
+  // supported_characters_ is owned by the parent
+  // FcFontSet and should never be freed.
+  FcCharSet* supported_characters_;
+};
+
+class CachedFontSet {
+ public:
+  // CachedFontSet takes ownership of the passed FcFontSet.
+  static std::unique_ptr<CachedFontSet> CreateForLocale(
+      const std::string& locale) {
+    FcFontSet* font_set = CreateFcFontSetForLocale(locale);
+    return base::WrapUnique(new CachedFontSet(font_set));
+  }
+
+  CachedFontSet(const CachedFontSet&) = delete;
+  CachedFontSet& operator=(const CachedFontSet&) = delete;
+
+  ~CachedFontSet() {
+    fallback_list_.clear();
+    FcFontSetDestroy(font_set_);
+  }
+
+  bool GetFallbackFontForChar(UChar32 c, FallbackFontData* fallback_font) {
+    TRACE_EVENT0("fonts", "gfx::CachedFontSet::GetFallbackFontForChar");
+
+    for (const auto& cached_font : fallback_list_) {
+      if (cached_font.HasGlyphForCharacter(c)) {
+        *fallback_font = cached_font.fallback_font();
+        return true;
+      }
+    }
+    return false;
+  }
+
+ private:
+  static FcFontSet* CreateFcFontSetForLocale(const std::string& locale) {
+    FcPattern* pattern = FcPatternCreate();
+
+    if (!locale.empty()) {
+      // FcChar* is unsigned char* so we have to cast.
+      FcPatternAddString(pattern, FC_LANG,
+                         reinterpret_cast<const FcChar8*>(locale.c_str()));
+    }
+
+    FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
+
+    FcConfigSubstitute(0, pattern, FcMatchPattern);
+    FcDefaultSubstitute(pattern);
+
+    if (locale.empty())
+      FcPatternDel(pattern, FC_LANG);
+
+    // The result parameter returns if any fonts were found.
+    // We already handle 0 fonts correctly, so we ignore the param.
+    FcResult result;
+    FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result);
+    FcPatternDestroy(pattern);
+
+    // The caller will take ownership of this FcFontSet.
+    return font_set;
+  }
+
+  CachedFontSet(FcFontSet* font_set) : font_set_(font_set) {
+    FillFallbackList();
+  }
+
+  void FillFallbackList() {
+    TRACE_EVENT0("fonts", "gfx::CachedFontSet::FillFallbackList");
+
+    DCHECK(fallback_list_.empty());
+    if (!font_set_)
+      return;
+
+    for (int i = 0; i < font_set_->nfont; ++i) {
+      FcPattern* pattern = font_set_->fonts[i];
+
+      if (!IsValidFontFromPattern(pattern))
+        continue;
+
+      // Make sure this font can tell us what characters it has glyphs for.
+      FcCharSet* char_set;
+      if (FcPatternGetCharSet(pattern, FC_CHARSET, 0, &char_set) !=
+          FcResultMatch)
+        continue;
+
+      fallback_list_.emplace_back(pattern, char_set);
+    }
+  }
+
+  FcFontSet* font_set_;  // Owned by this object.
+  // CachedFont has a FcCharset* which points into the FcFontSet.
+  // If the FcFontSet is ever destroyed, the fallback list
+  // must be cleared first.
+  std::vector<CachedFont> fallback_list_;
+};
+
+typedef std::map<std::string, std::unique_ptr<CachedFontSet>> FontSetCache;
+base::LazyInstance<FontSetCache>::Leaky g_font_sets_by_locale =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+FallbackFontData::FallbackFontData() = default;
+FallbackFontData::FallbackFontData(const FallbackFontData& other) = default;
+FallbackFontData& FallbackFontData::operator=(const FallbackFontData& other) =
+    default;
+
+bool GetFallbackFontForChar(UChar32 c,
+                            const std::string& locale,
+                            FallbackFontData* fallback_font) {
+  auto& cached_font_set = g_font_sets_by_locale.Get()[locale];
+  if (!cached_font_set)
+    cached_font_set = CachedFontSet::CreateForLocale(locale);
+  return cached_font_set->GetFallbackFontForChar(c, fallback_font);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_linux.h b/ui/gfx/font_fallback_linux.h
new file mode 100644
index 0000000..7a768690
--- /dev/null
+++ b/ui/gfx/font_fallback_linux.h
@@ -0,0 +1,47 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_FALLBACK_LINUX_H_
+#define UI_GFX_FONT_FALLBACK_LINUX_H_
+
+#include <string>
+
+#include "base/files/file_path.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Exposed fallback font caches methods for testing.
+GFX_EXPORT size_t GetFallbackFontEntriesCacheSizeForTesting();
+GFX_EXPORT size_t GetFallbackFontListCacheSizeForTesting();
+GFX_EXPORT void ClearAllFontFallbackCachesForTesting();
+
+struct GFX_EXPORT FallbackFontData {
+  std::string name;
+  base::FilePath filepath;
+  int fontconfig_interface_id = 0;
+  int ttc_index = 0;
+  bool is_bold = false;
+  bool is_italic = false;
+
+  FallbackFontData();
+  FallbackFontData(const FallbackFontData& other);
+  FallbackFontData& operator=(const FallbackFontData& other);
+};
+
+// Return a font family which provides a glyph for the Unicode code point
+// specified by character.
+//   c: an UTF-32 code point
+//   preferred_locale: preferred locale identifier for |c|
+//                     (e.g. "en", "ja", "zh-CN")
+//
+// Return whether the request was successful or not.
+GFX_EXPORT bool GetFallbackFontForChar(UChar32 c,
+                                       const std::string& preferred_locale,
+                                       FallbackFontData* fallback_font);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FONT_FALLBACK_LINUX_H_
diff --git a/ui/gfx/font_fallback_linux_unittest.cc b/ui/gfx/font_fallback_linux_unittest.cc
new file mode 100644
index 0000000..ec156cf
--- /dev/null
+++ b/ui/gfx/font_fallback_linux_unittest.cc
@@ -0,0 +1,106 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/font_fallback_linux.h"
+
+#include "base/files/file_path.h"
+#include "base/strings/utf_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_fallback.h"
+
+namespace gfx {
+
+namespace {
+const char kDefaultApplicationLocale[] = "us-en";
+const char kFrenchApplicationLocale[] = "ca-fr";
+}  // namespace
+
+class FontFallbackLinuxTest : public testing::Test {
+ public:
+  void SetUp() override {
+    // Clear the font fallback caches.
+    ClearAllFontFallbackCachesForTesting();
+  }
+};
+
+// If the Type 1 Symbol.pfb font is installed, it is returned as fallback font
+// for the PUA character 0xf6db. This test ensures we're not returning Type 1
+// fonts as fallback.
+TEST_F(FontFallbackLinuxTest, NoType1InFallbackFonts) {
+  FallbackFontData font_fallback_data;
+  if (GetFallbackFontForChar(0xf6db, std::string(), &font_fallback_data)) {
+    std::string extension = font_fallback_data.filepath.Extension();
+    if (!extension.empty())
+      EXPECT_NE(extension, ".pfb");
+  }
+}
+
+TEST_F(FontFallbackLinuxTest, GetFallbackFont) {
+  Font base_font;
+
+  Font fallback_font_cjk;
+  EXPECT_TRUE(GetFallbackFont(base_font, kDefaultApplicationLocale, u"⻩",
+                              &fallback_font_cjk));
+  EXPECT_EQ(fallback_font_cjk.GetFontName(), "Noto Sans CJK JP");
+
+  Font fallback_font_khmer;
+  EXPECT_TRUE(GetFallbackFont(base_font, kDefaultApplicationLocale, u"ឨឮឡ",
+                              &fallback_font_khmer));
+  EXPECT_EQ(fallback_font_khmer.GetFontName(), "Noto Sans Khmer");
+}
+
+TEST_F(FontFallbackLinuxTest, GetFallbackFontCache) {
+  EXPECT_EQ(0U, GetFallbackFontEntriesCacheSizeForTesting());
+
+  Font base_font;
+  Font fallback_font;
+  EXPECT_TRUE(GetFallbackFont(base_font, kDefaultApplicationLocale, u"⻩",
+                              &fallback_font));
+  EXPECT_EQ(1U, GetFallbackFontEntriesCacheSizeForTesting());
+
+  // Second call should not increase the cache size.
+  EXPECT_TRUE(GetFallbackFont(base_font, kDefaultApplicationLocale, u"⻩",
+                              &fallback_font));
+  EXPECT_EQ(1U, GetFallbackFontEntriesCacheSizeForTesting());
+
+  // Third call with a different code point in the same font, should not
+  // increase the cache size.
+  EXPECT_TRUE(GetFallbackFont(base_font, kDefaultApplicationLocale, u"⻪",
+                              &fallback_font));
+  EXPECT_EQ(1U, GetFallbackFontEntriesCacheSizeForTesting());
+
+  // A different locale should trigger an new cache entry.
+  EXPECT_TRUE(GetFallbackFont(base_font, kFrenchApplicationLocale, u"⻩",
+                              &fallback_font));
+  EXPECT_EQ(2U, GetFallbackFontEntriesCacheSizeForTesting());
+
+  // The fallbackfonts cache should not be affected.
+  EXPECT_EQ(0U, GetFallbackFontListCacheSizeForTesting());
+}
+
+TEST_F(FontFallbackLinuxTest, Fallbacks) {
+  EXPECT_EQ(0U, GetFallbackFontListCacheSizeForTesting());
+
+  Font default_font("sans", 13);
+  std::vector<Font> fallbacks = GetFallbackFonts(default_font);
+  EXPECT_FALSE(fallbacks.empty());
+  EXPECT_EQ(1U, GetFallbackFontListCacheSizeForTesting());
+
+  // The first fallback should be 'DejaVu Sans' which is the default linux
+  // fonts. The fonts on linux are mock with test_fonts (see
+  // third_party/tests_font).
+  if (!fallbacks.empty())
+    EXPECT_EQ(fallbacks[0].GetFontName(), "DejaVu Sans");
+
+  // Second lookup should not increase the cache size.
+  fallbacks = GetFallbackFonts(default_font);
+  EXPECT_FALSE(fallbacks.empty());
+  EXPECT_EQ(1U, GetFallbackFontListCacheSizeForTesting());
+
+  // The fallbackfont cache should not be affected.
+  EXPECT_EQ(0U, GetFallbackFontEntriesCacheSizeForTesting());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_mac.mm b/ui/gfx/font_fallback_mac.mm
new file mode 100644
index 0000000..aee2249
--- /dev/null
+++ b/ui/gfx/font_fallback_mac.mm
@@ -0,0 +1,95 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/font_fallback.h"
+
+#include <CoreText/CoreText.h>
+#import <Foundation/Foundation.h>
+
+#include "base/i18n/char_iterator.h"
+#include "base/mac/foundation_util.h"
+#import "base/mac/mac_util.h"
+#include "base/mac/scoped_cftyperef.h"
+#import "base/strings/sys_string_conversions.h"
+#include "base/trace_event/trace_event.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_fallback_skia_impl.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+
+namespace {
+
+bool TextSequenceHasEmoji(base::StringPiece16 text) {
+  for (base::i18n::UTF16CharIterator iter(text); !iter.end(); iter.Advance()) {
+    const UChar32 codepoint = iter.get();
+    if (u_hasBinaryProperty(codepoint, UCHAR_EMOJI))
+      return true;
+  }
+  return false;
+}
+
+}  // namespace
+
+std::vector<Font> GetFallbackFonts(const Font& font) {
+  DCHECK(font.GetNativeFont());
+  // On Mac "There is a system default cascade list (which is polymorphic, based
+  // on the user's language setting and current font)" - CoreText Programming
+  // Guide.
+  NSArray* languages = [[NSUserDefaults standardUserDefaults]
+      stringArrayForKey:@"AppleLanguages"];
+  CFArrayRef languages_cf = base::mac::NSToCFCast(languages);
+  base::ScopedCFTypeRef<CFArrayRef> cascade_list(
+      CTFontCopyDefaultCascadeListForLanguages(
+          static_cast<CTFontRef>(font.GetNativeFont()), languages_cf));
+
+  std::vector<Font> fallback_fonts;
+  if (!cascade_list)
+    return fallback_fonts;  // This should only happen for an invalid |font|.
+
+  const CFIndex fallback_count = CFArrayGetCount(cascade_list);
+  for (CFIndex i = 0; i < fallback_count; ++i) {
+    CTFontDescriptorRef descriptor =
+        base::mac::CFCastStrict<CTFontDescriptorRef>(
+            CFArrayGetValueAtIndex(cascade_list, i));
+    base::ScopedCFTypeRef<CTFontRef> fallback_font(
+        CTFontCreateWithFontDescriptor(descriptor, 0.0, nullptr));
+    if (fallback_font.get())
+      fallback_fonts.push_back(Font(static_cast<NSFont*>(fallback_font.get())));
+  }
+
+  if (fallback_fonts.empty())
+    return std::vector<Font>(1, font);
+
+  return fallback_fonts;
+}
+
+bool GetFallbackFont(const Font& font,
+                     const std::string& locale,
+                     base::StringPiece16 text,
+                     Font* result) {
+  TRACE_EVENT0("fonts", "gfx::GetFallbackFont");
+
+  if (TextSequenceHasEmoji(text)) {
+    *result = Font("Apple Color Emoji", font.GetFontSize());
+    return true;
+  }
+
+  sk_sp<SkTypeface> fallback_typeface =
+      GetSkiaFallbackTypeface(font, locale, text);
+
+  if (!fallback_typeface)
+    return false;
+
+  // Fallback needs to keep the exact SkTypeface, as re-matching the font using
+  // family name and styling information loses access to the underlying platform
+  // font handles and is not guaranteed to result in the correct typeface, see
+  // https://crbug.com/1003829
+  *result = Font(PlatformFont::CreateFromSkTypeface(
+      std::move(fallback_typeface), font.GetFontSize(), absl::nullopt));
+  return true;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_mac_unittest.cc b/ui/gfx/font_fallback_mac_unittest.cc
new file mode 100644
index 0000000..dbb1724
--- /dev/null
+++ b/ui/gfx/font_fallback_mac_unittest.cc
@@ -0,0 +1,76 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/font_fallback.h"
+
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font.h"
+
+namespace gfx {
+
+namespace {
+const char kDefaultApplicationLocale[] = "us-en";
+}  // namespace
+
+// A targeted test for GetFallbackFonts on Mac. It uses a system API that
+// only became publicly available in the 10.8 SDK. This test is to ensure it
+// behaves sensibly on all supported OS versions.
+TEST(FontFallbackMacTest, GetFallbackFonts) {
+  Font font("Arial", 12);
+  std::vector<Font> fallback_fonts = GetFallbackFonts(font);
+  // If there is only one fallback, it means the only fallback is the font
+  // itself.
+  EXPECT_LT(1u, fallback_fonts.size());
+}
+
+// Sanity check GetFallbackFont() behavior on Mac. This test makes assumptions
+// about font properties and availability on specific macOS versions.
+TEST(FontFallbackMacTest, GetFallbackFont) {
+  Font arial("Helvetica", 12);
+  const std::u16string ascii = u"abc";
+  const std::u16string hebrew = u"\x5d0\x5d1\x5d2";
+  const std::u16string emoji = u"😋";
+
+  Font fallback;
+  EXPECT_TRUE(
+      GetFallbackFont(arial, kDefaultApplicationLocale, hebrew, &fallback));
+  EXPECT_EQ("Lucida Grande", fallback.GetFontName());
+  EXPECT_TRUE(
+      GetFallbackFont(arial, kDefaultApplicationLocale, emoji, &fallback));
+  EXPECT_EQ("Apple Color Emoji", fallback.GetFontName());
+}
+
+TEST(FontFallbackMacTest, GetFallbackFontForEmoji) {
+  static struct {
+    const char* test_name;
+    const wchar_t* text;
+  } kEmojiTests[] = {
+      {"aries", L"\u2648"},
+      {"candle", L"\U0001F56F"},
+      {"anchor", L"\u2693"},
+      {"grinning_face", L"\U0001F600"},
+      {"flag_andorra", L"\U0001F1E6\U0001F1E9"},
+      {"woman_man_hands_light", L"\U0001F46B\U0001F3FB"},
+      {"hole_text", L"\U0001F573\uFE0E"},
+      {"hole_emoji", L"\U0001F573\uFE0F"},
+      {"man_judge_medium", L"\U0001F468\U0001F3FD\u200D\u2696\uFE0F"},
+      {"woman_turban", L"\U0001F473\u200D\u2640\uFE0F"},
+      {"rainbow_flag", L"\U0001F3F3\uFE0F\u200D\U0001F308"},
+      {"eye_bubble", L"\U0001F441\uFE0F\u200D\U0001F5E8\uFE0F"},
+  };
+
+  Font font;
+  for (const auto& test : kEmojiTests) {
+    SCOPED_TRACE(
+        base::StringPrintf("GetFallbackFontForEmoji [%s]", test.test_name));
+    Font fallback;
+    EXPECT_TRUE(GetFallbackFont(font, kDefaultApplicationLocale,
+                                base::WideToUTF16(test.text), &fallback));
+    EXPECT_EQ("Apple Color Emoji", fallback.GetFontName());
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_skia.cc b/ui/gfx/font_fallback_skia.cc
new file mode 100644
index 0000000..29a5cc0
--- /dev/null
+++ b/ui/gfx/font_fallback_skia.cc
@@ -0,0 +1,49 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/font_fallback.h"
+
+#include <string>
+#include <vector>
+
+#include "base/strings/utf_string_conversions.h"
+#include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_fallback_skia_impl.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+
+std::vector<Font> GetFallbackFonts(const Font& font) {
+  return std::vector<Font>();
+}
+
+bool GetFallbackFont(const Font& font,
+                     const std::string& locale,
+                     base::StringPiece16 text,
+                     Font* result) {
+  TRACE_EVENT0("fonts", "gfx::GetFallbackFont");
+
+  if (text.empty())
+    return false;
+
+  sk_sp<SkTypeface> fallback_typeface =
+      GetSkiaFallbackTypeface(font, locale, text);
+
+  if (!fallback_typeface)
+    return false;
+
+  // Fallback needs to keep the exact SkTypeface, as re-matching the font using
+  // family name and styling information loses access to the underlying platform
+  // font handles and is not guaranteed to result in the correct typeface, see
+  // https://crbug.com/1003829
+  *result = Font(PlatformFont::CreateFromSkTypeface(
+      std::move(fallback_typeface), font.GetFontSize(), absl::nullopt));
+  return true;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_skia_impl.cc b/ui/gfx/font_fallback_skia_impl.cc
new file mode 100644
index 0000000..a2eb422
--- /dev/null
+++ b/ui/gfx/font_fallback_skia_impl.cc
@@ -0,0 +1,160 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/font_fallback_skia_impl.h"
+
+#include <set>
+#include <string>
+
+#include "third_party/icu/source/common/unicode/normalizer2.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "third_party/icu/source/common/unicode/utf16.h"
+#include "third_party/skia/include/core/SkFontMgr.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+
+namespace gfx {
+
+namespace {
+
+// Returns true when the codepoint has an unicode decomposition and store
+// the decomposed string into |output|.
+bool UnicodeDecomposeCodepoint(UChar32 codepoint, icu::UnicodeString* output) {
+  static const icu::Normalizer2* normalizer = nullptr;
+
+  UErrorCode error = U_ZERO_ERROR;
+  if (!normalizer) {
+    normalizer = icu::Normalizer2::getNFDInstance(error);
+    if (U_FAILURE(error))
+      return false;
+    DCHECK(normalizer);
+  }
+
+  return normalizer->getDecomposition(codepoint, *output);
+}
+
+// Extracts every codepoint and its decomposed codepoints from unicode
+// decomposition. Inserts in |codepoints| the set of codepoints in |text|.
+void RetrieveCodepointsAndDecomposedCodepoints(base::StringPiece16 text,
+                                               std::set<UChar32>* codepoints) {
+  size_t offset = 0;
+  while (offset < text.length()) {
+    UChar32 codepoint;
+    U16_NEXT(text.data(), offset, text.length(), codepoint);
+
+    if (codepoints->insert(codepoint).second) {
+      // For each codepoint, add the decomposed codepoints.
+      icu::UnicodeString decomposed_text;
+      if (UnicodeDecomposeCodepoint(codepoint, &decomposed_text)) {
+        for (int i = 0; i < decomposed_text.length(); ++i) {
+          codepoints->insert(decomposed_text[i]);
+        }
+      }
+    }
+  }
+}
+
+// Returns the amount of codepoint in |text| without a glyph representation in
+// |typeface|. A codepoint is present if there is a corresponding glyph in
+// typeface, or if there are glyphs for each of its decomposed codepoints.
+size_t ComputeMissingGlyphsForGivenTypeface(base::StringPiece16 text,
+                                            sk_sp<SkTypeface> typeface) {
+  // Validate that every character has a known glyph in the font.
+  size_t missing_glyphs = 0;
+  size_t i = 0;
+  while (i < text.length()) {
+    UChar32 codepoint;
+    U16_NEXT(text.data(), i, text.length(), codepoint);
+
+    // The glyph is present in the font.
+    if (typeface->unicharToGlyph(codepoint) != 0)
+      continue;
+
+    // Do not count missing codepoints when they are ignorable as they will be
+    // ignored by the shaping engine.
+    if (u_hasBinaryProperty(codepoint, UCHAR_DEFAULT_IGNORABLE_CODE_POINT))
+      continue;
+
+    // No glyph is present in the font for the codepoint. Try the decomposed
+    // codepoints instead.
+    icu::UnicodeString decomposed_text;
+    if (UnicodeDecomposeCodepoint(codepoint, &decomposed_text) &&
+        !decomposed_text.isEmpty()) {
+      // Check that every decomposed codepoint is in the font.
+      bool every_codepoint_found = true;
+      for (int offset = 0; offset < decomposed_text.length(); ++offset) {
+        if (typeface->unicharToGlyph(decomposed_text[offset]) == 0) {
+          every_codepoint_found = false;
+          break;
+        }
+      }
+
+      // The decomposed codepoints can be mapped to glyphs by the font.
+      if (every_codepoint_found)
+        continue;
+    }
+
+    // The current glyphs can't be find.
+    ++missing_glyphs;
+  }
+
+  return missing_glyphs;
+}
+
+}  // namespace
+
+sk_sp<SkTypeface> GetSkiaFallbackTypeface(const Font& template_font,
+                                          const std::string& locale,
+                                          base::StringPiece16 text) {
+  if (text.empty())
+    return nullptr;
+
+  sk_sp<SkFontMgr> font_mgr(SkFontMgr::RefDefault());
+
+  const char* bcp47_locales[] = {locale.c_str()};
+  int num_locales = locale.empty() ? 0 : 1;
+  const char** locales = locale.empty() ? nullptr : bcp47_locales;
+
+  const int font_weight = (template_font.GetWeight() == Font::Weight::INVALID)
+                              ? static_cast<int>(Font::Weight::NORMAL)
+                              : static_cast<int>(template_font.GetWeight());
+  const bool italic = (template_font.GetStyle() & Font::ITALIC) != 0;
+  SkFontStyle skia_style(
+      font_weight, SkFontStyle::kNormal_Width,
+      italic ? SkFontStyle::kItalic_Slant : SkFontStyle::kUpright_Slant);
+
+  std::set<SkFontID> tested_typeface;
+  sk_sp<SkTypeface> fallback_typeface;
+  size_t fewest_missing_glyphs = text.length() + 1;
+
+  // Retrieve the set of codepoints (or unicode decomposed codepoints) from
+  // the input text.
+  std::set<UChar32> codepoints;
+  RetrieveCodepointsAndDecomposedCodepoints(text, &codepoints);
+
+  // Determine which fallback font is given the fewer missing glyphs.
+  for (UChar32 codepoint : codepoints) {
+    sk_sp<SkTypeface> typeface(font_mgr->matchFamilyStyleCharacter(
+        template_font.GetFontName().c_str(), skia_style, locales, num_locales,
+        codepoint));
+    // If the typeface is not found or was already tested, skip it.
+    if (!typeface || !tested_typeface.insert(typeface->uniqueID()).second)
+      continue;
+
+    // Validate that every codepoint has a known glyph in the font.
+    size_t missing_glyphs =
+        ComputeMissingGlyphsForGivenTypeface(text, typeface);
+    if (missing_glyphs < fewest_missing_glyphs) {
+      fewest_missing_glyphs = missing_glyphs;
+      fallback_typeface = typeface;
+    }
+
+    // The font is a valid fallback font for the given text.
+    if (missing_glyphs == 0)
+      break;
+  }
+
+  return fallback_typeface;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_skia_impl.h b/ui/gfx/font_fallback_skia_impl.h
new file mode 100644
index 0000000..1908dee
--- /dev/null
+++ b/ui/gfx/font_fallback_skia_impl.h
@@ -0,0 +1,23 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_FALLBACK_SKIA_IMPL_H_
+#define UI_GFX_FONT_FALLBACK_SKIA_IMPL_H_
+
+#include <string>
+
+#include "base/strings/string_piece.h"
+#include "ui/gfx/font.h"
+
+#include "third_party/skia/include/core/SkRefCnt.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+
+namespace gfx {
+
+sk_sp<SkTypeface> GetSkiaFallbackTypeface(const Font& template_font,
+                                          const std::string& locale,
+                                          base::StringPiece16 text);
+}
+
+#endif  // UI_GFX_FONT_FALLBACK_SKIA_IMPL_H_
diff --git a/ui/gfx/font_fallback_skia_unittest.cc b/ui/gfx/font_fallback_skia_unittest.cc
new file mode 100644
index 0000000..01bd3f2
--- /dev/null
+++ b/ui/gfx/font_fallback_skia_unittest.cc
@@ -0,0 +1,96 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/font_fallback.h"
+
+#include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+
+namespace {
+
+const wchar_t* kFallbackFontTests[] = {
+    L"\u0540\u0541",  // Armenian,
+    L"\u0631\u0632",  // Arabic
+    L"\u0915\u093f",  // Devanagari
+    L"\u5203\u5204",  // CJK Unified Ideograph
+};
+
+const char kDefaultApplicationLocale[] = "us-en";
+
+}  // namespace
+
+TEST(FontFallbackSkiaTest, EmptyStringFallback) {
+  Font base_font;
+  Font fallback_font;
+  bool result = GetFallbackFont(base_font, kDefaultApplicationLocale,
+                                base::StringPiece16(), &fallback_font);
+  EXPECT_FALSE(result);
+}
+
+TEST(FontFallbackSkiaTest, FontFallback) {
+  for (const auto* test : kFallbackFontTests) {
+    Font base_font;
+    Font fallback_font;
+    std::u16string text = base::WideToUTF16(test);
+
+    if (!GetFallbackFont(base_font, kDefaultApplicationLocale, text,
+                         &fallback_font)) {
+      ADD_FAILURE() << "Font fallback failed: '" << text << "'";
+    }
+  }
+}
+
+#if !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
+// TODO(sergeyu): Fuchsia doesn't not support locale for font fallbacks.
+// TODO(etienneb): Android doesn't allow locale override, unless the language
+//                 is added in the system UI.
+TEST(FontFallbackSkiaTest, CJKLocaleFallback) {
+  // Han unification is an effort to map multiple character sets of the CJK
+  // languages into a single set of unified characters. Han characters are a
+  // common feature of written Chinese (hanzi), Japanese (kanji), and Korean
+  // (hanja). The same text will be rendered using a different font based on
+  // locale.
+  const std::u16string kCJKTest = u"\u8AA4\u904E\u9AA8";
+  Font base_font;
+
+  Font fallback_font_zh_cn;
+  Font fallback_font_zh_tw;
+  Font fallback_font_zh_hk;
+  EXPECT_TRUE(
+      GetFallbackFont(base_font, "zh-CN", kCJKTest, &fallback_font_zh_cn));
+  EXPECT_TRUE(
+      GetFallbackFont(base_font, "zh-TW", kCJKTest, &fallback_font_zh_tw));
+  EXPECT_TRUE(
+      GetFallbackFont(base_font, "zh-HK", kCJKTest, &fallback_font_zh_hk));
+  EXPECT_EQ(fallback_font_zh_cn.GetFontName(),
+            fallback_font_zh_tw.GetFontName());
+  EXPECT_EQ(fallback_font_zh_cn.GetFontName(),
+            fallback_font_zh_hk.GetFontName());
+
+  Font fallback_font_ja;
+  Font fallback_font_ja_jp;
+  EXPECT_TRUE(GetFallbackFont(base_font, "ja", kCJKTest, &fallback_font_ja));
+  EXPECT_TRUE(
+      GetFallbackFont(base_font, "ja-JP", kCJKTest, &fallback_font_ja_jp));
+  EXPECT_EQ(fallback_font_ja.GetFontName(), fallback_font_ja_jp.GetFontName());
+
+  Font fallback_font_ko;
+  Font fallback_font_ko_kr;
+  EXPECT_TRUE(GetFallbackFont(base_font, "ko", kCJKTest, &fallback_font_ko));
+  EXPECT_TRUE(
+      GetFallbackFont(base_font, "ko-KR", kCJKTest, &fallback_font_ko_kr));
+  EXPECT_EQ(fallback_font_ko.GetFontName(), fallback_font_ko_kr.GetFontName());
+
+  // The three fonts must not be the same.
+  EXPECT_NE(fallback_font_zh_cn.GetFontName(), fallback_font_ja.GetFontName());
+  EXPECT_NE(fallback_font_zh_cn.GetFontName(), fallback_font_ko.GetFontName());
+  EXPECT_NE(fallback_font_ja.GetFontName(), fallback_font_ko.GetFontName());
+}
+#endif  // !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_unittest.cc b/ui/gfx/font_fallback_unittest.cc
new file mode 100644
index 0000000..236ba7c
--- /dev/null
+++ b/ui/gfx/font_fallback_unittest.cc
@@ -0,0 +1,276 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/font_fallback_win.h"
+
+#include <tuple>
+
+#include "base/cxx17_backports.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/test/task_environment.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "third_party/icu/source/common/unicode/uscript.h"
+#include "third_party/icu/source/common/unicode/utf16.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "ui/gfx/platform_font.h"
+#include "ui/gfx/test/font_fallback_test_data.h"
+
+#if defined(OS_WIN)
+#include "base/win/windows_version.h"
+#endif
+
+namespace gfx {
+
+namespace {
+
+// Options to parameterized unittests.
+struct FallbackFontTestOption {
+  bool ignore_get_fallback_failure = false;
+  bool skip_code_point_validation = false;
+  bool skip_fallback_fonts_validation = false;
+};
+
+const FallbackFontTestOption default_fallback_option = {false, false, false};
+// Options for tests that does not validate the GetFallbackFont(...) parameters.
+const FallbackFontTestOption untested_fallback_option = {true, true, true};
+
+struct BaseFontTestOption {
+  const char* family_name = nullptr;
+  int delta = 0;
+  int style = 0;
+  Font::Weight weight = Font::Weight::NORMAL;
+};
+
+constexpr BaseFontTestOption default_base_font;
+constexpr BaseFontTestOption styled_font = {nullptr, 1, Font::FontStyle::ITALIC,
+                                            Font::Weight::BOLD};
+constexpr BaseFontTestOption sans_font = {"sans", 2};
+
+using FallbackFontTestParamInfo = std::
+    tuple<FallbackFontTestCase, FallbackFontTestOption, BaseFontTestOption>;
+
+class GetFallbackFontTest
+    : public ::testing::TestWithParam<FallbackFontTestParamInfo> {
+ public:
+  GetFallbackFontTest() = default;
+
+  GetFallbackFontTest(const GetFallbackFontTest&) = delete;
+  GetFallbackFontTest& operator=(const GetFallbackFontTest&) = delete;
+
+  static std::string ParamInfoToString(
+      ::testing::TestParamInfo<FallbackFontTestParamInfo> param_info) {
+    const FallbackFontTestCase& test_case = std::get<0>(param_info.param);
+    const BaseFontTestOption& base_font_option = std::get<2>(param_info.param);
+
+    std::string font_option;
+    if (base_font_option.family_name)
+      font_option += std::string("F") + base_font_option.family_name;
+    if (base_font_option.delta || base_font_option.style ||
+        base_font_option.style) {
+      font_option +=
+          base::StringPrintf("_d%ds%dw%d", base_font_option.delta,
+                             base_font_option.style, base_font_option.weight);
+    }
+
+    std::string language_tag = test_case.language_tag;
+    base::RemoveChars(language_tag, "-", &language_tag);
+    return std::string("S") + uscript_getName(test_case.script) + "L" +
+           language_tag + font_option;
+  }
+
+  void SetUp() override {
+    std::tie(test_case_, test_option_, base_font_option_) = GetParam();
+  }
+
+ protected:
+  bool GetFallbackFont(const Font& font,
+                       const std::string& language_tag,
+                       Font* result) {
+    return gfx::GetFallbackFont(font, language_tag, test_case_.text, result);
+  }
+
+  bool EnsuresScriptSupportCodePoints(const std::u16string& text,
+                                      UScriptCode script,
+                                      const std::string& script_name) {
+    size_t i = 0;
+    while (i < text.length()) {
+      UChar32 code_point;
+      U16_NEXT(text.c_str(), i, text.size(), code_point);
+      if (!uscript_hasScript(code_point, script)) {
+        // Retrieve the appropriate script
+        UErrorCode script_error;
+        UScriptCode codepoint_script =
+            uscript_getScript(code_point, &script_error);
+
+        ADD_FAILURE() << "CodePoint U+" << std::hex << code_point
+                      << " is not part of the script '" << script_name
+                      << "'. Script '" << uscript_getName(codepoint_script)
+                      << "' detected.";
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool DoesFontSupportCodePoints(Font font, const std::u16string& text) {
+    sk_sp<SkTypeface> skia_face = font.platform_font()->GetNativeSkTypeface();
+    if (!skia_face) {
+      ADD_FAILURE() << "Cannot create typeface for '" << font.GetFontName()
+                    << "'.";
+      return false;
+    }
+
+    size_t i = 0;
+    const SkGlyphID kUnsupportedGlyph = 0;
+    while (i < text.length()) {
+      UChar32 code_point;
+      U16_NEXT(text.c_str(), i, text.size(), code_point);
+      SkGlyphID glyph_id = skia_face->unicharToGlyph(code_point);
+      if (glyph_id == kUnsupportedGlyph)
+        return false;
+    }
+    return true;
+  }
+
+  FallbackFontTestCase test_case_;
+  FallbackFontTestOption test_option_;
+  BaseFontTestOption base_font_option_;
+  std::string script_name_;
+
+ private:
+  // Needed to bypass DCHECK in GetFallbackFont.
+  base::test::TaskEnvironment task_environment_{
+      base::test::TaskEnvironment::MainThreadType::UI};
+};
+
+}  // namespace
+
+// This test ensures the font fallback work correctly. It will ensures that
+//   1) The script supports the text
+//   2) The input font does not already support the text
+//   3) The call to GetFallbackFont() succeed
+//   4) The fallback font has a glyph for every character of the text
+//
+// The previous checks can be activated or deactivated through the class
+// FallbackFontTestOption (e.g. test_option_).
+TEST_P(GetFallbackFontTest, GetFallbackFont) {
+  // Default system font.
+  Font base_font;
+  // Apply font options to the base font.
+  if (base_font_option_.family_name)
+    base_font = Font(base_font_option_.family_name, base_font.GetFontSize());
+  if (base_font_option_.delta != 0 || base_font_option_.style != 0 ||
+      base_font_option_.weight != gfx::Font::Weight::NORMAL) {
+    base_font =
+        base_font.Derive(base_font_option_.delta, base_font_option_.style,
+                         base_font_option_.weight);
+  }
+
+#if defined(OS_WIN)
+  // Skip testing this call to GetFallbackFont on older windows versions. Some
+  // fonts only got introduced on windows 10 and the test will fail on previous
+  // versions.
+  const bool is_win10 = base::win::GetVersion() >= base::win::Version::WIN10;
+  if (test_case_.is_win10 && !is_win10)
+    return;
+#endif
+
+  // Retrieve the name of the current script.
+  script_name_ = uscript_getName(test_case_.script);
+
+  // Validate that tested characters are part of the script.
+  if (!test_option_.skip_code_point_validation &&
+      !EnsuresScriptSupportCodePoints(test_case_.text, test_case_.script,
+                                      script_name_)) {
+    return;
+  }
+
+  // The default font already support it, do not try to find a fallback font.
+  if (DoesFontSupportCodePoints(base_font, test_case_.text))
+    return;
+
+  // Retrieve the fallback font.
+  Font fallback_font;
+  bool result =
+      GetFallbackFont(base_font, test_case_.language_tag, &fallback_font);
+  if (!result) {
+    if (!test_option_.ignore_get_fallback_failure)
+      ADD_FAILURE() << "GetFallbackFont failed for '" << script_name_ << "'";
+    return;
+  }
+
+  // Ensure the fallback font is a part of the validation fallback fonts list.
+  if (!test_option_.skip_fallback_fonts_validation) {
+    bool valid = std::find(test_case_.fallback_fonts.begin(),
+                           test_case_.fallback_fonts.end(),
+                           fallback_font.GetFontName()) !=
+                 test_case_.fallback_fonts.end();
+    if (!valid) {
+      ADD_FAILURE() << "GetFallbackFont failed for '" << script_name_
+                    << "' invalid fallback font: "
+                    << fallback_font.GetFontName()
+                    << " not among valid options: "
+                    << base::JoinString(test_case_.fallback_fonts, ", ");
+      return;
+    }
+  }
+
+  // Ensure that glyphs exists in the fallback font.
+  if (!DoesFontSupportCodePoints(fallback_font, test_case_.text)) {
+    ADD_FAILURE() << "Font '" << fallback_font.GetFontName()
+                  << "' does not matched every CodePoints.";
+    return;
+  }
+}
+
+// Produces a font test case for every script.
+std::vector<FallbackFontTestCase> GetSampleFontTestCases() {
+  std::vector<FallbackFontTestCase> result;
+
+  const unsigned int script_max = u_getIntPropertyMaxValue(UCHAR_SCRIPT) + 1;
+  for (unsigned int i = 0; i < script_max; i++) {
+    const UScriptCode script = static_cast<UScriptCode>(i);
+
+    // Make a sample text to test the script.
+    char16_t text[8];
+    UErrorCode errorCode = U_ZERO_ERROR;
+    int text_length =
+        uscript_getSampleString(script, text, base::size(text), &errorCode);
+    if (text_length <= 0 || errorCode != U_ZERO_ERROR)
+      continue;
+
+    FallbackFontTestCase test_case(script, "", text, {});
+    result.push_back(test_case);
+  }
+  return result;
+}
+
+// Ensures that the default fallback font gives known results. The test
+// is validating that a known fallback font is given for a given text and font.
+INSTANTIATE_TEST_SUITE_P(
+    KnownExpectedFonts,
+    GetFallbackFontTest,
+    testing::Combine(
+        testing::ValuesIn(kGetFontFallbackTests),
+        testing::Values(default_fallback_option),
+        testing::Values(default_base_font, styled_font, sans_font)),
+    GetFallbackFontTest::ParamInfoToString);
+
+// Ensures that font fallback functions are working properly for any string
+// (strings from any script). The test doesn't enforce the functions to
+// give a fallback font. The accepted behaviors are:
+//    1) The fallback function failed and doesn't provide a fallback.
+//    2) The fallback function succeeded and the font supports every glyphs.
+INSTANTIATE_TEST_SUITE_P(
+    Glyphs,
+    GetFallbackFontTest,
+    testing::Combine(testing::ValuesIn(GetSampleFontTestCases()),
+                     testing::Values(untested_fallback_option),
+                     testing::Values(default_base_font)),
+    GetFallbackFontTest::ParamInfoToString);
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_win.cc b/ui/gfx/font_fallback_win.cc
new file mode 100644
index 0000000..753b511
--- /dev/null
+++ b/ui/gfx/font_fallback_win.cc
@@ -0,0 +1,246 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/font_fallback_win.h"
+
+#include <algorithm>
+#include <map>
+
+#include "base/macros.h"
+#include "base/memory/singleton.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/task/current_thread.h"
+#include "base/trace_event/trace_event.h"
+#include "base/win/registry.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_fallback.h"
+#include "ui/gfx/font_fallback_skia_impl.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+
+namespace {
+
+// Queries the registry to get a mapping from font filenames to font names.
+void QueryFontsFromRegistry(std::map<std::string, std::string>* map) {
+  const wchar_t* kFonts =
+      L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
+
+  base::win::RegistryValueIterator it(HKEY_LOCAL_MACHINE, kFonts);
+  for (; it.Valid(); ++it) {
+    const std::string filename =
+        base::ToLowerASCII(base::WideToUTF8(it.Value()));
+    (*map)[filename] = base::WideToUTF8(it.Name());
+  }
+}
+
+// Fills |font_names| with a list of font families found in the font file at
+// |filename|. Takes in a |font_map| from font filename to font families, which
+// is filled-in by querying the registry, if empty.
+void GetFontNamesFromFilename(const std::string& filename,
+                              std::map<std::string, std::string>* font_map,
+                              std::vector<std::string>* font_names) {
+  if (font_map->empty())
+    QueryFontsFromRegistry(font_map);
+
+  std::map<std::string, std::string>::const_iterator it =
+      font_map->find(base::ToLowerASCII(filename));
+  if (it == font_map->end())
+    return;
+
+  internal::ParseFontFamilyString(it->second, font_names);
+}
+
+// Returns true if |text| contains only ASCII digits.
+bool ContainsOnlyDigits(const std::string& text) {
+  return text.find_first_not_of("0123456789") == std::u16string::npos;
+}
+
+// Appends a Font with the given |name| and |size| to |fonts| unless the last
+// entry is already a font with that name.
+void AppendFont(const std::string& name, int size, std::vector<Font>* fonts) {
+  if (fonts->empty() || fonts->back().GetFontName() != name)
+    fonts->push_back(Font(name, size));
+}
+
+// Queries the registry to get a list of linked fonts for |font|.
+void QueryLinkedFontsFromRegistry(const Font& font,
+                                  std::map<std::string, std::string>* font_map,
+                                  std::vector<Font>* linked_fonts) {
+  const wchar_t* kSystemLink =
+      L"Software\\Microsoft\\Windows NT\\CurrentVersion\\FontLink\\SystemLink";
+
+  base::win::RegKey key;
+  if (FAILED(key.Open(HKEY_LOCAL_MACHINE, kSystemLink, KEY_READ)))
+    return;
+
+  const std::wstring original_font_name = base::UTF8ToWide(font.GetFontName());
+  std::vector<std::wstring> values;
+  if (FAILED(key.ReadValues(original_font_name.c_str(), &values))) {
+    key.Close();
+    return;
+  }
+
+  std::string filename;
+  std::string font_name;
+  for (size_t i = 0; i < values.size(); ++i) {
+    internal::ParseFontLinkEntry(
+        base::WideToUTF8(values[i]), &filename, &font_name);
+
+    // If the font name is present, add that directly, otherwise add the
+    // font names corresponding to the filename.
+    if (!font_name.empty()) {
+      AppendFont(font_name, font.GetFontSize(), linked_fonts);
+    } else if (!filename.empty()) {
+      std::vector<std::string> filename_fonts;
+      GetFontNamesFromFilename(filename, font_map, &filename_fonts);
+      for (const std::string& filename_font : filename_fonts)
+        AppendFont(filename_font, font.GetFontSize(), linked_fonts);
+    }
+  }
+
+  key.Close();
+}
+
+// CachedFontLinkSettings is a singleton cache of the Windows font settings
+// from the registry. It maintains a cached view of the registry's list of
+// system fonts and their font link chains.
+class CachedFontLinkSettings {
+ public:
+  static CachedFontLinkSettings* GetInstance();
+
+  CachedFontLinkSettings(const CachedFontLinkSettings&) = delete;
+  CachedFontLinkSettings& operator=(const CachedFontLinkSettings&) = delete;
+
+  // Returns the linked fonts list correspond to |font|. Returned value will
+  // never be null.
+  const std::vector<Font>* GetLinkedFonts(const Font& font);
+
+ private:
+  friend struct base::DefaultSingletonTraits<CachedFontLinkSettings>;
+
+  CachedFontLinkSettings();
+  virtual ~CachedFontLinkSettings();
+
+  // Map of system fonts, from file names to font families.
+  std::map<std::string, std::string> cached_system_fonts_;
+
+  // Map from font names to vectors of linked fonts.
+  std::map<std::string, std::vector<Font> > cached_linked_fonts_;
+};
+
+// static
+CachedFontLinkSettings* CachedFontLinkSettings::GetInstance() {
+  return base::Singleton<
+      CachedFontLinkSettings,
+      base::LeakySingletonTraits<CachedFontLinkSettings>>::get();
+}
+
+const std::vector<Font>* CachedFontLinkSettings::GetLinkedFonts(
+    const Font& font) {
+  const std::string& font_name = font.GetFontName();
+  std::map<std::string, std::vector<Font> >::const_iterator it =
+      cached_linked_fonts_.find(font_name);
+  if (it != cached_linked_fonts_.end())
+    return &it->second;
+
+  std::vector<Font>* linked_fonts = &cached_linked_fonts_[font_name];
+  QueryLinkedFontsFromRegistry(font, &cached_system_fonts_, linked_fonts);
+  return linked_fonts;
+}
+
+CachedFontLinkSettings::CachedFontLinkSettings() {
+}
+
+CachedFontLinkSettings::~CachedFontLinkSettings() {
+}
+
+}  // namespace
+
+namespace internal {
+
+void ParseFontLinkEntry(const std::string& entry,
+                        std::string* filename,
+                        std::string* font_name) {
+  std::vector<std::string> parts = base::SplitString(
+      entry, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  filename->clear();
+  font_name->clear();
+  if (parts.size() > 0)
+    *filename = parts[0];
+  // The second entry may be the font name or the first scaling factor, if the
+  // entry does not contain a font name. If it contains only digits, assume it
+  // is a scaling factor.
+  if (parts.size() > 1 && !ContainsOnlyDigits(parts[1]))
+    *font_name = parts[1];
+}
+
+void ParseFontFamilyString(const std::string& family,
+                           std::vector<std::string>* font_names) {
+  // The entry is comma separated, having the font filename as the first value
+  // followed optionally by the font family name and a pair of integer scaling
+  // factors.
+  // TODO(asvitkine): Should we support these scaling factors?
+  *font_names = base::SplitString(family, "&", base::TRIM_WHITESPACE,
+                                  base::SPLIT_WANT_ALL);
+  if (!font_names->empty()) {
+    const size_t index = font_names->back().find('(');
+    if (index != std::string::npos) {
+      font_names->back().resize(index);
+      base::TrimWhitespaceASCII(font_names->back(), base::TRIM_TRAILING,
+                                &font_names->back());
+    }
+  }
+}
+
+}  // namespace internal
+
+std::vector<Font> GetFallbackFonts(const Font& font) {
+  TRACE_EVENT0("fonts", "gfx::GetFallbackFonts");
+  std::string font_family = font.GetFontName();
+  CachedFontLinkSettings* font_link = CachedFontLinkSettings::GetInstance();
+  // GetLinkedFonts doesn't care about the font size, so we always pass 10.
+  return *font_link->GetLinkedFonts(Font(font_family, 10));
+}
+
+bool GetFallbackFont(const Font& font,
+                     const std::string& locale,
+                     base::StringPiece16 text,
+                     Font* result) {
+  TRACE_EVENT0("fonts", "gfx::GetFallbackFont");
+  // Creating a DirectWrite font fallback can be expensive. It's ok in the
+  // browser process because we can use the shared system fallback, but in the
+  // renderer this can cause hangs. Code that needs font fallback in the
+  // renderer should instead use the font proxy.
+  DCHECK(base::CurrentUIThread::IsSet());
+
+  // The text passed must be at least length 1.
+  if (text.empty())
+    return false;
+
+  // Check that we have at least as much text as was claimed. If we have less
+  // text than expected then DirectWrite will become confused and crash. This
+  // shouldn't happen, but crbug.com/624905 shows that it happens sometimes.
+  constexpr char16_t kNulCharacter = '\0';
+  if (text.find(kNulCharacter) != base::StringPiece16::npos)
+    return false;
+
+  sk_sp<SkTypeface> fallback_typeface =
+      GetSkiaFallbackTypeface(font, locale, text);
+
+  if (!fallback_typeface)
+    return false;
+
+  // Fallback needs to keep the exact SkTypeface, as re-matching the font using
+  // family name and styling information loses access to the underlying platform
+  // font handles and is not guaranteed to result in the correct typeface, see
+  // https://crbug.com/1003829
+  *result = Font(PlatformFont::CreateFromSkTypeface(
+      std::move(fallback_typeface), font.GetFontSize(), absl::nullopt));
+  return true;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_fallback_win.h b/ui/gfx/font_fallback_win.h
new file mode 100644
index 0000000..bf6c745
--- /dev/null
+++ b/ui/gfx/font_fallback_win.h
@@ -0,0 +1,40 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_FALLBACK_WIN_H_
+#define UI_GFX_FONT_FALLBACK_WIN_H_
+
+#include <stddef.h>
+
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_fallback.h"
+
+namespace gfx {
+
+// Internals of font_fallback_win.cc exposed for testing.
+namespace internal {
+
+// Parses comma separated SystemLink |entry|, per the format described here:
+// http://msdn.microsoft.com/en-us/goglobal/bb688134.aspx
+//
+// Sets |filename| and |font_name| respectively. If a field is not present
+// or could not be parsed, the corresponding parameter will be cleared.
+void GFX_EXPORT ParseFontLinkEntry(const std::string& entry,
+                                   std::string* filename,
+                                   std::string* font_name);
+
+// Parses a font |family| in the format "FamilyFoo & FamilyBar (TrueType)".
+// Splits by '&' and strips off the trailing parenthesized expression.
+void GFX_EXPORT ParseFontFamilyString(const std::string& family,
+                                      std::vector<std::string>* font_names);
+
+}  // namespace internal
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FONT_FALLBACK_WIN_H_
diff --git a/ui/gfx/font_fallback_win_unittest.cc b/ui/gfx/font_fallback_win_unittest.cc
new file mode 100644
index 0000000..b3b68b3
--- /dev/null
+++ b/ui/gfx/font_fallback_win_unittest.cc
@@ -0,0 +1,145 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/font_fallback_win.h"
+
+#include "base/cxx17_backports.h"
+#include "base/macros.h"
+#include "base/test/task_environment.h"
+#include "base/win/windows_version.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+
+namespace {
+
+const char kDefaultApplicationLocale[] = "us-en";
+
+class FontFallbackWinTest : public testing::Test {
+ public:
+  FontFallbackWinTest() = default;
+
+  FontFallbackWinTest(const FontFallbackWinTest&) = delete;
+  FontFallbackWinTest& operator=(const FontFallbackWinTest&) = delete;
+
+ private:
+  // Needed to bypass DCHECK in GetFallbackFont.
+  base::test::TaskEnvironment task_environment_{
+      base::test::TaskEnvironment::MainThreadType::UI};
+};
+
+}  // namespace
+
+TEST_F(FontFallbackWinTest, ParseFontLinkEntry) {
+  std::string file;
+  std::string font;
+
+  internal::ParseFontLinkEntry("TAHOMA.TTF", &file, &font);
+  EXPECT_EQ("TAHOMA.TTF", file);
+  EXPECT_EQ("", font);
+
+  internal::ParseFontLinkEntry("MSGOTHIC.TTC,MS UI Gothic", &file, &font);
+  EXPECT_EQ("MSGOTHIC.TTC", file);
+  EXPECT_EQ("MS UI Gothic", font);
+
+  internal::ParseFontLinkEntry("MALGUN.TTF,128,96", &file, &font);
+  EXPECT_EQ("MALGUN.TTF", file);
+  EXPECT_EQ("", font);
+
+  internal::ParseFontLinkEntry("MEIRYO.TTC,Meiryo,128,85", &file, &font);
+  EXPECT_EQ("MEIRYO.TTC", file);
+  EXPECT_EQ("Meiryo", font);
+}
+
+TEST_F(FontFallbackWinTest, ParseFontFamilyString) {
+  std::vector<std::string> font_names;
+
+  internal::ParseFontFamilyString("Times New Roman (TrueType)", &font_names);
+  ASSERT_EQ(1U, font_names.size());
+  EXPECT_EQ("Times New Roman", font_names[0]);
+  font_names.clear();
+
+  internal::ParseFontFamilyString("Cambria & Cambria Math (TrueType)",
+                                  &font_names);
+  ASSERT_EQ(2U, font_names.size());
+  EXPECT_EQ("Cambria", font_names[0]);
+  EXPECT_EQ("Cambria Math", font_names[1]);
+  font_names.clear();
+
+  internal::ParseFontFamilyString(
+      "Meiryo & Meiryo Italic & Meiryo UI & Meiryo UI Italic (TrueType)",
+      &font_names);
+  ASSERT_EQ(4U, font_names.size());
+  EXPECT_EQ("Meiryo", font_names[0]);
+  EXPECT_EQ("Meiryo Italic", font_names[1]);
+  EXPECT_EQ("Meiryo UI", font_names[2]);
+  EXPECT_EQ("Meiryo UI Italic", font_names[3]);
+}
+
+TEST_F(FontFallbackWinTest, EmptyStringFallback) {
+  Font base_font;
+  Font fallback_font;
+  bool result = GetFallbackFont(base_font, kDefaultApplicationLocale,
+                                base::StringPiece16(), &fallback_font);
+  EXPECT_FALSE(result);
+}
+
+TEST_F(FontFallbackWinTest, NulTerminatedStringPiece) {
+  Font base_font;
+  Font fallback_font;
+  // Multiple ending NUL characters.
+  const char16_t kTest1[] = {0x0540, 0x0541, 0, 0, 0};
+  EXPECT_FALSE(GetFallbackFont(base_font, kDefaultApplicationLocale,
+                               base::StringPiece16(kTest1, base::size(kTest1)),
+                               &fallback_font));
+  // No ending NUL character.
+  const char16_t kTest2[] = {0x0540, 0x0541};
+  EXPECT_TRUE(GetFallbackFont(base_font, kDefaultApplicationLocale,
+                              base::StringPiece16(kTest2, base::size(kTest2)),
+                              &fallback_font));
+
+  // NUL only characters.
+  const char16_t kTest3[] = {0, 0, 0};
+  EXPECT_FALSE(GetFallbackFont(base_font, kDefaultApplicationLocale,
+                               base::StringPiece16(kTest3, base::size(kTest3)),
+                               &fallback_font));
+}
+
+TEST_F(FontFallbackWinTest, CJKLocaleFallback) {
+  // The uniscribe fallback used by win7 does not support locale.
+  if (base::win::GetVersion() < base::win::Version::WIN10)
+    return;
+
+  // Han unification is an effort to map multiple character sets of the CJK
+  // languages into a single set of unified characters. Han characters are a
+  // common feature of written Chinese (hanzi), Japanese (kanji), and Korean
+  // (hanja). The same text will be rendered using a different font based on
+  // locale.
+  const char16_t kCJKTest[] = u"\u8AA4\u904E\u9AA8";
+  Font base_font;
+  Font fallback_font;
+
+  EXPECT_TRUE(GetFallbackFont(base_font, "zh-CN", kCJKTest, &fallback_font));
+  EXPECT_EQ(fallback_font.GetFontName(), "Microsoft YaHei UI");
+
+  EXPECT_TRUE(GetFallbackFont(base_font, "zh-TW", kCJKTest, &fallback_font));
+  EXPECT_EQ(fallback_font.GetFontName(), "Microsoft JhengHei UI");
+
+  EXPECT_TRUE(GetFallbackFont(base_font, "zh-HK", kCJKTest, &fallback_font));
+  EXPECT_EQ(fallback_font.GetFontName(), "Microsoft JhengHei UI");
+
+  EXPECT_TRUE(GetFallbackFont(base_font, "ja", kCJKTest, &fallback_font));
+  EXPECT_EQ(fallback_font.GetFontName(), "Yu Gothic UI");
+
+  EXPECT_TRUE(GetFallbackFont(base_font, "ja-JP", kCJKTest, &fallback_font));
+  EXPECT_EQ(fallback_font.GetFontName(), "Yu Gothic UI");
+
+  EXPECT_TRUE(GetFallbackFont(base_font, "ko", kCJKTest, &fallback_font));
+  EXPECT_EQ(fallback_font.GetFontName(), "Malgun Gothic");
+
+  EXPECT_TRUE(GetFallbackFont(base_font, "ko-KR", kCJKTest, &fallback_font));
+  EXPECT_EQ(fallback_font.GetFontName(), "Malgun Gothic");
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_list.cc b/ui/gfx/font_list.cc
new file mode 100644
index 0000000..4155b8a
--- /dev/null
+++ b/ui/gfx/font_list.cc
@@ -0,0 +1,255 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/font_list.h"
+
+#include <ostream>
+
+#include "base/lazy_instance.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "third_party/skia/include/core/SkFontMgr.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "ui/gfx/font_list_impl.h"
+
+namespace {
+
+// Font description of the default font set.
+base::LazyInstance<std::string>::Leaky g_default_font_description =
+    LAZY_INSTANCE_INITIALIZER;
+
+// The default instance of gfx::FontListImpl.
+base::LazyInstance<scoped_refptr<gfx::FontListImpl>>::Leaky g_default_impl =
+    LAZY_INSTANCE_INITIALIZER;
+bool g_default_impl_initialized = false;
+
+bool IsFontFamilyAvailable(const std::string& family, SkFontMgr* fontManager) {
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  return !!fontManager->legacyMakeTypeface(family.c_str(), SkFontStyle());
+#else
+  sk_sp<SkFontStyleSet> set(fontManager->matchFamily(family.c_str()));
+  return set && set->count();
+#endif
+}
+
+}  // namespace
+
+namespace gfx {
+
+// static
+bool FontList::ParseDescription(const std::string& description,
+                                std::vector<std::string>* families_out,
+                                int* style_out,
+                                int* size_pixels_out,
+                                Font::Weight* weight_out) {
+  DCHECK(families_out);
+  DCHECK(style_out);
+  DCHECK(size_pixels_out);
+  DCHECK(weight_out);
+
+  *families_out = base::SplitString(
+      description, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  if (families_out->empty())
+    return false;
+  for (auto& family : *families_out)
+    base::TrimWhitespaceASCII(family, base::TRIM_ALL, &family);
+
+  // The last item is "[STYLE1] [STYLE2] [...] SIZE".
+  std::vector<std::string> styles = base::SplitString(
+      families_out->back(), base::kWhitespaceASCII,
+      base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  families_out->pop_back();
+  if (styles.empty())
+    return false;
+
+  // The size takes the form "<INT>px".
+  std::string size_string = styles.back();
+  styles.pop_back();
+  if (!base::EndsWith(size_string, "px", base::CompareCase::SENSITIVE))
+    return false;
+  size_string.resize(size_string.size() - 2);
+  if (!base::StringToInt(size_string, size_pixels_out) ||
+      *size_pixels_out <= 0)
+    return false;
+
+  // Font supports ITALIC and weights; underline is supported via RenderText.
+  *style_out = Font::NORMAL;
+  *weight_out = Font::Weight::NORMAL;
+  for (const auto& style_string : styles) {
+    if (style_string == "Italic")
+      *style_out |= Font::ITALIC;
+    else if (style_string == "Thin")
+      *weight_out = Font::Weight::THIN;
+    else if (style_string == "Ultra-Light")
+      *weight_out = Font::Weight::EXTRA_LIGHT;
+    else if (style_string == "Light")
+      *weight_out = Font::Weight::LIGHT;
+    else if (style_string == "Normal")
+      *weight_out = Font::Weight::NORMAL;
+    else if (style_string == "Medium")
+      *weight_out = Font::Weight::MEDIUM;
+    else if (style_string == "Semi-Bold")
+      *weight_out = Font::Weight::SEMIBOLD;
+    else if (style_string == "Bold")
+      *weight_out = Font::Weight::BOLD;
+    else if (style_string == "Ultra-Bold")
+      *weight_out = Font::Weight::EXTRA_BOLD;
+    else if (style_string == "Heavy")
+      *weight_out = Font::Weight::BLACK;
+    else
+      return false;
+  }
+
+  return true;
+}
+
+FontList::FontList() : impl_(GetDefaultImpl()) {}
+
+FontList::FontList(const FontList& other) : impl_(other.impl_) {}
+
+FontList::FontList(const std::string& font_description_string)
+    : impl_(new FontListImpl(font_description_string)) {}
+
+FontList::FontList(const std::vector<std::string>& font_names,
+                   int font_style,
+                   int font_size,
+                   Font::Weight font_weight)
+    : impl_(new FontListImpl(font_names, font_style, font_size, font_weight)) {}
+
+FontList::FontList(const std::vector<Font>& fonts)
+    : impl_(new FontListImpl(fonts)) {}
+
+FontList::FontList(const Font& font) : impl_(new FontListImpl(font)) {}
+
+FontList::~FontList() {}
+
+FontList& FontList::operator=(const FontList& other) {
+  impl_ = other.impl_;
+  return *this;
+}
+
+// static
+void FontList::SetDefaultFontDescription(const std::string& font_description) {
+  // The description string must end with "px" for size in pixel, or must be
+  // the empty string, which specifies to use a single default font.
+  DCHECK(font_description.empty() ||
+         base::EndsWith(font_description, "px", base::CompareCase::SENSITIVE));
+
+  g_default_font_description.Get() = font_description;
+  g_default_impl_initialized = false;
+}
+
+FontList FontList::Derive(int size_delta,
+                          int font_style,
+                          Font::Weight weight) const {
+  return FontList(impl_->Derive(size_delta, font_style, weight));
+}
+
+FontList FontList::DeriveWithSizeDelta(int size_delta) const {
+  return Derive(size_delta, GetFontStyle(), GetFontWeight());
+}
+
+FontList FontList::DeriveWithStyle(int font_style) const {
+  return Derive(0, font_style, GetFontWeight());
+}
+
+FontList FontList::DeriveWithWeight(Font::Weight weight) const {
+  return Derive(0, GetFontStyle(), weight);
+}
+
+FontList FontList::DeriveWithHeightUpperBound(int height) const {
+  FontList font_list(*this);
+  for (int font_size = font_list.GetFontSize(); font_size > 1; --font_size) {
+    const int internal_leading =
+        font_list.GetBaseline() - font_list.GetCapHeight();
+    // Some platforms don't support getting the cap height, and simply return
+    // the entire font ascent from GetCapHeight().  Centering the ascent makes
+    // the font look too low, so if GetCapHeight() returns the ascent, center
+    // the entire font height instead.
+    const int space =
+        height - ((internal_leading != 0) ?
+                  font_list.GetCapHeight() : font_list.GetHeight());
+    const int y_offset = space / 2 - internal_leading;
+    const int space_at_bottom = height - (y_offset + font_list.GetHeight());
+    if ((y_offset >= 0) && (space_at_bottom >= 0))
+      break;
+    font_list = font_list.DeriveWithSizeDelta(-1);
+  }
+  return font_list;
+}
+
+int FontList::GetHeight() const {
+  return impl_->GetHeight();
+}
+
+int FontList::GetBaseline() const {
+  return impl_->GetBaseline();
+}
+
+int FontList::GetCapHeight() const {
+  return impl_->GetCapHeight();
+}
+
+int FontList::GetExpectedTextWidth(int length) const {
+  return impl_->GetExpectedTextWidth(length);
+}
+
+int FontList::GetFontStyle() const {
+  return impl_->GetFontStyle();
+}
+
+int FontList::GetFontSize() const {
+  return impl_->GetFontSize();
+}
+
+Font::Weight FontList::GetFontWeight() const {
+  return impl_->GetFontWeight();
+}
+
+const std::vector<Font>& FontList::GetFonts() const {
+  return impl_->GetFonts();
+}
+
+const Font& FontList::GetPrimaryFont() const {
+  return impl_->GetPrimaryFont();
+}
+
+FontList::FontList(FontListImpl* impl) : impl_(impl) {}
+
+// static
+const scoped_refptr<FontListImpl>& FontList::GetDefaultImpl() {
+  // SetDefaultFontDescription() must be called and the default font description
+  // must be set earlier than any call of this function.
+  DCHECK(g_default_font_description.IsCreated())
+      << "SetDefaultFontDescription has not been called.";
+
+  if (!g_default_impl_initialized) {
+    g_default_impl.Get() =
+        g_default_font_description.Get().empty() ?
+            new FontListImpl(Font()) :
+            new FontListImpl(g_default_font_description.Get());
+    g_default_impl_initialized = true;
+  }
+
+  return g_default_impl.Get();
+}
+
+// static
+std::string FontList::FirstAvailableOrFirst(const std::string& font_name_list) {
+  std::vector<std::string> families = base::SplitString(
+      font_name_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  if (families.empty())
+    return std::string();
+  if (families.size() == 1)
+    return families[0];
+  sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
+  for (const auto& family : families) {
+    if (IsFontFamilyAvailable(family, fm.get()))
+      return family;
+  }
+  return families[0];
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_list.h b/ui/gfx/font_list.h
new file mode 100644
index 0000000..a0d96fa
--- /dev/null
+++ b/ui/gfx/font_list.h
@@ -0,0 +1,187 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_LIST_H_
+#define UI_GFX_FONT_LIST_H_
+
+#include <string>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class FontListImpl;
+
+// FontList represents a list of fonts and provides metrics which are common
+// across the fonts.  FontList is copyable and quite cheap to copy.
+//
+// The format of font description strings is a subset of that used by Pango, as
+// described at
+// http://developer.gnome.org/pango/stable/pango-Fonts.html#pango-font-description-from-string
+//
+// Pango font description strings should not be passed directly into FontLists.
+//
+// The format is "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where:
+// - FONT_FAMILY_LIST is a comma-separated list of font family names,
+// - STYLES is an optional space-separated list of style names (case-sensitive
+//   "Italic" "Ultra-Light" "Light" "Normal" "Semi-Bold" "Bold" "Ultra-Bold"
+//   "Heavy" are supported), and
+// - SIZE is an integer font size in pixels with the suffix "px"
+//
+// Here are examples of valid font description strings:
+// - "Arial, Helvetica, Italic Semi-Bold 14px"
+// - "Arial, 14px"
+class GFX_EXPORT FontList {
+ public:
+  // Parses a FontList description string into |families_out|, |style_out| (a
+  // bitfield of gfx::Font::Style values), |size_pixels_out| and |weight_out|.
+  // Returns true if the string is properly-formed.
+  static bool ParseDescription(const std::string& description,
+                               std::vector<std::string>* families_out,
+                               int* style_out,
+                               int* size_pixels_out,
+                               Font::Weight* weight_out);
+
+  // Creates a font list with default font names, size and style, which are
+  // specified by SetDefaultFontDescription().
+  FontList();
+
+  // Creates a font list that is a clone of another font list.
+  FontList(const FontList& other);
+
+  // Creates a font list from a string representing font names, styles, and
+  // size.
+  explicit FontList(const std::string& font_description_string);
+
+  // Creates a font list from font names, styles, size and weight.
+  FontList(const std::vector<std::string>& font_names,
+           int font_style,
+           int font_size,
+           Font::Weight font_weight);
+
+  // Creates a font list from a Font vector.
+  // All fonts in this vector should have the same style and size.
+  explicit FontList(const std::vector<Font>& fonts);
+
+  // Creates a font list from a Font.
+  explicit FontList(const Font& font);
+
+  ~FontList();
+
+  // Copies the given font list into this object.
+  FontList& operator=(const FontList& other);
+
+  // Sets the description string for default FontList construction. If it's
+  // empty, FontList will initialize using the default Font constructor.
+  //
+  // The client code must call this function before any call of the default
+  // constructor. This should be done on the UI thread.
+  //
+  // ui::ResourceBundle may call this function more than once when UI language
+  // is changed.
+  //
+  // Unit Tests should use ScopedDefaultFontDescription instead of calling this
+  // directly, to avoid leaving the default font description in an unexpected
+  // state for tests that run in the same process.
+  static void SetDefaultFontDescription(const std::string& font_description);
+
+  // Returns a new FontList with the same font names but resized and the given
+  // style and weight. |size_delta| is the size in pixels to add to the current
+  // font size. |font_style| specifies the new style, which is a bitmask of the
+  // values: Font::ITALIC and Font::UNDERLINE. |weight| is the requested font
+  // weight.
+  FontList Derive(int size_delta,
+                  int font_style,
+                  Font::Weight weight) const;
+
+  // Returns a new FontList with the same font names and style but resized.
+  // |size_delta| is the size in pixels to add to the current font size.
+  FontList DeriveWithSizeDelta(int size_delta) const;
+
+  // Returns a new FontList with the same font names, weight and size but the
+  // given style. |font_style| specifies the new style, which is a bitmask of
+  // the values: Font::ITALIC and Font::UNDERLINE.
+  FontList DeriveWithStyle(int font_style) const;
+
+  // Returns a new FontList with the same font name, size and style but with
+  // the given weight.
+  FontList DeriveWithWeight(Font::Weight weight) const;
+
+  // Shrinks the font size until the font list fits within |height| while
+  // having its cap height vertically centered. Returns a new FontList with
+  // the correct height.
+  //
+  // The expected layout:
+  //   +--------+-----------------------------------------------+------------+
+  //   |        | y offset                                      | space      |
+  //   |        +--------+-------------------+------------------+ above      |
+  //   |        |        |                   | internal leading | cap height |
+  //   | box    | font   | ascent (baseline) +------------------+------------+
+  //   | height | height |                   | cap height                    |
+  //   |        |        |-------------------+------------------+------------+
+  //   |        |        | descent (height - baseline)          | space      |
+  //   |        +--------+--------------------------------------+ below      |
+  //   |        | space at bottom                               | cap height |
+  //   +--------+-----------------------------------------------+------------+
+  // Goal:
+  //     center of box height == center of cap height
+  //     (i.e. space above cap height == space below cap height)
+  // Restrictions:
+  //     y offset >= 0
+  //     space at bottom >= 0
+  //     (i.e. Entire font must be visible inside the box.)
+  FontList DeriveWithHeightUpperBound(int height) const;
+
+  // Returns the height of this font list, which is max(ascent) + max(descent)
+  // for all the fonts in the font list.
+  int GetHeight() const;
+
+  // Returns the baseline of this font list, which is max(baseline) for all the
+  // fonts in the font list.
+  int GetBaseline() const;
+
+  // Returns the cap height of this font list.
+  // Currently returns the cap height of the primary font.
+  int GetCapHeight() const;
+
+  // Returns the expected number of horizontal pixels needed to display the
+  // specified length of characters. Call GetStringWidth() to retrieve the
+  // actual number.
+  int GetExpectedTextWidth(int length) const;
+
+  // Returns the |Font::FontStyle| style flags for this font list.
+  int GetFontStyle() const;
+
+  // Returns the font size in pixels.
+  int GetFontSize() const;
+
+  // Returns the font weight.
+  Font::Weight GetFontWeight() const;
+
+  // Returns the Font vector.
+  const std::vector<Font>& GetFonts() const;
+
+  // Returns the first font in the list.
+  const Font& GetPrimaryFont() const;
+
+  // Returns the first available font name. If there is no available font,
+  // returns the first font name. Empty entries are ignored.
+  // Used by Blink and webui to pick the primary standard/serif/sans/fixed/etc.
+  // fonts from region-specific IDS lists.
+  static std::string FirstAvailableOrFirst(const std::string& font_name_list);
+
+ private:
+  explicit FontList(FontListImpl* impl);
+
+  static const scoped_refptr<FontListImpl>& GetDefaultImpl();
+
+  scoped_refptr<FontListImpl> impl_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FONT_LIST_H_
diff --git a/ui/gfx/font_list_impl.cc b/ui/gfx/font_list_impl.cc
new file mode 100644
index 0000000..d805ee1
--- /dev/null
+++ b/ui/gfx/font_list_impl.cc
@@ -0,0 +1,242 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/font_list_impl.h"
+
+#include <stddef.h>
+
+#include <algorithm>
+
+#include "base/check_op.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "ui/gfx/font_list.h"
+
+namespace gfx {
+namespace {
+
+// Returns a font description from |families|, |style|, and |size_pixels|.
+std::string BuildDescription(const std::vector<std::string>& families,
+                             int style,
+                             int size_pixels,
+                             Font::Weight weight) {
+  std::string description = base::JoinString(families, ",");
+  description += ",";
+
+  if (style & Font::ITALIC)
+    description += "Italic ";
+  switch (weight) {
+    case Font::Weight::THIN:
+      description += "Thin ";
+      break;
+    case Font::Weight::EXTRA_LIGHT:
+      description += "Ultra-Light ";
+      break;
+    case Font::Weight::LIGHT:
+      description += "Light ";
+      break;
+    case Font::Weight::MEDIUM:
+      description += "Medium ";
+      break;
+    case Font::Weight::SEMIBOLD:
+      description += "Semi-Bold ";
+      break;
+    case Font::Weight::BOLD:
+      description += "Bold ";
+      break;
+    case Font::Weight::EXTRA_BOLD:
+      description += "Ultra-Bold ";
+      break;
+    case Font::Weight::BLACK:
+      description += "Heavy ";
+      break;
+    case Font::Weight::NORMAL:
+    case Font::Weight::INVALID:
+      break;
+  }
+
+  description += base::NumberToString(size_pixels);
+  description += "px";
+
+  return description;
+}
+
+}  // namespace
+
+FontListImpl::FontListImpl(const std::string& font_description_string)
+    : font_description_string_(font_description_string),
+      common_height_(-1),
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1),
+      font_weight_(Font::Weight::INVALID) {
+  DCHECK(!font_description_string.empty());
+  // DCHECK description string ends with "px" for size in pixel.
+  DCHECK(base::EndsWith(font_description_string, "px",
+                        base::CompareCase::SENSITIVE));
+}
+
+FontListImpl::FontListImpl(const std::vector<std::string>& font_names,
+                           int font_style,
+                           int font_size,
+                           Font::Weight font_weight)
+    : font_description_string_(
+          BuildDescription(font_names, font_style, font_size, font_weight)),
+      common_height_(-1),
+      common_baseline_(-1),
+      font_style_(font_style),
+      font_size_(font_size),
+      font_weight_(font_weight) {
+  DCHECK(!font_names.empty());
+  DCHECK(!font_names[0].empty());
+}
+
+FontListImpl::FontListImpl(const std::vector<Font>& fonts)
+    : fonts_(fonts),
+      common_height_(-1),
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1),
+      font_weight_(Font::Weight::INVALID) {
+  DCHECK(!fonts.empty());
+  font_style_ = fonts[0].GetStyle();
+  font_size_ = fonts[0].GetFontSize();
+  font_weight_ = fonts[0].GetWeight();
+#if DCHECK_IS_ON()
+  for (size_t i = 1; i < fonts.size(); ++i) {
+    DCHECK_EQ(fonts[i].GetStyle(), font_style_);
+    DCHECK_EQ(fonts[i].GetFontSize(), font_size_);
+  }
+#endif
+}
+
+FontListImpl::FontListImpl(const Font& font)
+    : common_height_(-1),
+      common_baseline_(-1),
+      font_style_(-1),
+      font_size_(-1),
+      font_weight_(Font::Weight::INVALID) {
+  fonts_.push_back(font);
+}
+
+FontListImpl* FontListImpl::Derive(int size_delta,
+                                   int font_style,
+                                   Font::Weight weight) const {
+  // If there is a font vector, derive from that.
+  if (!fonts_.empty()) {
+    std::vector<Font> fonts = fonts_;
+    for (size_t i = 0; i < fonts.size(); ++i)
+      fonts[i] = fonts[i].Derive(size_delta, font_style, weight);
+    return new FontListImpl(fonts);
+  }
+
+  // Otherwise, parse the font description string to derive from it.
+  std::vector<std::string> font_names;
+  int old_size;
+  int old_style;
+  Font::Weight old_weight;
+  CHECK(FontList::ParseDescription(font_description_string_, &font_names,
+                                   &old_style, &old_size, &old_weight));
+  const int size = std::max(1, old_size + size_delta);
+  return new FontListImpl(font_names, font_style, size, weight);
+}
+
+int FontListImpl::GetHeight() const {
+  if (common_height_ == -1)
+    CacheCommonFontHeightAndBaseline();
+  return common_height_;
+}
+
+int FontListImpl::GetBaseline() const {
+  if (common_baseline_ == -1)
+    CacheCommonFontHeightAndBaseline();
+  return common_baseline_;
+}
+
+int FontListImpl::GetCapHeight() const {
+  // Assume the primary font is used to render Latin characters.
+  return GetPrimaryFont().GetCapHeight();
+}
+
+int FontListImpl::GetExpectedTextWidth(int length) const {
+  // Rely on the primary font metrics for the time being.
+  return GetPrimaryFont().GetExpectedTextWidth(length);
+}
+
+int FontListImpl::GetFontStyle() const {
+  if (font_style_ == -1)
+    CacheFontStyleAndSize();
+  return font_style_;
+}
+
+int FontListImpl::GetFontSize() const {
+  if (font_size_ == -1)
+    CacheFontStyleAndSize();
+  return font_size_;
+}
+
+Font::Weight FontListImpl::GetFontWeight() const {
+  if (font_weight_ == Font::Weight::INVALID)
+    CacheFontStyleAndSize();
+  return font_weight_;
+}
+
+const std::vector<Font>& FontListImpl::GetFonts() const {
+  if (fonts_.empty()) {
+    DCHECK(!font_description_string_.empty());
+
+    std::vector<std::string> font_names;
+    // It's possible that Font::UNDERLINE is specified and it's already
+    // stored in |font_style_| but |font_description_string_| doesn't have the
+    // underline info.  So we should respect |font_style_| as long as it's
+    // valid.
+    int style = 0;
+    CHECK(FontList::ParseDescription(font_description_string_, &font_names,
+                                     &style, &font_size_, &font_weight_));
+    if (font_style_ == -1)
+      font_style_ = style;
+    for (size_t i = 0; i < font_names.size(); ++i) {
+      DCHECK(!font_names[i].empty());
+
+      Font font(font_names[i], font_size_);
+      if (font_style_ == Font::NORMAL && font_weight_ == Font::Weight::NORMAL)
+        fonts_.push_back(font);
+      else
+        fonts_.push_back(font.Derive(0, font_style_, font_weight_));
+    }
+  }
+  return fonts_;
+}
+
+const Font& FontListImpl::GetPrimaryFont() const {
+  return GetFonts()[0];
+}
+
+FontListImpl::~FontListImpl() {}
+
+void FontListImpl::CacheCommonFontHeightAndBaseline() const {
+  int ascent = 0;
+  int descent = 0;
+  const std::vector<Font>& fonts = GetFonts();
+  for (auto i = fonts.begin(); i != fonts.end(); ++i) {
+    ascent = std::max(ascent, i->GetBaseline());
+    descent = std::max(descent, i->GetHeight() - i->GetBaseline());
+  }
+  common_height_ = ascent + descent;
+  common_baseline_ = ascent;
+}
+
+void FontListImpl::CacheFontStyleAndSize() const {
+  if (!fonts_.empty()) {
+    font_style_ = fonts_[0].GetStyle();
+    font_size_ = fonts_[0].GetFontSize();
+    font_weight_ = fonts_[0].GetWeight();
+  } else {
+    std::vector<std::string> font_names;
+    CHECK(FontList::ParseDescription(font_description_string_, &font_names,
+                                     &font_style_, &font_size_, &font_weight_));
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_list_impl.h b/ui/gfx/font_list_impl.h
new file mode 100644
index 0000000..d405288
--- /dev/null
+++ b/ui/gfx/font_list_impl.h
@@ -0,0 +1,126 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_LIST_IMPL_H_
+#define UI_GFX_FONT_LIST_IMPL_H_
+
+#include <string>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "ui/gfx/font.h"
+
+namespace gfx {
+
+// FontListImpl is designed to provide the implementation of FontList and
+// intended to be used only from FontList.  You must not use this class
+// directly.
+//
+// FontListImpl represents a list of fonts either in the form of Font vector or
+// in the form of a string representing font names, styles, and size.
+//
+// FontListImpl could be initialized either way without conversion to the other
+// form. The conversion to the other form is done only when asked to get the
+// other form.
+//
+// For the format of font description string, see font_list.h for details.
+class FontListImpl : public base::RefCounted<FontListImpl> {
+ public:
+  // Creates a font list from a string representing font names, styles, and
+  // size.
+  explicit FontListImpl(const std::string& font_description_string);
+
+  // Creates a font list from font names, styles, size and weight.
+  FontListImpl(const std::vector<std::string>& font_names,
+               int font_style,
+               int font_size,
+               Font::Weight font_weight);
+
+  // Creates a font list from a Font vector.
+  // All fonts in this vector should have the same style and size.
+  explicit FontListImpl(const std::vector<Font>& fonts);
+
+  // Creates a font list from a Font.
+  explicit FontListImpl(const Font& font);
+
+  // Returns a new FontListImpl with the same font names but resized and the
+  // given style and weight. |size_delta| is the size in pixels to add to the
+  // current font size. |font_style| specifies the new style, which is a
+  // bitmask of the values: Font::ITALIC and Font::UNDERLINE.
+  FontListImpl* Derive(int size_delta,
+                       int font_style,
+                       Font::Weight weight) const;
+
+  // Returns the height of this font list, which is max(ascent) + max(descent)
+  // for all the fonts in the font list.
+  int GetHeight() const;
+
+  // Returns the baseline of this font list, which is max(baseline) for all the
+  // fonts in the font list.
+  int GetBaseline() const;
+
+  // Returns the cap height of this font list.
+  // Currently returns the cap height of the primary font.
+  int GetCapHeight() const;
+
+  // Returns the expected number of horizontal pixels needed to display the
+  // specified length of characters. Call GetStringWidth() to retrieve the
+  // actual number.
+  int GetExpectedTextWidth(int length) const;
+
+  // Returns the |Font::FontStyle| style flags for this font list.
+  int GetFontStyle() const;
+
+  // Returns the font size in pixels.
+  int GetFontSize() const;
+
+  // Returns the font weight.
+  Font::Weight GetFontWeight() const;
+
+  // Returns the Font vector.
+  const std::vector<Font>& GetFonts() const;
+
+  // Returns the first font in the list.
+  const Font& GetPrimaryFont() const;
+
+ private:
+  friend class base::RefCounted<FontListImpl>;
+
+  ~FontListImpl();
+
+  // Extracts common font height and baseline into |common_height_| and
+  // |common_baseline_|.
+  void CacheCommonFontHeightAndBaseline() const;
+
+  // Extracts font style and size into |font_style_| and |font_size_|.
+  void CacheFontStyleAndSize() const;
+
+  // A vector of Font. If FontListImpl is constructed with font description
+  // string, |fonts_| is not initialized during construction. Instead, it is
+  // computed lazily when user asked to get the font vector.
+  mutable std::vector<Font> fonts_;
+
+  // A string representing font names, styles, and sizes.
+  // Please refer to the comments before class declaration for details on string
+  // format.
+  // If FontListImpl is constructed with a vector of font,
+  // |font_description_string_| is not initialized during construction. Instead,
+  // it is computed lazily when user asked to get the font description string.
+  //
+  // TODO(derat): Remove laziness so that this can be removed.
+  mutable std::string font_description_string_;
+
+  // The cached common height and baseline of the fonts in the font list.
+  mutable int common_height_;
+  mutable int common_baseline_;
+
+  // Cached font style and size.
+  mutable int font_style_;
+  mutable int font_size_;
+  mutable Font::Weight font_weight_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FONT_LIST_IMPL_H_
diff --git a/ui/gfx/font_list_unittest.cc b/ui/gfx/font_list_unittest.cc
new file mode 100644
index 0000000..405bdd9
--- /dev/null
+++ b/ui/gfx/font_list_unittest.cc
@@ -0,0 +1,307 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/font_list.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font_names_testing.h"
+
+namespace gfx {
+
+namespace {
+
+// Helper function for comparing fonts for equality.
+std::string FontToString(const Font& font) {
+  std::string font_string = font.GetFontName();
+  font_string += "|";
+  font_string += base::NumberToString(font.GetFontSize());
+  int style = font.GetStyle();
+  if (style & Font::ITALIC)
+    font_string += "|italic";
+  if (style & Font::UNDERLINE)
+    font_string += "|underline";
+  auto weight = font.GetWeight();
+  if (weight == Font::Weight::BLACK)
+    font_string += "|black";
+  else if (weight == Font::Weight::BOLD)
+    font_string += "|bold";
+  else if (weight == Font::Weight::EXTRA_BOLD)
+    font_string += "|extrabold";
+  else if (weight == Font::Weight::EXTRA_LIGHT)
+    font_string += "|extralight";
+  else if (weight == Font::Weight::LIGHT)
+    font_string += "|light";
+  else if (weight == Font::Weight::MEDIUM)
+    font_string += "|medium";
+  else if (weight == Font::Weight::NORMAL)
+    font_string += "|normal";
+  else if (weight == Font::Weight::SEMIBOLD)
+    font_string += "|semibold";
+  else if (weight == Font::Weight::THIN)
+    font_string += "|thin";
+  return font_string;
+}
+
+}  // namespace
+
+TEST(FontListTest, ParseDescription) {
+  std::vector<std::string> families;
+  int style = Font::NORMAL;
+  int size_pixels = 0;
+  Font::Weight weight = Font::Weight::NORMAL;
+
+  // Parse a well-formed description containing styles and a size.
+  EXPECT_TRUE(FontList::ParseDescription("Arial,Helvetica,Bold Italic 12px",
+                                         &families, &style, &size_pixels,
+                                         &weight));
+  ASSERT_EQ(2U, families.size());
+  EXPECT_EQ("Arial", families[0]);
+  EXPECT_EQ("Helvetica", families[1]);
+  EXPECT_EQ(Font::ITALIC, style);
+  EXPECT_EQ(Font::Weight::BOLD, weight);
+  EXPECT_EQ(12, size_pixels);
+
+  // Whitespace should be removed.
+  EXPECT_TRUE(FontList::ParseDescription("  Verdana , Italic  Bold   10px ",
+                                         &families, &style, &size_pixels,
+                                         &weight));
+  ASSERT_EQ(1U, families.size());
+  EXPECT_EQ("Verdana", families[0]);
+  EXPECT_EQ(Font::ITALIC, style);
+  EXPECT_EQ(Font::Weight::BOLD, weight);
+  EXPECT_EQ(10, size_pixels);
+
+  // Invalid descriptions should be rejected.
+  EXPECT_FALSE(
+      FontList::ParseDescription("", &families, &style, &size_pixels, &weight));
+  EXPECT_FALSE(FontList::ParseDescription("Arial", &families, &style,
+                                          &size_pixels, &weight));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,12", &families, &style,
+                                          &size_pixels, &weight));
+  EXPECT_FALSE(FontList::ParseDescription("Arial 12px", &families, &style,
+                                          &size_pixels, &weight));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,12px,", &families, &style,
+                                          &size_pixels, &weight));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,0px", &families, &style,
+                                          &size_pixels, &weight));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,-1px", &families, &style,
+                                          &size_pixels, &weight));
+  EXPECT_FALSE(FontList::ParseDescription("Arial,foo 12px", &families, &style,
+                                          &size_pixels, &weight));
+}
+
+TEST(FontListTest, Fonts_FromDescString) {
+  // Test init from font name size string.
+  FontList font_list = FontList("arial, Courier New, 13px");
+  const std::vector<Font>& fonts = font_list.GetFonts();
+  ASSERT_EQ(2U, fonts.size());
+  EXPECT_EQ("arial|13|normal", FontToString(fonts[0]));
+  EXPECT_EQ("Courier New|13|normal", FontToString(fonts[1]));
+}
+
+TEST(FontListTest, Fonts_FromDescStringInFlexibleFormat) {
+  // Test init from font name size string with flexible format.
+  FontList font_list = FontList("  arial   ,   Courier New ,   13px");
+  const std::vector<Font>& fonts = font_list.GetFonts();
+  ASSERT_EQ(2U, fonts.size());
+  EXPECT_EQ("arial|13|normal", FontToString(fonts[0]));
+  EXPECT_EQ("Courier New|13|normal", FontToString(fonts[1]));
+}
+
+TEST(FontListTest, Fonts_FromDescStringWithStyleInFlexibleFormat) {
+  // Test init from font name style size string with flexible format.
+  FontList font_list = FontList(
+      "  arial  ,  Courier New ,  Bold   "
+      "  Italic   13px");
+  const std::vector<Font>& fonts = font_list.GetFonts();
+  ASSERT_EQ(2U, fonts.size());
+  EXPECT_EQ("arial|13|italic|bold", FontToString(fonts[0]));
+  EXPECT_EQ("Courier New|13|italic|bold", FontToString(fonts[1]));
+}
+
+TEST(FontListTest, Fonts_FromFont) {
+  // Test init from Font.
+  Font font("Arial", 8);
+  FontList font_list = FontList(font);
+  const std::vector<Font>& fonts = font_list.GetFonts();
+  ASSERT_EQ(1U, fonts.size());
+  EXPECT_EQ("Arial|8|normal", FontToString(fonts[0]));
+}
+
+TEST(FontListTest, Fonts_FromFontWithNonNormalStyle) {
+  // Test init from Font with non-normal style.
+  Font font("Arial", 8);
+  FontList font_list(font.Derive(2, Font::NORMAL, Font::Weight::BOLD));
+  std::vector<Font> fonts = font_list.GetFonts();
+  ASSERT_EQ(1U, fonts.size());
+  EXPECT_EQ("Arial|10|bold", FontToString(fonts[0]));
+
+  font_list = FontList(font.Derive(-2, Font::ITALIC, Font::Weight::NORMAL));
+  fonts = font_list.GetFonts();
+  ASSERT_EQ(1U, fonts.size());
+  EXPECT_EQ("Arial|6|italic|normal", FontToString(fonts[0]));
+}
+
+TEST(FontListTest, Fonts_FromFontVector) {
+  // Test init from Font vector.
+  Font font("Arial", 8);
+  Font font_1("Courier New", 10);
+  std::vector<Font> input_fonts;
+  input_fonts.push_back(font.Derive(0, Font::NORMAL, Font::Weight::BOLD));
+  input_fonts.push_back(font_1.Derive(-2, Font::NORMAL, Font::Weight::BOLD));
+  FontList font_list = FontList(input_fonts);
+  const std::vector<Font>& fonts = font_list.GetFonts();
+  ASSERT_EQ(2U, fonts.size());
+  EXPECT_EQ("Arial|8|bold", FontToString(fonts[0]));
+  EXPECT_EQ("Courier New|8|bold", FontToString(fonts[1]));
+}
+
+TEST(FontListTest, FontDescString_GetStyle) {
+  FontList font_list = FontList("Arial,Sans serif, 8px");
+  EXPECT_EQ(Font::NORMAL, font_list.GetFontStyle());
+  EXPECT_EQ(Font::Weight::NORMAL, font_list.GetFontWeight());
+
+  font_list = FontList("Arial,Sans serif,Bold 8px");
+  EXPECT_EQ(Font::NORMAL, font_list.GetFontStyle());
+  EXPECT_EQ(Font::Weight::BOLD, font_list.GetFontWeight());
+
+  font_list = FontList("Arial,Sans serif,Italic 8px");
+  EXPECT_EQ(Font::ITALIC, font_list.GetFontStyle());
+  EXPECT_EQ(Font::Weight::NORMAL, font_list.GetFontWeight());
+
+  font_list = FontList("Arial,Italic Bold 8px");
+  EXPECT_EQ(Font::ITALIC, font_list.GetFontStyle());
+  EXPECT_EQ(Font::Weight::BOLD, font_list.GetFontWeight());
+}
+
+TEST(FontListTest, Fonts_GetStyle) {
+  std::vector<Font> fonts;
+  fonts.push_back(Font("Arial", 8));
+  fonts.push_back(Font("Sans serif", 8));
+  FontList font_list = FontList(fonts);
+  EXPECT_EQ(Font::NORMAL, font_list.GetFontStyle());
+  fonts[0] = fonts[0].Derive(0, Font::ITALIC, Font::Weight::BOLD);
+  fonts[1] = fonts[1].Derive(0, Font::ITALIC, Font::Weight::BOLD);
+  font_list = FontList(fonts);
+  EXPECT_EQ(Font::ITALIC, font_list.GetFontStyle());
+  EXPECT_EQ(Font::Weight::BOLD, font_list.GetFontWeight());
+}
+
+TEST(FontListTest, Fonts_Derive) {
+  std::vector<Font> fonts;
+  fonts.push_back(Font("Arial", 8));
+  fonts.push_back(Font("Courier New", 8));
+  FontList font_list = FontList(fonts);
+
+  FontList derived = font_list.Derive(5, Font::ITALIC, Font::Weight::BOLD);
+  const std::vector<Font>& derived_fonts = derived.GetFonts();
+
+  EXPECT_EQ(2U, derived_fonts.size());
+  EXPECT_EQ("Arial|13|italic|bold", FontToString(derived_fonts[0]));
+  EXPECT_EQ("Courier New|13|italic|bold", FontToString(derived_fonts[1]));
+
+  derived = font_list.Derive(5, Font::UNDERLINE, Font::Weight::BOLD);
+  const std::vector<Font>& underline_fonts = derived.GetFonts();
+
+  EXPECT_EQ(2U, underline_fonts.size());
+  EXPECT_EQ("Arial|13|underline|bold", FontToString(underline_fonts[0]));
+  EXPECT_EQ("Courier New|13|underline|bold", FontToString(underline_fonts[1]));
+}
+
+TEST(FontListTest, Fonts_DeriveWithSizeDelta) {
+  std::vector<Font> fonts;
+  fonts.push_back(
+      Font("Arial", 18).Derive(0, Font::ITALIC, Font::Weight::NORMAL));
+  fonts.push_back(Font("Courier New", 18)
+                      .Derive(0, Font::ITALIC, Font::Weight::NORMAL));
+  FontList font_list = FontList(fonts);
+
+  FontList derived = font_list.DeriveWithSizeDelta(-5);
+  const std::vector<Font>& derived_fonts = derived.GetFonts();
+
+  EXPECT_EQ(2U, derived_fonts.size());
+  EXPECT_EQ("Arial|13|italic|normal", FontToString(derived_fonts[0]));
+  EXPECT_EQ("Courier New|13|italic|normal", FontToString(derived_fonts[1]));
+}
+
+TEST(FontListTest, Fonts_GetHeight_GetBaseline) {
+  // If a font list has only one font, the height and baseline must be the same.
+  Font font1(kTestFontName, 16);
+  ASSERT_EQ(base::ToLowerASCII(kTestFontName),
+            base::ToLowerASCII(font1.GetActualFontName()));
+  FontList font_list1(std::string(kTestFontName) + ", 16px");
+  EXPECT_EQ(font1.GetHeight(), font_list1.GetHeight());
+  EXPECT_EQ(font1.GetBaseline(), font_list1.GetBaseline());
+
+  // If there are two different fonts, the font list returns the max value
+  // for the baseline (ascent) and height.
+  // NOTE: On most platforms, kCJKFontName has different metrics than
+  // kTestFontName, but on Android it does not.
+  Font font2(kCJKFontName, 16);
+  ASSERT_EQ(base::ToLowerASCII(kCJKFontName),
+            base::ToLowerASCII(font2.GetActualFontName()));
+  std::vector<Font> fonts;
+  fonts.push_back(font1);
+  fonts.push_back(font2);
+  FontList font_list_mix(fonts);
+  // ascent of FontList == max(ascent of Fonts)
+  EXPECT_EQ(std::max(font1.GetBaseline(), font2.GetBaseline()),
+            font_list_mix.GetBaseline());
+  // descent of FontList == max(descent of Fonts)
+  EXPECT_EQ(std::max(font1.GetHeight() - font1.GetBaseline(),
+                     font2.GetHeight() - font2.GetBaseline()),
+            font_list_mix.GetHeight() - font_list_mix.GetBaseline());
+}
+
+TEST(FontListTest, Fonts_DeriveWithHeightUpperBound) {
+  std::vector<Font> fonts;
+
+  fonts.push_back(Font("Arial", 18));
+  fonts.push_back(Font("Sans serif", 18));
+  fonts.push_back(Font(kSymbolFontName, 18));
+  FontList font_list = FontList(fonts);
+
+  // A smaller upper bound should derive a font list with a smaller height.
+  const int height_1 = font_list.GetHeight() - 5;
+  FontList derived_1 = font_list.DeriveWithHeightUpperBound(height_1);
+  EXPECT_LE(derived_1.GetHeight(), height_1);
+  EXPECT_LT(derived_1.GetHeight(), font_list.GetHeight());
+  EXPECT_LT(derived_1.GetFontSize(), font_list.GetFontSize());
+
+  // A larger upper bound should not change the height of the font list.
+  const int height_2 = font_list.GetHeight() + 5;
+  FontList derived_2 = font_list.DeriveWithHeightUpperBound(height_2);
+  EXPECT_LE(derived_2.GetHeight(), height_2);
+  EXPECT_EQ(font_list.GetHeight(), derived_2.GetHeight());
+  EXPECT_EQ(font_list.GetFontSize(), derived_2.GetFontSize());
+}
+
+TEST(FontListTest, FirstAvailableOrFirst) {
+  EXPECT_TRUE(FontList::FirstAvailableOrFirst("").empty());
+  EXPECT_TRUE(FontList::FirstAvailableOrFirst(std::string()).empty());
+
+  EXPECT_EQ("Arial", FontList::FirstAvailableOrFirst("Arial"));
+  EXPECT_EQ("not exist", FontList::FirstAvailableOrFirst("not exist"));
+
+  EXPECT_EQ("Arial", FontList::FirstAvailableOrFirst("Arial, not exist"));
+  EXPECT_EQ("Arial", FontList::FirstAvailableOrFirst("not exist, Arial"));
+  EXPECT_EQ("Arial",
+            FontList::FirstAvailableOrFirst("not exist, Arial, not exist"));
+
+  EXPECT_EQ("not exist",
+            FontList::FirstAvailableOrFirst("not exist, not exist 2"));
+
+  EXPECT_EQ("Arial", FontList::FirstAvailableOrFirst(", not exist, Arial"));
+  EXPECT_EQ("not exist",
+            FontList::FirstAvailableOrFirst(", not exist, not exist"));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_names_testing.cc b/ui/gfx/font_names_testing.cc
new file mode 100644
index 0000000..86e4abb
--- /dev/null
+++ b/ui/gfx/font_names_testing.cc
@@ -0,0 +1,53 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/font_names_testing.h"
+
+#include "build/build_config.h"
+
+namespace gfx {
+
+/*
+Reference for fonts available on Android:
+
+Jelly Bean:
+  https://android.googlesource.com/platform/frameworks/base/+/jb-release/data/fonts/system_fonts.xml
+KitKat:
+  https://android.googlesource.com/platform/frameworks/base/+/kitkat-release/data/fonts/system_fonts.xml
+master:
+  https://android.googlesource.com/platform/frameworks/base/+/master/data/fonts/fonts.xml
+
+Note that we have to support the full range from JellyBean to the latest
+dessert.
+*/
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_FUCHSIA)
+const char kTestFontName[] = "Arimo";
+#elif defined(OS_ANDROID)
+const char kTestFontName[] = "sans-serif";
+#else
+const char kTestFontName[] = "Arial";
+#endif
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_FUCHSIA)
+const char kSymbolFontName[] = "DejaVu Sans";
+#elif defined(OS_ANDROID)
+const char kSymbolFontName[] = "monospace";
+#elif defined(OS_WIN)
+const char kSymbolFontName[] = "Segoe UI Symbol";
+#else
+const char kSymbolFontName[] = "Symbol";
+#endif
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_FUCHSIA)
+const char kCJKFontName[] = "Noto Sans CJK JP";
+#elif defined(OS_ANDROID)
+const char kCJKFontName[] = "serif";
+#elif defined(OS_APPLE)
+const char kCJKFontName[] = "Heiti SC";
+#else
+const char kCJKFontName[] = "SimSun";
+#endif
+
+} // namespace gfx
diff --git a/ui/gfx/font_names_testing.h b/ui/gfx/font_names_testing.h
new file mode 100644
index 0000000..b4f7a9a
--- /dev/null
+++ b/ui/gfx/font_names_testing.h
@@ -0,0 +1,16 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_NAMES_TESTING_H_
+#define UI_GFX_FONT_NAMES_TESTING_H_
+
+namespace gfx {
+
+extern const char kTestFontName[];
+extern const char kSymbolFontName[];
+extern const char kCJKFontName[];
+
+} // end namespace gfx
+
+#endif  // UI_GFX_FONT_NAMES_TESTING_H_
diff --git a/ui/gfx/font_render_params.cc b/ui/gfx/font_render_params.cc
new file mode 100644
index 0000000..31799c8
--- /dev/null
+++ b/ui/gfx/font_render_params.cc
@@ -0,0 +1,43 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/font_render_params.h"
+
+#include "base/notreached.h"
+
+namespace gfx {
+
+// static
+SkPixelGeometry FontRenderParams::SubpixelRenderingToSkiaPixelGeometry(
+    FontRenderParams::SubpixelRendering subpixel_rendering) {
+  switch (subpixel_rendering) {
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE:
+      return kRGB_H_SkPixelGeometry;  // why not kUnknown_SkPixelGeometry ??
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_RGB:
+      return kRGB_H_SkPixelGeometry;
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_VRGB:
+      return kRGB_V_SkPixelGeometry;
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_BGR:
+      return kBGR_H_SkPixelGeometry;
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_VBGR:
+      return kBGR_V_SkPixelGeometry;
+  }
+
+  NOTREACHED();
+  return kRGB_H_SkPixelGeometry;
+}
+
+FontRenderParamsQuery::FontRenderParamsQuery()
+    : pixel_size(0),
+      point_size(0),
+      style(-1),
+      weight(Font::Weight::INVALID),
+      device_scale_factor(0) {}
+
+FontRenderParamsQuery::FontRenderParamsQuery(
+    const FontRenderParamsQuery& other) = default;
+
+FontRenderParamsQuery::~FontRenderParamsQuery() {}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_render_params.h b/ui/gfx/font_render_params.h
new file mode 100644
index 0000000..96508f2
--- /dev/null
+++ b/ui/gfx/font_render_params.h
@@ -0,0 +1,131 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_RENDER_PARAMS_H_
+#define UI_GFX_FONT_RENDER_PARAMS_H_
+
+#include <string>
+#include <vector>
+
+#include "build/build_config.h"
+#include "device/vr/buildflags/buildflags.h"
+#include "third_party/skia/include/core/SkSurfaceProps.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// A collection of parameters describing how text should be rendered on Linux.
+struct GFX_EXPORT FontRenderParams {
+  bool operator==(const FontRenderParams& other) const {
+    return antialiasing == other.antialiasing &&
+           subpixel_positioning == other.subpixel_positioning &&
+           autohinter == other.autohinter && use_bitmaps == other.use_bitmaps &&
+           hinting == other.hinting &&
+           subpixel_rendering == other.subpixel_rendering;
+  }
+
+  // Level of hinting to be applied.
+  enum Hinting {
+    HINTING_NONE = 0,
+    HINTING_SLIGHT,
+    HINTING_MEDIUM,
+    HINTING_FULL,
+
+    HINTING_MAX = HINTING_FULL,
+  };
+
+  // Different subpixel orders to be used for subpixel rendering.
+  enum SubpixelRendering {
+    SUBPIXEL_RENDERING_NONE = 0,
+    SUBPIXEL_RENDERING_RGB,
+    SUBPIXEL_RENDERING_BGR,
+    SUBPIXEL_RENDERING_VRGB,
+    SUBPIXEL_RENDERING_VBGR,
+
+    SUBPIXEL_RENDERING_MAX = SUBPIXEL_RENDERING_VBGR,
+  };
+
+  // Antialiasing (grayscale if |subpixel_rendering| is SUBPIXEL_RENDERING_NONE
+  // and RGBA otherwise).
+  bool antialiasing = true;
+
+  // Should subpixel positioning (i.e. fractional X positions for glyphs) be
+  // used?
+  // TODO(derat): Remove this; we don't set it in the browser and mostly ignore
+  // it in Blink: http://crbug.com/396659
+  bool subpixel_positioning = true;
+
+  // Should FreeType's autohinter be used (as opposed to Freetype's bytecode
+  // interpreter, which uses fonts' own hinting instructions)?
+  bool autohinter = false;
+
+  // Should embedded bitmaps in fonts should be used?
+  bool use_bitmaps = false;
+
+  // Hinting level.
+  Hinting hinting = HINTING_MEDIUM;
+
+  // Whether subpixel rendering should be used or not, and if so, the display's
+  // subpixel order.
+  SubpixelRendering subpixel_rendering = SUBPIXEL_RENDERING_NONE;
+
+  static SkPixelGeometry SubpixelRenderingToSkiaPixelGeometry(
+      SubpixelRendering subpixel_rendering);
+};
+
+// A query used to determine the appropriate FontRenderParams.
+struct GFX_EXPORT FontRenderParamsQuery {
+  FontRenderParamsQuery();
+  FontRenderParamsQuery(const FontRenderParamsQuery& other);
+  ~FontRenderParamsQuery();
+
+  bool is_empty() const {
+    return families.empty() && pixel_size <= 0 && point_size <= 0 && style < 0;
+  }
+
+  // Requested font families, or empty if unset.
+  std::vector<std::string> families;
+
+  // Font size in pixels or points, or 0 if unset.
+  int pixel_size;
+  int point_size;
+
+  // Font::FontStyle bit field, or -1 if unset.
+  int style;
+
+  // Weight of the font. Weight::NORMAL by default.
+  Font::Weight weight;
+
+  // The device scale factor of the display, or 0 if unset.
+  float device_scale_factor;
+};
+
+// Returns the appropriate parameters for rendering the font described by
+// |query|. If |family_out| is non-NULL, it will be updated to contain the
+// recommended font family from |query.families|.
+GFX_EXPORT FontRenderParams GetFontRenderParams(
+    const FontRenderParamsQuery& query,
+    std::string* family_out);
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+// Clears GetFontRenderParams()'s cache. Intended to be called by tests that are
+// changing Fontconfig's configuration.
+GFX_EXPORT void ClearFontRenderParamsCacheForTest();
+#endif
+
+// Gets the device scale factor to query the FontRenderParams.
+GFX_EXPORT float GetFontRenderParamsDeviceScaleFactor();
+
+#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS) || \
+    defined(OS_ANDROID) || defined(OS_FUCHSIA)
+// Sets the device scale factor for FontRenderParams to decide
+// if it should enable subpixel positioning.
+GFX_EXPORT void SetFontRenderParamsDeviceScaleFactor(
+    float device_scale_factor);
+#endif
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FONT_RENDER_PARAMS_H_
diff --git a/ui/gfx/font_render_params_linux.cc b/ui/gfx/font_render_params_linux.cc
new file mode 100644
index 0000000..7e42a2e
--- /dev/null
+++ b/ui/gfx/font_render_params_linux.cc
@@ -0,0 +1,273 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/font_render_params.h"
+
+#include <fontconfig/fontconfig.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+
+#include "base/command_line.h"
+#include "base/containers/mru_cache.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/synchronization/lock.h"
+#include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/linux/fontconfig_util.h"
+#include "ui/gfx/skia_font_delegate.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+
+namespace {
+
+int FontWeightToFCWeight(Font::Weight weight) {
+  const int weight_number = static_cast<int>(weight);
+  if (weight_number <= (static_cast<int>(Font::Weight::THIN) +
+                        static_cast<int>(Font::Weight::EXTRA_LIGHT)) /
+                           2)
+    return FC_WEIGHT_THIN;
+  else if (weight_number <= (static_cast<int>(Font::Weight::EXTRA_LIGHT) +
+                             static_cast<int>(Font::Weight::LIGHT)) /
+                                2)
+    return FC_WEIGHT_ULTRALIGHT;
+  else if (weight_number <= (static_cast<int>(Font::Weight::LIGHT) +
+                             static_cast<int>(Font::Weight::NORMAL)) /
+                                2)
+    return FC_WEIGHT_LIGHT;
+  else if (weight_number <= (static_cast<int>(Font::Weight::NORMAL) +
+                             static_cast<int>(Font::Weight::MEDIUM)) /
+                                2)
+    return FC_WEIGHT_NORMAL;
+  else if (weight_number <= (static_cast<int>(Font::Weight::MEDIUM) +
+                             static_cast<int>(Font::Weight::SEMIBOLD)) /
+                                2)
+    return FC_WEIGHT_MEDIUM;
+  else if (weight_number <= (static_cast<int>(Font::Weight::SEMIBOLD) +
+                             static_cast<int>(Font::Weight::BOLD)) /
+                                2)
+    return FC_WEIGHT_DEMIBOLD;
+  else if (weight_number <= (static_cast<int>(Font::Weight::BOLD) +
+                             static_cast<int>(Font::Weight::EXTRA_BOLD)) /
+                                2)
+    return FC_WEIGHT_BOLD;
+  else if (weight_number <= (static_cast<int>(Font::Weight::EXTRA_BOLD) +
+                             static_cast<int>(Font::Weight::BLACK)) /
+                                2)
+    return FC_WEIGHT_ULTRABOLD;
+  else
+    return FC_WEIGHT_BLACK;
+}
+
+// A device scale factor used to determine if subpixel positioning
+// should be used.
+float device_scale_factor_ = 1.0f;
+
+// Number of recent GetFontRenderParams() results to cache.
+const size_t kCacheSize = 256;
+
+// Cached result from a call to GetFontRenderParams().
+struct QueryResult {
+  QueryResult(const FontRenderParams& params, const std::string& family)
+      : params(params),
+        family(family) {
+  }
+  ~QueryResult() {}
+
+  FontRenderParams params;
+  std::string family;
+};
+
+// Keyed by hashes of FontRenderParamQuery structs from
+// HashFontRenderParamsQuery().
+typedef base::HashingMRUCache<std::string, QueryResult> Cache;
+
+// A cache and the lock that must be held while accessing it.
+// GetFontRenderParams() is called by both the UI thread and the sandbox IPC
+// thread.
+struct SynchronizedCache {
+  SynchronizedCache() : cache(kCacheSize) {}
+
+  base::Lock lock;
+  Cache cache;
+};
+
+base::LazyInstance<SynchronizedCache>::Leaky g_synchronized_cache =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Queries Fontconfig for rendering settings and updates |params_out| and
+// |family_out| (if non-NULL). Returns false on failure.
+bool QueryFontconfig(const FontRenderParamsQuery& query,
+                     FontRenderParams* params_out,
+                     std::string* family_out) {
+  TRACE_EVENT0("fonts", "gfx::QueryFontconfig");
+
+  ScopedFcPattern query_pattern(FcPatternCreate());
+  CHECK(query_pattern);
+
+  FcPatternAddBool(query_pattern.get(), FC_SCALABLE, FcTrue);
+
+  for (auto it = query.families.begin(); it != query.families.end(); ++it) {
+    FcPatternAddString(query_pattern.get(),
+        FC_FAMILY, reinterpret_cast<const FcChar8*>(it->c_str()));
+  }
+  if (query.pixel_size > 0)
+    FcPatternAddDouble(query_pattern.get(), FC_PIXEL_SIZE, query.pixel_size);
+  if (query.point_size > 0)
+    FcPatternAddInteger(query_pattern.get(), FC_SIZE, query.point_size);
+  if (query.style >= 0) {
+    FcPatternAddInteger(query_pattern.get(), FC_SLANT,
+        (query.style & Font::ITALIC) ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
+  }
+  if (query.weight != Font::Weight::INVALID) {
+    FcPatternAddInteger(query_pattern.get(), FC_WEIGHT,
+                        FontWeightToFCWeight(query.weight));
+  }
+
+  FcConfig* config = GetGlobalFontConfig();
+  FcConfigSubstitute(config, query_pattern.get(), FcMatchPattern);
+  FcDefaultSubstitute(query_pattern.get());
+
+  ScopedFcPattern result_pattern;
+  if (query.is_empty()) {
+    // If the query was empty, call FcConfigSubstituteWithPat() to get a
+    // non-family- or size-specific configuration so it can be used as the
+    // default.
+    result_pattern.reset(FcPatternDuplicate(query_pattern.get()));
+    if (!result_pattern)
+      return false;
+    FcPatternDel(result_pattern.get(), FC_FAMILY);
+    FcPatternDel(result_pattern.get(), FC_PIXEL_SIZE);
+    FcPatternDel(result_pattern.get(), FC_SIZE);
+    FcConfigSubstituteWithPat(config, result_pattern.get(), query_pattern.get(),
+                              FcMatchFont);
+  } else {
+    TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("fonts"), "FcFontMatch");
+    FcResult result;
+    result_pattern.reset(FcFontMatch(config, query_pattern.get(), &result));
+    if (!result_pattern)
+      return false;
+  }
+  DCHECK(result_pattern);
+
+  if (family_out) {
+    FcChar8* family = NULL;
+    FcPatternGetString(result_pattern.get(), FC_FAMILY, 0, &family);
+    if (family)
+      family_out->assign(reinterpret_cast<const char*>(family));
+  }
+
+  if (params_out)
+    GetFontRenderParamsFromFcPattern(result_pattern.get(), params_out);
+
+  return true;
+}
+
+// Serialize |query| into a string value suitable for use as a cache key.
+std::string GetFontRenderParamsQueryKey(const FontRenderParamsQuery& query) {
+  return base::StringPrintf(
+      "%d|%d|%d|%d|%s|%f", query.pixel_size, query.point_size, query.style,
+      static_cast<int>(query.weight),
+      base::JoinString(query.families, ",").c_str(), query.device_scale_factor);
+}
+
+}  // namespace
+
+FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
+                                     std::string* family_out) {
+  TRACE_EVENT0("fonts", "gfx::GetFontRenderParams");
+
+  FontRenderParamsQuery actual_query(query);
+  if (actual_query.device_scale_factor == 0)
+    actual_query.device_scale_factor = device_scale_factor_;
+
+  std::string query_key = GetFontRenderParamsQueryKey(actual_query);
+  SynchronizedCache* synchronized_cache = g_synchronized_cache.Pointer();
+
+  {
+    // Try to find a cached result so Fontconfig doesn't need to be queried.
+    base::AutoLock lock(synchronized_cache->lock);
+    Cache::const_iterator it = synchronized_cache->cache.Get(query_key);
+    if (it != synchronized_cache->cache.end()) {
+      DVLOG(1) << "Returning cached params for " << query_key;
+      const QueryResult& result = it->second;
+      if (family_out)
+        *family_out = result.family;
+      return result.params;
+    }
+  }
+
+  DVLOG(1) << "Computing params for " << query_key;
+  if (family_out)
+    family_out->clear();
+
+  // Start with the delegate's settings, but let Fontconfig have the final say.
+  FontRenderParams params;
+  const SkiaFontDelegate* delegate = SkiaFontDelegate::instance();
+  if (delegate)
+    params = delegate->GetDefaultFontRenderParams();
+  QueryFontconfig(actual_query, &params, family_out);
+  if (!params.antialiasing) {
+    // Cairo forces full hinting when antialiasing is disabled, since anything
+    // less than that looks awful; do the same here. Requesting subpixel
+    // rendering or positioning doesn't make sense either.
+    params.hinting = FontRenderParams::HINTING_FULL;
+    params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_NONE;
+    params.subpixel_positioning = false;
+  } else if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+                 switches::kDisableFontSubpixelPositioning)) {
+#if !BUILDFLAG(IS_CHROMEOS_ASH)
+    params.subpixel_positioning = actual_query.device_scale_factor > 1.0f;
+#else
+    // We want to enable subpixel positioning for fractional dsf.
+    params.subpixel_positioning =
+        std::abs(std::round(actual_query.device_scale_factor) -
+                 actual_query.device_scale_factor) >
+        std::numeric_limits<float>::epsilon();
+#endif  // !BUILDFLAG(IS_CHROMEOS_ASH)
+
+    // To enable subpixel positioning, we need to disable hinting.
+    if (params.subpixel_positioning)
+      params.hinting = FontRenderParams::HINTING_NONE;
+  }
+
+  // Use the first family from the list if Fontconfig didn't suggest a family.
+  if (family_out && family_out->empty() && !actual_query.families.empty())
+    *family_out = actual_query.families[0];
+
+  {
+    // Store the result. It's fine if this overwrites a result that was cached
+    // by a different thread in the meantime; the values should be identical.
+    base::AutoLock lock(synchronized_cache->lock);
+    synchronized_cache->cache.Put(
+        query_key,
+        QueryResult(params, family_out ? *family_out : std::string()));
+  }
+
+  return params;
+}
+
+void ClearFontRenderParamsCacheForTest() {
+  SynchronizedCache* synchronized_cache = g_synchronized_cache.Pointer();
+  base::AutoLock lock(synchronized_cache->lock);
+  synchronized_cache->cache.Clear();
+}
+
+float GetFontRenderParamsDeviceScaleFactor() {
+  return device_scale_factor_;
+}
+
+void SetFontRenderParamsDeviceScaleFactor(float device_scale_factor) {
+  device_scale_factor_ = device_scale_factor;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_render_params_linux_unittest.cc b/ui/gfx/font_render_params_linux_unittest.cc
new file mode 100644
index 0000000..240e68b
--- /dev/null
+++ b/ui/gfx/font_render_params_linux_unittest.cc
@@ -0,0 +1,462 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/font_render_params.h"
+
+#include <fontconfig/fontconfig.h>
+
+#include "base/check_op.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
+#include "base/notreached.h"
+#include "base/strings/stringprintf.h"
+#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/test_fonts/fontconfig_util_linux.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/linux/fontconfig_util.h"
+#include "ui/gfx/skia_font_delegate.h"
+
+namespace gfx {
+
+namespace {
+
+// Strings appearing at the beginning and end of Fontconfig XML files.
+const char kFontconfigFileHeader[] =
+    "<?xml version=\"1.0\"?>\n"
+    "<!DOCTYPE fontconfig SYSTEM \"fonts.dtd\">\n"
+    "<fontconfig>\n";
+const char kFontconfigFileFooter[] = "</fontconfig>";
+
+// Strings appearing at the beginning and end of Fontconfig <match> stanzas.
+const char kFontconfigMatchFontHeader[] = "  <match target=\"font\">\n";
+const char kFontconfigMatchPatternHeader[] = "  <match target=\"pattern\">\n";
+const char kFontconfigMatchFooter[] = "  </match>\n";
+
+// Implementation of SkiaFontDelegate that returns a canned FontRenderParams
+// struct. This is used to isolate tests from the system's local configuration.
+class TestFontDelegate : public SkiaFontDelegate {
+ public:
+  TestFontDelegate() {}
+
+  TestFontDelegate(const TestFontDelegate&) = delete;
+  TestFontDelegate& operator=(const TestFontDelegate&) = delete;
+
+  ~TestFontDelegate() override {}
+
+  void set_params(const FontRenderParams& params) { params_ = params; }
+
+  FontRenderParams GetDefaultFontRenderParams() const override {
+    return params_;
+  }
+  void GetDefaultFontDescription(std::string* family_out,
+                                 int* size_pixels_out,
+                                 int* style_out,
+                                 Font::Weight* weight_out,
+                                 FontRenderParams* params_out) const override {
+    NOTIMPLEMENTED();
+  }
+
+ private:
+  FontRenderParams params_;
+};
+
+// Loads XML-formatted |data| into the current font configuration.
+bool LoadConfigDataIntoFontconfig(const std::string& data) {
+  FcConfig* config = GetGlobalFontConfig();
+  constexpr FcBool kComplain = FcTrue;
+  return FcConfigParseAndLoadFromMemory(
+      config, reinterpret_cast<const FcChar8*>(data.c_str()), kComplain);
+}
+
+// Returns a Fontconfig <edit> stanza.
+std::string CreateFontconfigEditStanza(const std::string& name,
+                                       const std::string& type,
+                                       const std::string& value) {
+  return base::StringPrintf(
+      "    <edit name=\"%s\" mode=\"assign\">\n"
+      "      <%s>%s</%s>\n"
+      "    </edit>\n",
+      name.c_str(), type.c_str(), value.c_str(), type.c_str());
+}
+
+// Returns a Fontconfig <test> stanza.
+std::string CreateFontconfigTestStanza(const std::string& name,
+                                       const std::string& op,
+                                       const std::string& type,
+                                       const std::string& value) {
+  return base::StringPrintf(
+      "    <test name=\"%s\" compare=\"%s\" qual=\"any\">\n"
+      "      <%s>%s</%s>\n"
+      "    </test>\n",
+      name.c_str(), op.c_str(), type.c_str(), value.c_str(), type.c_str());
+}
+
+// Returns a Fontconfig <alias> stanza.
+std::string CreateFontconfigAliasStanza(const std::string& original_family,
+                                        const std::string& preferred_family) {
+  return base::StringPrintf(
+      "  <alias>\n"
+      "    <family>%s</family>\n"
+      "    <prefer><family>%s</family></prefer>\n"
+      "  </alias>\n",
+      original_family.c_str(), preferred_family.c_str());
+}
+
+}  // namespace
+
+class FontRenderParamsTest : public testing::Test {
+ public:
+  FontRenderParamsTest() {
+    original_font_delegate_ = SkiaFontDelegate::instance();
+    SkiaFontDelegate::SetInstance(&test_font_delegate_);
+    ClearFontRenderParamsCacheForTest();
+
+    // Create a new fontconfig configuration and load the default fonts
+    // configuration. The default test config file is produced in the build
+    // folder under <build_dir>/etc/fonts/fonts.conf and the loaded tests fonts
+    // are under <build_dir>/test_fonts.
+    override_config_ = FcConfigCreate();
+    FcBool parse_success =
+        FcConfigParseAndLoad(override_config_, nullptr, FcTrue);
+    DCHECK_NE(parse_success, FcFalse);
+    FcBool load_success = FcConfigBuildFonts(override_config_);
+    DCHECK_NE(load_success, FcFalse);
+
+    original_config_ = GetGlobalFontConfig();
+    OverrideGlobalFontConfigForTesting(override_config_);
+  }
+
+  FontRenderParamsTest(const FontRenderParamsTest&) = delete;
+  FontRenderParamsTest& operator=(const FontRenderParamsTest&) = delete;
+
+  ~FontRenderParamsTest() override {
+    OverrideGlobalFontConfigForTesting(original_config_);
+    FcConfigDestroy(override_config_);
+
+    SkiaFontDelegate::SetInstance(
+        const_cast<SkiaFontDelegate*>(original_font_delegate_));
+  }
+
+ protected:
+  const SkiaFontDelegate* original_font_delegate_;
+  TestFontDelegate test_font_delegate_;
+
+  FcConfig* override_config_ = nullptr;
+  FcConfig* original_config_ = nullptr;
+};
+
+TEST_F(FontRenderParamsTest, Default) {
+  ASSERT_TRUE(LoadConfigDataIntoFontconfig(
+      std::string(kFontconfigFileHeader) +
+          // Specify the desired defaults via a font match rather than a pattern
+          // match (since this is the style generally used in
+          // /etc/fonts/conf.d).
+          kFontconfigMatchFontHeader +
+          CreateFontconfigEditStanza("antialias", "bool", "true") +
+          CreateFontconfigEditStanza("autohint", "bool", "true") +
+          CreateFontconfigEditStanza("hinting", "bool", "true") +
+          CreateFontconfigEditStanza("hintstyle", "const", "hintslight") +
+          CreateFontconfigEditStanza("rgba", "const", "rgb") +
+          kFontconfigMatchFooter +
+          // Add a font match for Arimo. Since it specifies a family, it
+          // shouldn't take effect when querying default settings.
+          kFontconfigMatchFontHeader +
+          CreateFontconfigTestStanza("family", "eq", "string", "Arimo") +
+          CreateFontconfigEditStanza("antialias", "bool", "true") +
+          CreateFontconfigEditStanza("autohint", "bool", "false") +
+          CreateFontconfigEditStanza("hinting", "bool", "true") +
+          CreateFontconfigEditStanza("hintstyle", "const", "hintfull") +
+          CreateFontconfigEditStanza("rgba", "const", "none") +
+          kFontconfigMatchFooter +
+          // Add font matches for fonts between 10 and 20 points or pixels.
+          // Since they specify sizes, they also should not affect the defaults.
+          kFontconfigMatchFontHeader +
+          CreateFontconfigTestStanza("size", "more_eq", "double", "10.0") +
+          CreateFontconfigTestStanza("size", "less_eq", "double", "20.0") +
+          CreateFontconfigEditStanza("antialias", "bool", "false") +
+          kFontconfigMatchFooter + kFontconfigMatchFontHeader +
+          CreateFontconfigTestStanza("pixel_size", "more_eq", "double",
+                                     "10.0") +
+          CreateFontconfigTestStanza("pixel_size", "less_eq", "double",
+                                     "20.0") +
+          CreateFontconfigEditStanza("antialias", "bool", "false") +
+          kFontconfigMatchFooter + kFontconfigFileFooter));
+
+  FontRenderParams params = GetFontRenderParams(
+      FontRenderParamsQuery(), NULL);
+  EXPECT_TRUE(params.antialiasing);
+  EXPECT_TRUE(params.autohinter);
+  EXPECT_TRUE(params.use_bitmaps);
+  EXPECT_EQ(FontRenderParams::HINTING_SLIGHT, params.hinting);
+  EXPECT_FALSE(params.subpixel_positioning);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_RGB,
+            params.subpixel_rendering);
+}
+
+TEST_F(FontRenderParamsTest, Size) {
+  ASSERT_TRUE(LoadConfigDataIntoFontconfig(
+      std::string(kFontconfigFileHeader) + kFontconfigMatchPatternHeader +
+          CreateFontconfigEditStanza("antialias", "bool", "true") +
+          CreateFontconfigEditStanza("hinting", "bool", "true") +
+          CreateFontconfigEditStanza("hintstyle", "const", "hintfull") +
+          CreateFontconfigEditStanza("rgba", "const", "none") +
+          kFontconfigMatchFooter + kFontconfigMatchPatternHeader +
+          CreateFontconfigTestStanza("pixelsize", "less_eq", "double", "10") +
+          CreateFontconfigEditStanza("antialias", "bool", "false") +
+          kFontconfigMatchFooter + kFontconfigMatchPatternHeader +
+          CreateFontconfigTestStanza("size", "more_eq", "double", "20") +
+          CreateFontconfigEditStanza("hintstyle", "const", "hintslight") +
+          CreateFontconfigEditStanza("rgba", "const", "rgb") +
+          kFontconfigMatchFooter + kFontconfigFileFooter));
+
+  // The defaults should be used when the supplied size isn't matched by the
+  // second or third blocks.
+  FontRenderParamsQuery query;
+  query.pixel_size = 12;
+  FontRenderParams params = GetFontRenderParams(query, NULL);
+  EXPECT_TRUE(params.antialiasing);
+  EXPECT_EQ(FontRenderParams::HINTING_FULL, params.hinting);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_NONE,
+            params.subpixel_rendering);
+
+  query.pixel_size = 10;
+  params = GetFontRenderParams(query, NULL);
+  EXPECT_FALSE(params.antialiasing);
+  EXPECT_EQ(FontRenderParams::HINTING_FULL, params.hinting);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_NONE,
+            params.subpixel_rendering);
+
+  query.pixel_size = 0;
+  query.point_size = 20;
+  params = GetFontRenderParams(query, NULL);
+  EXPECT_TRUE(params.antialiasing);
+  EXPECT_EQ(FontRenderParams::HINTING_SLIGHT, params.hinting);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_RGB,
+            params.subpixel_rendering);
+}
+
+TEST_F(FontRenderParamsTest, Style) {
+  // Load a config that disables subpixel rendering for bold text and disables
+  // hinting for italic text.
+  ASSERT_TRUE(LoadConfigDataIntoFontconfig(
+      std::string(kFontconfigFileHeader) + kFontconfigMatchPatternHeader +
+          CreateFontconfigEditStanza("antialias", "bool", "true") +
+          CreateFontconfigEditStanza("hinting", "bool", "true") +
+          CreateFontconfigEditStanza("hintstyle", "const", "hintslight") +
+          CreateFontconfigEditStanza("rgba", "const", "rgb") +
+          kFontconfigMatchFooter + kFontconfigMatchPatternHeader +
+          CreateFontconfigTestStanza("weight", "eq", "const", "bold") +
+          CreateFontconfigEditStanza("rgba", "const", "none") +
+          kFontconfigMatchFooter + kFontconfigMatchPatternHeader +
+          CreateFontconfigTestStanza("slant", "eq", "const", "italic") +
+          CreateFontconfigEditStanza("hinting", "bool", "false") +
+          kFontconfigMatchFooter + kFontconfigFileFooter));
+
+  FontRenderParamsQuery query;
+  query.style = Font::NORMAL;
+  FontRenderParams params = GetFontRenderParams(query, NULL);
+  EXPECT_EQ(FontRenderParams::HINTING_SLIGHT, params.hinting);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_RGB,
+            params.subpixel_rendering);
+
+  query.weight = Font::Weight::BOLD;
+  params = GetFontRenderParams(query, NULL);
+  EXPECT_EQ(FontRenderParams::HINTING_SLIGHT, params.hinting);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_NONE,
+            params.subpixel_rendering);
+
+  query.weight = Font::Weight::NORMAL;
+  query.style = Font::ITALIC;
+  params = GetFontRenderParams(query, NULL);
+  EXPECT_EQ(FontRenderParams::HINTING_NONE, params.hinting);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_RGB,
+            params.subpixel_rendering);
+
+  query.weight = Font::Weight::BOLD;
+  query.style = Font::ITALIC;
+  params = GetFontRenderParams(query, NULL);
+  EXPECT_EQ(FontRenderParams::HINTING_NONE, params.hinting);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_NONE,
+            params.subpixel_rendering);
+}
+
+TEST_F(FontRenderParamsTest, Scalable) {
+  // Load a config that only enables antialiasing for scalable fonts.
+  ASSERT_TRUE(LoadConfigDataIntoFontconfig(
+      std::string(kFontconfigFileHeader) + kFontconfigMatchPatternHeader +
+          CreateFontconfigEditStanza("antialias", "bool", "false") +
+          kFontconfigMatchFooter + kFontconfigMatchPatternHeader +
+          CreateFontconfigTestStanza("scalable", "eq", "bool", "true") +
+          CreateFontconfigEditStanza("antialias", "bool", "true") +
+          kFontconfigMatchFooter + kFontconfigFileFooter));
+
+  // Check that we specifically ask how scalable fonts should be rendered.
+  FontRenderParams params = GetFontRenderParams(
+      FontRenderParamsQuery(), NULL);
+  EXPECT_TRUE(params.antialiasing);
+}
+
+TEST_F(FontRenderParamsTest, UseBitmaps) {
+  // Load a config that enables embedded bitmaps for fonts <= 10 pixels.
+  ASSERT_TRUE(LoadConfigDataIntoFontconfig(
+      std::string(kFontconfigFileHeader) + kFontconfigMatchPatternHeader +
+          CreateFontconfigEditStanza("embeddedbitmap", "bool", "false") +
+          kFontconfigMatchFooter + kFontconfigMatchPatternHeader +
+          CreateFontconfigTestStanza("pixelsize", "less_eq", "double", "10") +
+          CreateFontconfigEditStanza("embeddedbitmap", "bool", "true") +
+          kFontconfigMatchFooter + kFontconfigFileFooter));
+
+  FontRenderParamsQuery query;
+  FontRenderParams params = GetFontRenderParams(query, NULL);
+  EXPECT_FALSE(params.use_bitmaps);
+
+  query.pixel_size = 5;
+  params = GetFontRenderParams(query, NULL);
+  EXPECT_TRUE(params.use_bitmaps);
+}
+
+TEST_F(FontRenderParamsTest, ForceFullHintingWhenAntialiasingIsDisabled) {
+  // Load a config that disables antialiasing and hinting while requesting
+  // subpixel rendering.
+  ASSERT_TRUE(LoadConfigDataIntoFontconfig(
+      std::string(kFontconfigFileHeader) + kFontconfigMatchPatternHeader +
+          CreateFontconfigEditStanza("antialias", "bool", "false") +
+          CreateFontconfigEditStanza("hinting", "bool", "false") +
+          CreateFontconfigEditStanza("hintstyle", "const", "hintnone") +
+          CreateFontconfigEditStanza("rgba", "const", "rgb") +
+          kFontconfigMatchFooter + kFontconfigFileFooter));
+
+  // Full hinting should be forced. See the comment in GetFontRenderParams() for
+  // more information.
+  FontRenderParams params = GetFontRenderParams(
+      FontRenderParamsQuery(), NULL);
+  EXPECT_FALSE(params.antialiasing);
+  EXPECT_EQ(FontRenderParams::HINTING_FULL, params.hinting);
+  EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_NONE,
+            params.subpixel_rendering);
+  EXPECT_FALSE(params.subpixel_positioning);
+}
+
+TEST_F(FontRenderParamsTest, ForceSubpixelPositioning) {
+  {
+    FontRenderParams params =
+        GetFontRenderParams(FontRenderParamsQuery(), NULL);
+    EXPECT_TRUE(params.antialiasing);
+    EXPECT_FALSE(params.subpixel_positioning);
+    SetFontRenderParamsDeviceScaleFactor(1.0f);
+  }
+  ClearFontRenderParamsCacheForTest();
+  SetFontRenderParamsDeviceScaleFactor(1.25f);
+  // Subpixel positioning should be forced.
+  {
+    FontRenderParams params =
+        GetFontRenderParams(FontRenderParamsQuery(), NULL);
+    EXPECT_TRUE(params.antialiasing);
+    EXPECT_TRUE(params.subpixel_positioning);
+    SetFontRenderParamsDeviceScaleFactor(1.0f);
+  }
+  ClearFontRenderParamsCacheForTest();
+  SetFontRenderParamsDeviceScaleFactor(2.f);
+  // Subpixel positioning should be forced on non-Chrome-OS.
+  {
+    FontRenderParams params =
+        GetFontRenderParams(FontRenderParamsQuery(), nullptr);
+    EXPECT_TRUE(params.antialiasing);
+#if !BUILDFLAG(IS_CHROMEOS_ASH)
+    EXPECT_TRUE(params.subpixel_positioning);
+#else
+    // Integral scale factor does not require subpixel positioning.
+    EXPECT_FALSE(params.subpixel_positioning);
+#endif  // !BUILDFLAG(IS_CHROMEOS_ASH)
+    SetFontRenderParamsDeviceScaleFactor(1.0f);
+  }
+}
+
+TEST_F(FontRenderParamsTest, OnlySetConfiguredValues) {
+  // Configure the SkiaFontDelegate (which queries GtkSettings on desktop
+  // Linux) to request subpixel rendering.
+  FontRenderParams system_params;
+  system_params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_RGB;
+  test_font_delegate_.set_params(system_params);
+
+  // Load a Fontconfig config that enables antialiasing but doesn't say anything
+  // about subpixel rendering.
+  ASSERT_TRUE(LoadConfigDataIntoFontconfig(
+      std::string(kFontconfigFileHeader) + kFontconfigMatchPatternHeader +
+          CreateFontconfigEditStanza("antialias", "bool", "true") +
+          kFontconfigMatchFooter + kFontconfigFileFooter));
+
+  // The subpixel rendering setting from the delegate should make it through.
+  FontRenderParams params = GetFontRenderParams(
+      FontRenderParamsQuery(), NULL);
+  EXPECT_EQ(system_params.subpixel_rendering, params.subpixel_rendering);
+}
+
+TEST_F(FontRenderParamsTest, NoFontconfigMatch) {
+  // A default configuration was set up globally.  Reset it to a blank config.
+  FcConfig* blank = FcConfigCreate();
+  OverrideGlobalFontConfigForTesting(blank);
+
+  FontRenderParams system_params;
+  system_params.antialiasing = true;
+  system_params.hinting = FontRenderParams::HINTING_MEDIUM;
+  system_params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_RGB;
+  test_font_delegate_.set_params(system_params);
+
+  FontRenderParamsQuery query;
+  query.families.push_back("Arimo");
+  query.families.push_back("Times New Roman");
+  query.pixel_size = 10;
+  std::string suggested_family;
+  FontRenderParams params = GetFontRenderParams(query, &suggested_family);
+
+  // The system params and the first requested family should be returned.
+  EXPECT_EQ(system_params.antialiasing, params.antialiasing);
+  EXPECT_EQ(system_params.hinting, params.hinting);
+  EXPECT_EQ(system_params.subpixel_rendering, params.subpixel_rendering);
+  EXPECT_EQ(query.families[0], suggested_family);
+
+  OverrideGlobalFontConfigForTesting(override_config_);
+  FcConfigDestroy(blank);
+}
+
+TEST_F(FontRenderParamsTest, MissingFamily) {
+  // With Arimo and Verdana installed, request (in order) Helvetica, Arimo, and
+  // Verdana and check that Arimo is returned.
+  FontRenderParamsQuery query;
+  query.families.push_back("Helvetica");
+  query.families.push_back("Arimo");
+  query.families.push_back("Verdana");
+  std::string suggested_family;
+  GetFontRenderParams(query, &suggested_family);
+  EXPECT_EQ("Arimo", suggested_family);
+}
+
+TEST_F(FontRenderParamsTest, SubstituteFamily) {
+  // Configure Fontconfig to use Tinos for both Helvetica and Arimo.
+  ASSERT_TRUE(LoadConfigDataIntoFontconfig(
+      std::string(kFontconfigFileHeader) +
+          CreateFontconfigAliasStanza("Helvetica", "Tinos") +
+          kFontconfigMatchPatternHeader +
+          CreateFontconfigTestStanza("family", "eq", "string", "Arimo") +
+          CreateFontconfigEditStanza("family", "string", "Tinos") +
+          kFontconfigMatchFooter + kFontconfigFileFooter));
+
+  FontRenderParamsQuery query;
+  query.families.push_back("Helvetica");
+  std::string suggested_family;
+  GetFontRenderParams(query, &suggested_family);
+  EXPECT_EQ("Tinos", suggested_family);
+
+  query.families.clear();
+  query.families.push_back("Arimo");
+  suggested_family.clear();
+  GetFontRenderParams(query, &suggested_family);
+  EXPECT_EQ("Tinos", suggested_family);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_render_params_mac.cc b/ui/gfx/font_render_params_mac.cc
new file mode 100644
index 0000000..03bf988
--- /dev/null
+++ b/ui/gfx/font_render_params_mac.cc
@@ -0,0 +1,42 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/font_render_params.h"
+
+#include "base/macros.h"
+#include "base/notreached.h"
+
+namespace gfx {
+
+namespace {
+
+// Returns params that match SkiaTextRenderer's default render settings.
+FontRenderParams LoadDefaults() {
+  FontRenderParams params;
+  params.antialiasing = true;
+  params.autohinter = false;
+  params.use_bitmaps = true;
+  params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_RGB;
+  params.subpixel_positioning = true;
+  params.hinting = FontRenderParams::HINTING_MEDIUM;
+
+  return params;
+}
+
+}  // namespace
+
+FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
+                                     std::string* family_out) {
+  if (family_out)
+    NOTIMPLEMENTED();
+  // TODO: Query the OS for font render settings instead of returning defaults.
+  static const gfx::FontRenderParams params(LoadDefaults());
+  return params;
+}
+
+float GetFontRenderParamsDeviceScaleFactor() {
+  return 1.0;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_render_params_skia.cc b/ui/gfx/font_render_params_skia.cc
new file mode 100644
index 0000000..7e8edf7
--- /dev/null
+++ b/ui/gfx/font_render_params_skia.cc
@@ -0,0 +1,54 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/font_render_params.h"
+
+#include "base/macros.h"
+#include "base/notreached.h"
+
+namespace gfx {
+
+namespace {
+
+// Returns the system's default settings.
+FontRenderParams LoadDefaults() {
+  FontRenderParams params;
+  params.antialiasing = true;
+  params.autohinter = true;
+  params.use_bitmaps = true;
+  params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_NONE;
+
+  // Use subpixel text positioning to keep consistent character spacing when
+  // the page is scaled by a fractional factor.
+  params.subpixel_positioning = true;
+  // Slight hinting renders much better than normal hinting on Android.
+  params.hinting = FontRenderParams::HINTING_SLIGHT;
+
+  return params;
+}
+
+// A device scale factor used to determine if subpixel positioning
+// should be used.
+float device_scale_factor_ = 1.0f;
+
+}  // namespace
+
+FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
+                                     std::string* family_out) {
+  if (family_out)
+    NOTIMPLEMENTED();
+  // Customized font rendering settings are not supported, only defaults.
+  static const gfx::FontRenderParams params(LoadDefaults());
+  return params;
+}
+
+float GetFontRenderParamsDeviceScaleFactor() {
+  return device_scale_factor_;
+}
+
+void SetFontRenderParamsDeviceScaleFactor(float device_scale_factor) {
+  device_scale_factor_ = device_scale_factor;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_render_params_win.cc b/ui/gfx/font_render_params_win.cc
new file mode 100644
index 0000000..1369f8a
--- /dev/null
+++ b/ui/gfx/font_render_params_win.cc
@@ -0,0 +1,120 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/font_render_params.h"
+
+#include <memory>
+
+#include "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/files/file_path.h"
+#include "base/macros.h"
+#include "base/memory/singleton.h"
+#include "base/win/registry.h"
+#include "ui/gfx/win/singleton_hwnd_observer.h"
+
+namespace gfx {
+
+namespace {
+
+FontRenderParams::SubpixelRendering GetSubpixelRenderingGeometry() {
+  DISPLAY_DEVICE display_device = {sizeof(DISPLAY_DEVICE)};
+  for (int i = 0; EnumDisplayDevices(nullptr, i, &display_device, 0); ++i) {
+    // TODO(scottmg): We only support the primary device currently.
+    if (display_device.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
+      base::FilePath trimmed =
+          base::FilePath(display_device.DeviceName).BaseName();
+      base::win::RegKey key(
+          HKEY_LOCAL_MACHINE,
+          (L"SOFTWARE\\Microsoft\\Avalon.Graphics\\" + trimmed.value()).c_str(),
+          KEY_READ);
+      DWORD pixel_structure;
+      if (key.ReadValueDW(L"PixelStructure", &pixel_structure) ==
+          ERROR_SUCCESS) {
+        if (pixel_structure == 1)
+          return FontRenderParams::SUBPIXEL_RENDERING_RGB;
+        if (pixel_structure == 2)
+          return FontRenderParams::SUBPIXEL_RENDERING_BGR;
+      }
+      break;
+    }
+  }
+
+  // No explicit ClearType settings, default to RGB.
+  return FontRenderParams::SUBPIXEL_RENDERING_RGB;
+}
+
+// Caches font render params and updates them on system notifications.
+class CachedFontRenderParams {
+ public:
+  static CachedFontRenderParams* GetInstance() {
+    return base::Singleton<CachedFontRenderParams>::get();
+  }
+
+  CachedFontRenderParams(const CachedFontRenderParams&) = delete;
+  CachedFontRenderParams& operator=(const CachedFontRenderParams&) = delete;
+
+  const FontRenderParams& GetParams() {
+    if (params_)
+      return *params_;
+
+    params_ = std::make_unique<FontRenderParams>();
+    params_->antialiasing = false;
+    params_->subpixel_positioning = false;
+    params_->autohinter = false;
+    params_->use_bitmaps = false;
+    params_->hinting = FontRenderParams::HINTING_MEDIUM;
+    params_->subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_NONE;
+
+    BOOL enabled = false;
+    if (SystemParametersInfo(SPI_GETFONTSMOOTHING, 0, &enabled, 0) && enabled) {
+      params_->antialiasing = true;
+      params_->subpixel_positioning = true;
+
+      UINT type = 0;
+      if (SystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE, 0, &type, 0) &&
+          type == FE_FONTSMOOTHINGCLEARTYPE) {
+        params_->subpixel_rendering = GetSubpixelRenderingGeometry();
+      }
+    }
+    singleton_hwnd_observer_ =
+        std::make_unique<SingletonHwndObserver>(base::BindRepeating(
+            &CachedFontRenderParams::OnWndProc, base::Unretained(this)));
+    return *params_;
+  }
+
+ private:
+  friend struct base::DefaultSingletonTraits<CachedFontRenderParams>;
+
+  CachedFontRenderParams() {}
+  ~CachedFontRenderParams() {}
+
+  void OnWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+    if (message == WM_SETTINGCHANGE) {
+      // TODO(khushalsagar): This should trigger an update to the
+      // renderer and gpu processes, where the params are cached.
+      params_.reset();
+      singleton_hwnd_observer_.reset(nullptr);
+    }
+  }
+
+  std::unique_ptr<FontRenderParams> params_;
+  std::unique_ptr<SingletonHwndObserver> singleton_hwnd_observer_;
+};
+
+}  // namespace
+
+FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
+                                     std::string* family_out) {
+  if (family_out)
+    NOTIMPLEMENTED();
+  // Customized font rendering settings are not supported, only defaults.
+  return CachedFontRenderParams::GetInstance()->GetParams();
+}
+
+float GetFontRenderParamsDeviceScaleFactor() {
+  return 1.;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_unittest.cc b/ui/gfx/font_unittest.cc
new file mode 100644
index 0000000..c71929d
--- /dev/null
+++ b/ui/gfx/font_unittest.cc
@@ -0,0 +1,181 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/font.h"
+
+#include <string>
+
+#include "base/macros.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font_names_testing.h"
+
+#if defined(OS_WIN)
+#include "ui/gfx/system_fonts_win.h"
+#endif
+
+namespace gfx {
+namespace {
+
+class FontTest : public testing::Test {
+ public:
+  FontTest() = default;
+
+  FontTest(const FontTest&) = delete;
+  FontTest& operator=(const FontTest&) = delete;
+
+ protected:
+  void SetUp() override {
+#if defined(OS_WIN)
+    // System fonts is keeping a cache of loaded system fonts. These fonts are
+    // scaled based on global callbacks configured on startup. The tests in this
+    // file are testing these callbacks and need to be sure we cleared the
+    // global state to avoid flaky tests.
+    win::ResetSystemFontsForTesting();
+#endif
+  }
+};
+
+TEST_F(FontTest, DefaultFont) {
+  Font cf;
+  EXPECT_EQ(cf.GetStyle(), Font::NORMAL);
+  EXPECT_EQ(cf.GetWeight(), Font::Weight::NORMAL);
+  // Ensures that font metrics are generated. Some fonts backends do not provide
+  // some metrics (e.g. DWrite do not produce average character width).
+  EXPECT_GT(cf.GetFontSize(), 0);
+  EXPECT_GT(cf.GetHeight(), 0);
+  EXPECT_GT(cf.GetBaseline(), 0);
+  EXPECT_GT(cf.GetCapHeight(), 0);
+  EXPECT_GT(cf.GetExpectedTextWidth(1), 0);
+}
+
+TEST_F(FontTest, LoadArial) {
+  Font cf(kTestFontName, 16);
+#if defined(OS_APPLE)
+  EXPECT_TRUE(cf.GetNativeFont());
+#endif
+  EXPECT_EQ(cf.GetStyle(), Font::NORMAL);
+  EXPECT_EQ(cf.GetFontSize(), 16);
+  EXPECT_EQ(cf.GetFontName(), kTestFontName);
+  EXPECT_EQ(base::ToLowerASCII(kTestFontName),
+            base::ToLowerASCII(cf.GetActualFontName()));
+}
+
+TEST_F(FontTest, LoadArialBold) {
+  Font cf(kTestFontName, 16);
+  Font bold(cf.Derive(0, Font::NORMAL, Font::Weight::BOLD));
+#if defined(OS_APPLE)
+  EXPECT_TRUE(bold.GetNativeFont());
+#endif
+  EXPECT_EQ(bold.GetStyle(), Font::NORMAL);
+  EXPECT_EQ(bold.GetWeight(), Font::Weight::BOLD);
+  EXPECT_EQ(base::ToLowerASCII(kTestFontName),
+            base::ToLowerASCII(cf.GetActualFontName()));
+}
+
+TEST_F(FontTest, Ascent) {
+  Font cf(kTestFontName, 16);
+  EXPECT_GT(cf.GetBaseline(), 2);
+  EXPECT_LE(cf.GetBaseline(), 22);
+}
+
+TEST_F(FontTest, Height) {
+  Font cf(kTestFontName, 16);
+  EXPECT_GE(cf.GetHeight(), 16);
+  // TODO(akalin): Figure out why height is so large on Linux.
+  EXPECT_LE(cf.GetHeight(), 26);
+}
+
+TEST_F(FontTest, CapHeight) {
+  Font cf(kTestFontName, 16);
+  EXPECT_GT(cf.GetCapHeight(), 0);
+  EXPECT_GT(cf.GetCapHeight(), cf.GetHeight() / 2);
+  EXPECT_LT(cf.GetCapHeight(), cf.GetBaseline());
+}
+
+TEST_F(FontTest, AvgWidths) {
+  Font cf(kTestFontName, 16);
+  EXPECT_EQ(cf.GetExpectedTextWidth(0), 0);
+  EXPECT_GT(cf.GetExpectedTextWidth(1), cf.GetExpectedTextWidth(0));
+  EXPECT_GT(cf.GetExpectedTextWidth(2), cf.GetExpectedTextWidth(1));
+  EXPECT_GT(cf.GetExpectedTextWidth(3), cf.GetExpectedTextWidth(2));
+}
+
+// Check that fonts used for testing are installed and enabled. On Mac
+// fonts may be installed but still need enabling in Font Book.app.
+// http://crbug.com/347429
+TEST_F(FontTest, GetActualFontName) {
+  Font arial(kTestFontName, 16);
+  EXPECT_EQ(base::ToLowerASCII(kTestFontName),
+            base::ToLowerASCII(arial.GetActualFontName()))
+      << "********\n"
+      << "Your test environment seems to be missing Arial font, which is "
+      << "needed for unittests.  Check if Arial font is installed.\n"
+      << "********";
+  Font symbol(kSymbolFontName, 16);
+  EXPECT_EQ(base::ToLowerASCII(kSymbolFontName),
+            base::ToLowerASCII(symbol.GetActualFontName()))
+      << "********\n"
+      << "Your test environment seems to be missing the " << kSymbolFontName
+      << " font, which is "
+      << "needed for unittests.  Check if " << kSymbolFontName
+      << " font is installed.\n"
+      << "********";
+
+  const char* const invalid_font_name = "no_such_font_name";
+  Font fallback_font(invalid_font_name, 16);
+  EXPECT_NE(invalid_font_name,
+            base::ToLowerASCII(fallback_font.GetActualFontName()));
+}
+
+TEST_F(FontTest, DeriveFont) {
+  Font cf(kTestFontName, 8);
+  const int kSizeDelta = 2;
+  Font cf_underlined =
+      cf.Derive(0, cf.GetStyle() | gfx::Font::UNDERLINE, cf.GetWeight());
+  Font cf_underlined_resized = cf_underlined.Derive(
+      kSizeDelta, cf_underlined.GetStyle(), cf_underlined.GetWeight());
+  EXPECT_EQ(cf.GetStyle() | gfx::Font::UNDERLINE,
+            cf_underlined_resized.GetStyle());
+  EXPECT_EQ(cf.GetFontSize() + kSizeDelta, cf_underlined_resized.GetFontSize());
+  EXPECT_EQ(cf.GetWeight(), cf_underlined_resized.GetWeight());
+}
+
+#if defined(OS_WIN)
+TEST_F(FontTest, DeriveResizesIfSizeTooSmall) {
+  Font cf(kTestFontName, 8);
+  gfx::win::SetGetMinimumFontSizeCallback([] { return 5; });
+
+  Font derived_font = cf.Derive(-4, cf.GetStyle(), cf.GetWeight());
+  EXPECT_EQ(5, derived_font.GetFontSize());
+}
+
+TEST_F(FontTest, DeriveKeepsOriginalSizeIfHeightOk) {
+  Font cf(kTestFontName, 8);
+  gfx::win::SetGetMinimumFontSizeCallback([] { return 5; });
+
+  Font derived_font = cf.Derive(-2, cf.GetStyle(), cf.GetWeight());
+  EXPECT_EQ(6, derived_font.GetFontSize());
+}
+#endif  // defined(OS_WIN)
+
+TEST_F(FontTest, WeightConversion) {
+  struct WeightMatchExpectation {
+    int weight;
+    Font::Weight enum_value;
+  } expectations[] = {
+      {-10, Font::Weight::INVALID}, {-1, Font::Weight::INVALID},
+      {0, Font::Weight::THIN},      {1, Font::Weight::THIN},
+      {100, Font::Weight::THIN},    {350, Font::Weight::NORMAL},
+      {400, Font::Weight::NORMAL},  {899, Font::Weight::BLACK},
+      {900, Font::Weight::BLACK},   {901, Font::Weight::INVALID}};
+  for (const auto& expectation : expectations) {
+    EXPECT_EQ(FontWeightFromInt(expectation.weight), expectation.enum_value);
+  }
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/font_util.cc b/ui/gfx/font_util.cc
new file mode 100644
index 0000000..faf6dd7
--- /dev/null
+++ b/ui/gfx/font_util.cc
@@ -0,0 +1,38 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/font_util.h"
+
+#include "build/build_config.h"
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+#include <fontconfig/fontconfig.h>
+#include "ui/gfx/linux/fontconfig_util.h"
+#endif
+
+#if defined(OS_WIN)
+#include "ui/gfx/win/direct_write.h"
+#endif
+
+namespace gfx {
+
+void InitializeFonts() {
+  // Implicit initialization can cause a long delay on the first rendering if
+  // the font cache has to be regenerated for some reason. Doing it explicitly
+  // here helps in cases where the browser process is starting up in the
+  // background (resources have not yet been granted to cast) since it prevents
+  // the long delay the user would have seen on first rendering.
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  // Ensures the config is created on this thread.
+  FcConfig* config = GetGlobalFontConfig();
+  DCHECK(config);
+#endif  // defined(OS_LINUX) || defined(OS_CHROMEOS)
+
+#if defined(OS_WIN)
+  gfx::win::InitializeDirectWrite();
+#endif  // OS_WIN
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/font_util.h b/ui/gfx/font_util.h
new file mode 100644
index 0000000..0ceac62
--- /dev/null
+++ b/ui/gfx/font_util.h
@@ -0,0 +1,17 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_FONT_UTIL_H_
+#define UI_GFX_FONT_UTIL_H_
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Initialize the library fonts.
+GFX_EXPORT void InitializeFonts();
+
+}  // namespace gfx
+
+#endif  // UI_GFX_FONT_UTIL_H_
diff --git a/ui/gfx/gdi_util.cc b/ui/gfx/gdi_util.cc
new file mode 100644
index 0000000..abfc3cb
--- /dev/null
+++ b/ui/gfx/gdi_util.cc
@@ -0,0 +1,57 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/gdi_util.h"
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <memory>
+
+#include "skia/ext/skia_utils_win.h"
+
+namespace gfx {
+
+void CreateBitmapV4HeaderForARGB888(int width,
+                                    int height,
+                                    BITMAPV4HEADER* hdr) {
+  // Because bmp v4 header is just an extension, we just create a v3 header and
+  // copy the bits over to the v4 header.
+  BITMAPINFOHEADER header_v3;
+  skia::CreateBitmapHeaderForXRGB888(width, height, &header_v3);
+  memset(hdr, 0, sizeof(BITMAPV4HEADER));
+  memcpy(hdr, &header_v3, sizeof(BITMAPINFOHEADER));
+
+  // Correct the size of the header and fill in the mask values.
+  hdr->bV4Size = sizeof(BITMAPV4HEADER);
+  hdr->bV4RedMask   = 0x00ff0000;
+  hdr->bV4GreenMask = 0x0000ff00;
+  hdr->bV4BlueMask  = 0x000000ff;
+  hdr->bV4AlphaMask = 0xff000000;
+}
+
+float CalculatePageScale(HDC dc, int page_width, int page_height) {
+  int dc_width = GetDeviceCaps(dc, HORZRES);
+  int dc_height = GetDeviceCaps(dc, VERTRES);
+
+  // If page fits DC - no scaling needed.
+  if (dc_width >= page_width && dc_height >= page_height)
+    return 1.0;
+
+  float x_factor =
+      static_cast<float>(dc_width) / static_cast<float>(page_width);
+  float y_factor =
+      static_cast<float>(dc_height) / static_cast<float>(page_height);
+  return std::min(x_factor, y_factor);
+}
+
+// Apply scaling to the DC.
+bool ScaleDC(HDC dc, float scale_factor) {
+  SetGraphicsMode(dc, GM_ADVANCED);
+  XFORM xform = {0};
+  xform.eM11 = xform.eM22 = scale_factor;
+  return !!ModifyWorldTransform(dc, &xform, MWT_LEFTMULTIPLY);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/gdi_util.h b/ui/gfx/gdi_util.h
new file mode 100644
index 0000000..5b9af51
--- /dev/null
+++ b/ui/gfx/gdi_util.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GDI_UTIL_H_
+#define UI_GFX_GDI_UTIL_H_
+
+#include <windows.h>
+
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Creates a BITMAPV4HEADER structure given the bitmap's size.  You probably
+// only need to use BMP V4 if you need transparency (alpha channel). This
+// function sets the AlphaMask to 0xff000000, meaning this header is for a
+// 32-bits-per-pixel ARGB8888 bitmap.
+GFX_EXPORT void CreateBitmapV4HeaderForARGB888(int width,
+                                               int height,
+                                               BITMAPV4HEADER* hdr);
+
+// Calculate scale to fit an entire page on DC.
+GFX_EXPORT float CalculatePageScale(HDC dc, int page_width, int page_height);
+
+// Apply scaling to the DC.
+GFX_EXPORT bool ScaleDC(HDC dc, float scale_factor);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GDI_UTIL_H_
diff --git a/ui/gfx/generic_shared_memory_id.cc b/ui/gfx/generic_shared_memory_id.cc
new file mode 100644
index 0000000..e9ed1c9
--- /dev/null
+++ b/ui/gfx/generic_shared_memory_id.cc
@@ -0,0 +1,21 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/generic_shared_memory_id.h"
+
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+base::trace_event::MemoryAllocatorDumpGuid
+GetGenericSharedGpuMemoryGUIDForTracing(
+    uint64_t tracing_process_id,
+    GenericSharedMemoryId generic_shared_memory_id) {
+  return base::trace_event::MemoryAllocatorDumpGuid(
+      base::StringPrintf("genericsharedmemory-x-process/%" PRIx64 "/%d",
+                         tracing_process_id, generic_shared_memory_id.id));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/generic_shared_memory_id.h b/ui/gfx/generic_shared_memory_id.h
new file mode 100644
index 0000000..39c53e0
--- /dev/null
+++ b/ui/gfx/generic_shared_memory_id.h
@@ -0,0 +1,72 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GENERIC_SHARED_MEMORY_ID_H_
+#define UI_GFX_GENERIC_SHARED_MEMORY_ID_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <functional>
+
+#include "base/hash/hash.h"
+#include "base/trace_event/memory_allocator_dump.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Defines an ID type which is used across all types of shared memory
+// allocations in content/. This ID type is in ui/gfx, as components outside
+// content/ may need to hold an ID (but should not generate one).
+class GFX_EXPORT GenericSharedMemoryId {
+ public:
+  int id;
+
+  // Invalid ID is -1 to match semantics of base::AtomicSequenceNumber.
+  GenericSharedMemoryId() : id(-1) {}
+  explicit GenericSharedMemoryId(int id) : id(id) {}
+  GenericSharedMemoryId(const GenericSharedMemoryId& other) = default;
+  GenericSharedMemoryId& operator=(const GenericSharedMemoryId& other) =
+      default;
+
+  bool is_valid() const { return id >= 0; }
+
+  bool operator==(const GenericSharedMemoryId& other) const {
+    return id == other.id;
+  }
+
+  bool operator<(const GenericSharedMemoryId& other) const {
+    return id < other.id;
+  }
+};
+
+// Generates GUID which can be used to trace shared memory using its
+// GenericSharedMemoryId.
+GFX_EXPORT base::trace_event::MemoryAllocatorDumpGuid
+GetGenericSharedGpuMemoryGUIDForTracing(
+    uint64_t tracing_process_id,
+    GenericSharedMemoryId generic_shared_memory_id);
+
+}  // namespace gfx
+
+namespace std {
+
+template <>
+struct hash<gfx::GenericSharedMemoryId> {
+  size_t operator()(gfx::GenericSharedMemoryId key) const {
+    return std::hash<int>()(key.id);
+  }
+};
+
+template <typename Second>
+struct hash<std::pair<gfx::GenericSharedMemoryId, Second>> {
+  size_t operator()(
+      const std::pair<gfx::GenericSharedMemoryId, Second>& pair) const {
+    return base::HashInts(pair.first.id, pair.second);
+  }
+};
+
+}  // namespace std
+
+#endif  // UI_GFX_GENERIC_SHARED_MEMORY_ID_H_
diff --git a/ui/gfx/geometry/BUILD.gn b/ui/gfx/geometry/BUILD.gn
new file mode 100644
index 0000000..abc446c
--- /dev/null
+++ b/ui/gfx/geometry/BUILD.gn
@@ -0,0 +1,101 @@
+# Copyright 2014 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.
+
+component("geometry") {
+  sources = [
+    "../gfx_export.h",
+    "angle_conversions.h",
+    "axis_transform2d.cc",
+    "axis_transform2d.h",
+    "box_f.cc",
+    "box_f.h",
+    "cubic_bezier.cc",
+    "cubic_bezier.h",
+    "dip_util.cc",
+    "dip_util.h",
+    "geometry_export.h",
+    "insets.cc",
+    "insets.h",
+    "insets_conversions.cc",
+    "insets_conversions.h",
+    "insets_f.cc",
+    "insets_f.h",
+    "matrix3_f.cc",
+    "matrix3_f.h",
+    "point.cc",
+    "point.h",
+    "point3_f.cc",
+    "point3_f.h",
+    "point_conversions.cc",
+    "point_conversions.h",
+    "point_f.cc",
+    "point_f.h",
+    "quad_f.cc",
+    "quad_f.h",
+    "quaternion.cc",
+    "quaternion.h",
+    "rect.cc",
+    "rect.h",
+    "rect_conversions.cc",
+    "rect_conversions.h",
+    "rect_f.cc",
+    "rect_f.h",
+    "resize_utils.cc",
+    "resize_utils.h",
+    "rounded_corners_f.cc",
+    "rounded_corners_f.h",
+    "size.cc",
+    "size.h",
+    "size_conversions.cc",
+    "size_conversions.h",
+    "size_f.cc",
+    "size_f.h",
+    "vector2d.cc",
+    "vector2d.h",
+    "vector2d_conversions.cc",
+    "vector2d_conversions.h",
+    "vector2d_f.cc",
+    "vector2d_f.h",
+    "vector3d_f.cc",
+    "vector3d_f.h",
+  ]
+
+  defines = [ "GEOMETRY_IMPLEMENTATION" ]
+
+  deps = [ "//base" ]
+
+  if (!is_debug) {
+    configs -= [ "//build/config/compiler:default_optimization" ]
+    configs += [ "//build/config/compiler:optimize_max" ]
+  }
+}
+
+component("geometry_skia") {
+  sources = [
+    "geometry_skia_export.h",
+    "mask_filter_info.cc",
+    "mask_filter_info.h",
+    "rrect_f.cc",
+    "rrect_f.h",
+    "rrect_f_builder.cc",
+    "rrect_f_builder.h",
+    "skia_conversions.cc",
+    "skia_conversions.h",
+    "transform.cc",
+    "transform.h",
+    "transform_operation.cc",
+    "transform_operation.h",
+    "transform_operations.cc",
+    "transform_operations.h",
+    "transform_util.cc",
+    "transform_util.h",
+  ]
+  configs += [ "//build/config/compiler:wexit_time_destructors" ]
+  public_deps = [
+    ":geometry",
+    "//base",
+    "//skia",
+  ]
+  defines = [ "GEOMETRY_SKIA_IMPLEMENTATION" ]
+}
diff --git a/ui/gfx/geometry/OWNERS b/ui/gfx/geometry/OWNERS
new file mode 100644
index 0000000..3aaf7a7
--- /dev/null
+++ b/ui/gfx/geometry/OWNERS
@@ -0,0 +1,5 @@
+danakj@chromium.org
+vollick@chromium.org
+
+per-file cubic_bezier*=ajuma@chromium.org
+per-file box*=ajuma@chromium.org
diff --git a/ui/gfx/geometry/angle_conversions.h b/ui/gfx/geometry/angle_conversions.h
new file mode 100644
index 0000000..876ad5c
--- /dev/null
+++ b/ui/gfx/geometry/angle_conversions.h
@@ -0,0 +1,29 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_ANGLE_CONVERSIONS_H_
+#define UI_GFX_GEOMETRY_ANGLE_CONVERSIONS_H_
+
+#include "base/numerics/math_constants.h"
+#include "ui/gfx/geometry/geometry_export.h"
+
+namespace gfx {
+
+GEOMETRY_EXPORT constexpr double DegToRad(double deg) {
+  return deg * base::kPiDouble / 180.0;
+}
+GEOMETRY_EXPORT constexpr float DegToRad(float deg) {
+  return deg * base::kPiFloat / 180.0f;
+}
+
+GEOMETRY_EXPORT constexpr double RadToDeg(double rad) {
+  return rad * 180.0 / base::kPiDouble;
+}
+GEOMETRY_EXPORT constexpr float RadToDeg(float rad) {
+  return rad * 180.0f / base::kPiFloat;
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_ANGLE_CONVERSIONS_H_
diff --git a/ui/gfx/geometry/axis_transform2d.cc b/ui/gfx/geometry/axis_transform2d.cc
new file mode 100644
index 0000000..fb2bb42
--- /dev/null
+++ b/ui/gfx/geometry/axis_transform2d.cc
@@ -0,0 +1,16 @@
+// 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.
+
+#include "ui/gfx/geometry/axis_transform2d.h"
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+std::string AxisTransform2d::ToString() const {
+  return base::StringPrintf("[%s, %s]", scale_.ToString().c_str(),
+                            translation_.ToString().c_str());
+}
+
+}  // namespace gfx
\ No newline at end of file
diff --git a/ui/gfx/geometry/axis_transform2d.h b/ui/gfx/geometry/axis_transform2d.h
new file mode 100644
index 0000000..3e74fca
--- /dev/null
+++ b/ui/gfx/geometry/axis_transform2d.h
@@ -0,0 +1,144 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_AXIS_TRANSFORM2D_H_
+#define UI_GFX_GEOMETRY_AXIS_TRANSFORM2D_H_
+
+#include "base/check_op.h"
+#include "ui/gfx/geometry/geometry_export.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace gfx {
+
+// This class implements the subset of 2D linear transforms that only
+// translation and uniform scaling are allowed.
+// Internally this is stored as a vector for pre-scale, and another vector
+// for post-translation. The class constructor and member accessor follows
+// the same convention, but a scalar scale factor is also accepted.
+class GEOMETRY_EXPORT AxisTransform2d {
+ public:
+  constexpr AxisTransform2d() = default;
+  constexpr AxisTransform2d(float scale, const Vector2dF& translation)
+      : scale_(scale, scale), translation_(translation) {}
+  constexpr AxisTransform2d(const Vector2dF& scale,
+                            const Vector2dF& translation)
+      : scale_(scale), translation_(translation) {}
+
+  bool operator==(const AxisTransform2d& other) const {
+    return scale_ == other.scale_ && translation_ == other.translation_;
+  }
+  bool operator!=(const AxisTransform2d& other) const {
+    return !(*this == other);
+  }
+
+  void PreScale(const Vector2dF& scale) { scale_.Scale(scale.x(), scale.y()); }
+  void PostScale(const Vector2dF& scale) {
+    scale_.Scale(scale.x(), scale.y());
+    translation_.Scale(scale.x(), scale.y());
+  }
+  void PreTranslate(const Vector2dF& translation) {
+    translation_ += ScaleVector2d(translation, scale_.x(), scale_.y());
+  }
+  void PostTranslate(const Vector2dF& translation) {
+    translation_ += translation;
+  }
+
+  void PreConcat(const AxisTransform2d& pre) {
+    PreTranslate(pre.translation_);
+    PreScale(pre.scale_);
+  }
+  void PostConcat(const AxisTransform2d& post) {
+    PostScale(post.scale_);
+    PostTranslate(post.translation_);
+  }
+
+  void Invert() {
+    DCHECK(scale_.x());
+    DCHECK(scale_.y());
+    scale_ = Vector2dF(1.f / scale_.x(), 1.f / scale_.y());
+    translation_.Scale(-scale_.x(), -scale_.y());
+  }
+
+  PointF MapPoint(const PointF& p) const {
+    return ScalePoint(p, scale_.x(), scale_.y()) + translation_;
+  }
+  PointF InverseMapPoint(const PointF& p) const {
+    return ScalePoint(p - translation_, 1.f / scale_.x(), 1.f / scale_.y());
+  }
+
+  RectF MapRect(const RectF& r) const {
+    DCHECK_GE(scale_.x(), 0.f);
+    DCHECK_GE(scale_.y(), 0.f);
+    return ScaleRect(r, scale_.x(), scale_.y()) + translation_;
+  }
+  RectF InverseMapRect(const RectF& r) const {
+    DCHECK_GT(scale_.x(), 0.f);
+    DCHECK_GT(scale_.y(), 0.f);
+    return ScaleRect(r - translation_, 1.f / scale_.x(), 1.f / scale_.y());
+  }
+
+  const Vector2dF& scale() const { return scale_; }
+  const Vector2dF& translation() const { return translation_; }
+
+  std::string ToString() const;
+
+ private:
+  // Scale is applied before translation, i.e.
+  // this->Transform(p) == scale_ * p + translation_
+  Vector2dF scale_{1.f, 1.f};
+  Vector2dF translation_;
+};
+
+inline AxisTransform2d PreScaleAxisTransform2d(const AxisTransform2d& t,
+                                               float scale) {
+  AxisTransform2d result(t);
+  result.PreScale(Vector2dF(scale, scale));
+  return result;
+}
+
+inline AxisTransform2d PostScaleAxisTransform2d(const AxisTransform2d& t,
+                                                float scale) {
+  AxisTransform2d result(t);
+  result.PostScale(Vector2dF(scale, scale));
+  return result;
+}
+
+inline AxisTransform2d PreTranslateAxisTransform2d(
+    const AxisTransform2d& t,
+    const Vector2dF& translation) {
+  AxisTransform2d result(t);
+  result.PreTranslate(translation);
+  return result;
+}
+
+inline AxisTransform2d PostTranslateAxisTransform2d(
+    const AxisTransform2d& t,
+    const Vector2dF& translation) {
+  AxisTransform2d result(t);
+  result.PostTranslate(translation);
+  return result;
+}
+
+inline AxisTransform2d ConcatAxisTransform2d(const AxisTransform2d& post,
+                                             const AxisTransform2d& pre) {
+  AxisTransform2d result(post);
+  result.PreConcat(pre);
+  return result;
+}
+
+inline AxisTransform2d InvertAxisTransform2d(const AxisTransform2d& t) {
+  AxisTransform2d result = t;
+  result.Invert();
+  return result;
+}
+
+// This is declared here for use in gtest-based unit tests but is defined in
+// the //ui/gfx:test_support target. Depend on that to use this in your unit
+// test. This should not be used in production code - call ToString() instead.
+void PrintTo(const AxisTransform2d&, ::std::ostream* os);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_AXIS_TRANSFORM2D_H_
diff --git a/ui/gfx/geometry/axis_transform2d_unittest.cc b/ui/gfx/geometry/axis_transform2d_unittest.cc
new file mode 100644
index 0000000..6bee3da
--- /dev/null
+++ b/ui/gfx/geometry/axis_transform2d_unittest.cc
@@ -0,0 +1,91 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/geometry/axis_transform2d.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/test/gfx_util.h"
+
+namespace gfx {
+namespace {
+
+TEST(AxisTransform2dTest, Mapping) {
+  AxisTransform2d t(1.25f, Vector2dF(3.75f, 55.f));
+
+  PointF p(150.f, 100.f);
+  EXPECT_EQ(PointF(191.25f, 180.f), t.MapPoint(p));
+  EXPECT_POINTF_EQ(PointF(117.f, 36.f), t.InverseMapPoint(p));
+
+  RectF r(150.f, 100.f, 22.5f, 37.5f);
+  EXPECT_EQ(RectF(191.25f, 180.f, 28.125f, 46.875f), t.MapRect(r));
+  EXPECT_RECTF_EQ(RectF(117.f, 36.f, 18.f, 30.f), t.InverseMapRect(r));
+}
+
+TEST(AxisTransform2dTest, Scaling) {
+  {
+    AxisTransform2d t(1.25f, Vector2dF(3.75f, 55.f));
+    EXPECT_EQ(AxisTransform2d(1.5625f, Vector2dF(3.75f, 55.f)),
+              PreScaleAxisTransform2d(t, 1.25));
+    t.PreScale(Vector2dF(1.25f, 1.25f));
+    EXPECT_EQ(AxisTransform2d(1.5625f, Vector2dF(3.75f, 55.f)), t);
+  }
+
+  {
+    AxisTransform2d t(1.25f, Vector2dF(3.75f, 55.f));
+    EXPECT_EQ(AxisTransform2d(1.5625f, Vector2dF(4.6875f, 68.75f)),
+              PostScaleAxisTransform2d(t, 1.25));
+    t.PostScale(Vector2dF(1.25f, 1.25f));
+    EXPECT_EQ(AxisTransform2d(1.5625f, Vector2dF(4.6875f, 68.75f)), t);
+  }
+}
+
+TEST(AxisTransform2dTest, Translating) {
+  Vector2dF tr(3.f, -5.f);
+  {
+    AxisTransform2d t(1.25f, Vector2dF(3.75f, 55.f));
+    EXPECT_EQ(AxisTransform2d(1.25f, Vector2dF(7.5f, 48.75f)),
+              PreTranslateAxisTransform2d(t, tr));
+    t.PreTranslate(tr);
+    EXPECT_EQ(AxisTransform2d(1.25f, Vector2dF(7.5f, 48.75f)), t);
+  }
+
+  {
+    AxisTransform2d t(1.25f, Vector2dF(3.75f, 55.f));
+    EXPECT_EQ(AxisTransform2d(1.25f, Vector2dF(6.75f, 50.f)),
+              PostTranslateAxisTransform2d(t, tr));
+    t.PostTranslate(tr);
+    EXPECT_EQ(AxisTransform2d(1.25f, Vector2dF(6.75f, 50.f)), t);
+  }
+}
+
+TEST(AxisTransform2dTest, Concat) {
+  AxisTransform2d pre(1.25f, Vector2dF(3.75f, 55.f));
+  AxisTransform2d post(0.5f, Vector2dF(10.f, 5.f));
+  AxisTransform2d expectation(0.625f, Vector2dF(11.875f, 32.5f));
+  EXPECT_EQ(expectation, ConcatAxisTransform2d(post, pre));
+
+  AxisTransform2d post_concat = pre;
+  post_concat.PostConcat(post);
+  EXPECT_EQ(expectation, post_concat);
+
+  AxisTransform2d pre_concat = post;
+  pre_concat.PreConcat(pre);
+  EXPECT_EQ(expectation, pre_concat);
+}
+
+TEST(AxisTransform2dTest, Inverse) {
+  AxisTransform2d t(1.25f, Vector2dF(3.75f, 55.f));
+  AxisTransform2d inv_inplace = t;
+  inv_inplace.Invert();
+  AxisTransform2d inv_out_of_place = InvertAxisTransform2d(t);
+
+  EXPECT_AXIS_TRANSFORM2D_EQ(inv_inplace, inv_out_of_place);
+  EXPECT_AXIS_TRANSFORM2D_EQ(AxisTransform2d(),
+                             ConcatAxisTransform2d(t, inv_inplace));
+  EXPECT_AXIS_TRANSFORM2D_EQ(AxisTransform2d(),
+                             ConcatAxisTransform2d(inv_inplace, t));
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/geometry/box_f.cc b/ui/gfx/geometry/box_f.cc
new file mode 100644
index 0000000..d942b70
--- /dev/null
+++ b/ui/gfx/geometry/box_f.cc
@@ -0,0 +1,70 @@
+// 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.
+
+#include "ui/gfx/geometry/box_f.h"
+
+#include <algorithm>
+
+#include "base/check_op.h"
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+std::string BoxF::ToString() const {
+  return base::StringPrintf("%s %fx%fx%f",
+                            origin().ToString().c_str(),
+                            width_,
+                            height_,
+                            depth_);
+}
+
+bool BoxF::IsEmpty() const {
+  return (width_ == 0 && height_ == 0) ||
+         (width_ == 0 && depth_ == 0) ||
+         (height_ == 0 && depth_ == 0);
+}
+
+void BoxF::ExpandTo(const Point3F& min, const Point3F& max) {
+  DCHECK_LE(min.x(), max.x());
+  DCHECK_LE(min.y(), max.y());
+  DCHECK_LE(min.z(), max.z());
+
+  float min_x = std::min(x(), min.x());
+  float min_y = std::min(y(), min.y());
+  float min_z = std::min(z(), min.z());
+  float max_x = std::max(right(), max.x());
+  float max_y = std::max(bottom(), max.y());
+  float max_z = std::max(front(), max.z());
+
+  origin_.SetPoint(min_x, min_y, min_z);
+  width_ = max_x - min_x;
+  height_ = max_y - min_y;
+  depth_ = max_z - min_z;
+}
+
+void BoxF::Union(const BoxF& box) {
+  if (IsEmpty()) {
+    *this = box;
+    return;
+  }
+  if (box.IsEmpty())
+    return;
+  ExpandTo(box);
+}
+
+void BoxF::ExpandTo(const Point3F& point) {
+  ExpandTo(point, point);
+}
+
+void BoxF::ExpandTo(const BoxF& box) {
+  ExpandTo(box.origin(), gfx::Point3F(box.right(), box.bottom(), box.front()));
+}
+
+BoxF UnionBoxes(const BoxF& a, const BoxF& b) {
+  BoxF result = a;
+  result.Union(b);
+  return result;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/box_f.h b/ui/gfx/geometry/box_f.h
new file mode 100644
index 0000000..443174d
--- /dev/null
+++ b/ui/gfx/geometry/box_f.h
@@ -0,0 +1,160 @@
+// 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.
+
+#ifndef UI_GFX_GEOMETRY_BOX_F_H_
+#define UI_GFX_GEOMETRY_BOX_F_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+// A 3d version of gfx::RectF, with the positive z-axis pointed towards
+// the camera.
+class GEOMETRY_EXPORT BoxF {
+ public:
+  constexpr BoxF() : BoxF(0, 0, 0) {}
+  constexpr BoxF(float width, float height, float depth)
+      : BoxF(0, 0, 0, width, height, depth) {}
+  constexpr BoxF(float x,
+                 float y,
+                 float z,
+                 float width,
+                 float height,
+                 float depth)
+      : BoxF(Point3F(x, y, z), width, height, depth) {}
+  constexpr BoxF(const Point3F& origin, float width, float height, float depth)
+      : origin_(origin),
+        width_(width >= 0 ? width : 0),
+        height_(height >= 0 ? height : 0),
+        depth_(depth >= 0 ? depth : 0) {}
+
+  // Scales all three axes by the given scale.
+  void Scale(float scale) {
+    Scale(scale, scale, scale);
+  }
+
+  // Scales each axis by the corresponding given scale.
+  void Scale(float x_scale, float y_scale, float z_scale) {
+    origin_.Scale(x_scale, y_scale, z_scale);
+    set_size(width_ * x_scale, height_ * y_scale, depth_ * z_scale);
+  }
+
+  // Moves the box by the specified distance in each dimension.
+  void operator+=(const Vector3dF& offset) {
+    origin_ += offset;
+  }
+
+  // Returns true if the box has no interior points.
+  bool IsEmpty() const;
+
+  // Computes the union of this box with the given box. The union is the
+  // smallest box that contains both boxes.
+  void Union(const BoxF& box);
+
+  std::string ToString() const;
+
+  constexpr float x() const { return origin_.x(); }
+  void set_x(float x) { origin_.set_x(x); }
+
+  constexpr float y() const { return origin_.y(); }
+  void set_y(float y) { origin_.set_y(y); }
+
+  constexpr float z() const { return origin_.z(); }
+  void set_z(float z) { origin_.set_z(z); }
+
+  constexpr float width() const { return width_; }
+  void set_width(float width) { width_ = width < 0 ? 0 : width; }
+
+  constexpr float height() const { return height_; }
+  void set_height(float height) { height_ = height < 0 ? 0 : height; }
+
+  constexpr float depth() const { return depth_; }
+  void set_depth(float depth) { depth_ = depth < 0 ? 0 : depth; }
+
+  constexpr float right() const { return x() + width(); }
+  constexpr float bottom() const { return y() + height(); }
+  constexpr float front() const { return z() + depth(); }
+
+  void set_size(float width, float height, float depth) {
+    width_ = width < 0 ? 0 : width;
+    height_ = height < 0 ? 0 : height;
+    depth_ = depth < 0 ? 0 : depth;
+  }
+
+  constexpr const Point3F& origin() const { return origin_; }
+  void set_origin(const Point3F& origin) { origin_ = origin; }
+
+  // Expands |this| to contain the given point, if necessary. Please note, even
+  // if |this| is empty, after the function |this| will continue to contain its
+  // |origin_|.
+  void ExpandTo(const Point3F& point);
+
+  // Expands |this| to contain the given box, if necessary. Please note, even
+  // if |this| is empty, after the function |this| will continue to contain its
+  // |origin_|.
+  void ExpandTo(const BoxF& box);
+
+ private:
+  // Expands the box to contain the two given points. It is required that each
+  // component of |min| is less than or equal to the corresponding component in
+  // |max|. Precisely, what this function does is ensure that after the function
+  // completes, |this| contains origin_, min, max, and origin_ + (width_,
+  // height_, depth_), even if the box is empty. Emptiness checks are handled in
+  // the public function Union.
+  void ExpandTo(const Point3F& min, const Point3F& max);
+
+  Point3F origin_;
+  float width_;
+  float height_;
+  float depth_;
+};
+
+GEOMETRY_EXPORT BoxF UnionBoxes(const BoxF& a, const BoxF& b);
+
+inline BoxF ScaleBox(const BoxF& b,
+                     float x_scale,
+                     float y_scale,
+                     float z_scale) {
+  return BoxF(b.x() * x_scale,
+              b.y() * y_scale,
+              b.z() * z_scale,
+              b.width() * x_scale,
+              b.height() * y_scale,
+              b.depth() * z_scale);
+}
+
+inline BoxF ScaleBox(const BoxF& b, float scale) {
+  return ScaleBox(b, scale, scale, scale);
+}
+
+inline bool operator==(const BoxF& a, const BoxF& b) {
+  return a.origin() == b.origin() && a.width() == b.width() &&
+         a.height() == b.height() && a.depth() == b.depth();
+}
+
+inline bool operator!=(const BoxF& a, const BoxF& b) {
+  return !(a == b);
+}
+
+inline BoxF operator+(const BoxF& b, const Vector3dF& v) {
+  return BoxF(b.x() + v.x(),
+              b.y() + v.y(),
+              b.z() + v.z(),
+              b.width(),
+              b.height(),
+              b.depth());
+}
+
+// This is declared here for use in gtest-based unit tests but is defined in
+// the //ui/gfx:test_support target. Depend on that to use this in your unit
+// test. This should not be used in production code - call ToString() instead.
+void PrintTo(const BoxF& box, ::std::ostream* os);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_BOX_F_H_
diff --git a/ui/gfx/geometry/box_unittest.cc b/ui/gfx/geometry/box_unittest.cc
new file mode 100644
index 0000000..990fccc
--- /dev/null
+++ b/ui/gfx/geometry/box_unittest.cc
@@ -0,0 +1,175 @@
+// 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.
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/box_f.h"
+
+namespace gfx {
+
+TEST(BoxTest, Constructors) {
+  EXPECT_EQ(BoxF(0.f, 0.f, 0.f, 0.f, 0.f, 0.f).ToString(),
+            BoxF().ToString());
+  EXPECT_EQ(BoxF(0.f, 0.f, 0.f, -3.f, -5.f, -7.f).ToString(),
+            BoxF().ToString());
+
+  EXPECT_EQ(BoxF(0.f, 0.f, 0.f, 3.f, 5.f, 7.f).ToString(),
+            BoxF(3.f, 5.f, 7.f).ToString());
+  EXPECT_EQ(BoxF(0.f, 0.f, 0.f, 0.f, 0.f, 0.f).ToString(),
+            BoxF(-3.f, -5.f, -7.f).ToString());
+
+  EXPECT_EQ(BoxF(2.f, 4.f, 6.f, 3.f, 5.f, 7.f).ToString(),
+            BoxF(Point3F(2.f, 4.f, 6.f), 3.f, 5.f, 7.f).ToString());
+  EXPECT_EQ(BoxF(2.f, 4.f, 6.f, 0.f, 0.f, 0.f).ToString(),
+            BoxF(Point3F(2.f, 4.f, 6.f), -3.f, -5.f, -7.f).ToString());
+}
+
+TEST(BoxTest, IsEmpty) {
+  EXPECT_TRUE(BoxF(0.f, 0.f, 0.f, 0.f, 0.f, 0.f).IsEmpty());
+  EXPECT_TRUE(BoxF(1.f, 2.f, 3.f, 0.f, 0.f, 0.f).IsEmpty());
+
+  EXPECT_TRUE(BoxF(0.f, 0.f, 0.f, 2.f, 0.f, 0.f).IsEmpty());
+  EXPECT_TRUE(BoxF(1.f, 2.f, 3.f, 2.f, 0.f, 0.f).IsEmpty());
+  EXPECT_TRUE(BoxF(0.f, 0.f, 0.f, 0.f, 2.f, 0.f).IsEmpty());
+  EXPECT_TRUE(BoxF(1.f, 2.f, 3.f, 0.f, 2.f, 0.f).IsEmpty());
+  EXPECT_TRUE(BoxF(0.f, 0.f, 0.f, 0.f, 0.f, 2.f).IsEmpty());
+  EXPECT_TRUE(BoxF(1.f, 2.f, 3.f, 0.f, 0.f, 2.f).IsEmpty());
+
+  EXPECT_FALSE(BoxF(0.f, 0.f, 0.f, 0.f, 2.f, 2.f).IsEmpty());
+  EXPECT_FALSE(BoxF(1.f, 2.f, 3.f, 0.f, 2.f, 2.f).IsEmpty());
+  EXPECT_FALSE(BoxF(0.f, 0.f, 0.f, 2.f, 0.f, 2.f).IsEmpty());
+  EXPECT_FALSE(BoxF(1.f, 2.f, 3.f, 2.f, 0.f, 2.f).IsEmpty());
+  EXPECT_FALSE(BoxF(0.f, 0.f, 0.f, 2.f, 2.f, 0.f).IsEmpty());
+  EXPECT_FALSE(BoxF(1.f, 2.f, 3.f, 2.f, 2.f, 0.f).IsEmpty());
+
+  EXPECT_FALSE(BoxF(0.f, 0.f, 0.f, 2.f, 2.f, 2.f).IsEmpty());
+  EXPECT_FALSE(BoxF(1.f, 2.f, 3.f, 2.f, 2.f, 2.f).IsEmpty());
+}
+
+TEST(BoxTest, Union) {
+  BoxF empty_box;
+  BoxF box1(0.f, 0.f, 0.f, 1.f, 1.f, 1.f);
+  BoxF box2(0.f, 0.f, 0.f, 4.f, 6.f, 8.f);
+  BoxF box3(3.f, 4.f, 5.f, 6.f, 4.f, 0.f);
+
+  EXPECT_EQ(empty_box.ToString(), UnionBoxes(empty_box, empty_box).ToString());
+  EXPECT_EQ(box1.ToString(), UnionBoxes(empty_box, box1).ToString());
+  EXPECT_EQ(box1.ToString(), UnionBoxes(box1, empty_box).ToString());
+  EXPECT_EQ(box2.ToString(), UnionBoxes(empty_box, box2).ToString());
+  EXPECT_EQ(box2.ToString(), UnionBoxes(box2, empty_box).ToString());
+  EXPECT_EQ(box3.ToString(), UnionBoxes(empty_box, box3).ToString());
+  EXPECT_EQ(box3.ToString(), UnionBoxes(box3, empty_box).ToString());
+
+  // box_1 is contained in box_2
+  EXPECT_EQ(box2.ToString(), UnionBoxes(box1, box2).ToString());
+  EXPECT_EQ(box2.ToString(), UnionBoxes(box2, box1).ToString());
+
+  // box_1 and box_3 are disjoint
+  EXPECT_EQ(BoxF(0.f, 0.f, 0.f, 9.f, 8.f, 5.f).ToString(),
+            UnionBoxes(box1, box3).ToString());
+  EXPECT_EQ(BoxF(0.f, 0.f, 0.f, 9.f, 8.f, 5.f).ToString(),
+            UnionBoxes(box3, box1).ToString());
+
+  // box_2 and box_3 intersect, but neither contains the other
+  EXPECT_EQ(BoxF(0.f, 0.f, 0.f, 9.f, 8.f, 8.f).ToString(),
+            UnionBoxes(box2, box3).ToString());
+  EXPECT_EQ(BoxF(0.f, 0.f, 0.f, 9.f, 8.f, 8.f).ToString(),
+            UnionBoxes(box3, box2).ToString());
+}
+
+TEST(BoxTest, ExpandTo) {
+  BoxF box1;
+  BoxF box2(0.f, 0.f, 0.f, 1.f, 1.f, 1.f);
+  BoxF box3(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
+
+  Point3F point1(0.5f, 0.5f, 0.5f);
+  Point3F point2(-0.5f, -0.5f, -0.5f);
+
+  BoxF expected1_1(0.f, 0.f, 0.f, 0.5f, 0.5f, 0.5f);
+  BoxF expected1_2(-0.5f, -0.5f, -0.5f, 1.f, 1.f, 1.f);
+
+  BoxF expected2_1 = box2;
+  BoxF expected2_2(-0.5f, -0.5f, -0.5f, 1.5f, 1.5f, 1.5f);
+
+  BoxF expected3_1(0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f);
+  BoxF expected3_2(-0.5f, -0.5f, -0.5f, 1.5f, 1.5f, 1.5f);
+
+  box1.ExpandTo(point1);
+  EXPECT_EQ(expected1_1.ToString(), box1.ToString());
+  box1.ExpandTo(point2);
+  EXPECT_EQ(expected1_2.ToString(), box1.ToString());
+
+  box2.ExpandTo(point1);
+  EXPECT_EQ(expected2_1.ToString(), box2.ToString());
+  box2.ExpandTo(point2);
+  EXPECT_EQ(expected2_2.ToString(), box2.ToString());
+
+  box3.ExpandTo(point1);
+  EXPECT_EQ(expected3_1.ToString(), box3.ToString());
+  box3.ExpandTo(point2);
+  EXPECT_EQ(expected3_2.ToString(), box3.ToString());
+}
+
+TEST(BoxTest, Scale) {
+  BoxF box1(2.f, 3.f, 4.f, 5.f, 6.f, 7.f);
+
+  EXPECT_EQ(BoxF().ToString(), ScaleBox(box1, 0.f).ToString());
+  EXPECT_EQ(box1.ToString(), ScaleBox(box1, 1.f).ToString());
+  EXPECT_EQ(BoxF(4.f, 12.f, 24.f, 10.f, 24.f, 42.f).ToString(),
+            ScaleBox(box1, 2.f, 4.f, 6.f).ToString());
+
+  BoxF box2 = box1;
+  box2.Scale(0.f);
+  EXPECT_EQ(BoxF().ToString(), box2.ToString());
+
+  box2 = box1;
+  box2.Scale(1.f);
+  EXPECT_EQ(box1.ToString(), box2.ToString());
+
+  box2.Scale(2.f, 4.f, 6.f);
+  EXPECT_EQ(BoxF(4.f, 12.f, 24.f, 10.f, 24.f, 42.f).ToString(),
+            box2.ToString());
+}
+
+TEST(BoxTest, Equals) {
+  EXPECT_TRUE(BoxF() == BoxF());
+  EXPECT_TRUE(BoxF(2.f, 3.f, 4.f, 6.f, 8.f, 10.f) ==
+              BoxF(2.f, 3.f, 4.f, 6.f, 8.f, 10.f));
+  EXPECT_FALSE(BoxF() == BoxF(0.f, 0.f, 0.f, 0.f, 0.f, 1.f));
+  EXPECT_FALSE(BoxF() == BoxF(0.f, 0.f, 0.f, 0.f, 1.f, 0.f));
+  EXPECT_FALSE(BoxF() == BoxF(0.f, 0.f, 0.f, 1.f, 0.f, 0.f));
+  EXPECT_FALSE(BoxF() == BoxF(0.f, 0.f, 1.f, 0.f, 0.f, 0.f));
+  EXPECT_FALSE(BoxF() == BoxF(0.f, 1.f, 0.f, 0.f, 0.f, 0.f));
+  EXPECT_FALSE(BoxF() == BoxF(1.f, 0.f, 0.f, 0.f, 0.f, 0.f));
+}
+
+TEST(BoxTest, NotEquals) {
+  EXPECT_FALSE(BoxF() != BoxF());
+  EXPECT_FALSE(BoxF(2.f, 3.f, 4.f, 6.f, 8.f, 10.f) !=
+               BoxF(2.f, 3.f, 4.f, 6.f, 8.f, 10.f));
+  EXPECT_TRUE(BoxF() != BoxF(0.f, 0.f, 0.f, 0.f, 0.f, 1.f));
+  EXPECT_TRUE(BoxF() != BoxF(0.f, 0.f, 0.f, 0.f, 1.f, 0.f));
+  EXPECT_TRUE(BoxF() != BoxF(0.f, 0.f, 0.f, 1.f, 0.f, 0.f));
+  EXPECT_TRUE(BoxF() != BoxF(0.f, 0.f, 1.f, 0.f, 0.f, 0.f));
+  EXPECT_TRUE(BoxF() != BoxF(0.f, 1.f, 0.f, 0.f, 0.f, 0.f));
+  EXPECT_TRUE(BoxF() != BoxF(1.f, 0.f, 0.f, 0.f, 0.f, 0.f));
+}
+
+
+TEST(BoxTest, Offset) {
+  BoxF box1(2.f, 3.f, 4.f, 5.f, 6.f, 7.f);
+
+  EXPECT_EQ(box1.ToString(), (box1 + Vector3dF(0.f, 0.f, 0.f)).ToString());
+  EXPECT_EQ(BoxF(3.f, 1.f, 0.f, 5.f, 6.f, 7.f).ToString(),
+            (box1 + Vector3dF(1.f, -2.f, -4.f)).ToString());
+
+  BoxF box2 = box1;
+  box2 += Vector3dF(0.f, 0.f, 0.f);
+  EXPECT_EQ(box1.ToString(), box2.ToString());
+
+  box2 += Vector3dF(1.f, -2.f, -4.f);
+  EXPECT_EQ(BoxF(3.f, 1.f, 0.f, 5.f, 6.f, 7.f).ToString(),
+            box2.ToString());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/cubic_bezier.cc b/ui/gfx/geometry/cubic_bezier.cc
new file mode 100644
index 0000000..ccd297b
--- /dev/null
+++ b/ui/gfx/geometry/cubic_bezier.cc
@@ -0,0 +1,259 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/geometry/cubic_bezier.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "base/check_op.h"
+#include "base/cxx17_backports.h"
+
+namespace gfx {
+
+namespace {
+
+const int kMaxNewtonIterations = 4;
+
+}  // namespace
+
+static const double kBezierEpsilon = 1e-7;
+
+CubicBezier::CubicBezier(double p1x, double p1y, double p2x, double p2y) {
+  InitCoefficients(p1x, p1y, p2x, p2y);
+  InitGradients(p1x, p1y, p2x, p2y);
+  InitRange(p1y, p2y);
+  InitSpline();
+}
+
+CubicBezier::CubicBezier(const CubicBezier& other) = default;
+
+void CubicBezier::InitCoefficients(double p1x,
+                                   double p1y,
+                                   double p2x,
+                                   double p2y) {
+  // Calculate the polynomial coefficients, implicit first and last control
+  // points are (0,0) and (1,1).
+  cx_ = 3.0 * p1x;
+  bx_ = 3.0 * (p2x - p1x) - cx_;
+  ax_ = 1.0 - cx_ - bx_;
+
+  cy_ = 3.0 * p1y;
+  by_ = 3.0 * (p2y - p1y) - cy_;
+  ay_ = 1.0 - cy_ - by_;
+
+#ifndef NDEBUG
+  // Bezier curves with x-coordinates outside the range [0,1] for internal
+  // control points may have multiple values for t for a given value of x.
+  // In this case, calls to SolveCurveX may produce ambiguous results.
+  monotonically_increasing_ = p1x >= 0 && p1x <= 1 && p2x >= 0 && p2x <= 1;
+#endif
+}
+
+void CubicBezier::InitGradients(double p1x,
+                                double p1y,
+                                double p2x,
+                                double p2y) {
+  // End-point gradients are used to calculate timing function results
+  // outside the range [0, 1].
+  //
+  // There are four possibilities for the gradient at each end:
+  // (1) the closest control point is not horizontally coincident with regard to
+  //     (0, 0) or (1, 1). In this case the line between the end point and
+  //     the control point is tangent to the bezier at the end point.
+  // (2) the closest control point is coincident with the end point. In
+  //     this case the line between the end point and the far control
+  //     point is tangent to the bezier at the end point.
+  // (3) both internal control points are coincident with an endpoint. There
+  //     are two special case that fall into this category:
+  //     CubicBezier(0, 0, 0, 0) and CubicBezier(1, 1, 1, 1). Both are
+  //     equivalent to linear.
+  // (4) the closest control point is horizontally coincident with the end
+  //     point, but vertically distinct. In this case the gradient at the
+  //     end point is Infinite. However, this causes issues when
+  //     interpolating. As a result, we break down to a simple case of
+  //     0 gradient under these conditions.
+
+  if (p1x > 0)
+    start_gradient_ = p1y / p1x;
+  else if (!p1y && p2x > 0)
+    start_gradient_ = p2y / p2x;
+  else if (!p1y && !p2y)
+    start_gradient_ = 1;
+  else
+    start_gradient_ = 0;
+
+  if (p2x < 1)
+    end_gradient_ = (p2y - 1) / (p2x - 1);
+  else if (p2y == 1 && p1x < 1)
+    end_gradient_ = (p1y - 1) / (p1x - 1);
+  else if (p2y == 1 && p1y == 1)
+    end_gradient_ = 1;
+  else
+    end_gradient_ = 0;
+}
+
+// This works by taking taking the derivative of the cubic bezier, on the y
+// axis. We can then solve for where the derivative is zero to find the min
+// and max distance along the line. We the have to solve those in terms of time
+// rather than distance on the x-axis
+void CubicBezier::InitRange(double p1y, double p2y) {
+  range_min_ = 0;
+  range_max_ = 1;
+  if (0 <= p1y && p1y < 1 && 0 <= p2y && p2y <= 1)
+    return;
+
+  const double epsilon = kBezierEpsilon;
+
+  // Represent the function's derivative in the form at^2 + bt + c
+  // as in sampleCurveDerivativeY.
+  // (Technically this is (dy/dt)*(1/3), which is suitable for finding zeros
+  // but does not actually give the slope of the curve.)
+  const double a = 3.0 * ay_;
+  const double b = 2.0 * by_;
+  const double c = cy_;
+
+  // Check if the derivative is constant.
+  if (std::abs(a) < epsilon && std::abs(b) < epsilon)
+    return;
+
+  // Zeros of the function's derivative.
+  double t1 = 0;
+  double t2 = 0;
+
+  if (std::abs(a) < epsilon) {
+    // The function's derivative is linear.
+    t1 = -c / b;
+  } else {
+    // The function's derivative is a quadratic. We find the zeros of this
+    // quadratic using the quadratic formula.
+    double discriminant = b * b - 4 * a * c;
+    if (discriminant < 0)
+      return;
+    double discriminant_sqrt = sqrt(discriminant);
+    t1 = (-b + discriminant_sqrt) / (2 * a);
+    t2 = (-b - discriminant_sqrt) / (2 * a);
+  }
+
+  double sol1 = 0;
+  double sol2 = 0;
+
+  // If the solution is in the range [0,1] then we include it, otherwise we
+  // ignore it.
+
+  // An interesting fact about these beziers is that they are only
+  // actually evaluated in [0,1]. After that we take the tangent at that point
+  // and linearly project it out.
+  if (0 < t1 && t1 < 1)
+    sol1 = SampleCurveY(t1);
+
+  if (0 < t2 && t2 < 1)
+    sol2 = SampleCurveY(t2);
+
+  range_min_ = std::min({range_min_, sol1, sol2});
+  range_max_ = std::max({range_max_, sol1, sol2});
+}
+
+void CubicBezier::InitSpline() {
+  double delta_t = 1.0 / (CUBIC_BEZIER_SPLINE_SAMPLES - 1);
+  for (int i = 0; i < CUBIC_BEZIER_SPLINE_SAMPLES; i++) {
+    spline_samples_[i] = SampleCurveX(i * delta_t);
+  }
+}
+
+double CubicBezier::GetDefaultEpsilon() {
+  return kBezierEpsilon;
+}
+
+double CubicBezier::SolveCurveX(double x, double epsilon) const {
+  DCHECK_GE(x, 0.0);
+  DCHECK_LE(x, 1.0);
+
+  double t0;
+  double t1;
+  double t2 = x;
+  double x2;
+  double d2;
+  int i;
+
+#ifndef NDEBUG
+  DCHECK(monotonically_increasing_);
+#endif
+
+  // Linear interpolation of spline curve for initial guess.
+  double delta_t = 1.0 / (CUBIC_BEZIER_SPLINE_SAMPLES - 1);
+  for (i = 1; i < CUBIC_BEZIER_SPLINE_SAMPLES; i++) {
+    if (x <= spline_samples_[i]) {
+      t1 = delta_t * i;
+      t0 = t1 - delta_t;
+      t2 = t0 + (t1 - t0) * (x - spline_samples_[i - 1]) /
+                    (spline_samples_[i] - spline_samples_[i - 1]);
+      break;
+    }
+  }
+
+  // Perform a few iterations of Newton's method -- normally very fast.
+  // See https://en.wikipedia.org/wiki/Newton%27s_method.
+  double newton_epsilon = std::min(kBezierEpsilon, epsilon);
+  for (i = 0; i < kMaxNewtonIterations; i++) {
+    x2 = SampleCurveX(t2) - x;
+    if (fabs(x2) < newton_epsilon)
+      return t2;
+    d2 = SampleCurveDerivativeX(t2);
+    if (fabs(d2) < kBezierEpsilon)
+      break;
+    t2 = t2 - x2 / d2;
+  }
+  if (fabs(x2) < epsilon)
+    return t2;
+
+  // Fall back to the bisection method for reliability.
+  while (t0 < t1) {
+    x2 = SampleCurveX(t2);
+    if (fabs(x2 - x) < epsilon)
+      return t2;
+    if (x > x2)
+      t0 = t2;
+    else
+      t1 = t2;
+    t2 = (t1 + t0) * .5;
+  }
+
+  // Failure.
+  return t2;
+}
+
+double CubicBezier::Solve(double x) const {
+  return SolveWithEpsilon(x, kBezierEpsilon);
+}
+
+double CubicBezier::SlopeWithEpsilon(double x, double epsilon) const {
+  x = base::clamp(x, 0.0, 1.0);
+  double t = SolveCurveX(x, epsilon);
+  double dx = SampleCurveDerivativeX(t);
+  double dy = SampleCurveDerivativeY(t);
+  return dy / dx;
+}
+
+double CubicBezier::Slope(double x) const {
+  return SlopeWithEpsilon(x, kBezierEpsilon);
+}
+
+double CubicBezier::GetX1() const {
+  return cx_ / 3.0;
+}
+
+double CubicBezier::GetY1() const {
+  return cy_ / 3.0;
+}
+
+double CubicBezier::GetX2() const {
+  return (bx_ + cx_) / 3.0 + GetX1();
+}
+
+double CubicBezier::GetY2() const {
+  return (by_ + cy_) / 3.0 + GetY1();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/cubic_bezier.h b/ui/gfx/geometry/cubic_bezier.h
new file mode 100644
index 0000000..5709888
--- /dev/null
+++ b/ui/gfx/geometry/cubic_bezier.h
@@ -0,0 +1,107 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_CUBIC_BEZIER_H_
+#define UI_GFX_GEOMETRY_CUBIC_BEZIER_H_
+
+#include "base/macros.h"
+#include "ui/gfx/geometry/geometry_export.h"
+
+namespace gfx {
+
+#define CUBIC_BEZIER_SPLINE_SAMPLES 11
+
+class GEOMETRY_EXPORT CubicBezier {
+ public:
+  CubicBezier(double p1x, double p1y, double p2x, double p2y);
+  CubicBezier(const CubicBezier& other);
+
+  CubicBezier& operator=(const CubicBezier&) = delete;
+
+  double SampleCurveX(double t) const {
+    // `ax t^3 + bx t^2 + cx t' expanded using Horner's rule.
+    return ((ax_ * t + bx_) * t + cx_) * t;
+  }
+
+  double SampleCurveY(double t) const {
+    return ((ay_ * t + by_) * t + cy_) * t;
+  }
+
+  double SampleCurveDerivativeX(double t) const {
+    return (3.0 * ax_ * t + 2.0 * bx_) * t + cx_;
+  }
+
+  double SampleCurveDerivativeY(double t) const {
+    return (3.0 * ay_ * t + 2.0 * by_) * t + cy_;
+  }
+
+  static double GetDefaultEpsilon();
+
+  // Given an x value, find a parametric value it came from.
+  // x must be in [0, 1] range. Doesn't use gradients.
+  double SolveCurveX(double x, double epsilon) const;
+
+  // Evaluates y at the given x with default epsilon.
+  double Solve(double x) const;
+  // Evaluates y at the given x. The epsilon parameter provides a hint as to the
+  // required accuracy and is not guaranteed. Uses gradients if x is
+  // out of [0, 1] range.
+  double SolveWithEpsilon(double x, double epsilon) const {
+    if (x < 0.0)
+      return 0.0 + start_gradient_ * x;
+    if (x > 1.0)
+      return 1.0 + end_gradient_ * (x - 1.0);
+    return SampleCurveY(SolveCurveX(x, epsilon));
+  }
+
+  // Returns an approximation of dy/dx at the given x with default epsilon.
+  double Slope(double x) const;
+  // Returns an approximation of dy/dx at the given x.
+  // Clamps x to range [0, 1].
+  double SlopeWithEpsilon(double x, double epsilon) const;
+
+  // These getters are used rarely. We reverse compute them from coefficients.
+  // See CubicBezier::InitCoefficients. The speed has been traded for memory.
+  double GetX1() const;
+  double GetY1() const;
+  double GetX2() const;
+  double GetY2() const;
+
+  // Gets the bezier's minimum y value in the interval [0, 1].
+  double range_min() const { return range_min_; }
+  // Gets the bezier's maximum y value in the interval [0, 1].
+  double range_max() const { return range_max_; }
+
+ private:
+  void InitCoefficients(double p1x, double p1y, double p2x, double p2y);
+  void InitGradients(double p1x, double p1y, double p2x, double p2y);
+  void InitRange(double p1y, double p2y);
+  void InitSpline();
+
+  double ax_;
+  double bx_;
+  double cx_;
+
+  double ay_;
+  double by_;
+  double cy_;
+
+  double start_gradient_;
+  double end_gradient_;
+
+  double range_min_;
+  double range_max_;
+
+  double spline_samples_[CUBIC_BEZIER_SPLINE_SAMPLES];
+
+#ifndef NDEBUG
+  // Guard against attempted to solve for t given x in the event that the curve
+  // may have multiple values for t for some values of x in [0, 1].
+  bool monotonically_increasing_;
+#endif
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_CUBIC_BEZIER_H_
diff --git a/ui/gfx/geometry/cubic_bezier_unittest.cc b/ui/gfx/geometry/cubic_bezier_unittest.cc
new file mode 100644
index 0000000..bf86f41
--- /dev/null
+++ b/ui/gfx/geometry/cubic_bezier_unittest.cc
@@ -0,0 +1,273 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/geometry/cubic_bezier.h"
+
+#include <memory>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+namespace {
+
+TEST(CubicBezierTest, Basic) {
+  CubicBezier function(0.25, 0.0, 0.75, 1.0);
+
+  double epsilon = 0.00015;
+
+  EXPECT_NEAR(function.Solve(0), 0, epsilon);
+  EXPECT_NEAR(function.Solve(0.05), 0.01136, epsilon);
+  EXPECT_NEAR(function.Solve(0.1), 0.03978, epsilon);
+  EXPECT_NEAR(function.Solve(0.15), 0.079780, epsilon);
+  EXPECT_NEAR(function.Solve(0.2), 0.12803, epsilon);
+  EXPECT_NEAR(function.Solve(0.25), 0.18235, epsilon);
+  EXPECT_NEAR(function.Solve(0.3), 0.24115, epsilon);
+  EXPECT_NEAR(function.Solve(0.35), 0.30323, epsilon);
+  EXPECT_NEAR(function.Solve(0.4), 0.36761, epsilon);
+  EXPECT_NEAR(function.Solve(0.45), 0.43345, epsilon);
+  EXPECT_NEAR(function.Solve(0.5), 0.5, epsilon);
+  EXPECT_NEAR(function.Solve(0.6), 0.63238, epsilon);
+  EXPECT_NEAR(function.Solve(0.65), 0.69676, epsilon);
+  EXPECT_NEAR(function.Solve(0.7), 0.75884, epsilon);
+  EXPECT_NEAR(function.Solve(0.75), 0.81764, epsilon);
+  EXPECT_NEAR(function.Solve(0.8), 0.87196, epsilon);
+  EXPECT_NEAR(function.Solve(0.85), 0.92021, epsilon);
+  EXPECT_NEAR(function.Solve(0.9), 0.96021, epsilon);
+  EXPECT_NEAR(function.Solve(0.95), 0.98863, epsilon);
+  EXPECT_NEAR(function.Solve(1), 1, epsilon);
+
+  CubicBezier basic_use(0.5, 1.0, 0.5, 1.0);
+  EXPECT_EQ(0.875, basic_use.Solve(0.5));
+
+  CubicBezier overshoot(0.5, 2.0, 0.5, 2.0);
+  EXPECT_EQ(1.625, overshoot.Solve(0.5));
+
+  CubicBezier undershoot(0.5, -1.0, 0.5, -1.0);
+  EXPECT_EQ(-0.625, undershoot.Solve(0.5));
+}
+
+// Tests that solving the bezier works with knots with y not in (0, 1).
+TEST(CubicBezierTest, UnclampedYValues) {
+  CubicBezier function(0.5, -1.0, 0.5, 2.0);
+
+  double epsilon = 0.00015;
+
+  EXPECT_NEAR(function.Solve(0.0), 0.0, epsilon);
+  EXPECT_NEAR(function.Solve(0.05), -0.08954, epsilon);
+  EXPECT_NEAR(function.Solve(0.1), -0.15613, epsilon);
+  EXPECT_NEAR(function.Solve(0.15), -0.19641, epsilon);
+  EXPECT_NEAR(function.Solve(0.2), -0.20651, epsilon);
+  EXPECT_NEAR(function.Solve(0.25), -0.18232, epsilon);
+  EXPECT_NEAR(function.Solve(0.3), -0.11992, epsilon);
+  EXPECT_NEAR(function.Solve(0.35), -0.01672, epsilon);
+  EXPECT_NEAR(function.Solve(0.4), 0.12660, epsilon);
+  EXPECT_NEAR(function.Solve(0.45), 0.30349, epsilon);
+  EXPECT_NEAR(function.Solve(0.5), 0.50000, epsilon);
+  EXPECT_NEAR(function.Solve(0.55), 0.69651, epsilon);
+  EXPECT_NEAR(function.Solve(0.6), 0.87340, epsilon);
+  EXPECT_NEAR(function.Solve(0.65), 1.01672, epsilon);
+  EXPECT_NEAR(function.Solve(0.7), 1.11992, epsilon);
+  EXPECT_NEAR(function.Solve(0.75), 1.18232, epsilon);
+  EXPECT_NEAR(function.Solve(0.8), 1.20651, epsilon);
+  EXPECT_NEAR(function.Solve(0.85), 1.19641, epsilon);
+  EXPECT_NEAR(function.Solve(0.9), 1.15613, epsilon);
+  EXPECT_NEAR(function.Solve(0.95), 1.08954, epsilon);
+  EXPECT_NEAR(function.Solve(1.0), 1.0, epsilon);
+}
+
+TEST(CubicBezierTest, Range) {
+  double epsilon = 0.00015;
+
+  // Derivative is a constant.
+  std::unique_ptr<CubicBezier> function =
+      std::make_unique<CubicBezier>(0.25, (1.0 / 3.0), 0.75, (2.0 / 3.0));
+  EXPECT_EQ(0, function->range_min());
+  EXPECT_EQ(1, function->range_max());
+
+  // Derivative is linear.
+  function = std::make_unique<CubicBezier>(0.25, -0.5, 0.75, (-1.0 / 6.0));
+  EXPECT_NEAR(function->range_min(), -0.225, epsilon);
+  EXPECT_EQ(1, function->range_max());
+
+  // Derivative has no real roots.
+  function = std::make_unique<CubicBezier>(0.25, 0.25, 0.75, 0.5);
+  EXPECT_EQ(0, function->range_min());
+  EXPECT_EQ(1, function->range_max());
+
+  // Derivative has exactly one real root.
+  function = std::make_unique<CubicBezier>(0.0, 1.0, 1.0, 0.0);
+  EXPECT_EQ(0, function->range_min());
+  EXPECT_EQ(1, function->range_max());
+
+  // Derivative has one root < 0 and one root > 1.
+  function = std::make_unique<CubicBezier>(0.25, 0.1, 0.75, 0.9);
+  EXPECT_EQ(0, function->range_min());
+  EXPECT_EQ(1, function->range_max());
+
+  // Derivative has two roots in [0,1].
+  function = std::make_unique<CubicBezier>(0.25, 2.5, 0.75, 0.5);
+  EXPECT_EQ(0, function->range_min());
+  EXPECT_NEAR(function->range_max(), 1.28818, epsilon);
+  function = std::make_unique<CubicBezier>(0.25, 0.5, 0.75, -1.5);
+  EXPECT_NEAR(function->range_min(), -0.28818, epsilon);
+  EXPECT_EQ(1, function->range_max());
+
+  // Derivative has one root < 0 and one root in [0,1].
+  function = std::make_unique<CubicBezier>(0.25, 0.1, 0.75, 1.5);
+  EXPECT_EQ(0, function->range_min());
+  EXPECT_NEAR(function->range_max(), 1.10755, epsilon);
+
+  // Derivative has one root in [0,1] and one root > 1.
+  function = std::make_unique<CubicBezier>(0.25, -0.5, 0.75, 0.9);
+  EXPECT_NEAR(function->range_min(), -0.10755, epsilon);
+  EXPECT_EQ(1, function->range_max());
+
+  // Derivative has two roots < 0.
+  function = std::make_unique<CubicBezier>(0.25, 0.3, 0.75, 0.633);
+  EXPECT_EQ(0, function->range_min());
+  EXPECT_EQ(1, function->range_max());
+
+  // Derivative has two roots > 1.
+  function = std::make_unique<CubicBezier>(0.25, 0.367, 0.75, 0.7);
+  EXPECT_EQ(0.f, function->range_min());
+  EXPECT_EQ(1.f, function->range_max());
+}
+
+TEST(CubicBezierTest, Slope) {
+  CubicBezier function(0.25, 0.0, 0.75, 1.0);
+
+  double epsilon = 0.00015;
+
+  EXPECT_NEAR(function.Slope(-0.1), 0, epsilon);
+  EXPECT_NEAR(function.Slope(0), 0, epsilon);
+  EXPECT_NEAR(function.Slope(0.05), 0.42170, epsilon);
+  EXPECT_NEAR(function.Slope(0.1), 0.69778, epsilon);
+  EXPECT_NEAR(function.Slope(0.15), 0.89121, epsilon);
+  EXPECT_NEAR(function.Slope(0.2), 1.03184, epsilon);
+  EXPECT_NEAR(function.Slope(0.25), 1.13576, epsilon);
+  EXPECT_NEAR(function.Slope(0.3), 1.21239, epsilon);
+  EXPECT_NEAR(function.Slope(0.35), 1.26751, epsilon);
+  EXPECT_NEAR(function.Slope(0.4), 1.30474, epsilon);
+  EXPECT_NEAR(function.Slope(0.45), 1.32628, epsilon);
+  EXPECT_NEAR(function.Slope(0.5), 1.33333, epsilon);
+  EXPECT_NEAR(function.Slope(0.55), 1.32628, epsilon);
+  EXPECT_NEAR(function.Slope(0.6), 1.30474, epsilon);
+  EXPECT_NEAR(function.Slope(0.65), 1.26751, epsilon);
+  EXPECT_NEAR(function.Slope(0.7), 1.21239, epsilon);
+  EXPECT_NEAR(function.Slope(0.75), 1.13576, epsilon);
+  EXPECT_NEAR(function.Slope(0.8), 1.03184, epsilon);
+  EXPECT_NEAR(function.Slope(0.85), 0.89121, epsilon);
+  EXPECT_NEAR(function.Slope(0.9), 0.69778, epsilon);
+  EXPECT_NEAR(function.Slope(0.95), 0.42170, epsilon);
+  EXPECT_NEAR(function.Slope(1), 0, epsilon);
+  EXPECT_NEAR(function.Slope(1.1), 0, epsilon);
+}
+
+TEST(CubicBezierTest, InputOutOfRange) {
+  CubicBezier simple(0.5, 1.0, 0.5, 1.0);
+  EXPECT_EQ(-2.0, simple.Solve(-1.0));
+  EXPECT_EQ(1.0, simple.Solve(2.0));
+
+  CubicBezier at_edge_of_range(0.5, 1.0, 0.5, 1.0);
+  EXPECT_EQ(0.0, at_edge_of_range.Solve(0.0));
+  EXPECT_EQ(1.0, at_edge_of_range.Solve(1.0));
+
+  CubicBezier large_epsilon(0.5, 1.0, 0.5, 1.0);
+  EXPECT_EQ(-2.0, large_epsilon.SolveWithEpsilon(-1.0, 1.0));
+  EXPECT_EQ(1.0, large_epsilon.SolveWithEpsilon(2.0, 1.0));
+
+  CubicBezier coincident_endpoints(0.0, 0.0, 1.0, 1.0);
+  EXPECT_EQ(-1.0, coincident_endpoints.Solve(-1.0));
+  EXPECT_EQ(2.0, coincident_endpoints.Solve(2.0));
+
+  CubicBezier vertical_gradient(0.0, 1.0, 1.0, 0.0);
+  EXPECT_EQ(0.0, vertical_gradient.Solve(-1.0));
+  EXPECT_EQ(1.0, vertical_gradient.Solve(2.0));
+
+  CubicBezier vertical_trailing_gradient(0.5, 0.0, 1.0, 0.5);
+  EXPECT_EQ(0.0, vertical_trailing_gradient.Solve(-1.0));
+  EXPECT_EQ(1.0, vertical_trailing_gradient.Solve(2.0));
+
+  CubicBezier distinct_endpoints(0.1, 0.2, 0.8, 0.8);
+  EXPECT_EQ(-2.0, distinct_endpoints.Solve(-1.0));
+  EXPECT_EQ(2.0, distinct_endpoints.Solve(2.0));
+
+  CubicBezier coincident_leading_endpoint(0.0, 0.0, 0.5, 1.0);
+  EXPECT_EQ(-2.0, coincident_leading_endpoint.Solve(-1.0));
+  EXPECT_EQ(1.0, coincident_leading_endpoint.Solve(2.0));
+
+  CubicBezier coincident_trailing_endpoint(1.0, 0.5, 1.0, 1.0);
+  EXPECT_EQ(-0.5, coincident_trailing_endpoint.Solve(-1.0));
+  EXPECT_EQ(1.0, coincident_trailing_endpoint.Solve(2.0));
+
+  // Two special cases with three coincident points. Both are equivalent to
+  // linear.
+  CubicBezier all_zeros(0.0, 0.0, 0.0, 0.0);
+  EXPECT_EQ(-1.0, all_zeros.Solve(-1.0));
+  EXPECT_EQ(2.0, all_zeros.Solve(2.0));
+
+  CubicBezier all_ones(1.0, 1.0, 1.0, 1.0);
+  EXPECT_EQ(-1.0, all_ones.Solve(-1.0));
+  EXPECT_EQ(2.0, all_ones.Solve(2.0));
+}
+
+TEST(CubicBezierTest, GetPoints) {
+  double epsilon = 0.00015;
+
+  CubicBezier cubic1(0.1, 0.2, 0.8, 0.9);
+  EXPECT_NEAR(0.1, cubic1.GetX1(), epsilon);
+  EXPECT_NEAR(0.2, cubic1.GetY1(), epsilon);
+  EXPECT_NEAR(0.8, cubic1.GetX2(), epsilon);
+  EXPECT_NEAR(0.9, cubic1.GetY2(), epsilon);
+
+  CubicBezier cubic_zero(0, 0, 0, 0);
+  EXPECT_NEAR(0, cubic_zero.GetX1(), epsilon);
+  EXPECT_NEAR(0, cubic_zero.GetY1(), epsilon);
+  EXPECT_NEAR(0, cubic_zero.GetX2(), epsilon);
+  EXPECT_NEAR(0, cubic_zero.GetY2(), epsilon);
+
+  CubicBezier cubic_one(1, 1, 1, 1);
+  EXPECT_NEAR(1, cubic_one.GetX1(), epsilon);
+  EXPECT_NEAR(1, cubic_one.GetY1(), epsilon);
+  EXPECT_NEAR(1, cubic_one.GetX2(), epsilon);
+  EXPECT_NEAR(1, cubic_one.GetY2(), epsilon);
+
+  CubicBezier cubic_oor(-0.5, -1.5, 1.5, -1.6);
+  EXPECT_NEAR(-0.5, cubic_oor.GetX1(), epsilon);
+  EXPECT_NEAR(-1.5, cubic_oor.GetY1(), epsilon);
+  EXPECT_NEAR(1.5, cubic_oor.GetX2(), epsilon);
+  EXPECT_NEAR(-1.6, cubic_oor.GetY2(), epsilon);
+}
+
+void validateSolver(const CubicBezier& cubic_bezier) {
+  const double epsilon = 1e-7;
+  const double precision = 1e-5;
+  for (double t = 0; t <= 1; t += 0.05) {
+    double x = cubic_bezier.SampleCurveX(t);
+    double root = cubic_bezier.SolveCurveX(x, epsilon);
+    EXPECT_NEAR(t, root, precision);
+  }
+}
+
+TEST(CubicBezierTest, CommonEasingFunctions) {
+  validateSolver(CubicBezier(0.25, 0.1, 0.25, 1));  // ease
+  validateSolver(CubicBezier(0.42, 0, 1, 1));       // ease-in
+  validateSolver(CubicBezier(0, 0, 0.58, 1));       // ease-out
+  validateSolver(CubicBezier(0.42, 0, 0.58, 1));    // ease-in-out
+}
+
+TEST(CubicBezierTest, LinearEquivalentBeziers) {
+  validateSolver(CubicBezier(0.0, 0.0, 0.0, 0.0));
+  validateSolver(CubicBezier(1.0, 1.0, 1.0, 1.0));
+}
+
+TEST(CubicBezierTest, ControlPointsOutsideUnitSquare) {
+  validateSolver(CubicBezier(0.3, 1.5, 0.8, 1.5));
+  validateSolver(CubicBezier(0.4, -0.8, 0.7, 1.7));
+  validateSolver(CubicBezier(0.7, -2.0, 1.0, -1.5));
+  validateSolver(CubicBezier(0, 4, 1, -3));
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/geometry/dip_util.cc b/ui/gfx/geometry/dip_util.cc
new file mode 100644
index 0000000..11a15f7
--- /dev/null
+++ b/ui/gfx/geometry/dip_util.cc
@@ -0,0 +1,169 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/geometry/dip_util.h"
+
+#include "base/numerics/safe_conversions.h"
+#include "build/build_config.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_conversions.h"
+
+namespace gfx {
+
+#if defined(OS_MAC)
+// Returns true if the floating point value is holding an integer, modulo
+// floating point error. The value `f` can be safely converted to its integer
+// form with base::ClampRound().
+static bool IsIntegerInFloat(float f) {
+  return std::abs(f - base::ClampRound(f)) < 0.01f;
+}
+#endif
+
+PointF ConvertPointToDips(const Point& point_in_pixels,
+                          float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScalePoint(PointF(point_in_pixels), 1.f / device_scale_factor);
+}
+
+PointF ConvertPointToDips(const PointF& point_in_pixels,
+                          float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScalePoint(point_in_pixels, 1.f / device_scale_factor);
+}
+
+PointF ConvertPointToPixels(const Point& point_in_dips,
+                            float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScalePoint(PointF(point_in_dips), device_scale_factor);
+}
+
+PointF ConvertPointToPixels(const PointF& point_in_dips,
+                            float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScalePoint(point_in_dips, device_scale_factor);
+}
+
+SizeF ConvertSizeToDips(const Size& size_in_pixels, float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleSize(SizeF(size_in_pixels), 1.f / device_scale_factor);
+}
+
+SizeF ConvertSizeToDips(const SizeF& size_in_pixels,
+                        float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleSize(size_in_pixels, 1.f / device_scale_factor);
+}
+
+SizeF ConvertSizeToPixels(const Size& size_in_dips, float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleSize(SizeF(size_in_dips), device_scale_factor);
+}
+
+SizeF ConvertSizeToPixels(const SizeF& size_in_dips,
+                          float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleSize(size_in_dips, device_scale_factor);
+}
+
+RectF ConvertRectToDips(const Rect& rect_in_pixels, float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleRect(RectF(rect_in_pixels), 1.f / device_scale_factor);
+}
+
+RectF ConvertRectToDips(const RectF& rect_in_pixels,
+                        float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleRect(rect_in_pixels, 1.f / device_scale_factor);
+}
+
+RectF ConvertRectToPixels(const Rect& rect_in_dips, float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleRect(RectF(rect_in_dips), device_scale_factor);
+}
+
+RectF ConvertRectToPixels(const RectF& rect_in_dips,
+                          float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleRect(rect_in_dips, device_scale_factor);
+}
+
+InsetsF ConvertInsetsToDips(const gfx::Insets& insets_in_pixels,
+                            float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleInsets(InsetsF(insets_in_pixels), 1.f / device_scale_factor);
+}
+
+InsetsF ConvertInsetsToDips(const gfx::InsetsF& insets_in_pixels,
+                            float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleInsets(insets_in_pixels, 1.f / device_scale_factor);
+}
+
+InsetsF ConvertInsetsToPixels(const gfx::Insets& insets_in_dips,
+                              float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleInsets(InsetsF(insets_in_dips), device_scale_factor);
+}
+
+InsetsF ConvertInsetsToPixels(const gfx::InsetsF& insets_in_dips,
+                              float device_scale_factor) {
+#if defined(OS_MAC)
+  // Device scale factor on MacOSX is always an integer.
+  DCHECK(IsIntegerInFloat(device_scale_factor));
+#endif
+  return ScaleInsets(insets_in_dips, device_scale_factor);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/dip_util.h b/ui/gfx/geometry/dip_util.h
new file mode 100644
index 0000000..cc542a8
--- /dev/null
+++ b/ui/gfx/geometry/dip_util.h
@@ -0,0 +1,83 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_DIP_UTIL_H_
+#define UI_GFX_GEOMETRY_DIP_UTIL_H_
+
+#include "ui/gfx/geometry/geometry_export.h"
+
+namespace gfx {
+
+class Insets;
+class InsetsF;
+class Point;
+class PointF;
+class Rect;
+class RectF;
+class Size;
+class SizeF;
+
+// This file contains helper functions to move between DIPs (device-independent
+// pixels) and physical pixels, by multiplying or dividing by device scale
+// factor. These help show the intent of the caller by naming the operation,
+// instead of directly performing a scale operation. More complicated
+// transformations between coordinate spaces than DIP<->physical pixels should
+// be done via more explicit means.
+//
+// Note that functions that receive integer values will convert them to floating
+// point values, which can itself be a lossy operation for large integers. The
+// intention of these methods is to be used for UI values which are relatively
+// small.
+
+GEOMETRY_EXPORT gfx::PointF ConvertPointToDips(
+    const gfx::Point& point_in_pixels,
+    float device_scale_factor);
+GEOMETRY_EXPORT gfx::PointF ConvertPointToDips(
+    const gfx::PointF& point_in_pixels,
+    float device_scale_factor);
+
+GEOMETRY_EXPORT gfx::PointF ConvertPointToPixels(
+    const gfx::Point& point_in_dips,
+    float device_scale_factor);
+GEOMETRY_EXPORT gfx::PointF ConvertPointToPixels(
+    const gfx::PointF& point_in_dips,
+    float device_scale_factor);
+
+GEOMETRY_EXPORT gfx::SizeF ConvertSizeToDips(const gfx::Size& size_in_pixels,
+                                             float device_scale_factor);
+GEOMETRY_EXPORT gfx::SizeF ConvertSizeToDips(const gfx::SizeF& size_in_pixels,
+                                             float device_scale_factor);
+
+GEOMETRY_EXPORT gfx::SizeF ConvertSizeToPixels(const gfx::Size& size_in_dips,
+                                               float device_scale_factor);
+GEOMETRY_EXPORT gfx::SizeF ConvertSizeToPixels(const gfx::SizeF& size_in_dips,
+                                               float device_scale_factor);
+
+GEOMETRY_EXPORT gfx::RectF ConvertRectToDips(const gfx::Rect& rect_in_pixels,
+                                             float device_scale_factor);
+GEOMETRY_EXPORT gfx::RectF ConvertRectToDips(const gfx::RectF& rect_in_pixels,
+                                             float device_scale_factor);
+
+GEOMETRY_EXPORT gfx::RectF ConvertRectToPixels(const gfx::Rect& rect_in_dips,
+                                               float device_scale_factor);
+GEOMETRY_EXPORT gfx::RectF ConvertRectToPixels(const gfx::RectF& rect_in_dips,
+                                               float device_scale_factor);
+
+GEOMETRY_EXPORT gfx::InsetsF ConvertInsetsToDips(
+    const gfx::Insets& insets_in_pixels,
+    float device_scale_factor);
+GEOMETRY_EXPORT gfx::InsetsF ConvertInsetsToDips(
+    const gfx::InsetsF& insets_in_pixels,
+    float device_scale_factor);
+
+GEOMETRY_EXPORT gfx::InsetsF ConvertInsetsToPixels(
+    const gfx::Insets& insets_in_dips,
+    float device_scale_factor);
+GEOMETRY_EXPORT gfx::InsetsF ConvertInsetsToPixels(
+    const gfx::InsetsF& insets_in_dips,
+    float device_scale_factor);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_DIP_UTIL_H_
diff --git a/ui/gfx/geometry/geometry_export.h b/ui/gfx/geometry/geometry_export.h
new file mode 100644
index 0000000..5e68787
--- /dev/null
+++ b/ui/gfx/geometry/geometry_export.h
@@ -0,0 +1,29 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_GEOMETRY_EXPORT_H_
+#define UI_GFX_GEOMETRY_GEOMETRY_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GEOMETRY_IMPLEMENTATION)
+#define GEOMETRY_EXPORT __declspec(dllexport)
+#else
+#define GEOMETRY_EXPORT __declspec(dllimport)
+#endif  // defined(GEOMETRY_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GEOMETRY_IMPLEMENTATION)
+#define GEOMETRY_EXPORT __attribute__((visibility("default")))
+#else
+#define GEOMETRY_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GEOMETRY_EXPORT
+#endif
+
+#endif  // UI_GFX_GEOMETRY_GEOMETRY_EXPORT_H_
diff --git a/ui/gfx/geometry/geometry_skia_export.h b/ui/gfx/geometry/geometry_skia_export.h
new file mode 100644
index 0000000..b7cda33
--- /dev/null
+++ b/ui/gfx/geometry/geometry_skia_export.h
@@ -0,0 +1,29 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_GEOMETRY_SKIA_EXPORT_H_
+#define UI_GFX_GEOMETRY_GEOMETRY_SKIA_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GEOMETRY_SKIA_IMPLEMENTATION)
+#define GEOMETRY_SKIA_EXPORT __declspec(dllexport)
+#else
+#define GEOMETRY_SKIA_EXPORT __declspec(dllimport)
+#endif  // defined(GEOMETRY_SKIA_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GEOMETRY_SKIA_IMPLEMENTATION)
+#define GEOMETRY_SKIA_EXPORT __attribute__((visibility("default")))
+#else
+#define GEOMETRY_SKIA_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GEOMETRY_SKIA_EXPORT
+#endif
+
+#endif  // UI_GFX_GEOMETRY_GEOMETRY_SKIA_EXPORT_H_
diff --git a/ui/gfx/geometry/insets.cc b/ui/gfx/geometry/insets.cc
new file mode 100644
index 0000000..0e706e1
--- /dev/null
+++ b/ui/gfx/geometry/insets.cc
@@ -0,0 +1,66 @@
+// Copyright (c) 2009 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.
+
+#include "ui/gfx/geometry/insets.h"
+
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/geometry/insets_conversions.h"
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/vector2d.h"
+
+namespace gfx {
+
+std::string Insets::ToString() const {
+  // Print members in the same order of the constructor parameters.
+  return base::StringPrintf("%d,%d,%d,%d", top(),  left(), bottom(), right());
+}
+
+Insets Insets::Offset(const gfx::Vector2d& vector) const {
+  return gfx::Insets(base::ClampAdd(top(), vector.y()),
+                     base::ClampAdd(left(), vector.x()),
+                     base::ClampSub(bottom(), vector.y()),
+                     base::ClampSub(right(), vector.x()));
+}
+
+Insets ScaleToCeiledInsets(const Insets& insets, float x_scale, float y_scale) {
+  if (x_scale == 1.f && y_scale == 1.f)
+    return insets;
+  return ToCeiledInsets(ScaleInsets(gfx::InsetsF(insets), x_scale, y_scale));
+}
+
+Insets ScaleToCeiledInsets(const Insets& insets, float scale) {
+  if (scale == 1.f)
+    return insets;
+  return ToCeiledInsets(ScaleInsets(gfx::InsetsF(insets), scale));
+}
+
+Insets ScaleToFlooredInsets(const Insets& insets,
+                            float x_scale,
+                            float y_scale) {
+  if (x_scale == 1.f && y_scale == 1.f)
+    return insets;
+  return ToFlooredInsets(ScaleInsets(gfx::InsetsF(insets), x_scale, y_scale));
+}
+
+Insets ScaleToFlooredInsets(const Insets& insets, float scale) {
+  if (scale == 1.f)
+    return insets;
+  return ToFlooredInsets(ScaleInsets(gfx::InsetsF(insets), scale));
+}
+
+Insets ScaleToRoundedInsets(const Insets& insets,
+                            float x_scale,
+                            float y_scale) {
+  if (x_scale == 1.f && y_scale == 1.f)
+    return insets;
+  return ToRoundedInsets(ScaleInsets(gfx::InsetsF(insets), x_scale, y_scale));
+}
+
+Insets ScaleToRoundedInsets(const Insets& insets, float scale) {
+  if (scale == 1.f)
+    return insets;
+  return ToRoundedInsets(ScaleInsets(gfx::InsetsF(insets), scale));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/insets.h b/ui/gfx/geometry/insets.h
new file mode 100644
index 0000000..9d83dca
--- /dev/null
+++ b/ui/gfx/geometry/insets.h
@@ -0,0 +1,199 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_INSETS_H_
+#define UI_GFX_GEOMETRY_INSETS_H_
+
+#include <string>
+
+#include "base/numerics/clamped_math.h"
+#include "ui/gfx/geometry/geometry_export.h"
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace gfx {
+
+class Vector2d;
+
+// Represents the widths of the four borders or margins of an unspecified
+// rectangle. An Insets stores the thickness of the top, left, bottom and right
+// edges, without storing the actual size and position of the rectangle itself.
+//
+// This can be used to represent a space within a rectangle, by "shrinking" the
+// rectangle by the inset amount on all four sides. Alternatively, it can
+// represent a border that has a different thickness on each side.
+class GEOMETRY_EXPORT Insets {
+ public:
+  constexpr Insets() : top_(0), left_(0), bottom_(0), right_(0) {}
+  constexpr explicit Insets(int all)
+      : top_(all),
+        left_(all),
+        bottom_(GetClampedValue(all, all)),
+        right_(GetClampedValue(all, all)) {}
+  constexpr explicit Insets(int vertical, int horizontal)
+      : top_(vertical),
+        left_(horizontal),
+        bottom_(GetClampedValue(vertical, vertical)),
+        right_(GetClampedValue(horizontal, horizontal)) {}
+  constexpr Insets(int top, int left, int bottom, int right)
+      : top_(top),
+        left_(left),
+        bottom_(GetClampedValue(top, bottom)),
+        right_(GetClampedValue(left, right)) {}
+
+  constexpr int top() const { return top_; }
+  constexpr int left() const { return left_; }
+  constexpr int bottom() const { return bottom_; }
+  constexpr int right() const { return right_; }
+
+  // Returns the total width taken up by the insets, which is the sum of the
+  // left and right insets.
+  constexpr int width() const { return left_ + right_; }
+
+  // Returns the total height taken up by the insets, which is the sum of the
+  // top and bottom insets.
+  constexpr int height() const { return top_ + bottom_; }
+
+  // Returns the sum of the left and right insets as the width, the sum of the
+  // top and bottom insets as the height.
+  constexpr Size size() const { return Size(width(), height()); }
+
+  // Returns true if the insets are empty.
+  bool IsEmpty() const { return width() == 0 && height() == 0; }
+
+  void set_top(int top) {
+    top_ = top;
+    bottom_ = GetClampedValue(top_, bottom_);
+  }
+  void set_left(int left) {
+    left_ = left;
+    right_ = GetClampedValue(left_, right_);
+  }
+  void set_bottom(int bottom) { bottom_ = GetClampedValue(top_, bottom); }
+  void set_right(int right) { right_ = GetClampedValue(left_, right); }
+
+  void Set(int top, int left, int bottom, int right) {
+    top_ = top;
+    left_ = left;
+    bottom_ = GetClampedValue(top_, bottom);
+    right_ = GetClampedValue(left_, right);
+  }
+
+  bool operator==(const Insets& insets) const {
+    return top_ == insets.top_ && left_ == insets.left_ &&
+           bottom_ == insets.bottom_ && right_ == insets.right_;
+  }
+
+  bool operator!=(const Insets& insets) const {
+    return !(*this == insets);
+  }
+
+  void operator+=(const Insets& insets) {
+    top_ = base::ClampAdd(top_, insets.top_);
+    left_ = base::ClampAdd(left_, insets.left_);
+    bottom_ = GetClampedValue(top_, base::ClampAdd(bottom_, insets.bottom_));
+    right_ = GetClampedValue(left_, base::ClampAdd(right_, insets.right_));
+  }
+
+  void operator-=(const Insets& insets) {
+    top_ = base::ClampSub(top_, insets.top_);
+    left_ = base::ClampSub(left_, insets.left_);
+    bottom_ = GetClampedValue(top_, base::ClampSub(bottom_, insets.bottom_));
+    right_ = GetClampedValue(left_, base::ClampSub(right_, insets.right_));
+  }
+
+  Insets operator-() const {
+    return Insets(-base::MakeClampedNum(top_), -base::MakeClampedNum(left_),
+                  -base::MakeClampedNum(bottom_),
+                  -base::MakeClampedNum(right_));
+  }
+
+  // Adjusts the vertical and horizontal dimensions by the values described in
+  // |vector|. Offsetting insets before applying to a rectangle would be
+  // equivalent to offseting the rectangle then applying the insets.
+  Insets Offset(const gfx::Vector2d& vector) const;
+
+  operator InsetsF() const {
+    return InsetsF(static_cast<float>(top()), static_cast<float>(left()),
+                   static_cast<float>(bottom()), static_cast<float>(right()));
+  }
+
+  // Returns a string representation of the insets.
+  std::string ToString() const;
+
+ private:
+  int top_;
+  int left_;
+  int bottom_;
+  int right_;
+
+  // See ui/gfx/geometry/rect.h
+  // Returns true iff a+b would overflow max int.
+  static constexpr bool AddWouldOverflow(int a, int b) {
+    // In this function, GCC tries to make optimizations that would only work if
+    // max - a wouldn't overflow but it isn't smart enough to notice that a > 0.
+    // So cast everything to unsigned to avoid this.  As it is guaranteed that
+    // max - a and b are both already positive, the cast is a noop.
+    //
+    // This is intended to be: a > 0 && max - a < b
+    return a > 0 && b > 0 &&
+           static_cast<unsigned>(std::numeric_limits<int>::max() - a) <
+               static_cast<unsigned>(b);
+  }
+
+  // Returns true iff a+b would underflow min int.
+  static constexpr bool AddWouldUnderflow(int a, int b) {
+    return a < 0 && b < 0 && std::numeric_limits<int>::min() - a > b;
+  }
+
+  // Clamp the right/bottom to avoid integer over/underflow in width() and
+  // height(). This returns the right/bottom given a top_or_left and a
+  // bottom_or_right.
+  // TODO(enne): this should probably use base::ClampAdd, but that
+  // function is not a constexpr.
+  static constexpr int GetClampedValue(int top_or_left, int bottom_or_right) {
+    if (AddWouldOverflow(top_or_left, bottom_or_right)) {
+      return std::numeric_limits<int>::max() - top_or_left;
+    } else if (AddWouldUnderflow(top_or_left, bottom_or_right)) {
+      // If |top_or_left| and |bottom_or_right| are both negative,
+      // adds |top_or_left| to prevent underflow by subtracting it.
+      return std::numeric_limits<int>::min() - top_or_left;
+    } else {
+      return bottom_or_right;
+    }
+  }
+};
+
+// This is declared here for use in gtest-based unit tests but is defined in
+// the //ui/gfx:test_support target. Depend on that to use this in your unit
+// test. This should not be used in production code - call ToString() instead.
+void PrintTo(const Insets& point, ::std::ostream* os);
+
+inline Insets operator+(Insets lhs, const Insets& rhs) {
+  lhs += rhs;
+  return lhs;
+}
+
+inline Insets operator-(Insets lhs, const Insets& rhs) {
+  lhs -= rhs;
+  return lhs;
+}
+
+// Helper methods to scale a gfx::Insets to a new gfx::Insets.
+GEOMETRY_EXPORT Insets ScaleToCeiledInsets(const Insets& insets,
+                                           float x_scale,
+                                           float y_scale);
+GEOMETRY_EXPORT Insets ScaleToCeiledInsets(const Insets& insets, float scale);
+GEOMETRY_EXPORT Insets ScaleToFlooredInsets(const Insets& insets,
+                                            float x_scale,
+                                            float y_scale);
+GEOMETRY_EXPORT Insets ScaleToFlooredInsets(const Insets& insets, float scale);
+GEOMETRY_EXPORT Insets ScaleToRoundedInsets(const Insets& insets,
+                                            float x_scale,
+                                            float y_scale);
+GEOMETRY_EXPORT Insets ScaleToRoundedInsets(const Insets& insets, float scale);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_INSETS_H_
diff --git a/ui/gfx/geometry/insets_conversions.cc b/ui/gfx/geometry/insets_conversions.cc
new file mode 100644
index 0000000..e41a600
--- /dev/null
+++ b/ui/gfx/geometry/insets_conversions.cc
@@ -0,0 +1,31 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/geometry/insets_conversions.h"
+
+#include "base/numerics/safe_conversions.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/insets_f.h"
+
+namespace gfx {
+
+Insets ToFlooredInsets(const InsetsF& insets) {
+  return Insets(base::ClampFloor(insets.top()), base::ClampFloor(insets.left()),
+                base::ClampFloor(insets.bottom()),
+                base::ClampFloor(insets.right()));
+}
+
+Insets ToCeiledInsets(const InsetsF& insets) {
+  return Insets(base::ClampCeil(insets.top()), base::ClampCeil(insets.left()),
+                base::ClampCeil(insets.bottom()),
+                base::ClampCeil(insets.right()));
+}
+
+Insets ToRoundedInsets(const InsetsF& insets) {
+  return Insets(base::ClampRound(insets.top()), base::ClampRound(insets.left()),
+                base::ClampRound(insets.bottom()),
+                base::ClampRound(insets.right()));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/insets_conversions.h b/ui/gfx/geometry/insets_conversions.h
new file mode 100644
index 0000000..6135150
--- /dev/null
+++ b/ui/gfx/geometry/insets_conversions.h
@@ -0,0 +1,25 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_INSETS_CONVERSIONS_H_
+#define UI_GFX_GEOMETRY_INSETS_CONVERSIONS_H_
+
+#include "ui/gfx/geometry/geometry_export.h"
+
+namespace gfx {
+class Insets;
+class InsetsF;
+
+// Returns an Insets with each component from the input InsetsF floored.
+GEOMETRY_EXPORT Insets ToFlooredInsets(const InsetsF& insets);
+
+// Returns an Insets with each component from the input InsetsF ceiled.
+GEOMETRY_EXPORT Insets ToCeiledInsets(const InsetsF& insets);
+
+// Returns a Point with each component from the input PointF rounded.
+GEOMETRY_EXPORT Insets ToRoundedInsets(const InsetsF& insets);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_INSETS_CONVERSIONS_H_
diff --git a/ui/gfx/geometry/insets_f.cc b/ui/gfx/geometry/insets_f.cc
new file mode 100644
index 0000000..c1bc27e
--- /dev/null
+++ b/ui/gfx/geometry/insets_f.cc
@@ -0,0 +1,16 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/insets_f.h"
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+std::string InsetsF::ToString() const {
+  // Print members in the same order of the constructor parameters.
+  return base::StringPrintf("%f,%f,%f,%f", top(),  left(), bottom(), right());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/insets_f.h b/ui/gfx/geometry/insets_f.h
new file mode 100644
index 0000000..3d9380c
--- /dev/null
+++ b/ui/gfx/geometry/insets_f.h
@@ -0,0 +1,120 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_INSETS_F_H_
+#define UI_GFX_GEOMETRY_INSETS_F_H_
+
+#include <string>
+
+#include "ui/gfx/geometry/geometry_export.h"
+
+namespace gfx {
+
+// A floating point version of gfx::Insets.
+class GEOMETRY_EXPORT InsetsF {
+ public:
+  constexpr InsetsF() : top_(0.f), left_(0.f), bottom_(0.f), right_(0.f) {}
+  constexpr explicit InsetsF(float all)
+      : top_(all), left_(all), bottom_(all), right_(all) {}
+  constexpr InsetsF(float vertical, float horizontal)
+      : top_(vertical),
+        left_(horizontal),
+        bottom_(vertical),
+        right_(horizontal) {}
+  constexpr InsetsF(float top, float left, float bottom, float right)
+      : top_(top), left_(left), bottom_(bottom), right_(right) {}
+
+  constexpr float top() const { return top_; }
+  constexpr float left() const { return left_; }
+  constexpr float bottom() const { return bottom_; }
+  constexpr float right() const { return right_; }
+
+  // Returns the total width taken up by the insets, which is the sum of the
+  // left and right insets.
+  constexpr float width() const { return left_ + right_; }
+
+  // Returns the total height taken up by the insets, which is the sum of the
+  // top and bottom insets.
+  constexpr float height() const { return top_ + bottom_; }
+
+  // Returns true if the insets are empty.
+  bool IsEmpty() const { return width() == 0.f && height() == 0.f; }
+
+  void Set(float top, float left, float bottom, float right) {
+    top_ = top;
+    left_ = left;
+    bottom_ = bottom;
+    right_ = right;
+  }
+
+  bool operator==(const InsetsF& insets) const {
+    return top_ == insets.top_ && left_ == insets.left_ &&
+           bottom_ == insets.bottom_ && right_ == insets.right_;
+  }
+
+  bool operator!=(const InsetsF& insets) const {
+    return !(*this == insets);
+  }
+
+  void operator+=(const InsetsF& insets) {
+    top_ += insets.top_;
+    left_ += insets.left_;
+    bottom_ += insets.bottom_;
+    right_ += insets.right_;
+  }
+
+  void operator-=(const InsetsF& insets) {
+    top_ -= insets.top_;
+    left_ -= insets.left_;
+    bottom_ -= insets.bottom_;
+    right_ -= insets.right_;
+  }
+
+  InsetsF operator-() const {
+    return InsetsF(-top_, -left_, -bottom_, -right_);
+  }
+
+  InsetsF Scale(float scale) const {
+    return InsetsF(scale * top(), scale * left(), scale * bottom(),
+                   scale * right());
+  }
+
+  // Returns a string representation of the insets.
+  std::string ToString() const;
+
+ private:
+  float top_;
+  float left_;
+  float bottom_;
+  float right_;
+};
+
+// This is declared here for use in gtest-based unit tests but is defined in
+// the //ui/gfx:test_support target. Depend on that to use this in your unit
+// test. This should not be used in production code - call ToString() instead.
+void PrintTo(const InsetsF& point, ::std::ostream* os);
+
+inline InsetsF ScaleInsets(const InsetsF& i, float scale) {
+  return InsetsF(i.top() * scale, i.left() * scale, i.bottom() * scale,
+                 i.right() * scale);
+}
+
+inline InsetsF ScaleInsets(const InsetsF& i, float x_scale, float y_scale) {
+  return InsetsF(i.top() * y_scale, i.left() * x_scale, i.bottom() * y_scale,
+                 i.right() * x_scale);
+}
+
+inline InsetsF operator+(InsetsF lhs, const InsetsF& rhs) {
+  lhs += rhs;
+  return lhs;
+}
+
+inline InsetsF operator-(InsetsF lhs, const InsetsF& rhs) {
+  lhs -= rhs;
+  return lhs;
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_INSETS_F_H_
diff --git a/ui/gfx/geometry/insets_unittest.cc b/ui/gfx/geometry/insets_unittest.cc
new file mode 100644
index 0000000..83ef910
--- /dev/null
+++ b/ui/gfx/geometry/insets_unittest.cc
@@ -0,0 +1,336 @@
+// Copyright (c) 2009 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.
+
+#include "ui/gfx/geometry/insets.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/vector2d.h"
+
+TEST(InsetsTest, InsetsDefault) {
+  gfx::Insets insets;
+  EXPECT_EQ(0, insets.top());
+  EXPECT_EQ(0, insets.left());
+  EXPECT_EQ(0, insets.bottom());
+  EXPECT_EQ(0, insets.right());
+  EXPECT_EQ(0, insets.width());
+  EXPECT_EQ(0, insets.height());
+  EXPECT_TRUE(insets.IsEmpty());
+}
+
+TEST(InsetsTest, Insets) {
+  gfx::Insets insets(1, 2, 3, 4);
+  EXPECT_EQ(1, insets.top());
+  EXPECT_EQ(2, insets.left());
+  EXPECT_EQ(3, insets.bottom());
+  EXPECT_EQ(4, insets.right());
+  EXPECT_EQ(6, insets.width());  // Left + right.
+  EXPECT_EQ(4, insets.height());  // Top + bottom.
+  EXPECT_FALSE(insets.IsEmpty());
+}
+
+TEST(InsetsTest, SetTop) {
+  gfx::Insets insets(1);
+  insets.set_top(2);
+  EXPECT_EQ(gfx::Insets(2, 1, 1, 1), insets);
+}
+
+TEST(InsetsTest, SetBottom) {
+  gfx::Insets insets(1);
+  insets.set_bottom(2);
+  EXPECT_EQ(gfx::Insets(1, 1, 2, 1), insets);
+}
+
+TEST(InsetsTest, SetLeft) {
+  gfx::Insets insets(1);
+  insets.set_left(2);
+  EXPECT_EQ(gfx::Insets(1, 2, 1, 1), insets);
+}
+
+TEST(InsetsTest, SetRight) {
+  gfx::Insets insets(1);
+  insets.set_right(2);
+  EXPECT_EQ(gfx::Insets(1, 1, 1, 2), insets);
+}
+
+TEST(InsetsTest, Set) {
+  gfx::Insets insets;
+  insets.Set(1, 2, 3, 4);
+  EXPECT_EQ(1, insets.top());
+  EXPECT_EQ(2, insets.left());
+  EXPECT_EQ(3, insets.bottom());
+  EXPECT_EQ(4, insets.right());
+}
+
+TEST(InsetsTest, Operators) {
+  gfx::Insets insets;
+  insets.Set(1, 2, 3, 4);
+  insets += gfx::Insets(5, 6, 7, 8);
+  EXPECT_EQ(6, insets.top());
+  EXPECT_EQ(8, insets.left());
+  EXPECT_EQ(10, insets.bottom());
+  EXPECT_EQ(12, insets.right());
+
+  insets -= gfx::Insets(-1, 0, 1, 2);
+  EXPECT_EQ(7, insets.top());
+  EXPECT_EQ(8, insets.left());
+  EXPECT_EQ(9, insets.bottom());
+  EXPECT_EQ(10, insets.right());
+
+  insets = gfx::Insets(10, 10, 10, 10) + gfx::Insets(5, 5, 0, -20);
+  EXPECT_EQ(15, insets.top());
+  EXPECT_EQ(15, insets.left());
+  EXPECT_EQ(10, insets.bottom());
+  EXPECT_EQ(-10, insets.right());
+
+  insets = gfx::Insets(10, 10, 10, 10) - gfx::Insets(5, 5, 0, -20);
+  EXPECT_EQ(5, insets.top());
+  EXPECT_EQ(5, insets.left());
+  EXPECT_EQ(10, insets.bottom());
+  EXPECT_EQ(30, insets.right());
+}
+
+TEST(InsetsFTest, Operators) {
+  gfx::InsetsF insets;
+  insets.Set(1.f, 2.5f, 3.3f, 4.1f);
+  insets += gfx::InsetsF(5.8f, 6.7f, 7.6f, 8.5f);
+  EXPECT_FLOAT_EQ(6.8f, insets.top());
+  EXPECT_FLOAT_EQ(9.2f, insets.left());
+  EXPECT_FLOAT_EQ(10.9f, insets.bottom());
+  EXPECT_FLOAT_EQ(12.6f, insets.right());
+
+  insets -= gfx::InsetsF(-1.f, 0, 1.1f, 2.2f);
+  EXPECT_FLOAT_EQ(7.8f, insets.top());
+  EXPECT_FLOAT_EQ(9.2f, insets.left());
+  EXPECT_FLOAT_EQ(9.8f, insets.bottom());
+  EXPECT_FLOAT_EQ(10.4f, insets.right());
+
+  insets = gfx::InsetsF(10, 10.1f, 10.01f, 10.001f) +
+           gfx::InsetsF(5.5f, 5.f, 0, -20.2f);
+  EXPECT_FLOAT_EQ(15.5f, insets.top());
+  EXPECT_FLOAT_EQ(15.1f, insets.left());
+  EXPECT_FLOAT_EQ(10.01f, insets.bottom());
+  EXPECT_FLOAT_EQ(-10.199f, insets.right());
+
+  insets = gfx::InsetsF(10, 10.1f, 10.01f, 10.001f) -
+           gfx::InsetsF(5.5f, 5.f, 0, -20.2f);
+  EXPECT_FLOAT_EQ(4.5f, insets.top());
+  EXPECT_FLOAT_EQ(5.1f, insets.left());
+  EXPECT_FLOAT_EQ(10.01f, insets.bottom());
+  EXPECT_FLOAT_EQ(30.201f, insets.right());
+}
+
+TEST(InsetsTest, Equality) {
+  gfx::Insets insets1;
+  insets1.Set(1, 2, 3, 4);
+  gfx::Insets insets2;
+  // Test operator== and operator!=.
+  EXPECT_FALSE(insets1 == insets2);
+  EXPECT_TRUE(insets1 != insets2);
+
+  insets2.Set(1, 2, 3, 4);
+  EXPECT_TRUE(insets1 == insets2);
+  EXPECT_FALSE(insets1 != insets2);
+}
+
+TEST(InsetsTest, ToString) {
+  gfx::Insets insets(1, 2, 3, 4);
+  EXPECT_EQ("1,2,3,4", insets.ToString());
+}
+
+TEST(InsetsTest, Offset) {
+  const gfx::Insets insets(1, 2, 3, 4);
+  const gfx::Rect rect(5, 6, 7, 8);
+  const gfx::Vector2d vector(9, 10);
+
+  // Whether you inset then offset the rect, offset then inset the rect, or
+  // offset the insets then apply to the rect, the outcome should be the same.
+  gfx::Rect inset_first = rect;
+  inset_first.Inset(insets);
+  inset_first.Offset(vector);
+
+  gfx::Rect offset_first = rect;
+  offset_first.Offset(vector);
+  offset_first.Inset(insets);
+
+  gfx::Rect inset_by_offset = rect;
+  inset_by_offset.Inset(insets.Offset(vector));
+
+  EXPECT_EQ(inset_first, offset_first);
+  EXPECT_EQ(inset_by_offset, inset_first);
+}
+
+TEST(InsetsTest, Scale) {
+  gfx::Insets in(7, 5);
+
+  gfx::InsetsF testf = gfx::ScaleInsets(in, 2.5f, 3.5f);
+  EXPECT_EQ(gfx::InsetsF(24.5f, 12.5f), testf);
+  testf = gfx::ScaleInsets(in, 2.5f);
+  EXPECT_EQ(gfx::InsetsF(17.5f, 12.5f), testf);
+
+  gfx::Insets test = gfx::ScaleToFlooredInsets(in, 2.5f, 3.5f);
+  EXPECT_EQ(gfx::Insets(24, 12), test);
+  test = gfx::ScaleToFlooredInsets(in, 2.5f);
+  EXPECT_EQ(gfx::Insets(17, 12), test);
+
+  test = gfx::ScaleToCeiledInsets(in, 2.5f, 3.5f);
+  EXPECT_EQ(gfx::Insets(25, 13), test);
+  test = gfx::ScaleToCeiledInsets(in, 2.5f);
+  EXPECT_EQ(gfx::Insets(18, 13), test);
+
+  test = gfx::ScaleToRoundedInsets(in, 2.49f, 3.49f);
+  EXPECT_EQ(gfx::Insets(24, 12), test);
+  test = gfx::ScaleToRoundedInsets(in, 2.49f);
+  EXPECT_EQ(gfx::Insets(17, 12), test);
+
+  test = gfx::ScaleToRoundedInsets(in, 2.5f, 3.5f);
+  EXPECT_EQ(gfx::Insets(25, 13), test);
+  test = gfx::ScaleToRoundedInsets(in, 2.5f);
+  EXPECT_EQ(gfx::Insets(18, 13), test);
+}
+
+TEST(InsetsTest, ScaleNegative) {
+  gfx::Insets in(-7, -5);
+
+  gfx::InsetsF testf = gfx::ScaleInsets(in, 2.5f, 3.5f);
+  EXPECT_EQ(gfx::InsetsF(-24.5f, -12.5f), testf);
+  testf = gfx::ScaleInsets(in, 2.5f);
+  EXPECT_EQ(gfx::InsetsF(-17.5f, -12.5f), testf);
+
+  gfx::Insets test = gfx::ScaleToFlooredInsets(in, 2.5f, 3.5f);
+  EXPECT_EQ(gfx::Insets(-25, -13), test);
+  test = gfx::ScaleToFlooredInsets(in, 2.5f);
+  EXPECT_EQ(gfx::Insets(-18, -13), test);
+
+  test = gfx::ScaleToCeiledInsets(in, 2.5f, 3.5f);
+  EXPECT_EQ(gfx::Insets(-24, -12), test);
+  test = gfx::ScaleToCeiledInsets(in, 2.5f);
+  EXPECT_EQ(gfx::Insets(-17, -12), test);
+
+  test = gfx::ScaleToRoundedInsets(in, 2.49f, 3.49f);
+  EXPECT_EQ(gfx::Insets(-24, -12), test);
+  test = gfx::ScaleToRoundedInsets(in, 2.49f);
+  EXPECT_EQ(gfx::Insets(-17, -12), test);
+
+  test = gfx::ScaleToRoundedInsets(in, 2.5f, 3.5f);
+  EXPECT_EQ(gfx::Insets(-25, -13), test);
+  test = gfx::ScaleToRoundedInsets(in, 2.5f);
+  EXPECT_EQ(gfx::Insets(-18, -13), test);
+}
+
+TEST(InsetsTest, IntegerOverflow) {
+  constexpr int int_min = std::numeric_limits<int>::min();
+  constexpr int int_max = std::numeric_limits<int>::max();
+
+  gfx::Insets width_height_test(int_max);
+  EXPECT_EQ(int_max, width_height_test.width());
+  EXPECT_EQ(int_max, width_height_test.height());
+
+  gfx::Insets plus_test(int_max);
+  plus_test += gfx::Insets(int_max);
+  EXPECT_EQ(gfx::Insets(int_max), plus_test);
+
+  gfx::Insets negation_test = -gfx::Insets(int_min);
+  EXPECT_EQ(gfx::Insets(int_max), negation_test);
+
+  gfx::Insets scale_test(int_max);
+  scale_test = gfx::ScaleToRoundedInsets(scale_test, 2.f);
+  EXPECT_EQ(gfx::Insets(int_max), scale_test);
+}
+
+TEST(InsetsTest, IntegerUnderflow) {
+  constexpr int int_min = std::numeric_limits<int>::min();
+  constexpr int int_max = std::numeric_limits<int>::max();
+
+  gfx::Insets width_height_test = gfx::Insets(int_min);
+  EXPECT_EQ(int_min, width_height_test.width());
+  EXPECT_EQ(int_min, width_height_test.height());
+
+  gfx::Insets minus_test(int_min);
+  minus_test -= gfx::Insets(int_max);
+  EXPECT_EQ(gfx::Insets(int_min), minus_test);
+
+  gfx::Insets scale_test = gfx::Insets(int_min);
+  scale_test = gfx::ScaleToRoundedInsets(scale_test, 2.f);
+  EXPECT_EQ(gfx::Insets(int_min), scale_test);
+}
+
+TEST(InsetsTest, IntegerOverflowSetVariants) {
+  constexpr int int_max = std::numeric_limits<int>::max();
+
+  gfx::Insets set_test(20);
+  set_test.set_top(int_max);
+  EXPECT_EQ(int_max, set_test.top());
+  EXPECT_EQ(0, set_test.bottom());
+
+  set_test.set_left(int_max);
+  EXPECT_EQ(int_max, set_test.left());
+  EXPECT_EQ(0, set_test.right());
+
+  set_test = gfx::Insets(30);
+  set_test.set_bottom(int_max);
+  EXPECT_EQ(int_max - 30, set_test.bottom());
+  EXPECT_EQ(30, set_test.top());
+
+  set_test.set_right(int_max);
+  EXPECT_EQ(int_max - 30, set_test.right());
+  EXPECT_EQ(30, set_test.left());
+}
+
+TEST(InsetsTest, IntegerUnderflowSetVariants) {
+  constexpr int int_min = std::numeric_limits<int>::min();
+
+  gfx::Insets set_test(-20);
+  set_test.set_top(int_min);
+  EXPECT_EQ(int_min, set_test.top());
+  EXPECT_EQ(0, set_test.bottom());
+
+  set_test.set_left(int_min);
+  EXPECT_EQ(int_min, set_test.left());
+  EXPECT_EQ(0, set_test.right());
+
+  set_test = gfx::Insets(-30);
+  set_test.set_bottom(int_min);
+  EXPECT_EQ(int_min + 30, set_test.bottom());
+  EXPECT_EQ(-30, set_test.top());
+
+  set_test.set_right(int_min);
+  EXPECT_EQ(int_min + 30, set_test.right());
+  EXPECT_EQ(-30, set_test.left());
+}
+
+TEST(InsetsTest, IntegerOverflowSet) {
+  constexpr int int_max = std::numeric_limits<int>::max();
+
+  gfx::Insets set_all_test;
+  set_all_test.Set(10, 20, int_max, int_max);
+  EXPECT_EQ(gfx::Insets(10, 20, int_max - 10, int_max - 20), set_all_test);
+}
+
+TEST(InsetsTest, IntegerOverflowOffset) {
+  constexpr int int_max = std::numeric_limits<int>::max();
+
+  const gfx::Vector2d max_vector(int_max, int_max);
+  gfx::Insets insets(1, 2, 3, 4);
+  gfx::Insets offset_test = insets.Offset(max_vector);
+  EXPECT_EQ(gfx::Insets(int_max, int_max, 3 - int_max, 4 - int_max),
+            offset_test);
+}
+
+TEST(InsetsTest, IntegerUnderflowOffset) {
+  constexpr int int_min = std::numeric_limits<int>::min();
+
+  const gfx::Vector2d min_vector(int_min, int_min);
+  gfx::Insets insets(-10);
+  gfx::Insets offset_test = insets.Offset(min_vector);
+  EXPECT_EQ(gfx::Insets(int_min, int_min, -10 - int_min, -10 - int_min),
+            offset_test);
+}
+
+TEST(InsetsTest, Size) {
+  gfx::Insets insets(1, 2, 3, 4);
+  EXPECT_EQ(gfx::Size(6, 4), insets.size());
+}
diff --git a/ui/gfx/geometry/mask_filter_info.cc b/ui/gfx/geometry/mask_filter_info.cc
new file mode 100644
index 0000000..9757acd
--- /dev/null
+++ b/ui/gfx/geometry/mask_filter_info.cc
@@ -0,0 +1,23 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/geometry/mask_filter_info.h"
+
+#include <sstream>
+
+#include "ui/gfx/geometry/transform.h"
+
+namespace gfx {
+
+bool MaskFilterInfo::Transform(const gfx::Transform& transform) {
+  return rounded_corner_bounds_.IsEmpty()
+             ? false
+             : transform.TransformRRectF(&rounded_corner_bounds_);
+}
+
+std::string MaskFilterInfo::ToString() const {
+  return "MaskFilterInfo{" + rounded_corner_bounds_.ToString() + "}";
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/mask_filter_info.h b/ui/gfx/geometry/mask_filter_info.h
new file mode 100644
index 0000000..c796b49
--- /dev/null
+++ b/ui/gfx/geometry/mask_filter_info.h
@@ -0,0 +1,64 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_MASK_FILTER_INFO_H_
+#define UI_GFX_GEOMETRY_MASK_FILTER_INFO_H_
+
+#include "ui/gfx/geometry/geometry_skia_export.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/rrect_f.h"
+
+namespace gfx {
+
+class Transform;
+
+// This class defines a mask filter to be applied to the given rect.
+class GEOMETRY_SKIA_EXPORT MaskFilterInfo {
+ public:
+  MaskFilterInfo() = default;
+  explicit MaskFilterInfo(const RRectF& rrect)
+      : rounded_corner_bounds_(rrect) {}
+  MaskFilterInfo(const RectF& bounds, const RoundedCornersF& radii)
+      : rounded_corner_bounds_(bounds, radii) {}
+  MaskFilterInfo(const MaskFilterInfo& copy) = default;
+  ~MaskFilterInfo() = default;
+
+  // The bounds the filter will be applied to.
+  RectF bounds() const { return rounded_corner_bounds_.rect(); }
+
+  // Defines the rounded corner bounds to clip.
+  const RRectF& rounded_corner_bounds() const { return rounded_corner_bounds_; }
+
+  // True if this contains a rounded corner mask.
+  bool HasRoundedCorners() const {
+    return rounded_corner_bounds_.GetType() != RRectF::Type::kEmpty &&
+           rounded_corner_bounds_.GetType() != RRectF::Type::kRect;
+  }
+
+  // True if this contains no effective mask information.
+  bool IsEmpty() const { return rounded_corner_bounds_.IsEmpty(); }
+
+  // Transform the mask information. Returns false if the transform
+  // cannot be applied.
+  bool Transform(const gfx::Transform& transform);
+
+  std::string ToString() const;
+
+ private:
+  // The rounded corner bounds. This also defines the bounds that the mask
+  // filter will be applied to.
+  RRectF rounded_corner_bounds_;
+};
+
+inline bool operator==(const MaskFilterInfo& lhs, const MaskFilterInfo& rhs) {
+  return lhs.rounded_corner_bounds() == rhs.rounded_corner_bounds();
+}
+
+inline bool operator!=(const MaskFilterInfo& lhs, const MaskFilterInfo& rhs) {
+  return !(lhs == rhs);
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_MASK_FILTER_INFO_H_
diff --git a/ui/gfx/geometry/matrix3_f.cc b/ui/gfx/geometry/matrix3_f.cc
new file mode 100644
index 0000000..afacbea
--- /dev/null
+++ b/ui/gfx/geometry/matrix3_f.cc
@@ -0,0 +1,180 @@
+// Copyright (c) 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.
+
+#include "ui/gfx/geometry/matrix3_f.h"
+
+#include <string.h>
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+#include "base/numerics/math_constants.h"
+#include "base/strings/stringprintf.h"
+
+namespace {
+
+// This is only to make accessing indices self-explanatory.
+enum MatrixCoordinates {
+  M00,
+  M01,
+  M02,
+  M10,
+  M11,
+  M12,
+  M20,
+  M21,
+  M22,
+  M_END
+};
+
+template<typename T>
+double Determinant3x3(T data[M_END]) {
+  // This routine is separated from the Matrix3F::Determinant because in
+  // computing inverse we do want higher precision afforded by the explicit
+  // use of 'double'.
+  return
+      static_cast<double>(data[M00]) * (
+          static_cast<double>(data[M11]) * data[M22] -
+          static_cast<double>(data[M12]) * data[M21]) +
+      static_cast<double>(data[M01]) * (
+          static_cast<double>(data[M12]) * data[M20] -
+          static_cast<double>(data[M10]) * data[M22]) +
+      static_cast<double>(data[M02]) * (
+          static_cast<double>(data[M10]) * data[M21] -
+          static_cast<double>(data[M11]) * data[M20]);
+}
+
+}  // namespace
+
+namespace gfx {
+
+Matrix3F::Matrix3F() {
+}
+
+Matrix3F::~Matrix3F() {
+}
+
+// static
+Matrix3F Matrix3F::Zeros() {
+  Matrix3F matrix;
+  matrix.set(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+  return matrix;
+}
+
+// static
+Matrix3F Matrix3F::Ones() {
+  Matrix3F matrix;
+  matrix.set(1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
+  return matrix;
+}
+
+// static
+Matrix3F Matrix3F::Identity() {
+  Matrix3F matrix;
+  matrix.set(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
+  return matrix;
+}
+
+// static
+Matrix3F Matrix3F::FromOuterProduct(const Vector3dF& a, const Vector3dF& bt) {
+  Matrix3F matrix;
+  matrix.set(a.x() * bt.x(), a.x() * bt.y(), a.x() * bt.z(),
+             a.y() * bt.x(), a.y() * bt.y(), a.y() * bt.z(),
+             a.z() * bt.x(), a.z() * bt.y(), a.z() * bt.z());
+  return matrix;
+}
+
+bool Matrix3F::IsEqual(const Matrix3F& rhs) const {
+  return 0 == memcmp(data_, rhs.data_, sizeof(data_));
+}
+
+bool Matrix3F::IsNear(const Matrix3F& rhs, float precision) const {
+  DCHECK(precision >= 0);
+  for (int i = 0; i < M_END; ++i) {
+    if (std::abs(data_[i] - rhs.data_[i]) > precision)
+      return false;
+  }
+  return true;
+}
+
+Matrix3F Matrix3F::Add(const Matrix3F& rhs) const {
+  Matrix3F result;
+  for (int i = 0; i < M_END; ++i)
+    result.data_[i] = data_[i] + rhs.data_[i];
+  return result;
+}
+
+Matrix3F Matrix3F::Subtract(const Matrix3F& rhs) const {
+  Matrix3F result;
+  for (int i = 0; i < M_END; ++i)
+    result.data_[i] = data_[i] - rhs.data_[i];
+  return result;
+}
+
+Matrix3F Matrix3F::Inverse() const {
+  Matrix3F inverse = Matrix3F::Zeros();
+  double determinant = Determinant3x3(data_);
+  if (std::numeric_limits<float>::epsilon() > std::abs(determinant))
+    return inverse;  // Singular matrix. Return Zeros().
+
+  inverse.set(
+      static_cast<float>((data_[M11] * data_[M22] - data_[M12] * data_[M21]) /
+          determinant),
+      static_cast<float>((data_[M02] * data_[M21] - data_[M01] * data_[M22]) /
+          determinant),
+      static_cast<float>((data_[M01] * data_[M12] - data_[M02] * data_[M11]) /
+          determinant),
+      static_cast<float>((data_[M12] * data_[M20] - data_[M10] * data_[M22]) /
+          determinant),
+      static_cast<float>((data_[M00] * data_[M22] - data_[M02] * data_[M20]) /
+          determinant),
+      static_cast<float>((data_[M02] * data_[M10] - data_[M00] * data_[M12]) /
+          determinant),
+      static_cast<float>((data_[M10] * data_[M21] - data_[M11] * data_[M20]) /
+          determinant),
+      static_cast<float>((data_[M01] * data_[M20] - data_[M00] * data_[M21]) /
+          determinant),
+      static_cast<float>((data_[M00] * data_[M11] - data_[M01] * data_[M10]) /
+          determinant));
+  return inverse;
+}
+
+Matrix3F Matrix3F::Transpose() const {
+  Matrix3F transpose;
+  transpose.set(data_[M00], data_[M10], data_[M20], data_[M01], data_[M11],
+                data_[M21], data_[M02], data_[M12], data_[M22]);
+  return transpose;
+}
+
+float Matrix3F::Determinant() const {
+  return static_cast<float>(Determinant3x3(data_));
+}
+
+Matrix3F MatrixProduct(const Matrix3F& lhs, const Matrix3F& rhs) {
+  Matrix3F result = Matrix3F::Zeros();
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      result.set(i, j, DotProduct(lhs.get_row(i), rhs.get_column(j)));
+    }
+  }
+  return result;
+}
+
+Vector3dF MatrixProduct(const Matrix3F& lhs, const Vector3dF& rhs) {
+  return Vector3dF(DotProduct(lhs.get_row(0), rhs),
+                   DotProduct(lhs.get_row(1), rhs),
+                   DotProduct(lhs.get_row(2), rhs));
+}
+
+std::string Matrix3F::ToString() const {
+  return base::StringPrintf(
+      "[[%+0.4f, %+0.4f, %+0.4f],"
+      " [%+0.4f, %+0.4f, %+0.4f],"
+      " [%+0.4f, %+0.4f, %+0.4f]]",
+      data_[M00], data_[M01], data_[M02], data_[M10], data_[M11], data_[M12],
+      data_[M20], data_[M21], data_[M22]);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/matrix3_f.h b/ui/gfx/geometry/matrix3_f.h
new file mode 100644
index 0000000..0b5cc12
--- /dev/null
+++ b/ui/gfx/geometry/matrix3_f.h
@@ -0,0 +1,127 @@
+// Copyright (c) 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.
+
+#ifndef UI_GFX_GEOMETRY_MATRIX3_F_H_
+#define UI_GFX_GEOMETRY_MATRIX3_F_H_
+
+#include "base/check.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+class GEOMETRY_EXPORT Matrix3F {
+ public:
+  ~Matrix3F();
+
+  static Matrix3F Zeros();
+  static Matrix3F Ones();
+  static Matrix3F Identity();
+  static Matrix3F FromOuterProduct(const Vector3dF& a, const Vector3dF& bt);
+
+  bool IsEqual(const Matrix3F& rhs) const;
+
+  // Element-wise comparison with given precision.
+  bool IsNear(const Matrix3F& rhs, float precision) const;
+
+  float get(int i, int j) const {
+    return data_[MatrixToArrayCoords(i, j)];
+  }
+
+  void set(int i, int j, float v) {
+    data_[MatrixToArrayCoords(i, j)] = v;
+  }
+
+  void set(float m00, float m01, float m02,
+           float m10, float m11, float m12,
+           float m20, float m21, float m22) {
+    data_[0] = m00;
+    data_[1] = m01;
+    data_[2] = m02;
+    data_[3] = m10;
+    data_[4] = m11;
+    data_[5] = m12;
+    data_[6] = m20;
+    data_[7] = m21;
+    data_[8] = m22;
+  }
+
+  Vector3dF get_row(int i) const {
+    return Vector3dF(data_[MatrixToArrayCoords(i, 0)],
+                     data_[MatrixToArrayCoords(i, 1)],
+                     data_[MatrixToArrayCoords(i, 2)]);
+  }
+
+  Vector3dF get_column(int i) const {
+    return Vector3dF(
+      data_[MatrixToArrayCoords(0, i)],
+      data_[MatrixToArrayCoords(1, i)],
+      data_[MatrixToArrayCoords(2, i)]);
+  }
+
+  void set_column(int i, const Vector3dF& c) {
+    data_[MatrixToArrayCoords(0, i)] = c.x();
+    data_[MatrixToArrayCoords(1, i)] = c.y();
+    data_[MatrixToArrayCoords(2, i)] = c.z();
+  }
+
+  // Produces a new matrix by adding the elements of |rhs| to this matrix
+  Matrix3F Add(const Matrix3F& rhs) const;
+  // Produces a new matrix by subtracting elements of |rhs| from this matrix.
+  Matrix3F Subtract(const Matrix3F& rhs) const;
+
+  // Returns an inverse of this if the matrix is non-singular, zero (== Zero())
+  // otherwise.
+  Matrix3F Inverse() const;
+
+  // Returns a transpose of this matrix.
+  Matrix3F Transpose() const;
+
+  // Value of the determinant of the matrix.
+  float Determinant() const;
+
+  // Trace (sum of diagonal elements) of the matrix.
+  float Trace() const {
+    return data_[MatrixToArrayCoords(0, 0)] +
+        data_[MatrixToArrayCoords(1, 1)] +
+        data_[MatrixToArrayCoords(2, 2)];
+  }
+
+  std::string ToString() const;
+
+ private:
+  Matrix3F();  // Uninitialized default.
+
+  static int MatrixToArrayCoords(int i, int j) {
+    DCHECK(i >= 0 && i < 3);
+    DCHECK(j >= 0 && j < 3);
+    return i * 3 + j;
+  }
+
+  float data_[9];
+};
+
+inline bool operator==(const Matrix3F& lhs, const Matrix3F& rhs) {
+  return lhs.IsEqual(rhs);
+}
+
+// Matrix addition. Produces a new matrix by adding the corresponding elements
+// together.
+inline Matrix3F operator+(const Matrix3F& lhs, const Matrix3F& rhs) {
+  return lhs.Add(rhs);
+}
+
+// Matrix subtraction. Produces a new matrix by subtracting elements of rhs
+// from corresponding elements of lhs.
+inline Matrix3F operator-(const Matrix3F& lhs, const Matrix3F& rhs) {
+  return lhs.Subtract(rhs);
+}
+
+GEOMETRY_EXPORT Matrix3F MatrixProduct(const Matrix3F& lhs,
+                                       const Matrix3F& rhs);
+GEOMETRY_EXPORT Vector3dF MatrixProduct(const Matrix3F& lhs,
+                                        const Vector3dF& rhs);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_MATRIX3_F_H_
diff --git a/ui/gfx/geometry/matrix3_unittest.cc b/ui/gfx/geometry/matrix3_unittest.cc
new file mode 100644
index 0000000..1f550e8
--- /dev/null
+++ b/ui/gfx/geometry/matrix3_unittest.cc
@@ -0,0 +1,125 @@
+// Copyright (c) 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.
+
+#include <cmath>
+#include <limits>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/matrix3_f.h"
+
+namespace gfx {
+namespace {
+
+TEST(Matrix3fTest, Constructors) {
+  Matrix3F zeros = Matrix3F::Zeros();
+  Matrix3F ones = Matrix3F::Ones();
+  Matrix3F identity = Matrix3F::Identity();
+
+  Matrix3F product_ones = Matrix3F::FromOuterProduct(
+      Vector3dF(1.0f, 1.0f, 1.0f), Vector3dF(1.0f, 1.0f, 1.0f));
+  Matrix3F product_zeros = Matrix3F::FromOuterProduct(
+      Vector3dF(1.0f, 1.0f, 1.0f), Vector3dF(0.0f, 0.0f, 0.0f));
+  EXPECT_EQ(ones, product_ones);
+  EXPECT_EQ(zeros, product_zeros);
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j)
+      EXPECT_EQ(i == j ? 1.0f : 0.0f, identity.get(i, j));
+  }
+}
+
+TEST(Matrix3fTest, DataAccess) {
+  Matrix3F matrix = Matrix3F::Ones();
+  Matrix3F identity = Matrix3F::Identity();
+
+  EXPECT_EQ(Vector3dF(0.0f, 1.0f, 0.0f), identity.get_column(1));
+  EXPECT_EQ(Vector3dF(0.0f, 1.0f, 0.0f), identity.get_row(1));
+  matrix.set(0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
+  EXPECT_EQ(Vector3dF(2.0f, 5.0f, 8.0f), matrix.get_column(2));
+  EXPECT_EQ(Vector3dF(6.0f, 7.0f, 8.0f), matrix.get_row(2));
+  matrix.set_column(0, Vector3dF(0.1f, 0.2f, 0.3f));
+  matrix.set_column(0, Vector3dF(0.1f, 0.2f, 0.3f));
+  EXPECT_EQ(Vector3dF(0.1f, 0.2f, 0.3f), matrix.get_column(0));
+  EXPECT_EQ(Vector3dF(0.1f, 1.0f, 2.0f), matrix.get_row(0));
+
+  EXPECT_EQ(0.1f, matrix.get(0, 0));
+  EXPECT_EQ(5.0f, matrix.get(1, 2));
+}
+
+TEST(Matrix3fTest, Determinant) {
+  EXPECT_EQ(1.0f, Matrix3F::Identity().Determinant());
+  EXPECT_EQ(0.0f, Matrix3F::Zeros().Determinant());
+  EXPECT_EQ(0.0f, Matrix3F::Ones().Determinant());
+
+  // Now for something non-trivial...
+  Matrix3F matrix = Matrix3F::Zeros();
+  matrix.set(0, 5, 6, 8, 7, 0, 1, 9, 0);
+  EXPECT_EQ(390.0f, matrix.Determinant());
+  matrix.set(2, 0, 3 * matrix.get(0, 0));
+  matrix.set(2, 1, 3 * matrix.get(0, 1));
+  matrix.set(2, 2, 3 * matrix.get(0, 2));
+  EXPECT_EQ(0, matrix.Determinant());
+
+  matrix.set(0.57f,  0.205f,  0.942f,
+             0.314f,  0.845f,  0.826f,
+             0.131f,  0.025f,  0.962f);
+  EXPECT_NEAR(0.3149f, matrix.Determinant(), 0.0001f);
+}
+
+TEST(Matrix3fTest, Inverse) {
+  Matrix3F identity = Matrix3F::Identity();
+  Matrix3F inv_identity = identity.Inverse();
+  EXPECT_EQ(identity, inv_identity);
+
+  Matrix3F singular = Matrix3F::Zeros();
+  singular.set(1.0f, 3.0f, 4.0f,
+               2.0f, 11.0f, 5.0f,
+               0.5f, 1.5f, 2.0f);
+  EXPECT_EQ(0, singular.Determinant());
+  EXPECT_EQ(Matrix3F::Zeros(), singular.Inverse());
+
+  Matrix3F regular = Matrix3F::Zeros();
+  regular.set(0.57f,  0.205f,  0.942f,
+              0.314f,  0.845f,  0.826f,
+              0.131f,  0.025f,  0.962f);
+  Matrix3F inv_regular = regular.Inverse();
+  regular.set(2.51540616f, -0.55138018f, -1.98968043f,
+              -0.61552266f,  1.34920184f, -0.55573636f,
+              -0.32653861f,  0.04002158f,  1.32488726f);
+  EXPECT_TRUE(regular.IsNear(inv_regular, 0.00001f));
+}
+
+TEST(Matrix3fTest, Transpose) {
+  Matrix3F matrix = Matrix3F::Zeros();
+
+  matrix.set(0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
+
+  Matrix3F transpose = matrix.Transpose();
+  EXPECT_EQ(Vector3dF(0.0f, 1.0f, 2.0f), transpose.get_column(0));
+  EXPECT_EQ(Vector3dF(3.0f, 4.0f, 5.0f), transpose.get_column(1));
+  EXPECT_EQ(Vector3dF(6.0f, 7.0f, 8.0f), transpose.get_column(2));
+
+  EXPECT_TRUE(matrix.IsEqual(transpose.Transpose()));
+}
+
+TEST(Matrix3fTest, Operators) {
+  Matrix3F matrix1 = Matrix3F::Zeros();
+  matrix1.set(1, 2, 3, 4, 5, 6, 7, 8, 9);
+  EXPECT_EQ(matrix1 + Matrix3F::Zeros(), matrix1);
+
+  Matrix3F matrix2 = Matrix3F::Zeros();
+  matrix2.set(-1, -2, -3, -4, -5, -6, -7, -8, -9);
+  EXPECT_EQ(matrix1 + matrix2, Matrix3F::Zeros());
+
+  EXPECT_EQ(Matrix3F::Zeros() - matrix1, matrix2);
+
+  Matrix3F result = Matrix3F::Zeros();
+  result.set(2, 4, 6, 8, 10, 12, 14, 16, 18);
+  EXPECT_EQ(matrix1 - matrix2, result);
+  result.set(-2, -4, -6, -8, -10, -12, -14, -16, -18);
+  EXPECT_EQ(matrix2 - matrix1, result);
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/geometry/mojom/BUILD.gn b/ui/gfx/geometry/mojom/BUILD.gn
new file mode 100644
index 0000000..a5f18d7
--- /dev/null
+++ b/ui/gfx/geometry/mojom/BUILD.gn
@@ -0,0 +1,106 @@
+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//mojo/public/tools/bindings/mojom.gni")
+
+# This target does NOT depend on skia. One can depend on this target to avoid
+# picking up a dependency on skia.
+mojom("mojom") {
+  generate_java = true
+  sources = [ "geometry.mojom" ]
+
+  check_includes_blink = false
+
+  shared_cpp_typemap = {
+    types = [
+      {
+        mojom = "gfx.mojom.Point"
+        cpp = "::gfx::Point"
+      },
+      {
+        mojom = "gfx.mojom.PointF"
+        cpp = "::gfx::PointF"
+      },
+      {
+        mojom = "gfx.mojom.Point3F"
+        cpp = "::gfx::Point3F"
+      },
+      {
+        mojom = "gfx.mojom.Size"
+        cpp = "::gfx::Size"
+      },
+      {
+        mojom = "gfx.mojom.SizeF"
+        cpp = "::gfx::SizeF"
+      },
+      {
+        mojom = "gfx.mojom.Rect"
+        cpp = "::gfx::Rect"
+      },
+      {
+        mojom = "gfx.mojom.RectF"
+        cpp = "::gfx::RectF"
+      },
+      {
+        mojom = "gfx.mojom.Insets"
+        cpp = "::gfx::Insets"
+      },
+      {
+        mojom = "gfx.mojom.InsetsF"
+        cpp = "::gfx::InsetsF"
+      },
+      {
+        mojom = "gfx.mojom.Quaternion"
+        cpp = "::gfx::Quaternion"
+      },
+      {
+        mojom = "gfx.mojom.Vector2d"
+        cpp = "::gfx::Vector2d"
+      },
+      {
+        mojom = "gfx.mojom.Vector2dF"
+        cpp = "::gfx::Vector2dF"
+      },
+      {
+        mojom = "gfx.mojom.Vector3dF"
+        cpp = "::gfx::Vector3dF"
+      },
+    ]
+
+    traits_headers = [ "geometry_mojom_traits.h" ]
+    traits_public_deps = [ ":mojom_traits" ]
+  }
+  cpp_typemaps = [ shared_cpp_typemap ]
+  blink_cpp_typemaps = [ shared_cpp_typemap ]
+  webui_module_path = "chrome://resources/mojo/ui/gfx/geometry/mojom"
+}
+
+mojom("test_interfaces") {
+  sources = [ "geometry_traits_test_service.mojom" ]
+
+  public_deps = [ ":mojom" ]
+}
+
+source_set("unit_test") {
+  testonly = true
+
+  sources = [ "geometry_mojom_traits_unittest.cc" ]
+
+  deps = [
+    ":test_interfaces",
+    "//base",
+    "//base/test:test_support",
+    "//mojo/public/cpp/bindings",
+    "//testing/gtest",
+    "//ui/gfx/geometry",
+  ]
+}
+
+source_set("mojom_traits") {
+  sources = [ "geometry_mojom_traits.h" ]
+  public_deps = [
+    ":mojom_shared",
+    "//ui/gfx/geometry",
+  ]
+}
diff --git a/ui/gfx/geometry/mojom/DEPS b/ui/gfx/geometry/mojom/DEPS
new file mode 100644
index 0000000..3ad6543
--- /dev/null
+++ b/ui/gfx/geometry/mojom/DEPS
@@ -0,0 +1,4 @@
+include_rules = [
+  "+mojo/public",
+  "+ui/gfx/geometry",
+]
diff --git a/ui/gfx/geometry/mojom/OWNERS b/ui/gfx/geometry/mojom/OWNERS
new file mode 100644
index 0000000..7ed4e44
--- /dev/null
+++ b/ui/gfx/geometry/mojom/OWNERS
@@ -0,0 +1,8 @@
+per-file *_mojom_traits*.*=set noparent
+per-file *_mojom_traits*.*=file://ipc/SECURITY_OWNERS
+
+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS
+
+per-file *.typemap=set noparent
+per-file *.typemap=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/geometry/mojom/geometry.mojom b/ui/gfx/geometry/mojom/geometry.mojom
new file mode 100644
index 0000000..30be3e6
--- /dev/null
+++ b/ui/gfx/geometry/mojom/geometry.mojom
@@ -0,0 +1,88 @@
+// Copyright 2014 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.
+
+module gfx.mojom;
+
+[Stable]
+struct Point {
+  int32 x;
+  int32 y;
+};
+
+[Stable]
+struct PointF {
+  float x;
+  float y;
+};
+
+struct Point3F {
+  float x;
+  float y;
+  float z;
+};
+
+[Stable]
+struct Size {
+  int32 width;
+  int32 height;
+};
+
+struct SizeF {
+  float width;
+  float height;
+};
+
+[Stable]
+struct Rect {
+  int32 x;
+  int32 y;
+  int32 width;
+  int32 height;
+};
+
+[Stable]
+struct RectF {
+  float x;
+  float y;
+  float width;
+  float height;
+};
+
+[Stable]
+struct Insets {
+  int32 top;
+  int32 left;
+  int32 bottom;
+  int32 right;
+};
+
+struct InsetsF {
+  float top;
+  float left;
+  float bottom;
+  float right;
+};
+
+struct Vector2d {
+  int32 x;
+  int32 y;
+};
+
+struct Vector2dF {
+  float x;
+  float y;
+};
+
+struct Vector3dF {
+  float x;
+  float y;
+  float z;
+};
+
+struct Quaternion {
+  double x;
+  double y;
+  double z;
+  double w;
+};
diff --git a/ui/gfx/geometry/mojom/geometry_mojom_traits.h b/ui/gfx/geometry/mojom/geometry_mojom_traits.h
new file mode 100644
index 0000000..aa48273
--- /dev/null
+++ b/ui/gfx/geometry/mojom/geometry_mojom_traits.h
@@ -0,0 +1,188 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_MOJOM_GEOMETRY_MOJOM_TRAITS_H_
+#define UI_GFX_GEOMETRY_MOJOM_GEOMETRY_MOJOM_TRAITS_H_
+
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/mojom/geometry.mojom-shared.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/geometry/quaternion.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::InsetsDataView, gfx::Insets> {
+  static int top(const gfx::Insets& p) { return p.top(); }
+  static int left(const gfx::Insets& p) { return p.left(); }
+  static int bottom(const gfx::Insets& p) { return p.bottom(); }
+  static int right(const gfx::Insets& p) { return p.right(); }
+  static bool Read(gfx::mojom::InsetsDataView data, gfx::Insets* out) {
+    out->Set(data.top(), data.left(), data.bottom(), data.right());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::InsetsFDataView, gfx::InsetsF> {
+  static float top(const gfx::InsetsF& p) { return p.top(); }
+  static float left(const gfx::InsetsF& p) { return p.left(); }
+  static float bottom(const gfx::InsetsF& p) { return p.bottom(); }
+  static float right(const gfx::InsetsF& p) { return p.right(); }
+  static bool Read(gfx::mojom::InsetsFDataView data, gfx::InsetsF* out) {
+    out->Set(data.top(), data.left(), data.bottom(), data.right());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::PointDataView, gfx::Point> {
+  static int x(const gfx::Point& p) { return p.x(); }
+  static int y(const gfx::Point& p) { return p.y(); }
+  static bool Read(gfx::mojom::PointDataView data, gfx::Point* out) {
+    out->SetPoint(data.x(), data.y());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::PointFDataView, gfx::PointF> {
+  static float x(const gfx::PointF& p) { return p.x(); }
+  static float y(const gfx::PointF& p) { return p.y(); }
+  static bool Read(gfx::mojom::PointFDataView data, gfx::PointF* out) {
+    out->SetPoint(data.x(), data.y());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::Point3FDataView, gfx::Point3F> {
+  static float x(const gfx::Point3F& p) { return p.x(); }
+  static float y(const gfx::Point3F& p) { return p.y(); }
+  static float z(const gfx::Point3F& p) { return p.z(); }
+  static bool Read(gfx::mojom::Point3FDataView data, gfx::Point3F* out) {
+    out->SetPoint(data.x(), data.y(), data.z());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::RectDataView, gfx::Rect> {
+  static int x(const gfx::Rect& p) { return p.x(); }
+  static int y(const gfx::Rect& p) { return p.y(); }
+  static int width(const gfx::Rect& p) { return p.width(); }
+  static int height(const gfx::Rect& p) { return p.height(); }
+  static bool Read(gfx::mojom::RectDataView data, gfx::Rect* out) {
+    if (data.width() < 0 || data.height() < 0)
+      return false;
+
+    out->SetRect(data.x(), data.y(), data.width(), data.height());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::RectFDataView, gfx::RectF> {
+  static float x(const gfx::RectF& p) { return p.x(); }
+  static float y(const gfx::RectF& p) { return p.y(); }
+  static float width(const gfx::RectF& p) { return p.width(); }
+  static float height(const gfx::RectF& p) { return p.height(); }
+  static bool Read(gfx::mojom::RectFDataView data, gfx::RectF* out) {
+    if (data.width() < 0 || data.height() < 0)
+      return false;
+
+    out->SetRect(data.x(), data.y(), data.width(), data.height());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::SizeDataView, gfx::Size> {
+  static int width(const gfx::Size& p) { return p.width(); }
+  static int height(const gfx::Size& p) { return p.height(); }
+  static bool Read(gfx::mojom::SizeDataView data, gfx::Size* out) {
+    if (data.width() < 0 || data.height() < 0)
+      return false;
+
+    out->SetSize(data.width(), data.height());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::SizeFDataView, gfx::SizeF> {
+  static float width(const gfx::SizeF& p) { return p.width(); }
+  static float height(const gfx::SizeF& p) { return p.height(); }
+  static bool Read(gfx::mojom::SizeFDataView data, gfx::SizeF* out) {
+    if (data.width() < 0 || data.height() < 0)
+      return false;
+
+    out->SetSize(data.width(), data.height());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::Vector2dDataView, gfx::Vector2d> {
+  static int x(const gfx::Vector2d& v) { return v.x(); }
+  static int y(const gfx::Vector2d& v) { return v.y(); }
+  static bool Read(gfx::mojom::Vector2dDataView data, gfx::Vector2d* out) {
+    out->set_x(data.x());
+    out->set_y(data.y());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::Vector2dFDataView, gfx::Vector2dF> {
+  static float x(const gfx::Vector2dF& v) { return v.x(); }
+  static float y(const gfx::Vector2dF& v) { return v.y(); }
+  static bool Read(gfx::mojom::Vector2dFDataView data, gfx::Vector2dF* out) {
+    out->set_x(data.x());
+    out->set_y(data.y());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::Vector3dFDataView, gfx::Vector3dF> {
+  static float x(const gfx::Vector3dF& v) { return v.x(); }
+  static float y(const gfx::Vector3dF& v) { return v.y(); }
+  static float z(const gfx::Vector3dF& v) { return v.z(); }
+  static bool Read(gfx::mojom::Vector3dFDataView data, gfx::Vector3dF* out) {
+    out->set_x(data.x());
+    out->set_y(data.y());
+    out->set_z(data.z());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::QuaternionDataView, gfx::Quaternion> {
+  static double x(const gfx::Quaternion& q) { return q.x(); }
+  static double y(const gfx::Quaternion& q) { return q.y(); }
+  static double z(const gfx::Quaternion& q) { return q.z(); }
+  static double w(const gfx::Quaternion& q) { return q.w(); }
+  static bool Read(gfx::mojom::QuaternionDataView data, gfx::Quaternion* out) {
+    out->set_x(data.x());
+    out->set_y(data.y());
+    out->set_z(data.z());
+    out->set_w(data.w());
+    return true;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_GEOMETRY_MOJOM_GEOMETRY_MOJOM_TRAITS_H_
diff --git a/ui/gfx/geometry/mojom/geometry_mojom_traits_unittest.cc b/ui/gfx/geometry/mojom/geometry_mojom_traits_unittest.cc
new file mode 100644
index 0000000..d2c5959
--- /dev/null
+++ b/ui/gfx/geometry/mojom/geometry_mojom_traits_unittest.cc
@@ -0,0 +1,264 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <utility>
+
+#include "base/test/task_environment.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/mojom/geometry_traits_test_service.mojom.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/quaternion.h"
+
+namespace gfx {
+
+namespace {
+
+class GeometryStructTraitsTest : public testing::Test,
+                                 public mojom::GeometryTraitsTestService {
+ public:
+  GeometryStructTraitsTest() {}
+
+  GeometryStructTraitsTest(const GeometryStructTraitsTest&) = delete;
+  GeometryStructTraitsTest& operator=(const GeometryStructTraitsTest&) = delete;
+
+ protected:
+  mojo::Remote<mojom::GeometryTraitsTestService> GetTraitsTestRemote() {
+    mojo::Remote<mojom::GeometryTraitsTestService> remote;
+    traits_test_receivers_.Add(this, remote.BindNewPipeAndPassReceiver());
+    return remote;
+  }
+
+ private:
+  // GeometryTraitsTestService:
+  void EchoPoint(const Point& p, EchoPointCallback callback) override {
+    std::move(callback).Run(p);
+  }
+
+  void EchoPointF(const PointF& p, EchoPointFCallback callback) override {
+    std::move(callback).Run(p);
+  }
+
+  void EchoPoint3F(const Point3F& p, EchoPoint3FCallback callback) override {
+    std::move(callback).Run(p);
+  }
+
+  void EchoSize(const Size& s, EchoSizeCallback callback) override {
+    std::move(callback).Run(s);
+  }
+
+  void EchoSizeF(const SizeF& s, EchoSizeFCallback callback) override {
+    std::move(callback).Run(s);
+  }
+
+  void EchoRect(const Rect& r, EchoRectCallback callback) override {
+    std::move(callback).Run(r);
+  }
+
+  void EchoRectF(const RectF& r, EchoRectFCallback callback) override {
+    std::move(callback).Run(r);
+  }
+
+  void EchoInsets(const Insets& i, EchoInsetsCallback callback) override {
+    std::move(callback).Run(i);
+  }
+
+  void EchoInsetsF(const InsetsF& i, EchoInsetsFCallback callback) override {
+    std::move(callback).Run(i);
+  }
+
+  void EchoVector2d(const Vector2d& v, EchoVector2dCallback callback) override {
+    std::move(callback).Run(v);
+  }
+
+  void EchoVector2dF(const Vector2dF& v,
+                     EchoVector2dFCallback callback) override {
+    std::move(callback).Run(v);
+  }
+
+  void EchoVector3dF(const Vector3dF& v,
+                     EchoVector3dFCallback callback) override {
+    std::move(callback).Run(v);
+  }
+
+  void EchoQuaternion(const Quaternion& q,
+                      EchoQuaternionCallback callback) override {
+    std::move(callback).Run(q);
+  }
+
+  base::test::TaskEnvironment task_environment_;
+  mojo::ReceiverSet<GeometryTraitsTestService> traits_test_receivers_;
+};
+
+}  // namespace
+
+TEST_F(GeometryStructTraitsTest, Point) {
+  const int32_t x = 1234;
+  const int32_t y = -5678;
+  gfx::Point input(x, y);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Point output;
+  remote->EchoPoint(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+}
+
+TEST_F(GeometryStructTraitsTest, PointF) {
+  const float x = 1234.5f;
+  const float y = 6789.6f;
+  gfx::PointF input(x, y);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::PointF output;
+  remote->EchoPointF(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+}
+
+TEST_F(GeometryStructTraitsTest, Point3F) {
+  const float x = 1234.5f;
+  const float y = 6789.6f;
+  const float z = 5432.1f;
+  gfx::Point3F input(x, y, z);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Point3F output;
+  remote->EchoPoint3F(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+  EXPECT_EQ(z, output.z());
+}
+
+TEST_F(GeometryStructTraitsTest, Size) {
+  const int32_t width = 1234;
+  const int32_t height = 5678;
+  gfx::Size input(width, height);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Size output;
+  remote->EchoSize(input, &output);
+  EXPECT_EQ(width, output.width());
+  EXPECT_EQ(height, output.height());
+}
+
+TEST_F(GeometryStructTraitsTest, SizeF) {
+  const float width = 1234.5f;
+  const float height = 6789.6f;
+  gfx::SizeF input(width, height);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::SizeF output;
+  remote->EchoSizeF(input, &output);
+  EXPECT_EQ(width, output.width());
+  EXPECT_EQ(height, output.height());
+}
+
+TEST_F(GeometryStructTraitsTest, Rect) {
+  const int32_t x = 1234;
+  const int32_t y = 5678;
+  const int32_t width = 4321;
+  const int32_t height = 8765;
+  gfx::Rect input(x, y, width, height);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Rect output;
+  remote->EchoRect(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+  EXPECT_EQ(width, output.width());
+  EXPECT_EQ(height, output.height());
+}
+
+TEST_F(GeometryStructTraitsTest, RectF) {
+  const float x = 1234.1f;
+  const float y = 5678.2f;
+  const float width = 4321.3f;
+  const float height = 8765.4f;
+  gfx::RectF input(x, y, width, height);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::RectF output;
+  remote->EchoRectF(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+  EXPECT_EQ(width, output.width());
+  EXPECT_EQ(height, output.height());
+}
+
+TEST_F(GeometryStructTraitsTest, Insets) {
+  const int32_t top = 1234;
+  const int32_t left = 5678;
+  const int32_t bottom = 4321;
+  const int32_t right = 8765;
+  gfx::Insets input(top, left, bottom, right);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Insets output;
+  remote->EchoInsets(input, &output);
+  EXPECT_EQ(top, output.top());
+  EXPECT_EQ(left, output.left());
+  EXPECT_EQ(bottom, output.bottom());
+  EXPECT_EQ(right, output.right());
+}
+
+TEST_F(GeometryStructTraitsTest, InsetsF) {
+  const float top = 1234.1f;
+  const float left = 5678.2f;
+  const float bottom = 4321.3f;
+  const float right = 8765.4f;
+  gfx::InsetsF input(top, left, bottom, right);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::InsetsF output;
+  remote->EchoInsetsF(input, &output);
+  EXPECT_EQ(top, output.top());
+  EXPECT_EQ(left, output.left());
+  EXPECT_EQ(bottom, output.bottom());
+  EXPECT_EQ(right, output.right());
+}
+
+TEST_F(GeometryStructTraitsTest, Vector2d) {
+  const int32_t x = 1234;
+  const int32_t y = -5678;
+  gfx::Vector2d input(x, y);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Vector2d output;
+  remote->EchoVector2d(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+}
+
+TEST_F(GeometryStructTraitsTest, Vector2dF) {
+  const float x = 1234.5f;
+  const float y = 6789.6f;
+  gfx::Vector2dF input(x, y);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Vector2dF output;
+  remote->EchoVector2dF(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+}
+
+TEST_F(GeometryStructTraitsTest, Vector3dF) {
+  const float x = 1234.5f;
+  const float y = 6789.6f;
+  const float z = 5432.1f;
+  gfx::Vector3dF input(x, y, z);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Vector3dF output;
+  remote->EchoVector3dF(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+  EXPECT_EQ(z, output.z());
+}
+
+TEST_F(GeometryStructTraitsTest, Quaternion) {
+  const double x = 1234.5;
+  const double y = 6789.6;
+  const double z = 31415.9;
+  const double w = 27182.8;
+  gfx::Quaternion input(x, y, z, w);
+  mojo::Remote<mojom::GeometryTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Quaternion output;
+  remote->EchoQuaternion(input, &output);
+  EXPECT_EQ(x, output.x());
+  EXPECT_EQ(y, output.y());
+  EXPECT_EQ(z, output.z());
+  EXPECT_EQ(w, output.w());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/mojom/geometry_traits_test_service.mojom b/ui/gfx/geometry/mojom/geometry_traits_test_service.mojom
new file mode 100644
index 0000000..97b69ad
--- /dev/null
+++ b/ui/gfx/geometry/mojom/geometry_traits_test_service.mojom
@@ -0,0 +1,50 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+// All functions on this interface echo their arguments to test StructTraits
+// serialization and deserialization.
+interface GeometryTraitsTestService {
+  [Sync]
+  EchoPoint(Point p) => (Point pass);
+
+  [Sync]
+  EchoPointF(PointF p) => (PointF pass);
+
+  [Sync]
+  EchoPoint3F(Point3F p) => (Point3F pass);
+
+  [Sync]
+  EchoSize(Size s) => (Size pass);
+
+  [Sync]
+  EchoSizeF(SizeF s) => (SizeF pass);
+
+  [Sync]
+  EchoRect(Rect r) => (Rect pass);
+
+  [Sync]
+  EchoRectF(RectF r) => (RectF pass);
+
+  [Sync]
+  EchoInsets(Insets i) => (Insets pass);
+
+  [Sync]
+  EchoInsetsF(InsetsF i) => (InsetsF pass);
+
+  [Sync]
+  EchoVector2d(Vector2d v) => (Vector2d pass);
+
+  [Sync]
+  EchoVector2dF(Vector2dF v) => (Vector2dF pass);
+
+  [Sync]
+  EchoVector3dF(Vector3dF v) => (Vector3dF pass);
+
+  [Sync]
+  EchoQuaternion(Quaternion q) => (Quaternion pass);
+};
diff --git a/ui/gfx/geometry/point.cc b/ui/gfx/geometry/point.cc
new file mode 100644
index 0000000..f167f20
--- /dev/null
+++ b/ui/gfx/geometry/point.cc
@@ -0,0 +1,17 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/point.h"
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+template class PointBase<Point, int, Vector2d>;
+
+std::string Point::ToString() const {
+  return base::StringPrintf("%d,%d", x(), y());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/point.h b/ui/gfx/geometry/point.h
new file mode 100644
index 0000000..3d02ccf
--- /dev/null
+++ b/ui/gfx/geometry/point.h
@@ -0,0 +1,65 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_POINT_H_
+#define UI_GFX_GEOMETRY_POINT_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "ui/gfx/geometry/point_base.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/geometry/vector2d.h"
+
+namespace gfx {
+
+// A point has an x and y coordinate.
+class Point : public PointBase<Point, int, Vector2d> {
+ public:
+  Point() : PointBase<Point, int, Vector2d>(0, 0) {}
+  Point(int x, int y) : PointBase<Point, int, Vector2d>(x, y) {}
+
+  ~Point() {}
+
+  operator PointF() const {
+    return PointF(static_cast<float>(x()), static_cast<float>(y()));
+  }
+
+  // Returns a string representation of point.
+  std::string ToString() const;
+};
+
+inline bool operator==(const Point& lhs, const Point& rhs) {
+  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
+}
+
+inline bool operator!=(const Point& lhs, const Point& rhs) {
+  return !(lhs == rhs);
+}
+
+inline Point operator+(const Point& lhs, const Vector2d& rhs) {
+  Point result(lhs);
+  result += rhs;
+  return result;
+}
+
+inline Point operator-(const Point& lhs, const Vector2d& rhs) {
+  Point result(lhs);
+  result -= rhs;
+  return result;
+}
+
+inline Vector2d operator-(const Point& lhs, const Point& rhs) {
+  return Vector2d(lhs.x() - rhs.x(), lhs.y() - rhs.y());
+}
+
+inline Point PointAtOffsetFromOrigin(const Vector2d& offset_from_origin) {
+  return Point(offset_from_origin.x(), offset_from_origin.y());
+}
+
+extern template class PointBase<Point, int, Vector2d>;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_POINT_H_
diff --git a/ui/gfx/geometry/point3_f.cc b/ui/gfx/geometry/point3_f.cc
new file mode 100644
index 0000000..465376e
--- /dev/null
+++ b/ui/gfx/geometry/point3_f.cc
@@ -0,0 +1,40 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/point3_f.h"
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+std::string Point3F::ToString() const {
+  return base::StringPrintf("%f,%f,%f", x_, y_, z_);
+}
+
+Point3F operator+(const Point3F& lhs, const Vector3dF& rhs) {
+  float x = lhs.x() + rhs.x();
+  float y = lhs.y() + rhs.y();
+  float z = lhs.z() + rhs.z();
+  return Point3F(x, y, z);
+}
+
+// Subtract a vector from a point, producing a new point offset by the vector's
+// inverse.
+Point3F operator-(const Point3F& lhs, const Vector3dF& rhs) {
+  float x = lhs.x() - rhs.x();
+  float y = lhs.y() - rhs.y();
+  float z = lhs.z() - rhs.z();
+  return Point3F(x, y, z);
+}
+
+// Subtract one point from another, producing a vector that represents the
+// distances between the two points along each axis.
+Vector3dF operator-(const Point3F& lhs, const Point3F& rhs) {
+  float x = lhs.x() - rhs.x();
+  float y = lhs.y() - rhs.y();
+  float z = lhs.z() - rhs.z();
+  return Vector3dF(x, y, z);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/point3_f.h b/ui/gfx/geometry/point3_f.h
new file mode 100644
index 0000000..07b95c0
--- /dev/null
+++ b/ui/gfx/geometry/point3_f.h
@@ -0,0 +1,86 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_POINT3_F_H_
+#define UI_GFX_GEOMETRY_POINT3_F_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "ui/gfx/geometry/point_f.h"
+
+namespace gfx {
+
+// A point has an x, y and z coordinate.
+class Point3F {
+ public:
+  Point3F() : x_(0), y_(0), z_(0) {}
+
+  Point3F(float x, float y, float z) : x_(x), y_(y), z_(z) {}
+
+  explicit Point3F(const PointF& point) : x_(point.x()), y_(point.y()), z_(0) {}
+
+  ~Point3F() {}
+
+  void Scale(float scale) { Scale(scale, scale, scale); }
+
+  void Scale(float x_scale, float y_scale, float z_scale) {
+    SetPoint(x() * x_scale, y() * y_scale, z() * z_scale);
+  }
+
+  float x() const { return x_; }
+  float y() const { return y_; }
+  float z() const { return z_; }
+
+  void set_x(float x) { x_ = x; }
+  void set_y(float y) { y_ = y; }
+  void set_z(float z) { z_ = z; }
+
+  void SetPoint(float x, float y, float z) {
+    x_ = x;
+    y_ = y;
+    z_ = z;
+  }
+
+  // Returns the squared euclidean distance between two points.
+  float SquaredDistanceTo(const Point3F& other) const {
+    float dx = x_ - other.x_;
+    float dy = y_ - other.y_;
+    float dz = z_ - other.z_;
+    return dx * dx + dy * dy + dz * dz;
+  }
+
+  PointF AsPointF() const { return PointF(x_, y_); }
+
+  // Returns a string representation of 3d point.
+  std::string ToString() const;
+
+ private:
+  float x_;
+  float y_;
+  float z_;
+
+  // copy/assign are allowed.
+};
+
+inline bool operator==(const Point3F& lhs, const Point3F& rhs) {
+  return lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() == rhs.z();
+}
+
+inline bool operator!=(const Point3F& lhs, const Point3F& rhs) {
+  return !(lhs == rhs);
+}
+
+inline Point3F ScalePoint(const Point3F& p, float x_scale, float y_scale,
+                          float z_scale) {
+  return Point3F(p.x() * x_scale, p.y() * y_scale, p.z() * z_scale);
+}
+
+inline Point3F ScalePoint(const Point3F& p, float scale) {
+  return ScalePoint(p, scale, scale, scale);
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_POINT3_F_H_
diff --git a/ui/gfx/geometry/point3_unittest.cc b/ui/gfx/geometry/point3_unittest.cc
new file mode 100644
index 0000000..e1926ef
--- /dev/null
+++ b/ui/gfx/geometry/point3_unittest.cc
@@ -0,0 +1,71 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/point3_f.h"
+
+namespace gfx {
+
+TEST(Point3Test, VectorArithmetic) {
+  gfx::Point3F a(1.6f, 5.1f, 3.2f);
+  gfx::Vector3dF v1(3.1f, -3.2f, 9.3f);
+  gfx::Vector3dF v2(-8.1f, 1.2f, 3.3f);
+
+  static const struct {
+    gfx::Point3F expected;
+    gfx::Point3F actual;
+  } tests[] = {
+    { gfx::Point3F(4.7f, 1.9f, 12.5f), a + v1 },
+    { gfx::Point3F(-1.5f, 8.3f, -6.1f), a - v1 },
+    { a, a - v1 + v1 },
+    { a, a + v1 - v1 },
+    { a, a + gfx::Vector3dF() },
+    { gfx::Point3F(12.8f, 0.7f, 9.2f), a + v1 - v2 },
+    { gfx::Point3F(-9.6f, 9.5f, -2.8f), a - v1 + v2 }
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i)
+    EXPECT_EQ(tests[i].expected.ToString(),
+              tests[i].actual.ToString());
+
+  a += v1;
+  EXPECT_EQ(Point3F(4.7f, 1.9f, 12.5f).ToString(), a.ToString());
+
+  a -= v2;
+  EXPECT_EQ(Point3F(12.8f, 0.7f, 9.2f).ToString(), a.ToString());
+}
+
+TEST(Point3Test, VectorFromPoints) {
+  gfx::Point3F a(1.6f, 5.2f, 3.2f);
+  gfx::Vector3dF v1(3.1f, -3.2f, 9.3f);
+
+  gfx::Point3F b(a + v1);
+  EXPECT_EQ((b - a).ToString(), v1.ToString());
+}
+
+TEST(Point3Test, Scale) {
+  EXPECT_EQ(Point3F().ToString(), ScalePoint(Point3F(), 2.f).ToString());
+  EXPECT_EQ(Point3F().ToString(),
+            ScalePoint(Point3F(), 2.f, 2.f, 2.f).ToString());
+
+  EXPECT_EQ(Point3F(2.f, -2.f, 4.f).ToString(),
+            ScalePoint(Point3F(1.f, -1.f, 2.f), 2.f).ToString());
+  EXPECT_EQ(Point3F(2.f, -3.f, 8.f).ToString(),
+            ScalePoint(Point3F(1.f, -1.f, 2.f), 2.f, 3.f, 4.f).ToString());
+
+  Point3F zero;
+  zero.Scale(2.f);
+  zero.Scale(6.f, 3.f, 1.5f);
+  EXPECT_EQ(Point3F().ToString(), zero.ToString());
+
+  Point3F point(1.f, -1.f, 2.f);
+  point.Scale(2.f);
+  point.Scale(6.f, 3.f, 1.5f);
+  EXPECT_EQ(Point3F(12.f, -6.f, 6.f).ToString(), point.ToString());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/point_base.h b/ui/gfx/geometry/point_base.h
new file mode 100644
index 0000000..43eea50
--- /dev/null
+++ b/ui/gfx/geometry/point_base.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_POINT_BASE_H_
+#define UI_GFX_GEOMETRY_POINT_BASE_H_
+
+#include <string>
+
+namespace gfx {
+
+// A point has an x and y coordinate.
+template <typename Class, typename Type, typename VectorClass>
+class PointBase {
+ public:
+  Type x() const { return x_; }
+  Type y() const { return y_; }
+
+  void SetPoint(Type x, Type y) {
+    x_ = x;
+    y_ = y;
+  }
+
+  void set_x(Type x) { x_ = x; }
+  void set_y(Type y) { y_ = y; }
+
+  void Offset(Type delta_x, Type delta_y) {
+    x_ += delta_x;
+    y_ += delta_y;
+  }
+
+  void operator+=(const VectorClass& vector) {
+    x_ += vector.x();
+    y_ += vector.y();
+  }
+
+  void operator-=(const VectorClass& vector) {
+    x_ -= vector.x();
+    y_ -= vector.y();
+  }
+
+  void SetToMin(const Class& other) {
+    x_ = x_ <= other.x_ ? x_ : other.x_;
+    y_ = y_ <= other.y_ ? y_ : other.y_;
+  }
+
+  void SetToMax(const Class& other) {
+    x_ = x_ >= other.x_ ? x_ : other.x_;
+    y_ = y_ >= other.y_ ? y_ : other.y_;
+  }
+
+  bool IsOrigin() const { return x_ == Type(0) && y_ == Type(0); }
+
+  VectorClass OffsetFromOrigin() const { return VectorClass(x_, y_); }
+
+  // A point is less than another point if its y-value is closer
+  // to the origin. If the y-values are the same, then point with
+  // the x-value closer to the origin is considered less than the
+  // other.
+  // This comparison is required to use Point in sets, or sorted
+  // vectors.
+  bool operator<(const Class& rhs) const {
+    return (y_ == rhs.y_) ? (x_ < rhs.x_) : (y_ < rhs.y_);
+  }
+
+ protected:
+  PointBase() {}
+  PointBase(Type x, Type y) : x_(x), y_(y) {}
+  // Destructor is intentionally made non virtual and protected.
+  // Do not make this public.
+  ~PointBase() {}
+
+ private:
+  Type x_;
+  Type y_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_POINT_BASE_H_
diff --git a/ui/gfx/geometry/point_conversions.cc b/ui/gfx/geometry/point_conversions.cc
new file mode 100644
index 0000000..bf800da
--- /dev/null
+++ b/ui/gfx/geometry/point_conversions.cc
@@ -0,0 +1,24 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/point_conversions.h"
+
+#include "base/numerics/safe_conversions.h"
+
+namespace gfx {
+
+Point ToFlooredPoint(const PointF& point) {
+  return Point(base::ClampFloor(point.x()), base::ClampFloor(point.y()));
+}
+
+Point ToCeiledPoint(const PointF& point) {
+  return Point(base::ClampCeil(point.x()), base::ClampCeil(point.y()));
+}
+
+Point ToRoundedPoint(const PointF& point) {
+  return Point(base::ClampRound(point.x()), base::ClampRound(point.y()));
+}
+
+}  // namespace gfx
+
diff --git a/ui/gfx/geometry/point_conversions.h b/ui/gfx/geometry/point_conversions.h
new file mode 100644
index 0000000..894272c
--- /dev/null
+++ b/ui/gfx/geometry/point_conversions.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_POINT_CONVERSIONS_H_
+#define UI_GFX_GEOMETRY_POINT_CONVERSIONS_H_
+
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_f.h"
+
+namespace gfx {
+
+// Returns a Point with each component from the input PointF floored.
+GEOMETRY_EXPORT Point ToFlooredPoint(const PointF& point);
+
+// Returns a Point with each component from the input PointF ceiled.
+GEOMETRY_EXPORT Point ToCeiledPoint(const PointF& point);
+
+// Returns a Point with each component from the input PointF rounded.
+GEOMETRY_EXPORT Point ToRoundedPoint(const PointF& point);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_POINT_CONVERSIONS_H_
diff --git a/ui/gfx/geometry/point_f.cc b/ui/gfx/geometry/point_f.cc
new file mode 100644
index 0000000..4808ab7
--- /dev/null
+++ b/ui/gfx/geometry/point_f.cc
@@ -0,0 +1,23 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/point_f.h"
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+template class PointBase<PointF, float, Vector2dF>;
+
+std::string PointF::ToString() const {
+  return base::StringPrintf("%f,%f", x(), y());
+}
+
+PointF ScalePoint(const PointF& p, float x_scale, float y_scale) {
+  PointF scaled_p(p);
+  scaled_p.Scale(x_scale, y_scale);
+  return scaled_p;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/point_f.h b/ui/gfx/geometry/point_f.h
new file mode 100644
index 0000000..6dd12ff
--- /dev/null
+++ b/ui/gfx/geometry/point_f.h
@@ -0,0 +1,71 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_POINT_F_H_
+#define UI_GFX_GEOMETRY_POINT_F_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "ui/gfx/geometry/point_base.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace gfx {
+
+// A floating-point version of Point.
+class PointF : public PointBase<PointF, float, Vector2dF> {
+ public:
+  PointF() : PointBase<PointF, float, Vector2dF>(0, 0) {}
+  PointF(float x, float y) : PointBase<PointF, float, Vector2dF>(x, y) {}
+  ~PointF() {}
+
+  void Scale(float scale) { Scale(scale, scale); }
+
+  void Scale(float x_scale, float y_scale) {
+    SetPoint(x() * x_scale, y() * y_scale);
+  }
+
+  // Returns a string representation of point.
+  std::string ToString() const;
+};
+
+inline bool operator==(const PointF& lhs, const PointF& rhs) {
+  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
+}
+
+inline bool operator!=(const PointF& lhs, const PointF& rhs) {
+  return !(lhs == rhs);
+}
+
+inline PointF operator+(const PointF& lhs, const Vector2dF& rhs) {
+  PointF result(lhs);
+  result += rhs;
+  return result;
+}
+
+inline PointF operator-(const PointF& lhs, const Vector2dF& rhs) {
+  PointF result(lhs);
+  result -= rhs;
+  return result;
+}
+
+inline Vector2dF operator-(const PointF& lhs, const PointF& rhs) {
+  return Vector2dF(lhs.x() - rhs.x(), lhs.y() - rhs.y());
+}
+
+inline PointF PointAtOffsetFromOrigin(const Vector2dF& offset_from_origin) {
+  return PointF(offset_from_origin.x(), offset_from_origin.y());
+}
+
+PointF ScalePoint(const PointF& p, float x_scale, float y_scale);
+
+inline PointF ScalePoint(const PointF& p, float scale) {
+  return ScalePoint(p, scale, scale);
+}
+
+extern template class PointBase<PointF, float, Vector2dF>;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_POINT_F_H_
diff --git a/ui/gfx/geometry/point_unittest.cc b/ui/gfx/geometry/point_unittest.cc
new file mode 100644
index 0000000..90f61ae
--- /dev/null
+++ b/ui/gfx/geometry/point_unittest.cc
@@ -0,0 +1,255 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/point_f.h"
+
+namespace gfx {
+
+TEST(PointTest, ToPointF) {
+  // Check that explicit conversion from integer to float compiles.
+  Point a(10, 20);
+  PointF b = PointF(a);
+
+  EXPECT_EQ(static_cast<float>(a.x()), b.x());
+  EXPECT_EQ(static_cast<float>(a.y()), b.y());
+}
+
+TEST(PointTest, IsOrigin) {
+  EXPECT_FALSE(Point(1, 0).IsOrigin());
+  EXPECT_FALSE(Point(0, 1).IsOrigin());
+  EXPECT_FALSE(Point(1, 2).IsOrigin());
+  EXPECT_FALSE(Point(-1, 0).IsOrigin());
+  EXPECT_FALSE(Point(0, -1).IsOrigin());
+  EXPECT_FALSE(Point(-1, -2).IsOrigin());
+  EXPECT_TRUE(Point(0, 0).IsOrigin());
+
+  EXPECT_FALSE(PointF(0.1f, 0).IsOrigin());
+  EXPECT_FALSE(PointF(0, 0.1f).IsOrigin());
+  EXPECT_FALSE(PointF(0.1f, 2).IsOrigin());
+  EXPECT_FALSE(PointF(-0.1f, 0).IsOrigin());
+  EXPECT_FALSE(PointF(0, -0.1f).IsOrigin());
+  EXPECT_FALSE(PointF(-0.1f, -2).IsOrigin());
+  EXPECT_TRUE(PointF(0, 0).IsOrigin());
+}
+
+TEST(PointTest, VectorArithmetic) {
+  Point a(1, 5);
+  Vector2d v1(3, -3);
+  Vector2d v2(-8, 1);
+
+  static const struct {
+    Point expected;
+    Point actual;
+  } tests[] = {
+    { Point(4, 2), a + v1 },
+    { Point(-2, 8), a - v1 },
+    { a, a - v1 + v1 },
+    { a, a + v1 - v1 },
+    { a, a + Vector2d() },
+    { Point(12, 1), a + v1 - v2 },
+    { Point(-10, 9), a - v1 + v2 }
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i)
+    EXPECT_EQ(tests[i].expected.ToString(), tests[i].actual.ToString());
+}
+
+TEST(PointTest, OffsetFromPoint) {
+  Point a(1, 5);
+  Point b(-20, 8);
+  EXPECT_EQ(Vector2d(-20 - 1, 8 - 5).ToString(), (b - a).ToString());
+}
+
+TEST(PointTest, ToRoundedPoint) {
+  EXPECT_EQ(Point(0, 0), ToRoundedPoint(PointF(0, 0)));
+  EXPECT_EQ(Point(0, 0), ToRoundedPoint(PointF(0.0001f, 0.0001f)));
+  EXPECT_EQ(Point(0, 0), ToRoundedPoint(PointF(0.4999f, 0.4999f)));
+  EXPECT_EQ(Point(1, 1), ToRoundedPoint(PointF(0.5f, 0.5f)));
+  EXPECT_EQ(Point(1, 1), ToRoundedPoint(PointF(0.9999f, 0.9999f)));
+
+  EXPECT_EQ(Point(10, 10), ToRoundedPoint(PointF(10, 10)));
+  EXPECT_EQ(Point(10, 10), ToRoundedPoint(PointF(10.0001f, 10.0001f)));
+  EXPECT_EQ(Point(10, 10), ToRoundedPoint(PointF(10.4999f, 10.4999f)));
+  EXPECT_EQ(Point(11, 11), ToRoundedPoint(PointF(10.5f, 10.5f)));
+  EXPECT_EQ(Point(11, 11), ToRoundedPoint(PointF(10.9999f, 10.9999f)));
+
+  EXPECT_EQ(Point(-10, -10), ToRoundedPoint(PointF(-10, -10)));
+  EXPECT_EQ(Point(-10, -10), ToRoundedPoint(PointF(-10.0001f, -10.0001f)));
+  EXPECT_EQ(Point(-10, -10), ToRoundedPoint(PointF(-10.4999f, -10.4999f)));
+  EXPECT_EQ(Point(-11, -11), ToRoundedPoint(PointF(-10.5f, -10.5f)));
+  EXPECT_EQ(Point(-11, -11), ToRoundedPoint(PointF(-10.9999f, -10.9999f)));
+}
+
+TEST(PointTest, Scale) {
+  EXPECT_EQ(PointF().ToString(), ScalePoint(PointF(), 2).ToString());
+  EXPECT_EQ(PointF().ToString(), ScalePoint(PointF(), 2, 2).ToString());
+
+  EXPECT_EQ(PointF(2, -2).ToString(), ScalePoint(PointF(1, -1), 2).ToString());
+  EXPECT_EQ(PointF(2, -2).ToString(),
+            ScalePoint(PointF(1, -1), 2, 2).ToString());
+
+  PointF zero;
+  PointF one(1, -1);
+
+  zero.Scale(2);
+  zero.Scale(3, 1.5);
+
+  one.Scale(2);
+  one.Scale(3, 1.5);
+
+  EXPECT_EQ(PointF().ToString(), zero.ToString());
+  EXPECT_EQ(PointF(6, -3).ToString(), one.ToString());
+}
+
+TEST(PointTest, ClampPoint) {
+  Point a;
+
+  a = Point(3, 5);
+  EXPECT_EQ(Point(3, 5).ToString(), a.ToString());
+  a.SetToMax(Point(2, 4));
+  EXPECT_EQ(Point(3, 5).ToString(), a.ToString());
+  a.SetToMax(Point(3, 5));
+  EXPECT_EQ(Point(3, 5).ToString(), a.ToString());
+  a.SetToMax(Point(4, 2));
+  EXPECT_EQ(Point(4, 5).ToString(), a.ToString());
+  a.SetToMax(Point(8, 10));
+  EXPECT_EQ(Point(8, 10).ToString(), a.ToString());
+
+  a.SetToMin(Point(9, 11));
+  EXPECT_EQ(Point(8, 10).ToString(), a.ToString());
+  a.SetToMin(Point(8, 10));
+  EXPECT_EQ(Point(8, 10).ToString(), a.ToString());
+  a.SetToMin(Point(11, 9));
+  EXPECT_EQ(Point(8, 9).ToString(), a.ToString());
+  a.SetToMin(Point(7, 11));
+  EXPECT_EQ(Point(7, 9).ToString(), a.ToString());
+  a.SetToMin(Point(3, 5));
+  EXPECT_EQ(Point(3, 5).ToString(), a.ToString());
+}
+
+TEST(PointTest, ClampPointF) {
+  PointF a;
+
+  a = PointF(3.5f, 5.5f);
+  EXPECT_EQ(PointF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(PointF(2.5f, 4.5f));
+  EXPECT_EQ(PointF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(PointF(3.5f, 5.5f));
+  EXPECT_EQ(PointF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(PointF(4.5f, 2.5f));
+  EXPECT_EQ(PointF(4.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(PointF(8.5f, 10.5f));
+  EXPECT_EQ(PointF(8.5f, 10.5f).ToString(), a.ToString());
+
+  a.SetToMin(PointF(9.5f, 11.5f));
+  EXPECT_EQ(PointF(8.5f, 10.5f).ToString(), a.ToString());
+  a.SetToMin(PointF(8.5f, 10.5f));
+  EXPECT_EQ(PointF(8.5f, 10.5f).ToString(), a.ToString());
+  a.SetToMin(PointF(11.5f, 9.5f));
+  EXPECT_EQ(PointF(8.5f, 9.5f).ToString(), a.ToString());
+  a.SetToMin(PointF(7.5f, 11.5f));
+  EXPECT_EQ(PointF(7.5f, 9.5f).ToString(), a.ToString());
+  a.SetToMin(PointF(3.5f, 5.5f));
+  EXPECT_EQ(PointF(3.5f, 5.5f).ToString(), a.ToString());
+}
+
+TEST(PointTest, Offset) {
+  Point test(3, 4);
+  test.Offset(5, -8);
+  EXPECT_EQ(test, Point(8, -4));
+}
+
+TEST(PointTest, VectorMath) {
+  Point test = Point(3, 4);
+  test += Vector2d(5, -8);
+  EXPECT_EQ(test, Point(8, -4));
+
+  Point test2 = Point(3, 4);
+  test2 -= Vector2d(5, -8);
+  EXPECT_EQ(test2, Point(-2, 12));
+}
+
+TEST(PointTest, IntegerOverflow) {
+  int int_max = std::numeric_limits<int>::max();
+  int int_min = std::numeric_limits<int>::min();
+
+  Point max_point(int_max, int_max);
+  Point min_point(int_min, int_min);
+  Point test;
+
+  test = Point();
+  test.Offset(int_max, int_max);
+  EXPECT_EQ(test, max_point);
+
+  test = Point();
+  test.Offset(int_min, int_min);
+  EXPECT_EQ(test, min_point);
+
+  test = Point(10, 20);
+  test.Offset(int_max, int_max);
+  EXPECT_EQ(test, max_point);
+
+  test = Point(-10, -20);
+  test.Offset(int_min, int_min);
+  EXPECT_EQ(test, min_point);
+
+  test = Point();
+  test += Vector2d(int_max, int_max);
+  EXPECT_EQ(test, max_point);
+
+  test = Point();
+  test += Vector2d(int_min, int_min);
+  EXPECT_EQ(test, min_point);
+
+  test = Point(10, 20);
+  test += Vector2d(int_max, int_max);
+  EXPECT_EQ(test, max_point);
+
+  test = Point(-10, -20);
+  test += Vector2d(int_min, int_min);
+  EXPECT_EQ(test, min_point);
+
+  test = Point();
+  test -= Vector2d(int_max, int_max);
+  EXPECT_EQ(test, Point(-int_max, -int_max));
+
+  test = Point();
+  test -= Vector2d(int_min, int_min);
+  EXPECT_EQ(test, max_point);
+
+  test = Point(10, 20);
+  test -= Vector2d(int_min, int_min);
+  EXPECT_EQ(test, max_point);
+
+  test = Point(-10, -20);
+  test -= Vector2d(int_max, int_max);
+  EXPECT_EQ(test, min_point);
+}
+
+TEST(PointTest, IsWithinDistance) {
+  PointF pt(10.f, 10.f);
+  EXPECT_TRUE(pt.IsWithinDistance(PointF(10.f, 10.f),
+                                  /*allowed_distance=*/0.0000000000001f));
+  EXPECT_FALSE(pt.IsWithinDistance(PointF(8.f, 8.f), /*allowed_distance=*/1.f));
+
+  pt = PointF(-10.f, -10.f);
+  EXPECT_FALSE(
+      pt.IsWithinDistance(PointF(10.f, 10.f), /*allowed_distance=*/10.f));
+  EXPECT_TRUE(pt.IsWithinDistance(PointF(-9.9988f, -10.0013f),
+                                  /*epsallowed_distanceilon=*/0.0017689f));
+
+  pt = PointF(std::numeric_limits<float>::max(),
+              std::numeric_limits<float>::max());
+  EXPECT_FALSE(pt.IsWithinDistance(PointF(std::numeric_limits<float>::min(),
+                                          std::numeric_limits<float>::min()),
+                                   /*allowed_distance=*/100.f));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/quad_f.cc b/ui/gfx/geometry/quad_f.cc
new file mode 100644
index 0000000..8ed8b91
--- /dev/null
+++ b/ui/gfx/geometry/quad_f.cc
@@ -0,0 +1,134 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/quad_f.h"
+
+#include <limits>
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+void QuadF::operator=(const RectF& rect) {
+  p1_ = PointF(rect.x(), rect.y());
+  p2_ = PointF(rect.right(), rect.y());
+  p3_ = PointF(rect.right(), rect.bottom());
+  p4_ = PointF(rect.x(), rect.bottom());
+}
+
+std::string QuadF::ToString() const {
+  return base::StringPrintf("%s;%s;%s;%s",
+                            p1_.ToString().c_str(),
+                            p2_.ToString().c_str(),
+                            p3_.ToString().c_str(),
+                            p4_.ToString().c_str());
+}
+
+static inline bool WithinEpsilon(float a, float b) {
+  return std::abs(a - b) < std::numeric_limits<float>::epsilon();
+}
+
+bool QuadF::IsRectilinear() const {
+  return
+      (WithinEpsilon(p1_.x(), p2_.x()) && WithinEpsilon(p2_.y(), p3_.y()) &&
+       WithinEpsilon(p3_.x(), p4_.x()) && WithinEpsilon(p4_.y(), p1_.y())) ||
+      (WithinEpsilon(p1_.y(), p2_.y()) && WithinEpsilon(p2_.x(), p3_.x()) &&
+       WithinEpsilon(p3_.y(), p4_.y()) && WithinEpsilon(p4_.x(), p1_.x()));
+}
+
+bool QuadF::IsCounterClockwise() const {
+  // This math computes the signed area of the quad. Positive area
+  // indicates the quad is clockwise; negative area indicates the quad is
+  // counter-clockwise. Note carefully: this is backwards from conventional
+  // math because our geometric space uses screen coordiantes with y-axis
+  // pointing downards.
+  // Reference: http://mathworld.wolfram.com/PolygonArea.html.
+  // The equation can be written:
+  // Signed area = determinant1 + determinant2 + determinant3 + determinant4
+  // In practise, Refactoring the computation of adding determinants so that
+  // reducing the number of operations. The equation is:
+  // Signed area = element1 + element2 - element3 - element4
+
+  float p24 = p2_.y() - p4_.y();
+  float p31 = p3_.y() - p1_.y();
+
+  // Up-cast to double so this cannot overflow.
+  double element1 = static_cast<double>(p1_.x()) * p24;
+  double element2 = static_cast<double>(p2_.x()) * p31;
+  double element3 = static_cast<double>(p3_.x()) * p24;
+  double element4 = static_cast<double>(p4_.x()) * p31;
+
+  return element1 + element2 < element3 + element4;
+}
+
+static inline bool PointIsInTriangle(const PointF& point,
+                                     const PointF& r1,
+                                     const PointF& r2,
+                                     const PointF& r3) {
+  // Compute the barycentric coordinates (u, v, w) of |point| relative to the
+  // triangle (r1, r2, r3) by the solving the system of equations:
+  //   1) point = u * r1 + v * r2 + w * r3
+  //   2) u + v + w = 1
+  // This algorithm comes from Christer Ericson's Real-Time Collision Detection.
+
+  Vector2dF r31 = r1 - r3;
+  Vector2dF r32 = r2 - r3;
+  Vector2dF r3p = point - r3;
+
+  // Promote to doubles so all the math below is done with doubles, because
+  // otherwise it gets incorrect results on arm64.
+  double r31x = r31.x();
+  double r31y = r31.y();
+  double r32x = r32.x();
+  double r32y = r32.y();
+
+  double denom = r32y * r31x - r32x * r31y;
+  double u = (r32y * r3p.x() - r32x * r3p.y()) / denom;
+  double v = (r31x * r3p.y() - r31y * r3p.x()) / denom;
+  double w = 1.0 - u - v;
+
+  // Use the barycentric coordinates to test if |point| is inside the
+  // triangle (r1, r2, r2).
+  return (u >= 0) && (v >= 0) && (w >= 0);
+}
+
+bool QuadF::Contains(const PointF& point) const {
+  return PointIsInTriangle(point, p1_, p2_, p3_)
+      || PointIsInTriangle(point, p1_, p3_, p4_);
+}
+
+void QuadF::Scale(float x_scale, float y_scale) {
+  p1_.Scale(x_scale, y_scale);
+  p2_.Scale(x_scale, y_scale);
+  p3_.Scale(x_scale, y_scale);
+  p4_.Scale(x_scale, y_scale);
+}
+
+void QuadF::operator+=(const Vector2dF& rhs) {
+  p1_ += rhs;
+  p2_ += rhs;
+  p3_ += rhs;
+  p4_ += rhs;
+}
+
+void QuadF::operator-=(const Vector2dF& rhs) {
+  p1_ -= rhs;
+  p2_ -= rhs;
+  p3_ -= rhs;
+  p4_ -= rhs;
+}
+
+QuadF operator+(const QuadF& lhs, const Vector2dF& rhs) {
+  QuadF result = lhs;
+  result += rhs;
+  return result;
+}
+
+QuadF operator-(const QuadF& lhs, const Vector2dF& rhs) {
+  QuadF result = lhs;
+  result -= rhs;
+  return result;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/quad_f.h b/ui/gfx/geometry/quad_f.h
new file mode 100644
index 0000000..3fe8cf1
--- /dev/null
+++ b/ui/gfx/geometry/quad_f.h
@@ -0,0 +1,130 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_QUAD_F_H_
+#define UI_GFX_GEOMETRY_QUAD_F_H_
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <cmath>
+#include <iosfwd>
+#include <string>
+
+#include "base/check_op.h"
+#include "ui/gfx/geometry/geometry_export.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace gfx {
+
+// A Quad is defined by four corners, allowing it to have edges that are not
+// axis-aligned, unlike a Rect.
+class GEOMETRY_EXPORT QuadF {
+ public:
+  constexpr QuadF() = default;
+  constexpr QuadF(const PointF& p1,
+                  const PointF& p2,
+                  const PointF& p3,
+                  const PointF& p4)
+      : p1_(p1), p2_(p2), p3_(p3), p4_(p4) {}
+
+  constexpr explicit QuadF(const RectF& rect)
+      : p1_(rect.x(), rect.y()),
+        p2_(rect.right(), rect.y()),
+        p3_(rect.right(), rect.bottom()),
+        p4_(rect.x(), rect.bottom()) {}
+
+  void operator=(const RectF& rect);
+
+  void set_p1(const PointF& p) { p1_ = p; }
+  void set_p2(const PointF& p) { p2_ = p; }
+  void set_p3(const PointF& p) { p3_ = p; }
+  void set_p4(const PointF& p) { p4_ = p; }
+
+  constexpr const PointF& p1() const { return p1_; }
+  constexpr const PointF& p2() const { return p2_; }
+  constexpr const PointF& p3() const { return p3_; }
+  constexpr const PointF& p4() const { return p4_; }
+
+  // Returns true if the quad is an axis-aligned rectangle.
+  bool IsRectilinear() const;
+
+  // Returns true if the points of the quad are in counter-clockwise order. This
+  // assumes that the quad is convex, and that no three points are collinear.
+  bool IsCounterClockwise() const;
+
+  // Returns true if the |point| is contained within the quad, or lies on on
+  // edge of the quad. This assumes that the quad is convex.
+  bool Contains(const gfx::PointF& point) const;
+
+  // Returns a rectangle that bounds the four points of the quad. The points of
+  // the quad may lie on the right/bottom edge of the resulting rectangle,
+  // rather than being strictly inside it.
+  RectF BoundingBox() const {
+    float rl = std::min({p1_.x(), p2_.x(), p3_.x(), p4_.x()});
+    float rr = std::max({p1_.x(), p2_.x(), p3_.x(), p4_.x()});
+    float rt = std::min({p1_.y(), p2_.y(), p3_.y(), p4_.y()});
+    float rb = std::max({p1_.y(), p2_.y(), p3_.y(), p4_.y()});
+    return RectF(rl, rt, rr - rl, rb - rt);
+  }
+
+  // Realigns the corners in the quad by rotating them n corners to the right.
+  void Realign(size_t times) {
+    DCHECK_LE(times, 4u);
+    for (size_t i = 0; i < times; ++i) {
+      PointF temp = p1_;
+      p1_ = p2_;
+      p2_ = p3_;
+      p3_ = p4_;
+      p4_ = temp;
+    }
+  }
+
+  // Add a vector to the quad, offseting each point in the quad by the vector.
+  void operator+=(const Vector2dF& rhs);
+  // Subtract a vector from the quad, offseting each point in the quad by the
+  // inverse of the vector.
+  void operator-=(const Vector2dF& rhs);
+
+  // Scale each point in the quad by the |scale| factor.
+  void Scale(float scale) { Scale(scale, scale); }
+
+  // Scale each point in the quad by the scale factors along each axis.
+  void Scale(float x_scale, float y_scale);
+
+  // Returns a string representation of quad.
+  std::string ToString() const;
+
+ private:
+  PointF p1_;
+  PointF p2_;
+  PointF p3_;
+  PointF p4_;
+};
+
+inline bool operator==(const QuadF& lhs, const QuadF& rhs) {
+  return
+      lhs.p1() == rhs.p1() && lhs.p2() == rhs.p2() &&
+      lhs.p3() == rhs.p3() && lhs.p4() == rhs.p4();
+}
+
+inline bool operator!=(const QuadF& lhs, const QuadF& rhs) {
+  return !(lhs == rhs);
+}
+
+// Add a vector to a quad, offseting each point in the quad by the vector.
+GEOMETRY_EXPORT QuadF operator+(const QuadF& lhs, const Vector2dF& rhs);
+// Subtract a vector from a quad, offseting each point in the quad by the
+// inverse of the vector.
+GEOMETRY_EXPORT QuadF operator-(const QuadF& lhs, const Vector2dF& rhs);
+
+// This is declared here for use in gtest-based unit tests but is defined in
+// the //ui/gfx:test_support target. Depend on that to use this in your unit
+// test. This should not be used in production code - call ToString() instead.
+void PrintTo(const QuadF& quad, ::std::ostream* os);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_QUAD_F_H_
diff --git a/ui/gfx/geometry/quad_unittest.cc b/ui/gfx/geometry/quad_unittest.cc
new file mode 100644
index 0000000..87849b0
--- /dev/null
+++ b/ui/gfx/geometry/quad_unittest.cc
@@ -0,0 +1,361 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+
+#include "base/cxx17_backports.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/quad_f.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace gfx {
+
+TEST(QuadTest, Construction) {
+  // Verify constructors.
+  PointF a(1, 1);
+  PointF b(2, 1);
+  PointF c(2, 2);
+  PointF d(1, 2);
+  PointF e;
+  QuadF q1;
+  QuadF q2(e, e, e, e);
+  QuadF q3(a, b, c, d);
+  QuadF q4(BoundingRect(a, c));
+  EXPECT_EQ(q1, q2);
+  EXPECT_EQ(q3, q4);
+
+  // Verify getters.
+  EXPECT_EQ(q3.p1(), a);
+  EXPECT_EQ(q3.p2(), b);
+  EXPECT_EQ(q3.p3(), c);
+  EXPECT_EQ(q3.p4(), d);
+
+  // Verify setters.
+  q3.set_p1(b);
+  q3.set_p2(c);
+  q3.set_p3(d);
+  q3.set_p4(a);
+  EXPECT_EQ(q3.p1(), b);
+  EXPECT_EQ(q3.p2(), c);
+  EXPECT_EQ(q3.p3(), d);
+  EXPECT_EQ(q3.p4(), a);
+
+  // Verify operator=(Rect)
+  EXPECT_NE(q1, q4);
+  q1 = BoundingRect(a, c);
+  EXPECT_EQ(q1, q4);
+
+  // Verify operator=(Quad)
+  EXPECT_NE(q1, q3);
+  q1 = q3;
+  EXPECT_EQ(q1, q3);
+}
+
+TEST(QuadTest, AddingVectors) {
+  PointF a(1, 1);
+  PointF b(2, 1);
+  PointF c(2, 2);
+  PointF d(1, 2);
+  Vector2dF v(3.5f, -2.5f);
+
+  QuadF q1(a, b, c, d);
+  QuadF added = q1 + v;
+  q1 += v;
+  QuadF expected1(PointF(4.5f, -1.5f),
+                  PointF(5.5f, -1.5f),
+                  PointF(5.5f, -0.5f),
+                  PointF(4.5f, -0.5f));
+  EXPECT_EQ(expected1, added);
+  EXPECT_EQ(expected1, q1);
+
+  QuadF q2(a, b, c, d);
+  QuadF subtracted = q2 - v;
+  q2 -= v;
+  QuadF expected2(PointF(-2.5f, 3.5f),
+                  PointF(-1.5f, 3.5f),
+                  PointF(-1.5f, 4.5f),
+                  PointF(-2.5f, 4.5f));
+  EXPECT_EQ(expected2, subtracted);
+  EXPECT_EQ(expected2, q2);
+
+  QuadF q3(a, b, c, d);
+  q3 += v;
+  q3 -= v;
+  EXPECT_EQ(QuadF(a, b, c, d), q3);
+  EXPECT_EQ(q3, (q3 + v - v));
+}
+
+TEST(QuadTest, IsRectilinear) {
+  PointF a(1, 1);
+  PointF b(2, 1);
+  PointF c(2, 2);
+  PointF d(1, 2);
+  Vector2dF v(3.5f, -2.5f);
+
+  EXPECT_TRUE(QuadF().IsRectilinear());
+  EXPECT_TRUE(QuadF(a, b, c, d).IsRectilinear());
+  EXPECT_TRUE((QuadF(a, b, c, d) + v).IsRectilinear());
+
+  float epsilon = std::numeric_limits<float>::epsilon();
+  PointF a2(1 + epsilon / 2, 1 + epsilon / 2);
+  PointF b2(2 + epsilon / 2, 1 + epsilon / 2);
+  PointF c2(2 + epsilon / 2, 2 + epsilon / 2);
+  PointF d2(1 + epsilon / 2, 2 + epsilon / 2);
+  EXPECT_TRUE(QuadF(a2, b, c, d).IsRectilinear());
+  EXPECT_TRUE((QuadF(a2, b, c, d) + v).IsRectilinear());
+  EXPECT_TRUE(QuadF(a, b2, c, d).IsRectilinear());
+  EXPECT_TRUE((QuadF(a, b2, c, d) + v).IsRectilinear());
+  EXPECT_TRUE(QuadF(a, b, c2, d).IsRectilinear());
+  EXPECT_TRUE((QuadF(a, b, c2, d) + v).IsRectilinear());
+  EXPECT_TRUE(QuadF(a, b, c, d2).IsRectilinear());
+  EXPECT_TRUE((QuadF(a, b, c, d2) + v).IsRectilinear());
+
+  struct {
+    PointF a_off, b_off, c_off, d_off;
+  } tests[] = {
+    {
+      PointF(1, 1.00001f),
+      PointF(2, 1.00001f),
+      PointF(2, 2.00001f),
+      PointF(1, 2.00001f)
+    },
+    {
+      PointF(1.00001f, 1),
+      PointF(2.00001f, 1),
+      PointF(2.00001f, 2),
+      PointF(1.00001f, 2)
+    },
+    {
+      PointF(1.00001f, 1.00001f),
+      PointF(2.00001f, 1.00001f),
+      PointF(2.00001f, 2.00001f),
+      PointF(1.00001f, 2.00001f)
+    },
+    {
+      PointF(1, 0.99999f),
+      PointF(2, 0.99999f),
+      PointF(2, 1.99999f),
+      PointF(1, 1.99999f)
+    },
+    {
+      PointF(0.99999f, 1),
+      PointF(1.99999f, 1),
+      PointF(1.99999f, 2),
+      PointF(0.99999f, 2)
+    },
+    {
+      PointF(0.99999f, 0.99999f),
+      PointF(1.99999f, 0.99999f),
+      PointF(1.99999f, 1.99999f),
+      PointF(0.99999f, 1.99999f)
+    }
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    PointF a_off = tests[i].a_off;
+    PointF b_off = tests[i].b_off;
+    PointF c_off = tests[i].c_off;
+    PointF d_off = tests[i].d_off;
+
+    EXPECT_FALSE(QuadF(a_off, b, c, d).IsRectilinear());
+    EXPECT_FALSE((QuadF(a_off, b, c, d) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a, b_off, c, d).IsRectilinear());
+    EXPECT_FALSE((QuadF(a, b_off, c, d) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a, b, c_off, d).IsRectilinear());
+    EXPECT_FALSE((QuadF(a, b, c_off, d) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a, b, c, d_off).IsRectilinear());
+    EXPECT_FALSE((QuadF(a, b, c, d_off) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a_off, b, c_off, d).IsRectilinear());
+    EXPECT_FALSE((QuadF(a_off, b, c_off, d) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a, b_off, c, d_off).IsRectilinear());
+    EXPECT_FALSE((QuadF(a, b_off, c, d_off) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a, b_off, c_off, d_off).IsRectilinear());
+    EXPECT_FALSE((QuadF(a, b_off, c_off, d_off) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a_off, b, c_off, d_off).IsRectilinear());
+    EXPECT_FALSE((QuadF(a_off, b, c_off, d_off) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a_off, b_off, c, d_off).IsRectilinear());
+    EXPECT_FALSE((QuadF(a_off, b_off, c, d_off) + v).IsRectilinear());
+    EXPECT_FALSE(QuadF(a_off, b_off, c_off, d).IsRectilinear());
+    EXPECT_FALSE((QuadF(a_off, b_off, c_off, d) + v).IsRectilinear());
+    EXPECT_TRUE(QuadF(a_off, b_off, c_off, d_off).IsRectilinear());
+    EXPECT_TRUE((QuadF(a_off, b_off, c_off, d_off) + v).IsRectilinear());
+  }
+}
+
+TEST(QuadTest, IsCounterClockwise) {
+  PointF a1(1, 1);
+  PointF b1(2, 1);
+  PointF c1(2, 2);
+  PointF d1(1, 2);
+  EXPECT_FALSE(QuadF(a1, b1, c1, d1).IsCounterClockwise());
+  EXPECT_FALSE(QuadF(b1, c1, d1, a1).IsCounterClockwise());
+  EXPECT_TRUE(QuadF(a1, d1, c1, b1).IsCounterClockwise());
+  EXPECT_TRUE(QuadF(c1, b1, a1, d1).IsCounterClockwise());
+
+  // Slightly more complicated quads should work just as easily.
+  PointF a2(1.3f, 1.4f);
+  PointF b2(-0.7f, 4.9f);
+  PointF c2(1.8f, 6.2f);
+  PointF d2(2.1f, 1.6f);
+  EXPECT_TRUE(QuadF(a2, b2, c2, d2).IsCounterClockwise());
+  EXPECT_TRUE(QuadF(b2, c2, d2, a2).IsCounterClockwise());
+  EXPECT_FALSE(QuadF(a2, d2, c2, b2).IsCounterClockwise());
+  EXPECT_FALSE(QuadF(c2, b2, a2, d2).IsCounterClockwise());
+
+  // Quads with 3 collinear points should work correctly, too.
+  PointF a3(0, 0);
+  PointF b3(1, 0);
+  PointF c3(2, 0);
+  PointF d3(1, 1);
+  EXPECT_FALSE(QuadF(a3, b3, c3, d3).IsCounterClockwise());
+  EXPECT_FALSE(QuadF(b3, c3, d3, a3).IsCounterClockwise());
+  EXPECT_TRUE(QuadF(a3, d3, c3, b3).IsCounterClockwise());
+  // The next expectation in particular would fail for an implementation
+  // that incorrectly uses only a cross product of the first 3 vertices.
+  EXPECT_TRUE(QuadF(c3, b3, a3, d3).IsCounterClockwise());
+
+  // Non-convex quads should work correctly, too.
+  PointF a4(0, 0);
+  PointF b4(1, 1);
+  PointF c4(2, 0);
+  PointF d4(1, 3);
+  EXPECT_FALSE(QuadF(a4, b4, c4, d4).IsCounterClockwise());
+  EXPECT_FALSE(QuadF(b4, c4, d4, a4).IsCounterClockwise());
+  EXPECT_TRUE(QuadF(a4, d4, c4, b4).IsCounterClockwise());
+  EXPECT_TRUE(QuadF(c4, b4, a4, d4).IsCounterClockwise());
+
+  // A quad with huge coordinates should not fail this check due to
+  // single-precision overflow.
+  PointF a5(1e30f, 1e30f);
+  PointF b5(1e35f, 1e30f);
+  PointF c5(1e35f, 1e35f);
+  PointF d5(1e30f, 1e35f);
+  EXPECT_FALSE(QuadF(a5, b5, c5, d5).IsCounterClockwise());
+  EXPECT_FALSE(QuadF(b5, c5, d5, a5).IsCounterClockwise());
+  EXPECT_TRUE(QuadF(a5, d5, c5, b5).IsCounterClockwise());
+  EXPECT_TRUE(QuadF(c5, b5, a5, d5).IsCounterClockwise());
+}
+
+TEST(QuadTest, BoundingBox) {
+  RectF r(3.2f, 5.4f, 7.007f, 12.01f);
+  EXPECT_EQ(r, QuadF(r).BoundingBox());
+
+  PointF a(1.3f, 1.4f);
+  PointF b(-0.7f, 4.9f);
+  PointF c(1.8f, 6.2f);
+  PointF d(2.1f, 1.6f);
+  float left = -0.7f;
+  float top = 1.4f;
+  float right = 2.1f;
+  float bottom = 6.2f;
+  EXPECT_EQ(RectF(left, top, right - left, bottom - top),
+            QuadF(a, b, c, d).BoundingBox());
+}
+
+TEST(QuadTest, ContainsPoint) {
+  PointF a(1.3f, 1.4f);
+  PointF b(-0.8f, 4.4f);
+  PointF c(1.8f, 6.1f);
+  PointF d(2.1f, 1.6f);
+
+  Vector2dF epsilon_x(2 * std::numeric_limits<float>::epsilon(), 0);
+  Vector2dF epsilon_y(0, 2 * std::numeric_limits<float>::epsilon());
+
+  Vector2dF ac_center = c - a;
+  ac_center.Scale(0.5f);
+  Vector2dF bd_center = d - b;
+  bd_center.Scale(0.5f);
+
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(a + ac_center));
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(b + bd_center));
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(c - ac_center));
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(d - bd_center));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(a - ac_center));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(b - bd_center));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(c + ac_center));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(d + bd_center));
+
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(a));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(a - epsilon_x));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(a - epsilon_y));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(a + epsilon_x));
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(a + epsilon_y));
+
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(b));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(b - epsilon_x));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(b - epsilon_y));
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(b + epsilon_x));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(b + epsilon_y));
+
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(c));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(c - epsilon_x));
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(c - epsilon_y));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(c + epsilon_x));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(c + epsilon_y));
+
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(d));
+  EXPECT_TRUE(QuadF(a, b, c, d).Contains(d - epsilon_x));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(d - epsilon_y));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(d + epsilon_x));
+  EXPECT_FALSE(QuadF(a, b, c, d).Contains(d + epsilon_y));
+
+  // Test a simple square.
+  PointF s1(-1, -1);
+  PointF s2(1, -1);
+  PointF s3(1, 1);
+  PointF s4(-1, 1);
+  // Top edge.
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.1f, -1.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.0f, -1.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(0.0f, -1.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(1.0f, -1.0f)));
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(1.1f, -1.0f)));
+  // Bottom edge.
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.1f, 1.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.0f, 1.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(0.0f, 1.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(1.0f, 1.0f)));
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(1.1f, 1.0f)));
+  // Left edge.
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.0f, -1.1f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.0f, -1.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.0f, 0.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.0f, 1.0f)));
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.0f, 1.1f)));
+  // Right edge.
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(1.0f, -1.1f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(1.0f, -1.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(1.0f, 0.0f)));
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(1.0f, 1.0f)));
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(1.0f, 1.1f)));
+  // Centered inside.
+  EXPECT_TRUE(QuadF(s1, s2, s3, s4).Contains(PointF(0, 0)));
+  // Centered outside.
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(-1.1f, 0)));
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(1.1f, 0)));
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(0, -1.1f)));
+  EXPECT_FALSE(QuadF(s1, s2, s3, s4).Contains(PointF(0, 1.1f)));
+}
+
+TEST(QuadTest, Scale) {
+  PointF a(1.3f, 1.4f);
+  PointF b(-0.8f, 4.4f);
+  PointF c(1.8f, 6.1f);
+  PointF d(2.1f, 1.6f);
+  QuadF q1(a, b, c, d);
+  q1.Scale(1.5f);
+
+  PointF a_scaled = ScalePoint(a, 1.5f);
+  PointF b_scaled = ScalePoint(b, 1.5f);
+  PointF c_scaled = ScalePoint(c, 1.5f);
+  PointF d_scaled = ScalePoint(d, 1.5f);
+  EXPECT_EQ(q1, QuadF(a_scaled, b_scaled, c_scaled, d_scaled));
+
+  QuadF q2;
+  q2.Scale(1.5f);
+  EXPECT_EQ(q2, q2);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/quaternion.cc b/ui/gfx/geometry/quaternion.cc
new file mode 100644
index 0000000..86d674e
--- /dev/null
+++ b/ui/gfx/geometry/quaternion.cc
@@ -0,0 +1,132 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/geometry/quaternion.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "base/numerics/math_constants.h"
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+namespace {
+
+const double kEpsilon = 1e-5;
+
+}  // namespace
+
+Quaternion::Quaternion(const Vector3dF& axis, double theta) {
+  // Rotation angle is the product of |angle| and the magnitude of |axis|.
+  double length = axis.Length();
+  if (std::abs(length) < kEpsilon)
+    return;
+
+  Vector3dF normalized = axis;
+  normalized.Scale(1.0 / length);
+
+  theta *= 0.5;
+  double s = sin(theta);
+  x_ = normalized.x() * s;
+  y_ = normalized.y() * s;
+  z_ = normalized.z() * s;
+  w_ = cos(theta);
+}
+
+Quaternion::Quaternion(const Vector3dF& from, const Vector3dF& to) {
+  double dot = gfx::DotProduct(from, to);
+  double norm = sqrt(from.LengthSquared() * to.LengthSquared());
+  double real = norm + dot;
+  gfx::Vector3dF axis;
+  if (real < kEpsilon * norm) {
+    real = 0.0f;
+    axis = std::abs(from.x()) > std::abs(from.z())
+               ? gfx::Vector3dF{-from.y(), from.x(), 0.0}
+               : gfx::Vector3dF{0.0, -from.z(), from.y()};
+  } else {
+    axis = gfx::CrossProduct(from, to);
+  }
+  x_ = axis.x();
+  y_ = axis.y();
+  z_ = axis.z();
+  w_ = real;
+  *this = this->Normalized();
+}
+
+Quaternion Quaternion::FromAxisAngle(double x,
+                                     double y,
+                                     double z,
+                                     double angle) {
+  double length = std::sqrt(x * x + y * y + z * z);
+  if (std::abs(length) < kEpsilon)
+    return Quaternion(0, 0, 0, 1);
+
+  double scale = std::sin(0.5 * angle) / length;
+  return Quaternion(scale * x, scale * y, scale * z, std::cos(0.5 * angle));
+}
+
+// Adapted from https://www.euclideanspace.com/maths/algebra/realNormedAlgebra/
+// quaternions/slerp/index.htm
+Quaternion Quaternion::Slerp(const Quaternion& to, double t) const {
+  Quaternion from = *this;
+
+  double cos_half_angle =
+      from.x_ * to.x_ + from.y_ * to.y_ + from.z_ * to.z_ + from.w_ * to.w_;
+  if (cos_half_angle < 0) {
+    // Since the half angle is > 90 degrees, the full rotation angle would
+    // exceed 180 degrees. The quaternions (x, y, z, w) and (-x, -y, -z, -w)
+    // represent the same rotation. Flipping the orientation of either
+    // quaternion ensures that the half angle is less than 90 and that we are
+    // taking the shortest path.
+    from = from.flip();
+    cos_half_angle = -cos_half_angle;
+  }
+
+  // Ensure that acos is well behaved at the boundary.
+  if (cos_half_angle > 1)
+    cos_half_angle = 1;
+
+  double sin_half_angle = std::sqrt(1.0 - cos_half_angle * cos_half_angle);
+  if (sin_half_angle < kEpsilon) {
+    // Quaternions share common axis and angle.
+    return *this;
+  }
+
+  double half_angle = std::acos(cos_half_angle);
+
+  double scaleA = std::sin((1 - t) * half_angle) / sin_half_angle;
+  double scaleB = std::sin(t * half_angle) / sin_half_angle;
+
+  return (scaleA * from) + (scaleB * to);
+}
+
+Quaternion Quaternion::Lerp(const Quaternion& q, double t) const {
+  return (((1.0 - t) * *this) + (t * q)).Normalized();
+}
+
+double Quaternion::Length() const {
+  return x_ * x_ + y_ * y_ + z_ * z_ + w_ * w_;
+}
+
+Quaternion Quaternion::Normalized() const {
+  double length = Length();
+  if (length < kEpsilon)
+    return *this;
+  return *this / sqrt(length);
+}
+
+std::string Quaternion::ToString() const {
+  // q = (con(abs(v_theta)/2), v_theta/abs(v_theta) * sin(abs(v_theta)/2))
+  float abs_theta = acos(w_) * 2;
+  float scale = 1. / sin(abs_theta * .5);
+  gfx::Vector3dF v(x_, y_, z_);
+  v.Scale(scale);
+  return base::StringPrintf("[%f %f %f %f], v:", x_, y_, z_, w_) +
+         v.ToString() +
+         base::StringPrintf(", θ:%fπ", abs_theta / base::kPiFloat);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/quaternion.h b/ui/gfx/geometry/quaternion.h
new file mode 100644
index 0000000..8081881
--- /dev/null
+++ b/ui/gfx/geometry/quaternion.h
@@ -0,0 +1,109 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_QUATERNION_H_
+#define UI_GFX_GEOMETRY_QUATERNION_H_
+
+#include <string>
+
+#include "ui/gfx/geometry/geometry_export.h"
+
+namespace gfx {
+
+class Vector3dF;
+
+class GEOMETRY_EXPORT Quaternion {
+ public:
+  constexpr Quaternion() = default;
+  constexpr Quaternion(double x, double y, double z, double w)
+      : x_(x), y_(y), z_(z), w_(w) {}
+  Quaternion(const Vector3dF& axis, double angle);
+
+  // Constructs a quaternion representing a rotation between |from| and |to|.
+  Quaternion(const Vector3dF& from, const Vector3dF& to);
+
+  static Quaternion FromAxisAngle(double x, double y, double z, double angle);
+
+  constexpr double x() const { return x_; }
+  void set_x(double x) { x_ = x; }
+
+  constexpr double y() const { return y_; }
+  void set_y(double y) { y_ = y; }
+
+  constexpr double z() const { return z_; }
+  void set_z(double z) { z_ = z; }
+
+  constexpr double w() const { return w_; }
+  void set_w(double w) { w_ = w; }
+
+  Quaternion operator+(const Quaternion& q) const {
+    return {q.x_ + x_, q.y_ + y_, q.z_ + z_, q.w_ + w_};
+  }
+
+  Quaternion operator*(const Quaternion& q) const {
+    return {w_ * q.x_ + x_ * q.w_ + y_ * q.z_ - z_ * q.y_,
+            w_ * q.y_ - x_ * q.z_ + y_ * q.w_ + z_ * q.x_,
+            w_ * q.z_ + x_ * q.y_ - y_ * q.x_ + z_ * q.w_,
+            w_ * q.w_ - x_ * q.x_ - y_ * q.y_ - z_ * q.z_};
+  }
+
+  Quaternion inverse() const { return {-x_, -y_, -z_, w_}; }
+
+  Quaternion flip() const { return {-x_, -y_, -z_, -w_}; }
+
+  // Blends with the given quaternion, |q|, via spherical linear interpolation.
+  // Values of |t| in the range [0, 1] will interpolate between |this| and |q|,
+  // and values outside that range will extrapolate beyond in either direction.
+  Quaternion Slerp(const Quaternion& q, double t) const;
+
+  // Blends with the given quaternion, |q|, via linear interpolation. This is
+  // rarely what you want. Use only if you know what you're doing.
+  // Values of |t| in the range [0, 1] will interpolate between |this| and |q|,
+  // and values outside that range will extrapolate beyond in either direction.
+  Quaternion Lerp(const Quaternion& q, double t) const;
+
+  double Length() const;
+
+  Quaternion Normalized() const;
+
+  std::string ToString() const;
+
+ private:
+  double x_ = 0.0;
+  double y_ = 0.0;
+  double z_ = 0.0;
+  double w_ = 1.0;
+};
+
+// |s| is an arbitrary, real constant.
+inline Quaternion operator*(const Quaternion& q, double s) {
+  return Quaternion(q.x() * s, q.y() * s, q.z() * s, q.w() * s);
+}
+
+// |s| is an arbitrary, real constant.
+inline Quaternion operator*(double s, const Quaternion& q) {
+  return Quaternion(q.x() * s, q.y() * s, q.z() * s, q.w() * s);
+}
+
+// |s| is an arbitrary, real constant.
+inline Quaternion operator/(const Quaternion& q, double s) {
+  double inv = 1.0 / s;
+  return q * inv;
+}
+
+// Returns true if the x, y, z, w values of |lhs| and |rhs| are equal. Note that
+// two quaternions can represent the same orientation with different values.
+// This operator will return false in that scenario.
+inline bool operator==(const Quaternion& lhs, const Quaternion& rhs) {
+  return lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() == rhs.z() &&
+         lhs.w() == rhs.w();
+}
+
+inline bool operator!=(const Quaternion& lhs, const Quaternion& rhs) {
+  return !(lhs == rhs);
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_QUATERNION_H_
diff --git a/ui/gfx/geometry/quaternion_unittest.cc b/ui/gfx/geometry/quaternion_unittest.cc
new file mode 100644
index 0000000..3c9fd2b
--- /dev/null
+++ b/ui/gfx/geometry/quaternion_unittest.cc
@@ -0,0 +1,237 @@
+// Copyright 2017 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.
+
+#include <cmath>
+
+#include "base/cxx17_backports.h"
+#include "base/numerics/math_constants.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/quaternion.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+namespace {
+
+const double kEpsilon = 1e-7;
+
+#define EXPECT_QUATERNION(expected, actual)          \
+  do {                                               \
+    EXPECT_NEAR(expected.x(), actual.x(), kEpsilon); \
+    EXPECT_NEAR(expected.y(), actual.y(), kEpsilon); \
+    EXPECT_NEAR(expected.z(), actual.z(), kEpsilon); \
+    EXPECT_NEAR(expected.w(), actual.w(), kEpsilon); \
+  } while (false)
+
+void CompareQuaternions(const Quaternion& a, const Quaternion& b) {
+  EXPECT_FLOAT_EQ(a.x(), b.x());
+  EXPECT_FLOAT_EQ(a.y(), b.y());
+  EXPECT_FLOAT_EQ(a.z(), b.z());
+  EXPECT_FLOAT_EQ(a.w(), b.w());
+}
+
+}  // namespace
+
+TEST(QuatTest, DefaultConstruction) {
+  CompareQuaternions(Quaternion(0, 0, 0, 1), Quaternion());
+}
+
+TEST(QuatTest, AxisAngleCommon) {
+  double radians = 0.5;
+  Quaternion q(Vector3dF(1, 0, 0), radians);
+  CompareQuaternions(
+      Quaternion(std::sin(radians / 2), 0, 0, std::cos(radians / 2)), q);
+}
+
+TEST(QuatTest, VectorToVectorRotation) {
+  Quaternion q(Vector3dF(1.0f, 0.0f, 0.0f), Vector3dF(0.0f, 1.0f, 0.0f));
+  Quaternion r(Vector3dF(0.0f, 0.0f, 1.0f), base::kPiFloat / 2);
+
+  EXPECT_FLOAT_EQ(r.x(), q.x());
+  EXPECT_FLOAT_EQ(r.y(), q.y());
+  EXPECT_FLOAT_EQ(r.z(), q.z());
+  EXPECT_FLOAT_EQ(r.w(), q.w());
+}
+
+TEST(QuatTest, AxisAngleWithZeroLengthAxis) {
+  Quaternion q(Vector3dF(0, 0, 0), 0.5);
+  // If the axis of zero length, we should assume the default values.
+  CompareQuaternions(q, Quaternion());
+}
+
+TEST(QuatTest, Addition) {
+  double values[] = {0, 1, 100};
+  for (size_t i = 0; i < base::size(values); ++i) {
+    float t = values[i];
+    Quaternion a(t, 2 * t, 3 * t, 4 * t);
+    Quaternion b(5 * t, 4 * t, 3 * t, 2 * t);
+    Quaternion sum = a + b;
+    CompareQuaternions(Quaternion(t, t, t, t) * 6, sum);
+  }
+}
+
+TEST(QuatTest, Multiplication) {
+  struct {
+    Quaternion a;
+    Quaternion b;
+    Quaternion expected;
+  } cases[] = {
+      {Quaternion(1, 0, 0, 0), Quaternion(1, 0, 0, 0), Quaternion(0, 0, 0, -1)},
+      {Quaternion(0, 1, 0, 0), Quaternion(0, 1, 0, 0), Quaternion(0, 0, 0, -1)},
+      {Quaternion(0, 0, 1, 0), Quaternion(0, 0, 1, 0), Quaternion(0, 0, 0, -1)},
+      {Quaternion(0, 0, 0, 1), Quaternion(0, 0, 0, 1), Quaternion(0, 0, 0, 1)},
+      {Quaternion(1, 2, 3, 4), Quaternion(5, 6, 7, 8),
+       Quaternion(24, 48, 48, -6)},
+      {Quaternion(5, 6, 7, 8), Quaternion(1, 2, 3, 4),
+       Quaternion(32, 32, 56, -6)},
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    Quaternion product = cases[i].a * cases[i].b;
+    CompareQuaternions(cases[i].expected, product);
+  }
+}
+
+TEST(QuatTest, Scaling) {
+  double values[] = {0, 10, 100};
+  for (size_t i = 0; i < base::size(values); ++i) {
+    double s = values[i];
+    Quaternion q(1, 2, 3, 4);
+    Quaternion expected(s, 2 * s, 3 * s, 4 * s);
+    CompareQuaternions(expected, q * s);
+    CompareQuaternions(expected, s * q);
+    if (s > 0)
+      CompareQuaternions(expected, q / (1 / s));
+  }
+}
+
+TEST(QuatTest, Normalization) {
+  Quaternion q(1, -1, 1, -1);
+  EXPECT_NEAR(q.Length(), 4, kEpsilon);
+
+  q = q.Normalized();
+
+  EXPECT_NEAR(q.Length(), 1, kEpsilon);
+  EXPECT_NEAR(q.x(), 0.5, kEpsilon);
+  EXPECT_NEAR(q.y(), -0.5, kEpsilon);
+  EXPECT_NEAR(q.z(), 0.5, kEpsilon);
+  EXPECT_NEAR(q.w(), -0.5, kEpsilon);
+}
+
+TEST(QuatTest, Lerp) {
+  for (size_t i = 1; i < 100; ++i) {
+    Quaternion a(0, 0, 0, 0);
+    Quaternion b(1, 2, 3, 4);
+    float t = static_cast<float>(i) / 100.0f;
+    Quaternion interpolated = a.Lerp(b, t);
+    double s = 1.0 / sqrt(30.0);
+    CompareQuaternions(Quaternion(1, 2, 3, 4) * s, interpolated);
+  }
+
+  Quaternion a(4, 3, 2, 1);
+  Quaternion b(1, 2, 3, 4);
+  CompareQuaternions(a.Normalized(), a.Lerp(b, 0));
+  CompareQuaternions(b.Normalized(), a.Lerp(b, 1));
+  CompareQuaternions(Quaternion(1, 1, 1, 1).Normalized(), a.Lerp(b, 0.5));
+}
+
+TEST(QuatTest, Slerp) {
+  Vector3dF axis(1, 1, 1);
+  double start_radians = -0.5;
+  double stop_radians = 0.5;
+  Quaternion start(axis, start_radians);
+  Quaternion stop(axis, stop_radians);
+
+  for (size_t i = 0; i < 100; ++i) {
+    float t = static_cast<float>(i) / 100.0f;
+    double radians = (1.0 - t) * start_radians + t * stop_radians;
+    Quaternion expected(axis, radians);
+    Quaternion interpolated = start.Slerp(stop, t);
+    EXPECT_QUATERNION(expected, interpolated);
+  }
+}
+
+TEST(QuatTest, SlerpOppositeAngles) {
+  Vector3dF axis(1, 1, 1);
+  double start_radians = -base::kPiDouble / 2;
+  double stop_radians = base::kPiDouble / 2;
+  Quaternion start(axis, start_radians);
+  Quaternion stop(axis, stop_radians);
+
+  // When quaternions are pointed in the fully opposite direction, this is
+  // ambiguous, so we rotate as per https://www.w3.org/TR/css-transforms-1/
+  Quaternion expected(axis, 0);
+
+  Quaternion interpolated = start.Slerp(stop, 0.5f);
+  EXPECT_QUATERNION(expected, interpolated);
+}
+
+TEST(QuatTest, SlerpRotateXRotateY) {
+  Quaternion start(Vector3dF(1, 0, 0), base::kPiDouble / 2);
+  Quaternion stop(Vector3dF(0, 1, 0), base::kPiDouble / 2);
+  Quaternion interpolated = start.Slerp(stop, 0.5f);
+
+  double expected_angle = std::acos(1.0 / 3.0);
+  double xy = std::sin(0.5 * expected_angle) / std::sqrt(2);
+  Quaternion expected(xy, xy, 0, std::cos(0.5 * expected_angle));
+  EXPECT_QUATERNION(expected, interpolated);
+}
+
+TEST(QuatTest, Slerp360) {
+  Quaternion start(0, 0, 0, -1);  // 360 degree rotation.
+  Quaternion stop(Vector3dF(0, 0, 1), base::kPiDouble / 2);
+  Quaternion interpolated = start.Slerp(stop, 0.5f);
+  double expected_half_angle = base::kPiDouble / 8;
+  Quaternion expected(0, 0, std::sin(expected_half_angle),
+                      std::cos(expected_half_angle));
+  EXPECT_QUATERNION(expected, interpolated);
+}
+
+TEST(QuatTest, SlerpEquivalentQuaternions) {
+  Quaternion start(Vector3dF(1, 0, 0), base::kPiDouble / 3);
+  Quaternion stop = start.flip();
+  Quaternion interpolated = start.Slerp(stop, 0.5f);
+  EXPECT_QUATERNION(start, interpolated);
+}
+
+TEST(QuatTest, SlerpQuaternionWithInverse) {
+  Quaternion start(Vector3dF(1, 0, 0), base::kPiDouble / 3);
+  Quaternion stop = start.inverse();
+  Quaternion interpolated = start.Slerp(stop, 0.5f);
+  Quaternion expected(0, 0, 0, 1);
+  EXPECT_QUATERNION(expected, interpolated);
+}
+
+TEST(QuatTest, SlerpObtuseAngle) {
+  Quaternion start(Vector3dF(1, 1, 0), base::kPiDouble / 2);
+  Quaternion stop(Vector3dF(0, 1, -1), 3 * base::kPiDouble / 2);
+  Quaternion interpolated = start.Slerp(stop, 0.5f);
+  double expected_half_angle = -std::atan(0.5);
+  double xz = std::sin(expected_half_angle) / std::sqrt(2);
+  Quaternion expected(xz, 0, xz, -std::cos(expected_half_angle));
+  EXPECT_QUATERNION(expected, interpolated);
+}
+
+TEST(QuatTest, Equals) {
+  EXPECT_TRUE(Quaternion() == Quaternion());
+  EXPECT_TRUE(Quaternion() == Quaternion(0, 0, 0, 1));
+  EXPECT_TRUE(Quaternion(1, 5.2, -8.5, 222.2) ==
+              Quaternion(1, 5.2, -8.5, 222.2));
+  EXPECT_FALSE(Quaternion() == Quaternion(1, 0, 0, 0));
+  EXPECT_FALSE(Quaternion() == Quaternion(0, 1, 0, 0));
+  EXPECT_FALSE(Quaternion() == Quaternion(0, 0, 1, 0));
+  EXPECT_FALSE(Quaternion() == Quaternion(1, 0, 0, 1));
+}
+
+TEST(QuatTest, NotEquals) {
+  EXPECT_FALSE(Quaternion() != Quaternion());
+  EXPECT_FALSE(Quaternion(1, 5.2, -8.5, 222.2) !=
+               Quaternion(1, 5.2, -8.5, 222.2));
+  EXPECT_TRUE(Quaternion() != Quaternion(1, 0, 0, 0));
+  EXPECT_TRUE(Quaternion() != Quaternion(0, 1, 0, 0));
+  EXPECT_TRUE(Quaternion() != Quaternion(0, 0, 1, 0));
+  EXPECT_TRUE(Quaternion() != Quaternion(1, 0, 0, 1));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rect.cc b/ui/gfx/geometry/rect.cc
new file mode 100644
index 0000000..02b7156
--- /dev/null
+++ b/ui/gfx/geometry/rect.cc
@@ -0,0 +1,348 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/rect.h"
+
+#include <algorithm>
+
+#if defined(OS_WIN)
+#include <windows.h>
+#elif defined(OS_IOS)
+#include <CoreGraphics/CoreGraphics.h>
+#elif defined(OS_MAC)
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+
+#include "base/check.h"
+#include "base/numerics/clamped_math.h"
+#include "base/strings/stringprintf.h"
+#include "build/build_config.h"
+#include "ui/gfx/geometry/insets.h"
+
+namespace gfx {
+
+#if defined(OS_WIN)
+Rect::Rect(const RECT& r)
+    : origin_(r.left, r.top),
+      size_(std::abs(r.right - r.left), std::abs(r.bottom - r.top)) {
+}
+#elif defined(OS_APPLE)
+Rect::Rect(const CGRect& r)
+    : origin_(r.origin.x, r.origin.y), size_(r.size.width, r.size.height) {
+}
+#endif
+
+#if defined(OS_WIN)
+RECT Rect::ToRECT() const {
+  RECT r;
+  r.left = x();
+  r.right = right();
+  r.top = y();
+  r.bottom = bottom();
+  return r;
+}
+#elif defined(OS_APPLE)
+CGRect Rect::ToCGRect() const {
+  return CGRectMake(x(), y(), width(), height());
+}
+#endif
+
+void AdjustAlongAxis(int dst_origin, int dst_size, int* origin, int* size) {
+  *size = std::min(dst_size, *size);
+  if (*origin < dst_origin)
+    *origin = dst_origin;
+  else
+    *origin = std::min(dst_origin + dst_size, *origin + *size) - *size;
+}
+
+}  // namespace
+
+namespace gfx {
+
+// This is the per-axis heuristic for picking the most useful origin and
+// width/height to represent the input range.
+static void SaturatedClampRange(int min, int max, int* origin, int* span) {
+  if (max < min) {
+    *span = 0;
+    *origin = min;
+    return;
+  }
+
+  int effective_span = base::ClampSub(max, min);
+  int span_loss = base::ClampSub(max, min + effective_span);
+
+  // If the desired width is within the limits of ints, we can just
+  // use the simple computations to represent the range precisely.
+  if (span_loss == 0) {
+    *span = effective_span;
+    *origin = min;
+    return;
+  }
+
+  // Now we have to approximate. If one of min or max is close enough
+  // to zero we choose to represent that one precisely. The other side is
+  // probably practically "infinite", so we move it.
+  constexpr unsigned kMaxDimension = std::numeric_limits<int>::max() / 2;
+  if (base::SafeUnsignedAbs(max) < kMaxDimension) {
+    // Maintain origin + span == max.
+    *span = effective_span;
+    *origin = max - effective_span;
+  } else if (base::SafeUnsignedAbs(min) < kMaxDimension) {
+    // Maintain origin == min.
+    *span = effective_span;
+    *origin = min;
+  } else {
+    // Both are big, so keep the center.
+    *span = effective_span;
+    *origin = min + span_loss / 2;
+  }
+}
+
+void Rect::SetByBounds(int left, int top, int right, int bottom) {
+  int x, y;
+  int width, height;
+  SaturatedClampRange(left, right, &x, &width);
+  SaturatedClampRange(top, bottom, &y, &height);
+  origin_.SetPoint(x, y);
+  size_.SetSize(width, height);
+}
+
+void Rect::Inset(const Insets& insets) {
+  Inset(insets.left(), insets.top(), insets.right(), insets.bottom());
+}
+
+void Rect::Inset(int left, int top, int right, int bottom) {
+  origin_ += Vector2d(left, top);
+  // left+right might overflow/underflow, but width() - (left+right) might
+  // overflow as well.
+  set_width(base::ClampSub(width(), base::ClampAdd(left, right)));
+  set_height(base::ClampSub(height(), base::ClampAdd(top, bottom)));
+}
+
+void Rect::Offset(const Vector2d& distance) {
+  origin_ += distance;
+  // Ensure that width and height remain valid.
+  set_width(width());
+  set_height(height());
+}
+
+void Rect::operator+=(const Vector2d& offset) {
+  origin_ += offset;
+  // Ensure that width and height remain valid.
+  set_width(width());
+  set_height(height());
+}
+
+void Rect::operator-=(const Vector2d& offset) {
+  origin_ -= offset;
+}
+
+Insets Rect::InsetsFrom(const Rect& inner) const {
+  return Insets(inner.y() - y(),
+                inner.x() - x(),
+                bottom() - inner.bottom(),
+                right() - inner.right());
+}
+
+bool Rect::operator<(const Rect& other) const {
+  if (origin_ == other.origin_) {
+    if (width() == other.width()) {
+      return height() < other.height();
+    } else {
+      return width() < other.width();
+    }
+  } else {
+    return origin_ < other.origin_;
+  }
+}
+
+bool Rect::Contains(int point_x, int point_y) const {
+  return (point_x >= x()) && (point_x < right()) && (point_y >= y()) &&
+         (point_y < bottom());
+}
+
+bool Rect::Contains(const Rect& rect) const {
+  return (rect.x() >= x() && rect.right() <= right() && rect.y() >= y() &&
+          rect.bottom() <= bottom());
+}
+
+bool Rect::Intersects(const Rect& rect) const {
+  return !(IsEmpty() || rect.IsEmpty() || rect.x() >= right() ||
+           rect.right() <= x() || rect.y() >= bottom() || rect.bottom() <= y());
+}
+
+void Rect::Intersect(const Rect& rect) {
+  if (IsEmpty() || rect.IsEmpty()) {
+    SetRect(0, 0, 0, 0);  // Throws away empty position.
+    return;
+  }
+
+  int left = std::max(x(), rect.x());
+  int top = std::max(y(), rect.y());
+  int new_right = std::min(right(), rect.right());
+  int new_bottom = std::min(bottom(), rect.bottom());
+
+  if (left >= new_right || top >= new_bottom) {
+    SetRect(0, 0, 0, 0);  // Throws away empty position.
+    return;
+  }
+
+  SetByBounds(left, top, new_right, new_bottom);
+}
+
+void Rect::Union(const Rect& rect) {
+  if (IsEmpty()) {
+    *this = rect;
+    return;
+  }
+  if (rect.IsEmpty())
+    return;
+
+  SetByBounds(std::min(x(), rect.x()), std::min(y(), rect.y()),
+              std::max(right(), rect.right()),
+              std::max(bottom(), rect.bottom()));
+}
+
+void Rect::Subtract(const Rect& rect) {
+  if (!Intersects(rect))
+    return;
+  if (rect.Contains(*this)) {
+    SetRect(0, 0, 0, 0);
+    return;
+  }
+
+  int rx = x();
+  int ry = y();
+  int rr = right();
+  int rb = bottom();
+
+  if (rect.y() <= y() && rect.bottom() >= bottom()) {
+    // complete intersection in the y-direction
+    if (rect.x() <= x()) {
+      rx = rect.right();
+    } else if (rect.right() >= right()) {
+      rr = rect.x();
+    }
+  } else if (rect.x() <= x() && rect.right() >= right()) {
+    // complete intersection in the x-direction
+    if (rect.y() <= y()) {
+      ry = rect.bottom();
+    } else if (rect.bottom() >= bottom()) {
+      rb = rect.y();
+    }
+  }
+  SetByBounds(rx, ry, rr, rb);
+}
+
+void Rect::AdjustToFit(const Rect& rect) {
+  int new_x = x();
+  int new_y = y();
+  int new_width = width();
+  int new_height = height();
+  AdjustAlongAxis(rect.x(), rect.width(), &new_x, &new_width);
+  AdjustAlongAxis(rect.y(), rect.height(), &new_y, &new_height);
+  SetRect(new_x, new_y, new_width, new_height);
+}
+
+Point Rect::CenterPoint() const {
+  return Point(x() + width() / 2, y() + height() / 2);
+}
+
+void Rect::ClampToCenteredSize(const Size& size) {
+  int new_width = std::min(width(), size.width());
+  int new_height = std::min(height(), size.height());
+  int new_x = x() + (width() - new_width) / 2;
+  int new_y = y() + (height() - new_height) / 2;
+  SetRect(new_x, new_y, new_width, new_height);
+}
+
+void Rect::Transpose() {
+  SetRect(y(), x(), height(), width());
+}
+
+void Rect::SplitVertically(Rect* left_half, Rect* right_half) const {
+  DCHECK(left_half);
+  DCHECK(right_half);
+
+  left_half->SetRect(x(), y(), width() / 2, height());
+  right_half->SetRect(
+      left_half->right(), y(), width() - left_half->width(), height());
+}
+
+bool Rect::SharesEdgeWith(const Rect& rect) const {
+  return (y() == rect.y() && height() == rect.height() &&
+          (x() == rect.right() || right() == rect.x())) ||
+         (x() == rect.x() && width() == rect.width() &&
+          (y() == rect.bottom() || bottom() == rect.y()));
+}
+
+int Rect::ManhattanDistanceToPoint(const Point& point) const {
+  int x_distance =
+      std::max<int>(0, std::max(x() - point.x(), point.x() - right()));
+  int y_distance =
+      std::max<int>(0, std::max(y() - point.y(), point.y() - bottom()));
+
+  return x_distance + y_distance;
+}
+
+int Rect::ManhattanInternalDistance(const Rect& rect) const {
+  Rect c(*this);
+  c.Union(rect);
+
+  int x = std::max(0, c.width() - width() - rect.width() + 1);
+  int y = std::max(0, c.height() - height() - rect.height() + 1);
+  return x + y;
+}
+
+std::string Rect::ToString() const {
+  return base::StringPrintf("%s %s",
+                            origin().ToString().c_str(),
+                            size().ToString().c_str());
+}
+
+bool Rect::ApproximatelyEqual(const Rect& rect, int tolerance) const {
+  return std::abs(x() - rect.x()) <= tolerance &&
+         std::abs(y() - rect.y()) <= tolerance &&
+         std::abs(right() - rect.right()) <= tolerance &&
+         std::abs(bottom() - rect.bottom()) <= tolerance;
+}
+
+Rect operator+(const Rect& lhs, const Vector2d& rhs) {
+  Rect result(lhs);
+  result += rhs;
+  return result;
+}
+
+Rect operator-(const Rect& lhs, const Vector2d& rhs) {
+  Rect result(lhs);
+  result -= rhs;
+  return result;
+}
+
+Rect IntersectRects(const Rect& a, const Rect& b) {
+  Rect result = a;
+  result.Intersect(b);
+  return result;
+}
+
+Rect UnionRects(const Rect& a, const Rect& b) {
+  Rect result = a;
+  result.Union(b);
+  return result;
+}
+
+Rect SubtractRects(const Rect& a, const Rect& b) {
+  Rect result = a;
+  result.Subtract(b);
+  return result;
+}
+
+Rect BoundingRect(const Point& p1, const Point& p2) {
+  Rect result;
+  result.SetByBounds(std::min(p1.x(), p2.x()), std::min(p1.y(), p2.y()),
+                     std::max(p1.x(), p2.x()), std::max(p1.y(), p2.y()));
+  return result;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rect.h b/ui/gfx/geometry/rect.h
new file mode 100644
index 0000000..c980174
--- /dev/null
+++ b/ui/gfx/geometry/rect.h
@@ -0,0 +1,122 @@
+// Copyright (c) 2012 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.
+
+// Defines a simple integer rectangle class.  The containment semantics
+// are array-like; that is, the coordinate (x, y) is considered to be
+// contained by the rectangle, but the coordinate (x + width, y) is not.
+// The class will happily let you create malformed rectangles (that is,
+// rectangles with negative width and/or height), but there will be assertions
+// in the operations (such as Contains()) to complain in this case.
+
+#ifndef UI_GFX_GEOMETRY_RECT_H_
+#define UI_GFX_GEOMETRY_RECT_H_
+
+#include <cmath>
+#include <iosfwd>
+#include <string>
+
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect_base.h"
+#include "ui/gfx/geometry/rect_base_impl.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/vector2d.h"
+
+namespace gfx {
+
+class Insets;
+
+class Rect : public RectBase<Rect, Point, Size, Insets, Vector2d, int> {
+ public:
+  Rect() : RectBase<Rect, Point, Size, Insets, Vector2d, int>(Point()) {}
+
+  Rect(int width, int height)
+      : RectBase<Rect, Point, Size, Insets, Vector2d, int>(
+            Size(width, height)) {}
+
+  Rect(int x, int y, int width, int height)
+      : RectBase<Rect, Point, Size, Insets, Vector2d, int>(
+            Point(x, y), Size(width, height)) {}
+
+  explicit Rect(const Size& size)
+      : RectBase<Rect, Point, Size, Insets, Vector2d, int>(size) {}
+
+  Rect(const Point& origin, const Size& size)
+      : RectBase<Rect, Point, Size, Insets, Vector2d, int>(origin, size) {}
+
+  ~Rect() {}
+
+  std::string ToString() const;
+};
+
+inline bool operator==(const Rect& lhs, const Rect& rhs) {
+  return lhs.origin() == rhs.origin() && lhs.size() == rhs.size();
+}
+
+inline bool operator!=(const Rect& lhs, const Rect& rhs) {
+  return !(lhs == rhs);
+}
+
+Rect operator+(const Rect& lhs, const Vector2d& rhs);
+Rect operator-(const Rect& lhs, const Vector2d& rhs);
+
+inline std::ostream& operator<<(std::ostream& os, const Rect& rect) {
+  os << rect.ToString();
+  return os;
+}
+
+inline Rect operator+(const Vector2d& lhs, const Rect& rhs) {
+  return rhs + lhs;
+}
+
+Rect IntersectRects(const Rect& a, const Rect& b);
+Rect UnionRects(const Rect& a, const Rect& b);
+Rect SubtractRects(const Rect& a, const Rect& b);
+
+// Constructs a rectangle with |p1| and |p2| as opposite corners.
+//
+// This could also be thought of as "the smallest rect that contains both
+// points", except that we consider points on the right/bottom edges of the
+// rect to be outside the rect.  So technically one or both points will not be
+// contained within the rect, because they will appear on one of these edges.
+Rect BoundingRect(const Point& p1, const Point& p2);
+
+inline Rect ScaleToEnclosingRect(const Rect& rect, float x_scale,
+                                 float y_scale) {
+  int x = static_cast<int>(std::floor(rect.x() * x_scale));
+  int y = static_cast<int>(std::floor(rect.y() * y_scale));
+  int r = rect.width() == 0
+              ? x
+              : static_cast<int>(std::ceil(rect.right() * x_scale));
+  int b = rect.height() == 0
+              ? y
+              : static_cast<int>(std::ceil(rect.bottom() * y_scale));
+  return Rect(x, y, r - x, b - y);
+}
+
+inline Rect ScaleToEnclosingRect(const Rect& rect, float scale) {
+  return ScaleToEnclosingRect(rect, scale, scale);
+}
+
+inline Rect ScaleToEnclosedRect(const Rect& rect, float x_scale,
+                                float y_scale) {
+  int x = static_cast<int>(std::ceil(rect.x() * x_scale));
+  int y = static_cast<int>(std::ceil(rect.y() * y_scale));
+  int r = rect.width() == 0
+              ? x
+              : static_cast<int>(std::floor(rect.right() * x_scale));
+  int b = rect.height() == 0
+              ? y
+              : static_cast<int>(std::floor(rect.bottom() * y_scale));
+  return Rect(x, y, r - x, b - y);
+}
+
+inline Rect ScaleToEnclosedRect(const Rect& rect, float scale) {
+  return ScaleToEnclosedRect(rect, scale, scale);
+}
+
+// extern template class RectBase<Rect, Point, Size, Insets, Vector2d, int>;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_RECT_H_
diff --git a/ui/gfx/geometry/rect_base.h b/ui/gfx/geometry/rect_base.h
new file mode 100644
index 0000000..0cec1ea
--- /dev/null
+++ b/ui/gfx/geometry/rect_base.h
@@ -0,0 +1,173 @@
+// Copyright (c) 2012 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.
+
+// A template for a simple rectangle class.  The containment semantics
+// are array-like; that is, the coordinate (x, y) is considered to be
+// contained by the rectangle, but the coordinate (x + width, y) is not.
+// The class will happily let you create malformed rectangles (that is,
+// rectangles with negative width and/or height), but there will be assertions
+// in the operations (such as Contains()) to complain in this case.
+
+#ifndef UI_GFX_GEOMETRY_RECT_BASE_H_
+#define UI_GFX_GEOMETRY_RECT_BASE_H_
+
+#include <string>
+
+namespace gfx {
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+class RectBase {
+ public:
+  Type x() const { return origin_.x(); }
+  void set_x(Type x) { origin_.set_x(x); }
+
+  Type y() const { return origin_.y(); }
+  void set_y(Type y) { origin_.set_y(y); }
+
+  Type width() const { return size_.width(); }
+  void set_width(Type width) { size_.set_width(width); }
+
+  Type height() const { return size_.height(); }
+  void set_height(Type height) { size_.set_height(height); }
+
+  const PointClass& origin() const { return origin_; }
+  void set_origin(const PointClass& origin) { origin_ = origin; }
+
+  const SizeClass& size() const { return size_; }
+  void set_size(const SizeClass& size) { size_ = size; }
+
+  Type right() const { return x() + width(); }
+  Type bottom() const { return y() + height(); }
+
+  PointClass top_right() const { return PointClass(right(), y()); }
+  PointClass bottom_left() const { return PointClass(x(), bottom()); }
+  PointClass bottom_right() const { return PointClass(right(), bottom()); }
+
+  VectorClass OffsetFromOrigin() const { return VectorClass(x(), y()); }
+
+  void SetRect(Type x, Type y, Type width, Type height);
+
+  // Shrink the rectangle by a horizontal and vertical distance on all sides.
+  void Inset(Type horizontal, Type vertical) {
+    Inset(horizontal, vertical, horizontal, vertical);
+  }
+
+  // Enlarge the rectangle by a horizontal and vertical distance on all sides.
+  void Outset(Type horizontal, Type vertical) { Inset(-horizontal, -vertical); }
+
+  // Shrink the rectangle by the given insets.
+  void Inset(const InsetsClass& insets);
+
+  // Enlarge the rectangle by the given insets.
+  void Outset(const InsetsClass& insets) { Inset(-insets); }
+
+  // Shrink the rectangle by the specified amount on each side.
+  void Inset(Type left, Type top, Type right, Type bottom);
+
+  // Enlarge the rectangle by the specified amount on each side.
+  void Outset(Type left, Type top, Type right, Type bottom) {
+    Inset(-left, -top, -right, -bottom);
+  }
+
+  // Move the rectangle by a horizontal and vertical distance.
+  void Offset(Type horizontal, Type vertical);
+  void Offset(const VectorClass& distance) {
+    Offset(distance.x(), distance.y());
+  }
+  void operator+=(const VectorClass& offset);
+  void operator-=(const VectorClass& offset);
+
+  InsetsClass InsetsFrom(const Class& inner) const {
+    return InsetsClass(inner.x() - x(), inner.y() - y(),
+                       right() - inner.right(), bottom() - inner.bottom());
+  }
+
+  // Returns true if the area of the rectangle is zero.
+  bool IsEmpty() const { return size_.IsEmpty(); }
+
+  // A rect is less than another rect if its origin is less than
+  // the other rect's origin. If the origins are equal, then the
+  // shortest rect is less than the other. If the origin and the
+  // height are equal, then the narrowest rect is less than.
+  // This comparison is required to use Rects in sets, or sorted
+  // vectors.
+  bool operator<(const Class& other) const;
+
+  // Returns true if the point identified by point_x and point_y falls inside
+  // this rectangle.  The point (x, y) is inside the rectangle, but the
+  // point (x + width, y + height) is not.
+  bool Contains(Type point_x, Type point_y) const;
+
+  // Returns true if the specified point is contained by this rectangle.
+  bool Contains(const PointClass& point) const {
+    return Contains(point.x(), point.y());
+  }
+
+  // Returns true if this rectangle contains the specified rectangle.
+  bool Contains(const Class& rect) const;
+
+  // Returns true if this rectangle intersects the specified rectangle.
+  // An empty rectangle doesn't intersect any rectangle.
+  bool Intersects(const Class& rect) const;
+
+  // Computes the intersection of this rectangle with the given rectangle.
+  void Intersect(const Class& rect);
+
+  // Computes the union of this rectangle with the given rectangle.  The union
+  // is the smallest rectangle containing both rectangles.
+  void Union(const Class& rect);
+
+  // Computes the rectangle resulting from subtracting |rect| from |*this|,
+  // i.e. the bounding rect of |Region(*this) - Region(rect)|.
+  void Subtract(const Class& rect);
+
+  // Fits as much of the receiving rectangle into the supplied rectangle as
+  // possible, becoming the result. For example, if the receiver had
+  // a x-location of 2 and a width of 4, and the supplied rectangle had
+  // an x-location of 0 with a width of 5, the returned rectangle would have
+  // an x-location of 1 with a width of 4.
+  void AdjustToFit(const Class& rect);
+
+  // Returns the center of this rectangle.
+  PointClass CenterPoint() const;
+
+  // Becomes a rectangle that has the same center point but with a size capped
+  // at given |size|.
+  void ClampToCenteredSize(const SizeClass& size);
+
+  // Splits |this| in two halves, |left_half| and |right_half|.
+  void SplitVertically(Class* left_half, Class* right_half) const;
+
+  // Returns true if this rectangle shares an entire edge (i.e., same width or
+  // same height) with the given rectangle, and the rectangles do not overlap.
+  bool SharesEdgeWith(const Class& rect) const;
+
+  // Returns the manhattan distance from the rect to the point. If the point is
+  // inside the rect, returns 0.
+  Type ManhattanDistanceToPoint(const PointClass& point) const;
+
+  // Returns the manhattan distance between the contents of this rect and the
+  // contents of the given rect. That is, if the intersection of the two rects
+  // is non-empty then the function returns 0. If the rects share a side, it
+  // returns the smallest non-zero value appropriate for Type.
+  Type ManhattanInternalDistance(const Class& rect) const;
+
+ protected:
+  RectBase(const PointClass& origin, const SizeClass& size)
+      : origin_(origin), size_(size) {}
+  explicit RectBase(const SizeClass& size) : size_(size) {}
+  explicit RectBase(const PointClass& origin) : origin_(origin) {}
+  // Destructor is intentionally made non virtual and protected.
+  // Do not make this public.
+  ~RectBase() {}
+
+ private:
+  PointClass origin_;
+  SizeClass size_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_RECT_BASE_H_
diff --git a/ui/gfx/geometry/rect_base_impl.h b/ui/gfx/geometry/rect_base_impl.h
new file mode 100644
index 0000000..09ee7f3
--- /dev/null
+++ b/ui/gfx/geometry/rect_base_impl.h
@@ -0,0 +1,267 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_RECT_BASE_IMPL_H_
+#define UI_GFX_GEOMETRY_RECT_BASE_IMPL_H_
+
+#include <algorithm>
+#include <limits>
+
+#include "base/logging.h"
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/geometry/rect_base.h"
+
+namespace gfx {
+
+template <typename Type>
+void AdjustAlongAxis(Type dst_origin, Type dst_size, Type* origin, Type* size) {
+  *size = std::min(dst_size, *size);
+  if (*origin < dst_origin)
+    *origin = dst_origin;
+  else
+    *origin = std::min(dst_origin + dst_size, *origin + *size) - *size;
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::SetRect(Type x, Type y, Type width, Type height) {
+  origin_.SetPoint(x, y);
+  set_width(width);
+  set_height(height);
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Inset(const InsetsClass& insets) {
+  Inset(insets.left(), insets.top(), insets.right(), insets.bottom());
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Inset(Type left, Type top, Type right, Type bottom) {
+  origin_ += VectorClass(left, top);
+  set_width(std::max(width() - left - right, static_cast<Type>(0)));
+  set_height(std::max(height() - top - bottom, static_cast<Type>(0)));
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Offset(Type horizontal, Type vertical) {
+  origin_ += VectorClass(horizontal, vertical);
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>::
+operator+=(const VectorClass& offset) {
+  origin_ += offset;
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>::
+operator-=(const VectorClass& offset) {
+  origin_ -= offset;
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>::
+operator<(const Class& other) const {
+  if (origin_ == other.origin_) {
+    if (width() == other.width()) {
+      return height() < other.height();
+    } else {
+      return width() < other.width();
+    }
+  } else {
+    return origin_ < other.origin_;
+  }
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Contains(Type point_x, Type point_y) const {
+  return (point_x >= x()) && (point_x < right()) && (point_y >= y()) &&
+         (point_y < bottom());
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Contains(const Class& rect) const {
+  return (rect.x() >= x() && rect.right() <= right() && rect.y() >= y() &&
+          rect.bottom() <= bottom());
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Intersects(const Class& rect) const {
+  return !(IsEmpty() || rect.IsEmpty() || rect.x() >= right() ||
+           rect.right() <= x() || rect.y() >= bottom() || rect.bottom() <= y());
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Intersect(const Class& rect) {
+  if (IsEmpty() || rect.IsEmpty()) {
+    SetRect(Type(0), Type(0), Type(0), Type(0));
+    return;
+  }
+
+  Type rx = std::max(x(), rect.x());
+  Type ry = std::max(y(), rect.y());
+  Type rr = std::min(right(), rect.right());
+  Type rb = std::min(bottom(), rect.bottom());
+
+  if (rx >= rr || ry >= rb) rx = ry = rr = rb = Type(0);  // non-intersecting
+
+  SetRect(rx, ry, rr - rx, rb - ry);
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Union(const Class& rect) {
+  if (IsEmpty()) {
+    *this = rect;
+    return;
+  }
+  if (rect.IsEmpty()) return;
+
+  Type rx = std::min(x(), rect.x());
+  Type ry = std::min(y(), rect.y());
+  Type rr = std::max(right(), rect.right());
+  Type rb = std::max(bottom(), rect.bottom());
+
+  SetRect(rx, ry, rr - rx, rb - ry);
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::Subtract(const Class& rect) {
+  if (!Intersects(rect)) return;
+  if (rect.Contains(*static_cast<const Class*>(this))) {
+    SetRect(Type(0), Type(0), Type(0), Type(0));
+    return;
+  }
+
+  Type rx = x();
+  Type ry = y();
+  Type rr = right();
+  Type rb = bottom();
+
+  if (rect.y() <= y() && rect.bottom() >= bottom()) {
+    // complete intersection in the y-direction
+    if (rect.x() <= x()) {
+      rx = rect.right();
+    } else if (rect.right() >= right()) {
+      rr = rect.x();
+    }
+  } else if (rect.x() <= x() && rect.right() >= right()) {
+    // complete intersection in the x-direction
+    if (rect.y() <= y()) {
+      ry = rect.bottom();
+    } else if (rect.bottom() >= bottom()) {
+      rb = rect.y();
+    }
+  }
+  SetRect(rx, ry, rr - rx, rb - ry);
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::AdjustToFit(const Class& rect) {
+  Type new_x = x();
+  Type new_y = y();
+  Type new_width = width();
+  Type new_height = height();
+  AdjustAlongAxis(rect.x(), rect.width(), &new_x, &new_width);
+  AdjustAlongAxis(rect.y(), rect.height(), &new_y, &new_height);
+  SetRect(new_x, new_y, new_width, new_height);
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+PointClass RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+                    Type>::CenterPoint() const {
+  return PointClass(x() + width() / 2, y() + height() / 2);
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::ClampToCenteredSize(const SizeClass& size) {
+  Type new_width = std::min(width(), size.width());
+  Type new_height = std::min(height(), size.height());
+  Type new_x = x() + (width() - new_width) / 2;
+  Type new_y = y() + (height() - new_height) / 2;
+  SetRect(new_x, new_y, new_width, new_height);
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::SplitVertically(Class* left_half,
+                                     Class* right_half) const {
+  DCHECK(left_half);
+  DCHECK(right_half);
+
+  left_half->SetRect(x(), y(), width() / 2, height());
+  right_half->SetRect(left_half->right(), y(), width() - left_half->width(),
+                      height());
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::SharesEdgeWith(const Class& rect) const {
+  return (y() == rect.y() && height() == rect.height() &&
+          (x() == rect.right() || right() == rect.x())) ||
+         (x() == rect.x() && width() == rect.width() &&
+          (y() == rect.bottom() || bottom() == rect.y()));
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+Type RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::ManhattanDistanceToPoint(const PointClass& point) const {
+  Type x_distance =
+      std::max<Type>(Type(0), std::max(x() - point.x(), point.x() - right()));
+  Type y_distance =
+      std::max<Type>(Type(0), std::max(y() - point.y(), point.y() - bottom()));
+
+  return x_distance + y_distance;
+}
+
+template <typename Class, typename PointClass, typename SizeClass,
+          typename InsetsClass, typename VectorClass, typename Type>
+Type RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass,
+              Type>::ManhattanInternalDistance(const Class& rect) const {
+  Class c(x(), y(), width(), height());
+  c.Union(rect);
+
+  const Type kEpsilon = std::numeric_limits<Type>::is_integer
+                                   ? Type(1)
+                                   : std::numeric_limits<Type>::epsilon();
+
+  Type x =
+      std::max<Type>(Type(0), c.width() - width() - rect.width() + kEpsilon);
+  Type y =
+      std::max<Type>(Type(0), c.height() - height() - rect.height() + kEpsilon);
+  return x + y;
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_RECT_BASE_IMPL_H_
diff --git a/ui/gfx/geometry/rect_conversions.cc b/ui/gfx/geometry/rect_conversions.cc
new file mode 100644
index 0000000..212318b
--- /dev/null
+++ b/ui/gfx/geometry/rect_conversions.cc
@@ -0,0 +1,126 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/rect_conversions.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "base/check.h"
+#include "base/numerics/safe_conversions.h"
+
+namespace gfx {
+
+namespace {
+
+int FloorIgnoringError(float f, float error) {
+  int rounded = base::ClampRound(f);
+  return std::abs(rounded - f) < error ? rounded : base::ClampFloor(f);
+}
+
+int CeilIgnoringError(float f, float error) {
+  int rounded = base::ClampRound(f);
+  return std::abs(rounded - f) < error ? rounded : base::ClampCeil(f);
+}
+
+}  // anonymous namespace
+
+Rect ToEnclosingRect(const RectF& r) {
+  int left = base::ClampFloor(r.x());
+  int right = r.width() ? base::ClampCeil(r.right()) : left;
+  int top = base::ClampFloor(r.y());
+  int bottom = r.height() ? base::ClampCeil(r.bottom()) : top;
+
+  Rect result;
+  result.SetByBounds(left, top, right, bottom);
+  return result;
+}
+
+Rect ToEnclosingRectIgnoringError(const RectF& r, float error) {
+  int left = FloorIgnoringError(r.x(), error);
+  int right = r.width() ? CeilIgnoringError(r.right(), error) : left;
+  int top = FloorIgnoringError(r.y(), error);
+  int bottom = r.height() ? CeilIgnoringError(r.bottom(), error) : top;
+
+  Rect result;
+  result.SetByBounds(left, top, right, bottom);
+  return result;
+}
+
+Rect ToEnclosedRect(const RectF& rect) {
+  Rect result;
+  result.SetByBounds(base::ClampCeil(rect.x()), base::ClampCeil(rect.y()),
+                     base::ClampFloor(rect.right()),
+                     base::ClampFloor(rect.bottom()));
+  return result;
+}
+
+Rect ToEnclosedRectIgnoringError(const RectF& r, float error) {
+  int left = CeilIgnoringError(r.x(), error);
+  int right = r.width() ? FloorIgnoringError(r.right(), error) : left;
+  int top = CeilIgnoringError(r.y(), error);
+  int bottom = r.height() ? FloorIgnoringError(r.bottom(), error) : top;
+
+  Rect result;
+  result.SetByBounds(left, top, right, bottom);
+  return result;
+}
+
+Rect ToNearestRect(const RectF& rect) {
+  float float_min_x = rect.x();
+  float float_min_y = rect.y();
+  float float_max_x = rect.right();
+  float float_max_y = rect.bottom();
+
+  int min_x = base::ClampRound(float_min_x);
+  int min_y = base::ClampRound(float_min_y);
+  int max_x = base::ClampRound(float_max_x);
+  int max_y = base::ClampRound(float_max_y);
+
+  // If these DCHECKs fail, you're using the wrong method, consider using
+  // ToEnclosingRect or ToEnclosedRect instead.
+  DCHECK(std::abs(min_x - float_min_x) < 0.01f);
+  DCHECK(std::abs(min_y - float_min_y) < 0.01f);
+  DCHECK(std::abs(max_x - float_max_x) < 0.01f);
+  DCHECK(std::abs(max_y - float_max_y) < 0.01f);
+
+  Rect result;
+  result.SetByBounds(min_x, min_y, max_x, max_y);
+
+  return result;
+}
+
+bool IsNearestRectWithinDistance(const gfx::RectF& rect, float distance) {
+  float float_min_x = rect.x();
+  float float_min_y = rect.y();
+  float float_max_x = rect.right();
+  float float_max_y = rect.bottom();
+
+  int min_x = base::ClampRound(float_min_x);
+  int min_y = base::ClampRound(float_min_y);
+  int max_x = base::ClampRound(float_max_x);
+  int max_y = base::ClampRound(float_max_y);
+
+  return (std::abs(min_x - float_min_x) < distance) &&
+         (std::abs(min_y - float_min_y) < distance) &&
+         (std::abs(max_x - float_max_x) < distance) &&
+         (std::abs(max_y - float_max_y) < distance);
+}
+
+gfx::Rect ToRoundedRect(const gfx::RectF& rect) {
+  int left = base::ClampRound(rect.x());
+  int top = base::ClampRound(rect.y());
+  int right = base::ClampRound(rect.right());
+  int bottom = base::ClampRound(rect.bottom());
+  gfx::Rect result;
+  result.SetByBounds(left, top, right, bottom);
+  return result;
+}
+
+Rect ToFlooredRectDeprecated(const RectF& rect) {
+  return Rect(base::ClampFloor(rect.x()), base::ClampFloor(rect.y()),
+              base::ClampFloor(rect.width()), base::ClampFloor(rect.height()));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rect_conversions.h b/ui/gfx/geometry/rect_conversions.h
new file mode 100644
index 0000000..3460dcc
--- /dev/null
+++ b/ui/gfx/geometry/rect_conversions.h
@@ -0,0 +1,55 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_RECT_CONVERSIONS_H_
+#define UI_GFX_GEOMETRY_RECT_CONVERSIONS_H_
+
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace gfx {
+
+// Returns the smallest Rect that encloses the given RectF.
+GEOMETRY_EXPORT Rect ToEnclosingRect(const RectF& rect);
+
+// Similar to ToEnclosingRect(), but for each edge, if the distance between the
+// edge and the nearest integer grid is smaller than |error|, the edge is
+// snapped to the integer grid. Unlike ToNearestRect() which only accepts
+// integer rect with or without floating point error, this function also accepts
+// non-integer rect.
+GEOMETRY_EXPORT Rect ToEnclosingRectIgnoringError(const RectF& rect,
+                                                  float error);
+
+// Returns the largest Rect that is enclosed by the given RectF.
+GEOMETRY_EXPORT Rect ToEnclosedRect(const RectF& rect);
+
+// Similar to ToEnclosedRect(), but for each edge, if the distance between the
+// edge and the nearest integer grid is smaller than |error|, the edge is
+// snapped to the integer grid. Unlike ToNearestRect() which only accepts
+// integer rect with or without floating point error, this function also accepts
+// non-integer rect.
+GEOMETRY_EXPORT Rect ToEnclosedRectIgnoringError(const RectF& rect,
+                                                 float error);
+
+// Returns the Rect after snapping the corners of the RectF to an integer grid.
+// This should only be used when the RectF you provide is expected to be an
+// integer rect with floating point error. If it is an arbitrary RectF, then
+// you should use a different method.
+GEOMETRY_EXPORT Rect ToNearestRect(const RectF& rect);
+
+// Returns true if the Rect produced after snapping the corners of the RectF
+// to an integer grid is withing |distance|.
+GEOMETRY_EXPORT bool IsNearestRectWithinDistance(const gfx::RectF& rect,
+                                                 float distance);
+
+// Returns the Rect after rounding the corners of the RectF to an integer grid.
+GEOMETRY_EXPORT gfx::Rect ToRoundedRect(const gfx::RectF& rect);
+
+// Returns a Rect obtained by flooring the values of the given RectF.
+// Please prefer the previous two functions in new code.
+GEOMETRY_EXPORT Rect ToFlooredRectDeprecated(const RectF& rect);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_RECT_CONVERSIONS_H_
diff --git a/ui/gfx/geometry/rect_f.cc b/ui/gfx/geometry/rect_f.cc
new file mode 100644
index 0000000..c8dafe2
--- /dev/null
+++ b/ui/gfx/geometry/rect_f.cc
@@ -0,0 +1,266 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/rect_f.h"
+
+#include <algorithm>
+#include <limits>
+
+#include "base/check.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "build/build_config.h"
+#include "ui/gfx/geometry/insets_f.h"
+
+#if defined(OS_IOS)
+#include <CoreGraphics/CoreGraphics.h>
+#elif defined(OS_MAC)
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+
+namespace gfx {
+
+static void AdjustAlongAxis(float dst_origin,
+                            float dst_size,
+                            float* origin,
+                            float* size) {
+  *size = std::min(dst_size, *size);
+  if (*origin < dst_origin)
+    *origin = dst_origin;
+  else
+    *origin = std::min(dst_origin + dst_size, *origin + *size) - *size;
+}
+
+#if defined(OS_APPLE)
+RectF::RectF(const CGRect& r)
+    : origin_(r.origin.x, r.origin.y), size_(r.size.width, r.size.height) {
+}
+
+CGRect RectF::ToCGRect() const {
+  return CGRectMake(x(), y(), width(), height());
+}
+#endif
+
+void RectF::Inset(const InsetsF& insets) {
+  Inset(insets.left(), insets.top(), insets.right(), insets.bottom());
+}
+
+void RectF::Inset(float left, float top, float right, float bottom) {
+  origin_ += Vector2dF(left, top);
+  set_width(std::max(width() - left - right, 0.0f));
+  set_height(std::max(height() - top - bottom, 0.0f));
+}
+
+void RectF::Offset(float horizontal, float vertical) {
+  origin_ += Vector2dF(horizontal, vertical);
+}
+
+void RectF::operator+=(const Vector2dF& offset) {
+  origin_ += offset;
+}
+
+void RectF::operator-=(const Vector2dF& offset) {
+  origin_ -= offset;
+}
+
+InsetsF RectF::InsetsFrom(const RectF& inner) const {
+  return InsetsF(inner.y() - y(),
+                 inner.x() - x(),
+                 bottom() - inner.bottom(),
+                 right() - inner.right());
+}
+
+bool RectF::operator<(const RectF& other) const {
+  if (origin_ != other.origin_)
+    return origin_ < other.origin_;
+
+  if (width() == other.width())
+    return height() < other.height();
+  return width() < other.width();
+}
+
+bool RectF::Contains(float point_x, float point_y) const {
+  return point_x >= x() && point_x < right() && point_y >= y() &&
+         point_y < bottom();
+}
+
+bool RectF::Contains(const RectF& rect) const {
+  return rect.x() >= x() && rect.right() <= right() && rect.y() >= y() &&
+         rect.bottom() <= bottom();
+}
+
+bool RectF::Intersects(const RectF& rect) const {
+  return !IsEmpty() && !rect.IsEmpty() && rect.x() < right() &&
+         rect.right() > x() && rect.y() < bottom() && rect.bottom() > y();
+}
+
+void RectF::Intersect(const RectF& rect) {
+  if (IsEmpty() || rect.IsEmpty()) {
+    SetRect(0, 0, 0, 0);
+    return;
+  }
+
+  float rx = std::max(x(), rect.x());
+  float ry = std::max(y(), rect.y());
+  float rr = std::min(right(), rect.right());
+  float rb = std::min(bottom(), rect.bottom());
+
+  if (rx >= rr || ry >= rb) {
+    SetRect(0, 0, 0, 0);
+    return;
+  }
+
+  SetRect(rx, ry, rr - rx, rb - ry);
+}
+
+void RectF::Union(const RectF& rect) {
+  if (IsEmpty()) {
+    *this = rect;
+    return;
+  }
+  if (rect.IsEmpty())
+    return;
+
+  float rx = std::min(x(), rect.x());
+  float ry = std::min(y(), rect.y());
+  float rr = std::max(right(), rect.right());
+  float rb = std::max(bottom(), rect.bottom());
+
+  SetRect(rx, ry, rr - rx, rb - ry);
+}
+
+void RectF::Subtract(const RectF& rect) {
+  if (!Intersects(rect))
+    return;
+  if (rect.Contains(*this)) {
+    SetRect(0, 0, 0, 0);
+    return;
+  }
+
+  float rx = x();
+  float ry = y();
+  float rr = right();
+  float rb = bottom();
+
+  if (rect.y() <= y() && rect.bottom() >= bottom()) {
+    // complete intersection in the y-direction
+    if (rect.x() <= x()) {
+      rx = rect.right();
+    } else if (rect.right() >= right()) {
+      rr = rect.x();
+    }
+  } else if (rect.x() <= x() && rect.right() >= right()) {
+    // complete intersection in the x-direction
+    if (rect.y() <= y()) {
+      ry = rect.bottom();
+    } else if (rect.bottom() >= bottom()) {
+      rb = rect.y();
+    }
+  }
+  SetRect(rx, ry, rr - rx, rb - ry);
+}
+
+void RectF::AdjustToFit(const RectF& rect) {
+  float new_x = x();
+  float new_y = y();
+  float new_width = width();
+  float new_height = height();
+  AdjustAlongAxis(rect.x(), rect.width(), &new_x, &new_width);
+  AdjustAlongAxis(rect.y(), rect.height(), &new_y, &new_height);
+  SetRect(new_x, new_y, new_width, new_height);
+}
+
+PointF RectF::CenterPoint() const {
+  return PointF(x() + width() / 2, y() + height() / 2);
+}
+
+void RectF::ClampToCenteredSize(const SizeF& size) {
+  float new_width = std::min(width(), size.width());
+  float new_height = std::min(height(), size.height());
+  float new_x = x() + (width() - new_width) / 2;
+  float new_y = y() + (height() - new_height) / 2;
+  SetRect(new_x, new_y, new_width, new_height);
+}
+
+void RectF::Transpose() {
+  SetRect(y(), x(), height(), width());
+}
+
+void RectF::SplitVertically(RectF* left_half, RectF* right_half) const {
+  DCHECK(left_half);
+  DCHECK(right_half);
+
+  left_half->SetRect(x(), y(), width() / 2, height());
+  right_half->SetRect(
+      left_half->right(), y(), width() - left_half->width(), height());
+}
+
+bool RectF::SharesEdgeWith(const RectF& rect) const {
+  return (y() == rect.y() && height() == rect.height() &&
+          (x() == rect.right() || right() == rect.x())) ||
+         (x() == rect.x() && width() == rect.width() &&
+          (y() == rect.bottom() || bottom() == rect.y()));
+}
+
+float RectF::ManhattanDistanceToPoint(const PointF& point) const {
+  float x_distance =
+      std::max<float>(0, std::max(x() - point.x(), point.x() - right()));
+  float y_distance =
+      std::max<float>(0, std::max(y() - point.y(), point.y() - bottom()));
+
+  return x_distance + y_distance;
+}
+
+float RectF::ManhattanInternalDistance(const RectF& rect) const {
+  RectF c(*this);
+  c.Union(rect);
+
+  static constexpr float kEpsilon = std::numeric_limits<float>::epsilon();
+  float x = std::max(0.f, c.width() - width() - rect.width() + kEpsilon);
+  float y = std::max(0.f, c.height() - height() - rect.height() + kEpsilon);
+  return x + y;
+}
+
+bool RectF::IsExpressibleAsRect() const {
+  return base::IsValueInRangeForNumericType<int>(x()) &&
+         base::IsValueInRangeForNumericType<int>(y()) &&
+         base::IsValueInRangeForNumericType<int>(width()) &&
+         base::IsValueInRangeForNumericType<int>(height()) &&
+         base::IsValueInRangeForNumericType<int>(right()) &&
+         base::IsValueInRangeForNumericType<int>(bottom());
+}
+
+std::string RectF::ToString() const {
+  return base::StringPrintf("%s %s",
+                            origin().ToString().c_str(),
+                            size().ToString().c_str());
+}
+
+RectF IntersectRects(const RectF& a, const RectF& b) {
+  RectF result = a;
+  result.Intersect(b);
+  return result;
+}
+
+RectF UnionRects(const RectF& a, const RectF& b) {
+  RectF result = a;
+  result.Union(b);
+  return result;
+}
+
+RectF SubtractRects(const RectF& a, const RectF& b) {
+  RectF result = a;
+  result.Subtract(b);
+  return result;
+}
+
+RectF BoundingRect(const PointF& p1, const PointF& p2) {
+  float rx = std::min(p1.x(), p2.x());
+  float ry = std::min(p1.y(), p2.y());
+  float rr = std::max(p1.x(), p2.x());
+  float rb = std::max(p1.y(), p2.y());
+  return RectF(rx, ry, rr - rx, rb - ry);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rect_f.h b/ui/gfx/geometry/rect_f.h
new file mode 100644
index 0000000..acda35b
--- /dev/null
+++ b/ui/gfx/geometry/rect_f.h
@@ -0,0 +1,267 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_RECT_F_H_
+#define UI_GFX_GEOMETRY_RECT_F_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "build/build_config.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+#if defined(OS_APPLE)
+typedef struct CGRect CGRect;
+#endif
+
+namespace gfx {
+
+class InsetsF;
+
+// A floating version of gfx::Rect.
+class GEOMETRY_EXPORT RectF {
+ public:
+  constexpr RectF() = default;
+  constexpr RectF(float width, float height) : size_(width, height) {}
+  constexpr RectF(float x, float y, float width, float height)
+      : origin_(x, y), size_(width, height) {}
+  constexpr explicit RectF(const SizeF& size) : size_(size) {}
+  constexpr RectF(const PointF& origin, const SizeF& size)
+      : origin_(origin), size_(size) {}
+
+  constexpr explicit RectF(const Rect& r)
+      : RectF(static_cast<float>(r.x()),
+              static_cast<float>(r.y()),
+              static_cast<float>(r.width()),
+              static_cast<float>(r.height())) {}
+
+#if defined(OS_APPLE)
+  explicit RectF(const CGRect& r);
+  // Construct an equivalent CoreGraphics object.
+  CGRect ToCGRect() const;
+#endif
+
+  constexpr float x() const { return origin_.x(); }
+  void set_x(float x) { origin_.set_x(x); }
+
+  constexpr float y() const { return origin_.y(); }
+  void set_y(float y) { origin_.set_y(y); }
+
+  constexpr float width() const { return size_.width(); }
+  void set_width(float width) { size_.set_width(width); }
+
+  constexpr float height() const { return size_.height(); }
+  void set_height(float height) { size_.set_height(height); }
+
+  constexpr const PointF& origin() const { return origin_; }
+  void set_origin(const PointF& origin) { origin_ = origin; }
+
+  constexpr const SizeF& size() const { return size_; }
+  void set_size(const SizeF& size) { size_ = size; }
+
+  constexpr float right() const { return x() + width(); }
+  constexpr float bottom() const { return y() + height(); }
+
+  constexpr PointF top_right() const { return PointF(right(), y()); }
+  constexpr PointF bottom_left() const { return PointF(x(), bottom()); }
+  constexpr PointF bottom_right() const { return PointF(right(), bottom()); }
+
+  constexpr PointF left_center() const {
+    return PointF(x(), y() + height() / 2);
+  }
+  constexpr PointF top_center() const { return PointF(x() + width() / 2, y()); }
+  constexpr PointF right_center() const {
+    return PointF(right(), y() + height() / 2);
+  }
+  constexpr PointF bottom_center() const {
+    return PointF(x() + width() / 2, bottom());
+  }
+
+  Vector2dF OffsetFromOrigin() const { return Vector2dF(x(), y()); }
+
+  void SetRect(float x, float y, float width, float height) {
+    origin_.SetPoint(x, y);
+    size_.SetSize(width, height);
+  }
+
+  // Shrink the rectangle by |inset| on all sides.
+  void Inset(float inset) { Inset(inset, inset); }
+  // Shrink the rectangle by a horizontal and vertical distance on all sides.
+  void Inset(float horizontal, float vertical) {
+    Inset(horizontal, vertical, horizontal, vertical);
+  }
+
+  // Shrink the rectangle by the given insets.
+  void Inset(const InsetsF& insets);
+
+  // Shrink the rectangle by the specified amount on each side.
+  void Inset(float left, float top, float right, float bottom);
+
+  // Expand the rectangle by the specified amount on each side.
+  void Outset(float outset) { Inset(-outset); }
+  void Outset(float horizontal, float vertical) {
+    Inset(-horizontal, -vertical);
+  }
+  void Outset(float left, float top, float right, float bottom) {
+    Inset(-left, -top, -right, -bottom);
+  }
+
+  // Move the rectangle by a horizontal and vertical distance.
+  void Offset(float horizontal, float vertical);
+  void Offset(const Vector2dF& distance) { Offset(distance.x(), distance.y()); }
+  void operator+=(const Vector2dF& offset);
+  void operator-=(const Vector2dF& offset);
+
+  InsetsF InsetsFrom(const RectF& inner) const;
+
+  // Returns true if the area of the rectangle is zero.
+  bool IsEmpty() const { return size_.IsEmpty(); }
+
+  // A rect is less than another rect if its origin is less than
+  // the other rect's origin. If the origins are equal, then the
+  // shortest rect is less than the other. If the origin and the
+  // height are equal, then the narrowest rect is less than.
+  // This comparison is required to use Rects in sets, or sorted
+  // vectors.
+  bool operator<(const RectF& other) const;
+
+  // Returns true if the point identified by point_x and point_y falls inside
+  // this rectangle.  The point (x, y) is inside the rectangle, but the
+  // point (x + width, y + height) is not.
+  bool Contains(float point_x, float point_y) const;
+
+  // Returns true if the specified point is contained by this rectangle.
+  bool Contains(const PointF& point) const {
+    return Contains(point.x(), point.y());
+  }
+
+  // Returns true if this rectangle contains the specified rectangle.
+  bool Contains(const RectF& rect) const;
+
+  // Returns true if this rectangle intersects the specified rectangle.
+  // An empty rectangle doesn't intersect any rectangle.
+  bool Intersects(const RectF& rect) const;
+
+  // Computes the intersection of this rectangle with the given rectangle.
+  void Intersect(const RectF& rect);
+
+  // Computes the union of this rectangle with the given rectangle.  The union
+  // is the smallest rectangle containing both rectangles.
+  void Union(const RectF& rect);
+
+  // Computes the rectangle resulting from subtracting |rect| from |*this|,
+  // i.e. the bounding rect of |Region(*this) - Region(rect)|.
+  void Subtract(const RectF& rect);
+
+  // Fits as much of the receiving rectangle into the supplied rectangle as
+  // possible, becoming the result. For example, if the receiver had
+  // a x-location of 2 and a width of 4, and the supplied rectangle had
+  // an x-location of 0 with a width of 5, the returned rectangle would have
+  // an x-location of 1 with a width of 4.
+  void AdjustToFit(const RectF& rect);
+
+  // Returns the center of this rectangle.
+  PointF CenterPoint() const;
+
+  // Becomes a rectangle that has the same center point but with a size capped
+  // at given |size|.
+  void ClampToCenteredSize(const SizeF& size);
+
+  // Transpose x and y axis.
+  void Transpose();
+
+  // Splits |this| in two halves, |left_half| and |right_half|.
+  void SplitVertically(RectF* left_half, RectF* right_half) const;
+
+  // Returns true if this rectangle shares an entire edge (i.e., same width or
+  // same height) with the given rectangle, and the rectangles do not overlap.
+  bool SharesEdgeWith(const RectF& rect) const;
+
+  // Returns the manhattan distance from the rect to the point. If the point is
+  // inside the rect, returns 0.
+  float ManhattanDistanceToPoint(const PointF& point) const;
+
+  // Returns the manhattan distance between the contents of this rect and the
+  // contents of the given rect. That is, if the intersection of the two rects
+  // is non-empty then the function returns 0. If the rects share a side, it
+  // returns the smallest non-zero value appropriate for float.
+  float ManhattanInternalDistance(const RectF& rect) const;
+
+  // Scales the rectangle by |scale|.
+  void Scale(float scale) {
+    Scale(scale, scale);
+  }
+
+  void Scale(float x_scale, float y_scale) {
+    set_origin(ScalePoint(origin(), x_scale, y_scale));
+    set_size(ScaleSize(size(), x_scale, y_scale));
+  }
+
+  // This method reports if the RectF can be safely converted to an integer
+  // Rect. When it is false, some dimension of the RectF is outside the bounds
+  // of what an integer can represent, and converting it to a Rect will require
+  // clamping.
+  bool IsExpressibleAsRect() const;
+
+  std::string ToString() const;
+
+ private:
+  PointF origin_;
+  SizeF size_;
+};
+
+inline bool operator==(const RectF& lhs, const RectF& rhs) {
+  return lhs.origin() == rhs.origin() && lhs.size() == rhs.size();
+}
+
+inline bool operator!=(const RectF& lhs, const RectF& rhs) {
+  return !(lhs == rhs);
+}
+
+inline RectF operator+(const RectF& lhs, const Vector2dF& rhs) {
+  return RectF(lhs.x() + rhs.x(), lhs.y() + rhs.y(),
+      lhs.width(), lhs.height());
+}
+
+inline RectF operator-(const RectF& lhs, const Vector2dF& rhs) {
+  return RectF(lhs.x() - rhs.x(), lhs.y() - rhs.y(),
+      lhs.width(), lhs.height());
+}
+
+inline RectF operator+(const Vector2dF& lhs, const RectF& rhs) {
+  return rhs + lhs;
+}
+
+GEOMETRY_EXPORT RectF IntersectRects(const RectF& a, const RectF& b);
+GEOMETRY_EXPORT RectF UnionRects(const RectF& a, const RectF& b);
+GEOMETRY_EXPORT RectF SubtractRects(const RectF& a, const RectF& b);
+
+inline RectF ScaleRect(const RectF& r, float x_scale, float y_scale) {
+  return RectF(r.x() * x_scale, r.y() * y_scale,
+       r.width() * x_scale, r.height() * y_scale);
+}
+
+inline RectF ScaleRect(const RectF& r, float scale) {
+  return ScaleRect(r, scale, scale);
+}
+
+// Constructs a rectangle with |p1| and |p2| as opposite corners.
+//
+// This could also be thought of as "the smallest rect that contains both
+// points", except that we consider points on the right/bottom edges of the
+// rect to be outside the rect.  So technically one or both points will not be
+// contained within the rect, because they will appear on one of these edges.
+GEOMETRY_EXPORT RectF BoundingRect(const PointF& p1, const PointF& p2);
+
+// This is declared here for use in gtest-based unit tests but is defined in
+// the //ui/gfx:test_support target. Depend on that to use this in your unit
+// test. This should not be used in production code - call ToString() instead.
+void PrintTo(const RectF& rect, ::std::ostream* os);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_RECT_F_H_
diff --git a/ui/gfx/geometry/rect_f_unittest.cc b/ui/gfx/geometry/rect_f_unittest.cc
new file mode 100644
index 0000000..d318255
--- /dev/null
+++ b/ui/gfx/geometry/rect_f_unittest.cc
@@ -0,0 +1,78 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/geometry/rect_f.h"
+
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/test/gfx_util.h"
+
+namespace gfx {
+
+TEST(RectFTest, Inset) {
+  RectF r(10, 20, 30, 40);
+  r.Inset(0);
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+  r.Inset(1.5);
+  EXPECT_RECTF_EQ(RectF(11.5, 21.5, 27, 37), r);
+  r.Inset(-1.5);
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+
+  r.Inset(1.5, 2.25);
+  EXPECT_RECTF_EQ(RectF(11.5, 22.25, 27, 35.5), r);
+  r.Inset(-1.5, -2.25);
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+
+  // The parameters are left, top, right, bottom.
+  r.Inset(1.5, 2.25, 3.75, 4);
+  EXPECT_RECTF_EQ(RectF(11.5, 22.25, 24.75, 33.75), r);
+  r.Inset(-1.5, -2.25, -3.75, -4);
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+
+  // InsetsF parameters are top, right, bottom, left.
+  r.Inset(InsetsF(1.5, 2.25, 3.75, 4));
+  EXPECT_RECTF_EQ(RectF(12.25, 21.5, 23.75, 34.75), r);
+  r.Inset(InsetsF(-1.5, -2.25, -3.75, -4));
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+}
+
+TEST(RectFTest, Outset) {
+  RectF r(10, 20, 30, 40);
+  r.Outset(0);
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+  r.Outset(1.5);
+  EXPECT_RECTF_EQ(RectF(8.5, 18.5, 33, 43), r);
+  r.Outset(-1.5);
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+
+  r.Outset(1.5, 2.25);
+  EXPECT_RECTF_EQ(RectF(8.5, 17.75, 33, 44.5), r);
+  r.Outset(-1.5, -2.25);
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+
+  r.Outset(1.5, 2.25, 3.75, 4);
+  EXPECT_RECTF_EQ(RectF(8.5, 17.75, 35.25, 46.25), r);
+  r.Outset(-1.5, -2.25, -3.75, -4);
+  EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
+}
+
+TEST(RectFTest, InsetClamped) {
+  RectF r(10, 20, 30, 40);
+  r.Inset(18);
+  EXPECT_RECTF_EQ(RectF(28, 38, 0, 4), r);
+  r.Inset(-18);
+  EXPECT_RECTF_EQ(RectF(10, 20, 36, 40), r);
+
+  r.Inset(15, 30);
+  EXPECT_RECTF_EQ(RectF(25, 50, 6, 0), r);
+  r.Inset(-15, -30);
+  EXPECT_RECTF_EQ(RectF(10, 20, 36, 60), r);
+
+  r.Inset(20, 30, 40, 50);
+  EXPECT_RECTF_EQ(RectF(30, 50, 0, 0), r);
+  r.Inset(-20, -30, -40, -50);
+  EXPECT_RECTF_EQ(RectF(10, 20, 60, 80), r);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rect_unittest.cc b/ui/gfx/geometry/rect_unittest.cc
new file mode 100644
index 0000000..6aceed3
--- /dev/null
+++ b/ui/gfx/geometry/rect_unittest.cc
@@ -0,0 +1,1300 @@
+// Copyright (c) 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.
+
+#include <limits>
+
+#include <stddef.h>
+
+#include "base/cxx17_backports.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/test/gfx_util.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
+namespace gfx {
+
+TEST(RectTest, Contains) {
+  static const struct ContainsCase {
+    int rect_x;
+    int rect_y;
+    int rect_width;
+    int rect_height;
+    int point_x;
+    int point_y;
+    bool contained;
+  } contains_cases[] = {
+    {0, 0, 10, 10, 0, 0, true},
+    {0, 0, 10, 10, 5, 5, true},
+    {0, 0, 10, 10, 9, 9, true},
+    {0, 0, 10, 10, 5, 10, false},
+    {0, 0, 10, 10, 10, 5, false},
+    {0, 0, 10, 10, -1, -1, false},
+    {0, 0, 10, 10, 50, 50, false},
+  #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
+    {0, 0, -10, -10, 0, 0, false},
+  #endif
+  };
+  for (size_t i = 0; i < base::size(contains_cases); ++i) {
+    const ContainsCase& value = contains_cases[i];
+    Rect rect(value.rect_x, value.rect_y, value.rect_width, value.rect_height);
+    EXPECT_EQ(value.contained, rect.Contains(value.point_x, value.point_y));
+  }
+}
+
+TEST(RectTest, Intersects) {
+  static const struct {
+    int x1;  // rect 1
+    int y1;
+    int w1;
+    int h1;
+    int x2;  // rect 2
+    int y2;
+    int w2;
+    int h2;
+    bool intersects;
+  } tests[] = {
+    { 0, 0, 0, 0, 0, 0, 0, 0, false },
+    { 0, 0, 0, 0, -10, -10, 20, 20, false },
+    { -10, 0, 0, 20, 0, -10, 20, 0, false },
+    { 0, 0, 10, 10, 0, 0, 10, 10, true },
+    { 0, 0, 10, 10, 10, 10, 10, 10, false },
+    { 10, 10, 10, 10, 0, 0, 10, 10, false },
+    { 10, 10, 10, 10, 5, 5, 10, 10, true },
+    { 10, 10, 10, 10, 15, 15, 10, 10, true },
+    { 10, 10, 10, 10, 20, 15, 10, 10, false },
+    { 10, 10, 10, 10, 21, 15, 10, 10, false }
+  };
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
+    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
+    EXPECT_EQ(tests[i].intersects, r1.Intersects(r2));
+    EXPECT_EQ(tests[i].intersects, r2.Intersects(r1));
+  }
+}
+
+TEST(RectTest, Intersect) {
+  static const struct {
+    int x1;  // rect 1
+    int y1;
+    int w1;
+    int h1;
+    int x2;  // rect 2
+    int y2;
+    int w2;
+    int h2;
+    int x3;  // rect 3: the union of rects 1 and 2
+    int y3;
+    int w3;
+    int h3;
+  } tests[] = {
+    { 0, 0, 0, 0,   // zeros
+      0, 0, 0, 0,
+      0, 0, 0, 0 },
+    { 0, 0, 4, 4,   // equal
+      0, 0, 4, 4,
+      0, 0, 4, 4 },
+    { 0, 0, 4, 4,   // neighboring
+      4, 4, 4, 4,
+      0, 0, 0, 0 },
+    { 0, 0, 4, 4,   // overlapping corners
+      2, 2, 4, 4,
+      2, 2, 2, 2 },
+    { 0, 0, 4, 4,   // T junction
+      3, 1, 4, 2,
+      3, 1, 1, 2 },
+    { 3, 0, 2, 2,   // gap
+      0, 0, 2, 2,
+      0, 0, 0, 0 }
+  };
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
+    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
+    Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
+    Rect ir = IntersectRects(r1, r2);
+    EXPECT_EQ(r3.x(), ir.x());
+    EXPECT_EQ(r3.y(), ir.y());
+    EXPECT_EQ(r3.width(), ir.width());
+    EXPECT_EQ(r3.height(), ir.height());
+  }
+}
+
+TEST(RectTest, Union) {
+  static const struct Test {
+    int x1;  // rect 1
+    int y1;
+    int w1;
+    int h1;
+    int x2;  // rect 2
+    int y2;
+    int w2;
+    int h2;
+    int x3;  // rect 3: the union of rects 1 and 2
+    int y3;
+    int w3;
+    int h3;
+  } tests[] = {
+    { 0, 0, 0, 0,
+      0, 0, 0, 0,
+      0, 0, 0, 0 },
+    { 0, 0, 4, 4,
+      0, 0, 4, 4,
+      0, 0, 4, 4 },
+    { 0, 0, 4, 4,
+      4, 4, 4, 4,
+      0, 0, 8, 8 },
+    { 0, 0, 4, 4,
+      0, 5, 4, 4,
+      0, 0, 4, 9 },
+    { 0, 0, 2, 2,
+      3, 3, 2, 2,
+      0, 0, 5, 5 },
+    { 3, 3, 2, 2,   // reverse r1 and r2 from previous test
+      0, 0, 2, 2,
+      0, 0, 5, 5 },
+    { 0, 0, 0, 0,   // union with empty rect
+      2, 2, 2, 2,
+      2, 2, 2, 2 }
+  };
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
+    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
+    Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
+    Rect u = UnionRects(r1, r2);
+    EXPECT_EQ(r3.x(), u.x());
+    EXPECT_EQ(r3.y(), u.y());
+    EXPECT_EQ(r3.width(), u.width());
+    EXPECT_EQ(r3.height(), u.height());
+  }
+}
+
+TEST(RectTest, Equals) {
+  ASSERT_TRUE(Rect(0, 0, 0, 0) == Rect(0, 0, 0, 0));
+  ASSERT_TRUE(Rect(1, 2, 3, 4) == Rect(1, 2, 3, 4));
+  ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 0, 0, 1));
+  ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 0, 1, 0));
+  ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 1, 0, 0));
+  ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(1, 0, 0, 0));
+}
+
+TEST(RectTest, AdjustToFit) {
+  static const struct Test {
+    int x1;  // source
+    int y1;
+    int w1;
+    int h1;
+    int x2;  // target
+    int y2;
+    int w2;
+    int h2;
+    int x3;  // rect 3: results of invoking AdjustToFit
+    int y3;
+    int w3;
+    int h3;
+  } tests[] = {
+    { 0, 0, 2, 2,
+      0, 0, 2, 2,
+      0, 0, 2, 2 },
+    { 2, 2, 3, 3,
+      0, 0, 4, 4,
+      1, 1, 3, 3 },
+    { -1, -1, 5, 5,
+      0, 0, 4, 4,
+      0, 0, 4, 4 },
+    { 2, 2, 4, 4,
+      0, 0, 3, 3,
+      0, 0, 3, 3 },
+    { 2, 2, 1, 1,
+      0, 0, 3, 3,
+      2, 2, 1, 1 }
+  };
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
+    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
+    Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
+    Rect u = r1;
+    u.AdjustToFit(r2);
+    EXPECT_EQ(r3.x(), u.x());
+    EXPECT_EQ(r3.y(), u.y());
+    EXPECT_EQ(r3.width(), u.width());
+    EXPECT_EQ(r3.height(), u.height());
+  }
+}
+
+TEST(RectTest, Subtract) {
+  Rect result;
+
+  // Matching
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(10, 10, 20, 20));
+  EXPECT_EQ(Rect(0, 0, 0, 0), result);
+
+  // Contains
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(5, 5, 30, 30));
+  EXPECT_EQ(Rect(0, 0, 0, 0), result);
+
+  // No intersection
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(30, 30, 30, 30));
+  EXPECT_EQ(Rect(10, 10, 20, 20), result);
+
+  // Not a complete intersection in either direction
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(15, 15, 20, 20));
+  EXPECT_EQ(Rect(10, 10, 20, 20), result);
+
+  // Complete intersection in the x-direction, top edge is fully covered.
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(10, 15, 20, 20));
+  EXPECT_EQ(Rect(10, 10, 20, 5), result);
+
+  // Complete intersection in the x-direction, top edge is fully covered.
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(5, 15, 30, 20));
+  EXPECT_EQ(Rect(10, 10, 20, 5), result);
+
+  // Complete intersection in the x-direction, bottom edge is fully covered.
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(5, 5, 30, 20));
+  EXPECT_EQ(Rect(10, 25, 20, 5), result);
+
+  // Complete intersection in the x-direction, none of the edges is fully
+  // covered.
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(5, 15, 30, 1));
+  EXPECT_EQ(Rect(10, 10, 20, 20), result);
+
+  // Complete intersection in the y-direction, left edge is fully covered.
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(10, 10, 10, 30));
+  EXPECT_EQ(Rect(20, 10, 10, 20), result);
+
+  // Complete intersection in the y-direction, left edge is fully covered.
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(5, 5, 20, 30));
+  EXPECT_EQ(Rect(25, 10, 5, 20), result);
+
+  // Complete intersection in the y-direction, right edge is fully covered.
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(20, 5, 20, 30));
+  EXPECT_EQ(Rect(10, 10, 10, 20), result);
+
+  // Complete intersection in the y-direction, none of the edges is fully
+  // covered.
+  result = Rect(10, 10, 20, 20);
+  result.Subtract(Rect(15, 5, 1, 30));
+  EXPECT_EQ(Rect(10, 10, 20, 20), result);
+}
+
+TEST(RectTest, IsEmpty) {
+  EXPECT_TRUE(Rect(0, 0, 0, 0).IsEmpty());
+  EXPECT_TRUE(Rect(0, 0, 0, 0).size().IsEmpty());
+  EXPECT_TRUE(Rect(0, 0, 10, 0).IsEmpty());
+  EXPECT_TRUE(Rect(0, 0, 10, 0).size().IsEmpty());
+  EXPECT_TRUE(Rect(0, 0, 0, 10).IsEmpty());
+  EXPECT_TRUE(Rect(0, 0, 0, 10).size().IsEmpty());
+  EXPECT_FALSE(Rect(0, 0, 10, 10).IsEmpty());
+  EXPECT_FALSE(Rect(0, 0, 10, 10).size().IsEmpty());
+}
+
+TEST(RectTest, SplitVertically) {
+  Rect left_half, right_half;
+
+  // Splitting when origin is (0, 0).
+  Rect(0, 0, 20, 20).SplitVertically(&left_half, &right_half);
+  EXPECT_TRUE(left_half == Rect(0, 0, 10, 20));
+  EXPECT_TRUE(right_half == Rect(10, 0, 10, 20));
+
+  // Splitting when origin is arbitrary.
+  Rect(10, 10, 20, 10).SplitVertically(&left_half, &right_half);
+  EXPECT_TRUE(left_half == Rect(10, 10, 10, 10));
+  EXPECT_TRUE(right_half == Rect(20, 10, 10, 10));
+
+  // Splitting a rectangle of zero width.
+  Rect(10, 10, 0, 10).SplitVertically(&left_half, &right_half);
+  EXPECT_TRUE(left_half == Rect(10, 10, 0, 10));
+  EXPECT_TRUE(right_half == Rect(10, 10, 0, 10));
+
+  // Splitting a rectangle of odd width.
+  Rect(10, 10, 5, 10).SplitVertically(&left_half, &right_half);
+  EXPECT_TRUE(left_half == Rect(10, 10, 2, 10));
+  EXPECT_TRUE(right_half == Rect(12, 10, 3, 10));
+}
+
+TEST(RectTest, CenterPoint) {
+  Point center;
+
+  // When origin is (0, 0).
+  center = Rect(0, 0, 20, 20).CenterPoint();
+  EXPECT_TRUE(center == Point(10, 10));
+
+  // When origin is even.
+  center = Rect(10, 10, 20, 20).CenterPoint();
+  EXPECT_TRUE(center == Point(20, 20));
+
+  // When origin is odd.
+  center = Rect(11, 11, 20, 20).CenterPoint();
+  EXPECT_TRUE(center == Point(21, 21));
+
+  // When 0 width or height.
+  center = Rect(10, 10, 0, 20).CenterPoint();
+  EXPECT_TRUE(center == Point(10, 20));
+  center = Rect(10, 10, 20, 0).CenterPoint();
+  EXPECT_TRUE(center == Point(20, 10));
+
+  // When an odd size.
+  center = Rect(10, 10, 21, 21).CenterPoint();
+  EXPECT_TRUE(center == Point(20, 20));
+
+  // When an odd size and position.
+  center = Rect(11, 11, 21, 21).CenterPoint();
+  EXPECT_TRUE(center == Point(21, 21));
+}
+
+TEST(RectTest, CenterPointF) {
+  PointF center;
+
+  // When origin is (0, 0).
+  center = RectF(0, 0, 20, 20).CenterPoint();
+  EXPECT_TRUE(center == PointF(10, 10));
+
+  // When origin is even.
+  center = RectF(10, 10, 20, 20).CenterPoint();
+  EXPECT_TRUE(center == PointF(20, 20));
+
+  // When origin is odd.
+  center = RectF(11, 11, 20, 20).CenterPoint();
+  EXPECT_TRUE(center == PointF(21, 21));
+
+  // When 0 width or height.
+  center = RectF(10, 10, 0, 20).CenterPoint();
+  EXPECT_TRUE(center == PointF(10, 20));
+  center = RectF(10, 10, 20, 0).CenterPoint();
+  EXPECT_TRUE(center == PointF(20, 10));
+
+  // When an odd size.
+  center = RectF(10, 10, 21, 21).CenterPoint();
+  EXPECT_TRUE(center == PointF(20.5f, 20.5f));
+
+  // When an odd size and position.
+  center = RectF(11, 11, 21, 21).CenterPoint();
+  EXPECT_TRUE(center == PointF(21.5f, 21.5f));
+}
+
+TEST(RectTest, SharesEdgeWith) {
+  Rect r(2, 3, 4, 5);
+
+  // Must be non-overlapping
+  EXPECT_FALSE(r.SharesEdgeWith(r));
+
+  Rect just_above(2, 1, 4, 2);
+  Rect just_below(2, 8, 4, 2);
+  Rect just_left(0, 3, 2, 5);
+  Rect just_right(6, 3, 2, 5);
+
+  EXPECT_TRUE(r.SharesEdgeWith(just_above));
+  EXPECT_TRUE(r.SharesEdgeWith(just_below));
+  EXPECT_TRUE(r.SharesEdgeWith(just_left));
+  EXPECT_TRUE(r.SharesEdgeWith(just_right));
+
+  // Wrong placement
+  Rect same_height_no_edge(0, 0, 1, 5);
+  Rect same_width_no_edge(0, 0, 4, 1);
+
+  EXPECT_FALSE(r.SharesEdgeWith(same_height_no_edge));
+  EXPECT_FALSE(r.SharesEdgeWith(same_width_no_edge));
+
+  Rect just_above_no_edge(2, 1, 5, 2);  // too wide
+  Rect just_below_no_edge(2, 8, 3, 2);  // too narrow
+  Rect just_left_no_edge(0, 3, 2, 6);   // too tall
+  Rect just_right_no_edge(6, 3, 2, 4);  // too short
+
+  EXPECT_FALSE(r.SharesEdgeWith(just_above_no_edge));
+  EXPECT_FALSE(r.SharesEdgeWith(just_below_no_edge));
+  EXPECT_FALSE(r.SharesEdgeWith(just_left_no_edge));
+  EXPECT_FALSE(r.SharesEdgeWith(just_right_no_edge));
+}
+
+// Similar to EXPECT_FLOAT_EQ, but lets NaN equal NaN
+#define EXPECT_FLOAT_AND_NAN_EQ(a, b) \
+  { if (a == a || b == b) { EXPECT_FLOAT_EQ(a, b); } }
+
+TEST(RectTest, ScaleRect) {
+  static const struct Test {
+    int x1;  // source
+    int y1;
+    int w1;
+    int h1;
+    float scale;
+    float x2;  // target
+    float y2;
+    float w2;
+    float h2;
+  } tests[] = {
+    { 3, 3, 3, 3,
+      1.5f,
+      4.5f, 4.5f, 4.5f, 4.5f },
+    { 3, 3, 3, 3,
+      0.0f,
+      0.0f, 0.0f, 0.0f, 0.0f },
+    { 3, 3, 3, 3,
+      std::numeric_limits<float>::quiet_NaN(),
+      std::numeric_limits<float>::quiet_NaN(),
+      std::numeric_limits<float>::quiet_NaN(),
+      std::numeric_limits<float>::quiet_NaN(),
+      std::numeric_limits<float>::quiet_NaN() },
+    { 3, 3, 3, 3,
+      std::numeric_limits<float>::max(),
+      std::numeric_limits<float>::max(),
+      std::numeric_limits<float>::max(),
+      std::numeric_limits<float>::max(),
+      std::numeric_limits<float>::max() }
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
+    RectF r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
+
+    RectF scaled = ScaleRect(r1, tests[i].scale);
+    EXPECT_FLOAT_AND_NAN_EQ(r2.x(), scaled.x());
+    EXPECT_FLOAT_AND_NAN_EQ(r2.y(), scaled.y());
+    EXPECT_FLOAT_AND_NAN_EQ(r2.width(), scaled.width());
+    EXPECT_FLOAT_AND_NAN_EQ(r2.height(), scaled.height());
+  }
+}
+
+TEST(RectTest, ToEnclosedRect) {
+  static const int max_int = std::numeric_limits<int>::max();
+  static const int min_int = std::numeric_limits<int>::min();
+  static const float max_float = std::numeric_limits<float>::max();
+  static const float max_int_f = static_cast<float>(max_int);
+  static const float min_int_f = static_cast<float>(min_int);
+
+  static const struct Test {
+    struct {
+      float x;
+      float y;
+      float width;
+      float height;
+    } in;
+    struct {
+      int x;
+      int y;
+      int width;
+      int height;
+    } expected;
+  } tests[] = {
+      {{0.0f, 0.0f, 0.0f, 0.0f}, {0, 0, 0, 0}},
+      {{-1.5f, -1.5f, 3.0f, 3.0f}, {-1, -1, 2, 2}},
+      {{-1.5f, -1.5f, 3.5f, 3.5f}, {-1, -1, 3, 3}},
+      {{max_float, max_float, 2.0f, 2.0f}, {max_int, max_int, 0, 0}},
+      {{0.0f, 0.0f, max_float, max_float}, {0, 0, max_int, max_int}},
+      {{20000.5f, 20000.5f, 0.5f, 0.5f}, {20001, 20001, 0, 0}},
+      {{max_int_f, max_int_f, max_int_f, max_int_f}, {max_int, max_int, 0, 0}},
+      {{1.9999f, 2.0002f, 5.9998f, 6.0001f}, {2, 3, 5, 5}},
+      {{1.9999f, 2.0001f, 6.0002f, 5.9998f}, {2, 3, 6, 4}},
+      {{1.9998f, 2.0002f, 6.0001f, 5.9999f}, {2, 3, 5, 5}}};
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    RectF source(tests[i].in.x, tests[i].in.y, tests[i].in.width,
+                 tests[i].in.height);
+    Rect enclosed = ToEnclosedRect(source);
+
+    EXPECT_EQ(tests[i].expected.x, enclosed.x());
+    EXPECT_EQ(tests[i].expected.y, enclosed.y());
+    EXPECT_EQ(tests[i].expected.width, enclosed.width());
+    EXPECT_EQ(tests[i].expected.height, enclosed.height());
+  }
+
+  {
+    RectF source(min_int_f, min_int_f, max_int_f * 3.f, max_int_f * 3.f);
+    Rect enclosed = ToEnclosedRect(source);
+
+    // That rect can't be represented, but it should be big.
+    EXPECT_EQ(max_int, enclosed.width());
+    EXPECT_EQ(max_int, enclosed.height());
+    // It should include some axis near the global origin.
+    EXPECT_GT(1, enclosed.x());
+    EXPECT_GT(1, enclosed.y());
+    // And it should not cause computation issues for itself.
+    EXPECT_LT(0, enclosed.right());
+    EXPECT_LT(0, enclosed.bottom());
+  }
+}
+
+TEST(RectTest, ToEnclosingRect) {
+  static const int max_int = std::numeric_limits<int>::max();
+  static const int min_int = std::numeric_limits<int>::min();
+  static const float max_float = std::numeric_limits<float>::max();
+  static const float epsilon_float = std::numeric_limits<float>::epsilon();
+  static const float max_int_f = static_cast<float>(max_int);
+  static const float min_int_f = static_cast<float>(min_int);
+  static const struct Test {
+    struct {
+      float x;
+      float y;
+      float width;
+      float height;
+    } in;
+    struct {
+      int x;
+      int y;
+      int width;
+      int height;
+    } expected;
+  } tests[] = {
+      {{0.0f, 0.0f, 0.0f, 0.0f}, {0, 0, 0, 0}},
+      {{5.5f, 5.5f, 0.0f, 0.0f}, {5, 5, 0, 0}},
+      {{3.5f, 2.5f, epsilon_float, -0.0f}, {3, 2, 0, 0}},
+      {{3.5f, 2.5f, 0.f, 0.001f}, {3, 2, 0, 1}},
+      {{-1.5f, -1.5f, 3.0f, 3.0f}, {-2, -2, 4, 4}},
+      {{-1.5f, -1.5f, 3.5f, 3.5f}, {-2, -2, 4, 4}},
+      {{max_float, max_float, 2.0f, 2.0f}, {max_int, max_int, 0, 0}},
+      {{0.0f, 0.0f, max_float, max_float}, {0, 0, max_int, max_int}},
+      {{20000.5f, 20000.5f, 0.5f, 0.5f}, {20000, 20000, 1, 1}},
+      {{max_int_f, max_int_f, max_int_f, max_int_f}, {max_int, max_int, 0, 0}},
+      {{-0.5f, -0.5f, 22777712.f, 1.f}, {-1, -1, 22777713, 2}},
+      {{1.9999f, 2.0002f, 5.9998f, 6.0001f}, {1, 2, 7, 7}},
+      {{1.9999f, 2.0001f, 6.0002f, 5.9998f}, {1, 2, 8, 6}},
+      {{1.9998f, 2.0002f, 6.0001f, 5.9999f}, {1, 2, 7, 7}}};
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    RectF source(tests[i].in.x, tests[i].in.y, tests[i].in.width,
+                 tests[i].in.height);
+
+    Rect enclosing = ToEnclosingRect(source);
+    EXPECT_EQ(tests[i].expected.x, enclosing.x());
+    EXPECT_EQ(tests[i].expected.y, enclosing.y());
+    EXPECT_EQ(tests[i].expected.width, enclosing.width());
+    EXPECT_EQ(tests[i].expected.height, enclosing.height());
+  }
+
+  {
+    RectF source(min_int_f, min_int_f, max_int_f * 3.f, max_int_f * 3.f);
+    Rect enclosing = ToEnclosingRect(source);
+
+    // That rect can't be represented, but it should be big.
+    EXPECT_EQ(max_int, enclosing.width());
+    EXPECT_EQ(max_int, enclosing.height());
+    // It should include some axis near the global origin.
+    EXPECT_GT(1, enclosing.x());
+    EXPECT_GT(1, enclosing.y());
+    // And it should cause computation issues for itself.
+    EXPECT_LT(0, enclosing.right());
+    EXPECT_LT(0, enclosing.bottom());
+  }
+}
+
+TEST(RectTest, ToEnclosingRectIgnoringError) {
+  static const int max_int = std::numeric_limits<int>::max();
+  static const float max_float = std::numeric_limits<float>::max();
+  static const float epsilon_float = std::numeric_limits<float>::epsilon();
+  static const float max_int_f = static_cast<float>(max_int);
+  static const float error = 0.001f;
+  static const struct Test {
+    struct {
+      float x;
+      float y;
+      float width;
+      float height;
+    } in;
+    struct {
+      int x;
+      int y;
+      int width;
+      int height;
+    } expected;
+  } tests[] = {
+      {{0.0f, 0.0f, 0.0f, 0.0f}, {0, 0, 0, 0}},
+      {{5.5f, 5.5f, 0.0f, 0.0f}, {5, 5, 0, 0}},
+      {{3.5f, 2.5f, epsilon_float, -0.0f}, {3, 2, 0, 0}},
+      {{3.5f, 2.5f, 0.f, 0.001f}, {3, 2, 0, 1}},
+      {{-1.5f, -1.5f, 3.0f, 3.0f}, {-2, -2, 4, 4}},
+      {{-1.5f, -1.5f, 3.5f, 3.5f}, {-2, -2, 4, 4}},
+      {{max_float, max_float, 2.0f, 2.0f}, {max_int, max_int, 0, 0}},
+      {{0.0f, 0.0f, max_float, max_float}, {0, 0, max_int, max_int}},
+      {{20000.5f, 20000.5f, 0.5f, 0.5f}, {20000, 20000, 1, 1}},
+      {{max_int_f, max_int_f, max_int_f, max_int_f}, {max_int, max_int, 0, 0}},
+      {{-0.5f, -0.5f, 22777712.f, 1.f}, {-1, -1, 22777713, 2}},
+      {{1.9999f, 2.0002f, 5.9998f, 6.0001f}, {2, 2, 6, 6}},
+      {{1.9999f, 2.0001f, 6.0002f, 5.9998f}, {2, 2, 6, 6}},
+      {{1.9998f, 2.0002f, 6.0001f, 5.9999f}, {2, 2, 6, 6}}};
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    RectF source(tests[i].in.x, tests[i].in.y, tests[i].in.width,
+                 tests[i].in.height);
+
+    Rect enclosing = ToEnclosingRectIgnoringError(source, error);
+    EXPECT_EQ(tests[i].expected.x, enclosing.x());
+    EXPECT_EQ(tests[i].expected.y, enclosing.y());
+    EXPECT_EQ(tests[i].expected.width, enclosing.width());
+    EXPECT_EQ(tests[i].expected.height, enclosing.height());
+  }
+}
+
+TEST(RectTest, ToNearestRect) {
+  Rect rect;
+  EXPECT_EQ(rect, ToNearestRect(RectF(rect)));
+
+  rect = Rect(-1, -1, 3, 3);
+  EXPECT_EQ(rect, ToNearestRect(RectF(rect)));
+
+  RectF rectf(-1.00001f, -0.999999f, 3.0000001f, 2.999999f);
+  EXPECT_EQ(rect, ToNearestRect(rectf));
+}
+
+TEST(RectTest, ToFlooredRect) {
+  static const struct Test {
+    float x1; // source
+    float y1;
+    float w1;
+    float h1;
+    int x2; // target
+    int y2;
+    int w2;
+    int h2;
+  } tests [] = {
+    { 0.0f, 0.0f, 0.0f, 0.0f,
+      0, 0, 0, 0 },
+    { -1.5f, -1.5f, 3.0f, 3.0f,
+      -2, -2, 3, 3 },
+    { -1.5f, -1.5f, 3.5f, 3.5f,
+      -2, -2, 3, 3 },
+    { 20000.5f, 20000.5f, 0.5f, 0.5f,
+      20000, 20000, 0, 0 },
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
+    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
+
+    Rect floored = ToFlooredRectDeprecated(r1);
+    EXPECT_FLOAT_EQ(r2.x(), floored.x());
+    EXPECT_FLOAT_EQ(r2.y(), floored.y());
+    EXPECT_FLOAT_EQ(r2.width(), floored.width());
+    EXPECT_FLOAT_EQ(r2.height(), floored.height());
+  }
+}
+
+TEST(RectTest, ScaleToEnclosedRect) {
+  static const struct Test {
+    Rect input_rect;
+    float input_scale;
+    Rect expected_rect;
+  } tests[] = {
+    {
+      Rect(),
+      5.f,
+      Rect(),
+    }, {
+      Rect(1, 1, 1, 1),
+      5.f,
+      Rect(5, 5, 5, 5),
+    }, {
+      Rect(-1, -1, 0, 0),
+      5.f,
+      Rect(-5, -5, 0, 0),
+    }, {
+      Rect(1, -1, 0, 1),
+      5.f,
+      Rect(5, -5, 0, 5),
+    }, {
+      Rect(-1, 1, 1, 0),
+      5.f,
+      Rect(-5, 5, 5, 0),
+    }, {
+      Rect(1, 2, 3, 4),
+      1.5f,
+      Rect(2, 3, 4, 6),
+    }, {
+      Rect(-1, -2, 0, 0),
+      1.5f,
+      Rect(-1, -3, 0, 0),
+    }
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    Rect result = ScaleToEnclosedRect(tests[i].input_rect,
+                                      tests[i].input_scale);
+    EXPECT_EQ(tests[i].expected_rect, result);
+  }
+}
+
+TEST(RectTest, ScaleToEnclosingRect) {
+  static const struct Test {
+    Rect input_rect;
+    float input_scale;
+    Rect expected_rect;
+  } tests[] = {
+    {
+      Rect(),
+      5.f,
+      Rect(),
+    }, {
+      Rect(1, 1, 1, 1),
+      5.f,
+      Rect(5, 5, 5, 5),
+    }, {
+      Rect(-1, -1, 0, 0),
+      5.f,
+      Rect(-5, -5, 0, 0),
+    }, {
+      Rect(1, -1, 0, 1),
+      5.f,
+      Rect(5, -5, 0, 5),
+    }, {
+      Rect(-1, 1, 1, 0),
+      5.f,
+      Rect(-5, 5, 5, 0),
+    }, {
+      Rect(1, 2, 3, 4),
+      1.5f,
+      Rect(1, 3, 5, 6),
+    }, {
+      Rect(-1, -2, 0, 0),
+      1.5f,
+      Rect(-2, -3, 0, 0),
+    }
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    Rect result =
+        ScaleToEnclosingRect(tests[i].input_rect, tests[i].input_scale);
+    EXPECT_EQ(tests[i].expected_rect, result);
+    Rect result_safe =
+        ScaleToEnclosingRectSafe(tests[i].input_rect, tests[i].input_scale);
+    EXPECT_EQ(tests[i].expected_rect, result_safe);
+  }
+}
+
+#if defined(OS_WIN)
+TEST(RectTest, ConstructAndAssign) {
+  const RECT rect_1 = { 0, 0, 10, 10 };
+  const RECT rect_2 = { 0, 0, -10, -10 };
+  Rect test1(rect_1);
+  Rect test2(rect_2);
+}
+#endif
+
+TEST(RectTest, ToRectF) {
+  // Check that explicit conversion from integer to float compiles.
+  Rect a(10, 20, 30, 40);
+  RectF b(10, 20, 30, 40);
+
+  RectF c = RectF(a);
+  EXPECT_EQ(b, c);
+}
+
+TEST(RectTest, BoundingRect) {
+  struct {
+    Point a;
+    Point b;
+    Rect expected;
+  } int_tests[] = {
+    // If point B dominates A, then A should be the origin.
+    { Point(4, 6), Point(4, 6), Rect(4, 6, 0, 0) },
+    { Point(4, 6), Point(8, 6), Rect(4, 6, 4, 0) },
+    { Point(4, 6), Point(4, 9), Rect(4, 6, 0, 3) },
+    { Point(4, 6), Point(8, 9), Rect(4, 6, 4, 3) },
+    // If point A dominates B, then B should be the origin.
+    { Point(4, 6), Point(4, 6), Rect(4, 6, 0, 0) },
+    { Point(8, 6), Point(4, 6), Rect(4, 6, 4, 0) },
+    { Point(4, 9), Point(4, 6), Rect(4, 6, 0, 3) },
+    { Point(8, 9), Point(4, 6), Rect(4, 6, 4, 3) },
+    // If neither point dominates, then the origin is a combination of the two.
+    { Point(4, 6), Point(6, 4), Rect(4, 4, 2, 2) },
+    { Point(-4, -6), Point(-6, -4), Rect(-6, -6, 2, 2) },
+    { Point(-4, 6), Point(6, -4), Rect(-4, -4, 10, 10) },
+  };
+
+  for (size_t i = 0; i < base::size(int_tests); ++i) {
+    Rect actual = BoundingRect(int_tests[i].a, int_tests[i].b);
+    EXPECT_EQ(int_tests[i].expected, actual);
+  }
+
+  struct {
+    PointF a;
+    PointF b;
+    RectF expected;
+  } float_tests[] = {
+    // If point B dominates A, then A should be the origin.
+    { PointF(4.2f, 6.8f), PointF(4.2f, 6.8f),
+      RectF(4.2f, 6.8f, 0, 0) },
+    { PointF(4.2f, 6.8f), PointF(8.5f, 6.8f),
+      RectF(4.2f, 6.8f, 4.3f, 0) },
+    { PointF(4.2f, 6.8f), PointF(4.2f, 9.3f),
+      RectF(4.2f, 6.8f, 0, 2.5f) },
+    { PointF(4.2f, 6.8f), PointF(8.5f, 9.3f),
+      RectF(4.2f, 6.8f, 4.3f, 2.5f) },
+    // If point A dominates B, then B should be the origin.
+    { PointF(4.2f, 6.8f), PointF(4.2f, 6.8f),
+      RectF(4.2f, 6.8f, 0, 0) },
+    { PointF(8.5f, 6.8f), PointF(4.2f, 6.8f),
+      RectF(4.2f, 6.8f, 4.3f, 0) },
+    { PointF(4.2f, 9.3f), PointF(4.2f, 6.8f),
+      RectF(4.2f, 6.8f, 0, 2.5f) },
+    { PointF(8.5f, 9.3f), PointF(4.2f, 6.8f),
+      RectF(4.2f, 6.8f, 4.3f, 2.5f) },
+    // If neither point dominates, then the origin is a combination of the two.
+    { PointF(4.2f, 6.8f), PointF(6.8f, 4.2f),
+      RectF(4.2f, 4.2f, 2.6f, 2.6f) },
+    { PointF(-4.2f, -6.8f), PointF(-6.8f, -4.2f),
+      RectF(-6.8f, -6.8f, 2.6f, 2.6f) },
+    { PointF(-4.2f, 6.8f), PointF(6.8f, -4.2f),
+      RectF(-4.2f, -4.2f, 11.0f, 11.0f) }
+  };
+
+  for (size_t i = 0; i < base::size(float_tests); ++i) {
+    RectF actual = BoundingRect(float_tests[i].a, float_tests[i].b);
+    EXPECT_RECTF_EQ(float_tests[i].expected, actual);
+  }
+}
+
+TEST(RectTest, IsExpressibleAsRect) {
+  EXPECT_TRUE(RectF().IsExpressibleAsRect());
+
+  float min = std::numeric_limits<int>::min();
+  float max = static_cast<float>(std::numeric_limits<int>::max());
+  float infinity = std::numeric_limits<float>::infinity();
+
+  EXPECT_TRUE(RectF(
+      min + 200, min + 200, max - 200, max - 200).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(
+      min - 200, min + 200, max + 200, max + 200).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(
+      min + 200 , min - 200, max + 200, max + 200).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(
+      min + 200, min + 200, max + 200, max - 200).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(
+      min + 200, min + 200, max - 200, max + 200).IsExpressibleAsRect());
+
+  EXPECT_TRUE(RectF(0, 0, max - 200, max - 200).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(200, 0, max + 200, max - 200).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(0, 200, max - 200, max + 200).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(0, 0, max + 200, max - 200).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(0, 0, max - 200, max + 200).IsExpressibleAsRect());
+
+  EXPECT_FALSE(RectF(infinity, 0, 1, 1).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(0, infinity, 1, 1).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(0, 0, infinity, 1).IsExpressibleAsRect());
+  EXPECT_FALSE(RectF(0, 0, 1, infinity).IsExpressibleAsRect());
+}
+
+TEST(RectTest, Offset) {
+  Rect i(1, 2, 3, 4);
+
+  EXPECT_EQ(Rect(2, 1, 3, 4), (i + Vector2d(1, -1)));
+  EXPECT_EQ(Rect(2, 1, 3, 4), (Vector2d(1, -1) + i));
+  i += Vector2d(1, -1);
+  EXPECT_EQ(Rect(2, 1, 3, 4), i);
+  EXPECT_EQ(Rect(1, 2, 3, 4), (i - Vector2d(1, -1)));
+  i -= Vector2d(1, -1);
+  EXPECT_EQ(Rect(1, 2, 3, 4), i);
+
+  i.Offset(2, -2);
+  EXPECT_EQ(Rect(3, 0, 3, 4), i);
+
+  RectF f(1.1f, 2.2f, 3.3f, 4.4f);
+  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), (f + Vector2dF(1.1f, -1.1f)));
+  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), (Vector2dF(1.1f, -1.1f) + f));
+  f += Vector2dF(1.1f, -1.1f);
+  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), f);
+  EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f), (f - Vector2dF(1.1f, -1.1f)));
+  f -= Vector2dF(1.1f, -1.1f);
+  EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f), f);
+}
+
+TEST(RectTest, Corners) {
+  Rect i(1, 2, 3, 4);
+  RectF f(1.1f, 2.1f, 3.1f, 4.1f);
+
+  EXPECT_EQ(Point(1, 2), i.origin());
+  EXPECT_EQ(Point(4, 2), i.top_right());
+  EXPECT_EQ(Point(1, 6), i.bottom_left());
+  EXPECT_EQ(Point(4, 6), i.bottom_right());
+
+  EXPECT_EQ(PointF(1.1f, 2.1f), f.origin());
+  EXPECT_EQ(PointF(4.2f, 2.1f), f.top_right());
+  EXPECT_EQ(PointF(1.1f, 6.2f), f.bottom_left());
+  EXPECT_EQ(PointF(4.2f, 6.2f), f.bottom_right());
+}
+
+TEST(RectTest, Centers) {
+  Rect i(10, 20, 30, 40);
+  EXPECT_EQ(Point(10, 40), i.left_center());
+  EXPECT_EQ(Point(25, 20), i.top_center());
+  EXPECT_EQ(Point(40, 40), i.right_center());
+  EXPECT_EQ(Point(25, 60), i.bottom_center());
+
+  RectF f(10.1f, 20.2f, 30.3f, 40.4f);
+  EXPECT_EQ(PointF(10.1f, 40.4f), f.left_center());
+  EXPECT_EQ(PointF(25.25f, 20.2f), f.top_center());
+  EXPECT_EQ(PointF(40.4f, 40.4f), f.right_center());
+  EXPECT_EQ(25.25f, f.bottom_center().x());
+  EXPECT_NEAR(60.6f, f.bottom_center().y(), 0.001f);
+}
+
+TEST(RectTest, Transpose) {
+  Rect i(10, 20, 30, 40);
+  i.Transpose();
+  EXPECT_EQ(Rect(20, 10, 40, 30), i);
+
+  RectF f(10.1f, 20.2f, 30.3f, 40.4f);
+  f.Transpose();
+  EXPECT_EQ(RectF(20.2f, 10.1f, 40.4f, 30.3f), f);
+}
+
+TEST(RectTest, ManhattanDistanceToPoint) {
+  Rect i(1, 2, 3, 4);
+  EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(1, 2)));
+  EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(4, 6)));
+  EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(2, 4)));
+  EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(0, 0)));
+  EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(2, 0)));
+  EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(5, 0)));
+  EXPECT_EQ(1, i.ManhattanDistanceToPoint(Point(5, 4)));
+  EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(5, 8)));
+  EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(3, 8)));
+  EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(0, 7)));
+  EXPECT_EQ(1, i.ManhattanDistanceToPoint(Point(0, 3)));
+
+  RectF f(1.1f, 2.1f, 3.1f, 4.1f);
+  EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(1.1f, 2.1f)));
+  EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(4.2f, 6.f)));
+  EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(2.f, 4.f)));
+  EXPECT_FLOAT_EQ(3.2f, f.ManhattanDistanceToPoint(PointF(0.f, 0.f)));
+  EXPECT_FLOAT_EQ(2.1f, f.ManhattanDistanceToPoint(PointF(2.f, 0.f)));
+  EXPECT_FLOAT_EQ(2.9f, f.ManhattanDistanceToPoint(PointF(5.f, 0.f)));
+  EXPECT_FLOAT_EQ(.8f, f.ManhattanDistanceToPoint(PointF(5.f, 4.f)));
+  EXPECT_FLOAT_EQ(2.6f, f.ManhattanDistanceToPoint(PointF(5.f, 8.f)));
+  EXPECT_FLOAT_EQ(1.8f, f.ManhattanDistanceToPoint(PointF(3.f, 8.f)));
+  EXPECT_FLOAT_EQ(1.9f, f.ManhattanDistanceToPoint(PointF(0.f, 7.f)));
+  EXPECT_FLOAT_EQ(1.1f, f.ManhattanDistanceToPoint(PointF(0.f, 3.f)));
+}
+
+TEST(RectTest, ManhattanInternalDistance) {
+  Rect i(0, 0, 400, 400);
+  EXPECT_EQ(0, i.ManhattanInternalDistance(gfx::Rect(-1, 0, 2, 1)));
+  EXPECT_EQ(1, i.ManhattanInternalDistance(gfx::Rect(400, 0, 1, 400)));
+  EXPECT_EQ(2, i.ManhattanInternalDistance(gfx::Rect(-100, -100, 100, 100)));
+  EXPECT_EQ(2, i.ManhattanInternalDistance(gfx::Rect(-101, 100, 100, 100)));
+  EXPECT_EQ(4, i.ManhattanInternalDistance(gfx::Rect(-101, -101, 100, 100)));
+  EXPECT_EQ(435, i.ManhattanInternalDistance(gfx::Rect(630, 603, 100, 100)));
+
+  RectF f(0.0f, 0.0f, 400.0f, 400.0f);
+  static const float kEpsilon = std::numeric_limits<float>::epsilon();
+
+  EXPECT_FLOAT_EQ(
+      0.0f, f.ManhattanInternalDistance(gfx::RectF(-1.0f, 0.0f, 2.0f, 1.0f)));
+  EXPECT_FLOAT_EQ(
+      kEpsilon,
+      f.ManhattanInternalDistance(gfx::RectF(400.0f, 0.0f, 1.0f, 400.0f)));
+  EXPECT_FLOAT_EQ(2.0f * kEpsilon,
+                  f.ManhattanInternalDistance(
+                      gfx::RectF(-100.0f, -100.0f, 100.0f, 100.0f)));
+  EXPECT_FLOAT_EQ(
+      1.0f + kEpsilon,
+      f.ManhattanInternalDistance(gfx::RectF(-101.0f, 100.0f, 100.0f, 100.0f)));
+  EXPECT_FLOAT_EQ(2.0f + 2.0f * kEpsilon,
+                  f.ManhattanInternalDistance(
+                      gfx::RectF(-101.0f, -101.0f, 100.0f, 100.0f)));
+  EXPECT_FLOAT_EQ(
+      433.0f + 2.0f * kEpsilon,
+      f.ManhattanInternalDistance(gfx::RectF(630.0f, 603.0f, 100.0f, 100.0f)));
+
+  EXPECT_FLOAT_EQ(
+      0.0f, f.ManhattanInternalDistance(gfx::RectF(-1.0f, 0.0f, 1.1f, 1.0f)));
+  EXPECT_FLOAT_EQ(
+      0.1f + kEpsilon,
+      f.ManhattanInternalDistance(gfx::RectF(-1.5f, 0.0f, 1.4f, 1.0f)));
+  EXPECT_FLOAT_EQ(
+      kEpsilon,
+      f.ManhattanInternalDistance(gfx::RectF(-1.5f, 0.0f, 1.5f, 1.0f)));
+}
+
+TEST(RectTest, IntegerOverflow) {
+  int limit = std::numeric_limits<int>::max();
+  int min_limit = std::numeric_limits<int>::min();
+  int expected_thickness = 10;
+  int large_number = limit - expected_thickness;
+
+  Rect height_overflow(0, large_number, 100, 100);
+  EXPECT_EQ(large_number, height_overflow.y());
+  EXPECT_EQ(expected_thickness, height_overflow.height());
+
+  Rect width_overflow(large_number, 0, 100, 100);
+  EXPECT_EQ(large_number, width_overflow.x());
+  EXPECT_EQ(expected_thickness, width_overflow.width());
+
+  Rect size_height_overflow(Point(0, large_number), Size(100, 100));
+  EXPECT_EQ(large_number, size_height_overflow.y());
+  EXPECT_EQ(expected_thickness, size_height_overflow.height());
+
+  Rect size_width_overflow(Point(large_number, 0), Size(100, 100));
+  EXPECT_EQ(large_number, size_width_overflow.x());
+  EXPECT_EQ(expected_thickness, size_width_overflow.width());
+
+  Rect set_height_overflow(0, large_number, 100, 5);
+  EXPECT_EQ(5, set_height_overflow.height());
+  set_height_overflow.set_height(100);
+  EXPECT_EQ(expected_thickness, set_height_overflow.height());
+
+  Rect set_y_overflow(100, 100, 100, 100);
+  EXPECT_EQ(100, set_y_overflow.height());
+  set_y_overflow.set_y(large_number);
+  EXPECT_EQ(expected_thickness, set_y_overflow.height());
+
+  Rect set_width_overflow(large_number, 0, 5, 100);
+  EXPECT_EQ(5, set_width_overflow.width());
+  set_width_overflow.set_width(100);
+  EXPECT_EQ(expected_thickness, set_width_overflow.width());
+
+  Rect set_x_overflow(100, 100, 100, 100);
+  EXPECT_EQ(100, set_x_overflow.width());
+  set_x_overflow.set_x(large_number);
+  EXPECT_EQ(expected_thickness, set_x_overflow.width());
+
+  Point large_offset(large_number, large_number);
+  Size size(100, 100);
+  Size expected_size(10, 10);
+
+  Rect set_origin_overflow(100, 100, 100, 100);
+  EXPECT_EQ(size, set_origin_overflow.size());
+  set_origin_overflow.set_origin(large_offset);
+  EXPECT_EQ(large_offset, set_origin_overflow.origin());
+  EXPECT_EQ(expected_size, set_origin_overflow.size());
+
+  Rect set_size_overflow(large_number, large_number, 5, 5);
+  EXPECT_EQ(Size(5, 5), set_size_overflow.size());
+  set_size_overflow.set_size(size);
+  EXPECT_EQ(large_offset, set_size_overflow.origin());
+  EXPECT_EQ(expected_size, set_size_overflow.size());
+
+  Rect set_rect_overflow;
+  set_rect_overflow.SetRect(large_number, large_number, 100, 100);
+  EXPECT_EQ(large_offset, set_rect_overflow.origin());
+  EXPECT_EQ(expected_size, set_rect_overflow.size());
+
+  // Insetting an empty rect, but the total inset (left + right) could overflow.
+  Rect inset_overflow;
+  inset_overflow.Inset(large_number, large_number, 100, 100);
+  EXPECT_EQ(large_offset, inset_overflow.origin());
+  EXPECT_EQ(gfx::Size(), inset_overflow.size());
+
+  // Insetting where the total inset (width - left - right) could overflow.
+  // Also, this insetting by the min limit in all directions cannot
+  // represent width() without overflow, so that will also clamp.
+  Rect inset_overflow2;
+  inset_overflow2.Inset(min_limit, min_limit, min_limit, min_limit);
+  EXPECT_EQ(inset_overflow2, gfx::Rect(min_limit, min_limit, limit, limit));
+
+  // Insetting where the width shouldn't change, but if the insets operations
+  // clamped in the wrong order, e.g. ((width - left) - right) vs (width - (left
+  // + right)) then this will not work properly.  This is the proper order,
+  // as if left + right overflows, the width cannot be decreased by more than
+  // max int anyway.  Additionally, if left + right underflows, it cannot be
+  // increased by more then max int.
+  Rect inset_overflow3(0, 0, limit, limit);
+  inset_overflow3.Inset(-100, -100, 100, 100);
+  EXPECT_EQ(inset_overflow3, gfx::Rect(-100, -100, limit, limit));
+
+  Rect inset_overflow4(-1000, -1000, limit, limit);
+  inset_overflow4.Inset(100, 100, -100, -100);
+  EXPECT_EQ(inset_overflow4, gfx::Rect(-900, -900, limit, limit));
+
+  Rect offset_overflow(0, 0, 100, 100);
+  offset_overflow.Offset(large_number, large_number);
+  EXPECT_EQ(large_offset, offset_overflow.origin());
+  EXPECT_EQ(expected_size, offset_overflow.size());
+
+  Rect operator_overflow(0, 0, 100, 100);
+  operator_overflow += Vector2d(large_number, large_number);
+  EXPECT_EQ(large_offset, operator_overflow.origin());
+  EXPECT_EQ(expected_size, operator_overflow.size());
+
+  Rect origin_maxint(limit, limit, limit, limit);
+  EXPECT_EQ(origin_maxint, Rect(gfx::Point(limit, limit), gfx::Size()));
+
+  // Expect a rect at the origin and a rect whose right/bottom is maxint
+  // create a rect that extends from 0..maxint in both extents.
+  {
+    Rect origin_small(0, 0, 100, 100);
+    Rect big_clamped(50, 50, limit, limit);
+    EXPECT_EQ(big_clamped.right(), limit);
+
+    Rect unioned = UnionRects(origin_small, big_clamped);
+    Rect rect_limit(0, 0, limit, limit);
+    EXPECT_EQ(unioned, rect_limit);
+  }
+
+  // Expect a rect that would overflow width (but not right) to be clamped
+  // and to have maxint extents after unioning.
+  {
+    Rect small(-500, -400, 100, 100);
+    Rect big(-400, -500, limit, limit);
+    // Technically, this should be limit + 100 width, but will clamp to maxint.
+    EXPECT_EQ(UnionRects(small, big), Rect(-500, -500, limit, limit));
+  }
+
+  // Expect a rect that would overflow right *and* width to be clamped.
+  {
+    Rect clamped(500, 500, limit, limit);
+    Rect positive_origin(100, 100, 500, 500);
+
+    // Ideally, this should be (100, 100, limit + 400, limit + 400).
+    // However, width overflows and would be clamped to limit, but right
+    // overflows too and so will be clamped to limit - 100.
+    Rect expected_rect(100, 100, limit - 100, limit - 100);
+    EXPECT_EQ(UnionRects(clamped, positive_origin), expected_rect);
+  }
+
+  // Unioning a left=minint rect with a right=maxint rect.
+  // We can't represent both ends of the spectrum in the same rect.
+  // Make sure we keep the most useful area.
+  {
+    int part_limit = min_limit / 3;
+    Rect left_minint(min_limit, min_limit, 1, 1);
+    Rect right_maxint(limit - 1, limit - 1, limit, limit);
+    Rect expected_rect(part_limit, part_limit, 2 * part_limit, 2 * part_limit);
+    Rect result = UnionRects(left_minint, right_maxint);
+
+    // The result should be maximally big.
+    EXPECT_EQ(limit, result.height());
+    EXPECT_EQ(limit, result.width());
+
+    // The result should include the area near the origin.
+    EXPECT_GT(-part_limit, result.x());
+    EXPECT_LT(part_limit, result.right());
+    EXPECT_GT(-part_limit, result.y());
+    EXPECT_LT(part_limit, result.bottom());
+
+    // More succinctly, but harder to read in the results.
+    EXPECT_TRUE(UnionRects(left_minint, right_maxint).Contains(expected_rect));
+  }
+}
+
+TEST(RectTest, ScaleToEnclosingRectSafe) {
+  constexpr int kMaxInt = std::numeric_limits<int>::max();
+  constexpr int kMinInt = std::numeric_limits<int>::min();
+
+  Rect xy_underflow(-100000, -123456, 10, 20);
+  EXPECT_EQ(ScaleToEnclosingRectSafe(xy_underflow, 100000),
+            Rect(kMinInt, kMinInt, 1000000, 2000000));
+
+  // A location overflow means that width/right and bottom/top also
+  // overflow so need to be clamped.
+  Rect xy_overflow(100000, 123456, 10, 20);
+  EXPECT_EQ(ScaleToEnclosingRectSafe(xy_overflow, 100000),
+            Rect(kMaxInt, kMaxInt, 0, 0));
+
+  // In practice all rects are clamped to 0 width / 0 height so
+  // negative sizes don't matter, but try this for the sake of testing.
+  Rect size_underflow(-1, -2, 100000, 100000);
+  EXPECT_EQ(ScaleToEnclosingRectSafe(size_underflow, -100000),
+            Rect(100000, 200000, 0, 0));
+
+  Rect size_overflow(-1, -2, 123456, 234567);
+  EXPECT_EQ(ScaleToEnclosingRectSafe(size_overflow, 100000),
+            Rect(-100000, -200000, kMaxInt, kMaxInt));
+  // Verify width/right gets clamped properly too if x/y positive.
+  Rect size_overflow2(1, 2, 123456, 234567);
+  EXPECT_EQ(ScaleToEnclosingRectSafe(size_overflow2, 100000),
+            Rect(100000, 200000, kMaxInt - 100000, kMaxInt - 200000));
+
+  Rect max_rect(kMaxInt, kMaxInt, kMaxInt, kMaxInt);
+  EXPECT_EQ(ScaleToEnclosingRectSafe(max_rect, static_cast<float>(kMaxInt)),
+            Rect(kMaxInt, kMaxInt, 0, 0));
+
+  Rect min_rect(kMinInt, kMinInt, kMaxInt, kMaxInt);
+  // Min rect can't be scaled up any further in any dimension.
+  EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, 2, 3.5), min_rect);
+  EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, static_cast<float>(kMaxInt)),
+            min_rect);
+  // Min rect scaled by min is an empty rect at (max, max)
+  EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, kMinInt), max_rect);
+}
+
+TEST(RectTest, Inset) {
+  Rect r(10, 20, 30, 40);
+  r.Inset(0);
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+  r.Inset(1);
+  EXPECT_EQ(Rect(11, 21, 28, 38), r);
+  r.Inset(-1);
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+
+  r.Inset(1, 2);
+  EXPECT_EQ(Rect(11, 22, 28, 36), r);
+  r.Inset(-1, -2);
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+
+  // The parameters are left, top, right, bottom.
+  r.Inset(1, 2, 3, 4);
+  EXPECT_EQ(Rect(11, 22, 26, 34), r);
+  r.Inset(-1, -2, -3, -4);
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+
+  // Insets parameters are top, right, bottom, left.
+  r.Inset(Insets(1, 2, 3, 4));
+  EXPECT_EQ(Rect(12, 21, 24, 36), r);
+  r.Inset(Insets(-1, -2, -3, -4));
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+}
+
+TEST(RectTest, Outset) {
+  Rect r(10, 20, 30, 40);
+  r.Outset(0);
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+  r.Outset(1);
+  EXPECT_EQ(Rect(9, 19, 32, 42), r);
+  r.Outset(-1);
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+
+  r.Outset(1, 2);
+  EXPECT_EQ(Rect(9, 18, 32, 44), r);
+  r.Outset(-1, -2);
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+
+  r.Outset(1, 2, 3, 4);
+  EXPECT_EQ(Rect(9, 18, 34, 46), r);
+  r.Outset(-1, -2, -3, -4);
+  EXPECT_EQ(Rect(10, 20, 30, 40), r);
+}
+
+TEST(RectTest, InsetOutsetClamped) {
+  Rect r(10, 20, 30, 40);
+  r.Inset(18);
+  EXPECT_EQ(Rect(28, 38, 0, 4), r);
+  r.Inset(-18);
+  EXPECT_EQ(Rect(10, 20, 36, 40), r);
+
+  r.Inset(15, 30);
+  EXPECT_EQ(Rect(25, 50, 6, 0), r);
+  r.Inset(-15, -30);
+  EXPECT_EQ(Rect(10, 20, 36, 60), r);
+
+  r.Inset(20, 30, 40, 50);
+  EXPECT_EQ(Rect(30, 50, 0, 0), r);
+  r.Inset(-20, -30, -40, -50);
+  EXPECT_EQ(Rect(10, 20, 60, 80), r);
+
+  constexpr int kMaxInt = std::numeric_limits<int>::max();
+  constexpr int kMinInt = std::numeric_limits<int>::min();
+  r.Outset(kMaxInt);
+  EXPECT_EQ(Rect(10 - kMaxInt, 20 - kMaxInt, kMaxInt, kMaxInt), r);
+  r.Outset(0, kMaxInt);
+  EXPECT_EQ(Rect(10 - kMaxInt, kMinInt, kMaxInt, kMaxInt), r);
+  r.Outset(0, kMaxInt, kMaxInt, 0);
+  EXPECT_EQ(Rect(10 - kMaxInt, kMinInt, kMaxInt, kMaxInt), r);
+  r.Outset(kMaxInt, 0, kMaxInt, 0);
+  EXPECT_EQ(Rect(kMinInt, kMinInt, kMaxInt, kMaxInt), r);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/resize_utils.cc b/ui/gfx/geometry/resize_utils.cc
new file mode 100644
index 0000000..73c0ccf
--- /dev/null
+++ b/ui/gfx/geometry/resize_utils.cc
@@ -0,0 +1,112 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/geometry/resize_utils.h"
+
+#include "base/check_op.h"
+#include "base/cxx17_backports.h"
+#include "base/numerics/safe_conversions.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace gfx {
+namespace {
+
+// This function decides whether SizeRectToAspectRatio() will adjust the height
+// to match the specified width (resizing horizontally) or vice versa (resizing
+// vertically).
+bool IsResizingHorizontally(ResizeEdge resize_edge) {
+  switch (resize_edge) {
+    case ResizeEdge::kLeft:
+    case ResizeEdge::kRight:
+    case ResizeEdge::kTopLeft:
+    case ResizeEdge::kBottomLeft:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace
+
+void SizeRectToAspectRatio(ResizeEdge resize_edge,
+                           float aspect_ratio,
+                           const Size& min_window_size,
+                           const Size& max_window_size,
+                           Rect* rect) {
+  DCHECK_GT(aspect_ratio, 0.0f);
+  DCHECK_GE(max_window_size.width(), min_window_size.width());
+  DCHECK_GE(max_window_size.height(), min_window_size.height());
+  DCHECK(rect->Contains(Rect(rect->origin(), min_window_size)))
+      << rect->ToString() << " is smaller than the minimum size "
+      << min_window_size.ToString();
+  DCHECK(Rect(rect->origin(), max_window_size).Contains(*rect))
+      << rect->ToString() << " is larger than the maximum size "
+      << max_window_size.ToString();
+
+  Size new_size = rect->size();
+  if (IsResizingHorizontally(resize_edge)) {
+    new_size.set_height(base::ClampRound(new_size.width() / aspect_ratio));
+    if (min_window_size.height() > new_size.height() ||
+        new_size.height() > max_window_size.height()) {
+      new_size.set_height(base::clamp(new_size.height(),
+                                      min_window_size.height(),
+                                      max_window_size.height()));
+      new_size.set_width(base::ClampRound(new_size.height() * aspect_ratio));
+    }
+  } else {
+    new_size.set_width(base::ClampRound(new_size.height() * aspect_ratio));
+    if (min_window_size.width() > new_size.width() ||
+        new_size.width() > max_window_size.width()) {
+      new_size.set_width(base::clamp(new_size.width(), min_window_size.width(),
+                                     max_window_size.width()));
+      new_size.set_height(base::ClampRound(new_size.width() / aspect_ratio));
+    }
+  }
+
+  // The dimensions might still be outside of the allowed ranges at this point.
+  // This happens when the aspect ratio makes it impossible to fit |rect|
+  // within the size limits without letter-/pillarboxing.
+  new_size.SetToMin(max_window_size);
+  new_size.SetToMax(min_window_size);
+
+  // |rect| bounds before sizing to aspect ratio.
+  int left = rect->x();
+  int top = rect->y();
+  int right = rect->right();
+  int bottom = rect->bottom();
+
+  switch (resize_edge) {
+    case ResizeEdge::kRight:
+    case ResizeEdge::kBottom:
+      right = new_size.width() + left;
+      bottom = top + new_size.height();
+      break;
+    case ResizeEdge::kTop:
+      right = new_size.width() + left;
+      top = bottom - new_size.height();
+      break;
+    case ResizeEdge::kLeft:
+    case ResizeEdge::kTopLeft:
+      left = right - new_size.width();
+      top = bottom - new_size.height();
+      break;
+    case ResizeEdge::kTopRight:
+      right = left + new_size.width();
+      top = bottom - new_size.height();
+      break;
+    case ResizeEdge::kBottomLeft:
+      left = right - new_size.width();
+      bottom = top + new_size.height();
+      break;
+    case ResizeEdge::kBottomRight:
+      right = left + new_size.width();
+      bottom = top + new_size.height();
+      break;
+  }
+
+  rect->SetByBounds(left, top, right, bottom);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/resize_utils.h b/ui/gfx/geometry/resize_utils.h
new file mode 100644
index 0000000..318a31b
--- /dev/null
+++ b/ui/gfx/geometry/resize_utils.h
@@ -0,0 +1,41 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_RESIZE_UTILS_H_
+#define UI_GFX_GEOMETRY_RESIZE_UTILS_H_
+
+#include "ui/gfx/geometry/geometry_export.h"
+
+namespace gfx {
+
+class Rect;
+class Size;
+
+enum class ResizeEdge {
+  kBottom,
+  kBottomLeft,
+  kBottomRight,
+  kLeft,
+  kRight,
+  kTop,
+  kTopLeft,
+  kTopRight
+};
+
+// Updates |rect| to adhere to the |aspect_ratio| of the window, if it has
+// been set. |resize_edge| refers to the edge of the window being sized.
+// |min_window_size| and |max_window_size| are expected to adhere to the
+// given aspect ratio.
+// |aspect_ratio| must be valid and is found using width / height.
+// TODO(apacible): |max_window_size| is expected to be non-empty. Handle
+// unconstrained max sizes and sizing when windows are maximized.
+void GEOMETRY_EXPORT SizeRectToAspectRatio(ResizeEdge resize_edge,
+                                           float aspect_ratio,
+                                           const Size& min_window_size,
+                                           const Size& max_window_size,
+                                           Rect* rect);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_RESIZE_UTILS_H_
diff --git a/ui/gfx/geometry/resize_utils_unittest.cc b/ui/gfx/geometry/resize_utils_unittest.cc
new file mode 100644
index 0000000..bf1e90b
--- /dev/null
+++ b/ui/gfx/geometry/resize_utils_unittest.cc
@@ -0,0 +1,181 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/geometry/resize_utils.h"
+
+#include <string>
+
+#include "base/strings/strcat.h"
+#include "base/strings/string_number_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace gfx {
+namespace {
+
+// Aspect ratio is defined by width / height.
+constexpr float kAspectRatioSquare = 1.0f;
+constexpr float kAspectRatioHorizontal = 2.0f;
+constexpr float kAspectRatioVertical = 0.5f;
+
+constexpr Size kMinSizeHorizontal(20, 10);
+constexpr Size kMaxSizeHorizontal(50, 25);
+
+constexpr Size kMinSizeVertical(10, 20);
+constexpr Size kMaxSizeVertical(25, 50);
+
+std::string HitTestToString(ResizeEdge resize_edge) {
+  switch (resize_edge) {
+    case ResizeEdge::kTop:
+      return "top";
+    case ResizeEdge::kTopRight:
+      return "top-righ";
+    case ResizeEdge::kRight:
+      return "right";
+    case ResizeEdge::kBottomRight:
+      return "bottom-right";
+    case ResizeEdge::kBottom:
+      return "bottom";
+    case ResizeEdge::kBottomLeft:
+      return "bottom-left";
+    case ResizeEdge::kLeft:
+      return "left";
+    case ResizeEdge::kTopLeft:
+      return "top-left";
+  }
+}
+
+}  // namespace
+
+struct SizingParams {
+  ResizeEdge resize_edge{};
+  float aspect_ratio = 0.0f;
+  Size min_size;
+  Size max_size;
+  Rect input_rect;
+  Rect expected_output_rect;
+
+  std::string ToString() const {
+    return base::StrCat({HitTestToString(resize_edge),
+                         " ratio=", base::NumberToString(aspect_ratio), " [",
+                         min_size.ToString(), "..", max_size.ToString(), "] ",
+                         input_rect.ToString(), " -> ",
+                         expected_output_rect.ToString()});
+  }
+};
+
+using ResizeUtilsTest = testing::TestWithParam<SizingParams>;
+
+TEST_P(ResizeUtilsTest, SizeRectToAspectRatio) {
+  Rect rect = GetParam().input_rect;
+  SizeRectToAspectRatio(GetParam().resize_edge, GetParam().aspect_ratio,
+                        GetParam().min_size, GetParam().max_size, &rect);
+  EXPECT_EQ(rect, GetParam().expected_output_rect) << GetParam().ToString();
+}
+
+const SizingParams kSizeRectToSquareAspectRatioTestCases[] = {
+    // Dragging the top resizer up.
+    {ResizeEdge::kTop, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(100, 98, 22, 24), Rect(100, 98, 24, 24)},
+
+    // Dragging the bottom resizer down.
+    {ResizeEdge::kBottom, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(100, 100, 22, 24), Rect(100, 100, 24, 24)},
+
+    // Dragging the left resizer right.
+    {ResizeEdge::kLeft, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(102, 100, 22, 24), Rect(102, 102, 22, 22)},
+
+    // Dragging the right resizer left.
+    {ResizeEdge::kRight, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(100, 100, 22, 24), Rect(100, 100, 22, 22)},
+
+    // Dragging the top-left resizer right.
+    {ResizeEdge::kTopLeft, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(102, 100, 22, 24), Rect(102, 102, 22, 22)},
+
+    // Dragging the top-right resizer down.
+    {ResizeEdge::kTopRight, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(100, 102, 24, 22), Rect(100, 102, 22, 22)},
+
+    // Dragging the bottom-left resizer right.
+    {ResizeEdge::kBottomLeft, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(100, 102, 22, 24), Rect(100, 102, 22, 22)},
+
+    // Dragging the bottom-right resizer up.
+    {ResizeEdge::kBottomRight, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(100, 100, 24, 22), Rect(100, 100, 22, 22)},
+
+    // Dragging the bottom-right resizer left.
+    // Rect already as small as `kMinSizeHorizontal` allows.
+    {ResizeEdge::kBottomRight, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal,
+     Rect(100, 100, kMinSizeHorizontal.width(), kMinSizeHorizontal.width()),
+     Rect(100, 100, kMinSizeHorizontal.width(), kMinSizeHorizontal.width())},
+
+    // Dragging the top-left resizer left.
+    // Rect already as large as `kMaxSizeHorizontal` allows.
+    {ResizeEdge::kTopLeft, kAspectRatioSquare, kMinSizeHorizontal,
+     kMaxSizeHorizontal,
+     Rect(100, 100, kMaxSizeHorizontal.height(), kMaxSizeHorizontal.height()),
+     Rect(100, 100, kMaxSizeHorizontal.height(), kMaxSizeHorizontal.height())},
+};
+
+const SizingParams kSizeRectToHorizontalAspectRatioTestCases[] = {
+    // Dragging the top resizer down.
+    {ResizeEdge::kTop, kAspectRatioHorizontal, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(100, 102, 48, 22), Rect(100, 102, 44, 22)},
+
+    // Dragging the left resizer left.
+    {ResizeEdge::kLeft, kAspectRatioHorizontal, kMinSizeHorizontal,
+     kMaxSizeHorizontal, Rect(96, 100, 48, 22), Rect(96, 98, 48, 24)},
+
+    // Rect already as small as `kMinSizeHorizontal` allows.
+    {ResizeEdge::kTop, kAspectRatioHorizontal, kMinSizeHorizontal,
+     kMaxSizeHorizontal,
+     Rect(100, 100, kMinSizeHorizontal.width(), kMinSizeHorizontal.height()),
+     Rect(100, 100, kMinSizeHorizontal.width(), kMinSizeHorizontal.height())},
+
+    // Rect already as large as `kMaxSizeHorizontal` allows.
+    {ResizeEdge::kTop, kAspectRatioHorizontal, kMinSizeHorizontal,
+     kMaxSizeHorizontal,
+     Rect(100, 100, kMaxSizeHorizontal.width(), kMaxSizeHorizontal.height()),
+     Rect(100, 100, kMaxSizeHorizontal.width(), kMaxSizeHorizontal.height())},
+};
+
+const SizingParams kSizeRectToVerticalAspectRatioTestCases[] = {
+    // Dragging the bottom resizer up.
+    {ResizeEdge::kBottom, kAspectRatioVertical, kMinSizeVertical,
+     kMaxSizeVertical, Rect(100, 100, 24, 44), Rect(100, 100, 22, 44)},
+
+    // Dragging the right resizer right.
+    {ResizeEdge::kRight, kAspectRatioVertical, kMinSizeVertical,
+     kMaxSizeVertical, Rect(100, 100, 24, 44), Rect(100, 100, 24, 48)},
+
+    // Rect already as small as `kMinSizeVertical` allows.
+    {ResizeEdge::kTop, kAspectRatioVertical, kMinSizeVertical, kMaxSizeVertical,
+     Rect(100, 100, kMinSizeVertical.width(), kMinSizeVertical.height()),
+     Rect(100, 100, kMinSizeVertical.width(), kMinSizeVertical.height())},
+
+    // Rect already as large as `kMaxSizeVertical` allows.
+    {ResizeEdge::kTop, kAspectRatioVertical, kMinSizeVertical, kMaxSizeVertical,
+     Rect(100, 100, kMaxSizeVertical.width(), kMaxSizeVertical.height()),
+     Rect(100, 100, kMaxSizeVertical.width(), kMaxSizeVertical.height())},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    Square,
+    ResizeUtilsTest,
+    testing::ValuesIn(kSizeRectToSquareAspectRatioTestCases));
+INSTANTIATE_TEST_SUITE_P(
+    Horizontal,
+    ResizeUtilsTest,
+    testing::ValuesIn(kSizeRectToHorizontalAspectRatioTestCases));
+INSTANTIATE_TEST_SUITE_P(
+    Vertical,
+    ResizeUtilsTest,
+    testing::ValuesIn(kSizeRectToVerticalAspectRatioTestCases));
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rounded_corners_f.cc b/ui/gfx/geometry/rounded_corners_f.cc
new file mode 100644
index 0000000..7db277a
--- /dev/null
+++ b/ui/gfx/geometry/rounded_corners_f.cc
@@ -0,0 +1,17 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/geometry/rounded_corners_f.h"
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+std::string RoundedCornersF::ToString() const {
+  // Print members in the same order of the constructor parameters.
+  return base::StringPrintf("%f,%f,%f,%f", upper_left_, upper_right_,
+                            lower_right_, lower_left_);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rounded_corners_f.h b/ui/gfx/geometry/rounded_corners_f.h
new file mode 100644
index 0000000..12582d3
--- /dev/null
+++ b/ui/gfx/geometry/rounded_corners_f.h
@@ -0,0 +1,93 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_ROUNDED_CORNERS_F_H_
+#define UI_GFX_GEOMETRY_ROUNDED_CORNERS_F_H_
+
+#include <iosfwd>
+#include <limits>
+#include <string>
+
+#include "ui/gfx/geometry/geometry_export.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace gfx {
+
+// Represents the geometry of a region with rounded corners, expressed as four
+// corner radii in the order: top-left, top-right, bottom-right, bottom-left.
+class GEOMETRY_EXPORT RoundedCornersF {
+ public:
+  // Creates an empty RoundedCornersF with all corners having zero radius.
+  constexpr RoundedCornersF() : RoundedCornersF(0.0f) {}
+
+  // Creates a RoundedCornersF with the same radius for all corners.
+  constexpr explicit RoundedCornersF(float all)
+      : RoundedCornersF(all, all, all, all) {}
+
+  // Creates a RoundedCornersF with four different corner radii.
+  constexpr RoundedCornersF(float upper_left,
+                            float upper_right,
+                            float lower_right,
+                            float lower_left)
+      : upper_left_(clamp(upper_left)),
+        upper_right_(clamp(upper_right)),
+        lower_right_(clamp(lower_right)),
+        lower_left_(clamp(lower_left)) {}
+
+  constexpr float upper_left() const { return upper_left_; }
+  constexpr float upper_right() const { return upper_right_; }
+  constexpr float lower_right() const { return lower_right_; }
+  constexpr float lower_left() const { return lower_left_; }
+
+  void set_upper_left(float upper_left) { upper_left_ = clamp(upper_left); }
+  void set_upper_right(float upper_right) { upper_right_ = clamp(upper_right); }
+  void set_lower_right(float lower_right) { lower_right_ = clamp(lower_right); }
+  void set_lower_left(float lower_left) { lower_left_ = clamp(lower_left); }
+
+  void Set(float upper_left,
+           float upper_right,
+           float lower_right,
+           float lower_left) {
+    upper_left_ = clamp(upper_left);
+    upper_right_ = clamp(upper_right);
+    lower_right_ = clamp(lower_right);
+    lower_left_ = clamp(lower_left);
+  }
+
+  // Returns true if all of the corners are square (zero effective radius).
+  bool IsEmpty() const {
+    return upper_left_ == 0.0f && upper_right_ == 0.0f &&
+           lower_right_ == 0.0f && lower_left_ == 0.0f;
+  }
+
+  bool operator==(const RoundedCornersF& corners) const {
+    return upper_left_ == corners.upper_left_ &&
+           upper_right_ == corners.upper_right_ &&
+           lower_right_ == corners.lower_right_ &&
+           lower_left_ == corners.lower_left_;
+  }
+
+  bool operator!=(const RoundedCornersF& corners) const {
+    return !(*this == corners);
+  }
+
+  // Returns a string representation of the insets.
+  std::string ToString() const;
+
+ private:
+  static constexpr float kTrivial = 8.f * std::numeric_limits<float>::epsilon();
+
+  // Prevents values which are smaller than zero or negligibly small.
+  // Uses the same logic as gfx::Size.
+  static constexpr float clamp(float f) { return f > kTrivial ? f : 0.f; }
+
+  float upper_left_ = 0.0f;
+  float upper_right_ = 0.0f;
+  float lower_right_ = 0.0f;
+  float lower_left_ = 0.0f;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_ROUNDED_CORNERS_F_H_
diff --git a/ui/gfx/geometry/rounded_corners_f_unittest.cc b/ui/gfx/geometry/rounded_corners_f_unittest.cc
new file mode 100644
index 0000000..5c9bc91
--- /dev/null
+++ b/ui/gfx/geometry/rounded_corners_f_unittest.cc
@@ -0,0 +1,158 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/geometry/rounded_corners_f.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+
+TEST(RoundedCornersFTest, DefaultConstructor) {
+  const RoundedCornersF rc;
+  EXPECT_EQ(0.0f, rc.upper_left());
+  EXPECT_EQ(0.0f, rc.upper_right());
+  EXPECT_EQ(0.0f, rc.lower_right());
+  EXPECT_EQ(0.0f, rc.lower_left());
+}
+
+TEST(RoundedCornersFTest, FromSingleValue) {
+  constexpr float kValue = 1.33f;
+  const RoundedCornersF rc(kValue);
+  EXPECT_EQ(kValue, rc.upper_left());
+  EXPECT_EQ(kValue, rc.upper_right());
+  EXPECT_EQ(kValue, rc.lower_right());
+  EXPECT_EQ(kValue, rc.lower_left());
+}
+
+TEST(RoundedCornersFTest, FromFourValues) {
+  constexpr float kValue1 = 1.33f;
+  constexpr float kValue2 = 2.66f;
+  constexpr float kValue3 = 0.1f;
+  constexpr float kValue4 = 50.0f;
+  const RoundedCornersF rc(kValue1, kValue2, kValue3, kValue4);
+  EXPECT_EQ(kValue1, rc.upper_left());
+  EXPECT_EQ(kValue2, rc.upper_right());
+  EXPECT_EQ(kValue3, rc.lower_right());
+  EXPECT_EQ(kValue4, rc.lower_left());
+}
+
+TEST(RoundedCornersFTest, IsEmpty) {
+  EXPECT_TRUE(RoundedCornersF().IsEmpty());
+  EXPECT_FALSE(RoundedCornersF(1.0f).IsEmpty());
+  EXPECT_FALSE(RoundedCornersF(1.0f, 0.0f, 0.0f, 0.0f).IsEmpty());
+  EXPECT_FALSE(RoundedCornersF(0.0f, 1.0f, 0.0f, 0.0f).IsEmpty());
+  EXPECT_FALSE(RoundedCornersF(0.0f, 0.0f, 1.0f, 0.0f).IsEmpty());
+  EXPECT_FALSE(RoundedCornersF(0.0f, 0.0f, 0.0f, 1.0f).IsEmpty());
+}
+
+TEST(RoundedCornersFTest, Equality) {
+  constexpr RoundedCornersF kCorners(1.33f, 2.66f, 0.1f, 50.0f);
+  RoundedCornersF rc = kCorners;
+  // Using EXPECT_TRUE and EXPECT_FALSE to explicitly test == and != operators
+  // (rather than EXPECT_EQ, EXPECT_NE).
+  EXPECT_TRUE(rc == kCorners);
+  EXPECT_FALSE(rc != kCorners);
+  rc.set_upper_left(2.0f);
+  EXPECT_FALSE(rc == kCorners);
+  EXPECT_TRUE(rc != kCorners);
+  rc = kCorners;
+  rc.set_upper_right(2.0f);
+  EXPECT_FALSE(rc == kCorners);
+  EXPECT_TRUE(rc != kCorners);
+  rc = kCorners;
+  rc.set_lower_left(2.0f);
+  EXPECT_FALSE(rc == kCorners);
+  EXPECT_TRUE(rc != kCorners);
+  rc = kCorners;
+  rc.set_lower_right(2.0f);
+  EXPECT_FALSE(rc == kCorners);
+  EXPECT_TRUE(rc != kCorners);
+}
+
+TEST(RoundedCornersFTest, Set) {
+  RoundedCornersF rc(1.0f, 2.0f, 3.0f, 4.0f);
+  rc.Set(4.0f, 3.0f, 2.0f, 1.0f);
+  EXPECT_EQ(4.0f, rc.upper_left());
+  EXPECT_EQ(3.0f, rc.upper_right());
+  EXPECT_EQ(2.0f, rc.lower_right());
+  EXPECT_EQ(1.0f, rc.lower_left());
+}
+
+TEST(RoundedCornersFTest, SetProperties) {
+  RoundedCornersF rc(1.0f, 2.0f, 3.0f, 4.0f);
+
+  rc.set_upper_left(50.0f);
+  EXPECT_EQ(50.0f, rc.upper_left());
+  EXPECT_EQ(2.0f, rc.upper_right());
+  EXPECT_EQ(3.0f, rc.lower_right());
+  EXPECT_EQ(4.0f, rc.lower_left());
+
+  rc.set_upper_right(40.0f);
+  EXPECT_EQ(50.0f, rc.upper_left());
+  EXPECT_EQ(40.0f, rc.upper_right());
+  EXPECT_EQ(3.0f, rc.lower_right());
+  EXPECT_EQ(4.0f, rc.lower_left());
+
+  rc.set_lower_right(30.0f);
+  EXPECT_EQ(50.0f, rc.upper_left());
+  EXPECT_EQ(40.0f, rc.upper_right());
+  EXPECT_EQ(30.0f, rc.lower_right());
+  EXPECT_EQ(4.0f, rc.lower_left());
+
+  rc.set_lower_left(20.0f);
+  EXPECT_EQ(50.0f, rc.upper_left());
+  EXPECT_EQ(40.0f, rc.upper_right());
+  EXPECT_EQ(30.0f, rc.lower_right());
+  EXPECT_EQ(20.0f, rc.lower_left());
+}
+
+namespace {
+
+// Verify that IsEmpty() returns true and that all values are exactly zero.
+void VerifyEmptyAndZero(const RoundedCornersF& rc) {
+  EXPECT_TRUE(rc.IsEmpty());
+  EXPECT_EQ(0.0f, rc.upper_left());
+  EXPECT_EQ(0.0f, rc.upper_right());
+  EXPECT_EQ(0.0f, rc.lower_right());
+  EXPECT_EQ(0.0f, rc.lower_left());
+}
+
+}  // namespace
+
+TEST(RoundedCornersFTest, Epsilon) {
+  constexpr float kEpsilon = std::numeric_limits<float>::epsilon();
+  RoundedCornersF rc(kEpsilon, kEpsilon, kEpsilon, kEpsilon);
+  VerifyEmptyAndZero(rc);
+
+  rc.set_upper_left(kEpsilon);
+  VerifyEmptyAndZero(rc);
+  rc.set_upper_right(kEpsilon);
+  VerifyEmptyAndZero(rc);
+  rc.set_lower_right(kEpsilon);
+  VerifyEmptyAndZero(rc);
+  rc.set_lower_left(kEpsilon);
+  VerifyEmptyAndZero(rc);
+
+  rc.Set(kEpsilon, kEpsilon, kEpsilon, kEpsilon);
+  VerifyEmptyAndZero(rc);
+}
+
+TEST(RoundedCornersFTest, Negative) {
+  constexpr float kNegative = -0.5f;
+  RoundedCornersF rc(kNegative, kNegative, kNegative, kNegative);
+  VerifyEmptyAndZero(rc);
+
+  rc.set_upper_left(kNegative);
+  VerifyEmptyAndZero(rc);
+  rc.set_upper_right(kNegative);
+  VerifyEmptyAndZero(rc);
+  rc.set_lower_right(kNegative);
+  VerifyEmptyAndZero(rc);
+  rc.set_lower_left(kNegative);
+  VerifyEmptyAndZero(rc);
+
+  rc.Set(kNegative, kNegative, kNegative, kNegative);
+  VerifyEmptyAndZero(rc);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rrect_f.cc b/ui/gfx/geometry/rrect_f.cc
new file mode 100644
index 0000000..ab7dece
--- /dev/null
+++ b/ui/gfx/geometry/rrect_f.cc
@@ -0,0 +1,204 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/geometry/rrect_f.h"
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+#include "base/values.h"
+#include "third_party/skia/include/core/SkMatrix.h"
+
+namespace gfx {
+
+// Sets all x radii to x_rad, and all y radii to y_rad. If one of x_rad or
+// y_rad are zero, sets ALL radii to zero.
+RRectF::RRectF(float x,
+               float y,
+               float width,
+               float height,
+               float x_rad,
+               float y_rad)
+    : skrrect_(SkRRect::MakeRectXY(SkRect::MakeXYWH(x, y, width, height),
+                                   x_rad,
+                                   y_rad)) {
+  if (IsEmpty()) {
+    // Make sure that empty rects are created fully empty, not with some
+    // non-zero dimensions.
+    skrrect_ = SkRRect::MakeEmpty();
+  }
+}
+
+// Directly sets all four corners.
+RRectF::RRectF(float x,
+               float y,
+               float width,
+               float height,
+               float upper_left_x,
+               float upper_left_y,
+               float upper_right_x,
+               float upper_right_y,
+               float lower_right_x,
+               float lower_right_y,
+               float lower_left_x,
+               float lower_left_y) {
+  SkVector radii[4] = {
+      {upper_left_x, upper_left_y},
+      {upper_right_x, upper_right_y},
+      {lower_right_x, lower_right_y},
+      {lower_left_x, lower_left_y},
+  };
+  skrrect_.setRectRadii(SkRect::MakeXYWH(x, y, width, height), radii);
+  if (IsEmpty()) {
+    // Make sure that empty rects are created fully empty, not with some
+    // non-zero dimensions.
+    skrrect_ = SkRRect::MakeEmpty();
+  }
+}
+
+gfx::Vector2dF RRectF::GetSimpleRadii() const {
+  DCHECK(GetType() <= Type::kOval);
+  SkPoint result = skrrect_.getSimpleRadii();
+  return gfx::Vector2dF(result.x(), result.y());
+}
+
+float RRectF::GetSimpleRadius() const {
+  DCHECK(GetType() <= Type::kOval);
+  SkPoint result = skrrect_.getSimpleRadii();
+  DCHECK_EQ(result.x(), result.y());
+  return result.x();
+}
+
+RRectF::Type RRectF::GetType() const {
+  SkPoint rad;
+  switch (skrrect_.getType()) {
+    case SkRRect::kEmpty_Type:
+      return Type::kEmpty;
+    case SkRRect::kRect_Type:
+      return Type::kRect;
+    case SkRRect::kSimple_Type:
+      rad = skrrect_.getSimpleRadii();
+      if (rad.x() == rad.y()) {
+        return Type::kSingle;
+      }
+      return Type::kSimple;
+    case SkRRect::kOval_Type:
+      rad = skrrect_.getSimpleRadii();
+      if (rad.x() == rad.y()) {
+        return Type::kSingle;
+      }
+      return Type::kOval;
+    case SkRRect::kNinePatch_Type:
+    case SkRRect::kComplex_Type:
+    default:
+      return Type::kComplex;
+  }
+}
+
+gfx::Vector2dF RRectF::GetCornerRadii(Corner corner) const {
+  SkPoint result = skrrect_.radii(SkRRect::Corner(corner));
+  return gfx::Vector2dF(result.x(), result.y());
+}
+
+void RRectF::GetAllRadii(SkVector radii[4]) const {
+  // Unfortunately, the only way to get all radii is one at a time.
+  radii[SkRRect::kUpperLeft_Corner] =
+      skrrect_.radii(SkRRect::kUpperLeft_Corner);
+  radii[SkRRect::kUpperRight_Corner] =
+      skrrect_.radii(SkRRect::kUpperRight_Corner);
+  radii[SkRRect::kLowerRight_Corner] =
+      skrrect_.radii(SkRRect::kLowerRight_Corner);
+  radii[SkRRect::kLowerLeft_Corner] =
+      skrrect_.radii(SkRRect::kLowerLeft_Corner);
+}
+
+void RRectF::SetCornerRadii(Corner corner, float x_rad, float y_rad) {
+  // Unfortunately, the only way to set this is to create a new SkRRect.
+  SkVector radii[4];
+  GetAllRadii(radii);
+  radii[SkRRect::Corner(corner)] = SkPoint::Make(x_rad, y_rad);
+  skrrect_.setRectRadii(skrrect_.rect(), radii);
+}
+
+void RRectF::Scale(float x_scale, float y_scale) {
+  if (IsEmpty()) {
+    // SkRRect doesn't support scaling of empty rects.
+    return;
+  }
+  if (!x_scale || !y_scale) {
+    // SkRRect doesn't support scaling TO an empty rect.
+    skrrect_ = SkRRect::MakeEmpty();
+    return;
+  }
+  SkMatrix scale = SkMatrix::Scale(x_scale, y_scale);
+  SkRRect result;
+  bool success = skrrect_.transform(scale, &result);
+  DCHECK(success);
+  skrrect_ = result;
+}
+
+void RRectF::Offset(float horizontal, float vertical) {
+  skrrect_.offset(horizontal, vertical);
+}
+
+const RRectF& RRectF::operator+=(const gfx::Vector2dF& offset) {
+  Offset(offset.x(), offset.y());
+  return *this;
+}
+
+const RRectF& RRectF::operator-=(const gfx::Vector2dF& offset) {
+  Offset(-offset.x(), -offset.y());
+  return *this;
+}
+
+std::string RRectF::ToString() const {
+  std::stringstream ss;
+  ss << std::fixed << std::setprecision(3);
+  ss << rect().origin().x() << "," << rect().origin().y() << " "
+     << rect().size().width() << "x" << rect().size().height();
+  Type type = this->GetType();
+  if (type <= Type::kRect) {
+    ss << ", rectangular";
+  } else if (type <= Type::kSingle) {
+    ss << ", radius " << GetSimpleRadius();
+  } else if (type <= Type::kSimple) {
+    gfx::Vector2dF radii = GetSimpleRadii();
+    ss << ", x_rad " << radii.x() << ", y_rad " << radii.y();
+  } else {
+    ss << ",";
+    const Corner corners[] = {Corner::kUpperLeft, Corner::kUpperRight,
+                              Corner::kLowerRight, Corner::kLowerLeft};
+    for (const auto& c : corners) {
+      auto this_corner = GetCornerRadii(c);
+      ss << " [" << this_corner.x() << " " << this_corner.y() << "]";
+    }
+  }
+  return ss.str();
+}
+
+namespace {
+inline bool AboveTol(float val1, float val2, float tolerance) {
+  return (std::abs(val1 - val2) > tolerance);
+}
+}  // namespace
+
+bool RRectF::ApproximatelyEqual(const RRectF& rect, float tolerance) const {
+  if (AboveTol(skrrect_.rect().x(), rect.skrrect_.rect().x(), tolerance) ||
+      AboveTol(skrrect_.rect().y(), rect.skrrect_.rect().y(), tolerance) ||
+      AboveTol(skrrect_.width(), rect.skrrect_.width(), tolerance) ||
+      AboveTol(skrrect_.height(), rect.skrrect_.height(), tolerance))
+    return false;
+  for (int i = 0; i < 4; i++) {
+    SkVector r1 = skrrect_.radii(SkRRect::Corner(i));
+    SkVector r2 = rect.skrrect_.radii(SkRRect::Corner(i));
+    if (std::abs(r1.x() - r2.x()) > tolerance ||
+        std::abs(r1.y() - r2.y()) > tolerance) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rrect_f.h b/ui/gfx/geometry/rrect_f.h
new file mode 100644
index 0000000..7b3f46e
--- /dev/null
+++ b/ui/gfx/geometry/rrect_f.h
@@ -0,0 +1,201 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_RRECT_F_H_
+#define UI_GFX_GEOMETRY_RRECT_F_H_
+
+#include <memory>
+#include <string>
+
+#include "third_party/skia/include/core/SkRRect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/rounded_corners_f.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+
+namespace gfx {
+
+class GEOMETRY_SKIA_EXPORT RRectF {
+ public:
+  RRectF() = default;
+  ~RRectF() = default;
+  RRectF(const RRectF& rect) = default;
+  RRectF& operator=(const RRectF& rect) = default;
+  explicit RRectF(const SkRRect& rect) : skrrect_(rect) {}
+  explicit RRectF(const gfx::RectF& rect) : RRectF(rect, 0.f) {}
+  RRectF(const gfx::RectF& rect, float radius) : RRectF(rect, radius, radius) {}
+  RRectF(const gfx::RectF& rect, float x_rad, float y_rad)
+      : RRectF(rect.x(), rect.y(), rect.width(), rect.height(), x_rad, y_rad) {}
+  // Sets all x and y radii to radius.
+  RRectF(float x, float y, float width, float height, float radius)
+      : RRectF(x, y, width, height, radius, radius) {}
+  // Sets all x radii to x_rad, and all y radii to y_rad. If one of x_rad or
+  // y_rad are zero, sets ALL radii to zero.
+  RRectF(float x, float y, float width, float height, float x_rad, float y_rad);
+  // Directly sets all four corners.
+  RRectF(float x,
+         float y,
+         float width,
+         float height,
+         float upper_left_x,
+         float upper_left_y,
+         float upper_right_x,
+         float upper_right_y,
+         float lower_right_x,
+         float lower_right_y,
+         float lower_left_x,
+         float lower_left_y);
+  RRectF(const gfx::RectF& rect,
+         float upper_left_x,
+         float upper_left_y,
+         float upper_right_x,
+         float upper_right_y,
+         float lower_right_x,
+         float lower_right_y,
+         float lower_left_x,
+         float lower_left_y)
+      : RRectF(rect.x(),
+               rect.y(),
+               rect.width(),
+               rect.height(),
+               upper_left_x,
+               upper_left_y,
+               upper_right_x,
+               upper_right_y,
+               lower_right_x,
+               lower_right_y,
+               lower_left_x,
+               lower_left_y) {}
+  RRectF(const gfx::RectF& rect, const gfx::RoundedCornersF& corners)
+      : RRectF(rect.x(),
+               rect.y(),
+               rect.width(),
+               rect.height(),
+               corners.upper_left(),
+               corners.upper_left(),
+               corners.upper_right(),
+               corners.upper_right(),
+               corners.lower_right(),
+               corners.lower_right(),
+               corners.lower_left(),
+               corners.lower_left()) {}
+
+  // The rectangular portion of the RRectF, without the corner radii.
+  gfx::RectF rect() const { return gfx::SkRectToRectF(skrrect_.rect()); }
+
+  // Returns the radii of the all corners. DCHECKs that all corners
+  // have the same radii (the type is <= kOval).
+  gfx::Vector2dF GetSimpleRadii() const;
+  // Returns the radius of all corners. DCHECKs that all corners have the same
+  // radii, and that x_rad == y_rad (the type is <= kSingle).
+  float GetSimpleRadius() const;
+
+  // Make the RRectF empty.
+  void Clear() { skrrect_.setEmpty(); }
+
+  bool Equals(const RRectF& other) const { return skrrect_ == other.skrrect_; }
+
+  // These are all mutually exclusive, and ordered in increasing complexity. The
+  // order is assumed in several functions.
+  enum class Type {
+    kEmpty,   // Zero width or height.
+    kRect,    // Non-zero width and height, and zeroed radii - a pure rectangle.
+    kSingle,  // Non-zero width and height, and a single, non-zero value for all
+              // X and Y radii.
+    kSimple,  // Non-zero width and height, X radii all equal and non-zero, Y
+              // radii all equal and non-zero, and x_rad != y_rad.
+    kOval,    // Non-zero width and height, X radii all equal to width/2, and Y
+              // radii all equal to height/2, and x_rad != y_rad.
+    kComplex,  // Non-zero width and height, and arbitrary (non-equal) radii.
+  };
+  Type GetType() const;
+
+  bool IsEmpty() const { return GetType() == Type::kEmpty; }
+
+  // Enumeration of the corners of a rectangle in clockwise order. Values match
+  // SkRRect::Corner.
+  enum class Corner {
+    kUpperLeft = SkRRect::kUpperLeft_Corner,
+    kUpperRight = SkRRect::kUpperRight_Corner,
+    kLowerRight = SkRRect::kLowerRight_Corner,
+    kLowerLeft = SkRRect::kLowerLeft_Corner,
+  };
+  // GetCornerRadii may be called for any type of RRect (kRect, kOval, etc.),
+  // and it will return "correct" values. If GetType() is kOval or less, all
+  // corner values will be identical to each other. SetCornerRadii can similarly
+  // be called on any type of RRect, but GetType() may change as a result of the
+  // call.
+  gfx::Vector2dF GetCornerRadii(Corner corner) const;
+  void SetCornerRadii(Corner corner, float x_rad, float y_rad);
+  void SetCornerRadii(Corner corner, const gfx::Vector2dF& radii) {
+    SetCornerRadii(corner, radii.x(), radii.y());
+  }
+
+  // Returns true if |rect| is inside the bounds and corner radii of this
+  // RRectF, and if both this RRectF and rect are not empty.
+  bool Contains(const RectF& rect) const {
+    return skrrect_.contains(gfx::RectFToSkRect(rect));
+  }
+
+  // Scales the rectangle by |scale|.
+  void Scale(float scale) { Scale(scale, scale); }
+  // Scales the rectangle by |x_scale| and |y_scale|.
+  void Scale(float x_scale, float y_scale);
+
+  // Move the rectangle by a horizontal and vertical distance.
+  void Offset(float horizontal, float vertical);
+  void Offset(const Vector2dF& distance) { Offset(distance.x(), distance.y()); }
+  const RRectF& operator+=(const gfx::Vector2dF& offset);
+  const RRectF& operator-=(const gfx::Vector2dF& offset);
+
+  std::string ToString() const;
+  bool ApproximatelyEqual(const RRectF& rect, float tolerance) const;
+
+  // Insets bounds by dx and dy, and adjusts radii by dx and dy. dx and dy may
+  // be positive, negative, or zero. If either corner radius is zero, the corner
+  // has no curvature and is unchanged. Otherwise, if adjusted radius becomes
+  // negative, the radius is pinned to zero.
+  void Inset(float val) { skrrect_.inset(val, val); }
+  void Inset(float dx, float dy) { skrrect_.inset(dx, dy); }
+  // Outsets bounds by dx and dy, and adjusts radii by dx and dy. dx and dy may
+  // be positive, negative, or zero. If either corner radius is zero, the corner
+  // has no curvature and is unchanged. Otherwise, if adjusted radius becomes
+  // negative, the radius is pinned to zero.
+  void Outset(float val) { skrrect_.outset(val, val); }
+  void Outset(float dx, float dy) { skrrect_.outset(dx, dy); }
+
+  explicit operator SkRRect() const { return skrrect_; }
+
+ private:
+  void GetAllRadii(SkVector radii[4]) const;
+
+  SkRRect skrrect_;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const RRectF& rect) {
+  return os << rect.ToString();
+}
+
+inline bool operator==(const RRectF& a, const RRectF& b) {
+  return a.Equals(b);
+}
+
+inline bool operator!=(const RRectF& a, const RRectF& b) {
+  return !(a == b);
+}
+
+inline RRectF operator+(const RRectF& a, const gfx::Vector2dF& b) {
+  RRectF result = a;
+  result += b;
+  return result;
+}
+
+inline RRectF operator-(const RRectF& a, const Vector2dF& b) {
+  RRectF result = a;
+  result -= b;
+  return result;
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_RRECT_F_H_
diff --git a/ui/gfx/geometry/rrect_f_builder.cc b/ui/gfx/geometry/rrect_f_builder.cc
new file mode 100644
index 0000000..0fc1a7e
--- /dev/null
+++ b/ui/gfx/geometry/rrect_f_builder.cc
@@ -0,0 +1,18 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/geometry/rrect_f_builder.h"
+
+namespace gfx {
+
+RRectFBuilder::RRectFBuilder() = default;
+RRectFBuilder::RRectFBuilder(RRectFBuilder&& other) = default;
+
+RRectF RRectFBuilder::Build() {
+  return RRectF(x_, y_, width_, height_, upper_left_x_, upper_left_y_,
+                upper_right_x_, upper_right_y_, lower_right_x_, lower_right_y_,
+                lower_left_x_, lower_left_y_);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/rrect_f_builder.h b/ui/gfx/geometry/rrect_f_builder.h
new file mode 100644
index 0000000..a7c3023
--- /dev/null
+++ b/ui/gfx/geometry/rrect_f_builder.h
@@ -0,0 +1,130 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_RRECT_F_BUILDER_H_
+#define UI_GFX_GEOMETRY_RRECT_F_BUILDER_H_
+
+#include "ui/gfx/geometry/rrect_f.h"
+
+namespace gfx {
+
+// RRectFBuilder is implemented to make the parameter setting easier for RRectF.
+//
+// For example: To build an RRectF at point(40, 50) with size(60,70),
+// with corner radii {(1, 2),(3, 4),(5, 6),(7, 8)}, use:
+//
+//  RRectF a = RRectFBuilder()
+//                  .set_origin(40, 50)
+//                  .set_size(60, 70)
+//                  .set_upper_left(1, 2)
+//                  .set_upper_right(3, 4)
+//                  .set_lower_right(5, 6)
+//                  .set_lower_left(7, 8)
+//                  .Build();
+class GEOMETRY_SKIA_EXPORT RRectFBuilder {
+ public:
+  RRectFBuilder();
+  RRectFBuilder(RRectFBuilder&& other);
+  ~RRectFBuilder() = default;
+
+  RRectFBuilder&& set_origin(float x, float y) {
+    x_ = x;
+    y_ = y;
+    return std::move(*this);
+  }
+  RRectFBuilder&& set_origin(const PointF& origin) {
+    x_ = origin.x();
+    y_ = origin.y();
+    return std::move(*this);
+  }
+
+  RRectFBuilder&& set_size(float width, float height) {
+    width_ = width;
+    height_ = height;
+    return std::move(*this);
+  }
+  RRectFBuilder&& set_size(const SizeF& size) {
+    width_ = size.width();
+    height_ = size.height();
+    return std::move(*this);
+  }
+
+  RRectFBuilder&& set_rect(const gfx::RectF& rect) {
+    x_ = rect.x();
+    y_ = rect.y();
+    width_ = rect.width();
+    height_ = rect.height();
+    return std::move(*this);
+  }
+  template <class T>
+  void set_rect(const T&) = delete;  // To avoid implicit conversion.
+
+  RRectFBuilder&& set_radius(float radius) {
+    set_upper_left(radius, radius);
+    set_upper_right(radius, radius);
+    set_lower_right(radius, radius);
+    set_lower_left(radius, radius);
+    return std::move(*this);
+  }
+  RRectFBuilder&& set_radius(float x_rad, float y_rad) {
+    set_upper_left(x_rad, y_rad);
+    set_upper_right(x_rad, y_rad);
+    set_lower_right(x_rad, y_rad);
+    set_lower_left(x_rad, y_rad);
+    return std::move(*this);
+  }
+
+  RRectFBuilder&& set_upper_left(float upper_left_x, float upper_left_y) {
+    upper_left_x_ = upper_left_x;
+    upper_left_y_ = upper_left_y;
+    return std::move(*this);
+  }
+  RRectFBuilder&& set_upper_right(float upper_right_x, float upper_right_y) {
+    upper_right_x_ = upper_right_x;
+    upper_right_y_ = upper_right_y;
+    return std::move(*this);
+  }
+  RRectFBuilder&& set_lower_right(float lower_right_x, float lower_right_y) {
+    lower_right_x_ = lower_right_x;
+    lower_right_y_ = lower_right_y;
+    return std::move(*this);
+  }
+  RRectFBuilder&& set_lower_left(float lower_left_x, float lower_left_y) {
+    lower_left_x_ = lower_left_x;
+    lower_left_y_ = lower_left_y;
+    return std::move(*this);
+  }
+
+  RRectFBuilder&& set_corners(const gfx::RoundedCornersF& corners) {
+    upper_left_x_ = corners.upper_left();
+    upper_left_y_ = corners.upper_left();
+    upper_right_x_ = corners.upper_right();
+    upper_right_y_ = corners.upper_right();
+    lower_right_x_ = corners.lower_right();
+    lower_right_y_ = corners.lower_right();
+    lower_left_x_ = corners.lower_left();
+    lower_left_y_ = corners.lower_left();
+    return std::move(*this);
+  }
+
+  RRectF Build();
+
+ private:
+  float x_ = 0.f;
+  float y_ = 0.f;
+  float width_ = 0.f;
+  float height_ = 0.f;
+  float upper_left_x_ = 0.f;
+  float upper_left_y_ = 0.f;
+  float upper_right_x_ = 0.f;
+  float upper_right_y_ = 0.f;
+  float lower_right_x_ = 0.f;
+  float lower_right_y_ = 0.f;
+  float lower_left_x_ = 0.f;
+  float lower_left_y_ = 0.f;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_RRECT_F_BUILDER_H_
diff --git a/ui/gfx/geometry/rrect_f_unittest.cc b/ui/gfx/geometry/rrect_f_unittest.cc
new file mode 100644
index 0000000..45eeba1
--- /dev/null
+++ b/ui/gfx/geometry/rrect_f_unittest.cc
@@ -0,0 +1,405 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/geometry/rrect_f.h"
+
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rrect_f_builder.h"
+
+namespace gfx {
+
+TEST(RRectFTest, IsEmpty) {
+  EXPECT_TRUE(RRectF().IsEmpty());
+  EXPECT_TRUE(RRectF(0, 0, 0, 0, 0).IsEmpty());
+  EXPECT_TRUE(RRectF(0, 0, 10, 0, 0).IsEmpty());
+  EXPECT_TRUE(RRectF(0, 0, 0, 10, 0).IsEmpty());
+  EXPECT_TRUE(RRectF(0, 0, 0, 10, 10).IsEmpty());
+  EXPECT_FALSE(RRectF(0, 0, 10, 10, 0).IsEmpty());
+}
+
+TEST(RRectFTest, Equals) {
+  EXPECT_EQ(RRectF(0, 0, 0, 0, 0, 0), RRectF(0, 0, 0, 0, 0, 0));
+  EXPECT_EQ(RRectF(1, 2, 3, 4, 5, 6), RRectF(1, 2, 3, 4, 5, 6));
+  EXPECT_EQ(RRectF(1, 2, 3, 4, 5, 5), RRectF(1, 2, 3, 4, 5));
+  EXPECT_EQ(RRectF(0, 0, 2, 3, 0, 0), RRectF(0, 0, 2, 3, 0, 1));
+  EXPECT_EQ(RRectF(0, 0, 2, 3, 0, 0), RRectF(0, 0, 2, 3, 1, 0));
+  EXPECT_EQ(RRectF(1, 2, 3, 0, 5, 6), RRectF(0, 0, 0, 0, 0, 0));
+  EXPECT_EQ(RRectF(0, 0, 0, 0, 5, 6), RRectF(0, 0, 0, 0, 0, 0));
+
+  EXPECT_NE(RRectF(10, 20, 30, 40, 7, 8), RRectF(1, 20, 30, 40, 7, 8));
+  EXPECT_NE(RRectF(10, 20, 30, 40, 7, 8), RRectF(10, 2, 30, 40, 7, 8));
+  EXPECT_NE(RRectF(10, 20, 30, 40, 7, 8), RRectF(10, 20, 3, 40, 7, 8));
+  EXPECT_NE(RRectF(10, 20, 30, 40, 7, 8), RRectF(10, 20, 30, 4, 7, 8));
+  EXPECT_NE(RRectF(10, 20, 30, 40, 7, 8), RRectF(10, 20, 30, 40, 5, 8));
+  EXPECT_NE(RRectF(10, 20, 30, 40, 7, 8), RRectF(10, 20, 30, 40, 7, 6));
+}
+
+TEST(RRectFTest, PlusMinusOffset) {
+  const RRectF a(40, 50, 60, 70, 5);
+  gfx::Vector2d offset(23, 34);
+  RRectF correct(63, 84, 60, 70, 5);
+  RRectF b = a + offset;
+  ASSERT_EQ(b, correct);
+  b = a;
+  b.Offset(offset);
+  ASSERT_EQ(b, correct);
+
+  correct = RRectF(17, 16, 60, 70, 5);
+  b = a - offset;
+  ASSERT_EQ(b, correct);
+  b = a;
+  b.Offset(-offset);
+  ASSERT_EQ(b, correct);
+}
+
+TEST(RRectFTest, RRectTypes) {
+  RRectF a(40, 50, 0, 70, 0);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kEmpty);
+  EXPECT_TRUE(a.IsEmpty());
+  a = RRectF(40, 50, 60, 70, 0);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kRect);
+  a = RRectF(40, 50, 60, 70, 5);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kSingle);
+  a = RRectF(40, 50, 60, 70, 5, 5);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kSingle);
+  a = RRectF(40, 50, 60, 60, 30, 30);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kSingle);
+  a = RRectF(40, 50, 60, 70, 6, 3);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kSimple);
+  a = RRectF(40, 50, 60, 70, 30, 3);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kSimple);
+  a = RRectF(40, 50, 60, 70, 30, 35);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kOval);
+  a.SetCornerRadii(RRectF::Corner::kLowerRight, gfx::Vector2dF(7, 8));
+  EXPECT_EQ(a.GetType(), RRectF::Type::kComplex);
+
+  // When one radius is larger than half its dimension, both radii are scaled
+  // down proportionately.
+  a = RRectF(40, 50, 60, 70, 30, 70);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kSimple);
+  EXPECT_EQ(a, RRectF(40, 50, 60, 70, 15, 35));
+  // If they stay equal to half the radius, it stays oval.
+  a = RRectF(40, 50, 60, 70, 120, 140);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kOval);
+}
+
+void CheckRadii(RRectF val,
+                float ulx,
+                float uly,
+                float urx,
+                float ury,
+                float lrx,
+                float lry,
+                float llx,
+                float lly) {
+  EXPECT_EQ(val.GetCornerRadii(RRectF::Corner::kUpperLeft),
+            gfx::Vector2dF(ulx, uly));
+  EXPECT_EQ(val.GetCornerRadii(RRectF::Corner::kUpperRight),
+            gfx::Vector2dF(urx, ury));
+  EXPECT_EQ(val.GetCornerRadii(RRectF::Corner::kLowerRight),
+            gfx::Vector2dF(lrx, lry));
+  EXPECT_EQ(val.GetCornerRadii(RRectF::Corner::kLowerLeft),
+            gfx::Vector2dF(llx, lly));
+}
+
+TEST(RRectFTest, RRectRadii) {
+  RRectF a(40, 50, 60, 70, 0);
+  CheckRadii(a, 0, 0, 0, 0, 0, 0, 0, 0);
+
+  a.SetCornerRadii(RRectF::Corner::kUpperLeft, 1, 2);
+  CheckRadii(a, 1, 2, 0, 0, 0, 0, 0, 0);
+
+  a.SetCornerRadii(RRectF::Corner::kUpperRight, 3, 4);
+  CheckRadii(a, 1, 2, 3, 4, 0, 0, 0, 0);
+
+  a.SetCornerRadii(RRectF::Corner::kLowerRight, 5, 6);
+  CheckRadii(a, 1, 2, 3, 4, 5, 6, 0, 0);
+
+  a.SetCornerRadii(RRectF::Corner::kLowerLeft, 7, 8);
+  CheckRadii(a, 1, 2, 3, 4, 5, 6, 7, 8);
+
+  RRectF b(40, 50, 60, 70, 1, 2, 3, 4, 5, 6, 7, 8);
+  EXPECT_EQ(a, b);
+}
+
+TEST(RRectFTest, FromRectF) {
+  // Check that explicit conversion from float rect works.
+  RectF a(40, 50, 60, 70);
+  RRectF b(40, 50, 60, 70, 0);
+  RRectF c = RRectF(a);
+  EXPECT_EQ(b, c);
+}
+
+TEST(RRectFTest, FromSkRRect) {
+  // Check that explicit conversion from SkRRect works.
+  SkRRect a = SkRRect::MakeRectXY(SkRect::MakeXYWH(40, 50, 60, 70), 15, 25);
+  RRectF b(40, 50, 60, 70, 15, 25);
+  RRectF c = RRectF(a);
+  EXPECT_EQ(b, c);
+
+  // Try with single radius constructor.
+  a = SkRRect::MakeRectXY(SkRect::MakeXYWH(40, 50, 60, 70), 15, 15);
+  b = RRectF(40, 50, 60, 70, 15);
+  c = RRectF(a);
+  EXPECT_EQ(b, c);
+}
+
+TEST(RRectFTest, FromRoundedCornersF) {
+  constexpr RectF kRect(50.0f, 40.0f);
+  constexpr RoundedCornersF kCorners(1.5f, 2.5f, 3.5f, 4.5f);
+  const RRectF rrect_f(kRect, kCorners);
+
+  const auto upper_left = rrect_f.GetCornerRadii(RRectF::Corner::kUpperLeft);
+  EXPECT_EQ(kCorners.upper_left(), upper_left.x());
+  EXPECT_EQ(kCorners.upper_left(), upper_left.y());
+  const auto upper_right = rrect_f.GetCornerRadii(RRectF::Corner::kUpperRight);
+  EXPECT_EQ(kCorners.upper_right(), upper_right.x());
+  EXPECT_EQ(kCorners.upper_right(), upper_right.y());
+  const auto lower_right = rrect_f.GetCornerRadii(RRectF::Corner::kLowerRight);
+  EXPECT_EQ(kCorners.lower_right(), lower_right.x());
+  EXPECT_EQ(kCorners.lower_right(), lower_right.y());
+  const auto lower_left = rrect_f.GetCornerRadii(RRectF::Corner::kLowerLeft);
+  EXPECT_EQ(kCorners.lower_left(), lower_left.x());
+  EXPECT_EQ(kCorners.lower_left(), lower_left.y());
+}
+
+TEST(RRectFTest, ToString) {
+  RRectF a(40, 50, 60, 70, 0);
+  EXPECT_EQ(a.ToString(), "40.000,50.000 60.000x70.000, rectangular");
+  a = RRectF(40, 50, 60, 70, 15);
+  EXPECT_EQ(a.ToString(), "40.000,50.000 60.000x70.000, radius 15.000");
+  a = RRectF(40, 50, 60, 70, 15, 25);
+  EXPECT_EQ(a.ToString(),
+            "40.000,50.000 60.000x70.000, x_rad 15.000, y_rad 25.000");
+  a.SetCornerRadii(RRectF::Corner::kLowerRight, gfx::Vector2dF(7, 8));
+  EXPECT_EQ(a.ToString(),
+            "40.000,50.000 60.000x70.000, [15.000 25.000] "
+            "[15.000 25.000] [7.000 8.000] [15.000 25.000]");
+}
+
+TEST(RRectFTest, Sizes) {
+  RRectF a(40, 50, 60, 70, 5, 6);
+  EXPECT_EQ(a.rect().x(), 40);
+  EXPECT_EQ(a.rect().y(), 50);
+  EXPECT_EQ(a.rect().width(), 60);
+  EXPECT_EQ(a.rect().height(), 70);
+  EXPECT_EQ(a.GetSimpleRadii().x(), 5);
+  EXPECT_EQ(a.GetSimpleRadii().y(), 6);
+  a = RRectF(40, 50, 60, 70, 5, 5);
+  EXPECT_EQ(a.GetSimpleRadius(), 5);
+  a.Clear();
+  EXPECT_TRUE(a.IsEmpty());
+  // Make sure ovals can still get simple radii
+  a = RRectF(40, 50, 60, 70, 30, 35);
+  EXPECT_EQ(a.GetType(), RRectF::Type::kOval);
+  EXPECT_EQ(a.GetSimpleRadii().x(), 30);
+  EXPECT_EQ(a.GetSimpleRadii().y(), 35);
+}
+
+TEST(RRectFTest, Contains) {
+  RRectF a(40, 50, 60, 70, 5, 6);
+  RectF b(50, 60, 5, 6);
+  EXPECT_TRUE(a.Contains(b));
+  b = RectF(40, 50, 5, 6);  // Right on the border
+  EXPECT_FALSE(a.Contains(b));
+  b = RectF(95, 114, 5, 6);  // Right on the border
+  EXPECT_FALSE(a.Contains(b));
+  b = RectF(40, 50, 60, 70);
+  EXPECT_FALSE(a.Contains(b));
+}
+
+TEST(RRectFTest, Scale) {
+  // Note that SKRRect (the backing for RRectF) does not support scaling by NaN,
+  // or scaling out of numerical bounds. So this test doesn't exercise those.
+  static const struct Test {
+    float x1;  // source
+    float y1;
+    float w1;
+    float h1;
+    float x_rad1;
+    float y_rad1;
+
+    float x_scale;
+    float y_scale;
+    float x2;  // target
+    float y2;
+    float w2;
+    float h2;
+    float x_rad2;
+    float y_rad2;
+  } tests[] = {
+      {3.0f, 4.0f, 5.0f, 6.0f, 0.0f, 0.0f, 1.5f, 1.5f, 4.5f, 6.0f, 7.5f, 9.0f,
+       0.0f, 0.0f},
+      {3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 1.0f, 1.5f, 1.5f, 4.5f, 6.0f, 7.5f, 9.0f,
+       1.5f, 1.5f},
+      {3.0f, 4.0f, 5.0f, 6.0f, 0.0f, 0.0f, 1.5f, 3.0f, 4.5f, 12.0f, 7.5f, 18.0f,
+       0.0f, 0.0f},
+      {3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 1.0f, 1.5f, 3.0f, 4.5f, 12.0f, 7.5f, 18.0f,
+       1.5f, 3.0f},
+      {3.0f, 4.0f, 0.0f, 6.0f, 1.0f, 1.0f, 1.5f, 1.5f, 0.0f, 0.0f, 0.0f, 0.0f,
+       0.0f, 0.0f},
+      {3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+       0.0f, 0.0f},
+      {3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+       0.0f, 0.0f},
+      {3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+       0.0f, 0.0f},
+  };
+
+  for (auto& test : tests) {
+    RRectF r1(test.x1, test.y1, test.w1, test.h1, test.x_rad1, test.y_rad1);
+    RRectF r2(test.x2, test.y2, test.w2, test.h2, test.x_rad2, test.y_rad2);
+
+    r1.Scale(test.x_scale, test.y_scale);
+    ASSERT_TRUE(r1.GetType() <= RRectF::Type::kSimple);
+    EXPECT_EQ(r1.rect().x(), r2.rect().x());
+    EXPECT_EQ(r1.rect().y(), r2.rect().y());
+    EXPECT_EQ(r1.rect().width(), r2.rect().width());
+    EXPECT_EQ(r1.rect().height(), r2.rect().height());
+    EXPECT_EQ(r1.GetSimpleRadii(), r2.GetSimpleRadii());
+  }
+}
+
+TEST(RRectFTest, InsetOutset) {
+  RRectF a(40, 50, 60, 70, 5);
+  RRectF b = a;
+  b.Inset(3);
+  ASSERT_EQ(b, RRectF(43, 53, 54, 64, 2));
+  b = a;
+  b.Outset(3);
+  ASSERT_EQ(b, RRectF(37, 47, 66, 76, 8));
+}
+
+// The following tests(started with "Build*") are for RRectFBuilder. All
+// different tests are to make sure that existing RRectF definitions can be
+// implemented with RRectFBuilder.
+TEST(RRectFTest, BuildFromRectF) {
+  RectF a = RectF();
+  RRectF b(a);
+  RRectF c = RRectFBuilder().set_rect(a).Build();
+  EXPECT_EQ(b, c);
+
+  a = RectF(60, 70);
+  b = RRectF(a);
+  c = RRectFBuilder().set_rect(a).Build();
+  EXPECT_EQ(b, c);
+
+  a = RectF(40, 50, 60, 70);
+  b = RRectF(a);
+  c = RRectFBuilder().set_rect(a).Build();
+  EXPECT_EQ(b, c);
+}
+
+TEST(RRectFTest, BuildFromRadius) {
+  RRectF a(40, 50, 60, 70, 15);
+  RRectF b = RRectFBuilder()
+                 .set_origin(40, 50)
+                 .set_size(60, 70)
+                 .set_radius(15)
+                 .Build();
+  EXPECT_EQ(a, b);
+
+  a = RRectF(40, 50, 60, 70, 15, 25);
+  b = RRectFBuilder()
+          .set_origin(40, 50)
+          .set_size(60, 70)
+          .set_radius(15, 25)
+          .Build();
+  EXPECT_EQ(a, b);
+
+  const PointF p(40, 50);
+  const SizeF s(60, 70);
+  b = RRectFBuilder().set_origin(p).set_size(s).set_radius(15, 25).Build();
+  EXPECT_EQ(a, b);
+}
+
+TEST(RRectFTest, BuildFromRectFWithRadius) {
+  RectF a(40, 50, 60, 70);
+  RRectF b(a, 15);
+  RRectF c = RRectFBuilder().set_rect(a).set_radius(15).Build();
+  EXPECT_EQ(b, c);
+
+  b = RRectF(a, 15, 25);
+  c = RRectFBuilder().set_rect(a).set_radius(15, 25).Build();
+  EXPECT_EQ(b, c);
+}
+
+TEST(RRectFTest, BuildFromCorners) {
+  RRectF a(40, 50, 60, 70, 1, 2, 3, 4, 5, 6, 7, 8);
+  RRectF b = RRectFBuilder()
+                 .set_origin(40, 50)
+                 .set_size(60, 70)
+                 .set_upper_left(1, 2)
+                 .set_upper_right(3, 4)
+                 .set_lower_right(5, 6)
+                 .set_lower_left(7, 8)
+                 .Build();
+  EXPECT_EQ(a, b);
+}
+
+TEST(RRectFTest, BuildFromRectFWithCorners) {
+  RectF a(40, 50, 60, 70);
+  RRectF b(a, 1, 2, 3, 4, 5, 6, 7, 8);
+  RRectF c = RRectFBuilder()
+                 .set_rect(a)
+                 .set_upper_left(1, 2)
+                 .set_upper_right(3, 4)
+                 .set_lower_right(5, 6)
+                 .set_lower_left(7, 8)
+                 .Build();
+  EXPECT_EQ(b, c);
+}
+
+TEST(RRectFTest, BuildFromRoundedCornersF) {
+  RectF a(40, 50, 60, 70);
+  RoundedCornersF corners(1.5f, 2.5f, 3.5f, 4.5f);
+  RRectF b(a, corners);
+  RRectF c = RRectFBuilder().set_rect(a).set_corners(corners).Build();
+  EXPECT_EQ(b, c);
+}
+
+// In the following tests(*CornersHigherThanSize), we test whether the corner
+// radii gets truncated in case of being greater than the width/height.
+TEST(RRectFTest, BuildFromCornersHigherThanSize) {
+  RRectF a(0, 0, 20, 10, 12, 2, 8, 4, 14, 6, 6, 8);
+  RRectF b = RRectFBuilder()
+                 .set_origin(0, 0)
+                 .set_size(20, 10)
+                 .set_upper_left(48, 8)
+                 .set_upper_right(32, 16)
+                 .set_lower_right(56, 24)
+                 .set_lower_left(24, 32)
+                 .Build();
+  EXPECT_EQ(a, b);
+}
+
+TEST(RRectFTest, BuildFromRectFWithCornersHigherThanSize) {
+  RectF a(0, 0, 20, 10);
+  RRectF b(a, 12, 2, 8, 4, 14, 6, 6, 8);
+  RRectF c = RRectFBuilder()
+                 .set_rect(a)
+                 .set_upper_left(48, 8)
+                 .set_upper_right(32, 16)
+                 .set_lower_right(56, 24)
+                 .set_lower_left(24, 32)
+                 .Build();
+  EXPECT_EQ(b, c);
+}
+
+// In this test, we set the radius first but then change the value of the
+// corners.
+TEST(RRectFTest, BuildFromRadiusAndCorners) {
+  RRectF a(40, 50, 60, 70, 1, 2, 3, 4, 15, 25, 15, 25);
+  RRectF b = RRectFBuilder()
+                 .set_origin(40, 50)
+                 .set_size(60, 70)
+                 .set_radius(15, 25)
+                 .set_upper_left(1, 2)
+                 .set_upper_right(3, 4)
+                 .Build();
+  EXPECT_EQ(a, b);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/size.cc b/ui/gfx/geometry/size.cc
new file mode 100644
index 0000000..a7e330c
--- /dev/null
+++ b/ui/gfx/geometry/size.cc
@@ -0,0 +1,122 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/size.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#elif defined(OS_IOS)
+#include <CoreGraphics/CoreGraphics.h>
+#elif defined(OS_MAC)
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+
+#include "base/numerics/clamped_math.h"
+#include "base/numerics/safe_math.h"
+#include "base/strings/stringprintf.h"
+#include "build/build_config.h"
+#include "ui/gfx/geometry/size_conversions.h"
+
+namespace gfx {
+
+#if defined(OS_APPLE)
+Size::Size(const CGSize& s)
+    : width_(s.width < 0 ? 0 : s.width),
+      height_(s.height < 0 ? 0 : s.height) {
+}
+
+Size& Size::operator=(const CGSize& s) {
+  set_width(s.width);
+  set_height(s.height);
+  return *this;
+}
+#endif
+
+void Size::operator+=(const Size& size) {
+  Enlarge(size.width(), size.height());
+}
+
+void Size::operator-=(const Size& size) {
+  Enlarge(-size.width(), -size.height());
+}
+
+#if defined(OS_WIN)
+SIZE Size::ToSIZE() const {
+  SIZE s;
+  s.cx = width();
+  s.cy = height();
+  return s;
+}
+#elif defined(OS_APPLE)
+CGSize Size::ToCGSize() const {
+  return CGSizeMake(width(), height());
+}
+#endif
+
+int Size::GetArea() const {
+  return GetCheckedArea().ValueOrDie();
+}
+
+base::CheckedNumeric<int> Size::GetCheckedArea() const {
+  base::CheckedNumeric<int> checked_area = width();
+  checked_area *= height();
+  return checked_area;
+}
+
+void Size::Enlarge(int grow_width, int grow_height) {
+  SetSize(base::ClampAdd(width(), grow_width),
+          base::ClampAdd(height(), grow_height));
+}
+
+void Size::SetToMin(const Size& other) {
+  width_ = width() <= other.width() ? width() : other.width();
+  height_ = height() <= other.height() ? height() : other.height();
+}
+
+void Size::SetToMax(const Size& other) {
+  width_ = width() >= other.width() ? width() : other.width();
+  height_ = height() >= other.height() ? height() : other.height();
+}
+
+std::string Size::ToString() const {
+  return base::StringPrintf("%dx%d", width(), height());
+}
+
+Size ScaleToCeiledSize(const Size& size, float x_scale, float y_scale) {
+  if (x_scale == 1.f && y_scale == 1.f)
+    return size;
+  return ToCeiledSize(ScaleSize(gfx::SizeF(size), x_scale, y_scale));
+}
+
+Size ScaleToCeiledSize(const Size& size, float scale) {
+  if (scale == 1.f)
+    return size;
+  return ToCeiledSize(ScaleSize(gfx::SizeF(size), scale, scale));
+}
+
+Size ScaleToFlooredSize(const Size& size, float x_scale, float y_scale) {
+  if (x_scale == 1.f && y_scale == 1.f)
+    return size;
+  return ToFlooredSize(ScaleSize(gfx::SizeF(size), x_scale, y_scale));
+}
+
+Size ScaleToFlooredSize(const Size& size, float scale) {
+  if (scale == 1.f)
+    return size;
+  return ToFlooredSize(ScaleSize(gfx::SizeF(size), scale, scale));
+}
+
+Size ScaleToRoundedSize(const Size& size, float x_scale, float y_scale) {
+  if (x_scale == 1.f && y_scale == 1.f)
+    return size;
+  return ToRoundedSize(ScaleSize(gfx::SizeF(size), x_scale, y_scale));
+}
+
+Size ScaleToRoundedSize(const Size& size, float scale) {
+  if (scale == 1.f)
+    return size;
+  return ToRoundedSize(ScaleSize(gfx::SizeF(size), scale, scale));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/size.h b/ui/gfx/geometry/size.h
new file mode 100644
index 0000000..3e5a5b6
--- /dev/null
+++ b/ui/gfx/geometry/size.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_SIZE_H_
+#define UI_GFX_GEOMETRY_SIZE_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "base/numerics/checked_math.h"
+#include "ui/gfx/geometry/size_base.h"
+#include "ui/gfx/geometry/size_f.h"
+
+namespace gfx {
+
+// A size has width and height values.
+class Size : public SizeBase<Size, int> {
+ public:
+  Size() : SizeBase<Size, int>(0, 0) {}
+  Size(int width, int height) : SizeBase<Size, int>(width, height) {}
+  ~Size() {}
+
+  operator SizeF() const {
+    return SizeF(static_cast<float>(width()), static_cast<float>(height()));
+  }
+
+  int GetArea() const { return width() * height(); }
+
+  base::CheckedNumeric<int> GetCheckedArea() const {
+    base::CheckedNumeric<int> checked_area = width();
+    checked_area *= height();
+    return checked_area;
+  }
+
+  std::string ToString() const;
+};
+
+inline bool operator==(const Size& lhs, const Size& rhs) {
+  return lhs.width() == rhs.width() && lhs.height() == rhs.height();
+}
+
+inline bool operator!=(const Size& lhs, const Size& rhs) {
+  return !(lhs == rhs);
+}
+
+// extern template class SizeBase<Size, int>;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_SIZE_H_
diff --git a/ui/gfx/geometry/size_base.h b/ui/gfx/geometry/size_base.h
new file mode 100644
index 0000000..b535b3f
--- /dev/null
+++ b/ui/gfx/geometry/size_base.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_SIZE_BASE_H_
+#define UI_GFX_GEOMETRY_SIZE_BASE_H_
+
+namespace gfx {
+
+// A size has width and height values.
+template <typename Class, typename Type>
+class SizeBase {
+ public:
+  Type width() const { return width_; }
+  Type height() const { return height_; }
+
+  void SetSize(Type width, Type height) {
+    set_width(width);
+    set_height(height);
+  }
+
+  void Enlarge(Type width, Type height) {
+    set_width(width_ + width);
+    set_height(height_ + height);
+  }
+
+  void set_width(Type width) { width_ = width; }
+  void set_height(Type height) { height_ = height; }
+
+  void SetToMin(const Class& other) {
+    width_ = width_ <= other.width_ ? width_ : other.width_;
+    height_ = height_ <= other.height_ ? height_ : other.height_;
+  }
+
+  void SetToMax(const Class& other) {
+    width_ = width_ >= other.width_ ? width_ : other.width_;
+    height_ = height_ >= other.height_ ? height_ : other.height_;
+  }
+
+  bool IsEmpty() const { return (width_ == Type(0)) || (height_ == Type(0)); }
+
+ protected:
+  SizeBase() {}
+  SizeBase(Type width, Type height) : width_(width), height_(height) {}
+
+  // Destructor is intentionally made non virtual and protected.
+  // Do not make this public.
+  ~SizeBase() {}
+
+ private:
+  Type width_;
+  Type height_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_SIZE_BASE_H_
diff --git a/ui/gfx/geometry/size_conversions.cc b/ui/gfx/geometry/size_conversions.cc
new file mode 100644
index 0000000..18dab33
--- /dev/null
+++ b/ui/gfx/geometry/size_conversions.cc
@@ -0,0 +1,24 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/size_conversions.h"
+
+#include "base/numerics/safe_conversions.h"
+
+namespace gfx {
+
+Size ToFlooredSize(const SizeF& size) {
+  return Size(base::ClampFloor(size.width()), base::ClampFloor(size.height()));
+}
+
+Size ToCeiledSize(const SizeF& size) {
+  return Size(base::ClampCeil(size.width()), base::ClampCeil(size.height()));
+}
+
+Size ToRoundedSize(const SizeF& size) {
+  return Size(base::ClampRound(size.width()), base::ClampRound(size.height()));
+}
+
+}  // namespace gfx
+
diff --git a/ui/gfx/geometry/size_conversions.h b/ui/gfx/geometry/size_conversions.h
new file mode 100644
index 0000000..6bc74c0
--- /dev/null
+++ b/ui/gfx/geometry/size_conversions.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_SIZE_CONVERSIONS_H_
+#define UI_GFX_GEOMETRY_SIZE_CONVERSIONS_H_
+
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_f.h"
+
+namespace gfx {
+
+// Returns a Size with each component from the input SizeF floored.
+GEOMETRY_EXPORT Size ToFlooredSize(const SizeF& size);
+
+// Returns a Size with each component from the input SizeF ceiled.
+GEOMETRY_EXPORT Size ToCeiledSize(const SizeF& size);
+
+// Returns a Size with each component from the input SizeF rounded.
+GEOMETRY_EXPORT Size ToRoundedSize(const SizeF& size);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_SIZE_CONVERSIONS_H_
diff --git a/ui/gfx/geometry/size_f.cc b/ui/gfx/geometry/size_f.cc
new file mode 100644
index 0000000..6d08e18
--- /dev/null
+++ b/ui/gfx/geometry/size_f.cc
@@ -0,0 +1,39 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/size_f.h"
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+float SizeF::GetArea() const {
+  return width() * height();
+}
+
+void SizeF::Enlarge(float grow_width, float grow_height) {
+  SetSize(width() + grow_width, height() + grow_height);
+}
+
+void SizeF::SetToMin(const SizeF& other) {
+  width_ = width() <= other.width() ? width() : other.width();
+  height_ = height() <= other.height() ? height() : other.height();
+}
+
+void SizeF::SetToMax(const SizeF& other) {
+  width_ = width() >= other.width() ? width() : other.width();
+  height_ = height() >= other.height() ? height() : other.height();
+}
+
+std::string SizeF::ToString() const {
+  return base::StringPrintf("%fx%f", width(), height());
+}
+
+SizeF ScaleSize(const SizeF& s, float x_scale, float y_scale) {
+  SizeF scaled_s(s);
+  scaled_s.Scale(x_scale, y_scale);
+  return scaled_s;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/size_f.h b/ui/gfx/geometry/size_f.h
new file mode 100644
index 0000000..587f19e
--- /dev/null
+++ b/ui/gfx/geometry/size_f.h
@@ -0,0 +1,56 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_SIZE_F_H_
+#define UI_GFX_GEOMETRY_SIZE_F_H_
+
+#include <iostream>
+#include <string>
+
+#include "ui/gfx/geometry/size_base.h"
+
+namespace gfx {
+
+// A floating-point version of Size.
+class SizeF : public SizeBase<SizeF, float> {
+ public:
+  SizeF() : SizeBase<SizeF, float>(0, 0) {}
+  SizeF(float width, float height) : SizeBase<SizeF, float>(width, height) {}
+  ~SizeF() {}
+
+  float GetArea() const { return width() * height(); }
+
+  void Scale(float scale) { Scale(scale, scale); }
+
+  void Scale(float x_scale, float y_scale) {
+    SetSize(width() * x_scale, height() * y_scale);
+  }
+
+  std::string ToString() const;
+};
+
+inline bool operator==(const SizeF& lhs, const SizeF& rhs) {
+  return lhs.width() == rhs.width() && lhs.height() == rhs.height();
+}
+
+inline bool operator!=(const SizeF& lhs, const SizeF& rhs) {
+  return !(lhs == rhs);
+}
+
+SizeF ScaleSize(const SizeF& p, float x_scale, float y_scale);
+
+inline SizeF ScaleSize(const SizeF& p, float scale) {
+  return ScaleSize(p, scale, scale);
+}
+
+inline std::ostream& operator<<(std::ostream& stream, const SizeF& size) {
+  stream << "{width=" << size.width() << " height=" << size.height() << "}";
+  return stream;
+}
+
+// extern template class SizeBase<SizeF, float>;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_SIZE_F_H_
diff --git a/ui/gfx/geometry/size_unittest.cc b/ui/gfx/geometry/size_unittest.cc
new file mode 100644
index 0000000..b3ec2ec
--- /dev/null
+++ b/ui/gfx/geometry/size_unittest.cc
@@ -0,0 +1,300 @@
+// Copyright (c) 2012 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.
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/geometry/size_f.h"
+
+namespace gfx {
+
+namespace {
+
+int TestSizeF(const SizeF& s) {
+  return s.width();
+}
+
+}  // namespace
+
+TEST(SizeTest, ToSizeF) {
+  // Check that explicit conversion from integer to float compiles.
+  Size a(10, 20);
+  float width = TestSizeF(gfx::SizeF(a));
+  EXPECT_EQ(width, a.width());
+
+  SizeF b(10, 20);
+
+  EXPECT_EQ(b, gfx::SizeF(a));
+}
+
+TEST(SizeTest, ToFlooredSize) {
+  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0, 0)));
+  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.0001f, 0.0001f)));
+  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.4999f, 0.4999f)));
+  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.5f, 0.5f)));
+  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.9999f, 0.9999f)));
+
+  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10, 10)));
+  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.0001f, 10.0001f)));
+  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.4999f, 10.4999f)));
+  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.5f, 10.5f)));
+  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.9999f, 10.9999f)));
+}
+
+TEST(SizeTest, ToCeiledSize) {
+  EXPECT_EQ(Size(0, 0), ToCeiledSize(SizeF(0, 0)));
+  EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.0001f, 0.0001f)));
+  EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.4999f, 0.4999f)));
+  EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.5f, 0.5f)));
+  EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.9999f, 0.9999f)));
+
+  EXPECT_EQ(Size(10, 10), ToCeiledSize(SizeF(10, 10)));
+  EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.0001f, 10.0001f)));
+  EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.4999f, 10.4999f)));
+  EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.5f, 10.5f)));
+  EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.9999f, 10.9999f)));
+}
+
+TEST(SizeTest, ToRoundedSize) {
+  EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0, 0)));
+  EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0.0001f, 0.0001f)));
+  EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0.4999f, 0.4999f)));
+  EXPECT_EQ(Size(1, 1), ToRoundedSize(SizeF(0.5f, 0.5f)));
+  EXPECT_EQ(Size(1, 1), ToRoundedSize(SizeF(0.9999f, 0.9999f)));
+
+  EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10, 10)));
+  EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10.0001f, 10.0001f)));
+  EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10.4999f, 10.4999f)));
+  EXPECT_EQ(Size(11, 11), ToRoundedSize(SizeF(10.5f, 10.5f)));
+  EXPECT_EQ(Size(11, 11), ToRoundedSize(SizeF(10.9999f, 10.9999f)));
+}
+
+TEST(SizeTest, ClampSize) {
+  Size a;
+
+  a = Size(3, 5);
+  EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
+  a.SetToMax(Size(2, 4));
+  EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
+  a.SetToMax(Size(3, 5));
+  EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
+  a.SetToMax(Size(4, 2));
+  EXPECT_EQ(Size(4, 5).ToString(), a.ToString());
+  a.SetToMax(Size(8, 10));
+  EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
+
+  a.SetToMin(Size(9, 11));
+  EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
+  a.SetToMin(Size(8, 10));
+  EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
+  a.SetToMin(Size(11, 9));
+  EXPECT_EQ(Size(8, 9).ToString(), a.ToString());
+  a.SetToMin(Size(7, 11));
+  EXPECT_EQ(Size(7, 9).ToString(), a.ToString());
+  a.SetToMin(Size(3, 5));
+  EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
+}
+
+TEST(SizeTest, ClampSizeF) {
+  SizeF a;
+
+  a = SizeF(3.5f, 5.5f);
+  EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(SizeF(2.5f, 4.5f));
+  EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(SizeF(3.5f, 5.5f));
+  EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(SizeF(4.5f, 2.5f));
+  EXPECT_EQ(SizeF(4.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(SizeF(8.5f, 10.5f));
+  EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
+
+  a.SetToMin(SizeF(9.5f, 11.5f));
+  EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
+  a.SetToMin(SizeF(8.5f, 10.5f));
+  EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
+  a.SetToMin(SizeF(11.5f, 9.5f));
+  EXPECT_EQ(SizeF(8.5f, 9.5f).ToString(), a.ToString());
+  a.SetToMin(SizeF(7.5f, 11.5f));
+  EXPECT_EQ(SizeF(7.5f, 9.5f).ToString(), a.ToString());
+  a.SetToMin(SizeF(3.5f, 5.5f));
+  EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
+}
+
+TEST(SizeTest, Enlarge) {
+  Size test(3, 4);
+  test.Enlarge(5, -8);
+  EXPECT_EQ(test, Size(8, -4));
+}
+
+TEST(SizeTest, IntegerOverflow) {
+  int int_max = std::numeric_limits<int>::max();
+  int int_min = std::numeric_limits<int>::min();
+
+  Size max_size(int_max, int_max);
+  Size min_size(int_min, int_min);
+  Size test;
+
+  test = Size();
+  test.Enlarge(int_max, int_max);
+  EXPECT_EQ(test, max_size);
+
+  test = Size();
+  test.Enlarge(int_min, int_min);
+  EXPECT_EQ(test, min_size);
+
+  test = Size(10, 20);
+  test.Enlarge(int_max, int_max);
+  EXPECT_EQ(test, max_size);
+
+  test = Size(-10, -20);
+  test.Enlarge(int_min, int_min);
+  EXPECT_EQ(test, min_size);
+}
+
+// This checks that we set IsEmpty appropriately.
+TEST(SizeTest, TrivialDimensionTests) {
+  const float clearly_trivial = SizeF::kTrivial / 2.f;
+  const float massize_dimension = 4e13f;
+
+  // First, using the constructor.
+  EXPECT_TRUE(SizeF(clearly_trivial, 1.f).IsEmpty());
+  EXPECT_TRUE(SizeF(.01f, clearly_trivial).IsEmpty());
+  EXPECT_TRUE(SizeF(0.f, 0.f).IsEmpty());
+  EXPECT_FALSE(SizeF(.01f, .01f).IsEmpty());
+
+  // Then use the setter.
+  SizeF test(2.f, 1.f);
+  EXPECT_FALSE(test.IsEmpty());
+
+  test.SetSize(clearly_trivial, 1.f);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.SetSize(.01f, clearly_trivial);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.SetSize(0.f, 0.f);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.SetSize(.01f, .01f);
+  EXPECT_FALSE(test.IsEmpty());
+
+  // Now just one dimension at a time.
+  test.set_width(clearly_trivial);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.set_width(massize_dimension);
+  test.set_height(clearly_trivial);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.set_width(clearly_trivial);
+  test.set_height(massize_dimension);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.set_width(2.f);
+  EXPECT_FALSE(test.IsEmpty());
+}
+
+// These are the ramifications of the decision to keep the recorded size
+// at zero for trivial sizes.
+TEST(SizeTest, ClampsToZero) {
+  const float clearly_trivial = SizeF::kTrivial / 2.f;
+  const float nearly_trivial = SizeF::kTrivial * 1.5f;
+
+  SizeF test(clearly_trivial, 1.f);
+
+  EXPECT_FLOAT_EQ(0.f, test.width());
+  EXPECT_FLOAT_EQ(1.f, test.height());
+
+  test.SetSize(.01f, clearly_trivial);
+
+  EXPECT_FLOAT_EQ(.01f, test.width());
+  EXPECT_FLOAT_EQ(0.f, test.height());
+
+  test.SetSize(nearly_trivial, nearly_trivial);
+
+  EXPECT_FLOAT_EQ(nearly_trivial, test.width());
+  EXPECT_FLOAT_EQ(nearly_trivial, test.height());
+
+  test.Scale(0.5f);
+
+  EXPECT_FLOAT_EQ(0.f, test.width());
+  EXPECT_FLOAT_EQ(0.f, test.height());
+
+  test.SetSize(0.f, 0.f);
+  test.Enlarge(clearly_trivial, clearly_trivial);
+  test.Enlarge(clearly_trivial, clearly_trivial);
+  test.Enlarge(clearly_trivial, clearly_trivial);
+
+  EXPECT_EQ(SizeF(0.f, 0.f), test);
+}
+
+// These make sure the constructor and setter have the same effect on the
+// boundary case. This claims to know the boundary, but not which way it goes.
+TEST(SizeTest, ConsistentClamping) {
+  SizeF resized;
+
+  resized.SetSize(SizeF::kTrivial, 0.f);
+  EXPECT_EQ(SizeF(SizeF::kTrivial, 0.f), resized);
+
+  resized.SetSize(0.f, SizeF::kTrivial);
+  EXPECT_EQ(SizeF(0.f, SizeF::kTrivial), resized);
+}
+
+// Let's make sure we don't unexpectedly grow the struct by adding constants.
+// Also, if some platform packs floats inefficiently, it would be worth noting.
+TEST(SizeTest, StaysSmall) {
+  EXPECT_EQ(2 * sizeof(float), sizeof(SizeF));
+}
+
+TEST(SizeTest, OperatorAddSub) {
+  Size lhs(100, 20);
+  Size rhs(50, 10);
+
+  lhs += rhs;
+  EXPECT_EQ(Size(150, 30), lhs);
+
+  lhs = Size(100, 20);
+  EXPECT_EQ(Size(150, 30), lhs + rhs);
+
+  lhs = Size(100, 20);
+  lhs -= rhs;
+  EXPECT_EQ(Size(50, 10), lhs);
+
+  lhs = Size(100, 20);
+  EXPECT_EQ(Size(50, 10), lhs - rhs);
+}
+
+TEST(SizeTest, OperatorAddOverflow) {
+  int int_max = std::numeric_limits<int>::max();
+
+  Size lhs(int_max, int_max);
+  Size rhs(int_max, int_max);
+  EXPECT_EQ(Size(int_max, int_max), lhs + rhs);
+}
+
+TEST(SizeTest, OperatorSubClampAtZero) {
+  Size lhs(10, 10);
+  Size rhs(100, 100);
+  EXPECT_EQ(Size(0, 0), lhs - rhs);
+
+  lhs = Size(10, 10);
+  rhs = Size(100, 100);
+  lhs -= rhs;
+  EXPECT_EQ(Size(0, 0), lhs);
+}
+
+TEST(SizeTest, OperatorCompare) {
+  Size lhs(100, 20);
+  Size rhs(50, 10);
+
+  EXPECT_TRUE(lhs != rhs);
+  EXPECT_FALSE(lhs == rhs);
+
+  rhs = Size(100, 20);
+  EXPECT_TRUE(lhs == rhs);
+  EXPECT_FALSE(lhs != rhs);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/skia_conversions.cc b/ui/gfx/geometry/skia_conversions.cc
new file mode 100644
index 0000000..72ac7b3
--- /dev/null
+++ b/ui/gfx/geometry/skia_conversions.cc
@@ -0,0 +1,96 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/geometry/skia_conversions.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/numerics/safe_conversions.h"
+#include "base/numerics/safe_math.h"
+#include "ui/gfx/geometry/quad_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/transform.h"
+
+namespace gfx {
+
+SkPoint PointToSkPoint(const Point& point) {
+  return SkPoint::Make(SkIntToScalar(point.x()), SkIntToScalar(point.y()));
+}
+
+SkIPoint PointToSkIPoint(const Point& point) {
+  return SkIPoint::Make(point.x(), point.y());
+}
+
+SkPoint PointFToSkPoint(const PointF& point) {
+  return SkPoint::Make(SkFloatToScalar(point.x()), SkFloatToScalar(point.y()));
+}
+
+SkRect RectToSkRect(const Rect& rect) {
+  return SkRect::MakeXYWH(SkIntToScalar(rect.x()), SkIntToScalar(rect.y()),
+                          SkIntToScalar(rect.width()),
+                          SkIntToScalar(rect.height()));
+}
+
+SkIRect RectToSkIRect(const Rect& rect) {
+  return SkIRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height());
+}
+
+Rect SkIRectToRect(const SkIRect& rect) {
+  Rect result;
+  result.SetByBounds(rect.left(), rect.top(), rect.right(), rect.bottom());
+  return result;
+}
+
+SkRect RectFToSkRect(const RectF& rect) {
+  return SkRect::MakeXYWH(SkFloatToScalar(rect.x()), SkFloatToScalar(rect.y()),
+                          SkFloatToScalar(rect.width()),
+                          SkFloatToScalar(rect.height()));
+}
+
+RectF SkRectToRectF(const SkRect& rect) {
+  return RectF(SkScalarToFloat(rect.x()), SkScalarToFloat(rect.y()),
+               SkScalarToFloat(rect.width()), SkScalarToFloat(rect.height()));
+}
+
+SkSize SizeFToSkSize(const SizeF& size) {
+  return SkSize::Make(SkFloatToScalar(size.width()),
+                      SkFloatToScalar(size.height()));
+}
+
+SkISize SizeToSkISize(const Size& size) {
+  return SkISize::Make(size.width(), size.height());
+}
+
+SizeF SkSizeToSizeF(const SkSize& size) {
+  return SizeF(SkScalarToFloat(size.width()), SkScalarToFloat(size.height()));
+}
+
+Size SkISizeToSize(const SkISize& size) {
+  return Size(size.width(), size.height());
+}
+
+void TransformToFlattenedSkMatrix(const gfx::Transform& transform,
+                                  SkMatrix* flattened) {
+  // Convert from 4x4 to 3x3 by dropping the third row and column.
+  flattened->set(0, transform.matrix().get(0, 0));
+  flattened->set(1, transform.matrix().get(0, 1));
+  flattened->set(2, transform.matrix().get(0, 3));
+  flattened->set(3, transform.matrix().get(1, 0));
+  flattened->set(4, transform.matrix().get(1, 1));
+  flattened->set(5, transform.matrix().get(1, 3));
+  flattened->set(6, transform.matrix().get(3, 0));
+  flattened->set(7, transform.matrix().get(3, 1));
+  flattened->set(8, transform.matrix().get(3, 3));
+}
+
+void QuadFToSkPoints(const gfx::QuadF& quad, SkPoint points[4]) {
+  points[0] = PointFToSkPoint(quad.p1());
+  points[1] = PointFToSkPoint(quad.p2());
+  points[2] = PointFToSkPoint(quad.p3());
+  points[3] = PointFToSkPoint(quad.p4());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/skia_conversions.h b/ui/gfx/geometry/skia_conversions.h
new file mode 100644
index 0000000..a4c1329
--- /dev/null
+++ b/ui/gfx/geometry/skia_conversions.h
@@ -0,0 +1,47 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_SKIA_CONVERSIONS_H_
+#define UI_GFX_GEOMETRY_SKIA_CONVERSIONS_H_
+
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkRect.h"
+#include "ui/gfx/geometry/geometry_skia_export.h"
+#include "ui/gfx/geometry/quad_f.h"
+#include "ui/gfx/geometry/size.h"
+
+class SkMatrix;
+
+namespace gfx {
+
+class Point;
+class PointF;
+class Rect;
+class RectF;
+class Transform;
+
+// Convert between Skia and gfx types.
+GEOMETRY_SKIA_EXPORT SkPoint PointToSkPoint(const Point& point);
+GEOMETRY_SKIA_EXPORT SkIPoint PointToSkIPoint(const Point& point);
+GEOMETRY_SKIA_EXPORT SkPoint PointFToSkPoint(const PointF& point);
+GEOMETRY_SKIA_EXPORT SkRect RectToSkRect(const Rect& rect);
+GEOMETRY_SKIA_EXPORT SkIRect RectToSkIRect(const Rect& rect);
+GEOMETRY_SKIA_EXPORT Rect SkIRectToRect(const SkIRect& rect);
+GEOMETRY_SKIA_EXPORT SkRect RectFToSkRect(const RectF& rect);
+GEOMETRY_SKIA_EXPORT RectF SkRectToRectF(const SkRect& rect);
+GEOMETRY_SKIA_EXPORT SkSize SizeFToSkSize(const SizeF& size);
+GEOMETRY_SKIA_EXPORT SkISize SizeToSkISize(const Size& size);
+GEOMETRY_SKIA_EXPORT SizeF SkSizeToSizeF(const SkSize& size);
+GEOMETRY_SKIA_EXPORT Size SkISizeToSize(const SkISize& size);
+
+GEOMETRY_SKIA_EXPORT void QuadFToSkPoints(const gfx::QuadF& quad,
+                                          SkPoint points[4]);
+
+GEOMETRY_SKIA_EXPORT void TransformToFlattenedSkMatrix(
+    const gfx::Transform& transform,
+    SkMatrix* flattened);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_SKIA_CONVERSIONS_H_
diff --git a/ui/gfx/geometry/test/rect_test_util.cc b/ui/gfx/geometry/test/rect_test_util.cc
new file mode 100644
index 0000000..bcc943b
--- /dev/null
+++ b/ui/gfx/geometry/test/rect_test_util.cc
@@ -0,0 +1,23 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/geometry/test/rect_test_util.h"
+
+namespace gfx {
+namespace test {
+
+testing::AssertionResult RectContains(const gfx::Rect& outer_rect,
+                                      const gfx::Rect& inner_rect) {
+  if (outer_rect.Contains(inner_rect)) {
+    return testing::AssertionSuccess()
+           << "outer_rect (" << outer_rect.ToString()
+           << ") does contain inner_rect (" << inner_rect.ToString() << ")";
+  }
+  return testing::AssertionFailure() << "outer_rect (" << outer_rect.ToString()
+                                     << ") does not contain inner_rect ("
+                                     << inner_rect.ToString() << ")";
+}
+
+}  // namespace test
+}  // namespace gfx
diff --git a/ui/gfx/geometry/test/rect_test_util.h b/ui/gfx/geometry/test/rect_test_util.h
new file mode 100644
index 0000000..91d7b2a
--- /dev/null
+++ b/ui/gfx/geometry/test/rect_test_util.h
@@ -0,0 +1,20 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_TEST_RECT_TEST_UTIL_H_
+#define UI_GFX_GEOMETRY_TEST_RECT_TEST_UTIL_H_
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace gfx {
+namespace test {
+
+testing::AssertionResult RectContains(const gfx::Rect& outer_rect,
+                                      const gfx::Rect& inner_rect);
+
+}  // namespace test
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_TEST_RECT_TEST_UTIL_H_
diff --git a/ui/gfx/geometry/test/size_test_util.h b/ui/gfx/geometry/test/size_test_util.h
new file mode 100644
index 0000000..43a6739
--- /dev/null
+++ b/ui/gfx/geometry/test/size_test_util.h
@@ -0,0 +1,20 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_TEST_SIZE_TEST_UTIL_H_
+#define UI_GFX_GEOMETRY_TEST_SIZE_TEST_UTIL_H_
+
+#define EXPECT_FLOAT_SIZE_EQ(expected, actual)               \
+  do {                                                       \
+    EXPECT_FLOAT_EQ((expected).width(), (actual).width());   \
+    EXPECT_FLOAT_EQ((expected).height(), (actual).height()); \
+  } while (false)
+
+#define EXPECT_SIZE_EQ(expected, actual)               \
+  do {                                                 \
+    EXPECT_EQ((expected).width(), (actual).width());   \
+    EXPECT_EQ((expected).height(), (actual).height()); \
+  } while (false)
+
+#endif  // UI_GFX_GEOMETRY_TEST_SIZE_TEST_UTIL_H_
diff --git a/ui/gfx/geometry/test/transform_test_util.cc b/ui/gfx/geometry/test/transform_test_util.cc
new file mode 100644
index 0000000..e8fa4b5
--- /dev/null
+++ b/ui/gfx/geometry/test/transform_test_util.cc
@@ -0,0 +1,46 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/geometry/test/transform_test_util.h"
+
+#include "base/check.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+
+// NOTE: even though transform data types use double precision, we only check
+// for equality within single-precision error bounds because many transforms
+// originate from single-precision data types such as quads/rects/etc.
+
+void ExpectTransformationMatrixEq(const Transform& expected,
+                                  const Transform& actual) {
+  for (int row = 0; row < 4; ++row) {
+    for (int col = 0; col < 4; ++col) {
+      EXPECT_FLOAT_EQ(expected.matrix().get(row, col),
+                      actual.matrix().get(row, col))
+          << "row: " << row << " col: " << col;
+    }
+  }
+}
+
+void ExpectTransformationMatrixNear(const Transform& expected,
+                                    const Transform& actual,
+                                    float abs_error) {
+  for (int row = 0; row < 4; ++row) {
+    for (int col = 0; col < 4; ++col) {
+      EXPECT_NEAR(expected.matrix().get(row, col),
+                  actual.matrix().get(row, col), abs_error)
+          << "row: " << row << " col: " << col;
+    }
+  }
+}
+
+Transform InvertAndCheck(const Transform& transform) {
+  Transform result(Transform::kSkipInitialization);
+  bool inverted_successfully = transform.GetInverse(&result);
+  DCHECK(inverted_successfully);
+  return result;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/test/transform_test_util.h b/ui/gfx/geometry/test/transform_test_util.h
new file mode 100644
index 0000000..b9dbc90
--- /dev/null
+++ b/ui/gfx/geometry/test/transform_test_util.h
@@ -0,0 +1,30 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_TEST_TRANSFORM_TEST_UTIL_H_
+#define UI_GFX_GEOMETRY_TEST_TRANSFORM_TEST_UTIL_H_
+
+#include "ui/gfx/geometry/transform.h"
+
+namespace gfx {
+
+// This is a function rather than a macro because when this is included as a
+// macro in bulk, it causes a significant slow-down in compilation time. This
+// problem exists with both gcc and clang, and bugs have been filed at
+// http://llvm.org/bugs/show_bug.cgi?id=13651
+// and http://gcc.gnu.org/bugzilla/show_bug.cgi?id=54337
+void ExpectTransformationMatrixEq(const Transform& expected,
+                                  const Transform& actual);
+
+void ExpectTransformationMatrixNear(const Transform& expected,
+                                    const Transform& actual,
+                                    float abs_error);
+
+// Should be used in test code only, for convenience. Production code should use
+// the gfx::Transform::GetInverse() API.
+Transform InvertAndCheck(const Transform& transform);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_TEST_TRANSFORM_TEST_UTIL_H_
diff --git a/ui/gfx/geometry/transform.cc b/ui/gfx/geometry/transform.cc
new file mode 100644
index 0000000..eee5af7
--- /dev/null
+++ b/ui/gfx/geometry/transform.cc
@@ -0,0 +1,634 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/transform.h"
+
+#include "base/check_op.h"
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/geometry/angle_conversions.h"
+#include "ui/gfx/geometry/box_f.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/quaternion.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rrect_f.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/geometry/transform_util.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+namespace {
+
+const SkScalar kEpsilon = std::numeric_limits<float>::epsilon();
+
+SkScalar TanDegrees(double degrees) {
+  return SkDoubleToScalar(std::tan(gfx::DegToRad(degrees)));
+}
+
+inline bool ApproximatelyZero(SkScalar x, SkScalar tolerance) {
+  return std::abs(x) <= tolerance;
+}
+
+inline bool ApproximatelyOne(SkScalar x, SkScalar tolerance) {
+  return std::abs(x - 1) <= tolerance;
+}
+
+}  // namespace
+
+Transform::Transform(SkScalar col1row1,
+                     SkScalar col2row1,
+                     SkScalar col3row1,
+                     SkScalar col4row1,
+                     SkScalar col1row2,
+                     SkScalar col2row2,
+                     SkScalar col3row2,
+                     SkScalar col4row2,
+                     SkScalar col1row3,
+                     SkScalar col2row3,
+                     SkScalar col3row3,
+                     SkScalar col4row3,
+                     SkScalar col1row4,
+                     SkScalar col2row4,
+                     SkScalar col3row4,
+                     SkScalar col4row4)
+    : matrix_(skia::Matrix44::kUninitialized_Constructor) {
+  matrix_.set4x4(col1row1, col1row2, col1row3, col1row4, col2row1, col2row2,
+                 col2row3, col2row4, col3row1, col3row2, col3row3, col3row4,
+                 col4row1, col4row2, col4row3, col4row4);
+}
+
+Transform::Transform(SkScalar col1row1,
+                     SkScalar col2row1,
+                     SkScalar col1row2,
+                     SkScalar col2row2,
+                     SkScalar x_translation,
+                     SkScalar y_translation)
+    : matrix_(skia::Matrix44::kUninitialized_Constructor) {
+  matrix_.set4x4(col1row1, col1row2, 0, 0, col2row1, col2row2, 0, 0, 0, 0, 1, 0,
+                 x_translation, y_translation, 0, 1);
+}
+
+Transform::Transform(const Quaternion& q)
+    : matrix_(skia::Matrix44::kUninitialized_Constructor) {
+  double x = q.x();
+  double y = q.y();
+  double z = q.z();
+  double w = q.w();
+
+  // Implicitly calls matrix.setIdentity()
+  matrix_.set3x3(SkDoubleToScalar(1.0 - 2.0 * (y * y + z * z)),
+                 SkDoubleToScalar(2.0 * (x * y + z * w)),
+                 SkDoubleToScalar(2.0 * (x * z - y * w)),
+                 SkDoubleToScalar(2.0 * (x * y - z * w)),
+                 SkDoubleToScalar(1.0 - 2.0 * (x * x + z * z)),
+                 SkDoubleToScalar(2.0 * (y * z + x * w)),
+                 SkDoubleToScalar(2.0 * (x * z + y * w)),
+                 SkDoubleToScalar(2.0 * (y * z - x * w)),
+                 SkDoubleToScalar(1.0 - 2.0 * (x * x + y * y)));
+}
+
+void Transform::RotateAboutXAxis(double degrees) {
+  double radians = gfx::DegToRad(degrees);
+  SkScalar cosTheta = SkDoubleToScalar(std::cos(radians));
+  SkScalar sinTheta = SkDoubleToScalar(std::sin(radians));
+  if (matrix_.isIdentity()) {
+    matrix_.set3x3(1, 0, 0, 0, cosTheta, sinTheta, 0, -sinTheta, cosTheta);
+  } else {
+    skia::Matrix44 rot(skia::Matrix44::kUninitialized_Constructor);
+    rot.set3x3(1, 0, 0, 0, cosTheta, sinTheta, 0, -sinTheta, cosTheta);
+    matrix_.preConcat(rot);
+  }
+}
+
+void Transform::RotateAboutYAxis(double degrees) {
+  double radians = gfx::DegToRad(degrees);
+  SkScalar cosTheta = SkDoubleToScalar(std::cos(radians));
+  SkScalar sinTheta = SkDoubleToScalar(std::sin(radians));
+  if (matrix_.isIdentity()) {
+    // Note carefully the placement of the -sinTheta for rotation about
+    // y-axis is different than rotation about x-axis or z-axis.
+    matrix_.set3x3(cosTheta, 0, -sinTheta, 0, 1, 0, sinTheta, 0, cosTheta);
+  } else {
+    skia::Matrix44 rot(skia::Matrix44::kUninitialized_Constructor);
+    rot.set3x3(cosTheta, 0, -sinTheta, 0, 1, 0, sinTheta, 0, cosTheta);
+    matrix_.preConcat(rot);
+  }
+}
+
+void Transform::RotateAboutZAxis(double degrees) {
+  double radians = gfx::DegToRad(degrees);
+  SkScalar cosTheta = SkDoubleToScalar(std::cos(radians));
+  SkScalar sinTheta = SkDoubleToScalar(std::sin(radians));
+  if (matrix_.isIdentity()) {
+    matrix_.set3x3(cosTheta, sinTheta, 0, -sinTheta, cosTheta, 0, 0, 0, 1);
+  } else {
+    skia::Matrix44 rot(skia::Matrix44::kUninitialized_Constructor);
+    rot.set3x3(cosTheta, sinTheta, 0, -sinTheta, cosTheta, 0, 0, 0, 1);
+    matrix_.preConcat(rot);
+  }
+}
+
+void Transform::RotateAbout(const Vector3dF& axis, double degrees) {
+  if (matrix_.isIdentity()) {
+    matrix_.setRotateDegreesAbout(axis.x(), axis.y(), axis.z(),
+                                  SkDoubleToScalar(degrees));
+  } else {
+    skia::Matrix44 rot(skia::Matrix44::kUninitialized_Constructor);
+    rot.setRotateDegreesAbout(axis.x(), axis.y(), axis.z(),
+                              SkDoubleToScalar(degrees));
+    matrix_.preConcat(rot);
+  }
+}
+
+void Transform::Scale(SkScalar x, SkScalar y) {
+  matrix_.preScale(x, y, 1);
+}
+
+void Transform::PostScale(SkScalar x, SkScalar y) {
+  matrix_.postScale(x, y, 1);
+}
+
+void Transform::Scale3d(SkScalar x, SkScalar y, SkScalar z) {
+  matrix_.preScale(x, y, z);
+}
+
+void Transform::Translate(const Vector2dF& offset) {
+  Translate(offset.x(), offset.y());
+}
+
+void Transform::Translate(SkScalar x, SkScalar y) {
+  matrix_.preTranslate(x, y, 0);
+}
+
+void Transform::PostTranslate(const Vector2dF& offset) {
+  PostTranslate(offset.x(), offset.y());
+}
+
+void Transform::PostTranslate(SkScalar x, SkScalar y) {
+  matrix_.postTranslate(x, y, 0);
+}
+
+void Transform::Translate3d(const Vector3dF& offset) {
+  Translate3d(offset.x(), offset.y(), offset.z());
+}
+
+void Transform::Translate3d(SkScalar x, SkScalar y, SkScalar z) {
+  matrix_.preTranslate(x, y, z);
+}
+
+void Transform::Skew(double angle_x, double angle_y) {
+  if (matrix_.isIdentity()) {
+    matrix_.set(0, 1, TanDegrees(angle_x));
+    matrix_.set(1, 0, TanDegrees(angle_y));
+  } else {
+    skia::Matrix44 skew(skia::Matrix44::kIdentity_Constructor);
+    skew.set(0, 1, TanDegrees(angle_x));
+    skew.set(1, 0, TanDegrees(angle_y));
+    matrix_.preConcat(skew);
+  }
+}
+
+void Transform::ApplyPerspectiveDepth(SkScalar depth) {
+  if (depth == 0)
+    return;
+  if (matrix_.isIdentity()) {
+    matrix_.set(3, 2, -SK_Scalar1 / depth);
+  } else {
+    skia::Matrix44 m(skia::Matrix44::kIdentity_Constructor);
+    m.set(3, 2, -SK_Scalar1 / depth);
+    matrix_.preConcat(m);
+  }
+}
+
+void Transform::PreconcatTransform(const Transform& transform) {
+  matrix_.preConcat(transform.matrix_);
+}
+
+void Transform::ConcatTransform(const Transform& transform) {
+  matrix_.postConcat(transform.matrix_);
+}
+
+bool Transform::IsApproximatelyIdentityOrTranslation(SkScalar tolerance) const {
+  DCHECK_GE(tolerance, 0);
+  return ApproximatelyOne(matrix_.get(0, 0), tolerance) &&
+         ApproximatelyZero(matrix_.get(1, 0), tolerance) &&
+         ApproximatelyZero(matrix_.get(2, 0), tolerance) &&
+         matrix_.get(3, 0) == 0 &&
+         ApproximatelyZero(matrix_.get(0, 1), tolerance) &&
+         ApproximatelyOne(matrix_.get(1, 1), tolerance) &&
+         ApproximatelyZero(matrix_.get(2, 1), tolerance) &&
+         matrix_.get(3, 1) == 0 &&
+         ApproximatelyZero(matrix_.get(0, 2), tolerance) &&
+         ApproximatelyZero(matrix_.get(1, 2), tolerance) &&
+         ApproximatelyOne(matrix_.get(2, 2), tolerance) &&
+         matrix_.get(3, 2) == 0 && matrix_.get(3, 3) == 1;
+}
+
+bool Transform::IsApproximatelyIdentityOrIntegerTranslation(
+    SkScalar tolerance) const {
+  if (!IsApproximatelyIdentityOrTranslation(tolerance))
+    return false;
+
+  for (float t : {matrix_.get(0, 3), matrix_.get(1, 3), matrix_.get(2, 3)}) {
+    if (!base::IsValueInRangeForNumericType<int>(t) ||
+        std::abs(std::round(t) - t) > tolerance)
+      return false;
+  }
+  return true;
+}
+
+bool Transform::IsIdentityOrIntegerTranslation() const {
+  if (!IsIdentityOrTranslation())
+    return false;
+
+  for (float t : {matrix_.get(0, 3), matrix_.get(1, 3), matrix_.get(2, 3)}) {
+    if (!base::IsValueInRangeForNumericType<int>(t) || static_cast<int>(t) != t)
+      return false;
+  }
+  return true;
+}
+
+bool Transform::IsBackFaceVisible() const {
+  // Compute whether a layer with a forward-facing normal of (0, 0, 1, 0)
+  // would have its back face visible after applying the transform.
+  if (matrix_.isIdentity())
+    return false;
+
+  // This is done by transforming the normal and seeing if the resulting z
+  // value is positive or negative. However, note that transforming a normal
+  // actually requires using the inverse-transpose of the original transform.
+  //
+  // We can avoid inverting and transposing the matrix since we know we want
+  // to transform only the specific normal vector (0, 0, 1, 0). In this case,
+  // we only need the 3rd row, 3rd column of the inverse-transpose. We can
+  // calculate only the 3rd row 3rd column element of the inverse, skipping
+  // everything else.
+  //
+  // For more information, refer to:
+  //   http://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution
+  //
+
+  double determinant = matrix_.determinant();
+
+  // If matrix was not invertible, then just assume back face is not visible.
+  if (determinant == 0)
+    return false;
+
+  // Compute the cofactor of the 3rd row, 3rd column.
+  double cofactor_part_1 =
+      matrix_.get(0, 0) * matrix_.get(1, 1) * matrix_.get(3, 3);
+
+  double cofactor_part_2 =
+      matrix_.get(0, 1) * matrix_.get(1, 3) * matrix_.get(3, 0);
+
+  double cofactor_part_3 =
+      matrix_.get(0, 3) * matrix_.get(1, 0) * matrix_.get(3, 1);
+
+  double cofactor_part_4 =
+      matrix_.get(0, 0) * matrix_.get(1, 3) * matrix_.get(3, 1);
+
+  double cofactor_part_5 =
+      matrix_.get(0, 1) * matrix_.get(1, 0) * matrix_.get(3, 3);
+
+  double cofactor_part_6 =
+      matrix_.get(0, 3) * matrix_.get(1, 1) * matrix_.get(3, 0);
+
+  double cofactor33 = cofactor_part_1 + cofactor_part_2 + cofactor_part_3 -
+                      cofactor_part_4 - cofactor_part_5 - cofactor_part_6;
+
+  // Technically the transformed z component is cofactor33 / determinant.  But
+  // we can avoid the costly division because we only care about the resulting
+  // +/- sign; we can check this equivalently by multiplication.
+  return cofactor33 * determinant < -kEpsilon;
+}
+
+bool Transform::GetInverse(Transform* transform) const {
+  if (!matrix_.invert(&transform->matrix_)) {
+    // Initialize the return value to identity if this matrix turned
+    // out to be un-invertible.
+    transform->MakeIdentity();
+    return false;
+  }
+
+  return true;
+}
+
+bool Transform::Preserves2dAxisAlignment() const {
+  // Check whether an axis aligned 2-dimensional rect would remain axis-aligned
+  // after being transformed by this matrix (and implicitly projected by
+  // dropping any non-zero z-values).
+  //
+  // The 4th column can be ignored because translations don't affect axis
+  // alignment. The 3rd column can be ignored because we are assuming 2d
+  // inputs, where z-values will be zero. The 3rd row can also be ignored
+  // because we are assuming 2d outputs, and any resulting z-value is dropped
+  // anyway. For the inner 2x2 portion, the only effects that keep a rect axis
+  // aligned are (1) swapping axes and (2) scaling axes. This can be checked by
+  // verifying only 1 element of every column and row is non-zero.  Degenerate
+  // cases that project the x or y dimension to zero are considered to preserve
+  // axis alignment.
+  //
+  // If the matrix does have perspective component that is affected by x or y
+  // values: The current implementation conservatively assumes that axis
+  // alignment is not preserved.
+
+  bool has_x_or_y_perspective =
+      matrix_.get(3, 0) != 0 || matrix_.get(3, 1) != 0;
+
+  int num_non_zero_in_row_0 = 0;
+  int num_non_zero_in_row_1 = 0;
+  int num_non_zero_in_col_0 = 0;
+  int num_non_zero_in_col_1 = 0;
+
+  if (std::abs(matrix_.get(0, 0)) > kEpsilon) {
+    num_non_zero_in_row_0++;
+    num_non_zero_in_col_0++;
+  }
+
+  if (std::abs(matrix_.get(0, 1)) > kEpsilon) {
+    num_non_zero_in_row_0++;
+    num_non_zero_in_col_1++;
+  }
+
+  if (std::abs(matrix_.get(1, 0)) > kEpsilon) {
+    num_non_zero_in_row_1++;
+    num_non_zero_in_col_0++;
+  }
+
+  if (std::abs(matrix_.get(1, 1)) > kEpsilon) {
+    num_non_zero_in_row_1++;
+    num_non_zero_in_col_1++;
+  }
+
+  return num_non_zero_in_row_0 <= 1 && num_non_zero_in_row_1 <= 1 &&
+         num_non_zero_in_col_0 <= 1 && num_non_zero_in_col_1 <= 1 &&
+         !has_x_or_y_perspective;
+}
+
+bool Transform::NonDegeneratePreserves2dAxisAlignment() const {
+  // See comments above for Preserves2dAxisAlignment.
+
+  // This function differs from it by requiring:
+  //  (1) that there are exactly two nonzero values on a diagonal in
+  //      the upper left 2x2 submatrix, and
+  //  (2) that the w perspective value is positive.
+
+  bool has_x_or_y_perspective =
+      matrix_.get(3, 0) != 0 || matrix_.get(3, 1) != 0;
+  bool positive_w_perspective = matrix_.get(3, 3) > kEpsilon;
+
+  bool have_0_0 = std::abs(matrix_.get(0, 0)) > kEpsilon;
+  bool have_0_1 = std::abs(matrix_.get(0, 1)) > kEpsilon;
+  bool have_1_0 = std::abs(matrix_.get(1, 0)) > kEpsilon;
+  bool have_1_1 = std::abs(matrix_.get(1, 1)) > kEpsilon;
+
+  return have_0_0 == have_1_1 && have_0_1 == have_1_0 && have_0_0 != have_0_1 &&
+         !has_x_or_y_perspective && positive_w_perspective;
+}
+
+void Transform::Transpose() {
+  matrix_.transpose();
+}
+
+void Transform::FlattenTo2d() {
+  float tmp[16];
+  matrix_.asColMajorf(tmp);
+  tmp[2] = 0.0;
+  tmp[6] = 0.0;
+  tmp[8] = 0.0;
+  tmp[9] = 0.0;
+  tmp[10] = 1.0;
+  tmp[11] = 0.0;
+  tmp[14] = 0.0;
+  matrix_.setColMajorf(tmp);
+}
+
+bool Transform::IsFlat() const {
+  return matrix_.get(2, 0) == 0.0 && matrix_.get(2, 1) == 0.0 &&
+         matrix_.get(0, 2) == 0.0 && matrix_.get(1, 2) == 0.0 &&
+         matrix_.get(2, 2) == 1.0 && matrix_.get(3, 2) == 0.0 &&
+         matrix_.get(2, 3) == 0.0;
+}
+
+Vector2dF Transform::To2dTranslation() const {
+  return gfx::Vector2dF(SkScalarToFloat(matrix_.get(0, 3)),
+                        SkScalarToFloat(matrix_.get(1, 3)));
+}
+
+void Transform::TransformPoint(Point* point) const {
+  DCHECK(point);
+  TransformPointInternal(matrix_, point);
+}
+
+void Transform::TransformPoint(PointF* point) const {
+  DCHECK(point);
+  TransformPointInternal(matrix_, point);
+}
+
+void Transform::TransformPoint(Point3F* point) const {
+  DCHECK(point);
+  TransformPointInternal(matrix_, point);
+}
+
+void Transform::TransformVector(Vector3dF* vector) const {
+  DCHECK(vector);
+  TransformVectorInternal(matrix_, vector);
+}
+
+bool Transform::TransformPointReverse(Point* point) const {
+  DCHECK(point);
+
+  // TODO(sad): Try to avoid trying to invert the matrix.
+  skia::Matrix44 inverse(skia::Matrix44::kUninitialized_Constructor);
+  if (!matrix_.invert(&inverse))
+    return false;
+
+  TransformPointInternal(inverse, point);
+  return true;
+}
+
+bool Transform::TransformPointReverse(Point3F* point) const {
+  DCHECK(point);
+
+  // TODO(sad): Try to avoid trying to invert the matrix.
+  skia::Matrix44 inverse(skia::Matrix44::kUninitialized_Constructor);
+  if (!matrix_.invert(&inverse))
+    return false;
+
+  TransformPointInternal(inverse, point);
+  return true;
+}
+
+void Transform::TransformRect(RectF* rect) const {
+  if (matrix_.isIdentity())
+    return;
+
+  SkRect src = RectFToSkRect(*rect);
+  SkMatrix(matrix_).mapRect(&src);
+  *rect = SkRectToRectF(src);
+}
+
+bool Transform::TransformRectReverse(RectF* rect) const {
+  if (matrix_.isIdentity())
+    return true;
+
+  skia::Matrix44 inverse(skia::Matrix44::kUninitialized_Constructor);
+  if (!matrix_.invert(&inverse))
+    return false;
+
+  SkRect src = RectFToSkRect(*rect);
+  SkMatrix(inverse).mapRect(&src);
+  *rect = SkRectToRectF(src);
+  return true;
+}
+
+bool Transform::TransformRRectF(RRectF* rrect) const {
+  SkRRect result;
+  if (!SkRRect(*rrect).transform(SkMatrix(matrix_), &result))
+    return false;
+  *rrect = gfx::RRectF(result);
+  return true;
+}
+
+void Transform::TransformBox(BoxF* box) const {
+  BoxF bounds;
+  bool first_point = true;
+  for (int corner = 0; corner < 8; ++corner) {
+    gfx::Point3F point = box->origin();
+    point += gfx::Vector3dF(corner & 1 ? box->width() : 0.f,
+                            corner & 2 ? box->height() : 0.f,
+                            corner & 4 ? box->depth() : 0.f);
+    TransformPoint(&point);
+    if (first_point) {
+      bounds.set_origin(point);
+      first_point = false;
+    } else {
+      bounds.ExpandTo(point);
+    }
+  }
+  *box = bounds;
+}
+
+bool Transform::TransformBoxReverse(BoxF* box) const {
+  gfx::Transform inverse = *this;
+  if (!GetInverse(&inverse))
+    return false;
+  inverse.TransformBox(box);
+  return true;
+}
+
+bool Transform::Blend(const Transform& from, double progress) {
+  DecomposedTransform to_decomp;
+  DecomposedTransform from_decomp;
+  if (!DecomposeTransform(&to_decomp, *this) ||
+      !DecomposeTransform(&from_decomp, from))
+    return false;
+
+  to_decomp = BlendDecomposedTransforms(to_decomp, from_decomp, progress);
+
+  matrix_ = ComposeTransform(to_decomp).matrix();
+  return true;
+}
+
+void Transform::RoundTranslationComponents() {
+  matrix_.set(0, 3, std::round(matrix_.get(0, 3)));
+  matrix_.set(1, 3, std::round(matrix_.get(1, 3)));
+}
+
+void Transform::TransformPointInternal(const skia::Matrix44& xform,
+                                       Point3F* point) const {
+  if (xform.isIdentity())
+    return;
+
+  SkScalar p[4] = {point->x(), point->y(), point->z(), 1};
+
+  xform.mapScalars(p);
+
+  if (p[3] != SK_Scalar1 && p[3] != 0.f) {
+    float w_inverse = SK_Scalar1 / p[3];
+    point->SetPoint(p[0] * w_inverse, p[1] * w_inverse, p[2] * w_inverse);
+  } else {
+    point->SetPoint(p[0], p[1], p[2]);
+  }
+}
+
+void Transform::TransformVectorInternal(const skia::Matrix44& xform,
+                                        Vector3dF* vector) const {
+  if (xform.isIdentity())
+    return;
+
+  SkScalar p[4] = {vector->x(), vector->y(), vector->z(), 0};
+
+  xform.mapScalars(p);
+
+  vector->set_x(p[0]);
+  vector->set_y(p[1]);
+  vector->set_z(p[2]);
+}
+
+void Transform::TransformPointInternal(const skia::Matrix44& xform,
+                                       PointF* point) const {
+  if (xform.isIdentity())
+    return;
+
+  SkScalar p[4] = {SkIntToScalar(point->x()), SkIntToScalar(point->y()), 0, 1};
+
+  xform.mapScalars(p);
+
+  point->SetPoint(p[0], p[1]);
+}
+
+void Transform::TransformPointInternal(const skia::Matrix44& xform,
+                                       Point* point) const {
+  PointF point_float(*point);
+  TransformPointInternal(xform, &point_float);
+  *point = ToRoundedPoint(point_float);
+}
+
+bool Transform::ApproximatelyEqual(const gfx::Transform& transform) const {
+  static const float component_tolerance = 0.1f;
+
+  // We may have a larger discrepancy in the scroll components due to snapping
+  // (floating point error might round the other way).
+  static const float translation_tolerance = 1.f;
+
+  for (int row = 0; row < 4; row++) {
+    for (int col = 0; col < 4; col++) {
+      const float delta =
+          std::abs(matrix().get(row, col) - transform.matrix().get(row, col));
+      const float tolerance =
+          col == 3 && row < 3 ? translation_tolerance : component_tolerance;
+      if (delta > tolerance)
+        return false;
+    }
+  }
+
+  return true;
+}
+
+std::string Transform::ToString() const {
+  return base::StringPrintf(
+      "[ %+0.4f %+0.4f %+0.4f %+0.4f  \n"
+      "  %+0.4f %+0.4f %+0.4f %+0.4f  \n"
+      "  %+0.4f %+0.4f %+0.4f %+0.4f  \n"
+      "  %+0.4f %+0.4f %+0.4f %+0.4f ]\n",
+      matrix_.get(0, 0), matrix_.get(0, 1), matrix_.get(0, 2),
+      matrix_.get(0, 3), matrix_.get(1, 0), matrix_.get(1, 1),
+      matrix_.get(1, 2), matrix_.get(1, 3), matrix_.get(2, 0),
+      matrix_.get(2, 1), matrix_.get(2, 2), matrix_.get(2, 3),
+      matrix_.get(3, 0), matrix_.get(3, 1), matrix_.get(3, 2),
+      matrix_.get(3, 3));
+}
+
+SkM44 Transform::GetMatrixAsSkM44() const {
+  return SkM44(matrix_.get(0, 0), matrix_.get(0, 1), matrix_.get(0, 2),
+               matrix_.get(0, 3), matrix_.get(1, 0), matrix_.get(1, 1),
+               matrix_.get(1, 2), matrix_.get(1, 3), matrix_.get(2, 0),
+               matrix_.get(2, 1), matrix_.get(2, 2), matrix_.get(2, 3),
+               matrix_.get(3, 0), matrix_.get(3, 1), matrix_.get(3, 2),
+               matrix_.get(3, 3));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/transform.h b/ui/gfx/geometry/transform.h
new file mode 100644
index 0000000..e0df4d6
--- /dev/null
+++ b/ui/gfx/geometry/transform.h
@@ -0,0 +1,329 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_TRANSFORM_H_
+#define UI_GFX_GEOMETRY_TRANSFORM_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "skia/ext/skia_matrix_44.h"
+#include "third_party/skia/include/core/SkM44.h"
+#include "ui/gfx/geometry/geometry_skia_export.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace gfx {
+
+class BoxF;
+class RectF;
+class RRectF;
+class Point;
+class PointF;
+class Point3F;
+class Quaternion;
+class Vector3dF;
+
+// 4x4 transformation matrix. Transform is cheap and explicitly allows
+// copy/assign.
+class GEOMETRY_SKIA_EXPORT Transform {
+ public:
+  enum SkipInitialization { kSkipInitialization };
+
+  constexpr Transform() : matrix_(skia::Matrix44::kIdentity_Constructor) {}
+
+  // Skips initializing this matrix to avoid overhead, when we know it will be
+  // initialized before use.
+  explicit Transform(SkipInitialization)
+      : matrix_(skia::Matrix44::kUninitialized_Constructor) {}
+  Transform(const Transform& rhs) = default;
+  Transform& operator=(const Transform& rhs) = default;
+  // Initialize with the concatenation of lhs * rhs.
+  Transform(const Transform& lhs, const Transform& rhs)
+      : matrix_(lhs.matrix_, rhs.matrix_) {}
+  explicit Transform(const skia::Matrix44& matrix) : matrix_(matrix) {}
+  explicit Transform(const SkMatrix& matrix)
+      : matrix_(skia::Matrix44(matrix)) {}
+  // Constructs a transform from explicit 16 matrix elements. Elements
+  // should be given in row-major order.
+  Transform(SkScalar col1row1,
+            SkScalar col2row1,
+            SkScalar col3row1,
+            SkScalar col4row1,
+            SkScalar col1row2,
+            SkScalar col2row2,
+            SkScalar col3row2,
+            SkScalar col4row2,
+            SkScalar col1row3,
+            SkScalar col2row3,
+            SkScalar col3row3,
+            SkScalar col4row3,
+            SkScalar col1row4,
+            SkScalar col2row4,
+            SkScalar col3row4,
+            SkScalar col4row4);
+  // Constructs a transform from explicit 2d elements. All other matrix
+  // elements remain the same as the corresponding elements of an identity
+  // matrix.
+  Transform(SkScalar col1row1,
+            SkScalar col2row1,
+            SkScalar col1row2,
+            SkScalar col2row2,
+            SkScalar x_translation,
+            SkScalar y_translation);
+
+  // Constructs a transform corresponding to the given quaternion.
+  explicit Transform(const Quaternion& q);
+
+  bool operator==(const Transform& rhs) const { return matrix_ == rhs.matrix_; }
+  bool operator!=(const Transform& rhs) const { return matrix_ != rhs.matrix_; }
+
+  // Resets this transform to the identity transform.
+  void MakeIdentity() { matrix_.setIdentity(); }
+
+  // Applies the current transformation on a 2d rotation and assigns the result
+  // to |this|.
+  void Rotate(double degrees) { RotateAboutZAxis(degrees); }
+
+  // Applies the current transformation on an axis-angle rotation and assigns
+  // the result to |this|.
+  void RotateAboutXAxis(double degrees);
+  void RotateAboutYAxis(double degrees);
+  void RotateAboutZAxis(double degrees);
+  void RotateAbout(const Vector3dF& axis, double degrees);
+
+  // Applies the current transformation on a scaling and assigns the result
+  // to |this|.
+  void Scale(SkScalar x, SkScalar y);
+  void Scale3d(SkScalar x, SkScalar y, SkScalar z);
+  gfx::Vector2dF Scale2d() const {
+    return gfx::Vector2dF(matrix_.get(0, 0), matrix_.get(1, 1));
+  }
+
+  // Applies a scale to the current transformation and assigns the result to
+  // |this|.
+  void PostScale(SkScalar x, SkScalar y);
+
+  // Applies the current transformation on a translation and assigns the result
+  // to |this|.
+  void Translate(const Vector2dF& offset);
+  void Translate(SkScalar x, SkScalar y);
+  void Translate3d(const Vector3dF& offset);
+  void Translate3d(SkScalar x, SkScalar y, SkScalar z);
+
+  // Applies a translation to the current transformation and assigns the result
+  // to |this|.
+  void PostTranslate(const Vector2dF& offset);
+  void PostTranslate(SkScalar x, SkScalar y);
+
+  // Applies the current transformation on a skew and assigns the result
+  // to |this|.
+  void Skew(double angle_x, double angle_y);
+
+  // Applies the current transformation on a perspective transform and assigns
+  // the result to |this|.
+  void ApplyPerspectiveDepth(SkScalar depth);
+
+  // Applies a transformation on the current transformation
+  // (i.e. 'this = this * transform;').
+  void PreconcatTransform(const Transform& transform);
+
+  // Applies a transformation on the current transformation
+  // (i.e. 'this = transform * this;').
+  void ConcatTransform(const Transform& transform);
+
+  // Returns true if this is the identity matrix.
+  // This function modifies a mutable variable in |matrix_|.
+  bool IsIdentity() const { return matrix_.isIdentity(); }
+
+  // Returns true if the matrix is either identity or pure translation.
+  bool IsIdentityOrTranslation() const { return matrix_.isTranslate(); }
+
+  // Returns true if the matrix is either the identity or a 2d translation.
+  bool IsIdentityOr2DTranslation() const {
+    return matrix_.isTranslate() && matrix_.get(2, 3) == 0;
+  }
+
+  // Returns true if the matrix is either identity or pure translation,
+  // allowing for an amount of inaccuracy as specified by the parameter.
+  bool IsApproximatelyIdentityOrTranslation(SkScalar tolerance) const;
+  bool IsApproximatelyIdentityOrIntegerTranslation(SkScalar tolerance) const;
+
+  // Returns true if the matrix is either a positive scale and/or a translation.
+  bool IsPositiveScaleOrTranslation() const {
+    if (!IsScaleOrTranslation())
+      return false;
+    return matrix_.get(0, 0) > 0.0 && matrix_.get(1, 1) > 0.0 &&
+           matrix_.get(2, 2) > 0.0;
+  }
+
+  // Returns true if the matrix is identity or, if the matrix consists only
+  // of a translation whose components can be represented as integers. Returns
+  // false if the translation contains a fractional component or is too large to
+  // fit in an integer.
+  bool IsIdentityOrIntegerTranslation() const;
+
+  // Returns true if the matrix had only scaling components.
+  bool IsScale2d() const { return matrix_.isScale(); }
+
+  // Returns true if the matrix is has only scaling and translation components.
+  bool IsScaleOrTranslation() const { return matrix_.isScaleTranslate(); }
+
+  // Returns true if axis-aligned 2d rects will remain axis-aligned after being
+  // transformed by this matrix.
+  bool Preserves2dAxisAlignment() const;
+
+  // Returns true if axis-aligned 2d rects will remain axis-aligned and not
+  // clipped by perspective (w > 0) after being transformed by this matrix,
+  // and distinct points in the x/y plane will remain distinct after being
+  // transformed by this matrix and mapped back to the x/y plane.
+  bool NonDegeneratePreserves2dAxisAlignment() const;
+
+  // Returns true if the matrix has any perspective component that would
+  // change the w-component of a homogeneous point.
+  bool HasPerspective() const { return matrix_.hasPerspective(); }
+
+  // Returns true if this transform is non-singular.
+  bool IsInvertible() const { return matrix_.invert(nullptr); }
+
+  // Returns true if a layer with a forward-facing normal of (0, 0, 1) would
+  // have its back side facing frontwards after applying the transform.
+  bool IsBackFaceVisible() const;
+
+  // Inverts the transform which is passed in. Returns true if successful, or
+  // sets |transform| to the identify matrix on failure.
+  bool GetInverse(Transform* transform) const WARN_UNUSED_RESULT;
+
+  // Transposes this transform in place.
+  void Transpose();
+
+  // Set 3rd row and 3rd column to (0, 0, 1, 0). Note that this flattening
+  // operation is not quite the same as an orthographic projection and is
+  // technically not a linear operation.
+  //
+  // One useful interpretation of doing this operation:
+  //  - For x and y values, the new transform behaves effectively like an
+  //    orthographic projection was added to the matrix sequence.
+  //  - For z values, the new transform overrides any effect that the transform
+  //    had on z, and instead it preserves the z value for any points that are
+  //    transformed.
+  //  - Because of linearity of transforms, this flattened transform also
+  //    preserves the effect that any subsequent (multiplied from the right)
+  //    transforms would have on z values.
+  //
+  void FlattenTo2d();
+
+  // Returns true if the 3rd row and 3rd column are both (0, 0, 1, 0).
+  bool IsFlat() const;
+
+  // Returns the x and y translation components of the matrix.
+  Vector2dF To2dTranslation() const;
+
+  // Applies the transformation to the point.
+  void TransformPoint(Point3F* point) const;
+
+  // Applies the transformation to the point.
+  void TransformPoint(PointF* point) const;
+
+  // Applies the transformation to the point.
+  void TransformPoint(Point* point) const;
+
+  // Applies the transformation to the vector.
+  void TransformVector(Vector3dF* vector) const;
+
+  // Applies the reverse transformation on the point. Returns true if the
+  // transformation can be inverted.
+  bool TransformPointReverse(Point3F* point) const;
+
+  // Applies the reverse transformation on the point. Returns true if the
+  // transformation can be inverted. Rounds the result to the nearest point.
+  bool TransformPointReverse(Point* point) const;
+
+  // Applies transformation on the given rect. After the function completes,
+  // |rect| will be the smallest axis aligned bounding rect containing the
+  // transformed rect.
+  void TransformRect(RectF* rect) const;
+
+  // Applies the reverse transformation on the given rect. After the function
+  // completes, |rect| will be the smallest axis aligned bounding rect
+  // containing the transformed rect. Returns false if the matrix cannot be
+  // inverted.
+  bool TransformRectReverse(RectF* rect) const;
+
+  // Applies transformation on the given |rrect|. Returns false if the transform
+  // matrix cannot be applied to rrect.
+  bool TransformRRectF(RRectF* rrect) const;
+
+  // Applies transformation on the given box. After the function completes,
+  // |box| will be the smallest axis aligned bounding box containing the
+  // transformed box.
+  void TransformBox(BoxF* box) const;
+
+  // Applies the reverse transformation on the given box. After the function
+  // completes, |box| will be the smallest axis aligned bounding box
+  // containing the transformed box. Returns false if the matrix cannot be
+  // inverted.
+  bool TransformBoxReverse(BoxF* box) const;
+
+  // Decomposes |this| and |from|, interpolates the decomposed values, and
+  // sets |this| to the reconstituted result. Returns false if either matrix
+  // can't be decomposed. Uses routines described in this spec:
+  // http://www.w3.org/TR/css3-3d-transforms/.
+  //
+  // Note: this call is expensive since we need to decompose the transform. If
+  // you're going to be calling this rapidly (e.g., in an animation) you should
+  // decompose once using gfx::DecomposeTransforms and reuse your
+  // DecomposedTransform.
+  bool Blend(const Transform& from, double progress);
+
+  void RoundTranslationComponents();
+
+  // Returns |this| * |other|.
+  Transform operator*(const Transform& other) const {
+    return Transform(*this, other);
+  }
+
+  // Sets |this| = |this| * |other|
+  Transform& operator*=(const Transform& other) {
+    PreconcatTransform(other);
+    return *this;
+  }
+
+  // Returns the underlying matrix.
+  const skia::Matrix44& matrix() const { return matrix_; }
+  skia::Matrix44& matrix() { return matrix_; }
+
+  // TODO(crbug.com/1167153) skia::Matrix44 is deprecated, this is to help in
+  // moving the code base towards SkM44, although eventually this class should
+  // just hold an SkM44
+  SkM44 GetMatrixAsSkM44() const;
+
+  bool ApproximatelyEqual(const gfx::Transform& transform) const;
+
+  std::string ToString() const;
+
+ private:
+  void TransformPointInternal(const skia::Matrix44& xform, Point* point) const;
+
+  void TransformPointInternal(const skia::Matrix44& xform, PointF* point) const;
+
+  void TransformPointInternal(const skia::Matrix44& xform,
+                              Point3F* point) const;
+
+  void TransformVectorInternal(const skia::Matrix44& xform,
+                               Vector3dF* vector) const;
+
+  skia::Matrix44 matrix_;
+
+  // copy/assign are allowed.
+};
+
+// This is declared here for use in gtest-based unit tests but is defined in
+// the //ui/gfx:test_support target. Depend on that to use this in your unit
+// test. This should not be used in production code - call ToString() instead.
+void PrintTo(const Transform& transform, ::std::ostream* os);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_TRANSFORM_H_
diff --git a/ui/gfx/geometry/transform_operation.cc b/ui/gfx/geometry/transform_operation.cc
new file mode 100644
index 0000000..12303f5
--- /dev/null
+++ b/ui/gfx/geometry/transform_operation.cc
@@ -0,0 +1,514 @@
+// 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.
+
+#include <limits>
+#include <utility>
+
+#include "ui/gfx/geometry/transform_operation.h"
+
+#include "base/check_op.h"
+#include "base/notreached.h"
+#include "base/numerics/math_constants.h"
+#include "base/numerics/ranges.h"
+#include "ui/gfx/geometry/angle_conversions.h"
+#include "ui/gfx/geometry/box_f.h"
+#include "ui/gfx/geometry/transform_operations.h"
+#include "ui/gfx/geometry/transform_util.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace {
+const SkScalar kAngleEpsilon = 1e-4f;
+}
+
+namespace gfx {
+
+bool TransformOperation::IsIdentity() const {
+  return matrix.IsIdentity();
+}
+
+static bool IsOperationIdentity(const TransformOperation* operation) {
+  return !operation || operation->IsIdentity();
+}
+
+static bool ShareSameAxis(const TransformOperation* from,
+                          const TransformOperation* to,
+                          SkScalar* axis_x,
+                          SkScalar* axis_y,
+                          SkScalar* axis_z,
+                          SkScalar* angle_from) {
+  if (IsOperationIdentity(from) && IsOperationIdentity(to))
+    return false;
+
+  if (IsOperationIdentity(from) && !IsOperationIdentity(to)) {
+    *axis_x = to->rotate.axis.x;
+    *axis_y = to->rotate.axis.y;
+    *axis_z = to->rotate.axis.z;
+    *angle_from = 0;
+    return true;
+  }
+
+  if (!IsOperationIdentity(from) && IsOperationIdentity(to)) {
+    *axis_x = from->rotate.axis.x;
+    *axis_y = from->rotate.axis.y;
+    *axis_z = from->rotate.axis.z;
+    *angle_from = from->rotate.angle;
+    return true;
+  }
+
+  SkScalar length_2 = from->rotate.axis.x * from->rotate.axis.x +
+                      from->rotate.axis.y * from->rotate.axis.y +
+                      from->rotate.axis.z * from->rotate.axis.z;
+  SkScalar other_length_2 = to->rotate.axis.x * to->rotate.axis.x +
+                            to->rotate.axis.y * to->rotate.axis.y +
+                            to->rotate.axis.z * to->rotate.axis.z;
+
+  if (length_2 <= kAngleEpsilon || other_length_2 <= kAngleEpsilon)
+    return false;
+
+  SkScalar dot = to->rotate.axis.x * from->rotate.axis.x +
+                 to->rotate.axis.y * from->rotate.axis.y +
+                 to->rotate.axis.z * from->rotate.axis.z;
+  SkScalar error =
+      SkScalarAbs(SK_Scalar1 - (dot * dot) / (length_2 * other_length_2));
+  bool result = error < kAngleEpsilon;
+  if (result) {
+    *axis_x = to->rotate.axis.x;
+    *axis_y = to->rotate.axis.y;
+    *axis_z = to->rotate.axis.z;
+    // If the axes are pointing in opposite directions, we need to reverse
+    // the angle.
+    *angle_from = dot > 0 ? from->rotate.angle : -from->rotate.angle;
+  }
+  return result;
+}
+
+static SkScalar BlendSkScalars(SkScalar from, SkScalar to, SkScalar progress) {
+  return from * (1 - progress) + to * progress;
+}
+
+void TransformOperation::Bake() {
+  matrix.MakeIdentity();
+  switch (type) {
+    case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
+      matrix.Translate3d(translate.x, translate.y, translate.z);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_ROTATE:
+      matrix.RotateAbout(
+          gfx::Vector3dF(rotate.axis.x, rotate.axis.y, rotate.axis.z),
+          rotate.angle);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_SCALE:
+      matrix.Scale3d(scale.x, scale.y, scale.z);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_SKEWX:
+    case TransformOperation::TRANSFORM_OPERATION_SKEWY:
+    case TransformOperation::TRANSFORM_OPERATION_SKEW:
+      matrix.Skew(skew.x, skew.y);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
+      matrix.ApplyPerspectiveDepth(perspective_depth);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_MATRIX:
+    case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      break;
+  }
+}
+
+bool TransformOperation::ApproximatelyEqual(const TransformOperation& other,
+                                            SkScalar tolerance) const {
+  DCHECK_LE(0, tolerance);
+  if (type != other.type)
+    return false;
+  switch (type) {
+    case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
+      return base::IsApproximatelyEqual(translate.x, other.translate.x,
+                                        tolerance) &&
+             base::IsApproximatelyEqual(translate.y, other.translate.y,
+                                        tolerance) &&
+             base::IsApproximatelyEqual(translate.z, other.translate.z,
+                                        tolerance);
+    case TransformOperation::TRANSFORM_OPERATION_ROTATE:
+      return base::IsApproximatelyEqual(rotate.axis.x, other.rotate.axis.x,
+                                        tolerance) &&
+             base::IsApproximatelyEqual(rotate.axis.y, other.rotate.axis.y,
+                                        tolerance) &&
+             base::IsApproximatelyEqual(rotate.axis.z, other.rotate.axis.z,
+                                        tolerance) &&
+             base::IsApproximatelyEqual(rotate.angle, other.rotate.angle,
+                                        tolerance);
+    case TransformOperation::TRANSFORM_OPERATION_SCALE:
+      return base::IsApproximatelyEqual(scale.x, other.scale.x, tolerance) &&
+             base::IsApproximatelyEqual(scale.y, other.scale.y, tolerance) &&
+             base::IsApproximatelyEqual(scale.z, other.scale.z, tolerance);
+    case TransformOperation::TRANSFORM_OPERATION_SKEWX:
+    case TransformOperation::TRANSFORM_OPERATION_SKEWY:
+    case TransformOperation::TRANSFORM_OPERATION_SKEW:
+      return base::IsApproximatelyEqual(skew.x, other.skew.x, tolerance) &&
+             base::IsApproximatelyEqual(skew.y, other.skew.y, tolerance);
+    case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
+      return base::IsApproximatelyEqual(perspective_depth,
+                                        other.perspective_depth, tolerance);
+    case TransformOperation::TRANSFORM_OPERATION_MATRIX:
+      // TODO(vollick): we could expose a tolerance on gfx::Transform, but it's
+      // complex since we need a different tolerance per component. Driving this
+      // with a single tolerance will take some care. For now, we will check
+      // exact equality where the tolerance is 0.0f, otherwise we will use the
+      // unparameterized version of gfx::Transform::ApproximatelyEqual.
+      if (tolerance == 0.0f)
+        return matrix == other.matrix;
+      else
+        return matrix.ApproximatelyEqual(other.matrix);
+    case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      return other.matrix.IsIdentity();
+  }
+  NOTREACHED();
+  return false;
+}
+
+bool TransformOperation::BlendTransformOperations(
+    const TransformOperation* from,
+    const TransformOperation* to,
+    SkScalar progress,
+    TransformOperation* result) {
+  if (IsOperationIdentity(from) && IsOperationIdentity(to))
+    return true;
+
+  TransformOperation::Type interpolation_type =
+      TransformOperation::TRANSFORM_OPERATION_IDENTITY;
+  if (IsOperationIdentity(to))
+    interpolation_type = from->type;
+  else
+    interpolation_type = to->type;
+  result->type = interpolation_type;
+
+  switch (interpolation_type) {
+    case TransformOperation::TRANSFORM_OPERATION_TRANSLATE: {
+      SkScalar from_x = IsOperationIdentity(from) ? 0 : from->translate.x;
+      SkScalar from_y = IsOperationIdentity(from) ? 0 : from->translate.y;
+      SkScalar from_z = IsOperationIdentity(from) ? 0 : from->translate.z;
+      SkScalar to_x = IsOperationIdentity(to) ? 0 : to->translate.x;
+      SkScalar to_y = IsOperationIdentity(to) ? 0 : to->translate.y;
+      SkScalar to_z = IsOperationIdentity(to) ? 0 : to->translate.z;
+      result->translate.x = BlendSkScalars(from_x, to_x, progress),
+      result->translate.y = BlendSkScalars(from_y, to_y, progress),
+      result->translate.z = BlendSkScalars(from_z, to_z, progress),
+      result->Bake();
+      break;
+    }
+    case TransformOperation::TRANSFORM_OPERATION_ROTATE: {
+      SkScalar axis_x = 0;
+      SkScalar axis_y = 0;
+      SkScalar axis_z = 1;
+      SkScalar from_angle = 0;
+      SkScalar to_angle = IsOperationIdentity(to) ? 0 : to->rotate.angle;
+      if (ShareSameAxis(from, to, &axis_x, &axis_y, &axis_z, &from_angle)) {
+        result->rotate.axis.x = axis_x;
+        result->rotate.axis.y = axis_y;
+        result->rotate.axis.z = axis_z;
+        result->rotate.angle = BlendSkScalars(from_angle, to_angle, progress);
+        result->Bake();
+      } else {
+        if (!IsOperationIdentity(to))
+          result->matrix = to->matrix;
+        gfx::Transform from_matrix;
+        if (!IsOperationIdentity(from))
+          from_matrix = from->matrix;
+        if (!result->matrix.Blend(from_matrix, progress))
+          return false;
+      }
+      break;
+    }
+    case TransformOperation::TRANSFORM_OPERATION_SCALE: {
+      SkScalar from_x = IsOperationIdentity(from) ? 1 : from->scale.x;
+      SkScalar from_y = IsOperationIdentity(from) ? 1 : from->scale.y;
+      SkScalar from_z = IsOperationIdentity(from) ? 1 : from->scale.z;
+      SkScalar to_x = IsOperationIdentity(to) ? 1 : to->scale.x;
+      SkScalar to_y = IsOperationIdentity(to) ? 1 : to->scale.y;
+      SkScalar to_z = IsOperationIdentity(to) ? 1 : to->scale.z;
+      result->scale.x = BlendSkScalars(from_x, to_x, progress);
+      result->scale.y = BlendSkScalars(from_y, to_y, progress);
+      result->scale.z = BlendSkScalars(from_z, to_z, progress);
+      result->Bake();
+      break;
+    }
+    case TransformOperation::TRANSFORM_OPERATION_SKEWX:
+    case TransformOperation::TRANSFORM_OPERATION_SKEWY:
+    case TransformOperation::TRANSFORM_OPERATION_SKEW: {
+      SkScalar from_x = IsOperationIdentity(from) ? 0 : from->skew.x;
+      SkScalar from_y = IsOperationIdentity(from) ? 0 : from->skew.y;
+      SkScalar to_x = IsOperationIdentity(to) ? 0 : to->skew.x;
+      SkScalar to_y = IsOperationIdentity(to) ? 0 : to->skew.y;
+      result->skew.x = BlendSkScalars(from_x, to_x, progress);
+      result->skew.y = BlendSkScalars(from_y, to_y, progress);
+      result->Bake();
+      break;
+    }
+    case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE: {
+      SkScalar from_perspective_depth =
+          IsOperationIdentity(from) ? std::numeric_limits<SkScalar>::max()
+                                    : from->perspective_depth;
+      SkScalar to_perspective_depth = IsOperationIdentity(to)
+                                          ? std::numeric_limits<SkScalar>::max()
+                                          : to->perspective_depth;
+      if (from_perspective_depth == 0.f || to_perspective_depth == 0.f)
+        return false;
+
+      SkScalar blended_perspective_depth = BlendSkScalars(
+          1.f / from_perspective_depth, 1.f / to_perspective_depth, progress);
+
+      if (blended_perspective_depth == 0.f)
+        return false;
+
+      result->perspective_depth = 1.f / blended_perspective_depth;
+      result->Bake();
+      break;
+    }
+    case TransformOperation::TRANSFORM_OPERATION_MATRIX: {
+      if (!IsOperationIdentity(to))
+        result->matrix = to->matrix;
+      gfx::Transform from_matrix;
+      if (!IsOperationIdentity(from))
+        from_matrix = from->matrix;
+      if (!result->matrix.Blend(from_matrix, progress))
+        return false;
+      break;
+    }
+    case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      // Do nothing.
+      break;
+  }
+
+  return true;
+}
+
+// If p = (px, py) is a point in the plane being rotated about (0, 0, nz), this
+// function computes the angles we would have to rotate from p to get to
+// (length(p), 0), (-length(p), 0), (0, length(p)), (0, -length(p)). If nz is
+// negative, these angles will need to be reversed.
+static void FindCandidatesInPlane(float px,
+                                  float py,
+                                  float nz,
+                                  double* candidates,
+                                  int* num_candidates) {
+  double phi = atan2(px, py);
+  *num_candidates = 4;
+  candidates[0] = phi;
+  for (int i = 1; i < *num_candidates; ++i)
+    candidates[i] = candidates[i - 1] + base::kPiDouble / 2;
+  if (nz < 0.f) {
+    for (int i = 0; i < *num_candidates; ++i)
+      candidates[i] *= -1.f;
+  }
+}
+
+static void BoundingBoxForArc(const gfx::Point3F& point,
+                              const TransformOperation* from,
+                              const TransformOperation* to,
+                              SkScalar min_progress,
+                              SkScalar max_progress,
+                              gfx::BoxF* box) {
+  const TransformOperation* exemplar = from ? from : to;
+  gfx::Vector3dF axis(exemplar->rotate.axis.x, exemplar->rotate.axis.y,
+                      exemplar->rotate.axis.z);
+
+  const bool x_is_zero = axis.x() == 0.f;
+  const bool y_is_zero = axis.y() == 0.f;
+  const bool z_is_zero = axis.z() == 0.f;
+
+  // We will have at most 6 angles to test (excluding from->angle and
+  // to->angle).
+  static const int kMaxNumCandidates = 6;
+  double candidates[kMaxNumCandidates];
+  int num_candidates = kMaxNumCandidates;
+
+  if (x_is_zero && y_is_zero && z_is_zero)
+    return;
+
+  SkScalar from_angle = from ? from->rotate.angle : 0.f;
+  SkScalar to_angle = to ? to->rotate.angle : 0.f;
+
+  // If the axes of rotation are pointing in opposite directions, we need to
+  // flip one of the angles. Note, if both |from| and |to| exist, then axis will
+  // correspond to |from|.
+  if (from && to) {
+    gfx::Vector3dF other_axis(to->rotate.axis.x, to->rotate.axis.y,
+                              to->rotate.axis.z);
+    if (gfx::DotProduct(axis, other_axis) < 0.f)
+      to_angle *= -1.f;
+  }
+
+  float min_degrees =
+      SkScalarToFloat(BlendSkScalars(from_angle, to_angle, min_progress));
+  float max_degrees =
+      SkScalarToFloat(BlendSkScalars(from_angle, to_angle, max_progress));
+  if (max_degrees < min_degrees)
+    std::swap(min_degrees, max_degrees);
+
+  gfx::Transform from_transform;
+  from_transform.RotateAbout(axis, min_degrees);
+  gfx::Transform to_transform;
+  to_transform.RotateAbout(axis, max_degrees);
+
+  *box = gfx::BoxF();
+
+  gfx::Point3F point_rotated_from = point;
+  from_transform.TransformPoint(&point_rotated_from);
+  gfx::Point3F point_rotated_to = point;
+  to_transform.TransformPoint(&point_rotated_to);
+
+  box->set_origin(point_rotated_from);
+  box->ExpandTo(point_rotated_to);
+
+  if (x_is_zero && y_is_zero) {
+    FindCandidatesInPlane(point.x(), point.y(), axis.z(), candidates,
+                          &num_candidates);
+  } else if (x_is_zero && z_is_zero) {
+    FindCandidatesInPlane(point.z(), point.x(), axis.y(), candidates,
+                          &num_candidates);
+  } else if (y_is_zero && z_is_zero) {
+    FindCandidatesInPlane(point.y(), point.z(), axis.x(), candidates,
+                          &num_candidates);
+  } else {
+    gfx::Vector3dF normal = axis;
+    normal.Scale(1.f / normal.Length());
+
+    // First, find center of rotation.
+    gfx::Point3F origin;
+    gfx::Vector3dF to_point = point - origin;
+    gfx::Point3F center =
+        origin + gfx::ScaleVector3d(normal, gfx::DotProduct(to_point, normal));
+
+    // Now we need to find two vectors in the plane of rotation. One pointing
+    // towards point and another, perpendicular vector in the plane.
+    gfx::Vector3dF v1 = point - center;
+    float v1_length = v1.Length();
+    if (v1_length == 0.f)
+      return;
+
+    v1.Scale(1.f / v1_length);
+    gfx::Vector3dF v2 = gfx::CrossProduct(normal, v1);
+    // v1 is the basis vector in the direction of the point.
+    // i.e. with a rotation of 0, v1 is our +x vector.
+    // v2 is a perpenticular basis vector of our plane (+y).
+
+    // Take the parametric equation of a circle.
+    // x = r*cos(t); y = r*sin(t);
+    // We can treat that as a circle on the plane v1xv2.
+    // From that we get the parametric equations for a circle on the
+    // plane in 3d space of:
+    // x(t) = r*cos(t)*v1.x + r*sin(t)*v2.x + cx
+    // y(t) = r*cos(t)*v1.y + r*sin(t)*v2.y + cy
+    // z(t) = r*cos(t)*v1.z + r*sin(t)*v2.z + cz
+    // Taking the derivative of (x, y, z) and solving for 0 gives us our
+    // maximum/minimum x, y, z values.
+    // x'(t) = r*cos(t)*v2.x - r*sin(t)*v1.x = 0
+    // tan(t) = v2.x/v1.x
+    // t = atan2(v2.x, v1.x) + n*pi;
+    candidates[0] = atan2(v2.x(), v1.x());
+    candidates[1] = candidates[0] + base::kPiDouble;
+    candidates[2] = atan2(v2.y(), v1.y());
+    candidates[3] = candidates[2] + base::kPiDouble;
+    candidates[4] = atan2(v2.z(), v1.z());
+    candidates[5] = candidates[4] + base::kPiDouble;
+  }
+
+  double min_radians = gfx::DegToRad(min_degrees);
+  double max_radians = gfx::DegToRad(max_degrees);
+
+  for (int i = 0; i < num_candidates; ++i) {
+    double radians = candidates[i];
+    while (radians < min_radians)
+      radians += 2.0 * base::kPiDouble;
+    while (radians > max_radians)
+      radians -= 2.0 * base::kPiDouble;
+    if (radians < min_radians)
+      continue;
+
+    gfx::Transform rotation;
+    rotation.RotateAbout(axis, gfx::RadToDeg(radians));
+    gfx::Point3F rotated = point;
+    rotation.TransformPoint(&rotated);
+
+    box->ExpandTo(rotated);
+  }
+}
+
+bool TransformOperation::BlendedBoundsForBox(const gfx::BoxF& box,
+                                             const TransformOperation* from,
+                                             const TransformOperation* to,
+                                             SkScalar min_progress,
+                                             SkScalar max_progress,
+                                             gfx::BoxF* bounds) {
+  bool is_identity_from = IsOperationIdentity(from);
+  bool is_identity_to = IsOperationIdentity(to);
+  if (is_identity_from && is_identity_to) {
+    *bounds = box;
+    return true;
+  }
+
+  TransformOperation::Type interpolation_type =
+      TransformOperation::TRANSFORM_OPERATION_IDENTITY;
+  if (is_identity_to)
+    interpolation_type = from->type;
+  else
+    interpolation_type = to->type;
+
+  switch (interpolation_type) {
+    case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      *bounds = box;
+      return true;
+    case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
+    case TransformOperation::TRANSFORM_OPERATION_SKEWX:
+    case TransformOperation::TRANSFORM_OPERATION_SKEWY:
+    case TransformOperation::TRANSFORM_OPERATION_SKEW:
+    case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
+    case TransformOperation::TRANSFORM_OPERATION_SCALE: {
+      TransformOperation from_operation;
+      TransformOperation to_operation;
+      if (!BlendTransformOperations(from, to, min_progress, &from_operation) ||
+          !BlendTransformOperations(from, to, max_progress, &to_operation))
+        return false;
+
+      *bounds = box;
+      from_operation.matrix.TransformBox(bounds);
+
+      gfx::BoxF to_box = box;
+      to_operation.matrix.TransformBox(&to_box);
+      bounds->ExpandTo(to_box);
+
+      return true;
+    }
+    case TransformOperation::TRANSFORM_OPERATION_ROTATE: {
+      SkScalar axis_x = 0;
+      SkScalar axis_y = 0;
+      SkScalar axis_z = 1;
+      SkScalar from_angle = 0;
+      if (!ShareSameAxis(from, to, &axis_x, &axis_y, &axis_z, &from_angle))
+        return false;
+
+      bool first_point = true;
+      for (int i = 0; i < 8; ++i) {
+        gfx::Point3F corner = box.origin();
+        corner += gfx::Vector3dF(i & 1 ? box.width() : 0.f,
+                                 i & 2 ? box.height() : 0.f,
+                                 i & 4 ? box.depth() : 0.f);
+        gfx::BoxF box_for_arc;
+        BoundingBoxForArc(corner, from, to, min_progress, max_progress,
+                          &box_for_arc);
+        if (first_point)
+          *bounds = box_for_arc;
+        else
+          bounds->Union(box_for_arc);
+        first_point = false;
+      }
+      return true;
+    }
+    case TransformOperation::TRANSFORM_OPERATION_MATRIX:
+      return false;
+  }
+  NOTREACHED();
+  return false;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/transform_operation.h b/ui/gfx/geometry/transform_operation.h
new file mode 100644
index 0000000..8026bdf
--- /dev/null
+++ b/ui/gfx/geometry/transform_operation.h
@@ -0,0 +1,77 @@
+// 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.
+
+#ifndef UI_GFX_GEOMETRY_TRANSFORM_OPERATION_H_
+#define UI_GFX_GEOMETRY_TRANSFORM_OPERATION_H_
+
+#include "ui/gfx/geometry/geometry_skia_export.h"
+#include "ui/gfx/geometry/transform.h"
+
+namespace gfx {
+class BoxF;
+
+struct GEOMETRY_SKIA_EXPORT TransformOperation {
+  enum Type {
+    TRANSFORM_OPERATION_TRANSLATE,
+    TRANSFORM_OPERATION_ROTATE,
+    TRANSFORM_OPERATION_SCALE,
+    TRANSFORM_OPERATION_SKEWX,
+    TRANSFORM_OPERATION_SKEWY,
+    TRANSFORM_OPERATION_SKEW,
+    TRANSFORM_OPERATION_PERSPECTIVE,
+    TRANSFORM_OPERATION_MATRIX,
+    TRANSFORM_OPERATION_IDENTITY
+  };
+
+  Type type = TRANSFORM_OPERATION_IDENTITY;
+  gfx::Transform matrix;
+
+  union {
+    SkScalar perspective_depth;
+
+    struct {
+      SkScalar x, y;
+    } skew;
+
+    struct {
+      SkScalar x, y, z;
+    } scale;
+
+    struct {
+      SkScalar x, y, z;
+    } translate;
+
+    struct {
+      struct {
+        SkScalar x, y, z;
+      } axis;
+
+      SkScalar angle;
+    } rotate;
+  };
+
+  bool IsIdentity() const;
+
+  // Sets |matrix| based on type and the union values.
+  void Bake();
+
+  bool ApproximatelyEqual(const TransformOperation& other,
+                          SkScalar tolerance) const;
+
+  static bool BlendTransformOperations(const TransformOperation* from,
+                                       const TransformOperation* to,
+                                       SkScalar progress,
+                                       TransformOperation* result);
+
+  static bool BlendedBoundsForBox(const gfx::BoxF& box,
+                                  const TransformOperation* from,
+                                  const TransformOperation* to,
+                                  SkScalar min_progress,
+                                  SkScalar max_progress,
+                                  gfx::BoxF* bounds);
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_TRANSFORM_OPERATION_H_
diff --git a/ui/gfx/geometry/transform_operations.cc b/ui/gfx/geometry/transform_operations.cc
new file mode 100644
index 0000000..5d93258
--- /dev/null
+++ b/ui/gfx/geometry/transform_operations.cc
@@ -0,0 +1,384 @@
+// 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.
+
+#include "ui/gfx/geometry/transform_operations.h"
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <utility>
+
+#include "ui/gfx/geometry/angle_conversions.h"
+#include "ui/gfx/geometry/box_f.h"
+#include "ui/gfx/geometry/transform_util.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+TransformOperations::TransformOperations() = default;
+
+TransformOperations::TransformOperations(const TransformOperations& other) {
+  operations_ = other.operations_;
+}
+
+TransformOperations::~TransformOperations() = default;
+
+TransformOperations& TransformOperations::operator=(
+    const TransformOperations& other) {
+  operations_ = other.operations_;
+  return *this;
+}
+
+Transform TransformOperations::Apply() const {
+  return ApplyRemaining(0);
+}
+
+Transform TransformOperations::ApplyRemaining(size_t start) const {
+  Transform to_return;
+  for (size_t i = start; i < operations_.size(); i++) {
+    to_return.PreconcatTransform(operations_[i].matrix);
+  }
+  return to_return;
+}
+
+// TODO(crbug.com/914397): Consolidate blink and cc implementations of transform
+// interpolation.
+TransformOperations TransformOperations::Blend(const TransformOperations& from,
+                                               SkScalar progress) const {
+  TransformOperations to_return;
+  if (!BlendInternal(from, progress, &to_return)) {
+    // If the matrices cannot be blended, fallback to discrete animation logic.
+    // See https://drafts.csswg.org/css-transforms/#matrix-interpolation
+    to_return = progress < 0.5 ? from : *this;
+  }
+  return to_return;
+}
+
+bool TransformOperations::BlendedBoundsForBox(const BoxF& box,
+                                              const TransformOperations& from,
+                                              SkScalar min_progress,
+                                              SkScalar max_progress,
+                                              BoxF* bounds) const {
+  *bounds = box;
+
+  bool from_identity = from.IsIdentity();
+  bool to_identity = IsIdentity();
+  if (from_identity && to_identity)
+    return true;
+
+  if (!MatchesTypes(from))
+    return false;
+
+  size_t num_operations = std::max(from_identity ? 0 : from.operations_.size(),
+                                   to_identity ? 0 : operations_.size());
+
+  // Because we are squashing all of the matrices together when applying
+  // them to the animation, we must apply them in reverse order when
+  // not squashing them.
+  for (size_t i = 0; i < num_operations; ++i) {
+    size_t operation_index = num_operations - 1 - i;
+    BoxF bounds_for_operation;
+    const TransformOperation* from_op =
+        from_identity ? nullptr : &from.operations_[operation_index];
+    const TransformOperation* to_op =
+        to_identity ? nullptr : &operations_[operation_index];
+    if (!TransformOperation::BlendedBoundsForBox(*bounds, from_op, to_op,
+                                                 min_progress, max_progress,
+                                                 &bounds_for_operation)) {
+      return false;
+    }
+    *bounds = bounds_for_operation;
+  }
+
+  return true;
+}
+
+bool TransformOperations::PreservesAxisAlignment() const {
+  for (auto& operation : operations_) {
+    switch (operation.type) {
+      case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
+      case TransformOperation::TRANSFORM_OPERATION_SCALE:
+        continue;
+      case TransformOperation::TRANSFORM_OPERATION_MATRIX:
+        if (!operation.matrix.IsIdentity() &&
+            !operation.matrix.IsScaleOrTranslation())
+          return false;
+        continue;
+      case TransformOperation::TRANSFORM_OPERATION_ROTATE:
+      case TransformOperation::TRANSFORM_OPERATION_SKEWX:
+      case TransformOperation::TRANSFORM_OPERATION_SKEWY:
+      case TransformOperation::TRANSFORM_OPERATION_SKEW:
+      case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
+        return false;
+    }
+  }
+  return true;
+}
+
+bool TransformOperations::IsTranslation() const {
+  for (auto& operation : operations_) {
+    switch (operation.type) {
+      case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
+        continue;
+      case TransformOperation::TRANSFORM_OPERATION_MATRIX:
+        if (!operation.matrix.IsIdentityOrTranslation())
+          return false;
+        continue;
+      case TransformOperation::TRANSFORM_OPERATION_ROTATE:
+      case TransformOperation::TRANSFORM_OPERATION_SCALE:
+      case TransformOperation::TRANSFORM_OPERATION_SKEWX:
+      case TransformOperation::TRANSFORM_OPERATION_SKEWY:
+      case TransformOperation::TRANSFORM_OPERATION_SKEW:
+      case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
+        return false;
+    }
+  }
+  return true;
+}
+
+static SkScalar TanDegrees(double degrees) {
+  return SkDoubleToScalar(std::tan(DegToRad(degrees)));
+}
+
+bool TransformOperations::ScaleComponent(SkScalar* scale) const {
+  SkScalar operations_scale = 1.f;
+  for (auto& operation : operations_) {
+    switch (operation.type) {
+      case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
+      case TransformOperation::TRANSFORM_OPERATION_ROTATE:
+        continue;
+      case TransformOperation::TRANSFORM_OPERATION_MATRIX: {
+        if (operation.matrix.HasPerspective())
+          return false;
+        Vector2dF scale_components =
+            ComputeTransform2dScaleComponents(operation.matrix, 1.f);
+        operations_scale *=
+            std::max(scale_components.x(), scale_components.y());
+        break;
+      }
+      case TransformOperation::TRANSFORM_OPERATION_SKEWX:
+      case TransformOperation::TRANSFORM_OPERATION_SKEWY:
+      case TransformOperation::TRANSFORM_OPERATION_SKEW: {
+        SkScalar x_component = TanDegrees(operation.skew.x);
+        SkScalar y_component = TanDegrees(operation.skew.y);
+        SkScalar x_scale = std::sqrt(x_component * x_component + 1);
+        SkScalar y_scale = std::sqrt(y_component * y_component + 1);
+        operations_scale *= std::max(x_scale, y_scale);
+        break;
+      }
+      case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
+        return false;
+      case TransformOperation::TRANSFORM_OPERATION_SCALE:
+        operations_scale *= std::max(
+            std::abs(operation.scale.x),
+            std::max(std::abs(operation.scale.y), std::abs(operation.scale.z)));
+    }
+  }
+  *scale = operations_scale;
+  return true;
+}
+
+bool TransformOperations::MatchesTypes(const TransformOperations& other) const {
+  if (operations_.size() == 0 || other.operations_.size() == 0)
+    return true;
+
+  if (operations_.size() != other.operations_.size())
+    return false;
+
+  for (size_t i = 0; i < operations_.size(); ++i) {
+    if (operations_[i].type != other.operations_[i].type)
+      return false;
+  }
+
+  return true;
+}
+
+size_t TransformOperations::MatchingPrefixLength(
+    const TransformOperations& other) const {
+  size_t num_operations =
+      std::min(operations_.size(), other.operations_.size());
+  for (size_t i = 0; i < num_operations; ++i) {
+    if (operations_[i].type != other.operations_[i].type) {
+      // Remaining operations in each operations list require matrix/matrix3d
+      // interpolation.
+      return i;
+    }
+  }
+  // If the operations match to the length of the shorter list, then pad its
+  // length with the matching identity operations.
+  // https://drafts.csswg.org/css-transforms/#transform-function-lists
+  return std::max(operations_.size(), other.operations_.size());
+}
+
+bool TransformOperations::CanBlendWith(const TransformOperations& other) const {
+  TransformOperations dummy;
+  return BlendInternal(other, 0.5, &dummy);
+}
+
+void TransformOperations::AppendTranslate(SkScalar x, SkScalar y, SkScalar z) {
+  TransformOperation to_add;
+  to_add.matrix.Translate3d(x, y, z);
+  to_add.type = TransformOperation::TRANSFORM_OPERATION_TRANSLATE;
+  to_add.translate.x = x;
+  to_add.translate.y = y;
+  to_add.translate.z = z;
+  operations_.push_back(to_add);
+  decomposed_transforms_.clear();
+}
+
+void TransformOperations::AppendRotate(SkScalar x,
+                                       SkScalar y,
+                                       SkScalar z,
+                                       SkScalar degrees) {
+  TransformOperation to_add;
+  to_add.type = TransformOperation::TRANSFORM_OPERATION_ROTATE;
+  to_add.rotate.axis.x = x;
+  to_add.rotate.axis.y = y;
+  to_add.rotate.axis.z = z;
+  to_add.rotate.angle = degrees;
+  to_add.Bake();
+  operations_.push_back(to_add);
+  decomposed_transforms_.clear();
+}
+
+void TransformOperations::AppendScale(SkScalar x, SkScalar y, SkScalar z) {
+  TransformOperation to_add;
+  to_add.type = TransformOperation::TRANSFORM_OPERATION_SCALE;
+  to_add.scale.x = x;
+  to_add.scale.y = y;
+  to_add.scale.z = z;
+  to_add.Bake();
+  operations_.push_back(to_add);
+  decomposed_transforms_.clear();
+}
+
+void TransformOperations::AppendSkewX(SkScalar x) {
+  TransformOperation to_add;
+  to_add.type = TransformOperation::TRANSFORM_OPERATION_SKEWX;
+  to_add.skew.x = x;
+  to_add.skew.y = 0;
+  to_add.Bake();
+  operations_.push_back(to_add);
+  decomposed_transforms_.clear();
+}
+
+void TransformOperations::AppendSkewY(SkScalar y) {
+  TransformOperation to_add;
+  to_add.type = TransformOperation::TRANSFORM_OPERATION_SKEWY;
+  to_add.skew.x = 0;
+  to_add.skew.y = y;
+  to_add.Bake();
+  operations_.push_back(to_add);
+  decomposed_transforms_.clear();
+}
+
+void TransformOperations::AppendSkew(SkScalar x, SkScalar y) {
+  TransformOperation to_add;
+  to_add.type = TransformOperation::TRANSFORM_OPERATION_SKEW;
+  to_add.skew.x = x;
+  to_add.skew.y = y;
+  to_add.Bake();
+  operations_.push_back(to_add);
+  decomposed_transforms_.clear();
+}
+
+void TransformOperations::AppendPerspective(SkScalar depth) {
+  TransformOperation to_add;
+  to_add.type = TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE;
+  to_add.perspective_depth = depth;
+  to_add.Bake();
+  operations_.push_back(to_add);
+  decomposed_transforms_.clear();
+}
+
+void TransformOperations::AppendMatrix(const Transform& matrix) {
+  TransformOperation to_add;
+  to_add.matrix = matrix;
+  to_add.type = TransformOperation::TRANSFORM_OPERATION_MATRIX;
+  operations_.push_back(to_add);
+  decomposed_transforms_.clear();
+}
+
+void TransformOperations::AppendIdentity() {
+  operations_.emplace_back();
+}
+
+void TransformOperations::Append(const TransformOperation& operation) {
+  operations_.push_back(operation);
+  decomposed_transforms_.clear();
+}
+
+bool TransformOperations::IsIdentity() const {
+  for (auto& operation : operations_) {
+    if (!operation.IsIdentity())
+      return false;
+  }
+  return true;
+}
+
+bool TransformOperations::ApproximatelyEqual(const TransformOperations& other,
+                                             SkScalar tolerance) const {
+  if (size() != other.size())
+    return false;
+  for (size_t i = 0; i < operations_.size(); ++i) {
+    if (!operations_[i].ApproximatelyEqual(other.operations_[i], tolerance))
+      return false;
+  }
+  return true;
+}
+
+bool TransformOperations::BlendInternal(const TransformOperations& from,
+                                        SkScalar progress,
+                                        TransformOperations* result) const {
+  bool from_identity = from.IsIdentity();
+  bool to_identity = IsIdentity();
+  if (from_identity && to_identity)
+    return true;
+
+  size_t matching_prefix_length = MatchingPrefixLength(from);
+  size_t from_size = from_identity ? 0 : from.operations_.size();
+  size_t to_size = to_identity ? 0 : operations_.size();
+  size_t num_operations = std::max(from_size, to_size);
+
+  for (size_t i = 0; i < matching_prefix_length; ++i) {
+    TransformOperation blended;
+    if (!TransformOperation::BlendTransformOperations(
+            i >= from_size ? nullptr : &from.operations_[i],
+            i >= to_size ? nullptr : &operations_[i], progress, &blended)) {
+      return false;
+    }
+    result->Append(blended);
+  }
+
+  if (matching_prefix_length < num_operations) {
+    if (!ComputeDecomposedTransform(matching_prefix_length) ||
+        !from.ComputeDecomposedTransform(matching_prefix_length)) {
+      return false;
+    }
+    DecomposedTransform matrix_transform = BlendDecomposedTransforms(
+        *decomposed_transforms_[matching_prefix_length].get(),
+        *from.decomposed_transforms_[matching_prefix_length].get(), progress);
+    result->AppendMatrix(ComposeTransform(matrix_transform));
+  }
+  return true;
+}
+
+bool TransformOperations::ComputeDecomposedTransform(
+    size_t start_offset) const {
+  auto it = decomposed_transforms_.find(start_offset);
+  if (it == decomposed_transforms_.end()) {
+    std::unique_ptr<DecomposedTransform> decomposed_transform =
+        std::make_unique<DecomposedTransform>();
+    Transform transform = ApplyRemaining(start_offset);
+    if (!DecomposeTransform(decomposed_transform.get(), transform))
+      return false;
+    decomposed_transforms_[start_offset] = std::move(decomposed_transform);
+  }
+  return true;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/transform_operations.h b/ui/gfx/geometry/transform_operations.h
new file mode 100644
index 0000000..f1c9a89
--- /dev/null
+++ b/ui/gfx/geometry/transform_operations.h
@@ -0,0 +1,140 @@
+// 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.
+
+#ifndef UI_GFX_GEOMETRY_TRANSFORM_OPERATIONS_H_
+#define UI_GFX_GEOMETRY_TRANSFORM_OPERATIONS_H_
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "base/check_op.h"
+#include "base/gtest_prod_util.h"
+#include "ui/gfx/geometry/geometry_skia_export.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/geometry/transform_operation.h"
+
+namespace gfx {
+
+class BoxF;
+struct DecomposedTransform;
+
+// Transform operations are a decomposed transformation matrix. It can be
+// applied to obtain a Transform at any time, and can be blended
+// intelligently with other transform operations, so long as they represent the
+// same decomposition. For example, if we have a transform that is made up of
+// a rotation followed by skew, it can be blended intelligently with another
+// transform made up of a rotation followed by a skew. Blending is possible if
+// we have two dissimilar sets of transform operations, but the effect may not
+// be what was intended. For more information, see the comments for the blend
+// function below.
+class GEOMETRY_SKIA_EXPORT TransformOperations {
+ public:
+  TransformOperations();
+  TransformOperations(const TransformOperations& other);
+  ~TransformOperations();
+
+  TransformOperations& operator=(const TransformOperations& other);
+
+  // Returns a transformation matrix representing these transform operations.
+  Transform Apply() const;
+
+  // Returns a transformation matrix representing the set of transform
+  // operations from index |start| to the end of the list.
+  Transform ApplyRemaining(size_t start) const;
+
+  // Given another set of transform operations and a progress in the range
+  // [0, 1], returns a transformation matrix representing the intermediate
+  // value. If this->MatchesTypes(from), then each of the operations are
+  // blended separately and then combined. Otherwise, the two sets of
+  // transforms are baked to matrices (using apply), and the matrices are
+  // then decomposed and interpolated. For more information, see
+  // http://www.w3.org/TR/2011/WD-css3-2d-transforms-20111215/#matrix-decomposition.
+  //
+  // If either of the matrices are non-decomposable for the blend, Blend applies
+  // discrete interpolation between them based on the progress value.
+  TransformOperations Blend(const TransformOperations& from,
+                            SkScalar progress) const;
+
+  // Sets |bounds| be the bounding box for the region within which |box| will
+  // exist when it is transformed by the result of calling Blend on |from| and
+  // with progress in the range [min_progress, max_progress]. If this region
+  // cannot be computed, returns false.
+  bool BlendedBoundsForBox(const BoxF& box,
+                           const TransformOperations& from,
+                           SkScalar min_progress,
+                           SkScalar max_progress,
+                           BoxF* bounds) const;
+
+  // Returns true if these operations are only translations.
+  bool IsTranslation() const;
+
+  // Returns false if the operations affect 2d axis alignment.
+  bool PreservesAxisAlignment() const;
+
+  // Returns true if this operation and its descendants have the same types
+  // as other and its descendants.
+  bool MatchesTypes(const TransformOperations& other) const;
+
+  // Returns the number of matching transform operations at the start of the
+  // transform lists. If one list is shorter but pairwise compatible, it will be
+  // extended with matching identity operators per spec
+  // (https://drafts.csswg.org/css-transforms/#interpolation-of-transforms).
+  size_t MatchingPrefixLength(const TransformOperations& other) const;
+
+  // Returns true if these operations can be blended. It will only return
+  // false if we must resort to matrix interpolation, and matrix interpolation
+  // fails (this can happen if either matrix cannot be decomposed).
+  bool CanBlendWith(const TransformOperations& other) const;
+
+  // If none of these operations have a perspective component, sets |scale| to
+  // be the product of the scale component of every operation. Otherwise,
+  // returns false.
+  bool ScaleComponent(SkScalar* scale) const;
+
+  void AppendTranslate(SkScalar x, SkScalar y, SkScalar z);
+  void AppendRotate(SkScalar x, SkScalar y, SkScalar z, SkScalar degrees);
+  void AppendScale(SkScalar x, SkScalar y, SkScalar z);
+  void AppendSkewX(SkScalar x);
+  void AppendSkewY(SkScalar y);
+  void AppendSkew(SkScalar x, SkScalar y);
+  void AppendPerspective(SkScalar depth);
+  void AppendMatrix(const Transform& matrix);
+  void AppendIdentity();
+  void Append(const TransformOperation& operation);
+  bool IsIdentity() const;
+
+  size_t size() const { return operations_.size(); }
+
+  const TransformOperation& at(size_t index) const {
+    DCHECK_LT(index, size());
+    return operations_[index];
+  }
+  TransformOperation& at(size_t index) {
+    DCHECK_LT(index, size());
+    return operations_[index];
+  }
+
+  bool ApproximatelyEqual(const TransformOperations& other,
+                          SkScalar tolerance) const;
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(TransformOperationsTest, TestDecompositionCache);
+
+  bool BlendInternal(const TransformOperations& from,
+                     SkScalar progress,
+                     TransformOperations* result) const;
+
+  std::vector<TransformOperation> operations_;
+
+  bool ComputeDecomposedTransform(size_t start_offset) const;
+
+  // For efficiency, we cache the decomposed transforms.
+  mutable std::unordered_map<size_t, std::unique_ptr<DecomposedTransform>>
+      decomposed_transforms_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_TRANSFORM_OPERATIONS_H_
diff --git a/ui/gfx/geometry/transform_operations_unittest.cc b/ui/gfx/geometry/transform_operations_unittest.cc
new file mode 100644
index 0000000..75f9144
--- /dev/null
+++ b/ui/gfx/geometry/transform_operations_unittest.cc
@@ -0,0 +1,1813 @@
+// 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.
+
+#include "ui/gfx/geometry/transform_operations.h"
+
+#include <stddef.h>
+
+#include <limits>
+#include <utility>
+#include <vector>
+
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/animation/tween.h"
+#include "ui/gfx/geometry/box_f.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/test/transform_test_util.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+namespace {
+
+void ExpectTransformOperationEqual(const TransformOperation& lhs,
+                                   const TransformOperation& rhs) {
+  EXPECT_EQ(lhs.type, rhs.type);
+  ExpectTransformationMatrixEq(lhs.matrix, rhs.matrix);
+  switch (lhs.type) {
+    case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
+      EXPECT_FLOAT_EQ(lhs.translate.x, rhs.translate.x);
+      EXPECT_FLOAT_EQ(lhs.translate.y, rhs.translate.y);
+      EXPECT_FLOAT_EQ(lhs.translate.z, rhs.translate.z);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_ROTATE:
+      EXPECT_FLOAT_EQ(lhs.rotate.axis.x, rhs.rotate.axis.x);
+      EXPECT_FLOAT_EQ(lhs.rotate.axis.y, rhs.rotate.axis.y);
+      EXPECT_FLOAT_EQ(lhs.rotate.axis.z, rhs.rotate.axis.z);
+      EXPECT_FLOAT_EQ(lhs.rotate.angle, rhs.rotate.angle);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_SCALE:
+      EXPECT_FLOAT_EQ(lhs.scale.x, rhs.scale.x);
+      EXPECT_FLOAT_EQ(lhs.scale.y, rhs.scale.y);
+      EXPECT_FLOAT_EQ(lhs.scale.z, rhs.scale.z);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_SKEWX:
+    case TransformOperation::TRANSFORM_OPERATION_SKEWY:
+    case TransformOperation::TRANSFORM_OPERATION_SKEW:
+      EXPECT_FLOAT_EQ(lhs.skew.x, rhs.skew.x);
+      EXPECT_FLOAT_EQ(lhs.skew.y, rhs.skew.y);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
+      EXPECT_FLOAT_EQ(lhs.perspective_depth, rhs.perspective_depth);
+      break;
+    case TransformOperation::TRANSFORM_OPERATION_MATRIX:
+    case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+      break;
+  }
+}
+
+TEST(TransformOperationTest, TransformTypesAreUnique) {
+  std::vector<std::unique_ptr<TransformOperations>> transforms;
+
+  std::unique_ptr<TransformOperations> to_add(
+      std::make_unique<TransformOperations>());
+  to_add->AppendTranslate(1, 0, 0);
+  transforms.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendRotate(0, 0, 1, 2);
+  transforms.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendScale(2, 2, 2);
+  transforms.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendSkew(1, 0);
+  transforms.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendPerspective(800);
+  transforms.push_back(std::move(to_add));
+
+  for (size_t i = 0; i < transforms.size(); ++i) {
+    for (size_t j = 0; j < transforms.size(); ++j) {
+      bool matches_type = transforms[i]->MatchesTypes(*transforms[j]);
+      EXPECT_TRUE((i == j && matches_type) || !matches_type);
+    }
+  }
+}
+
+TEST(TransformOperationTest, MatchingPrefixSameLength) {
+  TransformOperations translates;
+  translates.AppendTranslate(1, 0, 0);
+  translates.AppendTranslate(1, 0, 0);
+  translates.AppendTranslate(1, 0, 0);
+
+  TransformOperations skews;
+  skews.AppendSkew(0, 2);
+  skews.AppendSkew(0, 2);
+  skews.AppendSkew(0, 2);
+
+  TransformOperations translates2;
+  translates2.AppendTranslate(0, 2, 0);
+  translates2.AppendTranslate(0, 2, 0);
+  translates2.AppendTranslate(0, 2, 0);
+
+  TransformOperations mixed;
+  mixed.AppendTranslate(0, 2, 0);
+  mixed.AppendScale(2, 1, 1);
+  mixed.AppendSkew(0, 2);
+
+  TransformOperations translates3 = translates2;
+
+  EXPECT_EQ(0UL, translates.MatchingPrefixLength(skews));
+  EXPECT_EQ(3UL, translates.MatchingPrefixLength(translates2));
+  EXPECT_EQ(3UL, translates.MatchingPrefixLength(translates3));
+  EXPECT_EQ(1UL, translates.MatchingPrefixLength(mixed));
+}
+
+TEST(TransformOperationTest, MatchingPrefixDifferentLength) {
+  TransformOperations translates;
+  translates.AppendTranslate(1, 0, 0);
+  translates.AppendTranslate(1, 0, 0);
+  translates.AppendTranslate(1, 0, 0);
+
+  TransformOperations skews;
+  skews.AppendSkew(2, 0);
+  skews.AppendSkew(2, 0);
+
+  TransformOperations translates2;
+  translates2.AppendTranslate(0, 2, 0);
+  translates2.AppendTranslate(0, 2, 0);
+
+  TransformOperations none;
+
+  EXPECT_EQ(0UL, translates.MatchingPrefixLength(skews));
+  // Pad the length of the shorter list provided all previous operation-
+  // pairs match per spec
+  // (https://drafts.csswg.org/css-transforms/#interpolation-of-transforms).
+  EXPECT_EQ(3UL, translates.MatchingPrefixLength(translates2));
+  EXPECT_EQ(3UL, translates.MatchingPrefixLength(none));
+}
+
+std::vector<std::unique_ptr<TransformOperations>> GetIdentityOperations() {
+  std::vector<std::unique_ptr<TransformOperations>> operations;
+  std::unique_ptr<TransformOperations> to_add(
+      std::make_unique<TransformOperations>());
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendTranslate(0, 0, 0);
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendTranslate(0, 0, 0);
+  to_add->AppendTranslate(0, 0, 0);
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendScale(1, 1, 1);
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendScale(1, 1, 1);
+  to_add->AppendScale(1, 1, 1);
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendSkew(0, 0);
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendSkew(0, 0);
+  to_add->AppendSkew(0, 0);
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendRotate(0, 0, 1, 0);
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendRotate(0, 0, 1, 0);
+  to_add->AppendRotate(0, 0, 1, 0);
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendMatrix(gfx::Transform());
+  operations.push_back(std::move(to_add));
+
+  to_add = std::make_unique<TransformOperations>();
+  to_add->AppendMatrix(gfx::Transform());
+  to_add->AppendMatrix(gfx::Transform());
+  operations.push_back(std::move(to_add));
+
+  return operations;
+}
+
+TEST(TransformOperationTest, MatchingPrefixLengthOrder) {
+  TransformOperations mix_order_identity;
+  mix_order_identity.AppendTranslate(0, 0, 0);
+  mix_order_identity.AppendScale(1, 1, 1);
+  mix_order_identity.AppendTranslate(0, 0, 0);
+
+  TransformOperations mix_order_one;
+  mix_order_one.AppendTranslate(0, 1, 0);
+  mix_order_one.AppendScale(2, 1, 3);
+  mix_order_one.AppendTranslate(1, 0, 0);
+
+  TransformOperations mix_order_two;
+  mix_order_two.AppendTranslate(0, 1, 0);
+  mix_order_two.AppendTranslate(1, 0, 0);
+  mix_order_two.AppendScale(2, 1, 3);
+
+  EXPECT_EQ(3UL, mix_order_identity.MatchingPrefixLength(mix_order_one));
+  EXPECT_EQ(1UL, mix_order_identity.MatchingPrefixLength(mix_order_two));
+  EXPECT_EQ(1UL, mix_order_one.MatchingPrefixLength(mix_order_two));
+}
+
+TEST(TransformOperationTest, NoneAlwaysMatches) {
+  std::vector<std::unique_ptr<TransformOperations>> operations =
+      GetIdentityOperations();
+
+  TransformOperations none_operation;
+  for (const auto& operation : operations) {
+    EXPECT_EQ(operation->size(),
+              operation->MatchingPrefixLength(none_operation));
+  }
+}
+
+TEST(TransformOperationTest, ApplyTranslate) {
+  SkScalar x = 1;
+  SkScalar y = 2;
+  SkScalar z = 3;
+  TransformOperations operations;
+  operations.AppendTranslate(x, y, z);
+  gfx::Transform expected;
+  expected.Translate3d(x, y, z);
+  ExpectTransformationMatrixEq(expected, operations.Apply());
+}
+
+TEST(TransformOperationTest, ApplyRotate) {
+  SkScalar x = 1;
+  SkScalar y = 2;
+  SkScalar z = 3;
+  SkScalar degrees = 80;
+  TransformOperations operations;
+  operations.AppendRotate(x, y, z, degrees);
+  gfx::Transform expected;
+  expected.RotateAbout(gfx::Vector3dF(x, y, z), degrees);
+  ExpectTransformationMatrixEq(expected, operations.Apply());
+}
+
+TEST(TransformOperationTest, ApplyScale) {
+  SkScalar x = 1;
+  SkScalar y = 2;
+  SkScalar z = 3;
+  TransformOperations operations;
+  operations.AppendScale(x, y, z);
+  gfx::Transform expected;
+  expected.Scale3d(x, y, z);
+  ExpectTransformationMatrixEq(expected, operations.Apply());
+}
+
+TEST(TransformOperationTest, ApplySkew) {
+  SkScalar x = 1;
+  SkScalar y = 2;
+  TransformOperations operations;
+  operations.AppendSkew(x, y);
+  gfx::Transform expected;
+  expected.Skew(x, y);
+  ExpectTransformationMatrixEq(expected, operations.Apply());
+}
+
+TEST(TransformOperationTest, ApplyPerspective) {
+  SkScalar depth = 800;
+  TransformOperations operations;
+  operations.AppendPerspective(depth);
+  gfx::Transform expected;
+  expected.ApplyPerspectiveDepth(depth);
+  ExpectTransformationMatrixEq(expected, operations.Apply());
+}
+
+TEST(TransformOperationTest, ApplyMatrix) {
+  SkScalar dx = 1;
+  SkScalar dy = 2;
+  SkScalar dz = 3;
+  gfx::Transform expected_matrix;
+  expected_matrix.Translate3d(dx, dy, dz);
+  TransformOperations matrix_transform;
+  matrix_transform.AppendMatrix(expected_matrix);
+  ExpectTransformationMatrixEq(expected_matrix, matrix_transform.Apply());
+}
+
+TEST(TransformOperationTest, ApplyOrder) {
+  SkScalar sx = 2;
+  SkScalar sy = 4;
+  SkScalar sz = 8;
+
+  SkScalar dx = 1;
+  SkScalar dy = 2;
+  SkScalar dz = 3;
+
+  TransformOperations operations;
+  operations.AppendScale(sx, sy, sz);
+  operations.AppendTranslate(dx, dy, dz);
+
+  gfx::Transform expected_scale_matrix;
+  expected_scale_matrix.Scale3d(sx, sy, sz);
+
+  gfx::Transform expected_translate_matrix;
+  expected_translate_matrix.Translate3d(dx, dy, dz);
+
+  gfx::Transform expected_combined_matrix = expected_scale_matrix;
+  expected_combined_matrix.PreconcatTransform(expected_translate_matrix);
+
+  ExpectTransformationMatrixEq(expected_combined_matrix, operations.Apply());
+}
+
+TEST(TransformOperationTest, BlendOrder) {
+  SkScalar sx1 = 2;
+  SkScalar sy1 = 4;
+  SkScalar sz1 = 8;
+
+  SkScalar dx1 = 1;
+  SkScalar dy1 = 2;
+  SkScalar dz1 = 3;
+
+  SkScalar sx2 = 4;
+  SkScalar sy2 = 8;
+  SkScalar sz2 = 16;
+
+  SkScalar dx2 = 10;
+  SkScalar dy2 = 20;
+  SkScalar dz2 = 30;
+
+  SkScalar sx3 = 2;
+  SkScalar sy3 = 1;
+  SkScalar sz3 = 1;
+
+  TransformOperations operations_from;
+  operations_from.AppendScale(sx1, sy1, sz1);
+  operations_from.AppendTranslate(dx1, dy1, dz1);
+
+  TransformOperations operations_to;
+  operations_to.AppendScale(sx2, sy2, sz2);
+  operations_to.AppendTranslate(dx2, dy2, dz2);
+
+  gfx::Transform scale_from;
+  scale_from.Scale3d(sx1, sy1, sz1);
+  gfx::Transform translate_from;
+  translate_from.Translate3d(dx1, dy1, dz1);
+
+  gfx::Transform scale_to;
+  scale_to.Scale3d(sx2, sy2, sz2);
+  gfx::Transform translate_to;
+  translate_to.Translate3d(dx2, dy2, dz2);
+
+  SkScalar progress = 0.25f;
+
+  TransformOperations operations_expected;
+  operations_expected.AppendScale(
+      gfx::Tween::FloatValueBetween(progress, sx1, sx2),
+      gfx::Tween::FloatValueBetween(progress, sy1, sy2),
+      gfx::Tween::FloatValueBetween(progress, sz1, sz2));
+
+  operations_expected.AppendTranslate(
+      gfx::Tween::FloatValueBetween(progress, dx1, dx2),
+      gfx::Tween::FloatValueBetween(progress, dy1, dy2),
+      gfx::Tween::FloatValueBetween(progress, dz1, dz2));
+
+  gfx::Transform blended_scale = scale_to;
+  blended_scale.Blend(scale_from, progress);
+
+  gfx::Transform blended_translate = translate_to;
+  blended_translate.Blend(translate_from, progress);
+
+  gfx::Transform expected = blended_scale;
+  expected.PreconcatTransform(blended_translate);
+
+  TransformOperations blended = operations_to.Blend(operations_from, progress);
+
+  ExpectTransformationMatrixEq(expected, blended.Apply());
+  ExpectTransformationMatrixEq(operations_expected.Apply(), blended.Apply());
+  EXPECT_EQ(operations_expected.size(), blended.size());
+  for (size_t i = 0; i < operations_expected.size(); ++i) {
+    TransformOperation expected_op = operations_expected.at(i);
+    TransformOperation blended_op = blended.at(i);
+    SCOPED_TRACE(i);
+    ExpectTransformOperationEqual(expected_op, blended_op);
+  }
+
+  TransformOperations base_operations_expected = operations_expected;
+
+  // Create a mismatch in number of operations. Pairwise interpolation is still
+  // used when the operations match up to the length of the shorter list.
+  operations_to.AppendScale(sx3, sy3, sz3);
+
+  gfx::Transform appended_scale;
+  appended_scale.Scale3d(sx3, sy3, sz3);
+
+  gfx::Transform blended_append_scale = appended_scale;
+  blended_append_scale.Blend(gfx::Transform(), progress);
+  expected.PreconcatTransform(blended_append_scale);
+
+  operations_expected.AppendScale(
+      gfx::Tween::FloatValueBetween(progress, 1, sx3),
+      gfx::Tween::FloatValueBetween(progress, 1, sy3),
+      gfx::Tween::FloatValueBetween(progress, 1, sz3));
+
+  blended = operations_to.Blend(operations_from, progress);
+
+  ExpectTransformationMatrixEq(expected, blended.Apply());
+  ExpectTransformationMatrixEq(operations_expected.Apply(), blended.Apply());
+  EXPECT_EQ(operations_expected.size(), blended.size());
+  for (size_t i = 0; i < operations_expected.size(); ++i) {
+    TransformOperation expected_op = operations_expected.at(i);
+    TransformOperation blended_op = blended.at(i);
+    SCOPED_TRACE(i);
+    ExpectTransformOperationEqual(expected_op, blended_op);
+  }
+
+  // Create a mismatch, forcing matrix interpolation for the last operator pair.
+  operations_from.AppendRotate(0, 0, 1, 90);
+
+  blended = operations_to.Blend(operations_from, progress);
+
+  gfx::Transform transform_from;
+  transform_from.RotateAboutZAxis(90);
+  gfx::Transform transform_to;
+  transform_to.Scale3d(sx3, sy3, sz3);
+  gfx::Transform blended_matrix = transform_to;
+  blended_matrix.Blend(transform_from, progress);
+
+  expected = blended_scale;
+  expected.PreconcatTransform(blended_translate);
+  expected.PreconcatTransform(blended_matrix);
+
+  operations_expected = base_operations_expected;
+  operations_expected.AppendMatrix(blended_matrix);
+
+  ExpectTransformationMatrixEq(expected, blended.Apply());
+  ExpectTransformationMatrixEq(operations_expected.Apply(), blended.Apply());
+  EXPECT_EQ(operations_expected.size(), blended.size());
+  for (size_t i = 0; i < operations_expected.size(); ++i) {
+    TransformOperation expected_op = operations_expected.at(i);
+    TransformOperation blended_op = blended.at(i);
+    SCOPED_TRACE(i);
+    ExpectTransformOperationEqual(expected_op, blended_op);
+  }
+}
+
+static void CheckProgress(SkScalar progress,
+                          const gfx::Transform& from_matrix,
+                          const gfx::Transform& to_matrix,
+                          const TransformOperations& from_transform,
+                          const TransformOperations& to_transform) {
+  gfx::Transform expected_matrix = to_matrix;
+  expected_matrix.Blend(from_matrix, progress);
+  ExpectTransformationMatrixEq(
+      expected_matrix, to_transform.Blend(from_transform, progress).Apply());
+}
+
+TEST(TransformOperationTest, BlendProgress) {
+  SkScalar sx = 2;
+  SkScalar sy = 4;
+  SkScalar sz = 8;
+  TransformOperations operations_from;
+  operations_from.AppendScale(sx, sy, sz);
+
+  gfx::Transform matrix_from;
+  matrix_from.Scale3d(sx, sy, sz);
+
+  sx = 4;
+  sy = 8;
+  sz = 16;
+  TransformOperations operations_to;
+  operations_to.AppendScale(sx, sy, sz);
+
+  gfx::Transform matrix_to;
+  matrix_to.Scale3d(sx, sy, sz);
+
+  CheckProgress(-1, matrix_from, matrix_to, operations_from, operations_to);
+  CheckProgress(0, matrix_from, matrix_to, operations_from, operations_to);
+  CheckProgress(0.25f, matrix_from, matrix_to, operations_from, operations_to);
+  CheckProgress(0.5f, matrix_from, matrix_to, operations_from, operations_to);
+  CheckProgress(1, matrix_from, matrix_to, operations_from, operations_to);
+  CheckProgress(2, matrix_from, matrix_to, operations_from, operations_to);
+}
+
+TEST(TransformOperationTest, BlendWhenTypesDoNotMatch) {
+  SkScalar sx1 = 2;
+  SkScalar sy1 = 4;
+  SkScalar sz1 = 8;
+
+  SkScalar dx1 = 1;
+  SkScalar dy1 = 2;
+  SkScalar dz1 = 3;
+
+  SkScalar sx2 = 4;
+  SkScalar sy2 = 8;
+  SkScalar sz2 = 16;
+
+  SkScalar dx2 = 10;
+  SkScalar dy2 = 20;
+  SkScalar dz2 = 30;
+
+  TransformOperations operations_from;
+  operations_from.AppendScale(sx1, sy1, sz1);
+  operations_from.AppendTranslate(dx1, dy1, dz1);
+
+  TransformOperations operations_to;
+  operations_to.AppendTranslate(dx2, dy2, dz2);
+  operations_to.AppendScale(sx2, sy2, sz2);
+
+  gfx::Transform from;
+  from.Scale3d(sx1, sy1, sz1);
+  from.Translate3d(dx1, dy1, dz1);
+
+  gfx::Transform to;
+  to.Translate3d(dx2, dy2, dz2);
+  to.Scale3d(sx2, sy2, sz2);
+
+  SkScalar progress = 0.25f;
+
+  gfx::Transform expected = to;
+  expected.Blend(from, progress);
+
+  ExpectTransformationMatrixEq(
+      expected, operations_to.Blend(operations_from, progress).Apply());
+}
+
+TEST(TransformOperationTest, LargeRotationsWithSameAxis) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(0, 0, 1, 0);
+
+  TransformOperations operations_to;
+  operations_to.AppendRotate(0, 0, 2, 360);
+
+  SkScalar progress = 0.5f;
+
+  gfx::Transform expected;
+  expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
+
+  ExpectTransformationMatrixEq(
+      expected, operations_to.Blend(operations_from, progress).Apply());
+}
+
+TEST(TransformOperationTest, LargeRotationsWithSameAxisInDifferentDirection) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(0, 0, 1, 180);
+
+  TransformOperations operations_to;
+  operations_to.AppendRotate(0, 0, -1, 180);
+
+  SkScalar progress = 0.5f;
+
+  gfx::Transform expected;
+
+  ExpectTransformationMatrixEq(
+      expected, operations_to.Blend(operations_from, progress).Apply());
+}
+
+TEST(TransformOperationTest, LargeRotationsWithDifferentAxes) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(0, 0, 1, 175);
+
+  TransformOperations operations_to;
+  operations_to.AppendRotate(0, 1, 0, 175);
+
+  SkScalar progress = 0.5f;
+  gfx::Transform matrix_from;
+  matrix_from.RotateAbout(gfx::Vector3dF(0, 0, 1), 175);
+
+  gfx::Transform matrix_to;
+  matrix_to.RotateAbout(gfx::Vector3dF(0, 1, 0), 175);
+
+  gfx::Transform expected = matrix_to;
+  expected.Blend(matrix_from, progress);
+
+  ExpectTransformationMatrixEq(
+      expected, operations_to.Blend(operations_from, progress).Apply());
+}
+
+TEST(TransformOperationTest, RotationFromZeroDegDifferentAxes) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(0, 0, 1, 0);
+
+  TransformOperations operations_to;
+  operations_to.AppendRotate(0, 1, 0, 450);
+
+  SkScalar progress = 0.5f;
+  gfx::Transform expected;
+  expected.RotateAbout(gfx::Vector3dF(0, 1, 0), 225);
+  ExpectTransformationMatrixEq(
+      expected, operations_to.Blend(operations_from, progress).Apply());
+}
+
+TEST(TransformOperationTest, RotationFromZeroDegSameAxes) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(0, 0, 1, 0);
+
+  TransformOperations operations_to;
+  operations_to.AppendRotate(0, 0, 1, 450);
+
+  SkScalar progress = 0.5f;
+  gfx::Transform expected;
+  expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 225);
+  ExpectTransformationMatrixEq(
+      expected, operations_to.Blend(operations_from, progress).Apply());
+}
+
+TEST(TransformOperationTest, RotationToZeroDegDifferentAxes) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(0, 1, 0, 450);
+
+  TransformOperations operations_to;
+  operations_to.AppendRotate(0, 0, 1, 0);
+
+  SkScalar progress = 0.5f;
+  gfx::Transform expected;
+  expected.RotateAbout(gfx::Vector3dF(0, 1, 0), 225);
+  ExpectTransformationMatrixEq(
+      expected, operations_to.Blend(operations_from, progress).Apply());
+}
+
+TEST(TransformOperationTest, RotationToZeroDegSameAxes) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(0, 0, 1, 450);
+
+  TransformOperations operations_to;
+  operations_to.AppendRotate(0, 0, 1, 0);
+
+  SkScalar progress = 0.5f;
+  gfx::Transform expected;
+  expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 225);
+  ExpectTransformationMatrixEq(
+      expected, operations_to.Blend(operations_from, progress).Apply());
+}
+
+TEST(TransformOperationTest, BlendRotationFromIdentity) {
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
+      GetIdentityOperations();
+
+  for (const auto& identity_operation : identity_operations) {
+    TransformOperations operations;
+    operations.AppendRotate(0, 0, 1, 90);
+
+    SkScalar progress = 0.5f;
+
+    gfx::Transform expected;
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+
+    progress = -0.5f;
+
+    expected.MakeIdentity();
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), -45);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+
+    progress = 1.5f;
+
+    expected.MakeIdentity();
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 135);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+  }
+}
+
+TEST(TransformOperationTest, BlendTranslationFromIdentity) {
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
+      GetIdentityOperations();
+
+  for (const auto& identity_operation : identity_operations) {
+    TransformOperations operations;
+    operations.AppendTranslate(2, 2, 2);
+
+    SkScalar progress = 0.5f;
+
+    gfx::Transform expected;
+    expected.Translate3d(1, 1, 1);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+
+    progress = -0.5f;
+
+    expected.MakeIdentity();
+    expected.Translate3d(-1, -1, -1);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+
+    progress = 1.5f;
+
+    expected.MakeIdentity();
+    expected.Translate3d(3, 3, 3);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+  }
+}
+
+TEST(TransformOperationTest, BlendScaleFromIdentity) {
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
+      GetIdentityOperations();
+
+  for (const auto& identity_operation : identity_operations) {
+    TransformOperations operations;
+    operations.AppendScale(3, 3, 3);
+
+    SkScalar progress = 0.5f;
+
+    gfx::Transform expected;
+    expected.Scale3d(2, 2, 2);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+
+    progress = -0.5f;
+
+    expected.MakeIdentity();
+    expected.Scale3d(0, 0, 0);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+
+    progress = 1.5f;
+
+    expected.MakeIdentity();
+    expected.Scale3d(4, 4, 4);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+  }
+}
+
+TEST(TransformOperationTest, BlendSkewFromEmpty) {
+  TransformOperations empty_operation;
+
+  TransformOperations operations;
+  operations.AppendSkew(2, 2);
+
+  SkScalar progress = 0.5f;
+
+  gfx::Transform expected;
+  expected.Skew(1, 1);
+
+  ExpectTransformationMatrixEq(
+      expected, operations.Blend(empty_operation, progress).Apply());
+
+  progress = -0.5f;
+
+  expected.MakeIdentity();
+  expected.Skew(-1, -1);
+
+  ExpectTransformationMatrixEq(
+      expected, operations.Blend(empty_operation, progress).Apply());
+
+  progress = 1.5f;
+
+  expected.MakeIdentity();
+  expected.Skew(3, 3);
+
+  ExpectTransformationMatrixEq(
+      expected, operations.Blend(empty_operation, progress).Apply());
+}
+
+TEST(TransformOperationTest, BlendPerspectiveFromIdentity) {
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
+      GetIdentityOperations();
+
+  for (const auto& identity_operation : identity_operations) {
+    TransformOperations operations;
+    operations.AppendPerspective(1000);
+
+    SkScalar progress = 0.5f;
+
+    gfx::Transform expected;
+    expected.ApplyPerspectiveDepth(2000);
+
+    ExpectTransformationMatrixEq(
+        expected, operations.Blend(*identity_operation, progress).Apply());
+  }
+}
+
+TEST(TransformOperationTest, BlendRotationToIdentity) {
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
+      GetIdentityOperations();
+
+  for (const auto& identity_operation : identity_operations) {
+    TransformOperations operations;
+    operations.AppendRotate(0, 0, 1, 90);
+
+    SkScalar progress = 0.5f;
+
+    gfx::Transform expected;
+    expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
+
+    ExpectTransformationMatrixEq(
+        expected, identity_operation->Blend(operations, progress).Apply());
+  }
+}
+
+TEST(TransformOperationTest, BlendTranslationToIdentity) {
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
+      GetIdentityOperations();
+
+  for (const auto& identity_operation : identity_operations) {
+    TransformOperations operations;
+    operations.AppendTranslate(2, 2, 2);
+
+    SkScalar progress = 0.5f;
+
+    gfx::Transform expected;
+    expected.Translate3d(1, 1, 1);
+
+    ExpectTransformationMatrixEq(
+        expected, identity_operation->Blend(operations, progress).Apply());
+  }
+}
+
+TEST(TransformOperationTest, BlendScaleToIdentity) {
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
+      GetIdentityOperations();
+
+  for (const auto& identity_operation : identity_operations) {
+    TransformOperations operations;
+    operations.AppendScale(3, 3, 3);
+
+    SkScalar progress = 0.5f;
+
+    gfx::Transform expected;
+    expected.Scale3d(2, 2, 2);
+
+    ExpectTransformationMatrixEq(
+        expected, identity_operation->Blend(operations, progress).Apply());
+  }
+}
+
+TEST(TransformOperationTest, BlendSkewToEmpty) {
+  TransformOperations empty_operation;
+
+  TransformOperations operations;
+  operations.AppendSkew(2, 2);
+
+  SkScalar progress = 0.5f;
+
+  gfx::Transform expected;
+  expected.Skew(1, 1);
+
+  ExpectTransformationMatrixEq(
+      expected, empty_operation.Blend(operations, progress).Apply());
+}
+
+TEST(TransformOperationTest, BlendPerspectiveToIdentity) {
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
+      GetIdentityOperations();
+
+  for (const auto& identity_operation : identity_operations) {
+    TransformOperations operations;
+    operations.AppendPerspective(1000);
+
+    SkScalar progress = 0.5f;
+
+    gfx::Transform expected;
+    expected.ApplyPerspectiveDepth(2000);
+
+    ExpectTransformationMatrixEq(
+        expected, identity_operation->Blend(operations, progress).Apply());
+  }
+}
+
+TEST(TransformOperationTest, ExtrapolatePerspectiveBlending) {
+  TransformOperations operations1;
+  operations1.AppendPerspective(1000);
+
+  TransformOperations operations2;
+  operations2.AppendPerspective(500);
+
+  gfx::Transform expected;
+  expected.ApplyPerspectiveDepth(400);
+
+  ExpectTransformationMatrixEq(expected,
+                               operations1.Blend(operations2, -0.5).Apply());
+
+  expected.MakeIdentity();
+  expected.ApplyPerspectiveDepth(2000);
+
+  ExpectTransformationMatrixEq(expected,
+                               operations1.Blend(operations2, 1.5).Apply());
+}
+
+TEST(TransformOperationTest, ExtrapolateMatrixBlending) {
+  gfx::Transform transform1;
+  transform1.Translate3d(1, 1, 1);
+  TransformOperations operations1;
+  operations1.AppendMatrix(transform1);
+
+  gfx::Transform transform2;
+  transform2.Translate3d(3, 3, 3);
+  TransformOperations operations2;
+  operations2.AppendMatrix(transform2);
+
+  gfx::Transform expected;
+  ExpectTransformationMatrixEq(expected,
+                               operations1.Blend(operations2, 1.5).Apply());
+
+  expected.Translate3d(4, 4, 4);
+  ExpectTransformationMatrixEq(expected,
+                               operations1.Blend(operations2, -0.5).Apply());
+}
+
+TEST(TransformOperationTest, NonDecomposableBlend) {
+  TransformOperations non_decomposible_transform;
+  gfx::Transform non_decomposible_matrix(0, 0, 0, 0, 0, 0);
+  non_decomposible_transform.AppendMatrix(non_decomposible_matrix);
+
+  TransformOperations identity_transform;
+  gfx::Transform identity_matrix;
+  identity_transform.AppendMatrix(identity_matrix);
+
+  // Before the half-way point, we should return the 'from' matrix.
+  ExpectTransformationMatrixEq(
+      non_decomposible_matrix,
+      identity_transform.Blend(non_decomposible_transform, 0.0f).Apply());
+  ExpectTransformationMatrixEq(
+      non_decomposible_matrix,
+      identity_transform.Blend(non_decomposible_transform, 0.49f).Apply());
+
+  // After the half-way point, we should return the 'to' matrix.
+  ExpectTransformationMatrixEq(
+      identity_matrix,
+      identity_transform.Blend(non_decomposible_transform, 0.5f).Apply());
+  ExpectTransformationMatrixEq(
+      identity_matrix,
+      identity_transform.Blend(non_decomposible_transform, 1.0f).Apply());
+}
+
+TEST(TransformOperationTest, BlendedBoundsWhenTypesDoNotMatch) {
+  TransformOperations operations_from;
+  operations_from.AppendScale(2.0, 4.0, 8.0);
+  operations_from.AppendTranslate(1.0, 2.0, 3.0);
+
+  TransformOperations operations_to;
+  operations_to.AppendTranslate(10.0, 20.0, 30.0);
+  operations_to.AppendScale(4.0, 8.0, 16.0);
+
+  gfx::BoxF box(1.f, 1.f, 1.f);
+  gfx::BoxF bounds;
+
+  SkScalar min_progress = 0.f;
+  SkScalar max_progress = 1.f;
+
+  EXPECT_FALSE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+}
+
+TEST(TransformOperationTest, BlendedBoundsForIdentity) {
+  TransformOperations operations_from;
+  operations_from.AppendIdentity();
+  TransformOperations operations_to;
+  operations_to.AppendIdentity();
+
+  gfx::BoxF box(1.f, 2.f, 3.f);
+  gfx::BoxF bounds;
+
+  SkScalar min_progress = 0.f;
+  SkScalar max_progress = 1.f;
+
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+  EXPECT_EQ(box.ToString(), bounds.ToString());
+}
+
+TEST(TransformOperationTest, BlendedBoundsForTranslate) {
+  TransformOperations operations_from;
+  operations_from.AppendTranslate(3.0, -4.0, 2.0);
+  TransformOperations operations_to;
+  operations_to.AppendTranslate(7.0, 4.0, -2.0);
+
+  gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
+  gfx::BoxF bounds;
+
+  SkScalar min_progress = -0.5f;
+  SkScalar max_progress = 1.5f;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(2.f, -6.f, -1.f, 12.f, 20.f, 12.f).ToString(),
+            bounds.ToString());
+
+  min_progress = 0.f;
+  max_progress = 1.f;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(4.f, -2.f, 1.f, 8.f, 12.f, 8.f).ToString(),
+            bounds.ToString());
+
+  TransformOperations identity;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(box, identity, min_progress,
+                                                max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(1.f, 2.f, 1.f, 11.f, 8.f, 6.f).ToString(),
+            bounds.ToString());
+
+  EXPECT_TRUE(identity.BlendedBoundsForBox(box, operations_from, min_progress,
+                                           max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(1.f, -2.f, 3.f, 7.f, 8.f, 6.f).ToString(),
+            bounds.ToString());
+}
+
+TEST(TransformOperationTest, BlendedBoundsForScale) {
+  TransformOperations operations_from;
+  operations_from.AppendScale(3.0, 0.5, 2.0);
+  TransformOperations operations_to;
+  operations_to.AppendScale(7.0, 4.0, -2.0);
+
+  gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
+  gfx::BoxF bounds;
+
+  SkScalar min_progress = -0.5f;
+  SkScalar max_progress = 1.5f;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(1.f, -7.5f, -28.f, 44.f, 42.f, 56.f).ToString(),
+            bounds.ToString());
+
+  min_progress = 0.f;
+  max_progress = 1.f;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(3.f, 1.f, -14.f, 32.f, 23.f, 28.f).ToString(),
+            bounds.ToString());
+
+  TransformOperations identity;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(box, identity, min_progress,
+                                                max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(1.f, 2.f, -14.f, 34.f, 22.f, 21.f).ToString(),
+            bounds.ToString());
+
+  EXPECT_TRUE(identity.BlendedBoundsForBox(box, operations_from, min_progress,
+                                           max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(1.f, 1.f, 3.f, 14.f, 5.f, 11.f).ToString(),
+            bounds.ToString());
+}
+
+TEST(TransformOperationTest, BlendedBoundsWithZeroScale) {
+  TransformOperations zero_scale;
+  zero_scale.AppendScale(0.0, 0.0, 0.0);
+  TransformOperations non_zero_scale;
+  non_zero_scale.AppendScale(2.0, -4.0, 5.0);
+
+  gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
+  gfx::BoxF bounds;
+
+  SkScalar min_progress = 0.f;
+  SkScalar max_progress = 1.f;
+  EXPECT_TRUE(zero_scale.BlendedBoundsForBox(box, non_zero_scale, min_progress,
+                                             max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(0.f, -24.f, 0.f, 10.f, 24.f, 35.f).ToString(),
+            bounds.ToString());
+
+  EXPECT_TRUE(non_zero_scale.BlendedBoundsForBox(box, zero_scale, min_progress,
+                                                 max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(0.f, -24.f, 0.f, 10.f, 24.f, 35.f).ToString(),
+            bounds.ToString());
+
+  EXPECT_TRUE(zero_scale.BlendedBoundsForBox(box, zero_scale, min_progress,
+                                             max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF().ToString(), bounds.ToString());
+}
+
+TEST(TransformOperationTest, BlendedBoundsForRotationTrivial) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(0.f, 0.f, 1.f, 0.f);
+  TransformOperations operations_to;
+  operations_to.AppendRotate(0.f, 0.f, 1.f, 360.f);
+
+  float sqrt_2 = sqrt(2.f);
+  gfx::BoxF box(-sqrt_2, -sqrt_2, 0.f, sqrt_2, sqrt_2, 0.f);
+  gfx::BoxF bounds;
+
+  // Since we're rotating 360 degrees, any box with dimensions between 0 and
+  // 2 * sqrt(2) should give the same result.
+  float sizes[] = {0.f, 0.1f, sqrt_2, 2.f * sqrt_2};
+  for (float size : sizes) {
+    box.set_size(size, size, 0.f);
+    SkScalar min_progress = 0.f;
+    SkScalar max_progress = 1.f;
+    EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+        box, operations_from, min_progress, max_progress, &bounds));
+    EXPECT_EQ(gfx::BoxF(-2.f, -2.f, 0.f, 4.f, 4.f, 0.f).ToString(),
+              bounds.ToString());
+  }
+}
+
+TEST(TransformOperationTest, BlendedBoundsForRotationAllExtrema) {
+  // If the normal is out of the plane, we can have up to 6 extrema (a min/max
+  // in each dimension) between the endpoints of the arc. This test ensures that
+  // we consider all 6.
+  TransformOperations operations_from;
+  operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
+  TransformOperations operations_to;
+  operations_to.AppendRotate(1.f, 1.f, 1.f, 390.f);
+
+  gfx::BoxF box(1.f, 0.f, 0.f, 0.f, 0.f, 0.f);
+  gfx::BoxF bounds;
+
+  float min = -1.f / 3.f;
+  float max = 1.f;
+  float size = max - min;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(box, operations_from, 0.f, 1.f,
+                                                &bounds));
+  EXPECT_EQ(gfx::BoxF(min, min, min, size, size, size).ToString(),
+            bounds.ToString());
+}
+
+TEST(TransformOperationTest, BlendedBoundsForRotationDifferentAxes) {
+  // We can handle rotations about a single axis. If the axes are different,
+  // we revert to matrix interpolation for which inflated bounds cannot be
+  // computed.
+  TransformOperations operations_from;
+  operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
+  TransformOperations operations_to_same;
+  operations_to_same.AppendRotate(1.f, 1.f, 1.f, 390.f);
+  TransformOperations operations_to_opposite;
+  operations_to_opposite.AppendRotate(-1.f, -1.f, -1.f, 390.f);
+  TransformOperations operations_to_different;
+  operations_to_different.AppendRotate(1.f, 3.f, 1.f, 390.f);
+
+  gfx::BoxF box(1.f, 0.f, 0.f, 0.f, 0.f, 0.f);
+  gfx::BoxF bounds;
+
+  EXPECT_TRUE(operations_to_same.BlendedBoundsForBox(box, operations_from, 0.f,
+                                                     1.f, &bounds));
+  EXPECT_TRUE(operations_to_opposite.BlendedBoundsForBox(box, operations_from,
+                                                         0.f, 1.f, &bounds));
+  EXPECT_FALSE(operations_to_different.BlendedBoundsForBox(box, operations_from,
+                                                           0.f, 1.f, &bounds));
+}
+
+TEST(TransformOperationTest, BlendedBoundsForRotationPointOnAxis) {
+  // Checks that if the point to rotate is sitting on the axis of rotation, that
+  // it does not get affected.
+  TransformOperations operations_from;
+  operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
+  TransformOperations operations_to;
+  operations_to.AppendRotate(1.f, 1.f, 1.f, 390.f);
+
+  gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
+  gfx::BoxF bounds;
+
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(box, operations_from, 0.f, 1.f,
+                                                &bounds));
+  EXPECT_EQ(box.ToString(), bounds.ToString());
+}
+
+TEST(TransformOperationTest, BlendedBoundsForRotationProblematicAxes) {
+  // Zeros in the components of the axis of rotation turned out to be tricky to
+  // deal with in practice. This function tests some potentially problematic
+  // axes to ensure sane behavior.
+
+  // Some common values used in the expected boxes.
+  float dim1 = 0.292893f;
+  float dim2 = sqrt(2.f);
+  float dim3 = 2.f * dim2;
+
+  struct {
+    float x;
+    float y;
+    float z;
+    gfx::BoxF expected;
+  } tests[] = {{0.f, 0.f, 0.f, gfx::BoxF(1.f, 1.f, 1.f, 0.f, 0.f, 0.f)},
+               {1.f, 0.f, 0.f, gfx::BoxF(1.f, -dim2, -dim2, 0.f, dim3, dim3)},
+               {0.f, 1.f, 0.f, gfx::BoxF(-dim2, 1.f, -dim2, dim3, 0.f, dim3)},
+               {0.f, 0.f, 1.f, gfx::BoxF(-dim2, -dim2, 1.f, dim3, dim3, 0.f)},
+               {1.f, 1.f, 0.f, gfx::BoxF(dim1, dim1, -1.f, dim2, dim2, 2.f)},
+               {0.f, 1.f, 1.f, gfx::BoxF(-1.f, dim1, dim1, 2.f, dim2, dim2)},
+               {1.f, 0.f, 1.f, gfx::BoxF(dim1, -1.f, dim1, dim2, 2.f, dim2)}};
+
+  for (const auto& test : tests) {
+    float x = test.x;
+    float y = test.y;
+    float z = test.z;
+    TransformOperations operations_from;
+    operations_from.AppendRotate(x, y, z, 0.f);
+    TransformOperations operations_to;
+    operations_to.AppendRotate(x, y, z, 360.f);
+    gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
+    gfx::BoxF bounds;
+
+    EXPECT_TRUE(operations_to.BlendedBoundsForBox(box, operations_from, 0.f,
+                                                  1.f, &bounds));
+    EXPECT_EQ(test.expected.ToString(), bounds.ToString());
+  }
+}
+
+static void ExpectBoxesApproximatelyEqual(const gfx::BoxF& lhs,
+                                          const gfx::BoxF& rhs,
+                                          float tolerance) {
+  EXPECT_NEAR(lhs.x(), rhs.x(), tolerance);
+  EXPECT_NEAR(lhs.y(), rhs.y(), tolerance);
+  EXPECT_NEAR(lhs.z(), rhs.z(), tolerance);
+  EXPECT_NEAR(lhs.width(), rhs.width(), tolerance);
+  EXPECT_NEAR(lhs.height(), rhs.height(), tolerance);
+  EXPECT_NEAR(lhs.depth(), rhs.depth(), tolerance);
+}
+
+static void EmpiricallyTestBounds(const TransformOperations& from,
+                                  const TransformOperations& to,
+                                  SkScalar min_progress,
+                                  SkScalar max_progress,
+                                  bool test_containment_only) {
+  gfx::BoxF box(200.f, 500.f, 100.f, 100.f, 300.f, 200.f);
+  gfx::BoxF bounds;
+  EXPECT_TRUE(
+      to.BlendedBoundsForBox(box, from, min_progress, max_progress, &bounds));
+
+  bool first_time = true;
+  gfx::BoxF empirical_bounds;
+  static const size_t kNumSteps = 10;
+  for (size_t step = 0; step < kNumSteps; ++step) {
+    float t = step / (kNumSteps - 1.f);
+    t = gfx::Tween::FloatValueBetween(t, min_progress, max_progress);
+    gfx::Transform partial_transform = to.Blend(from, t).Apply();
+    gfx::BoxF transformed = box;
+    partial_transform.TransformBox(&transformed);
+
+    if (first_time) {
+      empirical_bounds = transformed;
+      first_time = false;
+    } else {
+      empirical_bounds.Union(transformed);
+    }
+  }
+
+  if (test_containment_only) {
+    gfx::BoxF unified_bounds = bounds;
+    unified_bounds.Union(empirical_bounds);
+    // Convert to the screen space rects these boxes represent.
+    gfx::Rect bounds_rect = ToEnclosingRect(
+        gfx::RectF(bounds.x(), bounds.y(), bounds.width(), bounds.height()));
+    gfx::Rect unified_bounds_rect = ToEnclosingRect(
+        gfx::RectF(unified_bounds.x(), unified_bounds.y(),
+                   unified_bounds.width(), unified_bounds.height()));
+    EXPECT_EQ(bounds_rect.ToString(), unified_bounds_rect.ToString());
+  } else {
+    // Our empirical estimate will be a little rough since we're only doing
+    // 100 samples.
+    static const float kTolerance = 1e-2f;
+    ExpectBoxesApproximatelyEqual(empirical_bounds, bounds, kTolerance);
+  }
+}
+
+static void EmpiricallyTestBoundsEquality(const TransformOperations& from,
+                                          const TransformOperations& to,
+                                          SkScalar min_progress,
+                                          SkScalar max_progress) {
+  EmpiricallyTestBounds(from, to, min_progress, max_progress, false);
+}
+
+static void EmpiricallyTestBoundsContainment(const TransformOperations& from,
+                                             const TransformOperations& to,
+                                             SkScalar min_progress,
+                                             SkScalar max_progress) {
+  EmpiricallyTestBounds(from, to, min_progress, max_progress, true);
+}
+
+TEST(TransformOperationTest, BlendedBoundsForRotationEmpiricalTests) {
+  // Sets up various axis angle combinations, computes the bounding box and
+  // empirically tests that the transformed bounds are indeed contained by the
+  // computed bounding box.
+
+  struct {
+    float x;
+    float y;
+    float z;
+  } axes[] = {{1.f, 1.f, 1.f},   {-1.f, -1.f, -1.f}, {-1.f, 2.f, 3.f},
+              {1.f, -2.f, 3.f},  {1.f, 2.f, -3.f},   {0.f, 0.f, 0.f},
+              {1.f, 0.f, 0.f},   {0.f, 1.f, 0.f},    {0.f, 0.f, 1.f},
+              {1.f, 1.f, 0.f},   {0.f, 1.f, 1.f},    {1.f, 0.f, 1.f},
+              {-1.f, 0.f, 0.f},  {0.f, -1.f, 0.f},   {0.f, 0.f, -1.f},
+              {-1.f, -1.f, 0.f}, {0.f, -1.f, -1.f},  {-1.f, 0.f, -1.f}};
+
+  struct {
+    float theta_from;
+    float theta_to;
+  } angles[] = {{5.f, 10.f},     {10.f, 5.f},     {0.f, 360.f},  {20.f, 180.f},
+                {-20.f, -180.f}, {180.f, -220.f}, {220.f, 320.f}};
+
+  // We can go beyond the range [0, 1] (the bezier might slide out of this range
+  // at either end), but since the first and last knots are at (0, 0) and (1, 1)
+  // we will never go within it, so these tests are sufficient.
+  struct {
+    float min_progress;
+    float max_progress;
+  } progresses[] = {
+      {0.f, 1.f},
+      {-.25f, 1.25f},
+  };
+
+  for (const auto& axis : axes) {
+    for (const auto& angle : angles) {
+      for (const auto& progress : progresses) {
+        float x = axis.x;
+        float y = axis.y;
+        float z = axis.z;
+        TransformOperations operations_from;
+        operations_from.AppendRotate(x, y, z, angle.theta_from);
+        TransformOperations operations_to;
+        operations_to.AppendRotate(x, y, z, angle.theta_to);
+        EmpiricallyTestBoundsContainment(operations_from, operations_to,
+                                         progress.min_progress,
+                                         progress.max_progress);
+      }
+    }
+  }
+}
+
+TEST(TransformOperationTest, PerspectiveMatrixAndTransformBlendingEquivalency) {
+  TransformOperations from_operations;
+  from_operations.AppendPerspective(200);
+
+  TransformOperations to_operations;
+  to_operations.AppendPerspective(1000);
+
+  gfx::Transform from_transform;
+  from_transform.ApplyPerspectiveDepth(200);
+
+  gfx::Transform to_transform;
+  to_transform.ApplyPerspectiveDepth(1000);
+
+  static const int steps = 20;
+  for (int i = 0; i < steps; ++i) {
+    double progress = static_cast<double>(i) / (steps - 1);
+
+    gfx::Transform blended_matrix = to_transform;
+    EXPECT_TRUE(blended_matrix.Blend(from_transform, progress));
+
+    gfx::Transform blended_transform =
+        to_operations.Blend(from_operations, progress).Apply();
+
+    ExpectTransformationMatrixEq(blended_matrix, blended_transform);
+  }
+}
+
+TEST(TransformOperationTest, BlendedBoundsForPerspective) {
+  struct {
+    float from_depth;
+    float to_depth;
+  } perspective_depths[] = {
+      {600.f, 400.f},
+      {800.f, 1000.f},
+      {800.f, std::numeric_limits<float>::infinity()},
+  };
+
+  struct {
+    float min_progress;
+    float max_progress;
+  } progresses[] = {
+      {0.f, 1.f},
+      {-0.1f, 1.1f},
+  };
+
+  for (const auto& perspective_depth : perspective_depths) {
+    for (const auto& progress : progresses) {
+      TransformOperations operations_from;
+      operations_from.AppendPerspective(perspective_depth.from_depth);
+      TransformOperations operations_to;
+      operations_to.AppendPerspective(perspective_depth.to_depth);
+      EmpiricallyTestBoundsEquality(operations_from, operations_to,
+                                    progress.min_progress,
+                                    progress.max_progress);
+    }
+  }
+}
+
+TEST(TransformOperationTest, BlendedBoundsForSkew) {
+  struct {
+    float from_x;
+    float from_y;
+    float to_x;
+    float to_y;
+  } skews[] = {
+      {1.f, 0.5f, 0.5f, 1.f},
+      {2.f, 1.f, 0.5f, 0.5f},
+  };
+
+  struct {
+    float min_progress;
+    float max_progress;
+  } progresses[] = {
+      {0.f, 1.f},
+      {-0.1f, 1.1f},
+  };
+
+  for (const auto& skew : skews) {
+    for (const auto& progress : progresses) {
+      TransformOperations operations_from;
+      operations_from.AppendSkew(skew.from_x, skew.from_y);
+      TransformOperations operations_to;
+      operations_to.AppendSkew(skew.to_x, skew.to_y);
+      EmpiricallyTestBoundsEquality(operations_from, operations_to,
+                                    progress.min_progress,
+                                    progress.max_progress);
+    }
+  }
+}
+
+TEST(TransformOperationTest, NonCommutativeRotations) {
+  TransformOperations operations_from;
+  operations_from.AppendRotate(1.0, 0.0, 0.0, 0.0);
+  operations_from.AppendRotate(0.0, 1.0, 0.0, 0.0);
+  TransformOperations operations_to;
+  operations_to.AppendRotate(1.0, 0.0, 0.0, 45.0);
+  operations_to.AppendRotate(0.0, 1.0, 0.0, 135.0);
+
+  gfx::BoxF box(0, 0, 0, 1, 1, 1);
+  gfx::BoxF bounds;
+
+  SkScalar min_progress = 0.0f;
+  SkScalar max_progress = 1.0f;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+  gfx::Transform blended_transform =
+      operations_to.Blend(operations_from, max_progress).Apply();
+  gfx::Point3F blended_point(0.9f, 0.9f, 0.0f);
+  blended_transform.TransformPoint(&blended_point);
+  gfx::BoxF expanded_bounds = bounds;
+  expanded_bounds.ExpandTo(blended_point);
+  EXPECT_EQ(bounds.ToString(), expanded_bounds.ToString());
+}
+
+TEST(TransformOperationTest, BlendedBoundsForSequence) {
+  TransformOperations operations_from;
+  operations_from.AppendTranslate(1.0, -5.0, 1.0);
+  operations_from.AppendScale(-1.0, 2.0, 3.0);
+  operations_from.AppendTranslate(2.0, 4.0, -1.0);
+  TransformOperations operations_to;
+  operations_to.AppendTranslate(13.0, -1.0, 5.0);
+  operations_to.AppendScale(-3.0, -2.0, 5.0);
+  operations_to.AppendTranslate(6.0, -2.0, 3.0);
+
+  gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
+  gfx::BoxF bounds;
+
+  SkScalar min_progress = -0.5f;
+  SkScalar max_progress = 1.5f;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(-57.f, -59.f, -1.f, 76.f, 112.f, 80.f).ToString(),
+            bounds.ToString());
+
+  min_progress = 0.f;
+  max_progress = 1.f;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(
+      box, operations_from, min_progress, max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(-32.f, -25.f, 7.f, 42.f, 44.f, 48.f).ToString(),
+            bounds.ToString());
+
+  TransformOperations identity;
+  EXPECT_TRUE(operations_to.BlendedBoundsForBox(box, identity, min_progress,
+                                                max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(-33.f, -13.f, 3.f, 57.f, 19.f, 52.f).ToString(),
+            bounds.ToString());
+
+  EXPECT_TRUE(identity.BlendedBoundsForBox(box, operations_from, min_progress,
+                                           max_progress, &bounds));
+  EXPECT_EQ(gfx::BoxF(-7.f, -3.f, 2.f, 15.f, 23.f, 20.f).ToString(),
+            bounds.ToString());
+}
+
+TEST(TransformOperationTest, IsTranslationWithSingleOperation) {
+  TransformOperations empty_operations;
+  EXPECT_TRUE(empty_operations.IsTranslation());
+
+  TransformOperations identity;
+  identity.AppendIdentity();
+  EXPECT_TRUE(identity.IsTranslation());
+
+  TransformOperations translate;
+  translate.AppendTranslate(1.f, 2.f, 3.f);
+  EXPECT_TRUE(translate.IsTranslation());
+
+  TransformOperations rotate;
+  rotate.AppendRotate(1.f, 2.f, 3.f, 4.f);
+  EXPECT_FALSE(rotate.IsTranslation());
+
+  TransformOperations scale;
+  scale.AppendScale(1.f, 2.f, 3.f);
+  EXPECT_FALSE(scale.IsTranslation());
+
+  TransformOperations skew;
+  skew.AppendSkew(1.f, 2.f);
+  EXPECT_FALSE(skew.IsTranslation());
+
+  TransformOperations perspective;
+  perspective.AppendPerspective(1.f);
+  EXPECT_FALSE(perspective.IsTranslation());
+
+  TransformOperations identity_matrix;
+  identity_matrix.AppendMatrix(gfx::Transform());
+  EXPECT_TRUE(identity_matrix.IsTranslation());
+
+  TransformOperations translation_matrix;
+  gfx::Transform translation_transform;
+  translation_transform.Translate3d(1.f, 2.f, 3.f);
+  translation_matrix.AppendMatrix(translation_transform);
+  EXPECT_TRUE(translation_matrix.IsTranslation());
+
+  TransformOperations scaling_matrix;
+  gfx::Transform scaling_transform;
+  scaling_transform.Scale(2.f, 2.f);
+  scaling_matrix.AppendMatrix(scaling_transform);
+  EXPECT_FALSE(scaling_matrix.IsTranslation());
+}
+
+TEST(TransformOperationTest, IsTranslationWithMultipleOperations) {
+  TransformOperations operations1;
+  operations1.AppendSkew(1.f, 2.f);
+  operations1.AppendTranslate(1.f, 2.f, 3.f);
+  operations1.AppendIdentity();
+  EXPECT_FALSE(operations1.IsTranslation());
+
+  TransformOperations operations2;
+  operations2.AppendIdentity();
+  operations2.AppendTranslate(3.f, 2.f, 1.f);
+  gfx::Transform translation_transform;
+  translation_transform.Translate3d(1.f, 2.f, 3.f);
+  operations2.AppendMatrix(translation_transform);
+  EXPECT_TRUE(operations2.IsTranslation());
+}
+
+TEST(TransformOperationTest, ScaleComponent) {
+  SkScalar scale;
+
+  // Scale.
+  TransformOperations operations1;
+  operations1.AppendScale(-3.f, 2.f, 5.f);
+  EXPECT_TRUE(operations1.ScaleComponent(&scale));
+  EXPECT_EQ(5.f, scale);
+
+  // Translate.
+  TransformOperations operations2;
+  operations2.AppendTranslate(1.f, 2.f, 3.f);
+  EXPECT_TRUE(operations2.ScaleComponent(&scale));
+  EXPECT_EQ(1.f, scale);
+
+  // Rotate.
+  TransformOperations operations3;
+  operations3.AppendRotate(1.f, 2.f, 3.f, 4.f);
+  EXPECT_TRUE(operations3.ScaleComponent(&scale));
+  EXPECT_EQ(1.f, scale);
+
+  // Matrix that's only a translation.
+  TransformOperations operations4;
+  gfx::Transform translation_transform;
+  translation_transform.Translate3d(1.f, 2.f, 3.f);
+  operations4.AppendMatrix(translation_transform);
+  EXPECT_TRUE(operations4.ScaleComponent(&scale));
+  EXPECT_EQ(1.f, scale);
+
+  // Matrix that includes scale.
+  TransformOperations operations5;
+  gfx::Transform matrix;
+  matrix.RotateAboutZAxis(30.0);
+  matrix.Scale(-7.f, 6.f);
+  matrix.Translate3d(gfx::Vector3dF(3.f, 7.f, 1.f));
+  operations5.AppendMatrix(matrix);
+  EXPECT_TRUE(operations5.ScaleComponent(&scale));
+  EXPECT_EQ(7.f, scale);
+
+  // Matrix with perspective.
+  TransformOperations operations6;
+  matrix.ApplyPerspectiveDepth(2000.f);
+  operations6.AppendMatrix(matrix);
+  EXPECT_FALSE(operations6.ScaleComponent(&scale));
+
+  // Skew.
+  TransformOperations operations7;
+  operations7.AppendSkew(30.f, 60.f);
+  EXPECT_TRUE(operations7.ScaleComponent(&scale));
+  EXPECT_EQ(2.f, scale);
+
+  // Perspective.
+  TransformOperations operations8;
+  operations8.AppendPerspective(500.f);
+  EXPECT_FALSE(operations8.ScaleComponent(&scale));
+
+  // Translate + Scale.
+  TransformOperations operations9;
+  operations9.AppendTranslate(1.f, 2.f, 3.f);
+  operations9.AppendScale(2.f, 5.f, 4.f);
+  EXPECT_TRUE(operations9.ScaleComponent(&scale));
+  EXPECT_EQ(5.f, scale);
+
+  // Translate + Scale + Matrix with translate.
+  operations9.AppendMatrix(translation_transform);
+  EXPECT_TRUE(operations9.ScaleComponent(&scale));
+  EXPECT_EQ(5.f, scale);
+
+  // Scale + translate.
+  TransformOperations operations10;
+  operations10.AppendScale(2.f, 3.f, 2.f);
+  operations10.AppendTranslate(1.f, 2.f, 3.f);
+  EXPECT_TRUE(operations10.ScaleComponent(&scale));
+  EXPECT_EQ(3.f, scale);
+
+  // Two Scales.
+  TransformOperations operations11;
+  operations11.AppendScale(2.f, 3.f, 2.f);
+  operations11.AppendScale(-3.f, -2.f, -3.f);
+  EXPECT_TRUE(operations11.ScaleComponent(&scale));
+  EXPECT_EQ(9.f, scale);
+
+  // Scale + Matrix.
+  TransformOperations operations12;
+  operations12.AppendScale(2.f, 2.f, 2.f);
+  gfx::Transform scaling_transform;
+  scaling_transform.Scale(2.f, 2.f);
+  operations12.AppendMatrix(scaling_transform);
+  EXPECT_TRUE(operations12.ScaleComponent(&scale));
+  EXPECT_EQ(4.f, scale);
+
+  // Scale + Rotate.
+  TransformOperations operations13;
+  operations13.AppendScale(2.f, 2.f, 2.f);
+  operations13.AppendRotate(1.f, 2.f, 3.f, 4.f);
+  EXPECT_TRUE(operations13.ScaleComponent(&scale));
+  EXPECT_EQ(2.f, scale);
+
+  // Scale + Skew.
+  TransformOperations operations14;
+  operations14.AppendScale(2.f, 2.f, 2.f);
+  operations14.AppendSkew(60.f, 45.f);
+  EXPECT_TRUE(operations14.ScaleComponent(&scale));
+  EXPECT_EQ(4.f, scale);
+
+  // Scale + Perspective.
+  TransformOperations operations15;
+  operations15.AppendScale(2.f, 2.f, 2.f);
+  operations15.AppendPerspective(1.f);
+  EXPECT_FALSE(operations15.ScaleComponent(&scale));
+
+  // Matrix with skew.
+  TransformOperations operations16;
+  gfx::Transform skew_transform;
+  skew_transform.Skew(50.f, 60.f);
+  operations16.AppendMatrix(skew_transform);
+  EXPECT_TRUE(operations16.ScaleComponent(&scale));
+  EXPECT_EQ(2.f, scale);
+}
+
+TEST(TransformOperationsTest, ApproximateEquality) {
+  float noise = 1e-7f;
+  float tolerance = 1e-5f;
+  TransformOperations lhs;
+  TransformOperations rhs;
+
+  // Empty lists of operations are trivially equal.
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  rhs.AppendIdentity();
+  rhs.AppendTranslate(0, 0, 0);
+  rhs.AppendRotate(1, 0, 0, 0);
+  rhs.AppendScale(1, 1, 1);
+  rhs.AppendSkew(0, 0);
+  rhs.AppendMatrix(gfx::Transform());
+
+  // Even though both lists operations are effectively the identity matrix, rhs
+  // has a different number of operations and is therefore different.
+  EXPECT_FALSE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  rhs.AppendPerspective(800);
+
+  // Assignment should produce equal lists of operations.
+  lhs = rhs;
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  // Cannot affect identity operations.
+  lhs.at(0).translate.x = 1;
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  lhs.at(1).translate.x += noise;
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+  lhs.at(1).translate.x += 1;
+  EXPECT_FALSE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  lhs = rhs;
+  lhs.at(2).rotate.angle += noise;
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+  lhs.at(2).rotate.angle = 1;
+  EXPECT_FALSE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  lhs = rhs;
+  lhs.at(3).scale.x += noise;
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+  lhs.at(3).scale.x += 1;
+  EXPECT_FALSE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  lhs = rhs;
+  lhs.at(4).skew.x += noise;
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+  lhs.at(4).skew.x = 2;
+  EXPECT_FALSE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  lhs = rhs;
+  lhs.at(5).matrix.Translate3d(noise, 0, 0);
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+  lhs.at(5).matrix.Translate3d(1, 1, 1);
+  EXPECT_FALSE(lhs.ApproximatelyEqual(rhs, tolerance));
+
+  lhs = rhs;
+  lhs.at(6).perspective_depth += noise;
+  EXPECT_TRUE(lhs.ApproximatelyEqual(rhs, tolerance));
+  lhs.at(6).perspective_depth = 801;
+  EXPECT_FALSE(lhs.ApproximatelyEqual(rhs, tolerance));
+}
+
+}  // namespace
+
+// This test is intentionally outside the anonymous namespace for visibility as
+// it needs to be friend of TransformOperations.
+TEST(TransformOperationsTest, TestDecompositionCache) {
+  TransformOperations transforms;
+  EXPECT_EQ(0UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(0));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+
+  // Reset cache when appending a scale transform.
+  transforms.AppendScale(2.f, 2.f, 2.f);
+  EXPECT_EQ(0UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(1));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(1));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(0));
+  EXPECT_EQ(2UL, transforms.decomposed_transforms_.size());
+
+  // Reset cache when appending a rotation transform.
+  transforms.AppendRotate(1, 0, 0, 45);
+  EXPECT_EQ(0UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(0));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+
+  // Reset cache when appending a translation transform.
+  transforms.AppendTranslate(1, 1, 1);
+  EXPECT_EQ(0UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(0));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+
+  // Reset cache when appending a skew transform.
+  transforms.AppendSkew(1, 0);
+  EXPECT_EQ(0UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(0));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+
+  // Reset cache when appending a perspective transform.
+  transforms.AppendPerspective(800);
+  EXPECT_EQ(0UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(0));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+
+  // Reset cache when appending a matrix transform.
+  transforms.AppendMatrix(gfx::Transform());
+  EXPECT_EQ(0UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(0));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+
+  // Reset cache when appending a generic transform operation.
+  transforms.Append(TransformOperation());
+  EXPECT_EQ(0UL, transforms.decomposed_transforms_.size());
+  EXPECT_TRUE(transforms.ComputeDecomposedTransform(0));
+  EXPECT_EQ(1UL, transforms.decomposed_transforms_.size());
+}
+
+TEST(TransformOperationTest, BlendSkewMismatch) {
+  TransformOperations from_ops, to_ops, expected_ops;
+  from_ops.AppendSkewX(0);
+  from_ops.AppendRotate(0, 0, 1, 0);
+  to_ops.AppendSkewY(0);
+  to_ops.AppendRotate(0, 0, 1, 360);
+
+  // Skew types do not match so use matrix interpolation
+  expected_ops.AppendMatrix(gfx::Transform());
+
+  TransformOperations blended_ops = to_ops.Blend(from_ops, 0.5);
+  ASSERT_EQ(blended_ops.size(), 1u);
+  ExpectTransformOperationEqual(blended_ops.at(0), expected_ops.at(0));
+}
+
+TEST(TransformOperationTest, BlendSkewMatch) {
+  TransformOperations from_ops, to_ops, expected_ops;
+  from_ops.AppendSkew(30, 0);
+  from_ops.AppendRotate(0, 0, 1, 0);
+  to_ops.AppendSkew(0, 30);
+  to_ops.AppendRotate(0, 0, 1, 360);
+
+  // Skew types match so interpolate as a function.
+  expected_ops.AppendSkew(15, 15);
+  expected_ops.AppendRotate(0, 0, 1, 180);
+
+  TransformOperations blended_ops = to_ops.Blend(from_ops, 0.5);
+  ASSERT_EQ(blended_ops.size(), 2u);
+  ExpectTransformOperationEqual(blended_ops.at(0), expected_ops.at(0));
+  ExpectTransformOperationEqual(blended_ops.at(1), expected_ops.at(1));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/transform_unittest.cc b/ui/gfx/geometry/transform_unittest.cc
new file mode 100644
index 0000000..127c203
--- /dev/null
+++ b/ui/gfx/geometry/transform_unittest.cc
@@ -0,0 +1,2729 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/geometry/transform.h"
+
+#include <stddef.h>
+
+#include <limits>
+#include <ostream>
+
+#include "base/cxx17_backports.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/angle_conversions.h"
+#include "ui/gfx/geometry/box_f.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/quad_f.h"
+#include "ui/gfx/geometry/rrect_f.h"
+#include "ui/gfx/geometry/transform_util.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+namespace {
+
+#define EXPECT_ROW1_EQ(a, b, c, d, transform)           \
+  EXPECT_FLOAT_EQ((a), (transform).matrix().get(0, 0)); \
+  EXPECT_FLOAT_EQ((b), (transform).matrix().get(0, 1)); \
+  EXPECT_FLOAT_EQ((c), (transform).matrix().get(0, 2)); \
+  EXPECT_FLOAT_EQ((d), (transform).matrix().get(0, 3));
+
+#define EXPECT_ROW2_EQ(a, b, c, d, transform)           \
+  EXPECT_FLOAT_EQ((a), (transform).matrix().get(1, 0)); \
+  EXPECT_FLOAT_EQ((b), (transform).matrix().get(1, 1)); \
+  EXPECT_FLOAT_EQ((c), (transform).matrix().get(1, 2)); \
+  EXPECT_FLOAT_EQ((d), (transform).matrix().get(1, 3));
+
+#define EXPECT_ROW3_EQ(a, b, c, d, transform)           \
+  EXPECT_FLOAT_EQ((a), (transform).matrix().get(2, 0)); \
+  EXPECT_FLOAT_EQ((b), (transform).matrix().get(2, 1)); \
+  EXPECT_FLOAT_EQ((c), (transform).matrix().get(2, 2)); \
+  EXPECT_FLOAT_EQ((d), (transform).matrix().get(2, 3));
+
+#define EXPECT_ROW4_EQ(a, b, c, d, transform)           \
+  EXPECT_FLOAT_EQ((a), (transform).matrix().get(3, 0)); \
+  EXPECT_FLOAT_EQ((b), (transform).matrix().get(3, 1)); \
+  EXPECT_FLOAT_EQ((c), (transform).matrix().get(3, 2)); \
+  EXPECT_FLOAT_EQ((d), (transform).matrix().get(3, 3));
+
+// Checking float values for equality close to zero is not robust using
+// EXPECT_FLOAT_EQ (see gtest documentation). So, to verify rotation matrices,
+// we must use a looser absolute error threshold in some places.
+#define EXPECT_ROW1_NEAR(a, b, c, d, transform, errorThreshold)       \
+  EXPECT_NEAR((a), (transform).matrix().get(0, 0), (errorThreshold)); \
+  EXPECT_NEAR((b), (transform).matrix().get(0, 1), (errorThreshold)); \
+  EXPECT_NEAR((c), (transform).matrix().get(0, 2), (errorThreshold)); \
+  EXPECT_NEAR((d), (transform).matrix().get(0, 3), (errorThreshold));
+
+#define EXPECT_ROW2_NEAR(a, b, c, d, transform, errorThreshold)       \
+  EXPECT_NEAR((a), (transform).matrix().get(1, 0), (errorThreshold)); \
+  EXPECT_NEAR((b), (transform).matrix().get(1, 1), (errorThreshold)); \
+  EXPECT_NEAR((c), (transform).matrix().get(1, 2), (errorThreshold)); \
+  EXPECT_NEAR((d), (transform).matrix().get(1, 3), (errorThreshold));
+
+#define EXPECT_ROW3_NEAR(a, b, c, d, transform, errorThreshold)       \
+  EXPECT_NEAR((a), (transform).matrix().get(2, 0), (errorThreshold)); \
+  EXPECT_NEAR((b), (transform).matrix().get(2, 1), (errorThreshold)); \
+  EXPECT_NEAR((c), (transform).matrix().get(2, 2), (errorThreshold)); \
+  EXPECT_NEAR((d), (transform).matrix().get(2, 3), (errorThreshold));
+
+bool PointsAreNearlyEqual(const Point3F& lhs, const Point3F& rhs) {
+  float epsilon = 0.0001f;
+  return lhs.SquaredDistanceTo(rhs) < epsilon;
+}
+
+bool MatricesAreNearlyEqual(const Transform& lhs, const Transform& rhs) {
+  float epsilon = 0.0001f;
+  for (int row = 0; row < 4; ++row) {
+    for (int col = 0; col < 4; ++col) {
+      if (std::abs(lhs.matrix().get(row, col) - rhs.matrix().get(row, col)) >
+          epsilon)
+        return false;
+    }
+  }
+  return true;
+}
+
+void InitializeTestMatrix(Transform* transform) {
+  skia::Matrix44& matrix = transform->matrix();
+  matrix.set(0, 0, 10.f);
+  matrix.set(1, 0, 11.f);
+  matrix.set(2, 0, 12.f);
+  matrix.set(3, 0, 13.f);
+  matrix.set(0, 1, 14.f);
+  matrix.set(1, 1, 15.f);
+  matrix.set(2, 1, 16.f);
+  matrix.set(3, 1, 17.f);
+  matrix.set(0, 2, 18.f);
+  matrix.set(1, 2, 19.f);
+  matrix.set(2, 2, 20.f);
+  matrix.set(3, 2, 21.f);
+  matrix.set(0, 3, 22.f);
+  matrix.set(1, 3, 23.f);
+  matrix.set(2, 3, 24.f);
+  matrix.set(3, 3, 25.f);
+
+  // Sanity check
+  EXPECT_ROW1_EQ(10.0f, 14.0f, 18.0f, 22.0f, (*transform));
+  EXPECT_ROW2_EQ(11.0f, 15.0f, 19.0f, 23.0f, (*transform));
+  EXPECT_ROW3_EQ(12.0f, 16.0f, 20.0f, 24.0f, (*transform));
+  EXPECT_ROW4_EQ(13.0f, 17.0f, 21.0f, 25.0f, (*transform));
+}
+
+void InitializeTestMatrix2(Transform* transform) {
+  skia::Matrix44& matrix = transform->matrix();
+  matrix.set(0, 0, 30.f);
+  matrix.set(1, 0, 31.f);
+  matrix.set(2, 0, 32.f);
+  matrix.set(3, 0, 33.f);
+  matrix.set(0, 1, 34.f);
+  matrix.set(1, 1, 35.f);
+  matrix.set(2, 1, 36.f);
+  matrix.set(3, 1, 37.f);
+  matrix.set(0, 2, 38.f);
+  matrix.set(1, 2, 39.f);
+  matrix.set(2, 2, 40.f);
+  matrix.set(3, 2, 41.f);
+  matrix.set(0, 3, 42.f);
+  matrix.set(1, 3, 43.f);
+  matrix.set(2, 3, 44.f);
+  matrix.set(3, 3, 45.f);
+
+  // Sanity check
+  EXPECT_ROW1_EQ(30.0f, 34.0f, 38.0f, 42.0f, (*transform));
+  EXPECT_ROW2_EQ(31.0f, 35.0f, 39.0f, 43.0f, (*transform));
+  EXPECT_ROW3_EQ(32.0f, 36.0f, 40.0f, 44.0f, (*transform));
+  EXPECT_ROW4_EQ(33.0f, 37.0f, 41.0f, 45.0f, (*transform));
+}
+
+const SkScalar kApproxZero = std::numeric_limits<float>::epsilon();
+const SkScalar kApproxOne = 1 - kApproxZero;
+
+void InitializeApproxIdentityMatrix(Transform* transform) {
+  skia::Matrix44& matrix = transform->matrix();
+  matrix.set(0, 0, kApproxOne);
+  matrix.set(0, 1, kApproxZero);
+  matrix.set(0, 2, kApproxZero);
+  matrix.set(0, 3, kApproxZero);
+
+  matrix.set(1, 0, kApproxZero);
+  matrix.set(1, 1, kApproxOne);
+  matrix.set(1, 2, kApproxZero);
+  matrix.set(1, 3, kApproxZero);
+
+  matrix.set(2, 0, kApproxZero);
+  matrix.set(2, 1, kApproxZero);
+  matrix.set(2, 2, kApproxOne);
+  matrix.set(2, 3, kApproxZero);
+
+  matrix.set(3, 0, kApproxZero);
+  matrix.set(3, 1, kApproxZero);
+  matrix.set(3, 2, kApproxZero);
+  matrix.set(3, 3, kApproxOne);
+}
+
+#define ERROR_THRESHOLD 1e-7
+#define LOOSE_ERROR_THRESHOLD 1e-7
+
+TEST(XFormTest, Equality) {
+  Transform lhs, rhs, interpolated;
+  rhs.matrix().set3x3(1, 2, 3, 4, 5, 6, 7, 8, 9);
+  interpolated = lhs;
+  for (int i = 0; i <= 100; ++i) {
+    for (int row = 0; row < 4; ++row) {
+      for (int col = 0; col < 4; ++col) {
+        float a = lhs.matrix().get(row, col);
+        float b = rhs.matrix().get(row, col);
+        float t = i / 100.0f;
+        interpolated.matrix().set(row, col, a + (b - a) * t);
+      }
+    }
+    if (i == 100) {
+      EXPECT_TRUE(rhs == interpolated);
+    } else {
+      EXPECT_TRUE(rhs != interpolated);
+    }
+  }
+  lhs = Transform();
+  rhs = Transform();
+  for (int i = 1; i < 100; ++i) {
+    lhs.MakeIdentity();
+    rhs.MakeIdentity();
+    lhs.Translate(i, i);
+    rhs.Translate(-i, -i);
+    EXPECT_TRUE(lhs != rhs);
+    rhs.Translate(2 * i, 2 * i);
+    EXPECT_TRUE(lhs == rhs);
+  }
+}
+
+TEST(XFormTest, ConcatTranslate) {
+  static const struct TestCase {
+    int x1;
+    int y1;
+    float tx;
+    float ty;
+    int x2;
+    int y2;
+  } test_cases[] = {
+      {0, 0, 10.0f, 20.0f, 10, 20},
+      {0, 0, -10.0f, -20.0f, 0, 0},
+      {0, 0, -10.0f, -20.0f, -10, -20},
+      {0, 0, std::numeric_limits<float>::quiet_NaN(),
+       std::numeric_limits<float>::quiet_NaN(), 10, 20},
+  };
+
+  Transform xform;
+  for (const auto& value : test_cases) {
+    Transform translation;
+    translation.Translate(value.tx, value.ty);
+    xform = translation * xform;
+    Point3F p1(value.x1, value.y1, 0);
+    Point3F p2(value.x2, value.y2, 0);
+    xform.TransformPoint(&p1);
+    if (value.tx == value.tx && value.ty == value.ty) {
+      EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
+    }
+  }
+}
+
+TEST(XFormTest, ConcatScale) {
+  static const struct TestCase {
+    int before;
+    float scale;
+    int after;
+  } test_cases[] = {{1, 10.0f, 10},
+                    {1, .1f, 1},
+                    {1, 100.0f, 100},
+                    {1, -1.0f, -100},
+                    {1, std::numeric_limits<float>::quiet_NaN(), 1}};
+
+  Transform xform;
+  for (const auto& value : test_cases) {
+    Transform scale;
+    scale.Scale(value.scale, value.scale);
+    xform = scale * xform;
+    Point3F p1(value.before, value.before, 0);
+    Point3F p2(value.after, value.after, 0);
+    xform.TransformPoint(&p1);
+    if (value.scale == value.scale) {
+      EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
+    }
+  }
+}
+
+TEST(XFormTest, ConcatRotate) {
+  static const struct TestCase {
+    int x1;
+    int y1;
+    float degrees;
+    int x2;
+    int y2;
+  } test_cases[] = {{1, 0, 90.0f, 0, 1},
+                    {1, 0, -90.0f, 1, 0},
+                    {1, 0, 90.0f, 0, 1},
+                    {1, 0, 360.0f, 0, 1},
+                    {1, 0, 0.0f, 0, 1},
+                    {1, 0, std::numeric_limits<float>::quiet_NaN(), 1, 0}};
+
+  Transform xform;
+  for (const auto& value : test_cases) {
+    Transform rotation;
+    rotation.Rotate(value.degrees);
+    xform = rotation * xform;
+    Point3F p1(value.x1, value.y1, 0);
+    Point3F p2(value.x2, value.y2, 0);
+    xform.TransformPoint(&p1);
+    if (value.degrees == value.degrees) {
+      EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
+    }
+  }
+}
+
+TEST(XFormTest, SetTranslate) {
+  static const struct TestCase {
+    int x1;
+    int y1;
+    float tx;
+    float ty;
+    int x2;
+    int y2;
+  } test_cases[] = {{0, 0, 10.0f, 20.0f, 10, 20},
+                    {10, 20, 10.0f, 20.0f, 20, 40},
+                    {10, 20, 0.0f, 0.0f, 10, 20},
+                    {0, 0, std::numeric_limits<float>::quiet_NaN(),
+                     std::numeric_limits<float>::quiet_NaN(), 0, 0}};
+
+  for (const auto& value : test_cases) {
+    for (int k = 0; k < 3; ++k) {
+      Point3F p0, p1, p2;
+      Transform xform;
+      switch (k) {
+        case 0:
+          p1.SetPoint(value.x1, 0, 0);
+          p2.SetPoint(value.x2, 0, 0);
+          xform.Translate(value.tx, 0.0);
+          break;
+        case 1:
+          p1.SetPoint(0, value.y1, 0);
+          p2.SetPoint(0, value.y2, 0);
+          xform.Translate(0.0, value.ty);
+          break;
+        case 2:
+          p1.SetPoint(value.x1, value.y1, 0);
+          p2.SetPoint(value.x2, value.y2, 0);
+          xform.Translate(value.tx, value.ty);
+          break;
+      }
+      p0 = p1;
+      xform.TransformPoint(&p1);
+      if (value.tx == value.tx && value.ty == value.ty) {
+        EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
+        xform.TransformPointReverse(&p1);
+        EXPECT_TRUE(PointsAreNearlyEqual(p1, p0));
+      }
+    }
+  }
+}
+
+TEST(XFormTest, SetScale) {
+  static const struct TestCase {
+    int before;
+    float s;
+    int after;
+  } test_cases[] = {
+      {1, 10.0f, 10},
+      {1, 1.0f, 1},
+      {1, 0.0f, 0},
+      {0, 10.0f, 0},
+      {1, std::numeric_limits<float>::quiet_NaN(), 0},
+  };
+
+  for (const auto& value : test_cases) {
+    for (int k = 0; k < 3; ++k) {
+      Point3F p0, p1, p2;
+      Transform xform;
+      switch (k) {
+        case 0:
+          p1.SetPoint(value.before, 0, 0);
+          p2.SetPoint(value.after, 0, 0);
+          xform.Scale(value.s, 1.0);
+          break;
+        case 1:
+          p1.SetPoint(0, value.before, 0);
+          p2.SetPoint(0, value.after, 0);
+          xform.Scale(1.0, value.s);
+          break;
+        case 2:
+          p1.SetPoint(value.before, value.before, 0);
+          p2.SetPoint(value.after, value.after, 0);
+          xform.Scale(value.s, value.s);
+          break;
+      }
+      p0 = p1;
+      xform.TransformPoint(&p1);
+      if (value.s == value.s) {
+        EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
+        if (value.s != 0.0f) {
+          xform.TransformPointReverse(&p1);
+          EXPECT_TRUE(PointsAreNearlyEqual(p1, p0));
+        }
+      }
+    }
+  }
+}
+
+TEST(XFormTest, SetRotate) {
+  static const struct SetRotateCase {
+    int x;
+    int y;
+    float degree;
+    int xprime;
+    int yprime;
+  } set_rotate_cases[] = {{100, 0, 90.0f, 0, 100},
+                          {0, 0, 90.0f, 0, 0},
+                          {0, 100, 90.0f, -100, 0},
+                          {0, 1, -90.0f, 1, 0},
+                          {100, 0, 0.0f, 100, 0},
+                          {0, 0, 0.0f, 0, 0},
+                          {0, 0, std::numeric_limits<float>::quiet_NaN(), 0, 0},
+                          {100, 0, 360.0f, 100, 0}};
+
+  for (const auto& value : set_rotate_cases) {
+    Point3F p0;
+    Point3F p1(value.x, value.y, 0);
+    Point3F p2(value.xprime, value.yprime, 0);
+    p0 = p1;
+    Transform xform;
+    xform.Rotate(value.degree);
+    // just want to make sure that we don't crash in the case of NaN.
+    if (value.degree == value.degree) {
+      xform.TransformPoint(&p1);
+      EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
+      xform.TransformPointReverse(&p1);
+      EXPECT_TRUE(PointsAreNearlyEqual(p1, p0));
+    }
+  }
+}
+
+// 2D tests
+TEST(XFormTest, ConcatTranslate2D) {
+  static const struct TestCase {
+    int x1;
+    int y1;
+    float tx;
+    float ty;
+    int x2;
+    int y2;
+  } test_cases[] = {
+      {0, 0, 10.0f, 20.0f, 10, 20},
+      {0, 0, -10.0f, -20.0f, 0, 0},
+      {0, 0, -10.0f, -20.0f, -10, -20},
+  };
+
+  Transform xform;
+  for (const auto& value : test_cases) {
+    Transform translation;
+    translation.Translate(value.tx, value.ty);
+    xform = translation * xform;
+    Point p1(value.x1, value.y1);
+    Point p2(value.x2, value.y2);
+    xform.TransformPoint(&p1);
+    if (value.tx == value.tx && value.ty == value.ty) {
+      EXPECT_EQ(p1.x(), p2.x());
+      EXPECT_EQ(p1.y(), p2.y());
+    }
+  }
+}
+
+TEST(XFormTest, ConcatScale2D) {
+  static const struct TestCase {
+    int before;
+    float scale;
+    int after;
+  } test_cases[] = {
+      {1, 10.0f, 10},
+      {1, .1f, 1},
+      {1, 100.0f, 100},
+      {1, -1.0f, -100},
+  };
+
+  Transform xform;
+  for (const auto& value : test_cases) {
+    Transform scale;
+    scale.Scale(value.scale, value.scale);
+    xform = scale * xform;
+    Point p1(value.before, value.before);
+    Point p2(value.after, value.after);
+    xform.TransformPoint(&p1);
+    if (value.scale == value.scale) {
+      EXPECT_EQ(p1.x(), p2.x());
+      EXPECT_EQ(p1.y(), p2.y());
+    }
+  }
+}
+
+TEST(XFormTest, ConcatRotate2D) {
+  static const struct TestCase {
+    int x1;
+    int y1;
+    float degrees;
+    int x2;
+    int y2;
+  } test_cases[] = {
+      {1, 0, 90.0f, 0, 1},  {1, 0, -90.0f, 1, 0}, {1, 0, 90.0f, 0, 1},
+      {1, 0, 360.0f, 0, 1}, {1, 0, 0.0f, 0, 1},
+  };
+
+  Transform xform;
+  for (const auto& value : test_cases) {
+    Transform rotation;
+    rotation.Rotate(value.degrees);
+    xform = rotation * xform;
+    Point p1(value.x1, value.y1);
+    Point p2(value.x2, value.y2);
+    xform.TransformPoint(&p1);
+    if (value.degrees == value.degrees) {
+      EXPECT_EQ(p1.x(), p2.x());
+      EXPECT_EQ(p1.y(), p2.y());
+    }
+  }
+}
+
+TEST(XFormTest, SetTranslate2D) {
+  static const struct TestCase {
+    int x1;
+    int y1;
+    float tx;
+    float ty;
+    int x2;
+    int y2;
+  } test_cases[] = {
+      {0, 0, 10.0f, 20.0f, 10, 20},
+      {10, 20, 10.0f, 20.0f, 20, 40},
+      {10, 20, 0.0f, 0.0f, 10, 20},
+  };
+
+  for (const auto& value : test_cases) {
+    for (int j = -1; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        float epsilon = 0.0001f;
+        Point p0, p1, p2;
+        Transform xform;
+        switch (k) {
+          case 0:
+            p1.SetPoint(value.x1, 0);
+            p2.SetPoint(value.x2, 0);
+            xform.Translate(value.tx + j * epsilon, 0.0);
+            break;
+          case 1:
+            p1.SetPoint(0, value.y1);
+            p2.SetPoint(0, value.y2);
+            xform.Translate(0.0, value.ty + j * epsilon);
+            break;
+          case 2:
+            p1.SetPoint(value.x1, value.y1);
+            p2.SetPoint(value.x2, value.y2);
+            xform.Translate(value.tx + j * epsilon, value.ty + j * epsilon);
+            break;
+        }
+        p0 = p1;
+        xform.TransformPoint(&p1);
+        if (value.tx == value.tx && value.ty == value.ty) {
+          EXPECT_EQ(p1.x(), p2.x());
+          EXPECT_EQ(p1.y(), p2.y());
+          xform.TransformPointReverse(&p1);
+          EXPECT_EQ(p1.x(), p0.x());
+          EXPECT_EQ(p1.y(), p0.y());
+        }
+      }
+    }
+  }
+}
+
+TEST(XFormTest, SetScale2D) {
+  static const struct TestCase {
+    int before;
+    float s;
+    int after;
+  } test_cases[] = {
+      {1, 10.0f, 10},
+      {1, 1.0f, 1},
+      {1, 0.0f, 0},
+      {0, 10.0f, 0},
+  };
+
+  for (const auto& value : test_cases) {
+    for (int j = -1; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        float epsilon = 0.0001f;
+        Point p0, p1, p2;
+        Transform xform;
+        switch (k) {
+          case 0:
+            p1.SetPoint(value.before, 0);
+            p2.SetPoint(value.after, 0);
+            xform.Scale(value.s + j * epsilon, 1.0);
+            break;
+          case 1:
+            p1.SetPoint(0, value.before);
+            p2.SetPoint(0, value.after);
+            xform.Scale(1.0, value.s + j * epsilon);
+            break;
+          case 2:
+            p1.SetPoint(value.before, value.before);
+            p2.SetPoint(value.after, value.after);
+            xform.Scale(value.s + j * epsilon, value.s + j * epsilon);
+            break;
+        }
+        p0 = p1;
+        xform.TransformPoint(&p1);
+        if (value.s == value.s) {
+          EXPECT_EQ(p1.x(), p2.x());
+          EXPECT_EQ(p1.y(), p2.y());
+          if (value.s != 0.0f) {
+            xform.TransformPointReverse(&p1);
+            EXPECT_EQ(p1.x(), p0.x());
+            EXPECT_EQ(p1.y(), p0.y());
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(XFormTest, SetRotate2D) {
+  static const struct SetRotateCase {
+    int x;
+    int y;
+    float degree;
+    int xprime;
+    int yprime;
+  } set_rotate_cases[] = {{100, 0, 90.0f, 0, 100},
+                          {0, 0, 90.0f, 0, 0},
+                          {0, 100, 90.0f, -100, 0},
+                          {0, 1, -90.0f, 1, 0},
+                          {100, 0, 0.0f, 100, 0},
+                          {0, 0, 0.0f, 0, 0},
+                          {0, 0, std::numeric_limits<float>::quiet_NaN(), 0, 0},
+                          {100, 0, 360.0f, 100, 0}};
+
+  for (const auto& value : set_rotate_cases) {
+    for (int j = 1; j >= -1; --j) {
+      float epsilon = 0.1f;
+      Point pt(value.x, value.y);
+      Transform xform;
+      // should be invariant to small floating point errors.
+      xform.Rotate(value.degree + j * epsilon);
+      // just want to make sure that we don't crash in the case of NaN.
+      if (value.degree == value.degree) {
+        xform.TransformPoint(&pt);
+        EXPECT_EQ(value.xprime, pt.x());
+        EXPECT_EQ(value.yprime, pt.y());
+        xform.TransformPointReverse(&pt);
+        EXPECT_EQ(pt.x(), value.x);
+        EXPECT_EQ(pt.y(), value.y);
+      }
+    }
+  }
+}
+
+TEST(XFormTest, TransformPointWithExtremePerspective) {
+  Point3F point(1.f, 1.f, 1.f);
+  Transform perspective;
+  perspective.ApplyPerspectiveDepth(1.f);
+  Point3F transformed = point;
+  perspective.TransformPoint(&transformed);
+  EXPECT_EQ(point.ToString(), transformed.ToString());
+
+  transformed = point;
+  perspective.MakeIdentity();
+  perspective.ApplyPerspectiveDepth(1.1f);
+  perspective.TransformPoint(&transformed);
+  EXPECT_FLOAT_EQ(11.f, transformed.x());
+  EXPECT_FLOAT_EQ(11.f, transformed.y());
+  EXPECT_FLOAT_EQ(11.f, transformed.z());
+}
+
+TEST(XFormTest, BlendTranslate) {
+  Transform from;
+  for (int i = -5; i < 15; ++i) {
+    Transform to;
+    to.Translate3d(1, 1, 1);
+    double t = i / 9.0;
+    EXPECT_TRUE(to.Blend(from, t));
+    EXPECT_FLOAT_EQ(t, to.matrix().get(0, 3));
+    EXPECT_FLOAT_EQ(t, to.matrix().get(1, 3));
+    EXPECT_FLOAT_EQ(t, to.matrix().get(2, 3));
+  }
+}
+
+TEST(XFormTest, BlendRotate) {
+  Vector3dF axes[] = {Vector3dF(1, 0, 0), Vector3dF(0, 1, 0),
+                      Vector3dF(0, 0, 1), Vector3dF(1, 1, 1)};
+  Transform from;
+  for (const auto& axis : axes) {
+    for (int i = -5; i < 15; ++i) {
+      Transform to;
+      to.RotateAbout(axis, 90);
+      double t = i / 9.0;
+      EXPECT_TRUE(to.Blend(from, t));
+
+      Transform expected;
+      expected.RotateAbout(axis, 90 * t);
+
+      EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
+    }
+  }
+}
+
+TEST(XFormTest, CanBlend180DegreeRotation) {
+  Vector3dF axes[] = {Vector3dF(1, 0, 0), Vector3dF(0, 1, 0),
+                      Vector3dF(0, 0, 1), Vector3dF(1, 1, 1)};
+  Transform from;
+  for (const auto& axis : axes) {
+    for (int i = -5; i < 15; ++i) {
+      Transform to;
+      to.RotateAbout(axis, 180.0);
+      double t = i / 9.0;
+      EXPECT_TRUE(to.Blend(from, t));
+
+      // A 180 degree rotation is exactly opposite on the sphere, therefore
+      // either great circle arc to it is equivalent (and numerical precision
+      // will determine which is closer).  Test both directions.
+      Transform expected1;
+      expected1.RotateAbout(axis, 180.0 * t);
+      Transform expected2;
+      expected2.RotateAbout(axis, -180.0 * t);
+
+      EXPECT_TRUE(MatricesAreNearlyEqual(expected1, to) ||
+                  MatricesAreNearlyEqual(expected2, to))
+          << "axis: " << axis.ToString() << ", i: " << i;
+    }
+  }
+}
+
+TEST(XFormTest, BlendScale) {
+  Transform from;
+  for (int i = -5; i < 15; ++i) {
+    Transform to;
+    to.Scale3d(5, 4, 3);
+    double s1 = i / 9.0;
+    double s2 = 1 - s1;
+    EXPECT_TRUE(to.Blend(from, s1));
+    EXPECT_FLOAT_EQ(5 * s1 + s2, to.matrix().get(0, 0)) << "i: " << i;
+    EXPECT_FLOAT_EQ(4 * s1 + s2, to.matrix().get(1, 1)) << "i: " << i;
+    EXPECT_FLOAT_EQ(3 * s1 + s2, to.matrix().get(2, 2)) << "i: " << i;
+  }
+}
+
+TEST(XFormTest, BlendSkew) {
+  Transform from;
+  for (int i = 0; i < 2; ++i) {
+    Transform to;
+    to.Skew(10, 5);
+    double t = i;
+    Transform expected;
+    expected.Skew(t * 10, t * 5);
+    EXPECT_TRUE(to.Blend(from, t));
+    EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
+  }
+}
+
+TEST(XFormTest, ExtrapolateSkew) {
+  Transform from;
+  for (int i = -1; i < 2; ++i) {
+    Transform to;
+    to.Skew(20, 0);
+    double t = i;
+    Transform expected;
+    expected.Skew(t * 20, t * 0);
+    EXPECT_TRUE(to.Blend(from, t));
+    EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
+  }
+}
+
+TEST(XFormTest, BlendPerspective) {
+  Transform from;
+  from.ApplyPerspectiveDepth(200);
+  for (int i = -1; i < 3; ++i) {
+    Transform to;
+    to.ApplyPerspectiveDepth(800);
+    double t = i;
+    double depth = 1.0 / ((1.0 / 200) * (1.0 - t) + (1.0 / 800) * t);
+    Transform expected;
+    expected.ApplyPerspectiveDepth(depth);
+    EXPECT_TRUE(to.Blend(from, t));
+    EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
+  }
+}
+
+TEST(XFormTest, BlendIdentity) {
+  Transform from;
+  Transform to;
+  EXPECT_TRUE(to.Blend(from, 0.5));
+  EXPECT_EQ(to, from);
+}
+
+TEST(XFormTest, CannotBlendSingularMatrix) {
+  Transform from;
+  Transform to;
+  to.matrix().set(1, 1, 0);
+  EXPECT_FALSE(to.Blend(from, 0.5));
+}
+
+TEST(XFormTest, VerifyBlendForTranslation) {
+  Transform from;
+  from.Translate3d(100.0, 200.0, 100.0);
+
+  Transform to;
+
+  to.Translate3d(200.0, 100.0, 300.0);
+  to.Blend(from, 0.0);
+  EXPECT_EQ(from, to);
+
+  to = Transform();
+  to.Translate3d(200.0, 100.0, 300.0);
+  to.Blend(from, 0.25);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 125.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 175.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 150.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.Translate3d(200.0, 100.0, 300.0);
+  to.Blend(from, 0.5);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 150.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 150.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 200.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.Translate3d(200.0, 100.0, 300.0);
+  to.Blend(from, 1.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 200.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 100.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 300.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+}
+
+TEST(XFormTest, VerifyBlendForScale) {
+  Transform from;
+  from.Scale3d(100.0, 200.0, 100.0);
+
+  Transform to;
+
+  to.Scale3d(200.0, 100.0, 300.0);
+  to.Blend(from, 0.0);
+  EXPECT_EQ(from, to);
+
+  to = Transform();
+  to.Scale3d(200.0, 100.0, 300.0);
+  to.Blend(from, 0.25);
+  EXPECT_ROW1_EQ(125.0f, 0.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 175.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 150.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.Scale3d(200.0, 100.0, 300.0);
+  to.Blend(from, 0.5);
+  EXPECT_ROW1_EQ(150.0f, 0.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 150.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 200.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.Scale3d(200.0, 100.0, 300.0);
+  to.Blend(from, 1.0);
+  EXPECT_ROW1_EQ(200.0f, 0.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 100.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 300.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+}
+
+TEST(XFormTest, VerifyBlendForSkew) {
+  // Along X axis only
+  Transform from;
+  from.Skew(0.0, 0.0);
+
+  Transform to;
+
+  to.Skew(45.0, 0.0);
+  to.Blend(from, 0.0);
+  EXPECT_EQ(from, to);
+
+  to = Transform();
+  to.Skew(45.0, 0.0);
+  to.Blend(from, 0.5);
+  EXPECT_ROW1_EQ(1.0f, 0.5f, 0.0f, 0.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.Skew(45.0, 0.0);
+  to.Blend(from, 0.25);
+  EXPECT_ROW1_EQ(1.0f, 0.25f, 0.0f, 0.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.Skew(45.0, 0.0);
+  to.Blend(from, 1.0);
+  EXPECT_ROW1_EQ(1.0f, 1.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, to);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  // NOTE CAREFULLY: Decomposition of skew and rotation terms of the matrix
+  // is inherently underconstrained, and so it does not always compute the
+  // originally intended skew parameters. The current implementation uses QR
+  // decomposition, which decomposes the shear into a rotation + non-uniform
+  // scale.
+  //
+  // It is unlikely that the decomposition implementation will need to change
+  // very often, so to get any test coverage, the compromise is to verify the
+  // exact matrix that the.Blend() operation produces.
+  //
+  // This problem also potentially exists for skew along the X axis, but the
+  // current QR decomposition implementation just happens to decompose those
+  // test matrices intuitively.
+  //
+  // Unfortunately, this case suffers from uncomfortably large precision
+  // error.
+
+  from = Transform();
+  from.Skew(0.0, 0.0);
+
+  to = Transform();
+
+  to.Skew(0.0, 45.0);
+  to.Blend(from, 0.0);
+  EXPECT_EQ(from, to);
+
+  to = Transform();
+  to.Skew(0.0, 45.0);
+  to.Blend(from, 0.25);
+  EXPECT_LT(1.0, to.matrix().get(0, 0));
+  EXPECT_GT(1.5, to.matrix().get(0, 0));
+  EXPECT_LT(0.0, to.matrix().get(0, 1));
+  EXPECT_GT(0.5, to.matrix().get(0, 1));
+  EXPECT_FLOAT_EQ(0.0, to.matrix().get(0, 2));
+  EXPECT_FLOAT_EQ(0.0, to.matrix().get(0, 3));
+
+  EXPECT_LT(0.0, to.matrix().get(1, 0));
+  EXPECT_GT(0.5, to.matrix().get(1, 0));
+  EXPECT_LT(0.0, to.matrix().get(1, 1));
+  EXPECT_GT(1.0, to.matrix().get(1, 1));
+  EXPECT_FLOAT_EQ(0.0, to.matrix().get(1, 2));
+  EXPECT_FLOAT_EQ(0.0, to.matrix().get(1, 3));
+
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.Skew(0.0, 45.0);
+  to.Blend(from, 0.5);
+
+  EXPECT_LT(1.0, to.matrix().get(0, 0));
+  EXPECT_GT(1.5, to.matrix().get(0, 0));
+  EXPECT_LT(0.0, to.matrix().get(0, 1));
+  EXPECT_GT(0.5, to.matrix().get(0, 1));
+  EXPECT_FLOAT_EQ(0.0, to.matrix().get(0, 2));
+  EXPECT_FLOAT_EQ(0.0, to.matrix().get(0, 3));
+
+  EXPECT_LT(0.0, to.matrix().get(1, 0));
+  EXPECT_GT(1.0, to.matrix().get(1, 0));
+  EXPECT_LT(0.0, to.matrix().get(1, 1));
+  EXPECT_GT(1.0, to.matrix().get(1, 1));
+  EXPECT_FLOAT_EQ(0.0, to.matrix().get(1, 2));
+  EXPECT_FLOAT_EQ(0.0, to.matrix().get(1, 3));
+
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.Skew(0.0, 45.0);
+  to.Blend(from, 1.0);
+  EXPECT_ROW1_NEAR(1.0, 0.0, 0.0, 0.0, to, LOOSE_ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(1.0, 1.0, 0.0, 0.0, to, LOOSE_ERROR_THRESHOLD);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, to);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+}
+
+TEST(XFormTest, VerifyBlendForRotationAboutX) {
+  // Even though.Blending uses quaternions, axis-aligned rotations should.
+  // Blend the same with quaternions or Euler angles. So we can test
+  // rotation.Blending by comparing against manually specified matrices from
+  // Euler angles.
+
+  Transform from;
+  from.RotateAbout(Vector3dF(1.0, 0.0, 0.0), 0.0);
+
+  Transform to;
+
+  to.RotateAbout(Vector3dF(1.0, 0.0, 0.0), 90.0);
+  to.Blend(from, 0.0);
+  EXPECT_EQ(from, to);
+
+  double expectedRotationAngle = gfx::DegToRad(22.5);
+  to = Transform();
+  to.RotateAbout(Vector3dF(1.0, 0.0, 0.0), 90.0);
+  to.Blend(from, 0.25);
+  EXPECT_ROW1_NEAR(1.0, 0.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.0, std::cos(expectedRotationAngle),
+                   -std::sin(expectedRotationAngle), 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, std::sin(expectedRotationAngle),
+                   std::cos(expectedRotationAngle), 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  expectedRotationAngle = gfx::DegToRad(45.0);
+  to = Transform();
+  to.RotateAbout(Vector3dF(1.0, 0.0, 0.0), 90.0);
+  to.Blend(from, 0.5);
+  EXPECT_ROW1_NEAR(1.0, 0.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.0, std::cos(expectedRotationAngle),
+                   -std::sin(expectedRotationAngle), 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, std::sin(expectedRotationAngle),
+                   std::cos(expectedRotationAngle), 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.RotateAbout(Vector3dF(1.0, 0.0, 0.0), 90.0);
+  to.Blend(from, 1.0);
+  EXPECT_ROW1_NEAR(1.0, 0.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.0, 0.0, -1.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, 1.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+}
+
+TEST(XFormTest, VerifyBlendForRotationAboutY) {
+  Transform from;
+  from.RotateAbout(Vector3dF(0.0, 1.0, 0.0), 0.0);
+
+  Transform to;
+
+  to.RotateAbout(Vector3dF(0.0, 1.0, 0.0), 90.0);
+  to.Blend(from, 0.0);
+  EXPECT_EQ(from, to);
+
+  double expectedRotationAngle = gfx::DegToRad(22.5);
+  to = Transform();
+  to.RotateAbout(Vector3dF(0.0, 1.0, 0.0), 90.0);
+  to.Blend(from, 0.25);
+  EXPECT_ROW1_NEAR(std::cos(expectedRotationAngle), 0.0,
+                   std::sin(expectedRotationAngle), 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.0, 1.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(-std::sin(expectedRotationAngle), 0.0,
+                   std::cos(expectedRotationAngle), 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  expectedRotationAngle = gfx::DegToRad(45.0);
+  to = Transform();
+  to.RotateAbout(Vector3dF(0.0, 1.0, 0.0), 90.0);
+  to.Blend(from, 0.5);
+  EXPECT_ROW1_NEAR(std::cos(expectedRotationAngle), 0.0,
+                   std::sin(expectedRotationAngle), 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.0, 1.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(-std::sin(expectedRotationAngle), 0.0,
+                   std::cos(expectedRotationAngle), 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.RotateAbout(Vector3dF(0.0, 1.0, 0.0), 90.0);
+  to.Blend(from, 1.0);
+  EXPECT_ROW1_NEAR(0.0, 0.0, 1.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.0, 1.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(-1.0, 0.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+}
+
+TEST(XFormTest, VerifyBlendForRotationAboutZ) {
+  Transform from;
+  from.RotateAbout(Vector3dF(0.0, 0.0, 1.0), 0.0);
+
+  Transform to;
+
+  to.RotateAbout(Vector3dF(0.0, 0.0, 1.0), 90.0);
+  to.Blend(from, 0.0);
+  EXPECT_EQ(from, to);
+
+  double expectedRotationAngle = gfx::DegToRad(22.5);
+  to = Transform();
+  to.RotateAbout(Vector3dF(0.0, 0.0, 1.0), 90.0);
+  to.Blend(from, 0.25);
+  EXPECT_ROW1_NEAR(std::cos(expectedRotationAngle),
+                   -std::sin(expectedRotationAngle), 0.0, 0.0, to,
+                   ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(std::sin(expectedRotationAngle),
+                   std::cos(expectedRotationAngle), 0.0, 0.0, to,
+                   ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, 0.0, 1.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  expectedRotationAngle = gfx::DegToRad(45.0);
+  to = Transform();
+  to.RotateAbout(Vector3dF(0.0, 0.0, 1.0), 90.0);
+  to.Blend(from, 0.5);
+  EXPECT_ROW1_NEAR(std::cos(expectedRotationAngle),
+                   -std::sin(expectedRotationAngle), 0.0, 0.0, to,
+                   ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(std::sin(expectedRotationAngle),
+                   std::cos(expectedRotationAngle), 0.0, 0.0, to,
+                   ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, 0.0, 1.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+
+  to = Transform();
+  to.RotateAbout(Vector3dF(0.0, 0.0, 1.0), 90.0);
+  to.Blend(from, 1.0);
+  EXPECT_ROW1_NEAR(0.0, -1.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(1.0, 0.0, 0.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, 0.0, 1.0, 0.0, to, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, to);
+}
+
+TEST(XFormTest, VerifyBlendForCompositeTransform) {
+  // Verify that the.Blending was done with a decomposition in correct order
+  // by blending a composite transform. Using matrix x vector notation
+  // (Ax = b, where x is column vector), the ordering should be:
+  // perspective * translation * rotation * skew * scale
+  //
+  // It is not as important (or meaningful) to check intermediate
+  // interpolations; order of operations will be tested well enough by the
+  // end cases that are easier to specify.
+
+  Transform from;
+  Transform to;
+
+  Transform expectedEndOfAnimation;
+  expectedEndOfAnimation.ApplyPerspectiveDepth(1.0);
+  expectedEndOfAnimation.Translate3d(10.0, 20.0, 30.0);
+  expectedEndOfAnimation.RotateAbout(Vector3dF(0.0, 0.0, 1.0), 25.0);
+  expectedEndOfAnimation.Skew(0.0, 45.0);
+  expectedEndOfAnimation.Scale3d(6.0, 7.0, 8.0);
+
+  to = expectedEndOfAnimation;
+  to.Blend(from, 0.0);
+  EXPECT_EQ(from, to);
+
+  to = expectedEndOfAnimation;
+  // We short circuit if blend is >= 1, so to check the numerics, we will
+  // check that we get close to what we expect when we're nearly done
+  // interpolating.
+  to.Blend(from, .99999f);
+
+  // Recomposing the matrix results in a normalized matrix, so to verify we
+  // need to normalize the expectedEndOfAnimation before comparing elements.
+  // Normalizing means dividing everything by expectedEndOfAnimation.m44().
+  Transform normalizedExpectedEndOfAnimation = expectedEndOfAnimation;
+  Transform normalizationMatrix;
+  normalizationMatrix.matrix().set(
+      0.0, 0.0,
+      SkDoubleToScalar(1 / expectedEndOfAnimation.matrix().get(3.0, 3.0)));
+  normalizationMatrix.matrix().set(
+      1.0, 1.0,
+      SkDoubleToScalar(1 / expectedEndOfAnimation.matrix().get(3.0, 3.0)));
+  normalizationMatrix.matrix().set(
+      2.0, 2.0,
+      SkDoubleToScalar(1 / expectedEndOfAnimation.matrix().get(3.0, 3.0)));
+  normalizationMatrix.matrix().set(
+      3.0, 3.0,
+      SkDoubleToScalar(1 / expectedEndOfAnimation.matrix().get(3.0, 3.0)));
+  normalizedExpectedEndOfAnimation.PreconcatTransform(normalizationMatrix);
+
+  EXPECT_TRUE(MatricesAreNearlyEqual(normalizedExpectedEndOfAnimation, to));
+}
+
+TEST(XFormTest, DecomposedTransformCtor) {
+  DecomposedTransform decomp;
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_EQ(0.0, decomp.translate[i]);
+    EXPECT_EQ(1.0, decomp.scale[i]);
+    EXPECT_EQ(0.0, decomp.skew[i]);
+    EXPECT_EQ(0.0, decomp.perspective[i]);
+  }
+  EXPECT_EQ(1.0, decomp.perspective[3]);
+
+  EXPECT_EQ(0.0, decomp.quaternion.x());
+  EXPECT_EQ(0.0, decomp.quaternion.y());
+  EXPECT_EQ(0.0, decomp.quaternion.z());
+  EXPECT_EQ(1.0, decomp.quaternion.w());
+
+  Transform identity;
+  Transform composed = ComposeTransform(decomp);
+  EXPECT_TRUE(MatricesAreNearlyEqual(identity, composed));
+}
+
+TEST(XFormTest, FactorTRS) {
+  for (int degrees = 0; degrees < 180; ++degrees) {
+    // build a transformation matrix.
+    gfx::Transform transform;
+    transform.Translate(degrees * 2, -degrees * 3);
+    transform.Rotate(degrees);
+    transform.Scale(degrees + 1, 2 * degrees + 1);
+
+    // factor the matrix
+    DecomposedTransform decomp;
+    bool success = DecomposeTransform(&decomp, transform);
+    EXPECT_TRUE(success);
+    EXPECT_FLOAT_EQ(decomp.translate[0], degrees * 2);
+    EXPECT_FLOAT_EQ(decomp.translate[1], -degrees * 3);
+    double rotation =
+        gfx::RadToDeg(std::acos(double{decomp.quaternion.w()}) * 2);
+    while (rotation < 0.0)
+      rotation += 360.0;
+    while (rotation > 360.0)
+      rotation -= 360.0;
+
+    const float epsilon = 0.00015f;
+    EXPECT_NEAR(rotation, degrees, epsilon);
+    EXPECT_NEAR(decomp.scale[0], degrees + 1, epsilon);
+    EXPECT_NEAR(decomp.scale[1], 2 * degrees + 1, epsilon);
+  }
+}
+
+TEST(XFormTest, DecomposeTransform) {
+  for (float scale = 0.001f; scale < 2.0f; scale += 0.001f) {
+    gfx::Transform transform;
+    transform.Scale(scale, scale);
+    EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+
+    DecomposedTransform decomp;
+    bool success = DecomposeTransform(&decomp, transform);
+    EXPECT_TRUE(success);
+
+    gfx::Transform compose_transform = ComposeTransform(decomp);
+    EXPECT_TRUE(compose_transform.Preserves2dAxisAlignment());
+  }
+}
+
+TEST(XFormTest, IntegerTranslation) {
+  gfx::Transform transform;
+  EXPECT_TRUE(transform.IsIdentityOrIntegerTranslation());
+
+  transform.Translate3d(1, 2, 3);
+  EXPECT_TRUE(transform.IsIdentityOrIntegerTranslation());
+
+  transform.MakeIdentity();
+  transform.Translate3d(-1, -2, -3);
+  EXPECT_TRUE(transform.IsIdentityOrIntegerTranslation());
+
+  transform.MakeIdentity();
+  transform.Translate3d(4.5f, 0, 0);
+  EXPECT_FALSE(transform.IsIdentityOrIntegerTranslation());
+
+  transform.MakeIdentity();
+  transform.Translate3d(0, -6.7f, 0);
+  EXPECT_FALSE(transform.IsIdentityOrIntegerTranslation());
+
+  transform.MakeIdentity();
+  transform.Translate3d(0, 0, 8.9f);
+  EXPECT_FALSE(transform.IsIdentityOrIntegerTranslation());
+
+  float max_int = static_cast<float>(std::numeric_limits<int>::max());
+  transform.MakeIdentity();
+  transform.Translate3d(0, 0, max_int + 1000.5f);
+  EXPECT_FALSE(transform.IsIdentityOrIntegerTranslation());
+
+  float max_float = std::numeric_limits<float>::max();
+  transform.MakeIdentity();
+  transform.Translate3d(0, 0, max_float - 0.5f);
+  EXPECT_FALSE(transform.IsIdentityOrIntegerTranslation());
+}
+
+TEST(XFormTest, verifyMatrixInversion) {
+  {
+    // Invert a translation
+    gfx::Transform translation;
+    translation.Translate3d(2.0, 3.0, 4.0);
+    EXPECT_TRUE(translation.IsInvertible());
+
+    gfx::Transform inverse_translation;
+    bool is_invertible = translation.GetInverse(&inverse_translation);
+    EXPECT_TRUE(is_invertible);
+    EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, -2.0f, inverse_translation);
+    EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, -3.0f, inverse_translation);
+    EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, -4.0f, inverse_translation);
+    EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, inverse_translation);
+  }
+
+  {
+    // Invert a non-uniform scale
+    gfx::Transform scale;
+    scale.Scale3d(4.0, 10.0, 100.0);
+    EXPECT_TRUE(scale.IsInvertible());
+
+    gfx::Transform inverse_scale;
+    bool is_invertible = scale.GetInverse(&inverse_scale);
+    EXPECT_TRUE(is_invertible);
+    EXPECT_ROW1_EQ(0.25f, 0.0f, 0.0f, 0.0f, inverse_scale);
+    EXPECT_ROW2_EQ(0.0f, 0.1f, 0.0f, 0.0f, inverse_scale);
+    EXPECT_ROW3_EQ(0.0f, 0.0f, 0.01f, 0.0f, inverse_scale);
+    EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, inverse_scale);
+  }
+
+  {
+    // Try to invert a matrix that is not invertible.
+    // The inverse() function should reset the output matrix to identity.
+    gfx::Transform uninvertible;
+    uninvertible.matrix().set(0, 0, 0.f);
+    uninvertible.matrix().set(1, 1, 0.f);
+    uninvertible.matrix().set(2, 2, 0.f);
+    uninvertible.matrix().set(3, 3, 0.f);
+    EXPECT_FALSE(uninvertible.IsInvertible());
+
+    gfx::Transform inverse_of_uninvertible;
+
+    // Add a scale just to more easily ensure that inverse_of_uninvertible is
+    // reset to identity.
+    inverse_of_uninvertible.Scale3d(4.0, 10.0, 100.0);
+
+    bool is_invertible = uninvertible.GetInverse(&inverse_of_uninvertible);
+    EXPECT_FALSE(is_invertible);
+    EXPECT_TRUE(inverse_of_uninvertible.IsIdentity());
+    EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 0.0f, inverse_of_uninvertible);
+    EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, inverse_of_uninvertible);
+    EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, inverse_of_uninvertible);
+    EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, inverse_of_uninvertible);
+  }
+}
+
+TEST(XFormTest, verifyBackfaceVisibilityBasicCases) {
+  Transform transform;
+
+  transform.MakeIdentity();
+  EXPECT_FALSE(transform.IsBackFaceVisible());
+
+  transform.MakeIdentity();
+  transform.RotateAboutYAxis(80.0);
+  EXPECT_FALSE(transform.IsBackFaceVisible());
+
+  transform.MakeIdentity();
+  transform.RotateAboutYAxis(100.0);
+  EXPECT_TRUE(transform.IsBackFaceVisible());
+
+  // Edge case, 90 degree rotation should return false.
+  transform.MakeIdentity();
+  transform.RotateAboutYAxis(90.0);
+  EXPECT_FALSE(transform.IsBackFaceVisible());
+}
+
+TEST(XFormTest, verifyBackfaceVisibilityForPerspective) {
+  Transform layer_space_to_projection_plane;
+
+  // This tests if IsBackFaceVisible works properly under perspective
+  // transforms.  Specifically, layers that may have their back face visible in
+  // orthographic projection, may not actually have back face visible under
+  // perspective projection.
+
+  // Case 1: Layer is rotated by slightly more than 90 degrees, at the center
+  //         of the perspective projection. In this case, the layer's back-side
+  //         is visible to the camera.
+  layer_space_to_projection_plane.MakeIdentity();
+  layer_space_to_projection_plane.ApplyPerspectiveDepth(1.0);
+  layer_space_to_projection_plane.Translate3d(0.0, 0.0, 0.0);
+  layer_space_to_projection_plane.RotateAboutYAxis(100.0);
+  EXPECT_TRUE(layer_space_to_projection_plane.IsBackFaceVisible());
+
+  // Case 2: Layer is rotated by slightly more than 90 degrees, but shifted off
+  //         to the side of the camera. Because of the wide field-of-view, the
+  //         layer's front side is still visible.
+  //
+  //                       |<-- front side of layer is visible to camera
+  //                    \  |            /
+  //                     \ |           /
+  //                      \|          /
+  //                       |         /
+  //                       |\       /<-- camera field of view
+  //                       | \     /
+  // back side of layer -->|  \   /
+  //                           \./ <-- camera origin
+  //
+  layer_space_to_projection_plane.MakeIdentity();
+  layer_space_to_projection_plane.ApplyPerspectiveDepth(1.0);
+  layer_space_to_projection_plane.Translate3d(-10.0, 0.0, 0.0);
+  layer_space_to_projection_plane.RotateAboutYAxis(100.0);
+  EXPECT_FALSE(layer_space_to_projection_plane.IsBackFaceVisible());
+
+  // Case 3: Additionally rotating the layer by 180 degrees should of course
+  //         show the opposite result of case 2.
+  layer_space_to_projection_plane.RotateAboutYAxis(180.0);
+  EXPECT_TRUE(layer_space_to_projection_plane.IsBackFaceVisible());
+}
+
+TEST(XFormTest, verifyDefaultConstructorCreatesIdentityMatrix) {
+  Transform A;
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+  EXPECT_TRUE(A.IsIdentity());
+}
+
+TEST(XFormTest, verifyCopyConstructor) {
+  Transform A;
+  InitializeTestMatrix(&A);
+
+  // Copy constructor should produce exact same elements as matrix A.
+  Transform B(A);
+  EXPECT_ROW1_EQ(10.0f, 14.0f, 18.0f, 22.0f, B);
+  EXPECT_ROW2_EQ(11.0f, 15.0f, 19.0f, 23.0f, B);
+  EXPECT_ROW3_EQ(12.0f, 16.0f, 20.0f, 24.0f, B);
+  EXPECT_ROW4_EQ(13.0f, 17.0f, 21.0f, 25.0f, B);
+}
+
+TEST(XFormTest, verifyConstructorFor16Elements) {
+  Transform transform(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0,
+                      12.0, 13.0, 14.0, 15.0, 16.0);
+
+  EXPECT_ROW1_EQ(1.0f, 2.0f, 3.0f, 4.0f, transform);
+  EXPECT_ROW2_EQ(5.0f, 6.0f, 7.0f, 8.0f, transform);
+  EXPECT_ROW3_EQ(9.0f, 10.0f, 11.0f, 12.0f, transform);
+  EXPECT_ROW4_EQ(13.0f, 14.0f, 15.0f, 16.0f, transform);
+}
+
+TEST(XFormTest, verifyConstructorFor2dElements) {
+  Transform transform(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
+
+  EXPECT_ROW1_EQ(1.0f, 2.0f, 0.0f, 5.0f, transform);
+  EXPECT_ROW2_EQ(3.0f, 4.0f, 0.0f, 6.0f, transform);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, transform);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, transform);
+}
+
+TEST(XFormTest, verifyAssignmentOperator) {
+  Transform A;
+  InitializeTestMatrix(&A);
+  Transform B;
+  InitializeTestMatrix2(&B);
+  Transform C;
+  InitializeTestMatrix2(&C);
+  C = B = A;
+
+  // Both B and C should now have been re-assigned to the value of A.
+  EXPECT_ROW1_EQ(10.0f, 14.0f, 18.0f, 22.0f, B);
+  EXPECT_ROW2_EQ(11.0f, 15.0f, 19.0f, 23.0f, B);
+  EXPECT_ROW3_EQ(12.0f, 16.0f, 20.0f, 24.0f, B);
+  EXPECT_ROW4_EQ(13.0f, 17.0f, 21.0f, 25.0f, B);
+
+  EXPECT_ROW1_EQ(10.0f, 14.0f, 18.0f, 22.0f, C);
+  EXPECT_ROW2_EQ(11.0f, 15.0f, 19.0f, 23.0f, C);
+  EXPECT_ROW3_EQ(12.0f, 16.0f, 20.0f, 24.0f, C);
+  EXPECT_ROW4_EQ(13.0f, 17.0f, 21.0f, 25.0f, C);
+}
+
+TEST(XFormTest, verifyEqualsBooleanOperator) {
+  Transform A;
+  InitializeTestMatrix(&A);
+
+  Transform B;
+  InitializeTestMatrix(&B);
+  EXPECT_TRUE(A == B);
+
+  // Modifying multiple elements should cause equals operator to return false.
+  Transform C;
+  InitializeTestMatrix2(&C);
+  EXPECT_FALSE(A == C);
+
+  // Modifying any one individual element should cause equals operator to
+  // return false.
+  Transform D;
+  D = A;
+  D.matrix().set(0, 0, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(1, 0, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(2, 0, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(3, 0, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(0, 1, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(1, 1, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(2, 1, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(3, 1, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(0, 2, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(1, 2, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(2, 2, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(3, 2, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(0, 3, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(1, 3, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(2, 3, 0.f);
+  EXPECT_FALSE(A == D);
+
+  D = A;
+  D.matrix().set(3, 3, 0.f);
+  EXPECT_FALSE(A == D);
+}
+
+TEST(XFormTest, verifyMultiplyOperator) {
+  Transform A;
+  InitializeTestMatrix(&A);
+
+  Transform B;
+  InitializeTestMatrix2(&B);
+
+  Transform C = A * B;
+  EXPECT_ROW1_EQ(2036.0f, 2292.0f, 2548.0f, 2804.0f, C);
+  EXPECT_ROW2_EQ(2162.0f, 2434.0f, 2706.0f, 2978.0f, C);
+  EXPECT_ROW3_EQ(2288.0f, 2576.0f, 2864.0f, 3152.0f, C);
+  EXPECT_ROW4_EQ(2414.0f, 2718.0f, 3022.0f, 3326.0f, C);
+
+  // Just an additional sanity check; matrix multiplication is not commutative.
+  EXPECT_FALSE(A * B == B * A);
+}
+
+TEST(XFormTest, verifyMultiplyAndAssignOperator) {
+  Transform A;
+  InitializeTestMatrix(&A);
+
+  Transform B;
+  InitializeTestMatrix2(&B);
+
+  A *= B;
+  EXPECT_ROW1_EQ(2036.0f, 2292.0f, 2548.0f, 2804.0f, A);
+  EXPECT_ROW2_EQ(2162.0f, 2434.0f, 2706.0f, 2978.0f, A);
+  EXPECT_ROW3_EQ(2288.0f, 2576.0f, 2864.0f, 3152.0f, A);
+  EXPECT_ROW4_EQ(2414.0f, 2718.0f, 3022.0f, 3326.0f, A);
+
+  // Just an additional sanity check; matrix multiplication is not commutative.
+  Transform C = A;
+  C *= B;
+  Transform D = B;
+  D *= A;
+  EXPECT_FALSE(C == D);
+}
+
+TEST(XFormTest, verifyMatrixMultiplication) {
+  Transform A;
+  InitializeTestMatrix(&A);
+
+  Transform B;
+  InitializeTestMatrix2(&B);
+
+  A.PreconcatTransform(B);
+  EXPECT_ROW1_EQ(2036.0f, 2292.0f, 2548.0f, 2804.0f, A);
+  EXPECT_ROW2_EQ(2162.0f, 2434.0f, 2706.0f, 2978.0f, A);
+  EXPECT_ROW3_EQ(2288.0f, 2576.0f, 2864.0f, 3152.0f, A);
+  EXPECT_ROW4_EQ(2414.0f, 2718.0f, 3022.0f, 3326.0f, A);
+}
+
+TEST(XFormTest, verifyMakeIdentiy) {
+  Transform A;
+  InitializeTestMatrix(&A);
+  A.MakeIdentity();
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+  EXPECT_TRUE(A.IsIdentity());
+}
+
+TEST(XFormTest, verifyTranslate) {
+  Transform A;
+  A.Translate(2.0, 3.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 2.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 3.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that Translate() post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Scale(5.0, 5.0);
+  A.Translate(2.0, 3.0);
+  EXPECT_ROW1_EQ(5.0f, 0.0f, 0.0f, 10.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 5.0f, 0.0f, 15.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyTranslate3d) {
+  Transform A;
+  A.Translate3d(2.0, 3.0, 4.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 2.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 3.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 4.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that Translate3d() post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Scale3d(6.0, 7.0, 8.0);
+  A.Translate3d(2.0, 3.0, 4.0);
+  EXPECT_ROW1_EQ(6.0f, 0.0f, 0.0f, 12.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 7.0f, 0.0f, 21.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 8.0f, 32.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyScale) {
+  Transform A;
+  A.Scale(6.0, 7.0);
+  EXPECT_ROW1_EQ(6.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 7.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that Scale() post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Translate3d(2.0, 3.0, 4.0);
+  A.Scale(6.0, 7.0);
+  EXPECT_ROW1_EQ(6.0f, 0.0f, 0.0f, 2.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 7.0f, 0.0f, 3.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 4.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyScale3d) {
+  Transform A;
+  A.Scale3d(6.0, 7.0, 8.0);
+  EXPECT_ROW1_EQ(6.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 7.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 8.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that scale3d() post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Translate3d(2.0, 3.0, 4.0);
+  A.Scale3d(6.0, 7.0, 8.0);
+  EXPECT_ROW1_EQ(6.0f, 0.0f, 0.0f, 2.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 7.0f, 0.0f, 3.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 8.0f, 4.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyRotate) {
+  Transform A;
+  A.Rotate(90.0);
+  EXPECT_ROW1_NEAR(0.0, -1.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(1.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that Rotate() post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Scale3d(6.0, 7.0, 8.0);
+  A.Rotate(90.0);
+  EXPECT_ROW1_NEAR(0.0, -6.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(7.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 8.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyRotateAboutXAxis) {
+  Transform A;
+  double sin45 = 0.5 * sqrt(2.0);
+  double cos45 = sin45;
+
+  A.MakeIdentity();
+  A.RotateAboutXAxis(90.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_NEAR(0.0, 0.0, -1.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, 1.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  A.MakeIdentity();
+  A.RotateAboutXAxis(45.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_NEAR(0.0, cos45, -sin45, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, sin45, cos45, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that RotateAboutXAxis(angle) post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Scale3d(6.0, 7.0, 8.0);
+  A.RotateAboutXAxis(90.0);
+  EXPECT_ROW1_NEAR(6.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.0, 0.0, -7.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, 8.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyRotateAboutYAxis) {
+  Transform A;
+  double sin45 = 0.5 * sqrt(2.0);
+  double cos45 = sin45;
+
+  // Note carefully, the expected pattern is inverted compared to rotating
+  // about x axis or z axis.
+  A.MakeIdentity();
+  A.RotateAboutYAxis(90.0);
+  EXPECT_ROW1_NEAR(0.0, 0.0, 1.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_NEAR(-1.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  A.MakeIdentity();
+  A.RotateAboutYAxis(45.0);
+  EXPECT_ROW1_NEAR(cos45, 0.0, sin45, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_NEAR(-sin45, 0.0, cos45, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that RotateAboutYAxis(angle) post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Scale3d(6.0, 7.0, 8.0);
+  A.RotateAboutYAxis(90.0);
+  EXPECT_ROW1_NEAR(0.0, 0.0, 6.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.0, 7.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(-8.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyRotateAboutZAxis) {
+  Transform A;
+  double sin45 = 0.5 * sqrt(2.0);
+  double cos45 = sin45;
+
+  A.MakeIdentity();
+  A.RotateAboutZAxis(90.0);
+  EXPECT_ROW1_NEAR(0.0, -1.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(1.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  A.MakeIdentity();
+  A.RotateAboutZAxis(45.0);
+  EXPECT_ROW1_NEAR(cos45, -sin45, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(sin45, cos45, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that RotateAboutZAxis(angle) post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Scale3d(6.0, 7.0, 8.0);
+  A.RotateAboutZAxis(90.0);
+  EXPECT_ROW1_NEAR(0.0, -6.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(7.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 8.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyRotateAboutForAlignedAxes) {
+  Transform A;
+
+  // Check rotation about z-axis
+  A.MakeIdentity();
+  A.RotateAbout(Vector3dF(0.0, 0.0, 1.0), 90.0);
+  EXPECT_ROW1_NEAR(0.0, -1.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(1.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Check rotation about x-axis
+  A.MakeIdentity();
+  A.RotateAbout(Vector3dF(1.0, 0.0, 0.0), 90.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_NEAR(0.0, 0.0, -1.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(0.0, 1.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Check rotation about y-axis. Note carefully, the expected pattern is
+  // inverted compared to rotating about x axis or z axis.
+  A.MakeIdentity();
+  A.RotateAbout(Vector3dF(0.0, 1.0, 0.0), 90.0);
+  EXPECT_ROW1_NEAR(0.0, 0.0, 1.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_NEAR(-1.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that rotate3d(axis, angle) post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Scale3d(6.0, 7.0, 8.0);
+  A.RotateAboutZAxis(90.0);
+  EXPECT_ROW1_NEAR(0.0, -6.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(7.0, 0.0, 0.0, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 8.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyRotateAboutForArbitraryAxis) {
+  // Check rotation about an arbitrary non-axis-aligned vector.
+  Transform A;
+  A.RotateAbout(Vector3dF(1.0, 1.0, 1.0), 90.0);
+  EXPECT_ROW1_NEAR(0.3333333333333334258519187, -0.2440169358562924717404030,
+                   0.9106836025229592124219380, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW2_NEAR(0.9106836025229592124219380, 0.3333333333333334258519187,
+                   -0.2440169358562924717404030, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW3_NEAR(-0.2440169358562924717404030, 0.9106836025229592124219380,
+                   0.3333333333333334258519187, 0.0, A, ERROR_THRESHOLD);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyRotateAboutForDegenerateAxis) {
+  // Check rotation about a degenerate zero vector.
+  // It is expected to skip applying the rotation.
+  Transform A;
+
+  A.RotateAbout(Vector3dF(0.0, 0.0, 0.0), 45.0);
+  // Verify that A remains unchanged.
+  EXPECT_TRUE(A.IsIdentity());
+
+  InitializeTestMatrix(&A);
+  A.RotateAbout(Vector3dF(0.0, 0.0, 0.0), 35.0);
+
+  // Verify that A remains unchanged.
+  EXPECT_ROW1_EQ(10.0f, 14.0f, 18.0f, 22.0f, A);
+  EXPECT_ROW2_EQ(11.0f, 15.0f, 19.0f, 23.0f, A);
+  EXPECT_ROW3_EQ(12.0f, 16.0f, 20.0f, 24.0f, A);
+  EXPECT_ROW4_EQ(13.0f, 17.0f, 21.0f, 25.0f, A);
+}
+
+TEST(XFormTest, verifySkew) {
+  // Test a skew along X axis only
+  Transform A;
+  A.Skew(45.0, 0.0);
+  EXPECT_ROW1_EQ(1.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Test a skew along Y axis only
+  A.MakeIdentity();
+  A.Skew(0.0, 45.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(1.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Verify that skew() post-multiplies the existing matrix. Row 1, column 2,
+  // would incorrectly have value "7" if the matrix is pre-multiplied instead
+  // of post-multiplied.
+  A.MakeIdentity();
+  A.Scale3d(6.0, 7.0, 8.0);
+  A.Skew(45.0, 0.0);
+  EXPECT_ROW1_EQ(6.0f, 6.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 7.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 8.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+
+  // Test a skew along X and Y axes both
+  A.MakeIdentity();
+  A.Skew(45.0, 45.0);
+  EXPECT_ROW1_EQ(1.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(1.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, 0.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyPerspectiveDepth) {
+  Transform A;
+  A.ApplyPerspectiveDepth(1.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, 0.0f, 0.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, -1.0f, 1.0f, A);
+
+  // Verify that PerspectiveDepth() post-multiplies the existing matrix.
+  A.MakeIdentity();
+  A.Translate3d(2.0, 3.0, 4.0);
+  A.ApplyPerspectiveDepth(1.0);
+  EXPECT_ROW1_EQ(1.0f, 0.0f, -2.0f, 2.0f, A);
+  EXPECT_ROW2_EQ(0.0f, 1.0f, -3.0f, 3.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, -3.0f, 4.0f, A);
+  EXPECT_ROW4_EQ(0.0f, 0.0f, -1.0f, 1.0f, A);
+}
+
+TEST(XFormTest, verifyHasPerspective) {
+  Transform A;
+  A.ApplyPerspectiveDepth(1.0);
+  EXPECT_TRUE(A.HasPerspective());
+
+  A.MakeIdentity();
+  A.ApplyPerspectiveDepth(0.0);
+  EXPECT_FALSE(A.HasPerspective());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 0, -1.f);
+  EXPECT_TRUE(A.HasPerspective());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 1, -1.f);
+  EXPECT_TRUE(A.HasPerspective());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 2, -0.3f);
+  EXPECT_TRUE(A.HasPerspective());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 3, 0.5f);
+  EXPECT_TRUE(A.HasPerspective());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 3, 0.f);
+  EXPECT_TRUE(A.HasPerspective());
+}
+
+TEST(XFormTest, verifyIsInvertible) {
+  Transform A;
+
+  // Translations, rotations, scales, skews and arbitrary combinations of them
+  // are invertible.
+  A.MakeIdentity();
+  EXPECT_TRUE(A.IsInvertible());
+
+  A.MakeIdentity();
+  A.Translate3d(2.0, 3.0, 4.0);
+  EXPECT_TRUE(A.IsInvertible());
+
+  A.MakeIdentity();
+  A.Scale3d(6.0, 7.0, 8.0);
+  EXPECT_TRUE(A.IsInvertible());
+
+  A.MakeIdentity();
+  A.RotateAboutXAxis(10.0);
+  A.RotateAboutYAxis(20.0);
+  A.RotateAboutZAxis(30.0);
+  EXPECT_TRUE(A.IsInvertible());
+
+  A.MakeIdentity();
+  A.Skew(45.0, 0.0);
+  EXPECT_TRUE(A.IsInvertible());
+
+  // A perspective matrix (projection plane at z=0) is invertible. The
+  // intuitive explanation is that perspective is equivalent to a skew of the
+  // w-axis; skews are invertible.
+  A.MakeIdentity();
+  A.ApplyPerspectiveDepth(1.0);
+  EXPECT_TRUE(A.IsInvertible());
+
+  // A "pure" perspective matrix derived by similar triangles, with m44() set
+  // to zero (i.e. camera positioned at the origin), is not invertible.
+  A.MakeIdentity();
+  A.ApplyPerspectiveDepth(1.0);
+  A.matrix().set(3, 3, 0.f);
+  EXPECT_FALSE(A.IsInvertible());
+
+  // Adding more to a non-invertible matrix will not make it invertible in the
+  // general case.
+  A.MakeIdentity();
+  A.ApplyPerspectiveDepth(1.0);
+  A.matrix().set(3, 3, 0.f);
+  A.Scale3d(6.0, 7.0, 8.0);
+  A.RotateAboutXAxis(10.0);
+  A.RotateAboutYAxis(20.0);
+  A.RotateAboutZAxis(30.0);
+  A.Translate3d(6.0, 7.0, 8.0);
+#if !defined(ARCH_CPU_ARM_FAMILY)
+  // TODO(enne): Make this pass on ARM, https://crbug.com/662558
+  EXPECT_FALSE(A.IsInvertible());
+#endif
+
+  // A degenerate matrix of all zeros is not invertible.
+  A.MakeIdentity();
+  A.matrix().set(0, 0, 0.f);
+  A.matrix().set(1, 1, 0.f);
+  A.matrix().set(2, 2, 0.f);
+  A.matrix().set(3, 3, 0.f);
+  EXPECT_FALSE(A.IsInvertible());
+}
+
+TEST(XFormTest, verifyIsIdentity) {
+  Transform A;
+
+  InitializeTestMatrix(&A);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  EXPECT_TRUE(A.IsIdentity());
+
+  // Modifying any one individual element should cause the matrix to no longer
+  // be identity.
+  A.MakeIdentity();
+  A.matrix().set(0, 0, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 0, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 0, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 0, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(0, 1, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 1, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 1, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 1, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(0, 2, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 2, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 2, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 2, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(0, 3, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 3, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 3, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 3, 2.f);
+  EXPECT_FALSE(A.IsIdentity());
+}
+
+TEST(XFormTest, verifyIsIdentityOrTranslation) {
+  Transform A;
+
+  InitializeTestMatrix(&A);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  EXPECT_TRUE(A.IsIdentityOrTranslation());
+
+  // Modifying any non-translation components should cause
+  // IsIdentityOrTranslation() to return false. NOTE: (0, 3), (1, 3), and
+  // (2, 3) are the translation components, so modifying them should still
+  // return true.
+  A.MakeIdentity();
+  A.matrix().set(0, 0, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 0, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 0, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 0, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(0, 1, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 1, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 1, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 1, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(0, 2, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 2, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 2, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 2, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(0, 3, 2.f);
+  EXPECT_TRUE(A.IsIdentityOrTranslation());
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(1, 3, 2.f);
+  EXPECT_TRUE(A.IsIdentityOrTranslation());
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(2, 3, 2.f);
+  EXPECT_TRUE(A.IsIdentityOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 3, 2.f);
+  EXPECT_FALSE(A.IsIdentityOrTranslation());
+}
+
+TEST(XFormTest, verifyIsApproximatelyIdentityOrTranslation) {
+  Transform A;
+  skia::Matrix44& matrix = A.matrix();
+
+  // Exact pure translation.
+  A.MakeIdentity();
+
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(kApproxZero));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrIntegerTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrIntegerTranslation(kApproxZero));
+
+  // Set translate values to integer values other than 0 or 1.
+  matrix.set(0, 3, 3);
+  matrix.set(1, 3, 4);
+  matrix.set(2, 3, 5);
+
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(kApproxZero));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrIntegerTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrIntegerTranslation(kApproxZero));
+
+  // Set translate values to values other than 0 or 1.
+  matrix.set(0, 3, 3.4f);
+  matrix.set(1, 3, 4.4f);
+  matrix.set(2, 3, 5.6f);
+
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(kApproxZero));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(0));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(kApproxZero));
+
+  // Approximately pure translation.
+  InitializeApproxIdentityMatrix(&A);
+
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrTranslation(0));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrTranslation(kApproxZero));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(0));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(kApproxZero));
+
+  // Some values must be exact.
+  matrix.set(3, 0, 0);
+  matrix.set(3, 1, 0);
+  matrix.set(3, 2, 0);
+  matrix.set(3, 3, 1);
+
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(kApproxZero));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrIntegerTranslation(kApproxZero));
+
+  // Set translate values to values other than 0 or 1.
+  matrix.set(0, 3, matrix.get(0, 3) + 3);
+  matrix.set(1, 3, matrix.get(1, 3) + 4);
+  matrix.set(2, 3, matrix.get(2, 3) + 5);
+
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(kApproxZero));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrIntegerTranslation(kApproxZero));
+
+  // Set translate values to values other than 0 or 1.
+  matrix.set(0, 3, 3.4f);
+  matrix.set(1, 3, 4.4f);
+  matrix.set(2, 3, 5.6f);
+
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrTranslation(0));
+  EXPECT_TRUE(A.IsApproximatelyIdentityOrTranslation(kApproxZero));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(0));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(kApproxZero));
+
+  // Not approximately pure translation.
+  InitializeApproxIdentityMatrix(&A);
+
+  // Some values must be exact.
+  matrix.set(3, 0, 0);
+  matrix.set(3, 1, 0);
+  matrix.set(3, 2, 0);
+  matrix.set(3, 3, 1);
+
+  // Set some values (not translate values) to values other than 0 or 1.
+  matrix.set(0, 1, 3.4f);
+  matrix.set(3, 2, 4.4f);
+  matrix.set(2, 0, 5.6f);
+
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrTranslation(0));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrTranslation(kApproxZero));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(0));
+  EXPECT_FALSE(A.IsApproximatelyIdentityOrIntegerTranslation(kApproxZero));
+}
+
+TEST(XFormTest, verifyIsScaleOrTranslation) {
+  Transform A;
+
+  InitializeTestMatrix(&A);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  EXPECT_TRUE(A.IsScaleOrTranslation());
+
+  // Modifying any non-scale or non-translation components should cause
+  // IsScaleOrTranslation() to return false. (0, 0), (1, 1), (2, 2), (0, 3),
+  // (1, 3), and (2, 3) are the scale and translation components, so
+  // modifying them should still return true.
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(0, 0, 2.f);
+  EXPECT_TRUE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 0, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 0, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 0, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(0, 1, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(1, 1, 2.f);
+  EXPECT_TRUE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(2, 1, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 1, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(0, 2, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(1, 2, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(2, 2, 2.f);
+  EXPECT_TRUE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 2, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(0, 3, 2.f);
+  EXPECT_TRUE(A.IsScaleOrTranslation());
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(1, 3, 2.f);
+  EXPECT_TRUE(A.IsScaleOrTranslation());
+
+  // Note carefully - expecting true here.
+  A.MakeIdentity();
+  A.matrix().set(2, 3, 2.f);
+  EXPECT_TRUE(A.IsScaleOrTranslation());
+
+  A.MakeIdentity();
+  A.matrix().set(3, 3, 2.f);
+  EXPECT_FALSE(A.IsScaleOrTranslation());
+}
+
+TEST(XFormTest, verifyFlattenTo2d) {
+  Transform A;
+  InitializeTestMatrix(&A);
+
+  A.FlattenTo2d();
+  EXPECT_ROW1_EQ(10.0f, 14.0f, 0.0f, 22.0f, A);
+  EXPECT_ROW2_EQ(11.0f, 15.0f, 0.0f, 23.0f, A);
+  EXPECT_ROW3_EQ(0.0f, 0.0f, 1.0f, 0.0f, A);
+  EXPECT_ROW4_EQ(13.0f, 17.0f, 0.0f, 25.0f, A);
+}
+
+TEST(XFormTest, IsFlat) {
+  Transform transform;
+  InitializeTestMatrix(&transform);
+
+  // A transform with all entries non-zero isn't flat.
+  EXPECT_FALSE(transform.IsFlat());
+
+  transform.matrix().set(0, 2, 0.f);
+  transform.matrix().set(1, 2, 0.f);
+  transform.matrix().set(2, 2, 1.f);
+  transform.matrix().set(3, 2, 0.f);
+
+  EXPECT_FALSE(transform.IsFlat());
+
+  transform.matrix().set(2, 0, 0.f);
+  transform.matrix().set(2, 1, 0.f);
+  transform.matrix().set(2, 3, 0.f);
+
+  // Since the third column and row are both (0, 0, 1, 0), the transform is
+  // flat.
+  EXPECT_TRUE(transform.IsFlat());
+}
+
+// Another implementation of Preserves2dAxisAlignment that isn't as fast,
+// good for testing the faster implementation.
+static bool EmpiricallyPreserves2dAxisAlignment(const Transform& transform) {
+  Point3F p1(5.0f, 5.0f, 0.0f);
+  Point3F p2(10.0f, 5.0f, 0.0f);
+  Point3F p3(10.0f, 20.0f, 0.0f);
+  Point3F p4(5.0f, 20.0f, 0.0f);
+
+  QuadF test_quad(PointF(p1.x(), p1.y()), PointF(p2.x(), p2.y()),
+                  PointF(p3.x(), p3.y()), PointF(p4.x(), p4.y()));
+  EXPECT_TRUE(test_quad.IsRectilinear());
+
+  transform.TransformPoint(&p1);
+  transform.TransformPoint(&p2);
+  transform.TransformPoint(&p3);
+  transform.TransformPoint(&p4);
+
+  QuadF transformedQuad(PointF(p1.x(), p1.y()), PointF(p2.x(), p2.y()),
+                        PointF(p3.x(), p3.y()), PointF(p4.x(), p4.y()));
+  return transformedQuad.IsRectilinear();
+}
+
+TEST(XFormTest, Preserves2dAxisAlignment) {
+  static const struct TestCase {
+    SkScalar a;  // row 1, column 1
+    SkScalar b;  // row 1, column 2
+    SkScalar c;  // row 2, column 1
+    SkScalar d;  // row 2, column 2
+    bool expected;
+    bool degenerate;
+  } test_cases[] = {
+      // clang-format off
+      { 3.f, 0.f,
+        0.f, 4.f, true, false },  // basic case
+      { 0.f, 4.f,
+        3.f, 0.f, true, false },  // rotate by 90
+      { 0.f, 0.f,
+        0.f, 4.f, true, true },   // degenerate x
+      { 3.f, 0.f,
+        0.f, 0.f, true, true },   // degenerate y
+      { 0.f, 0.f,
+        3.f, 0.f, true, true },   // degenerate x + rotate by 90
+      { 0.f, 4.f,
+        0.f, 0.f, true, true },   // degenerate y + rotate by 90
+      { 3.f, 4.f,
+        0.f, 0.f, false, true },
+      { 0.f, 0.f,
+        3.f, 4.f, false, true },
+      { 0.f, 3.f,
+        0.f, 4.f, false, true },
+      { 3.f, 0.f,
+        4.f, 0.f, false, true },
+      { 3.f, 4.f,
+        5.f, 0.f, false, false },
+      { 3.f, 4.f,
+        0.f, 5.f, false, false },
+      { 3.f, 0.f,
+        4.f, 5.f, false, false },
+      { 0.f, 3.f,
+        4.f, 5.f, false, false },
+      { 2.f, 3.f,
+        4.f, 5.f, false, false },
+      // clang-format on
+  };
+
+  Transform transform;
+  for (const auto& value : test_cases) {
+    transform.MakeIdentity();
+    transform.matrix().set(0, 0, value.a);
+    transform.matrix().set(0, 1, value.b);
+    transform.matrix().set(1, 0, value.c);
+    transform.matrix().set(1, 1, value.d);
+
+    if (value.expected) {
+      EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+      EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+      if (value.degenerate) {
+        EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+      } else {
+        EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+      }
+    } else {
+      EXPECT_FALSE(EmpiricallyPreserves2dAxisAlignment(transform));
+      EXPECT_FALSE(transform.Preserves2dAxisAlignment());
+      EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+    }
+  }
+
+  // Try the same test cases again, but this time make sure that other matrix
+  // elements (except perspective) have entries, to test that they are ignored.
+  for (const auto& value : test_cases) {
+    transform.MakeIdentity();
+    transform.matrix().set(0, 0, value.a);
+    transform.matrix().set(0, 1, value.b);
+    transform.matrix().set(1, 0, value.c);
+    transform.matrix().set(1, 1, value.d);
+
+    transform.matrix().set(0, 2, 1.f);
+    transform.matrix().set(0, 3, 2.f);
+    transform.matrix().set(1, 2, 3.f);
+    transform.matrix().set(1, 3, 4.f);
+    transform.matrix().set(2, 0, 5.f);
+    transform.matrix().set(2, 1, 6.f);
+    transform.matrix().set(2, 2, 7.f);
+    transform.matrix().set(2, 3, 8.f);
+
+    if (value.expected) {
+      EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+      EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+      if (value.degenerate) {
+        EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+      } else {
+        EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+      }
+    } else {
+      EXPECT_FALSE(EmpiricallyPreserves2dAxisAlignment(transform));
+      EXPECT_FALSE(transform.Preserves2dAxisAlignment());
+      EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+    }
+  }
+
+  // Try the same test cases again, but this time add perspective which is
+  // always assumed to not-preserve axis alignment.
+  for (const auto& value : test_cases) {
+    transform.MakeIdentity();
+    transform.matrix().set(0, 0, value.a);
+    transform.matrix().set(0, 1, value.b);
+    transform.matrix().set(1, 0, value.c);
+    transform.matrix().set(1, 1, value.d);
+
+    transform.matrix().set(0, 2, 1.f);
+    transform.matrix().set(0, 3, 2.f);
+    transform.matrix().set(1, 2, 3.f);
+    transform.matrix().set(1, 3, 4.f);
+    transform.matrix().set(2, 0, 5.f);
+    transform.matrix().set(2, 1, 6.f);
+    transform.matrix().set(2, 2, 7.f);
+    transform.matrix().set(2, 3, 8.f);
+    transform.matrix().set(3, 0, 9.f);
+    transform.matrix().set(3, 1, 10.f);
+    transform.matrix().set(3, 2, 11.f);
+    transform.matrix().set(3, 3, 12.f);
+
+    EXPECT_FALSE(EmpiricallyPreserves2dAxisAlignment(transform));
+    EXPECT_FALSE(transform.Preserves2dAxisAlignment());
+    EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+  }
+
+  // Try a few more practical situations to check precision
+  transform.MakeIdentity();
+  transform.RotateAboutZAxis(90.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutZAxis(180.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutZAxis(270.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutYAxis(90.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutXAxis(90.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutZAxis(90.0);
+  transform.RotateAboutYAxis(90.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutZAxis(90.0);
+  transform.RotateAboutXAxis(90.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutYAxis(90.0);
+  transform.RotateAboutZAxis(90.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutZAxis(45.0);
+  EXPECT_FALSE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_FALSE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  // 3-d case; In 2d after an orthographic projection, this case does
+  // preserve 2d axis alignment. But in 3d, it does not preserve axis
+  // alignment.
+  transform.MakeIdentity();
+  transform.RotateAboutYAxis(45.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.RotateAboutXAxis(45.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  // Perspective cases.
+  transform.MakeIdentity();
+  transform.ApplyPerspectiveDepth(10.0);
+  transform.RotateAboutYAxis(45.0);
+  EXPECT_FALSE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_FALSE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.ApplyPerspectiveDepth(10.0);
+  transform.RotateAboutZAxis(90.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  transform.MakeIdentity();
+  transform.ApplyPerspectiveDepth(-10.0);
+  transform.RotateAboutZAxis(90.0);
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_TRUE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  // To be non-degenerate, the constant contribution to perspective must
+  // be positive.
+
+  // clang-format off
+  transform = Transform(1.0, 0.0, 0.0, 0.0,
+                        0.0, 1.0, 0.0, 0.0,
+                        0.0, 0.0, 1.0, 0.0,
+                        0.0, 0.0, 0.0, -1.0);
+  // clang-format on
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+
+  // clang-format off
+  transform = Transform(2.0, 0.0, 0.0, 0.0,
+                        0.0, 5.0, 0.0, 0.0,
+                        0.0, 0.0, 1.0, 0.0,
+                        0.0, 0.0, 0.0, 0.0);
+  // clang-format on
+  EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
+  EXPECT_TRUE(transform.Preserves2dAxisAlignment());
+  EXPECT_FALSE(transform.NonDegeneratePreserves2dAxisAlignment());
+}
+
+TEST(XFormTest, To2dTranslation) {
+  Vector2dF translation(3.f, 7.f);
+  Transform transform;
+  transform.Translate(translation.x(), translation.y() + 1);
+  EXPECT_NE(translation.ToString(), transform.To2dTranslation().ToString());
+  transform.MakeIdentity();
+  transform.Translate(translation.x(), translation.y());
+  EXPECT_EQ(translation.ToString(), transform.To2dTranslation().ToString());
+}
+
+TEST(XFormTest, TransformRect) {
+  Transform translation;
+  translation.Translate(3.f, 7.f);
+  RectF rect(1.f, 2.f, 3.f, 4.f);
+  RectF expected(4.f, 9.f, 3.f, 4.f);
+  translation.TransformRect(&rect);
+  EXPECT_EQ(expected.ToString(), rect.ToString());
+}
+
+TEST(XFormTest, TransformRectReverse) {
+  Transform translation;
+  translation.Translate(3.f, 7.f);
+  RectF rect(1.f, 2.f, 3.f, 4.f);
+  RectF expected(-2.f, -5.f, 3.f, 4.f);
+  EXPECT_TRUE(translation.TransformRectReverse(&rect));
+  EXPECT_EQ(expected.ToString(), rect.ToString());
+
+  Transform singular;
+  singular.Scale3d(0.f, 0.f, 0.f);
+  EXPECT_FALSE(singular.TransformRectReverse(&rect));
+}
+
+TEST(XFormTest, TransformRRectF) {
+  Transform translation;
+  translation.Translate(-3.f, -7.f);
+  RRectF rrect(1.f, 2.f, 20.f, 25.f, 5.f);
+  RRectF expected(-2.f, -5.f, 20.f, 25.f, 5.f);
+  EXPECT_TRUE(translation.TransformRRectF(&rrect));
+  EXPECT_EQ(expected.ToString(), rrect.ToString());
+
+  skia::Matrix44 rot(skia::Matrix44::kUninitialized_Constructor);
+  rot.set3x3(0, 1, 0, -1, 0, 0, 0, 0, 1);
+  Transform rotation_90_Clock(rot);
+
+  rrect = RRectF(gfx::RectF(0, 0, 20.f, 25.f),
+                 gfx::RoundedCornersF(1.f, 2.f, 3.f, 4.f));
+  expected = RRectF(gfx::RectF(-25.f, 0, 25.f, 20.f),
+                    gfx::RoundedCornersF(4.f, 1.f, 2.f, 3.f));
+  EXPECT_TRUE(rotation_90_Clock.TransformRRectF(&rrect));
+  EXPECT_EQ(expected.ToString(), rrect.ToString());
+
+  Transform scale;
+  scale.Scale(2.f, 2.f);
+  rrect = RRectF(gfx::RectF(0, 0, 20.f, 25.f),
+                 gfx::RoundedCornersF(1.f, 2.f, 3.f, 4.f));
+  expected = RRectF(gfx::RectF(0, 0, 40.f, 50.f),
+                    gfx::RoundedCornersF(2.f, 4.f, 6.f, 8.f));
+  EXPECT_TRUE(scale.TransformRRectF(&rrect));
+  EXPECT_EQ(expected.ToString(), rrect.ToString());
+}
+
+TEST(XFormTest, TransformBox) {
+  Transform translation;
+  translation.Translate3d(3.f, 7.f, 6.f);
+  BoxF box(1.f, 2.f, 3.f, 4.f, 5.f, 6.f);
+  BoxF expected(4.f, 9.f, 9.f, 4.f, 5.f, 6.f);
+  translation.TransformBox(&box);
+  EXPECT_EQ(expected.ToString(), box.ToString());
+}
+
+TEST(XFormTest, TransformBoxReverse) {
+  Transform translation;
+  translation.Translate3d(3.f, 7.f, 6.f);
+  BoxF box(1.f, 2.f, 3.f, 4.f, 5.f, 6.f);
+  BoxF expected(-2.f, -5.f, -3.f, 4.f, 5.f, 6.f);
+  EXPECT_TRUE(translation.TransformBoxReverse(&box));
+  EXPECT_EQ(expected.ToString(), box.ToString());
+
+  Transform singular;
+  singular.Scale3d(0.f, 0.f, 0.f);
+  EXPECT_FALSE(singular.TransformBoxReverse(&box));
+}
+
+TEST(XFormTest, RoundTranslationComponents) {
+  Transform translation;
+  Transform expected;
+
+  translation.RoundTranslationComponents();
+  EXPECT_EQ(expected.ToString(), translation.ToString());
+
+  translation.Translate(1.0f, 1.0f);
+  expected.Translate(1.0f, 1.0f);
+  translation.RoundTranslationComponents();
+  EXPECT_EQ(expected.ToString(), translation.ToString());
+
+  translation.Translate(0.5f, 0.4f);
+  expected.Translate(1.0f, 0.0f);
+  translation.RoundTranslationComponents();
+  EXPECT_EQ(expected.ToString(), translation.ToString());
+
+  // Rounding should only affect 2d translation components.
+  translation.Translate3d(0.f, 0.f, 0.5f);
+  expected.Translate3d(0.f, 0.f, 0.5f);
+  translation.RoundTranslationComponents();
+  EXPECT_EQ(expected.ToString(), translation.ToString());
+}
+
+TEST(XFormTest, BackFaceVisiblilityTolerance) {
+  Transform backface_invisible;
+  backface_invisible.matrix().set(0, 3, 1.f);
+  backface_invisible.matrix().set(3, 0, 1.f);
+  backface_invisible.matrix().set(2, 0, 1.f);
+  backface_invisible.matrix().set(3, 2, 1.f);
+
+  // The transformation matrix has a determinant = 1 and cofactor33 = 0. So,
+  // IsBackFaceVisible should return false.
+  EXPECT_EQ(backface_invisible.matrix().determinant(), 1.f);
+  EXPECT_FALSE(backface_invisible.IsBackFaceVisible());
+
+  // Adding a noise to the transformsation matrix that is within the tolerance
+  // (machine epsilon) should not change the result.
+  float noise = std::numeric_limits<float>::epsilon();
+  backface_invisible.matrix().set(0, 3, 1.f + noise);
+  EXPECT_FALSE(backface_invisible.IsBackFaceVisible());
+
+  // A noise that is more than the tolerance should change the result.
+  backface_invisible.matrix().set(0, 3, 1.f + (2 * noise));
+  EXPECT_TRUE(backface_invisible.IsBackFaceVisible());
+}
+
+}  // namespace
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/transform_util.cc b/ui/gfx/geometry/transform_util.cc
new file mode 100644
index 0000000..224598d
--- /dev/null
+++ b/ui/gfx/geometry/transform_util.cc
@@ -0,0 +1,673 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/transform_util.h"
+
+#include <algorithm>
+#include <cmath>
+#include <string>
+
+#include "base/check.h"
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace gfx {
+
+namespace {
+
+SkScalar Length3(SkScalar v[3]) {
+  double vd[3] = {v[0], v[1], v[2]};
+  return SkDoubleToScalar(
+      std::sqrt(vd[0] * vd[0] + vd[1] * vd[1] + vd[2] * vd[2]));
+}
+
+template <int n>
+SkScalar Dot(const SkScalar* a, const SkScalar* b) {
+  double total = 0.0;
+  for (int i = 0; i < n; ++i)
+    total += a[i] * b[i];
+  return SkDoubleToScalar(total);
+}
+
+template <int n>
+void Combine(SkScalar* out,
+             const SkScalar* a,
+             const SkScalar* b,
+             double scale_a,
+             double scale_b) {
+  for (int i = 0; i < n; ++i)
+    out[i] = SkDoubleToScalar(a[i] * scale_a + b[i] * scale_b);
+}
+
+void Cross3(SkScalar out[3], SkScalar a[3], SkScalar b[3]) {
+  SkScalar x = a[1] * b[2] - a[2] * b[1];
+  SkScalar y = a[2] * b[0] - a[0] * b[2];
+  SkScalar z = a[0] * b[1] - a[1] * b[0];
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+}
+
+SkScalar Round(SkScalar n) {
+  return SkDoubleToScalar(std::floor(double{n} + 0.5));
+}
+
+// Returns false if the matrix cannot be normalized.
+bool Normalize(skia::Matrix44& m) {
+  if (m.get(3, 3) == 0.0)
+    // Cannot normalize.
+    return false;
+
+  SkScalar scale = SK_Scalar1 / m.get(3, 3);
+  for (int i = 0; i < 4; i++)
+    for (int j = 0; j < 4; j++)
+      m.set(i, j, m.get(i, j) * scale);
+
+  return true;
+}
+
+skia::Matrix44 BuildPerspectiveMatrix(const DecomposedTransform& decomp) {
+  skia::Matrix44 matrix(skia::Matrix44::kIdentity_Constructor);
+
+  for (int i = 0; i < 4; i++)
+    matrix.setDouble(3, i, decomp.perspective[i]);
+  return matrix;
+}
+
+skia::Matrix44 BuildTranslationMatrix(const DecomposedTransform& decomp) {
+  skia::Matrix44 matrix(skia::Matrix44::kUninitialized_Constructor);
+  // Implicitly calls matrix.setIdentity()
+  matrix.setTranslate(SkDoubleToScalar(decomp.translate[0]),
+                      SkDoubleToScalar(decomp.translate[1]),
+                      SkDoubleToScalar(decomp.translate[2]));
+  return matrix;
+}
+
+skia::Matrix44 BuildSnappedTranslationMatrix(DecomposedTransform decomp) {
+  decomp.translate[0] = Round(decomp.translate[0]);
+  decomp.translate[1] = Round(decomp.translate[1]);
+  decomp.translate[2] = Round(decomp.translate[2]);
+  return BuildTranslationMatrix(decomp);
+}
+
+skia::Matrix44 BuildRotationMatrix(const DecomposedTransform& decomp) {
+  return Transform(decomp.quaternion).matrix();
+}
+
+skia::Matrix44 BuildSnappedRotationMatrix(const DecomposedTransform& decomp) {
+  // Create snapped rotation.
+  skia::Matrix44 rotation_matrix = BuildRotationMatrix(decomp);
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      SkScalar value = rotation_matrix.get(i, j);
+      // Snap values to -1, 0 or 1.
+      if (value < -0.5f) {
+        value = -1.0f;
+      } else if (value > 0.5f) {
+        value = 1.0f;
+      } else {
+        value = 0.0f;
+      }
+      rotation_matrix.set(i, j, value);
+    }
+  }
+  return rotation_matrix;
+}
+
+skia::Matrix44 BuildSkewMatrix(const DecomposedTransform& decomp) {
+  skia::Matrix44 matrix(skia::Matrix44::kIdentity_Constructor);
+
+  skia::Matrix44 temp(skia::Matrix44::kIdentity_Constructor);
+  if (decomp.skew[2]) {
+    temp.setDouble(1, 2, decomp.skew[2]);
+    matrix.preConcat(temp);
+  }
+
+  if (decomp.skew[1]) {
+    temp.setDouble(1, 2, 0);
+    temp.setDouble(0, 2, decomp.skew[1]);
+    matrix.preConcat(temp);
+  }
+
+  if (decomp.skew[0]) {
+    temp.setDouble(0, 2, 0);
+    temp.setDouble(0, 1, decomp.skew[0]);
+    matrix.preConcat(temp);
+  }
+  return matrix;
+}
+
+skia::Matrix44 BuildScaleMatrix(const DecomposedTransform& decomp) {
+  skia::Matrix44 matrix(skia::Matrix44::kUninitialized_Constructor);
+  matrix.setScale(SkDoubleToScalar(decomp.scale[0]),
+                  SkDoubleToScalar(decomp.scale[1]),
+                  SkDoubleToScalar(decomp.scale[2]));
+  return matrix;
+}
+
+skia::Matrix44 BuildSnappedScaleMatrix(DecomposedTransform decomp) {
+  decomp.scale[0] = Round(decomp.scale[0]);
+  decomp.scale[1] = Round(decomp.scale[1]);
+  decomp.scale[2] = Round(decomp.scale[2]);
+  return BuildScaleMatrix(decomp);
+}
+
+Transform ComposeTransform(const skia::Matrix44& perspective,
+                           const skia::Matrix44& translation,
+                           const skia::Matrix44& rotation,
+                           const skia::Matrix44& skew,
+                           const skia::Matrix44& scale) {
+  skia::Matrix44 matrix(skia::Matrix44::kIdentity_Constructor);
+
+  matrix.preConcat(perspective);
+  matrix.preConcat(translation);
+  matrix.preConcat(rotation);
+  matrix.preConcat(skew);
+  matrix.preConcat(scale);
+
+  Transform to_return;
+  to_return.matrix() = matrix;
+  return to_return;
+}
+
+bool CheckViewportPointMapsWithinOnePixel(const Point& point,
+                                          const Transform& transform) {
+  auto point_original = Point3F(PointF(point));
+  auto point_transformed = Point3F(PointF(point));
+
+  // Can't use TransformRect here since it would give us the axis-aligned
+  // bounding rect of the 4 points in the initial rectable which is not what we
+  // want.
+  transform.TransformPoint(&point_transformed);
+
+  if ((point_transformed - point_original).Length() > 1.f) {
+    // The changed distance should not be more than 1 pixel.
+    return false;
+  }
+  return true;
+}
+
+bool CheckTransformsMapsIntViewportWithinOnePixel(const Rect& viewport,
+                                                  const Transform& original,
+                                                  const Transform& snapped) {
+  Transform original_inv(Transform::kSkipInitialization);
+  bool invertible = true;
+  invertible &= original.GetInverse(&original_inv);
+  DCHECK(invertible) << "Non-invertible transform, cannot snap.";
+
+  Transform combined = snapped * original_inv;
+
+  return CheckViewportPointMapsWithinOnePixel(viewport.origin(), combined) &&
+         CheckViewportPointMapsWithinOnePixel(viewport.top_right(), combined) &&
+         CheckViewportPointMapsWithinOnePixel(viewport.bottom_left(),
+                                              combined) &&
+         CheckViewportPointMapsWithinOnePixel(viewport.bottom_right(),
+                                              combined);
+}
+
+bool Is2dTransform(const Transform& transform) {
+  const skia::Matrix44 matrix = transform.matrix();
+  if (matrix.hasPerspective())
+    return false;
+
+  return matrix.get(2, 0) == 0 && matrix.get(2, 1) == 0 &&
+         matrix.get(0, 2) == 0 && matrix.get(1, 2) == 0 &&
+         matrix.get(2, 2) == 1 && matrix.get(3, 2) == 0 &&
+         matrix.get(2, 3) == 0;
+}
+
+bool Decompose2DTransform(DecomposedTransform* decomp,
+                          const Transform& transform) {
+  if (!Is2dTransform(transform)) {
+    return false;
+  }
+
+  const skia::Matrix44 matrix = transform.matrix();
+  double m11 = matrix.getDouble(0, 0);
+  double m21 = matrix.getDouble(0, 1);
+  double m12 = matrix.getDouble(1, 0);
+  double m22 = matrix.getDouble(1, 1);
+
+  double determinant = m11 * m22 - m12 * m21;
+  // Test for matrix being singular.
+  if (determinant == 0) {
+    return false;
+  }
+
+  // Translation transform.
+  // [m11 m21 0 m41]    [1 0 0 Tx] [m11 m21 0 0]
+  // [m12 m22 0 m42]  = [0 1 0 Ty] [m12 m22 0 0]
+  // [ 0   0  1  0 ]    [0 0 1 0 ] [ 0   0  1 0]
+  // [ 0   0  0  1 ]    [0 0 0 1 ] [ 0   0  0 1]
+  decomp->translate[0] = matrix.get(0, 3);
+  decomp->translate[1] = matrix.get(1, 3);
+
+  // For the remainder of the decomposition process, we can focus on the upper
+  // 2x2 submatrix
+  // [m11 m21] = [cos(R) -sin(R)] [1 K] [Sx 0 ]
+  // [m12 m22]   [sin(R)  cos(R)] [0 1] [0  Sy]
+  //           = [Sx*cos(R) Sy*(K*cos(R) - sin(R))]
+  //             [Sx*sin(R) Sy*(K*sin(R) + cos(R))]
+
+  // Determine sign of the x and y scale.
+  if (determinant < 0) {
+    // If the determinant is negative, we need to flip either the x or y scale.
+    // Flipping both is equivalent to rotating by 180 degrees.
+    if (m11 < m22) {
+      decomp->scale[0] *= -1;
+    } else {
+      decomp->scale[1] *= -1;
+    }
+  }
+
+  // X Scale.
+  // m11^2 + m12^2 = Sx^2*(cos^2(R) + sin^2(R)) = Sx^2.
+  // Sx = +/-sqrt(m11^2 + m22^2)
+  decomp->scale[0] *= sqrt(m11 * m11 + m12 * m12);
+  m11 /= decomp->scale[0];
+  m12 /= decomp->scale[0];
+
+  // Post normalization, the submatrix is now of the form:
+  // [m11 m21] = [cos(R)  Sy*(K*cos(R) - sin(R))]
+  // [m12 m22]   [sin(R)  Sy*(K*sin(R) + cos(R))]
+
+  // XY Shear.
+  // m11 * m21 + m12 * m22 = Sy*K*cos^2(R) - Sy*sin(R)*cos(R) +
+  //                         Sy*K*sin^2(R) + Sy*cos(R)*sin(R)
+  //                       = Sy*K
+  double scaledShear = m11 * m21 + m12 * m22;
+  m21 -= m11 * scaledShear;
+  m22 -= m12 * scaledShear;
+
+  // Post normalization, the submatrix is now of the form:
+  // [m11 m21] = [cos(R)  -Sy*sin(R)]
+  // [m12 m22]   [sin(R)   Sy*cos(R)]
+
+  // Y Scale.
+  // Similar process to determining x-scale.
+  decomp->scale[1] *= sqrt(m21 * m21 + m22 * m22);
+  m21 /= decomp->scale[1];
+  m22 /= decomp->scale[1];
+  decomp->skew[0] = scaledShear / decomp->scale[1];
+
+  // Rotation transform.
+  // [1-2(yy+zz)  2(xy-zw)    2(xz+yw) ]   [cos(R) -sin(R)  0]
+  // [2(xy+zw)   1-2(xx+zz)   2(yz-xw) ] = [sin(R)  cos(R)  0]
+  // [2(xz-yw)    2*(yz+xw)  1-2(xx+yy)]   [  0       0     1]
+  // Comparing terms, we can conclude that x = y = 0.
+  // [1-2zz   -2zw  0]   [cos(R) -sin(R)  0]
+  // [ 2zw   1-2zz  0] = [sin(R)  cos(R)  0]
+  // [  0     0     1]   [  0       0     1]
+  // cos(R) = 1 - 2*z^2
+  // From the double angle formula: cos(2a) = 1 - 2 sin(a)^2
+  // cos(R) = 1 - 2*sin(R/2)^2 = 1 - 2*z^2 ==> z = sin(R/2)
+  // sin(R) = 2*z*w
+  // But sin(2a) = 2 sin(a) cos(a)
+  // sin(R) = 2 sin(R/2) cos(R/2) = 2*z*w ==> w = cos(R/2)
+  double angle = atan2(m12, m11);
+  decomp->quaternion.set_x(0);
+  decomp->quaternion.set_y(0);
+  decomp->quaternion.set_z(sin(0.5 * angle));
+  decomp->quaternion.set_w(cos(0.5 * angle));
+
+  return true;
+}
+
+}  // namespace
+
+Transform GetScaleTransform(const Point& anchor, float scale) {
+  Transform transform;
+  transform.Translate(anchor.x() * (1 - scale), anchor.y() * (1 - scale));
+  transform.Scale(scale, scale);
+  return transform;
+}
+
+DecomposedTransform::DecomposedTransform() {
+  translate[0] = translate[1] = translate[2] = 0.0;
+  scale[0] = scale[1] = scale[2] = 1.0;
+  skew[0] = skew[1] = skew[2] = 0.0;
+  perspective[0] = perspective[1] = perspective[2] = 0.0;
+  perspective[3] = 1.0;
+}
+
+DecomposedTransform BlendDecomposedTransforms(const DecomposedTransform& to,
+                                              const DecomposedTransform& from,
+                                              double progress) {
+  DecomposedTransform out;
+  double scalea = progress;
+  double scaleb = 1.0 - progress;
+  Combine<3>(out.translate, to.translate, from.translate, scalea, scaleb);
+  Combine<3>(out.scale, to.scale, from.scale, scalea, scaleb);
+  Combine<3>(out.skew, to.skew, from.skew, scalea, scaleb);
+  Combine<4>(out.perspective, to.perspective, from.perspective, scalea, scaleb);
+  out.quaternion = from.quaternion.Slerp(to.quaternion, progress);
+  return out;
+}
+
+// Taken from http://www.w3.org/TR/css3-transforms/.
+// TODO(crbug/937296): This implementation is virtually identical to the
+// implementation in blink::TransformationMatrix with the main difference being
+// the representation of the underlying matrix. These implementations should be
+// consolidated.
+bool DecomposeTransform(DecomposedTransform* decomp,
+                        const Transform& transform) {
+  if (!decomp)
+    return false;
+
+  if (Decompose2DTransform(decomp, transform))
+    return true;
+
+  // We'll operate on a copy of the matrix.
+  skia::Matrix44 matrix = transform.matrix();
+
+  // If we cannot normalize the matrix, then bail early as we cannot decompose.
+  if (!Normalize(matrix))
+    return false;
+
+  skia::Matrix44 perspectiveMatrix = matrix;
+
+  for (int i = 0; i < 3; ++i)
+    perspectiveMatrix.set(3, i, 0.0);
+
+  perspectiveMatrix.set(3, 3, 1.0);
+
+  // If the perspective matrix is not invertible, we are also unable to
+  // decompose, so we'll bail early. Constant taken from skia::Matrix44::invert.
+  if (std::abs(perspectiveMatrix.determinant()) < 1e-8)
+    return false;
+
+  if (matrix.get(3, 0) != 0.0 || matrix.get(3, 1) != 0.0 ||
+      matrix.get(3, 2) != 0.0) {
+    // rhs is the right hand side of the equation.
+    SkScalar rhs[4] = {matrix.get(3, 0), matrix.get(3, 1), matrix.get(3, 2),
+                       matrix.get(3, 3)};
+
+    // Solve the equation by inverting perspectiveMatrix and multiplying
+    // rhs by the inverse.
+    skia::Matrix44 inversePerspectiveMatrix(
+        skia::Matrix44::kUninitialized_Constructor);
+    if (!perspectiveMatrix.invert(&inversePerspectiveMatrix))
+      return false;
+
+    skia::Matrix44 transposedInversePerspectiveMatrix =
+        inversePerspectiveMatrix;
+
+    transposedInversePerspectiveMatrix.transpose();
+    transposedInversePerspectiveMatrix.mapScalars(rhs);
+
+    for (int i = 0; i < 4; ++i)
+      decomp->perspective[i] = rhs[i];
+
+  } else {
+    // No perspective.
+    for (int i = 0; i < 3; ++i)
+      decomp->perspective[i] = 0.0;
+    decomp->perspective[3] = 1.0;
+  }
+
+  for (int i = 0; i < 3; i++)
+    decomp->translate[i] = matrix.get(i, 3);
+
+  // Copy of matrix is stored in column major order to facilitate column-level
+  // operations.
+  SkScalar column[3][3];
+  for (int i = 0; i < 3; i++)
+    for (int j = 0; j < 3; ++j)
+      column[i][j] = matrix.get(j, i);
+
+  // Compute X scale factor and normalize first column.
+  decomp->scale[0] = Length3(column[0]);
+  if (decomp->scale[0] != 0.0) {
+    column[0][0] /= decomp->scale[0];
+    column[0][1] /= decomp->scale[0];
+    column[0][2] /= decomp->scale[0];
+  }
+
+  // Compute XY shear factor and make 2nd column orthogonal to 1st.
+  decomp->skew[0] = Dot<3>(column[0], column[1]);
+  Combine<3>(column[1], column[1], column[0], 1.0, -decomp->skew[0]);
+
+  // Now, compute Y scale and normalize 2nd column.
+  decomp->scale[1] = Length3(column[1]);
+  if (decomp->scale[1] != 0.0) {
+    column[1][0] /= decomp->scale[1];
+    column[1][1] /= decomp->scale[1];
+    column[1][2] /= decomp->scale[1];
+  }
+
+  decomp->skew[0] /= decomp->scale[1];
+
+  // Compute XZ and YZ shears, orthogonalize the 3rd column.
+  decomp->skew[1] = Dot<3>(column[0], column[2]);
+  Combine<3>(column[2], column[2], column[0], 1.0, -decomp->skew[1]);
+  decomp->skew[2] = Dot<3>(column[1], column[2]);
+  Combine<3>(column[2], column[2], column[1], 1.0, -decomp->skew[2]);
+
+  // Next, get Z scale and normalize the 3rd column.
+  decomp->scale[2] = Length3(column[2]);
+  if (decomp->scale[2] != 0.0) {
+    column[2][0] /= decomp->scale[2];
+    column[2][1] /= decomp->scale[2];
+    column[2][2] /= decomp->scale[2];
+  }
+
+  decomp->skew[1] /= decomp->scale[2];
+  decomp->skew[2] /= decomp->scale[2];
+
+  // At this point, the matrix is orthonormal.
+  // Check for a coordinate system flip.  If the determinant
+  // is -1, then negate the matrix and the scaling factors.
+  // TODO(kevers): This is inconsistent from the 2D specification, in which
+  // only 1 axis is flipped when the determinant is negative. Verify if it is
+  // correct to flip all of the scales and matrix elements, as this introduces
+  // rotation for the simple case of a single axis scale inversion.
+  SkScalar pdum3[3];
+  Cross3(pdum3, column[1], column[2]);
+  if (Dot<3>(column[0], pdum3) < 0) {
+    for (int i = 0; i < 3; i++) {
+      decomp->scale[i] *= -1.0;
+      for (int j = 0; j < 3; ++j)
+        column[i][j] *= -1.0;
+    }
+  }
+
+  // See https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion.
+  // Note: deviating from spec (http://www.w3.org/TR/css3-transforms/)
+  // which has a degenerate case of zero off-diagonal elements in the
+  // orthonormal matrix, which leads to errors in determining the sign
+  // of the quaternions.
+  double q_xx = column[0][0];
+  double q_xy = column[1][0];
+  double q_xz = column[2][0];
+  double q_yx = column[0][1];
+  double q_yy = column[1][1];
+  double q_yz = column[2][1];
+  double q_zx = column[0][2];
+  double q_zy = column[1][2];
+  double q_zz = column[2][2];
+
+  double r, s, t, x, y, z, w;
+  t = q_xx + q_yy + q_zz;
+  if (t > 0) {
+    r = std::sqrt(1.0 + t);
+    s = 0.5 / r;
+    w = 0.5 * r;
+    x = (q_zy - q_yz) * s;
+    y = (q_xz - q_zx) * s;
+    z = (q_yx - q_xy) * s;
+  } else if (q_xx > q_yy && q_xx > q_zz) {
+    r = std::sqrt(1.0 + q_xx - q_yy - q_zz);
+    s = 0.5 / r;
+    x = 0.5 * r;
+    y = (q_xy + q_yx) * s;
+    z = (q_xz + q_zx) * s;
+    w = (q_zy - q_yz) * s;
+  } else if (q_yy > q_zz) {
+    r = std::sqrt(1.0 - q_xx + q_yy - q_zz);
+    s = 0.5 / r;
+    x = (q_xy + q_yx) * s;
+    y = 0.5 * r;
+    z = (q_yz + q_zy) * s;
+    w = (q_xz - q_zx) * s;
+  } else {
+    r = std::sqrt(1.0 - q_xx - q_yy + q_zz);
+    s = 0.5 / r;
+    x = (q_xz + q_zx) * s;
+    y = (q_yz + q_zy) * s;
+    z = 0.5 * r;
+    w = (q_yx - q_xy) * s;
+  }
+
+  decomp->quaternion.set_x(SkDoubleToScalar(x));
+  decomp->quaternion.set_y(SkDoubleToScalar(y));
+  decomp->quaternion.set_z(SkDoubleToScalar(z));
+  decomp->quaternion.set_w(SkDoubleToScalar(w));
+
+  return true;
+}
+
+// Taken from http://www.w3.org/TR/css3-transforms/.
+Transform ComposeTransform(const DecomposedTransform& decomp) {
+  skia::Matrix44 perspective = BuildPerspectiveMatrix(decomp);
+  skia::Matrix44 translation = BuildTranslationMatrix(decomp);
+  skia::Matrix44 rotation = BuildRotationMatrix(decomp);
+  skia::Matrix44 skew = BuildSkewMatrix(decomp);
+  skia::Matrix44 scale = BuildScaleMatrix(decomp);
+
+  return ComposeTransform(perspective, translation, rotation, skew, scale);
+}
+
+bool SnapTransform(Transform* out,
+                   const Transform& transform,
+                   const Rect& viewport) {
+  DecomposedTransform decomp;
+  DecomposeTransform(&decomp, transform);
+
+  skia::Matrix44 rotation_matrix = BuildSnappedRotationMatrix(decomp);
+  skia::Matrix44 translation = BuildSnappedTranslationMatrix(decomp);
+  skia::Matrix44 scale = BuildSnappedScaleMatrix(decomp);
+
+  // Rebuild matrices for other unchanged components.
+  skia::Matrix44 perspective = BuildPerspectiveMatrix(decomp);
+
+  // Completely ignore the skew.
+  skia::Matrix44 skew(skia::Matrix44::kIdentity_Constructor);
+
+  // Get full transform.
+  Transform snapped =
+      ComposeTransform(perspective, translation, rotation_matrix, skew, scale);
+
+  // Verify that viewport is not moved unnaturally.
+  bool snappable = CheckTransformsMapsIntViewportWithinOnePixel(
+      viewport, transform, snapped);
+  if (snappable) {
+    *out = snapped;
+  }
+  return snappable;
+}
+
+Transform TransformAboutPivot(const Point& pivot, const Transform& transform) {
+  Transform result;
+  result.Translate(pivot.x(), pivot.y());
+  result.PreconcatTransform(transform);
+  result.Translate(-pivot.x(), -pivot.y());
+  return result;
+}
+
+Transform TransformBetweenRects(const RectF& src, const RectF& dst) {
+  DCHECK(!src.IsEmpty());
+  Transform result;
+  result.Translate(dst.origin() - src.origin());
+  result.Scale(dst.width() / src.width(), dst.height() / src.height());
+  return result;
+}
+
+std::string DecomposedTransform::ToString() const {
+  return base::StringPrintf(
+      "translate: %+0.4f %+0.4f %+0.4f\n"
+      "scale: %+0.4f %+0.4f %+0.4f\n"
+      "skew: %+0.4f %+0.4f %+0.4f\n"
+      "perspective: %+0.4f %+0.4f %+0.4f %+0.4f\n"
+      "quaternion: %+0.4f %+0.4f %+0.4f %+0.4f\n",
+      translate[0], translate[1], translate[2], scale[0], scale[1], scale[2],
+      skew[0], skew[1], skew[2], perspective[0], perspective[1], perspective[2],
+      perspective[3], quaternion.x(), quaternion.y(), quaternion.z(),
+      quaternion.w());
+}
+
+Transform OrthoProjectionMatrix(float left,
+                                float right,
+                                float bottom,
+                                float top) {
+  // Use the standard formula to map the clipping frustum to the cube from
+  // [-1, -1, -1] to [1, 1, 1].
+  float delta_x = right - left;
+  float delta_y = top - bottom;
+  Transform proj;
+  if (!delta_x || !delta_y)
+    return proj;
+  proj.matrix().set(0, 0, 2.0f / delta_x);
+  proj.matrix().set(0, 3, -(right + left) / delta_x);
+  proj.matrix().set(1, 1, 2.0f / delta_y);
+  proj.matrix().set(1, 3, -(top + bottom) / delta_y);
+
+  // Z component of vertices is always set to zero as we don't use the depth
+  // buffer while drawing.
+  proj.matrix().set(2, 2, 0);
+
+  return proj;
+}
+
+Transform WindowMatrix(int x, int y, int width, int height) {
+  Transform canvas;
+
+  // Map to window position and scale up to pixel coordinates.
+  canvas.Translate3d(x, y, 0);
+  canvas.Scale3d(width, height, 0);
+
+  // Map from ([-1, -1] to [1, 1]) -> ([0, 0] to [1, 1])
+  canvas.Translate3d(0.5, 0.5, 0.5);
+  canvas.Scale3d(0.5, 0.5, 0.5);
+
+  return canvas;
+}
+
+static inline bool NearlyZero(double value) {
+  return std::abs(value) < std::numeric_limits<double>::epsilon();
+}
+
+static inline float ScaleOnAxis(double a, double b, double c) {
+  if (NearlyZero(b) && NearlyZero(c))
+    return std::abs(a);
+  if (NearlyZero(a) && NearlyZero(c))
+    return std::abs(b);
+  if (NearlyZero(a) && NearlyZero(b))
+    return std::abs(c);
+
+  // Do the sqrt as a double to not lose precision.
+  return static_cast<float>(std::sqrt(a * a + b * b + c * c));
+}
+
+Vector2dF ComputeTransform2dScaleComponents(const Transform& transform,
+                                            float fallback_value) {
+  if (transform.HasPerspective())
+    return Vector2dF(fallback_value, fallback_value);
+  float x_scale = ScaleOnAxis(transform.matrix().getDouble(0, 0),
+                              transform.matrix().getDouble(1, 0),
+                              transform.matrix().getDouble(2, 0));
+  float y_scale = ScaleOnAxis(transform.matrix().getDouble(0, 1),
+                              transform.matrix().getDouble(1, 1),
+                              transform.matrix().getDouble(2, 1));
+  return Vector2dF(x_scale, y_scale);
+}
+
+float ComputeApproximateMaxScale(const Transform& transform) {
+  RectF unit(0.f, 0.f, 1.f, 1.f);
+  transform.TransformRect(&unit);
+  return std::max(unit.width(), unit.height());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/transform_util.h b/ui/gfx/geometry/transform_util.h
new file mode 100644
index 0000000..235c8e1
--- /dev/null
+++ b/ui/gfx/geometry/transform_util.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_TRANSFORM_UTIL_H_
+#define UI_GFX_GEOMETRY_TRANSFORM_UTIL_H_
+
+#include "ui/gfx/geometry/geometry_skia_export.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/quaternion.h"
+#include "ui/gfx/geometry/transform.h"
+
+namespace gfx {
+
+class Rect;
+class RectF;
+
+// Returns a scale transform at |anchor| point.
+GEOMETRY_SKIA_EXPORT Transform GetScaleTransform(const Point& anchor,
+                                                 float scale);
+
+// Contains the components of a factored transform. These components may be
+// blended and recomposed.
+struct GEOMETRY_SKIA_EXPORT DecomposedTransform {
+  // The default constructor initializes the components in such a way that
+  // if used with Compose below, will produce the identity transform.
+  DecomposedTransform();
+
+  SkScalar translate[3];
+  SkScalar scale[3];
+  SkScalar skew[3];
+  SkScalar perspective[4];
+  Quaternion quaternion;
+
+  std::string ToString() const;
+
+  // Copy and assign are allowed.
+};
+
+// Interpolates the decomposed components |to| with |from| using the
+// routines described in http://www.w3.org/TR/css3-3d-transform/.
+// |progress| is in the range [0, 1]. If 0 we will return |from|, if 1, we will
+// return |to|.
+GEOMETRY_SKIA_EXPORT DecomposedTransform
+BlendDecomposedTransforms(const DecomposedTransform& to,
+                          const DecomposedTransform& from,
+                          double progress);
+
+// Decomposes this transform into its translation, scale, skew, perspective,
+// and rotation components following the routines detailed in this spec:
+// http://www.w3.org/TR/css3-3d-transforms/.
+GEOMETRY_SKIA_EXPORT bool DecomposeTransform(DecomposedTransform* out,
+                                             const Transform& transform);
+
+// Composes a transform from the given translation, scale, skew, perspective,
+// and rotation components following the routines detailed in this spec:
+// http://www.w3.org/TR/css3-3d-transforms/.
+GEOMETRY_SKIA_EXPORT Transform
+ComposeTransform(const DecomposedTransform& decomp);
+
+GEOMETRY_SKIA_EXPORT bool SnapTransform(Transform* out,
+                                        const Transform& transform,
+                                        const Rect& viewport);
+
+// Calculates a transform with a transformed origin. The resulting transform is
+// created by composing P * T * P^-1 where P is a constant transform to the new
+// origin.
+GEOMETRY_SKIA_EXPORT Transform TransformAboutPivot(const Point& pivot,
+                                                   const Transform& transform);
+
+// Calculates a transform which would transform |src| to |dst|.
+GEOMETRY_SKIA_EXPORT Transform TransformBetweenRects(const RectF& src,
+                                                     const RectF& dst);
+
+// Generates projection matrix and returns it as a Transform.
+GEOMETRY_SKIA_EXPORT Transform OrthoProjectionMatrix(float left,
+                                                     float right,
+                                                     float bottom,
+                                                     float top);
+
+// Generates window matrix and returns it as a Transform.
+GEOMETRY_SKIA_EXPORT Transform WindowMatrix(int x,
+                                            int y,
+                                            int width,
+                                            int height);
+
+GEOMETRY_SKIA_EXPORT Vector2dF
+ComputeTransform2dScaleComponents(const Transform& transform,
+                                  float fallback_value);
+
+// Returns an approximate max scale value of the transform even if it has
+// perspective. Prefer to use ComputeTransform2dScaleComponents if there is no
+// perspective, since it can produce more accurate results.
+GEOMETRY_SKIA_EXPORT
+float ComputeApproximateMaxScale(const Transform& transform);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_TRANSFORM_UTIL_H_
diff --git a/ui/gfx/geometry/transform_util_unittest.cc b/ui/gfx/geometry/transform_util_unittest.cc
new file mode 100644
index 0000000..87530dd
--- /dev/null
+++ b/ui/gfx/geometry/transform_util_unittest.cc
@@ -0,0 +1,352 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/transform_util.h"
+
+#include <stddef.h>
+
+#include "base/numerics/math_constants.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace gfx {
+namespace {
+
+#define EXPECT_APPROX_EQ(val1, val2) EXPECT_NEAR(val1, val2, 1e-6);
+
+TEST(TransformUtilTest, GetScaleTransform) {
+  const Point kAnchor(20, 40);
+  const float kScale = 0.5f;
+
+  Transform scale = GetScaleTransform(kAnchor, kScale);
+
+  const int kOffset = 10;
+  for (int sign_x = -1; sign_x <= 1; ++sign_x) {
+    for (int sign_y = -1; sign_y <= 1; ++sign_y) {
+      Point test(kAnchor.x() + sign_x * kOffset,
+                 kAnchor.y() + sign_y * kOffset);
+      scale.TransformPoint(&test);
+
+      EXPECT_EQ(Point(kAnchor.x() + sign_x * kOffset * kScale,
+                      kAnchor.y() + sign_y * kOffset * kScale),
+                test);
+    }
+  }
+}
+
+TEST(TransformUtilTest, SnapRotation) {
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+  transform.RotateAboutZAxis(89.99);
+
+  Rect viewport(1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+
+  EXPECT_TRUE(snapped) << "Viewport should snap for this rotation.";
+}
+
+TEST(TransformUtilTest, SnapRotationDistantViewport) {
+  const int kOffset = 5000;
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+
+  transform.RotateAboutZAxis(89.99);
+
+  Rect viewport(kOffset, kOffset, 1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+
+  EXPECT_FALSE(snapped) << "Distant viewport shouldn't snap by more than 1px.";
+}
+
+TEST(TransformUtilTest, NoSnapRotation) {
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+  const int kOffset = 5000;
+
+  transform.RotateAboutZAxis(89.9);
+
+  Rect viewport(kOffset, kOffset, 1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+
+  EXPECT_FALSE(snapped) << "Viewport should not snap for this rotation.";
+}
+
+// Translations should always be snappable, the most we would move is 0.5
+// pixels towards either direction to the nearest value in each component.
+TEST(TransformUtilTest, SnapTranslation) {
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+
+  transform.Translate3d(SkDoubleToScalar(1.01), SkDoubleToScalar(1.99),
+                        SkDoubleToScalar(3.0));
+
+  Rect viewport(1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+
+  EXPECT_TRUE(snapped) << "Viewport should snap for this translation.";
+}
+
+TEST(TransformUtilTest, SnapTranslationDistantViewport) {
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+  const int kOffset = 5000;
+
+  transform.Translate3d(SkDoubleToScalar(1.01), SkDoubleToScalar(1.99),
+                        SkDoubleToScalar(3.0));
+
+  Rect viewport(kOffset, kOffset, 1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+
+  EXPECT_TRUE(snapped)
+      << "Distant viewport should still snap by less than 1px.";
+}
+
+TEST(TransformUtilTest, SnapScale) {
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+
+  transform.Scale3d(SkDoubleToScalar(5.0), SkDoubleToScalar(2.00001),
+                    SkDoubleToScalar(1.0));
+  Rect viewport(1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+
+  EXPECT_TRUE(snapped) << "Viewport should snap for this scaling.";
+}
+
+TEST(TransformUtilTest, NoSnapScale) {
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+
+  transform.Scale3d(SkDoubleToScalar(5.0), SkDoubleToScalar(2.1),
+                    SkDoubleToScalar(1.0));
+  Rect viewport(1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+
+  EXPECT_FALSE(snapped) << "Viewport shouldn't snap for this scaling.";
+}
+
+TEST(TransformUtilTest, SnapCompositeTransform) {
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+
+  transform.Translate3d(SkDoubleToScalar(30.5), SkDoubleToScalar(20.0),
+                        SkDoubleToScalar(10.1));
+  transform.RotateAboutZAxis(89.99);
+  transform.Scale3d(SkDoubleToScalar(1.0), SkDoubleToScalar(3.00001),
+                    SkDoubleToScalar(2.0));
+
+  Rect viewport(1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+  ASSERT_TRUE(snapped) << "Viewport should snap all components.";
+
+  Point3F point;
+
+  point = Point3F(PointF(viewport.origin()));
+  result.TransformPoint(&point);
+  EXPECT_EQ(Point3F(31.f, 20.f, 10.f), point) << "Transformed origin";
+
+  point = Point3F(PointF(viewport.top_right()));
+  result.TransformPoint(&point);
+  EXPECT_EQ(Point3F(31.f, 1940.f, 10.f), point) << "Transformed top-right";
+
+  point = Point3F(PointF(viewport.bottom_left()));
+  result.TransformPoint(&point);
+  EXPECT_EQ(Point3F(-3569.f, 20.f, 10.f), point) << "Transformed bottom-left";
+
+  point = Point3F(PointF(viewport.bottom_right()));
+  result.TransformPoint(&point);
+  EXPECT_EQ(Point3F(-3569.f, 1940.f, 10.f), point)
+      << "Transformed bottom-right";
+}
+
+TEST(TransformUtilTest, NoSnapSkewedCompositeTransform) {
+  Transform result(Transform::kSkipInitialization);
+  Transform transform;
+
+  transform.RotateAboutZAxis(89.99);
+  transform.Scale3d(SkDoubleToScalar(1.0), SkDoubleToScalar(3.00001),
+                    SkDoubleToScalar(2.0));
+  transform.Translate3d(SkDoubleToScalar(30.5), SkDoubleToScalar(20.0),
+                        SkDoubleToScalar(10.1));
+  transform.Skew(20.0, 0.0);
+  Rect viewport(1920, 1200);
+  bool snapped = SnapTransform(&result, transform, viewport);
+  EXPECT_FALSE(snapped) << "Skewed viewport should not snap.";
+}
+
+TEST(TransformUtilTest, TransformAboutPivot) {
+  Transform transform;
+  transform.Scale(3, 4);
+  transform = TransformAboutPivot(Point(7, 8), transform);
+
+  Point point;
+
+  point = Point(0, 0);
+  transform.TransformPoint(&point);
+  EXPECT_EQ(Point(-14, -24).ToString(), point.ToString());
+
+  point = Point(1, 1);
+  transform.TransformPoint(&point);
+  EXPECT_EQ(Point(-11, -20).ToString(), point.ToString());
+}
+
+TEST(TransformUtilTest, BlendOppositeQuaternions) {
+  DecomposedTransform first;
+  DecomposedTransform second;
+  second.quaternion.set_w(-second.quaternion.w());
+
+  DecomposedTransform result = BlendDecomposedTransforms(first, second, 0.25);
+
+  EXPECT_TRUE(std::isfinite(result.quaternion.x()));
+  EXPECT_TRUE(std::isfinite(result.quaternion.y()));
+  EXPECT_TRUE(std::isfinite(result.quaternion.z()));
+  EXPECT_TRUE(std::isfinite(result.quaternion.w()));
+
+  EXPECT_FALSE(std::isnan(result.quaternion.x()));
+  EXPECT_FALSE(std::isnan(result.quaternion.y()));
+  EXPECT_FALSE(std::isnan(result.quaternion.z()));
+  EXPECT_FALSE(std::isnan(result.quaternion.w()));
+}
+
+double ComputeDecompRecompError(const Transform& transform) {
+  DecomposedTransform decomp;
+  DecomposeTransform(&decomp, transform);
+  Transform composed = ComposeTransform(decomp);
+
+  float expected[16];
+  float actual[16];
+  transform.matrix().asRowMajorf(expected);
+  composed.matrix().asRowMajorf(actual);
+  double sse = 0;
+  for (int i = 0; i < 16; i++) {
+    double diff = expected[i] - actual[i];
+    sse += diff * diff;
+  }
+  return sse;
+}
+
+TEST(TransformUtilTest, RoundTripTest) {
+  // rotateZ(90deg)
+  EXPECT_APPROX_EQ(0, ComputeDecompRecompError(Transform(0, 1, -1, 0, 0, 0)));
+
+  // rotateZ(180deg)
+  // Edge case where w = 0.
+  EXPECT_APPROX_EQ(0, ComputeDecompRecompError(Transform(-1, 0, 0, -1, 0, 0)));
+
+  // rotateX(90deg) rotateY(90deg) rotateZ(90deg)
+  // [1  0   0][ 0 0 1][0 -1 0]   [0 0 1][0 -1 0]   [0  0 1]
+  // [0  0  -1][ 0 1 0][1  0 0] = [1 0 0][1  0 0] = [0 -1 0]
+  // [0  1   0][-1 0 0][0  0 1]   [0 1 0][0  0 1]   [1  0 0]
+  // This test case leads to Gimbal lock when using Euler angles.
+  EXPECT_APPROX_EQ(0, ComputeDecompRecompError(Transform(
+                          0, 0, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1)));
+
+  // Quaternion matrices with 0 off-diagonal elements, and negative trace.
+  // Stress tests handling of degenerate cases in computing quaternions.
+  // Validates fix for https://crbug.com/647554.
+  EXPECT_APPROX_EQ(0, ComputeDecompRecompError(Transform(1, 1, 1, 0, 0, 0)));
+  EXPECT_APPROX_EQ(0, ComputeDecompRecompError(Transform(
+                          -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)));
+  EXPECT_APPROX_EQ(0, ComputeDecompRecompError(Transform(
+                          1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)));
+  EXPECT_APPROX_EQ(0, ComputeDecompRecompError(Transform(
+                          1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1)));
+}
+
+TEST(TransformUtilTest, Transform2D) {
+  // The spec covering interpolation of 2D matrix transforms calls for inverting
+  // one of the axis in the case of a negative determinant.  This differs from
+  // the general 3D spec, which calls for flipping all of the scales when the
+  // determinant is negative. Flipping all scales not only introduces rotation
+  // in the case of a trivial scale inversion, but causes transformed objects
+  // to needlessly shrink and grow as they transform through scale = 0 along
+  // multiple axes.  2D transformation matrices should follow the 2D spec
+  // regarding matrix decomposition.
+  DecomposedTransform decompFlipX;
+  DecomposeTransform(&decompFlipX, Transform(-1, 0, 0, 1, 0, 0));
+  EXPECT_APPROX_EQ(-1, decompFlipX.scale[0]);
+  EXPECT_APPROX_EQ(1, decompFlipX.scale[1]);
+  EXPECT_APPROX_EQ(1, decompFlipX.scale[2]);
+  EXPECT_APPROX_EQ(0, decompFlipX.quaternion.z());
+  EXPECT_APPROX_EQ(1, decompFlipX.quaternion.w());
+
+  DecomposedTransform decompFlipY;
+  DecomposeTransform(&decompFlipY, Transform(1, 0, 0, -1, 0, 0));
+  EXPECT_APPROX_EQ(1, decompFlipY.scale[0]);
+  EXPECT_APPROX_EQ(-1, decompFlipY.scale[1]);
+  EXPECT_APPROX_EQ(1, decompFlipY.scale[2]);
+  EXPECT_APPROX_EQ(0, decompFlipY.quaternion.z());
+  EXPECT_APPROX_EQ(1, decompFlipY.quaternion.w());
+
+  DecomposedTransform decompR180;
+  DecomposeTransform(&decompR180, Transform(-1, 0, 0, -1, 0, 0));
+  EXPECT_APPROX_EQ(1, decompR180.scale[0]);
+  EXPECT_APPROX_EQ(1, decompR180.scale[1]);
+  EXPECT_APPROX_EQ(1, decompR180.scale[2]);
+  EXPECT_APPROX_EQ(1, decompR180.quaternion.z());
+  EXPECT_APPROX_EQ(0, decompR180.quaternion.w());
+
+  DecomposedTransform decompR90;
+  DecomposeTransform(&decompR180, Transform(0, -1, 1, 0, 0, 0));
+  EXPECT_APPROX_EQ(1, decompR180.scale[0]);
+  EXPECT_APPROX_EQ(1, decompR180.scale[1]);
+  EXPECT_APPROX_EQ(1, decompR180.scale[2]);
+  EXPECT_APPROX_EQ(1 / sqrt(2), decompR180.quaternion.z());
+  EXPECT_APPROX_EQ(1 / sqrt(2), decompR180.quaternion.w());
+
+  DecomposedTransform decompR90Translate;
+  DecomposeTransform(&decompR90Translate, Transform(0, -1, 1, 0, -1, 1));
+  EXPECT_APPROX_EQ(1, decompR90Translate.scale[0]);
+  EXPECT_APPROX_EQ(1, decompR90Translate.scale[1]);
+  EXPECT_APPROX_EQ(1, decompR90Translate.scale[2]);
+  EXPECT_APPROX_EQ(-1, decompR90Translate.translate[0]);
+  EXPECT_APPROX_EQ(1, decompR90Translate.translate[1]);
+  EXPECT_APPROX_EQ(0, decompR90Translate.translate[2]);
+  EXPECT_APPROX_EQ(1 / sqrt(2), decompR90Translate.quaternion.z());
+  EXPECT_APPROX_EQ(1 / sqrt(2), decompR90Translate.quaternion.w());
+
+  DecomposedTransform decompSkewRotate;
+  DecomposeTransform(&decompR90Translate, Transform(1, 1, 1, 0, 0, 0));
+  EXPECT_APPROX_EQ(sqrt(2), decompR90Translate.scale[0]);
+  EXPECT_APPROX_EQ(-1 / sqrt(2), decompR90Translate.scale[1]);
+  EXPECT_APPROX_EQ(1, decompR90Translate.scale[2]);
+  EXPECT_APPROX_EQ(-1, decompR90Translate.skew[0]);
+  EXPECT_APPROX_EQ(sin(base::kPiDouble / 8), decompR90Translate.quaternion.z());
+  EXPECT_APPROX_EQ(cos(base::kPiDouble / 8), decompR90Translate.quaternion.w());
+}
+
+TEST(TransformUtilTest, TransformBetweenRects) {
+  auto verify = [](const RectF& src_rect, const RectF& dst_rect) {
+    const Transform transform = TransformBetweenRects(src_rect, dst_rect);
+
+    // Applies |transform| to calculate the target rectangle from |src_rect|.
+    // Notes that |transform| is in |src_rect|'s local coordinates.
+    RectF dst_in_src_coordinates = RectF(src_rect.size());
+    transform.TransformRect(&dst_in_src_coordinates);
+    RectF dst_in_parent_coordinates = dst_in_src_coordinates;
+    dst_in_parent_coordinates.Offset(src_rect.OffsetFromOrigin());
+
+    // Verifies that the target rectangle is expected.
+    EXPECT_EQ(dst_rect, dst_in_parent_coordinates);
+  };
+
+  std::vector<const std::pair<const RectF, const RectF>> test_cases{
+      {RectF(0.f, 0.f, 2.f, 3.f), RectF(3.f, 5.f, 4.f, 9.f)},
+      {RectF(10.f, 7.f, 2.f, 6.f), RectF(4.f, 2.f, 1.f, 12.f)},
+      {RectF(0.f, 0.f, 3.f, 5.f), RectF(0.f, 0.f, 6.f, 2.5f)}};
+
+  for (const auto& test_case : test_cases) {
+    verify(test_case.first, test_case.second);
+    verify(test_case.second, test_case.first);
+  }
+
+  // Tests the case where the destination is an empty rectangle.
+  verify(RectF(0.f, 0.f, 3.f, 5.f), RectF());
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/geometry/vector2d.cc b/ui/gfx/geometry/vector2d.cc
new file mode 100644
index 0000000..0ce3b20
--- /dev/null
+++ b/ui/gfx/geometry/vector2d.cc
@@ -0,0 +1,40 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/vector2d.h"
+
+#include <cmath>
+
+#include "base/numerics/clamped_math.h"
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+bool Vector2d::IsZero() const {
+  return x_ == 0 && y_ == 0;
+}
+
+void Vector2d::Add(const Vector2d& other) {
+  x_ = base::ClampAdd(other.x_, x_);
+  y_ = base::ClampAdd(other.y_, y_);
+}
+
+void Vector2d::Subtract(const Vector2d& other) {
+  x_ = base::ClampSub(x_, other.x_);
+  y_ = base::ClampSub(y_, other.y_);
+}
+
+int64_t Vector2d::LengthSquared() const {
+  return static_cast<int64_t>(x_) * x_ + static_cast<int64_t>(y_) * y_;
+}
+
+float Vector2d::Length() const {
+  return static_cast<float>(std::sqrt(static_cast<double>(LengthSquared())));
+}
+
+std::string Vector2d::ToString() const {
+  return base::StringPrintf("[%d %d]", x_, y_);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/vector2d.h b/ui/gfx/geometry/vector2d.h
new file mode 100644
index 0000000..86ad260
--- /dev/null
+++ b/ui/gfx/geometry/vector2d.h
@@ -0,0 +1,98 @@
+// Copyright (c) 2012 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.
+
+// Defines a simple integer vector class.  This class is used to indicate a
+// distance in two dimensions between two points. Subtracting two points should
+// produce a vector, and adding a vector to a point produces the point at the
+// vector's distance from the original point.
+
+#ifndef UI_GFX_GEOMETRY_VECTOR2D_H_
+#define UI_GFX_GEOMETRY_VECTOR2D_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "base/basictypes.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace gfx {
+
+class Vector2d {
+ public:
+  Vector2d() : x_(0), y_(0) {}
+  Vector2d(int x, int y) : x_(x), y_(y) {}
+
+  void SetVector(int x, int y) {
+    x_ = x;
+    y_ = y;
+  }
+
+  int x() const { return x_; }
+  void set_x(int x) { x_ = x; }
+
+  int y() const { return y_; }
+  void set_y(int y) { y_ = y; }
+
+  // True if both components of the vector are 0.
+  bool IsZero() const;
+
+  // Add the components of the |other| vector to the current vector.
+  void Add(const Vector2d& other);
+  // Subtract the components of the |other| vector from the current vector.
+  void Subtract(const Vector2d& other);
+
+  void operator+=(const Vector2d& other) { Add(other); }
+  void operator-=(const Vector2d& other) { Subtract(other); }
+
+  void SetToMin(const Vector2d& other) {
+    x_ = x_ <= other.x_ ? x_ : other.x_;
+    y_ = y_ <= other.y_ ? y_ : other.y_;
+  }
+
+  void SetToMax(const Vector2d& other) {
+    x_ = x_ >= other.x_ ? x_ : other.x_;
+    y_ = y_ >= other.y_ ? y_ : other.y_;
+  }
+
+  // Gives the square of the diagonal length of the vector. Since this is
+  // cheaper to compute than Length(), it is useful when you want to compare
+  // relative lengths of different vectors without needing the actual lengths.
+  int64 LengthSquared() const;
+  // Gives the diagonal length of the vector.
+  float Length() const;
+
+  std::string ToString() const;
+
+  operator Vector2dF() const {
+    return Vector2dF(static_cast<float>(x_), static_cast<float>(y_));
+  }
+
+ private:
+  int x_;
+  int y_;
+};
+
+inline bool operator==(const Vector2d& lhs, const Vector2d& rhs) {
+  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
+}
+
+inline Vector2d operator-(const Vector2d& v) {
+  return Vector2d(-v.x(), -v.y());
+}
+
+inline Vector2d operator+(const Vector2d& lhs, const Vector2d& rhs) {
+  Vector2d result = lhs;
+  result.Add(rhs);
+  return result;
+}
+
+inline Vector2d operator-(const Vector2d& lhs, const Vector2d& rhs) {
+  Vector2d result = lhs;
+  result.Add(-rhs);
+  return result;
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_VECTOR2D_H_
diff --git a/ui/gfx/geometry/vector2d_conversions.cc b/ui/gfx/geometry/vector2d_conversions.cc
new file mode 100644
index 0000000..c33199b
--- /dev/null
+++ b/ui/gfx/geometry/vector2d_conversions.cc
@@ -0,0 +1,26 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/vector2d_conversions.h"
+
+#include "base/numerics/safe_conversions.h"
+
+namespace gfx {
+
+Vector2d ToFlooredVector2d(const Vector2dF& vector2d) {
+  return Vector2d(base::ClampFloor(vector2d.x()),
+                  base::ClampFloor(vector2d.y()));
+}
+
+Vector2d ToCeiledVector2d(const Vector2dF& vector2d) {
+  return Vector2d(base::ClampCeil(vector2d.x()), base::ClampCeil(vector2d.y()));
+}
+
+Vector2d ToRoundedVector2d(const Vector2dF& vector2d) {
+  return Vector2d(base::ClampRound(vector2d.x()),
+                  base::ClampRound(vector2d.y()));
+}
+
+}  // namespace gfx
+
diff --git a/ui/gfx/geometry/vector2d_conversions.h b/ui/gfx/geometry/vector2d_conversions.h
new file mode 100644
index 0000000..055ebd0
--- /dev/null
+++ b/ui/gfx/geometry/vector2d_conversions.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_VECTOR2D_CONVERSIONS_H_
+#define UI_GFX_GEOMETRY_VECTOR2D_CONVERSIONS_H_
+
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace gfx {
+
+// Returns a Vector2d with each component from the input Vector2dF floored.
+GEOMETRY_EXPORT Vector2d ToFlooredVector2d(const Vector2dF& vector2d);
+
+// Returns a Vector2d with each component from the input Vector2dF ceiled.
+GEOMETRY_EXPORT Vector2d ToCeiledVector2d(const Vector2dF& vector2d);
+
+// Returns a Vector2d with each component from the input Vector2dF rounded.
+GEOMETRY_EXPORT Vector2d ToRoundedVector2d(const Vector2dF& vector2d);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_VECTOR2D_CONVERSIONS_H_
diff --git a/ui/gfx/geometry/vector2d_f.cc b/ui/gfx/geometry/vector2d_f.cc
new file mode 100644
index 0000000..ccb15ae
--- /dev/null
+++ b/ui/gfx/geometry/vector2d_f.cc
@@ -0,0 +1,60 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/vector2d_f.h"
+
+#include <cmath>
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+std::string Vector2dF::ToString() const {
+  return base::StringPrintf("[%f %f]", x_, y_);
+}
+
+bool Vector2dF::IsZero() const {
+  return x_ == 0 && y_ == 0;
+}
+
+void Vector2dF::Add(const Vector2dF& other) {
+  x_ += other.x_;
+  y_ += other.y_;
+}
+
+void Vector2dF::Subtract(const Vector2dF& other) {
+  x_ -= other.x_;
+  y_ -= other.y_;
+}
+
+double Vector2dF::LengthSquared() const {
+  return static_cast<double>(x_) * x_ + static_cast<double>(y_) * y_;
+}
+
+float Vector2dF::Length() const {
+  return static_cast<float>(std::sqrt(LengthSquared()));
+}
+
+void Vector2dF::Scale(float x_scale, float y_scale) {
+  x_ *= x_scale;
+  y_ *= y_scale;
+}
+
+double CrossProduct(const Vector2dF& lhs, const Vector2dF& rhs) {
+  return static_cast<double>(lhs.x()) * rhs.y() -
+      static_cast<double>(lhs.y()) * rhs.x();
+}
+
+double DotProduct(const Vector2dF& lhs, const Vector2dF& rhs) {
+  return static_cast<double>(lhs.x()) * rhs.x() +
+      static_cast<double>(lhs.y()) * rhs.y();
+}
+
+Vector2dF ScaleVector2d(const Vector2dF& v, float x_scale, float y_scale) {
+  Vector2dF scaled_v(v);
+  scaled_v.Scale(x_scale, y_scale);
+  return scaled_v;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/vector2d_f.h b/ui/gfx/geometry/vector2d_f.h
new file mode 100644
index 0000000..f97ef00
--- /dev/null
+++ b/ui/gfx/geometry/vector2d_f.h
@@ -0,0 +1,127 @@
+// Copyright (c) 2012 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.
+
+// Defines a simple float vector class.  This class is used to indicate a
+// distance in two dimensions between two points. Subtracting two points should
+// produce a vector, and adding a vector to a point produces the point at the
+// vector's distance from the original point.
+
+#ifndef UI_GFX_GEOMETRY_VECTOR2D_F_H_
+#define UI_GFX_GEOMETRY_VECTOR2D_F_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "base/logging.h"
+
+namespace gfx {
+
+class Vector2dF {
+ public:
+  Vector2dF() : x_(0), y_(0) {}
+  Vector2dF(float x, float y) : x_(x), y_(y) {}
+
+  void SetVector(float x, float y) {
+    x_ = x;
+    y_ = y;
+  }
+
+  float x() const { return x_; }
+  void set_x(float x) { x_ = x; }
+
+  float y() const { return y_; }
+  void set_y(float y) { y_ = y; }
+
+  // True if both components of the vector are 0.
+  bool IsZero() const;
+
+  // Add the components of the |other| vector to the current vector.
+  void Add(const Vector2dF& other);
+  // Subtract the components of the |other| vector from the current vector.
+  void Subtract(const Vector2dF& other);
+
+  void operator+=(const Vector2dF& other) { Add(other); }
+  void operator-=(const Vector2dF& other) { Subtract(other); }
+
+  float operator[](int i) const {
+    DCHECK_LE(0, i);
+    DCHECK_GE(1, i);
+    return i == 0 ? x_ : y_;
+  }
+  float& operator[](int i) {
+    DCHECK_LE(0, i);
+    DCHECK_GE(1, i);
+    return i == 0 ? x_ : y_;
+  }
+
+  void SetToMin(const Vector2dF& other) {
+    x_ = x_ <= other.x_ ? x_ : other.x_;
+    y_ = y_ <= other.y_ ? y_ : other.y_;
+  }
+
+  void SetToMax(const Vector2dF& other) {
+    x_ = x_ >= other.x_ ? x_ : other.x_;
+    y_ = y_ >= other.y_ ? y_ : other.y_;
+  }
+
+  // Gives the square of the diagonal length of the vector.
+  double LengthSquared() const;
+  // Gives the diagonal length of the vector.
+  float Length() const;
+
+  // Scale the x and y components of the vector by |scale|.
+  void Scale(float scale) { Scale(scale, scale); }
+  // Scale the x and y components of the vector by |x_scale| and |y_scale|
+  // respectively.
+  void Scale(float x_scale, float y_scale);
+
+  std::string ToString() const;
+
+ private:
+  float x_;
+  float y_;
+};
+
+inline bool operator==(const Vector2dF& lhs, const Vector2dF& rhs) {
+  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
+}
+
+inline bool operator!=(const Vector2dF& lhs, const Vector2dF& rhs) {
+  return !(lhs == rhs);
+}
+
+inline Vector2dF operator-(const Vector2dF& v) {
+  return Vector2dF(-v.x(), -v.y());
+}
+
+inline Vector2dF operator+(const Vector2dF& lhs, const Vector2dF& rhs) {
+  Vector2dF result = lhs;
+  result.Add(rhs);
+  return result;
+}
+
+inline Vector2dF operator-(const Vector2dF& lhs, const Vector2dF& rhs) {
+  Vector2dF result = lhs;
+  result.Add(-rhs);
+  return result;
+}
+
+// Return the cross product of two vectors.
+double CrossProduct(const Vector2dF& lhs, const Vector2dF& rhs);
+
+// Return the dot product of two vectors.
+double DotProduct(const Vector2dF& lhs, const Vector2dF& rhs);
+
+// Return a vector that is |v| scaled by the given scale factors along each
+// axis.
+Vector2dF ScaleVector2d(const Vector2dF& v, float x_scale, float y_scale);
+
+// Return a vector that is |v| scaled by the given scale factor.
+inline Vector2dF ScaleVector2d(const Vector2dF& v, float scale) {
+  return ScaleVector2d(v, scale, scale);
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GEOMETRY_VECTOR2D_F_H_
diff --git a/ui/gfx/geometry/vector2d_unittest.cc b/ui/gfx/geometry/vector2d_unittest.cc
new file mode 100644
index 0000000..f4e754b
--- /dev/null
+++ b/ui/gfx/geometry/vector2d_unittest.cc
@@ -0,0 +1,293 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+
+#include <cmath>
+#include <limits>
+
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace gfx {
+
+TEST(Vector2dTest, ConversionToFloat) {
+  Vector2d i(3, 4);
+  Vector2dF f = i;
+  EXPECT_EQ(i, f);
+}
+
+TEST(Vector2dTest, IsZero) {
+  Vector2d int_zero(0, 0);
+  Vector2d int_nonzero(2, -2);
+  Vector2dF float_zero(0, 0);
+  Vector2dF float_nonzero(0.1f, -0.1f);
+
+  EXPECT_TRUE(int_zero.IsZero());
+  EXPECT_FALSE(int_nonzero.IsZero());
+  EXPECT_TRUE(float_zero.IsZero());
+  EXPECT_FALSE(float_nonzero.IsZero());
+}
+
+TEST(Vector2dTest, Add) {
+  Vector2d i1(3, 5);
+  Vector2d i2(4, -1);
+
+  const struct {
+    Vector2d expected;
+    Vector2d actual;
+  } int_tests[] = {
+    { Vector2d(3, 5), i1 + Vector2d() },
+    { Vector2d(3 + 4, 5 - 1), i1 + i2 },
+    { Vector2d(3 - 4, 5 + 1), i1 - i2 }
+  };
+
+  for (size_t i = 0; i < base::size(int_tests); ++i)
+    EXPECT_EQ(int_tests[i].expected.ToString(),
+              int_tests[i].actual.ToString());
+
+  Vector2dF f1(3.1f, 5.1f);
+  Vector2dF f2(4.3f, -1.3f);
+
+  const struct {
+    Vector2dF expected;
+    Vector2dF actual;
+  } float_tests[] = {
+    { Vector2dF(3.1F, 5.1F), f1 + Vector2d() },
+    { Vector2dF(3.1F, 5.1F), f1 + Vector2dF() },
+    { Vector2dF(3.1f + 4.3f, 5.1f - 1.3f), f1 + f2 },
+    { Vector2dF(3.1f - 4.3f, 5.1f + 1.3f), f1 - f2 }
+  };
+
+  for (size_t i = 0; i < base::size(float_tests); ++i)
+    EXPECT_EQ(float_tests[i].expected.ToString(),
+              float_tests[i].actual.ToString());
+}
+
+TEST(Vector2dTest, Negative) {
+  const struct {
+    Vector2d expected;
+    Vector2d actual;
+  } int_tests[] = {
+    { Vector2d(0, 0), -Vector2d(0, 0) },
+    { Vector2d(-3, -3), -Vector2d(3, 3) },
+    { Vector2d(3, 3), -Vector2d(-3, -3) },
+    { Vector2d(-3, 3), -Vector2d(3, -3) },
+    { Vector2d(3, -3), -Vector2d(-3, 3) }
+  };
+
+  for (size_t i = 0; i < base::size(int_tests); ++i)
+    EXPECT_EQ(int_tests[i].expected.ToString(),
+              int_tests[i].actual.ToString());
+
+  const struct {
+    Vector2dF expected;
+    Vector2dF actual;
+  } float_tests[] = {
+    { Vector2dF(0, 0), -Vector2d(0, 0) },
+    { Vector2dF(-0.3f, -0.3f), -Vector2dF(0.3f, 0.3f) },
+    { Vector2dF(0.3f, 0.3f), -Vector2dF(-0.3f, -0.3f) },
+    { Vector2dF(-0.3f, 0.3f), -Vector2dF(0.3f, -0.3f) },
+    { Vector2dF(0.3f, -0.3f), -Vector2dF(-0.3f, 0.3f) }
+  };
+
+  for (size_t i = 0; i < base::size(float_tests); ++i)
+    EXPECT_EQ(float_tests[i].expected.ToString(),
+              float_tests[i].actual.ToString());
+}
+
+TEST(Vector2dTest, Scale) {
+  float double_values[][4] = {
+    { 4.5f, 1.2f, 3.3f, 5.6f },
+    { 4.5f, -1.2f, 3.3f, 5.6f },
+    { 4.5f, 1.2f, 3.3f, -5.6f },
+    { 4.5f, 1.2f, -3.3f, -5.6f },
+    { -4.5f, 1.2f, 3.3f, 5.6f },
+    { -4.5f, 1.2f, 0, 5.6f },
+    { -4.5f, 1.2f, 3.3f, 0 },
+    { 4.5f, 0, 3.3f, 5.6f },
+    { 0, 1.2f, 3.3f, 5.6f }
+  };
+
+  for (size_t i = 0; i < base::size(double_values); ++i) {
+    Vector2dF v(double_values[i][0], double_values[i][1]);
+    v.Scale(double_values[i][2], double_values[i][3]);
+    EXPECT_EQ(v.x(), double_values[i][0] * double_values[i][2]);
+    EXPECT_EQ(v.y(), double_values[i][1] * double_values[i][3]);
+
+    Vector2dF v2 = ScaleVector2d(
+        gfx::Vector2dF(double_values[i][0], double_values[i][1]),
+        double_values[i][2], double_values[i][3]);
+    EXPECT_EQ(double_values[i][0] * double_values[i][2], v2.x());
+    EXPECT_EQ(double_values[i][1] * double_values[i][3], v2.y());
+  }
+
+  float single_values[][3] = {
+    { 4.5f, 1.2f, 3.3f },
+    { 4.5f, -1.2f, 3.3f },
+    { 4.5f, 1.2f, 3.3f },
+    { 4.5f, 1.2f, -3.3f },
+    { -4.5f, 1.2f, 3.3f },
+    { -4.5f, 1.2f, 0 },
+    { -4.5f, 1.2f, 3.3f },
+    { 4.5f, 0, 3.3f },
+    { 0, 1.2f, 3.3f }
+  };
+
+  for (size_t i = 0; i < base::size(single_values); ++i) {
+    Vector2dF v(single_values[i][0], single_values[i][1]);
+    v.Scale(single_values[i][2]);
+    EXPECT_EQ(v.x(), single_values[i][0] * single_values[i][2]);
+    EXPECT_EQ(v.y(), single_values[i][1] * single_values[i][2]);
+
+    Vector2dF v2 = ScaleVector2d(
+        gfx::Vector2dF(double_values[i][0], double_values[i][1]),
+        double_values[i][2]);
+    EXPECT_EQ(single_values[i][0] * single_values[i][2], v2.x());
+    EXPECT_EQ(single_values[i][1] * single_values[i][2], v2.y());
+  }
+}
+
+TEST(Vector2dTest, Length) {
+  int int_values[][2] = {
+    { 0, 0 },
+    { 10, 20 },
+    { 20, 10 },
+    { -10, -20 },
+    { -20, 10 },
+    { 10, -20 },
+  };
+
+  for (size_t i = 0; i < base::size(int_values); ++i) {
+    int v0 = int_values[i][0];
+    int v1 = int_values[i][1];
+    double length_squared =
+        static_cast<double>(v0) * v0 + static_cast<double>(v1) * v1;
+    double length = std::sqrt(length_squared);
+    Vector2d vector(v0, v1);
+    EXPECT_EQ(static_cast<float>(length_squared), vector.LengthSquared());
+    EXPECT_EQ(static_cast<float>(length), vector.Length());
+  }
+
+  float float_values[][2] = {
+    { 0, 0 },
+    { 10.5f, 20.5f },
+    { 20.5f, 10.5f },
+    { -10.5f, -20.5f },
+    { -20.5f, 10.5f },
+    { 10.5f, -20.5f },
+    // A large vector that fails if the Length function doesn't use
+    // double precision internally.
+    { 1236278317862780234892374893213178027.12122348904204230f,
+      335890352589839028212313231225425134332.38123f },
+  };
+
+  for (size_t i = 0; i < base::size(float_values); ++i) {
+    double v0 = float_values[i][0];
+    double v1 = float_values[i][1];
+    double length_squared =
+        static_cast<double>(v0) * v0 + static_cast<double>(v1) * v1;
+    double length = std::sqrt(length_squared);
+    Vector2dF vector(v0, v1);
+    EXPECT_DOUBLE_EQ(length_squared, vector.LengthSquared());
+    EXPECT_FLOAT_EQ(static_cast<float>(length), vector.Length());
+  }
+}
+
+TEST(Vector2dTest, ClampVector2d) {
+  Vector2d a;
+
+  a = Vector2d(3, 5);
+  EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
+  a.SetToMax(Vector2d(2, 4));
+  EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
+  a.SetToMax(Vector2d(3, 5));
+  EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
+  a.SetToMax(Vector2d(4, 2));
+  EXPECT_EQ(Vector2d(4, 5).ToString(), a.ToString());
+  a.SetToMax(Vector2d(8, 10));
+  EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
+
+  a.SetToMin(Vector2d(9, 11));
+  EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
+  a.SetToMin(Vector2d(8, 10));
+  EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
+  a.SetToMin(Vector2d(11, 9));
+  EXPECT_EQ(Vector2d(8, 9).ToString(), a.ToString());
+  a.SetToMin(Vector2d(7, 11));
+  EXPECT_EQ(Vector2d(7, 9).ToString(), a.ToString());
+  a.SetToMin(Vector2d(3, 5));
+  EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
+}
+
+TEST(Vector2dTest, ClampVector2dF) {
+  Vector2dF a;
+
+  a = Vector2dF(3.5f, 5.5f);
+  EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(Vector2dF(2.5f, 4.5f));
+  EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(Vector2dF(3.5f, 5.5f));
+  EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(Vector2dF(4.5f, 2.5f));
+  EXPECT_EQ(Vector2dF(4.5f, 5.5f).ToString(), a.ToString());
+  a.SetToMax(Vector2dF(8.5f, 10.5f));
+  EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
+
+  a.SetToMin(Vector2dF(9.5f, 11.5f));
+  EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
+  a.SetToMin(Vector2dF(8.5f, 10.5f));
+  EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
+  a.SetToMin(Vector2dF(11.5f, 9.5f));
+  EXPECT_EQ(Vector2dF(8.5f, 9.5f).ToString(), a.ToString());
+  a.SetToMin(Vector2dF(7.5f, 11.5f));
+  EXPECT_EQ(Vector2dF(7.5f, 9.5f).ToString(), a.ToString());
+  a.SetToMin(Vector2dF(3.5f, 5.5f));
+  EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
+}
+
+TEST(Vector2dTest, IntegerOverflow) {
+  int int_max = std::numeric_limits<int>::max();
+  int int_min = std::numeric_limits<int>::min();
+
+  Vector2d max_vector(int_max, int_max);
+  Vector2d min_vector(int_min, int_min);
+  Vector2d test;
+
+  test = Vector2d();
+  test += Vector2d(int_max, int_max);
+  EXPECT_EQ(test, max_vector);
+
+  test = Vector2d();
+  test += Vector2d(int_min, int_min);
+  EXPECT_EQ(test, min_vector);
+
+  test = Vector2d(10, 20);
+  test += Vector2d(int_max, int_max);
+  EXPECT_EQ(test, max_vector);
+
+  test = Vector2d(-10, -20);
+  test += Vector2d(int_min, int_min);
+  EXPECT_EQ(test, min_vector);
+
+  test = Vector2d();
+  test -= Vector2d(int_max, int_max);
+  EXPECT_EQ(test, Vector2d(-int_max, -int_max));
+
+  test = Vector2d();
+  test -= Vector2d(int_min, int_min);
+  EXPECT_EQ(test, max_vector);
+
+  test = Vector2d(10, 20);
+  test -= Vector2d(int_min, int_min);
+  EXPECT_EQ(test, max_vector);
+
+  test = Vector2d(-10, -20);
+  test -= Vector2d(int_max, int_max);
+  EXPECT_EQ(test, min_vector);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/vector3d_f.cc b/ui/gfx/geometry/vector3d_f.cc
new file mode 100644
index 0000000..d538a57
--- /dev/null
+++ b/ui/gfx/geometry/vector3d_f.cc
@@ -0,0 +1,111 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/geometry/vector3d_f.h"
+
+#include <cmath>
+
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/geometry/angle_conversions.h"
+
+namespace {
+const double kEpsilon = 1.0e-6;
+}
+
+namespace gfx {
+
+std::string Vector3dF::ToString() const {
+  return base::StringPrintf("[%f %f %f]", x_, y_, z_);
+}
+
+bool Vector3dF::IsZero() const {
+  return x_ == 0 && y_ == 0 && z_ == 0;
+}
+
+void Vector3dF::Add(const Vector3dF& other) {
+  x_ += other.x_;
+  y_ += other.y_;
+  z_ += other.z_;
+}
+
+void Vector3dF::Subtract(const Vector3dF& other) {
+  x_ -= other.x_;
+  y_ -= other.y_;
+  z_ -= other.z_;
+}
+
+double Vector3dF::LengthSquared() const {
+  return static_cast<double>(x_) * x_ + static_cast<double>(y_) * y_ +
+      static_cast<double>(z_) * z_;
+}
+
+float Vector3dF::Length() const {
+  return static_cast<float>(std::sqrt(LengthSquared()));
+}
+
+void Vector3dF::Scale(float x_scale, float y_scale, float z_scale) {
+  x_ *= x_scale;
+  y_ *= y_scale;
+  z_ *= z_scale;
+}
+
+void Vector3dF::Cross(const Vector3dF& other) {
+  double dx = x_;
+  double dy = y_;
+  double dz = z_;
+  float x = static_cast<float>(dy * other.z() - dz * other.y());
+  float y = static_cast<float>(dz * other.x() - dx * other.z());
+  float z = static_cast<float>(dx * other.y() - dy * other.x());
+  x_ = x;
+  y_ = y;
+  z_ = z;
+}
+
+bool Vector3dF::GetNormalized(Vector3dF* out) const {
+  double length_squared = LengthSquared();
+  *out = *this;
+  if (length_squared < kEpsilon * kEpsilon)
+    return false;
+  out->Scale(1 / sqrt(length_squared));
+  return true;
+}
+
+float DotProduct(const Vector3dF& lhs, const Vector3dF& rhs) {
+  return lhs.x() * rhs.x() + lhs.y() * rhs.y() + lhs.z() * rhs.z();
+}
+
+Vector3dF ScaleVector3d(const Vector3dF& v,
+                        float x_scale,
+                        float y_scale,
+                        float z_scale) {
+  Vector3dF scaled_v(v);
+  scaled_v.Scale(x_scale, y_scale, z_scale);
+  return scaled_v;
+}
+
+float AngleBetweenVectorsInDegrees(const gfx::Vector3dF& base,
+                                   const gfx::Vector3dF& other) {
+  // Clamp the resulting value to prevent potential NANs from floating point
+  // precision issues.
+  return gfx::RadToDeg(std::acos(fmax(
+      fmin(gfx::DotProduct(base, other) / base.Length() / other.Length(), 1.f),
+      -1.f)));
+}
+
+float ClockwiseAngleBetweenVectorsInDegrees(const gfx::Vector3dF& base,
+                                            const gfx::Vector3dF& other,
+                                            const gfx::Vector3dF& normal) {
+  float angle = AngleBetweenVectorsInDegrees(base, other);
+  gfx::Vector3dF cross(base);
+  cross.Cross(other);
+
+  // If the dot product of this cross product is normal, it means that the
+  // shortest angle between |base| and |other| was counterclockwise with respect
+  // to the surface represented by |normal| and this angle must be reversed.
+  if (gfx::DotProduct(cross, normal) > 0.0f)
+    angle = 360.0f - angle;
+  return angle;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry/vector3d_f.h b/ui/gfx/geometry/vector3d_f.h
new file mode 100644
index 0000000..8238a16
--- /dev/null
+++ b/ui/gfx/geometry/vector3d_f.h
@@ -0,0 +1,155 @@
+// Copyright (c) 2012 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.
+
+// Defines a simple float vector class.  This class is used to indicate a
+// distance in two dimensions between two points. Subtracting two points should
+// produce a vector, and adding a vector to a point produces the point at the
+// vector's distance from the original point.
+
+#ifndef UI_GFX_GEOMETRY_VECTOR3D_F_H_
+#define UI_GFX_GEOMETRY_VECTOR3D_F_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "ui/gfx/geometry/geometry_export.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace gfx {
+
+class GEOMETRY_EXPORT Vector3dF {
+ public:
+  constexpr Vector3dF() : x_(0), y_(0), z_(0) {}
+  constexpr Vector3dF(float x, float y, float z) : x_(x), y_(y), z_(z) {}
+
+  constexpr explicit Vector3dF(const Vector2dF& other)
+      : x_(other.x()), y_(other.y()), z_(0) {}
+
+  constexpr float x() const { return x_; }
+  void set_x(float x) { x_ = x; }
+
+  constexpr float y() const { return y_; }
+  void set_y(float y) { y_ = y; }
+
+  constexpr float z() const { return z_; }
+  void set_z(float z) { z_ = z; }
+
+  // True if all components of the vector are 0.
+  bool IsZero() const;
+
+  // Add the components of the |other| vector to the current vector.
+  void Add(const Vector3dF& other);
+  // Subtract the components of the |other| vector from the current vector.
+  void Subtract(const Vector3dF& other);
+
+  void operator+=(const Vector3dF& other) { Add(other); }
+  void operator-=(const Vector3dF& other) { Subtract(other); }
+
+  void SetToMin(const Vector3dF& other) {
+    x_ = x_ <= other.x_ ? x_ : other.x_;
+    y_ = y_ <= other.y_ ? y_ : other.y_;
+    z_ = z_ <= other.z_ ? z_ : other.z_;
+  }
+
+  void SetToMax(const Vector3dF& other) {
+    x_ = x_ >= other.x_ ? x_ : other.x_;
+    y_ = y_ >= other.y_ ? y_ : other.y_;
+    z_ = z_ >= other.z_ ? z_ : other.z_;
+  }
+
+  // Gives the square of the diagonal length of the vector.
+  double LengthSquared() const;
+  // Gives the diagonal length of the vector.
+  float Length() const;
+
+  // Scale all components of the vector by |scale|.
+  void Scale(float scale) { Scale(scale, scale, scale); }
+  // Scale the each component of the vector by the given scale factors.
+  void Scale(float x_scale, float y_scale, float z_scale);
+
+  // Take the cross product of this vector with |other| and become the result.
+  void Cross(const Vector3dF& other);
+
+  // |out| is assigned a unit-length vector in the direction of |this| iff
+  // this function returns true. It can return false if |this| is too short.
+  bool GetNormalized(Vector3dF* out) const;
+
+  std::string ToString() const;
+
+ private:
+  float x_;
+  float y_;
+  float z_;
+};
+
+inline bool operator==(const Vector3dF& lhs, const Vector3dF& rhs) {
+  return lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() == rhs.z();
+}
+
+inline bool operator!=(const Vector3dF& lhs, const Vector3dF& rhs) {
+  return !(lhs == rhs);
+}
+
+inline Vector3dF operator-(const Vector3dF& v) {
+  return Vector3dF(-v.x(), -v.y(), -v.z());
+}
+
+inline Vector3dF operator+(const Vector3dF& lhs, const Vector3dF& rhs) {
+  Vector3dF result = lhs;
+  result.Add(rhs);
+  return result;
+}
+
+inline Vector3dF operator-(const Vector3dF& lhs, const Vector3dF& rhs) {
+  Vector3dF result = lhs;
+  result.Add(-rhs);
+  return result;
+}
+
+// Return the cross product of two vectors.
+inline Vector3dF CrossProduct(const Vector3dF& lhs, const Vector3dF& rhs) {
+  Vector3dF result = lhs;
+  result.Cross(rhs);
+  return result;
+}
+
+// Return the dot product of two vectors.
+GEOMETRY_EXPORT float DotProduct(const Vector3dF& lhs, const Vector3dF& rhs);
+
+// Return a vector that is |v| scaled by the given scale factors along each
+// axis.
+GEOMETRY_EXPORT Vector3dF ScaleVector3d(const Vector3dF& v,
+                                        float x_scale,
+                                        float y_scale,
+                                        float z_scale);
+
+// Return a vector that is |v| scaled by the components of |s|
+inline Vector3dF ScaleVector3d(const Vector3dF& v, const Vector3dF& s) {
+  return ScaleVector3d(v, s.x(), s.y(), s.z());
+}
+
+// Return a vector that is |v| scaled by the given scale factor.
+inline Vector3dF ScaleVector3d(const Vector3dF& v, float scale) {
+  return ScaleVector3d(v, scale, scale, scale);
+}
+
+// Returns the angle between |base| and |other| in degrees.
+GEOMETRY_EXPORT float AngleBetweenVectorsInDegrees(const gfx::Vector3dF& base,
+                                                   const gfx::Vector3dF& other);
+
+// Returns the clockwise angle between |base| and |other| where |normal| is the
+// normal of the virtual surface to measure clockwise according to.
+GEOMETRY_EXPORT float ClockwiseAngleBetweenVectorsInDegrees(
+    const gfx::Vector3dF& base,
+    const gfx::Vector3dF& other,
+    const gfx::Vector3dF& normal);
+
+// This is declared here for use in gtest-based unit tests but is defined in
+// the //ui/gfx:test_support target. Depend on that to use this in your unit
+// test. This should not be used in production code - call ToString() instead.
+void PrintTo(const Vector3dF& vector, ::std::ostream* os);
+
+}  // namespace gfx
+
+#endif // UI_GFX_GEOMETRY_VECTOR3D_F_H_
diff --git a/ui/gfx/geometry/vector3d_unittest.cc b/ui/gfx/geometry/vector3d_unittest.cc
new file mode 100644
index 0000000..1eab6a6
--- /dev/null
+++ b/ui/gfx/geometry/vector3d_unittest.cc
@@ -0,0 +1,349 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+
+#include <cmath>
+#include <limits>
+
+#include "base/cxx17_backports.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+TEST(Vector3dTest, IsZero) {
+  gfx::Vector3dF float_zero(0, 0, 0);
+  gfx::Vector3dF float_nonzero(0.1f, -0.1f, 0.1f);
+
+  EXPECT_TRUE(float_zero.IsZero());
+  EXPECT_FALSE(float_nonzero.IsZero());
+}
+
+TEST(Vector3dTest, Add) {
+  gfx::Vector3dF f1(3.1f, 5.1f, 2.7f);
+  gfx::Vector3dF f2(4.3f, -1.3f, 8.1f);
+
+  const struct {
+    gfx::Vector3dF expected;
+    gfx::Vector3dF actual;
+  } float_tests[] = {
+    { gfx::Vector3dF(3.1F, 5.1F, 2.7f), f1 + gfx::Vector3dF() },
+    { gfx::Vector3dF(3.1f + 4.3f, 5.1f - 1.3f, 2.7f + 8.1f), f1 + f2 },
+    { gfx::Vector3dF(3.1f - 4.3f, 5.1f + 1.3f, 2.7f - 8.1f), f1 - f2 }
+  };
+
+  for (size_t i = 0; i < base::size(float_tests); ++i)
+    EXPECT_EQ(float_tests[i].expected.ToString(),
+              float_tests[i].actual.ToString());
+}
+
+TEST(Vector3dTest, Negative) {
+  const struct {
+    gfx::Vector3dF expected;
+    gfx::Vector3dF actual;
+  } float_tests[] = {
+    { gfx::Vector3dF(-0.0f, -0.0f, -0.0f), -gfx::Vector3dF(0, 0, 0) },
+    { gfx::Vector3dF(-0.3f, -0.3f, -0.3f), -gfx::Vector3dF(0.3f, 0.3f, 0.3f) },
+    { gfx::Vector3dF(0.3f, 0.3f, 0.3f), -gfx::Vector3dF(-0.3f, -0.3f, -0.3f) },
+    { gfx::Vector3dF(-0.3f, 0.3f, -0.3f), -gfx::Vector3dF(0.3f, -0.3f, 0.3f) },
+    { gfx::Vector3dF(0.3f, -0.3f, -0.3f), -gfx::Vector3dF(-0.3f, 0.3f, 0.3f) },
+    { gfx::Vector3dF(-0.3f, -0.3f, 0.3f), -gfx::Vector3dF(0.3f, 0.3f, -0.3f) }
+  };
+
+  for (size_t i = 0; i < base::size(float_tests); ++i)
+    EXPECT_EQ(float_tests[i].expected.ToString(),
+              float_tests[i].actual.ToString());
+}
+
+TEST(Vector3dTest, Scale) {
+  float triple_values[][6] = {
+    { 4.5f, 1.2f, 1.8f, 3.3f, 5.6f, 4.2f },
+    { 4.5f, -1.2f, -1.8f, 3.3f, 5.6f, 4.2f },
+    { 4.5f, 1.2f, -1.8f, 3.3f, 5.6f, 4.2f },
+    { 4.5f, -1.2f -1.8f, 3.3f, 5.6f, 4.2f },
+
+    { 4.5f, 1.2f, 1.8f, 3.3f, -5.6f, -4.2f },
+    { 4.5f, 1.2f, 1.8f, -3.3f, -5.6f, -4.2f },
+    { 4.5f, 1.2f, -1.8f, 3.3f, -5.6f, -4.2f },
+    { 4.5f, 1.2f, -1.8f, -3.3f, -5.6f, -4.2f },
+
+    { -4.5f, 1.2f, 1.8f, 3.3f, 5.6f, 4.2f },
+    { -4.5f, 1.2f, 1.8f, 0, 5.6f, 4.2f },
+    { -4.5f, 1.2f, -1.8f, 3.3f, 5.6f, 4.2f },
+    { -4.5f, 1.2f, -1.8f, 0, 5.6f, 4.2f },
+
+    { -4.5f, 1.2f, 1.8f, 3.3f, 0, 4.2f },
+    { 4.5f, 0, 1.8f, 3.3f, 5.6f, 4.2f },
+    { -4.5f, 1.2f, -1.8f, 3.3f, 0, 4.2f },
+    { 4.5f, 0, -1.8f, 3.3f, 5.6f, 4.2f },
+    { -4.5f, 1.2f, 1.8f, 3.3f, 5.6f, 0 },
+    { -4.5f, 1.2f, -1.8f, 3.3f, 5.6f, 0 },
+
+    { 0, 1.2f, 0, 3.3f, 5.6f, 4.2f },
+    { 0, 1.2f, 1.8f, 3.3f, 5.6f, 4.2f }
+  };
+
+  for (size_t i = 0; i < base::size(triple_values); ++i) {
+    gfx::Vector3dF v(triple_values[i][0],
+                     triple_values[i][1],
+                     triple_values[i][2]);
+    v.Scale(triple_values[i][3], triple_values[i][4], triple_values[i][5]);
+    EXPECT_EQ(triple_values[i][0] * triple_values[i][3], v.x());
+    EXPECT_EQ(triple_values[i][1] * triple_values[i][4], v.y());
+    EXPECT_EQ(triple_values[i][2] * triple_values[i][5], v.z());
+
+    Vector3dF v2 = ScaleVector3d(
+        gfx::Vector3dF(triple_values[i][0],
+                       triple_values[i][1],
+                       triple_values[i][2]),
+        triple_values[i][3], triple_values[i][4], triple_values[i][5]);
+    EXPECT_EQ(triple_values[i][0] * triple_values[i][3], v2.x());
+    EXPECT_EQ(triple_values[i][1] * triple_values[i][4], v2.y());
+    EXPECT_EQ(triple_values[i][2] * triple_values[i][5], v2.z());
+  }
+
+  float single_values[][4] = {
+    { 4.5f, 1.2f, 1.8f, 3.3f },
+    { 4.5f, -1.2f, 1.8f, 3.3f },
+    { 4.5f, 1.2f, -1.8f, 3.3f },
+    { 4.5f, -1.2f, -1.8f, 3.3f },
+    { -4.5f, 1.2f, 3.3f },
+    { -4.5f, 1.2f, 0 },
+    { -4.5f, 1.2f, 1.8f, 3.3f },
+    { -4.5f, 1.2f, 1.8f, 0 },
+    { 4.5f, 0, 1.8f, 3.3f },
+    { 0, 1.2f, 1.8f, 3.3f },
+    { 4.5f, 0, 1.8f, 3.3f },
+    { 0, 1.2f, 1.8f, 3.3f },
+    { 4.5f, 1.2f, 0, 3.3f },
+    { 4.5f, 1.2f, 0, 3.3f }
+  };
+
+  for (size_t i = 0; i < base::size(single_values); ++i) {
+    gfx::Vector3dF v(single_values[i][0],
+                     single_values[i][1],
+                     single_values[i][2]);
+    v.Scale(single_values[i][3]);
+    EXPECT_EQ(single_values[i][0] * single_values[i][3], v.x());
+    EXPECT_EQ(single_values[i][1] * single_values[i][3], v.y());
+    EXPECT_EQ(single_values[i][2] * single_values[i][3], v.z());
+
+    Vector3dF v2 = ScaleVector3d(
+        gfx::Vector3dF(single_values[i][0],
+                       single_values[i][1],
+                       single_values[i][2]),
+        single_values[i][3]);
+    EXPECT_EQ(single_values[i][0] * single_values[i][3], v2.x());
+    EXPECT_EQ(single_values[i][1] * single_values[i][3], v2.y());
+    EXPECT_EQ(single_values[i][2] * single_values[i][3], v2.z());
+  }
+}
+
+TEST(Vector3dTest, Length) {
+  float float_values[][3] = {
+    { 0, 0, 0 },
+    { 10.5f, 20.5f, 8.5f },
+    { 20.5f, 10.5f, 8.5f },
+    { 8.5f, 20.5f, 10.5f },
+    { 10.5f, 8.5f, 20.5f },
+    { -10.5f, -20.5f, -8.5f },
+    { -20.5f, 10.5f, -8.5f },
+    { -8.5f, -20.5f, -10.5f },
+    { -10.5f, -8.5f, -20.5f },
+    { 10.5f, -20.5f, 8.5f },
+    { -10.5f, 20.5f, 8.5f },
+    { 10.5f, -20.5f, -8.5f },
+    { -10.5f, 20.5f, -8.5f },
+    // A large vector that fails if the Length function doesn't use
+    // double precision internally.
+    { 1236278317862780234892374893213178027.12122348904204230f,
+      335890352589839028212313231225425134332.38123f,
+      27861786423846742743236423478236784678.236713617231f }
+  };
+
+  for (size_t i = 0; i < base::size(float_values); ++i) {
+    double v0 = float_values[i][0];
+    double v1 = float_values[i][1];
+    double v2 = float_values[i][2];
+    double length_squared =
+        static_cast<double>(v0) * v0 +
+        static_cast<double>(v1) * v1 +
+        static_cast<double>(v2) * v2;
+    double length = std::sqrt(length_squared);
+    gfx::Vector3dF vector(v0, v1, v2);
+    EXPECT_DOUBLE_EQ(length_squared, vector.LengthSquared());
+    EXPECT_FLOAT_EQ(static_cast<float>(length), vector.Length());
+  }
+}
+
+TEST(Vector3dTest, DotProduct) {
+  const struct {
+    float expected;
+    gfx::Vector3dF input1;
+    gfx::Vector3dF input2;
+  } tests[] = {
+    { 0, gfx::Vector3dF(1, 0, 0), gfx::Vector3dF(0, 1, 1) },
+    { 0, gfx::Vector3dF(0, 1, 0), gfx::Vector3dF(1, 0, 1) },
+    { 0, gfx::Vector3dF(0, 0, 1), gfx::Vector3dF(1, 1, 0) },
+
+    { 3, gfx::Vector3dF(1, 1, 1), gfx::Vector3dF(1, 1, 1) },
+
+    { 1.2f, gfx::Vector3dF(1.2f, -1.2f, 1.2f), gfx::Vector3dF(1, 1, 1) },
+    { 1.2f, gfx::Vector3dF(1, 1, 1), gfx::Vector3dF(1.2f, -1.2f, 1.2f) },
+
+    { 38.72f,
+      gfx::Vector3dF(1.1f, 2.2f, 3.3f), gfx::Vector3dF(4.4f, 5.5f, 6.6f) }
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    float actual = gfx::DotProduct(tests[i].input1, tests[i].input2);
+    EXPECT_EQ(tests[i].expected, actual);
+  }
+}
+
+TEST(Vector3dTest, CrossProduct) {
+  const struct {
+    gfx::Vector3dF expected;
+    gfx::Vector3dF input1;
+    gfx::Vector3dF input2;
+  } tests[] = {
+    { Vector3dF(), Vector3dF(), Vector3dF(1, 1, 1) },
+    { Vector3dF(), Vector3dF(1, 1, 1), Vector3dF() },
+    { Vector3dF(), Vector3dF(1, 1, 1), Vector3dF(1, 1, 1) },
+    { Vector3dF(),
+      Vector3dF(1.6f, 10.6f, -10.6f),
+      Vector3dF(1.6f, 10.6f, -10.6f) },
+
+    { Vector3dF(1, -1, 0), Vector3dF(1, 1, 1), Vector3dF(0, 0, 1) },
+    { Vector3dF(-1, 0, 1), Vector3dF(1, 1, 1), Vector3dF(0, 1, 0) },
+    { Vector3dF(0, 1, -1), Vector3dF(1, 1, 1), Vector3dF(1, 0, 0) },
+
+    { Vector3dF(-1, 1, 0), Vector3dF(0, 0, 1), Vector3dF(1, 1, 1) },
+    { Vector3dF(1, 0, -1), Vector3dF(0, 1, 0), Vector3dF(1, 1, 1) },
+    { Vector3dF(0, -1, 1), Vector3dF(1, 0, 0), Vector3dF(1, 1, 1) }
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    SCOPED_TRACE(i);
+    Vector3dF actual = gfx::CrossProduct(tests[i].input1, tests[i].input2);
+    EXPECT_EQ(tests[i].expected.ToString(), actual.ToString());
+  }
+}
+
+TEST(Vector3dFTest, ClampVector3dF) {
+  Vector3dF a;
+
+  a = Vector3dF(3.5f, 5.5f, 7.5f);
+  EXPECT_EQ(Vector3dF(3.5f, 5.5f, 7.5f).ToString(), a.ToString());
+  a.SetToMax(Vector3dF(2, 4.5f, 6.5f));
+  EXPECT_EQ(Vector3dF(3.5f, 5.5f, 7.5f).ToString(), a.ToString());
+  a.SetToMax(Vector3dF(3.5f, 5.5f, 7.5f));
+  EXPECT_EQ(Vector3dF(3.5f, 5.5f, 7.5f).ToString(), a.ToString());
+  a.SetToMax(Vector3dF(4.5f, 2, 6.5f));
+  EXPECT_EQ(Vector3dF(4.5f, 5.5f, 7.5f).ToString(), a.ToString());
+  a.SetToMax(Vector3dF(3.5f, 6.5f, 6.5f));
+  EXPECT_EQ(Vector3dF(4.5f, 6.5f, 7.5f).ToString(), a.ToString());
+  a.SetToMax(Vector3dF(3.5f, 5.5f, 8.5f));
+  EXPECT_EQ(Vector3dF(4.5f, 6.5f, 8.5f).ToString(), a.ToString());
+  a.SetToMax(Vector3dF(8.5f, 10.5f, 12.5f));
+  EXPECT_EQ(Vector3dF(8.5f, 10.5f, 12.5f).ToString(), a.ToString());
+
+  a.SetToMin(Vector3dF(9.5f, 11.5f, 13.5f));
+  EXPECT_EQ(Vector3dF(8.5f, 10.5f, 12.5f).ToString(), a.ToString());
+  a.SetToMin(Vector3dF(8.5f, 10.5f, 12.5f));
+  EXPECT_EQ(Vector3dF(8.5f, 10.5f, 12.5f).ToString(), a.ToString());
+  a.SetToMin(Vector3dF(7.5f, 11.5f, 13.5f));
+  EXPECT_EQ(Vector3dF(7.5f, 10.5f, 12.5f).ToString(), a.ToString());
+  a.SetToMin(Vector3dF(9.5f, 9.5f, 13.5f));
+  EXPECT_EQ(Vector3dF(7.5f, 9.5f, 12.5f).ToString(), a.ToString());
+  a.SetToMin(Vector3dF(9.5f, 11.5f, 11.5f));
+  EXPECT_EQ(Vector3dF(7.5f, 9.5f, 11.5f).ToString(), a.ToString());
+  a.SetToMin(Vector3dF(3.5f, 5.5f, 7.5f));
+  EXPECT_EQ(Vector3dF(3.5f, 5.5f, 7.5f).ToString(), a.ToString());
+}
+
+TEST(Vector3dTest, AngleBetweenVectorsInDegress) {
+  const struct {
+    float expected;
+    gfx::Vector3dF input1;
+    gfx::Vector3dF input2;
+  } tests[] = {{0, gfx::Vector3dF(0, 1, 0), gfx::Vector3dF(0, 1, 0)},
+               {90, gfx::Vector3dF(0, 1, 0), gfx::Vector3dF(0, 0, 1)},
+               {45, gfx::Vector3dF(0, 1, 0),
+                gfx::Vector3dF(0, 0.70710678188f, 0.70710678188f)},
+               {180, gfx::Vector3dF(0, 1, 0), gfx::Vector3dF(0, -1, 0)},
+               // Two vectors that are sufficiently close enough together to
+               // trigger an issue that produces NANs if the value passed to
+               // acos is not clamped due to floating point precision.
+               {0, gfx::Vector3dF(0, -0.990842f, -0.003177f),
+                gfx::Vector3dF(0, -0.999995f, -0.003124f)}};
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    float actual =
+        gfx::AngleBetweenVectorsInDegrees(tests[i].input1, tests[i].input2);
+    EXPECT_FLOAT_EQ(tests[i].expected, actual);
+    actual =
+        gfx::AngleBetweenVectorsInDegrees(tests[i].input2, tests[i].input1);
+    EXPECT_FLOAT_EQ(tests[i].expected, actual);
+  }
+}
+
+TEST(Vector3dTest, ClockwiseAngleBetweenVectorsInDegress) {
+  const struct {
+    float expected;
+    gfx::Vector3dF input1;
+    gfx::Vector3dF input2;
+  } tests[] = {
+      {0, gfx::Vector3dF(0, 1, 0), gfx::Vector3dF(0, 1, 0)},
+      {90, gfx::Vector3dF(0, 1, 0), gfx::Vector3dF(0, 0, -1)},
+      {45,
+       gfx::Vector3dF(0, -1, 0),
+       gfx::Vector3dF(0, -0.70710678188f, 0.70710678188f)},
+      {180, gfx::Vector3dF(0, -1, 0), gfx::Vector3dF(0, 1, 0)},
+      {270, gfx::Vector3dF(0, 1, 0), gfx::Vector3dF(0, 0, 1)},
+  };
+
+  const gfx::Vector3dF normal_vector(1.0f, 0.0f, 0.0f);
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    float actual = gfx::ClockwiseAngleBetweenVectorsInDegrees(
+        tests[i].input1, tests[i].input2, normal_vector);
+    EXPECT_FLOAT_EQ(tests[i].expected, actual);
+    actual = -gfx::ClockwiseAngleBetweenVectorsInDegrees(
+                 tests[i].input2, tests[i].input1, normal_vector);
+    if (actual < 0.0f)
+      actual += 360.0f;
+    EXPECT_FLOAT_EQ(tests[i].expected, actual);
+  }
+}
+
+TEST(Vector3dTest, GetNormalized) {
+  const struct {
+    bool expected;
+    gfx::Vector3dF v;
+    gfx::Vector3dF normalized;
+  } tests[] = {
+      {false, gfx::Vector3dF(0, 0, 0), gfx::Vector3dF(0, 0, 0)},
+      {false,
+       gfx::Vector3dF(std::numeric_limits<float>::min(),
+                      std::numeric_limits<float>::min(),
+                      std::numeric_limits<float>::min()),
+       gfx::Vector3dF(std::numeric_limits<float>::min(),
+                      std::numeric_limits<float>::min(),
+                      std::numeric_limits<float>::min())},
+      {true, gfx::Vector3dF(1, 0, 0), gfx::Vector3dF(1, 0, 0)},
+      {true, gfx::Vector3dF(std::numeric_limits<float>::max(), 0, 0),
+       gfx::Vector3dF(1, 0, 0)},
+  };
+
+  for (size_t i = 0; i < base::size(tests); ++i) {
+    gfx::Vector3dF n;
+    EXPECT_EQ(tests[i].expected, tests[i].v.GetNormalized(&n));
+    EXPECT_EQ(tests[i].normalized.ToString(), n.ToString());
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/geometry_skia_export.h b/ui/gfx/geometry_skia_export.h
new file mode 100644
index 0000000..c681982
--- /dev/null
+++ b/ui/gfx/geometry_skia_export.h
@@ -0,0 +1,29 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GEOMETRY_SKIA_EXPORT_H_
+#define UI_GFX_GEOMETRY_SKIA_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GEOMETRY_SKIA_IMPLEMENTATION)
+#define GEOMETRY_SKIA_EXPORT __declspec(dllexport)
+#else
+#define GEOMETRY_SKIA_EXPORT __declspec(dllimport)
+#endif  // defined(GEOMETRY_SKIA_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GEOMETRY_SKIA_IMPLEMENTATION)
+#define GEOMETRY_SKIA_EXPORT __attribute__((visibility("default")))
+#else
+#define GEOMETRY_SKIA_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GEOMETRY_SKIA_EXPORT
+#endif
+
+#endif  // UI_GFX_GEOMETRY_SKIA_EXPORT_H_
diff --git a/ui/gfx/gfx_export.h b/ui/gfx/gfx_export.h
new file mode 100644
index 0000000..20c8bb1
--- /dev/null
+++ b/ui/gfx/gfx_export.h
@@ -0,0 +1,29 @@
+// Copyright (c) 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.
+
+#ifndef UI_GFX_GFX_EXPORT_H_
+#define UI_GFX_GFX_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_IMPLEMENTATION)
+#define GFX_EXPORT __declspec(dllexport)
+#else
+#define GFX_EXPORT __declspec(dllimport)
+#endif  // defined(GFX_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_IMPLEMENTATION)
+#define GFX_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_EXPORT
+#endif
+
+#endif  // UI_GFX_GFX_EXPORT_H_
diff --git a/ui/gfx/gfx_skia_export.h b/ui/gfx/gfx_skia_export.h
new file mode 100644
index 0000000..5bd3572
--- /dev/null
+++ b/ui/gfx/gfx_skia_export.h
@@ -0,0 +1,29 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GFX_SKIA_EXPORT_H_
+#define UI_GFX_GFX_SKIA_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_SKIA_IMPLEMENTATION)
+#define GFX_SKIA_EXPORT __declspec(dllexport)
+#else
+#define GFX_SKIA_EXPORT __declspec(dllimport)
+#endif  // defined(GEOMETRY_SKIA_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_SKIA_IMPLEMENTATION)
+#define GFX_SKIA_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_SKIA_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_SKIA_EXPORT
+#endif
+
+#endif  // UI_GFX_GFX_SKIA_EXPORT_H_
diff --git a/ui/gfx/gpu_extra_info.cc b/ui/gfx/gpu_extra_info.cc
new file mode 100644
index 0000000..90747bf
--- /dev/null
+++ b/ui/gfx/gpu_extra_info.cc
@@ -0,0 +1,23 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/gpu_extra_info.h"
+
+namespace gfx {
+
+ANGLEFeature::ANGLEFeature() = default;
+ANGLEFeature::ANGLEFeature(const ANGLEFeature& other) = default;
+ANGLEFeature::ANGLEFeature(ANGLEFeature&& other) = default;
+ANGLEFeature::~ANGLEFeature() = default;
+ANGLEFeature& ANGLEFeature::operator=(const ANGLEFeature& other) = default;
+ANGLEFeature& ANGLEFeature::operator=(ANGLEFeature&& other) = default;
+
+GpuExtraInfo::GpuExtraInfo() = default;
+GpuExtraInfo::GpuExtraInfo(const GpuExtraInfo&) = default;
+GpuExtraInfo::GpuExtraInfo(GpuExtraInfo&&) = default;
+GpuExtraInfo::~GpuExtraInfo() = default;
+GpuExtraInfo& GpuExtraInfo::operator=(const GpuExtraInfo&) = default;
+GpuExtraInfo& GpuExtraInfo::operator=(GpuExtraInfo&&) = default;
+
+}  // namespace gfx
diff --git a/ui/gfx/gpu_extra_info.h b/ui/gfx/gpu_extra_info.h
new file mode 100644
index 0000000..c895145
--- /dev/null
+++ b/ui/gfx/gpu_extra_info.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GPU_EXTRA_INFO_H_
+#define UI_GFX_GPU_EXTRA_INFO_H_
+
+#include <string>
+#include <vector>
+
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/gfx_export.h"
+
+#if defined(USE_OZONE)
+#include "ui/ozone/buildflags.h"
+#if BUILDFLAG(OZONE_PLATFORM_X11)
+#define USE_OZONE_PLATFORM_X11
+#endif
+#endif
+
+#if defined(USE_X11) || defined(USE_OZONE_PLATFORM_X11)
+#include "ui/gfx/x/xproto.h"
+#endif
+
+namespace gfx {
+
+// Specification of a feature that can be enabled/disable in ANGLE
+struct GFX_EXPORT ANGLEFeature {
+  ANGLEFeature();
+  ANGLEFeature(const ANGLEFeature& other);
+  ANGLEFeature(ANGLEFeature&& other);
+  ~ANGLEFeature();
+  ANGLEFeature& operator=(const ANGLEFeature& other);
+  ANGLEFeature& operator=(ANGLEFeature&& other);
+
+  // Name of the feature in camel_case.
+  std::string name;
+
+  // Name of the category that the feature belongs to.
+  std::string category;
+
+  // One sentence description of the feature, why it's available.
+  std::string description;
+
+  // Full link to cr/angle bug if applicable.
+  std::string bug;
+
+  // Status, can be "enabled" or "disabled".
+  std::string status;
+
+  // Condition, contains the condition that set 'status'.
+  std::string condition;
+};
+using ANGLEFeatures = std::vector<ANGLEFeature>;
+
+struct GFX_EXPORT GpuExtraInfo {
+  GpuExtraInfo();
+  GpuExtraInfo(const GpuExtraInfo&);
+  GpuExtraInfo(GpuExtraInfo&&);
+  ~GpuExtraInfo();
+  GpuExtraInfo& operator=(const GpuExtraInfo&);
+  GpuExtraInfo& operator=(GpuExtraInfo&&);
+
+  // List of the currently available ANGLE features. May be empty if not
+  // applicable.
+  ANGLEFeatures angle_features;
+
+#if defined(USE_X11) || defined(USE_OZONE_PLATFORM_X11)
+  std::vector<gfx::BufferUsageAndFormat> gpu_memory_buffer_support_x11;
+#endif
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GPU_EXTRA_INFO_H_
diff --git a/ui/gfx/gpu_fence.cc b/ui/gfx/gpu_fence.cc
new file mode 100644
index 0000000..e52f607
--- /dev/null
+++ b/ui/gfx/gpu_fence.cc
@@ -0,0 +1,101 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/gpu_fence.h"
+
+#include "base/logging.h"
+#include "base/notreached.h"
+#include "base/time/time.h"
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_ANDROID)
+#include <sync/sync.h>
+#endif
+
+namespace gfx {
+
+GpuFence::GpuFence(GpuFenceHandle fence_handle)
+    : fence_handle_(std::move(fence_handle)) {}
+
+GpuFence::~GpuFence() = default;
+
+GpuFence::GpuFence(GpuFence&& other) = default;
+
+GpuFence& GpuFence::operator=(GpuFence&& other) = default;
+
+const GpuFenceHandle& GpuFence::GetGpuFenceHandle() const {
+  return fence_handle_;
+}
+
+ClientGpuFence GpuFence::AsClientGpuFence() {
+  return reinterpret_cast<ClientGpuFence>(this);
+}
+
+// static
+GpuFence* GpuFence::FromClientGpuFence(ClientGpuFence gpu_fence) {
+  return reinterpret_cast<GpuFence*>(gpu_fence);
+}
+
+void GpuFence::Wait() {
+  if (fence_handle_.is_null()) {
+    return;
+  }
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_ANDROID)
+  static const int kInfiniteSyncWaitTimeout = -1;
+  DCHECK_GE(fence_handle_.owned_fd.get(), 0);
+  if (sync_wait(fence_handle_.owned_fd.get(), kInfiniteSyncWaitTimeout) < 0) {
+    LOG(FATAL) << "Failed while waiting for gpu fence fd";
+  }
+#else
+  NOTREACHED();
+#endif
+}
+
+// static
+GpuFence::FenceStatus GpuFence::GetStatusChangeTime(int fd,
+                                                    base::TimeTicks* time) {
+  DCHECK_NE(fd, -1);
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_ANDROID)
+  auto info =
+      std::unique_ptr<sync_fence_info_data, void (*)(sync_fence_info_data*)>{
+          sync_fence_info(fd), sync_fence_info_free};
+  if (!info) {
+    LOG(ERROR) << "sync_fence_info returned null for fd : " << fd;
+    return FenceStatus::kInvalid;
+  }
+
+  // Not signalled yet.
+  if (info->status != 1) {
+    return FenceStatus::kNotSignaled;
+  }
+
+  uint64_t timestamp_ns = 0u;
+  struct sync_pt_info* pt_info = nullptr;
+  while ((pt_info = sync_pt_info(info.get(), pt_info)))
+    timestamp_ns = std::max(timestamp_ns, pt_info->timestamp_ns);
+
+  if (timestamp_ns == 0u) {
+    LOG(ERROR) << "No timestamp provided from sync_pt_info for fd : " << fd;
+    return FenceStatus::kInvalid;
+  }
+  *time = base::TimeTicks() + base::Nanoseconds(timestamp_ns);
+  return FenceStatus::kSignaled;
+#endif
+  NOTREACHED();
+  return FenceStatus::kInvalid;
+}
+
+base::TimeTicks GpuFence::GetMaxTimestamp() const {
+  base::TimeTicks timestamp;
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_ANDROID)
+  FenceStatus status =
+      GetStatusChangeTime(fence_handle_.owned_fd.get(), &timestamp);
+  DCHECK_EQ(status, FenceStatus::kSignaled);
+  return timestamp;
+#endif
+  NOTREACHED();
+  return timestamp;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/gpu_fence.h b/ui/gfx/gpu_fence.h
new file mode 100644
index 0000000..eb71d7f
--- /dev/null
+++ b/ui/gfx/gpu_fence.h
@@ -0,0 +1,59 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GPU_FENCE_H_
+#define UI_GFX_GPU_FENCE_H_
+
+#include "base/macros.h"
+#include "build/build_config.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/gpu_fence_handle.h"
+
+extern "C" typedef struct _ClientGpuFence* ClientGpuFence;
+
+namespace base {
+class TimeTicks;
+}  // namespace base
+
+namespace gfx {
+
+// GpuFence objects own a GpuFenceHandle and release the resources in it when
+// going out of scope as appropriate.
+class GFX_EXPORT GpuFence {
+ public:
+  // Constructor takes ownership of the source handle's resources.
+  explicit GpuFence(GpuFenceHandle handle);
+  GpuFence() = delete;
+  GpuFence(GpuFence&& other);
+  GpuFence& operator=(GpuFence&& other);
+
+  GpuFence(const GpuFence&) = delete;
+  GpuFence& operator=(const GpuFence&) = delete;
+
+  ~GpuFence();
+
+  // Returns a const reference to the underlying GpuFenceHandle
+  // owned by GpuFence. If you'd like a duplicated handle for use
+  // with IPC, call the Clone method on the returned handle.
+  const GpuFenceHandle& GetGpuFenceHandle() const;
+
+  // Casts for use with the GLES interface.
+  ClientGpuFence AsClientGpuFence();
+  static GpuFence* FromClientGpuFence(ClientGpuFence gpu_fence);
+
+  // Wait for the GpuFence to become ready.
+  void Wait();
+
+  enum FenceStatus { kSignaled, kNotSignaled, kInvalid };
+  static FenceStatus GetStatusChangeTime(int fd, base::TimeTicks* time);
+
+  base::TimeTicks GetMaxTimestamp() const;
+
+ private:
+  gfx::GpuFenceHandle fence_handle_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GPU_FENCE_H_
diff --git a/ui/gfx/gpu_fence_handle.cc b/ui/gfx/gpu_fence_handle.cc
new file mode 100644
index 0000000..85a6e5b
--- /dev/null
+++ b/ui/gfx/gpu_fence_handle.cc
@@ -0,0 +1,82 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/gpu_fence_handle.h"
+
+#include "base/debug/alias.h"
+#include "base/notreached.h"
+
+#if defined(OS_POSIX)
+#include <unistd.h>
+
+#include "base/posix/eintr_wrapper.h"
+#endif
+
+#if defined(OS_FUCHSIA)
+#include "base/fuchsia/fuchsia_logging.h"
+#endif
+
+#if defined(OS_WIN)
+#include <windows.h>
+#include "base/process/process_handle.h"
+#endif
+
+namespace gfx {
+
+GpuFenceHandle::GpuFenceHandle() = default;
+
+GpuFenceHandle::GpuFenceHandle(GpuFenceHandle&& other) = default;
+
+GpuFenceHandle& GpuFenceHandle::operator=(GpuFenceHandle&& other) = default;
+
+GpuFenceHandle::~GpuFenceHandle() = default;
+
+bool GpuFenceHandle::is_null() const {
+#if defined(OS_POSIX)
+  return !owned_fd.is_valid();
+#elif defined(OS_FUCHSIA)
+  return !owned_event.is_valid();
+#elif defined(OS_WIN)
+  return !owned_handle.IsValid();
+#else
+  return true;
+#endif
+}
+
+GpuFenceHandle GpuFenceHandle::Clone() const {
+  if (is_null())
+    return GpuFenceHandle();
+
+  gfx::GpuFenceHandle handle;
+#if defined(OS_POSIX)
+  const int duped_handle = HANDLE_EINTR(dup(owned_fd.get()));
+  if (duped_handle < 0)
+    return GpuFenceHandle();
+  handle.owned_fd = base::ScopedFD(duped_handle);
+#elif defined(OS_FUCHSIA)
+  zx_status_t status =
+      owned_event.duplicate(ZX_RIGHT_SAME_RIGHTS, &handle.owned_event);
+  if (status != ZX_OK) {
+    ZX_DLOG(ERROR, status) << "zx_handle_duplicate";
+    return GpuFenceHandle();
+  }
+#elif defined(OS_WIN)
+  const base::ProcessHandle process = ::GetCurrentProcess();
+  HANDLE duplicated_handle = INVALID_HANDLE_VALUE;
+  const BOOL result =
+      ::DuplicateHandle(process, owned_handle.Get(), process,
+                        &duplicated_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
+  if (!result) {
+    const DWORD last_error = ::GetLastError();
+    base::debug::Alias(&last_error);
+    CHECK(false);
+  }
+  handle.owned_handle.Set(duplicated_handle);
+#else
+  NOTREACHED();
+#endif
+  return handle;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/gpu_fence_handle.h b/ui/gfx/gpu_fence_handle.h
new file mode 100644
index 0000000..3e4abef
--- /dev/null
+++ b/ui/gfx/gpu_fence_handle.h
@@ -0,0 +1,54 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_GPU_FENCE_HANDLE_H_
+#define UI_GFX_GPU_FENCE_HANDLE_H_
+
+#include "base/macros.h"
+#include "build/build_config.h"
+#include "ui/gfx/gfx_export.h"
+
+#if defined(OS_POSIX)
+#include "base/files/scoped_file.h"
+#endif
+
+#if defined(OS_FUCHSIA)
+#include <lib/zx/event.h>
+#endif
+
+#if defined(OS_WIN)
+#include "base/win/scoped_handle.h"
+#endif
+
+namespace gfx {
+
+struct GFX_EXPORT GpuFenceHandle {
+  GpuFenceHandle(const GpuFenceHandle&) = delete;
+  GpuFenceHandle& operator=(const GpuFenceHandle&) = delete;
+
+  GpuFenceHandle();
+  GpuFenceHandle(GpuFenceHandle&& other);
+  GpuFenceHandle& operator=(GpuFenceHandle&& other);
+  ~GpuFenceHandle();
+
+  bool is_null() const;
+
+  // Returns an instance of |handle| which can be sent over IPC. This duplicates
+  // the handle so that IPC code can take ownership of it without invalidating
+  // |handle| itself.
+  GpuFenceHandle Clone() const;
+
+  // TODO(crbug.com/1142962): Make this a class instead of struct.
+#if defined(OS_POSIX)
+  base::ScopedFD owned_fd;
+#elif defined(OS_FUCHSIA)
+  zx::event owned_event;
+#elif defined(OS_WIN)
+  base::win::ScopedHandle owned_handle;
+#endif
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GPU_FENCE_HANDLE_H_
diff --git a/ui/gfx/gpu_memory_buffer.cc b/ui/gfx/gpu_memory_buffer.cc
new file mode 100644
index 0000000..44b2667
--- /dev/null
+++ b/ui/gfx/gpu_memory_buffer.cc
@@ -0,0 +1,72 @@
+// 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.
+
+#include "ui/gfx/gpu_memory_buffer.h"
+
+#include "base/logging.h"
+#include "ui/gfx/generic_shared_memory_id.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#include "base/win/scoped_handle.h"
+#endif
+
+namespace gfx {
+
+#if defined(OS_WIN)
+namespace {
+base::win::ScopedHandle CloneDXGIHandle(HANDLE handle) {
+  HANDLE target_handle = nullptr;
+  if (!::DuplicateHandle(GetCurrentProcess(), handle, GetCurrentProcess(),
+                         &target_handle, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+    DVLOG(1) << "Error duplicating GMB DXGI handle. error=" << GetLastError();
+  }
+  return base::win::ScopedHandle(target_handle);
+}
+}  // namespace
+#endif
+
+GpuMemoryBufferHandle::GpuMemoryBufferHandle() = default;
+
+#if defined(OS_ANDROID)
+GpuMemoryBufferHandle::GpuMemoryBufferHandle(
+    base::android::ScopedHardwareBufferHandle handle)
+    : type(GpuMemoryBufferType::ANDROID_HARDWARE_BUFFER),
+      android_hardware_buffer(std::move(handle)) {}
+#endif
+
+// TODO(crbug.com/863011): Reset |type| and possibly the handles on the
+// moved-from object.
+GpuMemoryBufferHandle::GpuMemoryBufferHandle(GpuMemoryBufferHandle&& other) =
+    default;
+
+GpuMemoryBufferHandle& GpuMemoryBufferHandle::operator=(
+    GpuMemoryBufferHandle&& other) = default;
+
+GpuMemoryBufferHandle::~GpuMemoryBufferHandle() = default;
+
+GpuMemoryBufferHandle GpuMemoryBufferHandle::Clone() const {
+  GpuMemoryBufferHandle handle;
+  handle.type = type;
+  handle.id = id;
+  handle.region = region.Duplicate();
+  handle.offset = offset;
+  handle.stride = stride;
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_FUCHSIA)
+  handle.native_pixmap_handle = CloneHandleForIPC(native_pixmap_handle);
+#elif defined(OS_MAC)
+  handle.io_surface = io_surface;
+#elif defined(OS_WIN)
+  handle.dxgi_handle = CloneDXGIHandle(dxgi_handle.Get());
+#elif defined(OS_ANDROID)
+  NOTIMPLEMENTED();
+#endif
+  return handle;
+}
+
+void GpuMemoryBuffer::SetColorSpace(const ColorSpace& color_space) {}
+
+void GpuMemoryBuffer::SetHDRMetadata(const HDRMetadata& hdr_metadata) {}
+
+}  // namespace gfx
diff --git a/ui/gfx/gpu_memory_buffer.h b/ui/gfx/gpu_memory_buffer.h
new file mode 100644
index 0000000..9d6fc35
--- /dev/null
+++ b/ui/gfx/gpu_memory_buffer.h
@@ -0,0 +1,151 @@
+// 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.
+
+#ifndef UI_GFX_GPU_MEMORY_BUFFER_H_
+#define UI_GFX_GPU_MEMORY_BUFFER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/memory/unsafe_shared_memory_region.h"
+#include "build/build_config.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/generic_shared_memory_id.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/hdr_metadata.h"
+
+#if defined(USE_OZONE) || defined(OS_LINUX) || defined(OS_CHROMEOS)
+#include "ui/gfx/native_pixmap_handle.h"
+#elif defined(OS_MAC)
+#include "ui/gfx/mac/io_surface.h"
+#elif defined(OS_WIN)
+#include "base/win/scoped_handle.h"
+#elif defined(OS_ANDROID)
+#include "base/android/scoped_hardware_buffer_handle.h"
+#endif
+
+extern "C" typedef struct _ClientBuffer* ClientBuffer;
+
+namespace base {
+namespace trace_event {
+class ProcessMemoryDump;
+class MemoryAllocatorDumpGuid;
+}  // namespace trace_event
+}  // namespace base
+
+namespace gfx {
+
+class ColorSpace;
+
+enum GpuMemoryBufferType {
+  EMPTY_BUFFER,
+  SHARED_MEMORY_BUFFER,
+  IO_SURFACE_BUFFER,
+  NATIVE_PIXMAP,
+  DXGI_SHARED_HANDLE,
+  ANDROID_HARDWARE_BUFFER,
+  GPU_MEMORY_BUFFER_TYPE_LAST = ANDROID_HARDWARE_BUFFER
+};
+
+using GpuMemoryBufferId = GenericSharedMemoryId;
+
+// TODO(crbug.com/863011): Convert this to a proper class to ensure the state is
+// always consistent, particularly that the only one handle is set at the same
+// time and it corresponds to |type|.
+struct GFX_EXPORT GpuMemoryBufferHandle {
+  GpuMemoryBufferHandle();
+#if defined(OS_ANDROID)
+  explicit GpuMemoryBufferHandle(
+      base::android::ScopedHardwareBufferHandle handle);
+#endif
+  GpuMemoryBufferHandle(GpuMemoryBufferHandle&& other);
+  GpuMemoryBufferHandle& operator=(GpuMemoryBufferHandle&& other);
+  ~GpuMemoryBufferHandle();
+  GpuMemoryBufferHandle Clone() const;
+  bool is_null() const { return type == EMPTY_BUFFER; }
+  GpuMemoryBufferType type = GpuMemoryBufferType::EMPTY_BUFFER;
+  GpuMemoryBufferId id{0};
+  base::UnsafeSharedMemoryRegion region;
+  uint32_t offset = 0;
+  int32_t stride = 0;
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_FUCHSIA)
+  NativePixmapHandle native_pixmap_handle;
+#elif defined(OS_MAC)
+  ScopedIOSurface io_surface;
+#elif defined(OS_WIN)
+  base::win::ScopedHandle dxgi_handle;
+#elif defined(OS_ANDROID)
+  base::android::ScopedHardwareBufferHandle android_hardware_buffer;
+#endif
+};
+
+// This interface typically correspond to a type of shared memory that is also
+// shared with the GPU. A GPU memory buffer can be written to directly by
+// regular CPU code, but can also be read by the GPU.
+class GFX_EXPORT GpuMemoryBuffer {
+ public:
+  virtual ~GpuMemoryBuffer() {}
+
+  // Maps each plane of the buffer into the client's address space so it can be
+  // written to by the CPU. This call may block, for instance if the GPU needs
+  // to finish accessing the buffer or if CPU caches need to be synchronized.
+  // Returns false on failure.
+  virtual bool Map() = 0;
+
+  // Returns a pointer to the memory address of a plane. Buffer must have been
+  // successfully mapped using a call to Map() before calling this function.
+  virtual void* memory(size_t plane) = 0;
+
+  // Unmaps the buffer. It's illegal to use any pointer returned by memory()
+  // after this has been called.
+  virtual void Unmap() = 0;
+
+  // Returns the size in pixels of the first plane of the buffer.
+  virtual Size GetSize() const = 0;
+
+  // Returns the format for the buffer.
+  virtual BufferFormat GetFormat() const = 0;
+
+  // Fills the stride in bytes for each plane of the buffer. The stride of
+  // plane K is stored at index K-1 of the |stride| array.
+  virtual int stride(size_t plane) const = 0;
+
+  // Set the color space in which this buffer should be interpreted when used
+  // as an overlay. Note that this will not impact texturing from the buffer.
+  virtual void SetColorSpace(const ColorSpace& color_space);
+
+  // Set the HDR metadata for use when this buffer is used as an overlay. Note
+  // that this will not impact texturing from the buffer.
+  virtual void SetHDRMetadata(const HDRMetadata& hdr_metadata);
+
+  // Returns a unique identifier associated with buffer.
+  virtual GpuMemoryBufferId GetId() const = 0;
+
+  // Returns the type of this buffer.
+  virtual GpuMemoryBufferType GetType() const = 0;
+
+  // Returns a platform specific handle for this buffer which in particular can
+  // be sent over IPC. This duplicates file handles as appropriate, so that a
+  // caller takes ownership of the returned handle.
+  virtual GpuMemoryBufferHandle CloneHandle() const = 0;
+
+  // Type-checking downcast routine.
+  virtual ClientBuffer AsClientBuffer() = 0;
+
+  // Dumps information about the memory backing the GpuMemoryBuffer to |pmd|.
+  // The memory usage is attributed to |buffer_dump_guid|.
+  // |tracing_process_id| uniquely identifies the process owning the memory.
+  // |importance| is relevant only for the cases of co-ownership, the memory
+  // gets attributed to the owner with the highest importance.
+  virtual void OnMemoryDump(
+      base::trace_event::ProcessMemoryDump* pmd,
+      const base::trace_event::MemoryAllocatorDumpGuid& buffer_dump_guid,
+      uint64_t tracing_process_id,
+      int importance) const = 0;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_GPU_MEMORY_BUFFER_H_
diff --git a/ui/gfx/half_float.cc b/ui/gfx/half_float.cc
new file mode 100644
index 0000000..a7c6696
--- /dev/null
+++ b/ui/gfx/half_float.cc
@@ -0,0 +1,17 @@
+// Copyright (c) 2017 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.
+
+#include "ui/gfx/half_float.h"
+
+namespace gfx {
+
+void FloatToHalfFloat(const float* input, HalfFloat* output, size_t num) {
+  for (size_t i = 0; i < num; i++) {
+    float tmp = input[i] * 1.9259299444e-34f;
+    uint32_t tmp2 = *reinterpret_cast<uint32_t*>(&tmp) + (1 << 12);
+    output[i] = (tmp2 & 0x80000000UL) >> 16 | (tmp2 >> 13);
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/half_float.h b/ui/gfx/half_float.h
new file mode 100644
index 0000000..c5e48ce
--- /dev/null
+++ b/ui/gfx/half_float.h
@@ -0,0 +1,23 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_HALF_FLOAT_H_
+#define UI_GFX_HALF_FLOAT_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+typedef uint16_t HalfFloat;
+
+// Floats are expected to be within +/- 65535.0;
+GFX_EXPORT void FloatToHalfFloat(const float* input,
+                                 HalfFloat* output,
+                                 size_t num);
+}  // namespace gfx
+
+#endif  // UI_GFX_HALF_FLOAT_H_
diff --git a/ui/gfx/half_float_unittest.cc b/ui/gfx/half_float_unittest.cc
new file mode 100644
index 0000000..d6a1965
--- /dev/null
+++ b/ui/gfx/half_float_unittest.cc
@@ -0,0 +1,88 @@
+// Copyright (c) 2017 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.
+
+#include <math.h>
+
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/half_float.h"
+
+namespace gfx {
+
+class HalfFloatTest : public testing::Test {
+ public:
+  union FloatUIntUnion {
+    // this must come first for the initializations below to work
+    uint32_t fUInt;
+    float fFloat;
+  };
+
+  // Convert an IEEE 754 half-float to a float value
+  // that we can do math on.
+  float FromHalfFloat(HalfFloat half_float) {
+    int sign = (half_float & 0x8000) ? -1 : 1;
+    int exponent = (half_float >> 10) & 0x1F;
+    int fraction = half_float & 0x3FF;
+    if (exponent == 0) {
+      return powf(2.0f, -24.0f) * fraction;
+    } else if (exponent == 0x1F) {
+      return sign * 1000000000000.0f;
+    } else {
+      return pow(2.0f, exponent - 25) * (0x400 + fraction);
+    }
+  }
+
+  HalfFloat ConvertTruth(float f) {
+    if (f < 0.0)
+      return 0x8000 | ConvertTruth(-f);
+    int max = 0x8000;
+    int min = 0;
+    while (max - min > 1) {
+      int mid = (min + max) >> 1;
+      if (FromHalfFloat(mid) > f) {
+        max = mid;
+      } else {
+        min = mid;
+      }
+    }
+    float low = FromHalfFloat(min);
+    float high = FromHalfFloat(min + 1);
+    if (f - low <= high - f) {
+      return min;
+    } else {
+      return min + 1;
+    }
+  }
+
+  HalfFloat Convert(float f) {
+    HalfFloat ret;
+    FloatToHalfFloat(&f, &ret, 1);
+    return ret;
+  }
+};
+
+TEST_F(HalfFloatTest, NoCrashTest) {
+  Convert(nanf(""));
+  Convert(1.0E30f);
+  Convert(-1.0E30f);
+  Convert(1.0E-30f);
+  Convert(-1.0E-30f);
+}
+
+TEST_F(HalfFloatTest, SimpleTest) {
+  static float test[] = {
+      0.0f,    1.0f,    10.0f,    1000.0f,  65503.0f,
+      1.0E-3f, 1.0E-6f, 1.0E-20f, 1.0E-44f,
+  };
+  for (size_t i = 0; i < base::size(test); i++) {
+    EXPECT_EQ(ConvertTruth(test[i]), Convert(test[i])) << " float = "
+                                                       << test[i];
+    if (test[i] != 0.0) {
+      EXPECT_EQ(ConvertTruth(-test[i]), Convert(-test[i])) << " float = "
+                                                           << -test[i];
+    }
+  }
+}
+
+}  // namespace
diff --git a/ui/gfx/harfbuzz_font_skia.cc b/ui/gfx/harfbuzz_font_skia.cc
new file mode 100644
index 0000000..7b13a18
--- /dev/null
+++ b/ui/gfx/harfbuzz_font_skia.cc
@@ -0,0 +1,306 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/harfbuzz_font_skia.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <limits>
+#include <map>
+
+#include "base/check_op.h"
+#include "base/containers/mru_cache.h"
+#include "base/lazy_instance.h"
+#include "base/macros.h"
+#include "base/no_destructor.h"
+#include "build/build_config.h"
+#include "third_party/skia/include/core/SkFont.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "ui/gfx/render_text.h"
+#include "ui/gfx/skia_util.h"
+
+namespace gfx {
+
+namespace {
+
+class TypefaceData;
+
+// Maps from code points to glyph indices in a font.
+using GlyphCache = std::map<uint32_t, uint16_t>;
+
+// Wraps a custom user data attached to a hb_font object. Font data provider for
+// HarfBuzz using Skia. Copied from Blink.
+// TODO(ckocagil): Eliminate the duplication. http://crbug.com/368375
+struct FontData {
+  explicit FontData(GlyphCache* glyph_cache) : glyph_cache_(glyph_cache) {}
+
+  SkFont font_;
+  GlyphCache* glyph_cache_;
+};
+
+// Deletes the object at the given pointer after casting it to the given type.
+template<typename Type>
+void DeleteByType(void* data) {
+  Type* typed_data = reinterpret_cast<Type*>(data);
+  delete typed_data;
+}
+
+template<typename Type>
+void DeleteArrayByType(void* data) {
+  Type* typed_data = reinterpret_cast<Type*>(data);
+  delete[] typed_data;
+}
+
+// Outputs the |width| and |extents| of the glyph with index |codepoint| in
+// |paint|'s font.
+void GetGlyphWidthAndExtents(const SkFont& font,
+                             hb_codepoint_t codepoint,
+                             hb_position_t* width,
+                             hb_glyph_extents_t* extents) {
+  DCHECK_LE(codepoint, std::numeric_limits<uint16_t>::max());
+
+  SkScalar sk_width;
+  SkRect sk_bounds;
+  uint16_t glyph = static_cast<uint16_t>(codepoint);
+
+  font.getWidths(&glyph, 1, &sk_width, &sk_bounds);
+  if (width)
+    *width = SkiaScalarToHarfBuzzUnits(sk_width);
+  if (extents) {
+    // Invert y-axis because Skia is y-grows-down but we set up HarfBuzz to be
+    // y-grows-up.
+    extents->x_bearing = SkiaScalarToHarfBuzzUnits(sk_bounds.fLeft);
+    extents->y_bearing = SkiaScalarToHarfBuzzUnits(-sk_bounds.fTop);
+    extents->width = SkiaScalarToHarfBuzzUnits(sk_bounds.width());
+    extents->height = SkiaScalarToHarfBuzzUnits(-sk_bounds.height());
+  }
+}
+
+// Writes the |glyph| index for the given |unicode| code point. Returns whether
+// the glyph exists, i.e. it is not a missing glyph.
+hb_bool_t GetGlyph(hb_font_t* font,
+                   void* data,
+                   hb_codepoint_t unicode,
+                   hb_codepoint_t variation_selector,
+                   hb_codepoint_t* glyph,
+                   void* user_data) {
+  FontData* font_data = reinterpret_cast<FontData*>(data);
+  GlyphCache* cache = font_data->glyph_cache_;
+
+  GlyphCache::iterator iter = cache->find(unicode);
+  if (iter == cache->end()) {
+    auto result = cache->insert(
+        std::make_pair(unicode, font_data->font_.unicharToGlyph(unicode)));
+    DCHECK(result.second);
+    iter = result.first;
+  }
+
+  *glyph = iter->second;
+  return !!*glyph;
+}
+
+hb_bool_t GetNominalGlyph(hb_font_t* font,
+                          void* data,
+                          hb_codepoint_t unicode,
+                          hb_codepoint_t* glyph,
+                          void* user_data) {
+  return GetGlyph(font, data, unicode, 0, glyph, user_data);
+}
+
+// Returns the horizontal advance value of the |glyph|.
+hb_position_t GetGlyphHorizontalAdvance(hb_font_t* font,
+                                        void* data,
+                                        hb_codepoint_t glyph,
+                                        void* user_data) {
+  FontData* font_data = reinterpret_cast<FontData*>(data);
+  hb_position_t advance = 0;
+
+  GetGlyphWidthAndExtents(font_data->font_, glyph, &advance, 0);
+  return advance;
+}
+
+hb_bool_t GetGlyphHorizontalOrigin(hb_font_t* font,
+                                   void* data,
+                                   hb_codepoint_t glyph,
+                                   hb_position_t* x,
+                                   hb_position_t* y,
+                                   void* user_data) {
+  // Just return true, like the HarfBuzz-FreeType implementation.
+  return true;
+}
+
+hb_position_t GetGlyphKerning(FontData* font_data,
+                              hb_codepoint_t first_glyph,
+                              hb_codepoint_t second_glyph) {
+  SkTypeface* typeface = font_data->font_.getTypeface();
+  const uint16_t glyphs[2] = { static_cast<uint16_t>(first_glyph),
+                               static_cast<uint16_t>(second_glyph) };
+  int32_t kerning_adjustments[1] = { 0 };
+
+  if (!typeface->getKerningPairAdjustments(glyphs, 2, kerning_adjustments))
+    return 0;
+
+  SkScalar upm = SkIntToScalar(typeface->getUnitsPerEm());
+  SkScalar size = font_data->font_.getSize();
+  return SkiaScalarToHarfBuzzUnits(SkIntToScalar(kerning_adjustments[0]) *
+                                   size / upm);
+}
+
+hb_position_t GetGlyphHorizontalKerning(hb_font_t* font,
+                                        void* data,
+                                        hb_codepoint_t left_glyph,
+                                        hb_codepoint_t right_glyph,
+                                        void* user_data) {
+  FontData* font_data = reinterpret_cast<FontData*>(data);
+  return GetGlyphKerning(font_data, left_glyph, right_glyph);
+}
+
+hb_position_t GetGlyphVerticalKerning(hb_font_t* font,
+                                      void* data,
+                                      hb_codepoint_t top_glyph,
+                                      hb_codepoint_t bottom_glyph,
+                                      void* user_data) {
+  FontData* font_data = reinterpret_cast<FontData*>(data);
+  return GetGlyphKerning(font_data, top_glyph, bottom_glyph);
+}
+
+// Writes the |extents| of |glyph|.
+hb_bool_t GetGlyphExtents(hb_font_t* font,
+                          void* data,
+                          hb_codepoint_t glyph,
+                          hb_glyph_extents_t* extents,
+                          void* user_data) {
+  FontData* font_data = reinterpret_cast<FontData*>(data);
+
+  GetGlyphWidthAndExtents(font_data->font_, glyph, 0, extents);
+  return true;
+}
+
+class FontFuncs {
+ public:
+  FontFuncs() : font_funcs_(hb_font_funcs_create()) {
+    hb_font_funcs_set_variation_glyph_func(font_funcs_, GetGlyph, 0, 0);
+    hb_font_funcs_set_nominal_glyph_func(font_funcs_, GetNominalGlyph, 0, 0);
+    hb_font_funcs_set_glyph_h_advance_func(
+        font_funcs_, GetGlyphHorizontalAdvance, 0, 0);
+    hb_font_funcs_set_glyph_h_kerning_func(
+        font_funcs_, GetGlyphHorizontalKerning, 0, 0);
+    hb_font_funcs_set_glyph_h_origin_func(
+        font_funcs_, GetGlyphHorizontalOrigin, 0, 0);
+    hb_font_funcs_set_glyph_v_kerning_func(
+        font_funcs_, GetGlyphVerticalKerning, 0, 0);
+    hb_font_funcs_set_glyph_extents_func(
+        font_funcs_, GetGlyphExtents, 0, 0);
+    hb_font_funcs_make_immutable(font_funcs_);
+  }
+
+  FontFuncs(const FontFuncs&) = delete;
+  FontFuncs& operator=(const FontFuncs&) = delete;
+
+  ~FontFuncs() {
+    hb_font_funcs_destroy(font_funcs_);
+  }
+
+  hb_font_funcs_t* get() { return font_funcs_; }
+
+ private:
+  hb_font_funcs_t* font_funcs_;
+};
+
+base::LazyInstance<FontFuncs>::Leaky g_font_funcs = LAZY_INSTANCE_INITIALIZER;
+
+// Returns the raw data of the font table |tag|.
+hb_blob_t* GetFontTable(hb_face_t* face, hb_tag_t tag, void* user_data) {
+  SkTypeface* typeface = reinterpret_cast<SkTypeface*>(user_data);
+
+  const size_t table_size = typeface->getTableSize(tag);
+  if (!table_size)
+    return 0;
+
+  std::unique_ptr<char[]> buffer(new char[table_size]);
+  if (!buffer)
+    return 0;
+  size_t actual_size = typeface->getTableData(tag, 0, table_size, buffer.get());
+  if (table_size != actual_size)
+    return 0;
+
+  char* buffer_raw = buffer.release();
+  return hb_blob_create(buffer_raw, static_cast<uint32_t>(table_size),
+                        HB_MEMORY_MODE_WRITABLE, buffer_raw,
+                        DeleteArrayByType<char>);
+}
+
+// For a given skia typeface, maps to its harfbuzz face and its glyphs cache.
+class TypefaceData {
+ public:
+  explicit TypefaceData(sk_sp<SkTypeface> skia_face) : sk_typeface_(skia_face) {
+    face_ = hb_face_create_for_tables(GetFontTable, skia_face.get(), nullptr);
+    DCHECK(face_);
+  }
+
+  TypefaceData(TypefaceData&& data) {
+    face_ = data.face_;
+    glyphs_ = std::move(data.glyphs_);
+    data.face_ = nullptr;
+  }
+
+  TypefaceData(const TypefaceData&) = delete;
+  TypefaceData& operator=(const TypefaceData&) = delete;
+
+  ~TypefaceData() { hb_face_destroy(face_); }
+
+  hb_face_t* face() { return face_; }
+  GlyphCache* glyphs() { return &glyphs_; }
+
+ private:
+  TypefaceData() = delete;
+
+  GlyphCache glyphs_;
+  hb_face_t* face_ = nullptr;
+
+  // The skia typeface must outlive |face_| since it's being used by harfbuzz.
+  sk_sp<SkTypeface> sk_typeface_;
+};
+
+}  // namespace
+
+// Creates a HarfBuzz font from the given Skia face and text size.
+hb_font_t* CreateHarfBuzzFont(sk_sp<SkTypeface> skia_face,
+                              SkScalar text_size,
+                              const FontRenderParams& params,
+                              bool subpixel_rendering_suppressed) {
+  // A cache from Skia font to harfbuzz typeface information.
+  using TypefaceCache = base::MRUCache<SkFontID, TypefaceData>;
+
+  constexpr int kTypefaceCacheSize = 64;
+  static base::NoDestructor<TypefaceCache> face_caches(kTypefaceCacheSize);
+
+  TypefaceCache* typeface_cache = face_caches.get();
+  TypefaceCache::iterator typeface_data =
+      typeface_cache->Get(skia_face->uniqueID());
+  if (typeface_data == typeface_cache->end()) {
+    TypefaceData new_typeface_data(skia_face);
+    typeface_data = typeface_cache->Put(skia_face->uniqueID(),
+                                        std::move(new_typeface_data));
+  }
+
+  DCHECK(typeface_data->second.face());
+  hb_font_t* harfbuzz_font = hb_font_create(typeface_data->second.face());
+
+  const int scale = SkiaScalarToHarfBuzzUnits(text_size);
+  hb_font_set_scale(harfbuzz_font, scale, scale);
+  FontData* hb_font_data = new FontData(typeface_data->second.glyphs());
+  hb_font_data->font_.setTypeface(std::move(skia_face));
+  hb_font_data->font_.setSize(text_size);
+  // TODO(ckocagil): Do we need to update these params later?
+  internal::ApplyRenderParams(params, subpixel_rendering_suppressed,
+                              &hb_font_data->font_);
+  hb_font_set_funcs(harfbuzz_font, g_font_funcs.Get().get(), hb_font_data,
+                    DeleteByType<FontData>);
+  hb_font_make_immutable(harfbuzz_font);
+  return harfbuzz_font;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/harfbuzz_font_skia.h b/ui/gfx/harfbuzz_font_skia.h
new file mode 100644
index 0000000..abc6c79
--- /dev/null
+++ b/ui/gfx/harfbuzz_font_skia.h
@@ -0,0 +1,25 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_HARFBUZZ_FONT_SKIA_H_
+#define UI_GFX_HARFBUZZ_FONT_SKIA_H_
+
+#include "third_party/skia/include/core/SkRefCnt.h"
+#include "third_party/skia/include/core/SkScalar.h"
+#include "ui/gfx/font_render_params.h"
+
+#include <hb.h>
+
+class SkTypeface;
+
+namespace gfx {
+
+hb_font_t* CreateHarfBuzzFont(sk_sp<SkTypeface> skia_face,
+                              SkScalar text_size,
+                              const FontRenderParams& params,
+                              bool subpixel_rendering_suppressed);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_HARFBUZZ_FONT_SKIA_H_
diff --git a/ui/gfx/hdr_metadata.cc b/ui/gfx/hdr_metadata.cc
new file mode 100644
index 0000000..ed20c0f
--- /dev/null
+++ b/ui/gfx/hdr_metadata.cc
@@ -0,0 +1,19 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/hdr_metadata.h"
+
+namespace gfx {
+
+ColorVolumeMetadata::ColorVolumeMetadata() = default;
+ColorVolumeMetadata::ColorVolumeMetadata(const ColorVolumeMetadata& rhs) =
+    default;
+ColorVolumeMetadata& ColorVolumeMetadata::operator=(
+    const ColorVolumeMetadata& rhs) = default;
+
+HDRMetadata::HDRMetadata() = default;
+HDRMetadata::HDRMetadata(const HDRMetadata& rhs) = default;
+HDRMetadata& HDRMetadata::operator=(const HDRMetadata& rhs) = default;
+
+}  // namespace gfx
diff --git a/ui/gfx/hdr_metadata.h b/ui/gfx/hdr_metadata.h
new file mode 100644
index 0000000..8828158
--- /dev/null
+++ b/ui/gfx/hdr_metadata.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_HDR_METADATA_H_
+#define UI_GFX_HDR_METADATA_H_
+
+#include "media/base/media_export.h"
+#include "ui/gfx/geometry/point_f.h"
+
+namespace gfx {
+
+// SMPTE ST 2086 color volume metadata.
+struct MEDIA_EXPORT ColorVolumeMetadata {
+  using Chromaticity = gfx::PointF;
+  Chromaticity primary_r;
+  Chromaticity primary_g;
+  Chromaticity primary_b;
+  Chromaticity white_point;
+  float luminance_max = 0;
+  float luminance_min = 0;
+
+  ColorVolumeMetadata() = default;
+  ColorVolumeMetadata(const ColorVolumeMetadata& rhs) = default;
+  ColorVolumeMetadata& operator=(const ColorVolumeMetadata& rhs) = default;
+
+  bool operator==(const ColorVolumeMetadata& rhs) const {
+    return ((primary_r == rhs.primary_r) && (primary_g == rhs.primary_g) &&
+            (primary_b == rhs.primary_b) && (white_point == rhs.white_point) &&
+            (luminance_max == rhs.luminance_max) &&
+            (luminance_min == rhs.luminance_min));
+  }
+};
+
+// HDR metadata common for HDR10 and WebM/VP9-based HDR formats.
+struct MEDIA_EXPORT HDRMetadata {
+  ColorVolumeMetadata color_volume_metadata;
+  // Max content light level (CLL), i.e. maximum brightness level present in the
+  // stream), in nits.
+  unsigned max_content_light_level = 0;
+  // Max frame-average light level (FALL), i.e. maximum average brightness of
+  // the brightest frame in the stream), in nits.
+  unsigned max_frame_average_light_level = 0;
+
+  HDRMetadata() = default;
+  HDRMetadata(const HDRMetadata& rhs) = default;
+  HDRMetadata& operator=(const HDRMetadata& rhs) = default;
+
+  bool IsValid() const {
+    return !((max_content_light_level == 0) &&
+             (max_frame_average_light_level == 0) &&
+             (color_volume_metadata == ColorVolumeMetadata()));
+  }
+
+  bool operator==(const HDRMetadata& rhs) const {
+    return (
+        (max_content_light_level == rhs.max_content_light_level) &&
+        (max_frame_average_light_level == rhs.max_frame_average_light_level) &&
+        (color_volume_metadata == rhs.color_volume_metadata));
+  }
+
+  bool operator!=(const HDRMetadata& rhs) const { return !(*this == rhs); }
+};
+
+// HDR metadata types as described in
+// https://w3c.github.io/media-capabilities/#enumdef-hdrmetadatatype
+enum class HdrMetadataType {
+  kNone,
+  kSmpteSt2086,
+  kSmpteSt2094_10,
+  kSmpteSt2094_40,
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_HDR_METADATA_H_
diff --git a/ui/gfx/hdr_static_metadata.cc b/ui/gfx/hdr_static_metadata.cc
new file mode 100644
index 0000000..b5b3f0a
--- /dev/null
+++ b/ui/gfx/hdr_static_metadata.cc
@@ -0,0 +1,16 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/hdr_static_metadata.h"
+
+namespace gfx {
+
+HDRStaticMetadata::HDRStaticMetadata() = default;
+HDRStaticMetadata::HDRStaticMetadata(double max, double max_avg, double min)
+    : max(max), max_avg(max_avg), min(min) {}
+HDRStaticMetadata::HDRStaticMetadata(const HDRStaticMetadata& rhs) = default;
+HDRStaticMetadata& HDRStaticMetadata::operator=(const HDRStaticMetadata& rhs) =
+    default;
+
+}  // namespace gfx
diff --git a/ui/gfx/hdr_static_metadata.h b/ui/gfx/hdr_static_metadata.h
new file mode 100644
index 0000000..035d3ac
--- /dev/null
+++ b/ui/gfx/hdr_static_metadata.h
@@ -0,0 +1,40 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_HDR_STATIC_METADATA_H_
+#define UI_GFX_HDR_STATIC_METADATA_H_
+
+#include "ui/gfx/color_space_export.h"
+
+namespace gfx {
+
+// This structure is used to define the HDR static capabilities of a display.
+// Reflects CEA 861.G-2018, Sec.7.5.13, "HDR Static Metadata Data Block"
+// A value of 0.0 in any of the fields means that it's not indicated.
+struct COLOR_SPACE_EXPORT HDRStaticMetadata {
+  // "Desired Content Max Luminance Data. This is the content’s absolute peak
+  // luminance (in cd/m2) (likely only in a small area of the screen) that the
+  // display prefers for optimal content rendering."
+  double max;
+  // "Desired Content Max Frame-average Luminance. This is the content’s max
+  // frame-average luminance (in cd/m2) that the display prefers for optimal
+  // content rendering."
+  double max_avg;
+  // "Desired Content Min Luminance. This is the minimum value of the content
+  // (in cd/m2) that the display prefers for optimal content rendering."
+  double min;
+
+  HDRStaticMetadata();
+  HDRStaticMetadata(double max, double max_avg, double min);
+  HDRStaticMetadata(const HDRStaticMetadata& rhs);
+  HDRStaticMetadata& operator=(const HDRStaticMetadata& rhs);
+
+  bool operator==(const HDRStaticMetadata& rhs) const {
+    return ((max == rhs.max) && (max_avg == rhs.max_avg) && (min == rhs.min));
+  }
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_HDR_STATIC_METADATA_H_
diff --git a/ui/gfx/icc_profile.cc b/ui/gfx/icc_profile.cc
new file mode 100644
index 0000000..94f0e7c
--- /dev/null
+++ b/ui/gfx/icc_profile.cc
@@ -0,0 +1,228 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/icc_profile.h"
+
+#include <list>
+#include <set>
+
+#include "base/command_line.h"
+#include "base/containers/mru_cache.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/synchronization/lock.h"
+#include "third_party/skia/include/core/SkColorSpace.h"
+#include "third_party/skia/include/third_party/skcms/skcms.h"
+#include "ui/gfx/skia_color_space_util.h"
+
+namespace gfx {
+
+namespace {
+
+static const size_t kMaxCachedICCProfiles = 16;
+
+// An MRU cache mapping data to ICCProfile objects, to avoid re-parsing
+// profiles every time they are read.
+using DataToProfileCacheBase = base::MRUCache<std::vector<char>, ICCProfile>;
+class DataToProfileCache : public DataToProfileCacheBase {
+ public:
+  DataToProfileCache() : DataToProfileCacheBase(kMaxCachedICCProfiles) {}
+};
+base::LazyInstance<DataToProfileCache>::Leaky g_data_to_profile_cache =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Lock that must be held to access |g_data_to_profile_cache|.
+base::LazyInstance<base::Lock>::Leaky g_icc_profile_lock =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+void ICCProfile::Internals::Initialize() {
+  // Start out with no parametric data.
+  if (data_.empty())
+    return;
+
+  // Parse the profile.
+  skcms_ICCProfile profile;
+  if (!skcms_Parse(data_.data(), data_.size(), &profile)) {
+    DLOG(ERROR) << "Failed to parse ICC profile.";
+    return;
+  }
+
+  // We have seen many users with profiles that don't have a D50 white point.
+  // Windows appears to detect these profiles, and not use them for OS drawing.
+  // It still returns them when we query the system for the installed profile.
+  // For consistency (and to match old behavior) we reject these profiles on
+  // all platforms.
+  // https://crbug.com/847024
+  const skcms_Matrix3x3& m(profile.toXYZD50);
+  float wX = m.vals[0][0] + m.vals[0][1] + m.vals[0][2];
+  float wY = m.vals[1][0] + m.vals[1][1] + m.vals[1][2];
+  float wZ = m.vals[2][0] + m.vals[2][1] + m.vals[2][2];
+  static const float kD50_WhitePoint[3] = { 0.96420f, 1.00000f, 0.82491f };
+  if (fabsf(wX - kD50_WhitePoint[0]) > 0.04f ||
+      fabsf(wY - kD50_WhitePoint[1]) > 0.04f ||
+      fabsf(wZ - kD50_WhitePoint[2]) > 0.04f) {
+    return;
+  }
+
+  // At this point, the profile is considered valid. We still need to determine
+  // if it's representable with a parametric transfer function.
+  is_valid_ = true;
+
+  // Extract the primary matrix, and assume that transfer function is sRGB until
+  // we get something more precise.
+  to_XYZD50_ = profile.toXYZD50;
+  transfer_fn_ = SkNamedTransferFn::kSRGB;
+
+  // Coerce it into a rasterization destination (if possible). If the profile
+  // can't be approximated accurately, then use an sRGB transfer function and
+  // return failure. We will continue to use the gamut from this profile.
+  if (!skcms_MakeUsableAsDestinationWithSingleCurve(&profile)) {
+    DLOG(ERROR) << "Parsed ICC profile but can't make usable as destination, "
+                   "using sRGB gamma";
+    return;
+  }
+
+  // If SkColorSpace will treat the gamma as that of sRGB, then use the named
+  // constants.
+  sk_sp<SkColorSpace> sk_color_space = SkColorSpace::Make(profile);
+  if (!sk_color_space) {
+    DLOG(ERROR) << "Parsed ICC profile but cannot create SkColorSpace from it, "
+                   "using sRGB gamma.";
+    return;
+  }
+
+  // We were able to get a parametric representation of the transfer function.
+  is_parametric_ = true;
+
+  if (sk_color_space->gammaCloseToSRGB())
+    return;
+
+  // We assume that if we accurately approximated the profile, then the
+  // single-curve version (which may have higher error) is also okay. If we
+  // want to maintain the distinction between accurate and inaccurate profiles,
+  // we could check to see if the single-curve version is/ approximately equal
+  // to the original (or to the multi-channel approximation).
+  transfer_fn_ = profile.trc[0].parametric;
+}
+
+ICCProfile::ICCProfile() = default;
+ICCProfile::ICCProfile(ICCProfile&& other) = default;
+ICCProfile::ICCProfile(const ICCProfile& other) = default;
+ICCProfile& ICCProfile::operator=(ICCProfile&& other) = default;
+ICCProfile& ICCProfile::operator=(const ICCProfile& other) = default;
+ICCProfile::~ICCProfile() = default;
+
+bool ICCProfile::operator==(const ICCProfile& other) const {
+  if (!internals_ && !other.internals_)
+    return true;
+  if (internals_ && other.internals_) {
+    return internals_->data_ == other.internals_->data_;
+  }
+  return false;
+}
+
+bool ICCProfile::operator!=(const ICCProfile& other) const {
+  return !(*this == other);
+}
+
+bool ICCProfile::IsValid() const {
+  return internals_ ? internals_->is_valid_ : false;
+}
+
+std::vector<char> ICCProfile::GetData() const {
+  return internals_ ? internals_->data_ : std::vector<char>();
+}
+
+// static
+ICCProfile ICCProfile::FromData(const void* data_as_void, size_t size) {
+  const char* data_as_byte = reinterpret_cast<const char*>(data_as_void);
+  std::vector<char> data(data_as_byte, data_as_byte + size);
+
+  base::AutoLock lock(g_icc_profile_lock.Get());
+
+  // See if there is already an entry with the same data. If so, return that
+  // entry. If not, parse the data.
+  ICCProfile icc_profile;
+  auto found_by_data = g_data_to_profile_cache.Get().Get(data);
+  if (found_by_data != g_data_to_profile_cache.Get().end()) {
+    icc_profile = found_by_data->second;
+  } else {
+    icc_profile.internals_ = base::MakeRefCounted<Internals>(std::move(data));
+  }
+
+  // Insert the profile into all caches.
+  g_data_to_profile_cache.Get().Put(icc_profile.internals_->data_, icc_profile);
+
+  return icc_profile;
+}
+
+ColorSpace ICCProfile::GetColorSpace() const {
+  if (!internals_ || !internals_->is_valid_)
+    return ColorSpace();
+
+  return ColorSpace(ColorSpace::PrimaryID::CUSTOM,
+                    ColorSpace::TransferID::CUSTOM, ColorSpace::MatrixID::RGB,
+                    ColorSpace::RangeID::FULL, &internals_->to_XYZD50_,
+                    &internals_->transfer_fn_);
+}
+
+ColorSpace ICCProfile::GetPrimariesOnlyColorSpace() const {
+  if (!internals_ || !internals_->is_valid_)
+    return ColorSpace();
+
+  return ColorSpace(ColorSpace::PrimaryID::CUSTOM,
+                    ColorSpace::TransferID::IEC61966_2_1,
+                    ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL,
+                    &internals_->to_XYZD50_, nullptr);
+}
+
+bool ICCProfile::IsColorSpaceAccurate() const {
+  if (!internals_)
+    return false;
+
+  if (!internals_->is_valid_)
+    return false;
+
+  return internals_->is_parametric_;
+}
+
+// static
+ICCProfile ICCProfile::FromColorSpace(const ColorSpace& color_space) {
+  if (!color_space.IsValid()) {
+    return ICCProfile();
+  }
+  if (color_space.GetMatrixID() != ColorSpace::MatrixID::RGB) {
+    DLOG(ERROR) << "Not creating non-RGB ICCProfile";
+    return ICCProfile();
+  }
+  if (color_space.GetRangeID() != ColorSpace::RangeID::FULL) {
+    DLOG(ERROR) << "Not creating non-full-range ICCProfile";
+    return ICCProfile();
+  }
+  skcms_Matrix3x3 to_XYZD50_matrix;
+  color_space.GetPrimaryMatrix(&to_XYZD50_matrix);
+  skcms_TransferFunction fn;
+  if (!color_space.GetTransferFunction(&fn)) {
+    DLOG(ERROR) << "Failed to get ColorSpace transfer function for ICCProfile.";
+    return ICCProfile();
+  }
+  sk_sp<SkData> data = SkWriteICCProfile(fn, to_XYZD50_matrix);
+  if (!data) {
+    DLOG(ERROR) << "Failed to create SkICC.";
+    return ICCProfile();
+  }
+  return FromData(data->data(), data->size());
+}
+
+ICCProfile::Internals::Internals(std::vector<char> data)
+    : data_(std::move(data)) {
+  // Parse the ICC profile
+  Initialize();
+}
+
+ICCProfile::Internals::~Internals() {}
+
+}  // namespace gfx
diff --git a/ui/gfx/icc_profile.h b/ui/gfx/icc_profile.h
new file mode 100644
index 0000000..542f703
--- /dev/null
+++ b/ui/gfx/icc_profile.h
@@ -0,0 +1,107 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ICC_PROFILE_H_
+#define UI_GFX_ICC_PROFILE_H_
+
+#include <stdint.h>
+#include <set>
+#include <vector>
+
+#include "base/gtest_prod_util.h"
+#include "base/memory/ref_counted.h"
+#include "third_party/skia/include/third_party/skcms/skcms.h"
+#include "ui/gfx/color_space.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
+
+namespace IPC {
+template <class P>
+struct ParamTraits;
+}  // namespace IPC
+
+namespace gfx {
+
+// Used to represent a full ICC profile, usually retrieved from a monitor. It
+// can be lossily compressed into a ColorSpace object. This structure should
+// only be sent from higher-privilege processes to lower-privilege processes,
+// as parsing this structure is not secure.
+class COLOR_SPACE_EXPORT ICCProfile {
+ public:
+  ICCProfile();
+  ICCProfile(ICCProfile&& other);
+  ICCProfile(const ICCProfile& other);
+  ICCProfile& operator=(ICCProfile&& other);
+  ICCProfile& operator=(const ICCProfile& other);
+  ~ICCProfile();
+  bool operator==(const ICCProfile& other) const;
+  bool operator!=(const ICCProfile& other) const;
+
+  // Returns true if this profile was successfully parsed by SkICC and will
+  // return a valid ColorSpace.
+  bool IsValid() const;
+
+  // Create directly from profile data. This function should be called only
+  // in the browser process (and the results from there sent to other
+  // processes).
+  static ICCProfile FromData(const void* icc_profile, size_t size);
+
+  // Create a profile for a color space. Returns an invalid profile if the
+  // specified space is not expressable as an ICCProfile.
+  static ICCProfile FromColorSpace(const gfx::ColorSpace& color_space);
+
+  // Return a ColorSpace that best represents this ICCProfile.
+  ColorSpace GetColorSpace() const;
+
+  // Return a ColorSpace with the primaries from this ICCProfile and an
+  // sRGB transfer function.
+  ColorSpace GetPrimariesOnlyColorSpace() const;
+
+  // Returns true if GetColorSpace returns an accurate representation of this
+  // ICCProfile. This could be false if the result of GetColorSpace had to
+  // approximate transfer functions.
+  bool IsColorSpaceAccurate() const;
+
+  // Return the data for the profile.
+  std::vector<char> GetData() const;
+
+ private:
+  class Internals : public base::RefCountedThreadSafe<ICCProfile::Internals> {
+   public:
+    explicit Internals(std::vector<char>);
+
+    const std::vector<char> data_;
+
+    // True iff we can create a valid ColorSpace (and ColorTransform) from this
+    // object. The transform may be LUT-based (using an SkColorSpaceXform to
+    // compute the lut).
+    bool is_valid_ = false;
+
+    // True iff |to_XYZD50_| and |transfer_fn_| are accurate representations of
+    // the data in this profile. In this case ColorTransforms created from this
+    // profile will be analytic and not LUT-based.
+    bool is_parametric_ = false;
+
+    // The best-fit parametric primaries and transfer function.
+    skcms_Matrix3x3 to_XYZD50_;
+    skcms_TransferFunction transfer_fn_;
+
+   protected:
+    friend class base::RefCountedThreadSafe<ICCProfile::Internals>;
+    void Initialize();
+    virtual ~Internals();
+  };
+  scoped_refptr<Internals> internals_;
+
+  FRIEND_TEST_ALL_PREFIXES(SimpleColorSpace, BT709toSRGBICC);
+  FRIEND_TEST_ALL_PREFIXES(SimpleColorSpace, GetColorSpace);
+  friend int ::LLVMFuzzerTestOneInput(const uint8_t*, size_t);
+  friend class ColorSpace;
+  friend class ColorTransformInternal;
+  friend struct IPC::ParamTraits<gfx::ICCProfile>;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ICC_PROFILE_H_
diff --git a/ui/gfx/icc_profile_unittest.cc b/ui/gfx/icc_profile_unittest.cc
new file mode 100644
index 0000000..29c4ff8
--- /dev/null
+++ b/ui/gfx/icc_profile_unittest.cc
@@ -0,0 +1,138 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/icc_profile.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/skia_color_space_util.h"
+#include "ui/gfx/test/icc_profiles.h"
+
+namespace gfx {
+
+TEST(ICCProfile, Conversions) {
+  ICCProfile icc_profile = ICCProfileForTestingColorSpin();
+  ColorSpace color_space_from_icc_profile = icc_profile.GetColorSpace();
+
+  ICCProfile icc_profile_from_color_space =
+      ICCProfile::FromColorSpace(color_space_from_icc_profile);
+  EXPECT_TRUE(icc_profile_from_color_space.IsValid());
+  EXPECT_NE(icc_profile, icc_profile_from_color_space);
+}
+
+TEST(ICCProfile, SRGB) {
+  ICCProfile icc_profile = ICCProfileForTestingSRGB();
+  ColorSpace color_space = ColorSpace::CreateSRGB();
+  sk_sp<SkColorSpace> sk_color_space = SkColorSpace::MakeSRGB();
+
+  // The ICC profile parser should note that this is SRGB.
+  EXPECT_EQ(icc_profile.GetColorSpace(), ColorSpace::CreateSRGB());
+  EXPECT_EQ(icc_profile.GetColorSpace().ToSkColorSpace().get(),
+            sk_color_space.get());
+  // The generated color space should recognize that this is SRGB.
+  EXPECT_EQ(color_space.ToSkColorSpace().get(), sk_color_space.get());
+}
+
+TEST(ICCProfile, Equality) {
+  ICCProfile spin_profile = ICCProfileForTestingColorSpin();
+  ICCProfile adobe_profile = ICCProfileForTestingAdobeRGB();
+  EXPECT_TRUE(spin_profile == spin_profile);
+  EXPECT_FALSE(spin_profile != spin_profile);
+  EXPECT_FALSE(spin_profile == adobe_profile);
+  EXPECT_TRUE(spin_profile != adobe_profile);
+
+  gfx::ColorSpace spin_space = spin_profile.GetColorSpace();
+  gfx::ColorSpace adobe_space = adobe_profile.GetColorSpace();
+  EXPECT_TRUE(spin_space == spin_space);
+  EXPECT_FALSE(spin_space != spin_space);
+  EXPECT_FALSE(spin_space == adobe_space);
+  EXPECT_TRUE(spin_space != adobe_space);
+
+  EXPECT_TRUE(!!spin_space.ToSkColorSpace());
+  EXPECT_TRUE(!!adobe_space.ToSkColorSpace());
+  EXPECT_FALSE(SkColorSpace::Equals(
+      spin_space.ToSkColorSpace().get(),
+      adobe_space.ToSkColorSpace().get()));
+}
+
+TEST(ICCProfile, ParametricVersusExactInaccurate) {
+  // This ICC profile has three transfer functions that differ significantly,
+  // but ICCProfiles are always either invalid or considered accurate (and in
+  // this case, each curve is approximated, so the profile is "accurate").
+  // See comments in ICCProfile::Internals::Analyze.
+  ICCProfile multi_tr_fn = ICCProfileForTestingNoAnalyticTrFn();
+  EXPECT_TRUE(multi_tr_fn.IsColorSpaceAccurate());
+
+  // We are capable of generating a parametric approximation.
+  ICCProfile profile;
+  profile = ICCProfile::FromColorSpace(multi_tr_fn.GetColorSpace());
+  EXPECT_TRUE(profile.IsValid());
+  EXPECT_NE(profile, multi_tr_fn);
+}
+
+TEST(ICCProfile, ParametricVersusExactOvershoot) {
+  // This ICC profile has a transfer function with T(1) that is greater than 1
+  // in the approximation, but is still close enough to be considered accurate.
+  ICCProfile overshoot = ICCProfileForTestingOvershoot();
+  EXPECT_TRUE(overshoot.IsColorSpaceAccurate());
+
+  ICCProfile profile;
+  profile = ICCProfile::FromColorSpace(overshoot.GetColorSpace());
+  EXPECT_TRUE(profile.IsValid());
+  EXPECT_NE(profile, overshoot);
+}
+
+TEST(ICCProfile, ParametricVersusExactAdobe) {
+  // This ICC profile is precisely represented by the parametric color space.
+  ICCProfile accurate = ICCProfileForTestingAdobeRGB();
+  EXPECT_TRUE(accurate.IsColorSpaceAccurate());
+
+  ICCProfile profile;
+  profile = ICCProfile::FromColorSpace(accurate.GetColorSpace());
+  EXPECT_TRUE(profile.IsValid());
+  EXPECT_NE(profile, accurate);
+}
+
+TEST(ICCProfile, ParametricVersusExactA2B) {
+  // This ICC profile has only an A2B representation. We cannot transform to
+  // A2B only ICC profiles, so this should be marked as invalid.
+  ICCProfile a2b = ICCProfileForTestingA2BOnly();
+  EXPECT_FALSE(a2b.GetColorSpace().IsValid());
+
+  // Even though it is invalid, it should not be equal to the empty constructor
+  EXPECT_NE(a2b, gfx::ICCProfile());
+}
+
+TEST(ICCProfile, GarbageData) {
+  std::vector<char> bad_data(10 * 1024);
+  const char* bad_data_string = "deadbeef";
+  for (size_t i = 0; i < bad_data.size(); ++i)
+    bad_data[i] = bad_data_string[i % 8];
+  ICCProfile garbage_profile =
+      ICCProfile::FromData(bad_data.data(), bad_data.size());
+  EXPECT_FALSE(garbage_profile.IsValid());
+  EXPECT_FALSE(garbage_profile.GetColorSpace().IsValid());
+
+  ICCProfile default_ctor_profile;
+  EXPECT_FALSE(default_ctor_profile.IsValid());
+  EXPECT_FALSE(default_ctor_profile.GetColorSpace().IsValid());
+}
+
+TEST(ICCProfile, GenericRGB) {
+  ColorSpace icc_profile = ICCProfileForTestingGenericRGB().GetColorSpace();
+  ColorSpace color_space(ColorSpace::PrimaryID::APPLE_GENERIC_RGB,
+                         ColorSpace::TransferID::GAMMA18);
+
+  skia::Matrix44 icc_profile_matrix;
+  skia::Matrix44 color_space_matrix;
+
+  icc_profile.GetPrimaryMatrix(&icc_profile_matrix);
+  color_space.GetPrimaryMatrix(&color_space_matrix);
+
+  skia::Matrix44 eye;
+  icc_profile_matrix.invert(&eye);
+  eye.postConcat(color_space_matrix);
+  EXPECT_TRUE(SkMatrixIsApproximatelyIdentity(eye));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/icon_util.cc b/ui/gfx/icon_util.cc
new file mode 100644
index 0000000..7da3e2b
--- /dev/null
+++ b/ui/gfx/icon_util.cc
@@ -0,0 +1,703 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/icon_util.h"
+
+#include "base/check_op.h"
+#include "base/cxx17_backports.h"
+#include "base/files/file_util.h"
+#include "base/files/important_file_writer.h"
+#include "base/notreached.h"
+#include "base/trace_event/trace_event.h"
+#include "base/win/resource_util.h"
+#include "base/win/scoped_gdi_object.h"
+#include "base/win/scoped_handle.h"
+#include "base/win/scoped_hdc.h"
+#include "skia/ext/image_operations.h"
+#include "skia/ext/skia_utils_win.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_family.h"
+#include "ui/gfx/skbitmap_operations.h"
+
+namespace {
+
+// Used for indicating that the .ico contains an icon (rather than a cursor)
+// image. This value is set in the |idType| field of the ICONDIR structure.
+const int kResourceTypeIcon = 1;
+
+struct ScopedICONINFO : ICONINFO {
+  ScopedICONINFO() {
+    hbmColor = NULL;
+    hbmMask = NULL;
+  }
+
+  ~ScopedICONINFO() {
+    if (hbmColor)
+      ::DeleteObject(hbmColor);
+    if (hbmMask)
+      ::DeleteObject(hbmMask);
+  }
+};
+
+// Creates a new ImageFamily, |resized_image_family|, based on the images in
+// |image_family|, but containing images of specific dimensions desirable for
+// Windows icons. For each desired image dimension, it chooses the most
+// appropriate image for that size, and resizes it to the desired size.
+// Returns true on success, false on failure. Failure can occur if
+// |image_family| is empty, all images in the family have size 0x0, or an image
+// has no allocated pixel data.
+// |resized_image_family| must be empty.
+bool BuildResizedImageFamily(const gfx::ImageFamily& image_family,
+                             gfx::ImageFamily* resized_image_family) {
+  DCHECK(resized_image_family);
+  DCHECK(resized_image_family->empty());
+
+  // Determine whether there is an image bigger than 48x48 (kMediumIconSize).
+  const gfx::Image* biggest =
+      image_family.GetBest(IconUtil::kLargeIconSize, IconUtil::kLargeIconSize);
+  if (!biggest || biggest->IsEmpty()) {
+    // Either |image_family| is empty, or all images have size 0x0.
+    return false;
+  }
+
+  bool has_bigger_than_medium = biggest->Width() > IconUtil::kMediumIconSize ||
+                                biggest->Height() > IconUtil::kMediumIconSize;
+
+  for (size_t i = 0; i < IconUtil::kNumIconDimensions; ++i) {
+    int dimension = IconUtil::kIconDimensions[i];
+    // Windows' "Large icons" view displays icons at full size only if there is
+    // a 256x256 (kLargeIconSize) image in the .ico file. Otherwise, it shrinks
+    // icons to 48x48 (kMediumIconSize). Therefore, if there is no source icon
+    // larger than 48x48, do not create any images larger than 48x48.
+    // kIconDimensions is sorted in ascending order, so it is safe to break
+    // here.
+    if (!has_bigger_than_medium && dimension > IconUtil::kMediumIconSize)
+      break;
+
+    gfx::Image resized = image_family.CreateExact(dimension, dimension);
+    if (resized.IsEmpty()) {
+      // An error occurred in CreateExact (typically because the image had the
+      // wrong pixel format).
+      return false;
+    }
+
+    resized_image_family->Add(resized);
+  }
+  return true;
+}
+
+// Creates a set of bitmaps from an image family.
+// All images smaller than 256x256 are converted to SkBitmaps, and inserted into
+// |bitmaps| in order of aspect ratio (thinnest to widest), and then ascending
+// size order. If an image of exactly 256x256 is specified, it is converted into
+// PNG format and stored in |png_bytes|. Images with width or height larger than
+// 256 are ignored.
+// |bitmaps| must be an empty vector, and not NULL.
+// Returns true on success, false on failure. This fails if any image in
+// |image_family| is not a 32-bit ARGB image, or is otherwise invalid.
+void ConvertImageFamilyToBitmaps(
+    const gfx::ImageFamily& image_family,
+    std::vector<SkBitmap>* bitmaps,
+    scoped_refptr<base::RefCountedMemory>* png_bytes) {
+  DCHECK(bitmaps != NULL);
+  DCHECK(bitmaps->empty());
+
+  for (gfx::ImageFamily::const_iterator it = image_family.begin();
+       it != image_family.end(); ++it) {
+    const gfx::Image& image = *it;
+
+    // All images should have one of the kIconDimensions sizes.
+    DCHECK_GT(image.Width(), 0);
+    DCHECK_LE(image.Width(), IconUtil::kLargeIconSize);
+    DCHECK_GT(image.Height(), 0);
+    DCHECK_LE(image.Height(), IconUtil::kLargeIconSize);
+
+    SkBitmap bitmap = image.AsBitmap();
+    CHECK_EQ(bitmap.colorType(), kN32_SkColorType);
+    CHECK(!bitmap.isNull());
+
+    // Special case: Icons exactly 256x256 are stored in PNG format.
+    if (image.Width() == IconUtil::kLargeIconSize &&
+        image.Height() == IconUtil::kLargeIconSize) {
+      *png_bytes = image.As1xPNGBytes();
+    } else {
+      bitmaps->push_back(bitmap);
+    }
+  }
+}
+
+}  // namespace
+
+// The icon images appear in the icon file in same order in which their
+// corresponding dimensions appear in this array, so it is important to keep
+// this array sorted. Also note that the maximum icon image size we can handle
+// is 256 by 256. See:
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa511280.aspx#size
+const int IconUtil::kIconDimensions[] = {
+  8,    // Recommended by the MSDN as a nice to have icon size.
+  10,   // Used by the Shell (e.g. for shortcuts).
+  14,   // Recommended by the MSDN as a nice to have icon size.
+  16,   // Toolbar, Application and Shell icon sizes.
+  22,   // Recommended by the MSDN as a nice to have icon size.
+  24,   // Used by the Shell (e.g. for shortcuts).
+  32,   // Toolbar, Dialog and Wizard icon size.
+  40,   // Quick Launch.
+  48,   // Alt+Tab icon size.
+  64,   // Recommended by the MSDN as a nice to have icon size.
+  96,   // Recommended by the MSDN as a nice to have icon size.
+  128,  // Used by the Shell (e.g. for shortcuts).
+  256   // Used by Vista onwards for large icons.
+};
+
+const size_t IconUtil::kNumIconDimensions = base::size(kIconDimensions);
+const size_t IconUtil::kNumIconDimensionsUpToMediumSize = 9;
+
+base::win::ScopedHICON IconUtil::CreateHICONFromSkBitmap(
+    const SkBitmap& bitmap) {
+  // Only 32 bit ARGB bitmaps are supported. We also try to perform as many
+  // validations as we can on the bitmap.
+  if ((bitmap.colorType() != kN32_SkColorType) ||
+      (bitmap.width() <= 0) || (bitmap.height() <= 0) ||
+      (bitmap.getPixels() == NULL))
+    return base::win::ScopedHICON();
+
+  // We start by creating a DIB which we'll use later on in order to create
+  // the HICON. We use BITMAPV5HEADER since the bitmap we are about to convert
+  // may contain an alpha channel and the V5 header allows us to specify the
+  // alpha mask for the DIB.
+  BITMAPV5HEADER bitmap_header;
+  InitializeBitmapHeader(&bitmap_header, bitmap.width(), bitmap.height());
+
+  void* bits = NULL;
+  HBITMAP dib;
+
+  {
+    base::win::ScopedGetDC hdc(NULL);
+    dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&bitmap_header),
+                             DIB_RGB_COLORS, &bits, NULL, 0);
+  }
+  if (!dib || !bits)
+    return base::win::ScopedHICON();
+
+  memcpy(bits, bitmap.getPixels(), bitmap.width() * bitmap.height() * 4);
+
+  // Icons are generally created using an AND and XOR masks where the AND
+  // specifies boolean transparency (the pixel is either opaque or
+  // transparent) and the XOR mask contains the actual image pixels. If the XOR
+  // mask bitmap has an alpha channel, the AND monochrome bitmap won't
+  // actually be used for computing the pixel transparency. Even though all our
+  // bitmap has an alpha channel, Windows might not agree when all alpha values
+  // are zero. So the monochrome bitmap is created with all pixels transparent
+  // for this case. Otherwise, it is created with all pixels opaque.
+  bool bitmap_has_alpha_channel =
+      PixelsHaveAlpha(static_cast<const uint32_t*>(bitmap.getPixels()),
+                      bitmap.width() * bitmap.height());
+
+  std::unique_ptr<uint8_t[]> mask_bits;
+  if (!bitmap_has_alpha_channel) {
+    // Bytes per line with paddings to make it word alignment.
+    size_t bytes_per_line = (bitmap.width() + 0xF) / 16 * 2;
+    size_t mask_bits_size = bytes_per_line * bitmap.height();
+
+    mask_bits = std::make_unique<uint8_t[]>(mask_bits_size);
+    DCHECK(mask_bits.get());
+
+    // Make all pixels transparent.
+    memset(mask_bits.get(), 0xFF, mask_bits_size);
+  }
+
+  HBITMAP mono_bitmap = ::CreateBitmap(bitmap.width(), bitmap.height(), 1, 1,
+      reinterpret_cast<LPVOID>(mask_bits.get()));
+  DCHECK(mono_bitmap);
+
+  ICONINFO icon_info;
+  icon_info.fIcon = TRUE;
+  icon_info.xHotspot = 0;
+  icon_info.yHotspot = 0;
+  icon_info.hbmMask = mono_bitmap;
+  icon_info.hbmColor = dib;
+  base::win::ScopedHICON icon(CreateIconIndirect(&icon_info));
+  ::DeleteObject(dib);
+  ::DeleteObject(mono_bitmap);
+  return icon;
+}
+
+SkBitmap IconUtil::CreateSkBitmapFromHICON(HICON icon, const gfx::Size& s) {
+  // We start with validating parameters.
+  if (!icon || s.IsEmpty())
+    return SkBitmap();
+  ScopedICONINFO icon_info;
+  if (!::GetIconInfo(icon, &icon_info))
+    return SkBitmap();
+  if (!icon_info.fIcon)
+    return SkBitmap();
+  return CreateSkBitmapFromHICONHelper(icon, s);
+}
+
+// static
+std::unique_ptr<gfx::ImageFamily> IconUtil::CreateImageFamilyFromIconResource(
+    HMODULE module,
+    int resource_id) {
+  // Read the resource directly so we can get the icon image sizes. This data
+  // will also be used to directly get the PNG bytes for large images.
+  void* icon_dir_data = NULL;
+  size_t icon_dir_size = 0;
+  if (!base::win::GetResourceFromModule(module, resource_id, RT_GROUP_ICON,
+                                        &icon_dir_data, &icon_dir_size)) {
+    return nullptr;
+  }
+  DCHECK(icon_dir_data);
+  DCHECK_GE(icon_dir_size, sizeof(GRPICONDIR));
+
+  const GRPICONDIR* icon_dir =
+      reinterpret_cast<const GRPICONDIR*>(icon_dir_data);
+  std::unique_ptr<gfx::ImageFamily> result(new gfx::ImageFamily);
+  for (size_t i = 0; i < icon_dir->idCount; ++i) {
+    const GRPICONDIRENTRY* entry = &icon_dir->idEntries[i];
+    if (entry->bWidth != 0 || entry->bHeight != 0) {
+      // Ignore the low-bit-depth versions of the icon.
+      if (entry->wBitCount != 32)
+        continue;
+
+      // For everything except the Vista+ 256x256 icons, use |LoadImage()|.
+      base::win::ScopedHICON icon_handle(static_cast<HICON>(LoadImage(
+          module, MAKEINTRESOURCE(resource_id), IMAGE_ICON, entry->bWidth,
+          entry->bHeight, LR_DEFAULTCOLOR | LR_DEFAULTSIZE)));
+      result->Add(gfx::Image::CreateFrom1xBitmap(
+          IconUtil::CreateSkBitmapFromHICON(icon_handle.get())));
+    } else {
+      // 256x256 icons are stored with width and height set to 0.
+      // See: http://en.wikipedia.org/wiki/ICO_(file_format)
+      void* png_data = NULL;
+      size_t png_size = 0;
+      if (!base::win::GetResourceFromModule(module, entry->nID, RT_ICON,
+                                            &png_data, &png_size)) {
+        return nullptr;
+      }
+      DCHECK(png_data);
+      DCHECK_EQ(png_size, entry->dwBytesInRes);
+
+      result->Add(gfx::Image::CreateFrom1xPNGBytes(
+          new base::RefCountedStaticMemory(png_data, png_size)));
+    }
+  }
+  return result;
+}
+
+SkBitmap IconUtil::CreateSkBitmapFromHICON(HICON icon) {
+  // We start with validating parameters.
+  if (!icon)
+    return SkBitmap();
+
+  ScopedICONINFO icon_info;
+  BITMAP bitmap_info = { 0 };
+
+  if (!::GetIconInfo(icon, &icon_info))
+    return SkBitmap();
+
+  if (!::GetObject(icon_info.hbmMask, sizeof(bitmap_info), &bitmap_info))
+    return SkBitmap();
+
+  // For non-color cursors, the mask contains both an AND and an XOR mask and
+  // the height includes both. Thus, the mask width is the same as image width,
+  // but we need to divide mask height by 2 to get the image height.
+  const int height = bitmap_info.bmHeight / (icon_info.hbmColor ? 1 : 2);
+  gfx::Size icon_size(bitmap_info.bmWidth, height);
+  return CreateSkBitmapFromHICONHelper(icon, icon_size);
+}
+
+base::win::ScopedHICON IconUtil::CreateCursorFromSkBitmap(
+    const SkBitmap& bitmap,
+    const gfx::Point& hotspot) {
+  if (bitmap.empty())
+    return base::win::ScopedHICON();
+
+  // Only 32 bit ARGB bitmaps are supported.
+  if (bitmap.colorType() != kN32_SkColorType) {
+    NOTIMPLEMENTED() << " unsupported color type: " << bitmap.colorType();
+    return base::win::ScopedHICON();
+  }
+
+  BITMAPINFO icon_bitmap_info = {};
+  skia::CreateBitmapHeaderForN32SkBitmap(
+      bitmap, reinterpret_cast<BITMAPINFOHEADER*>(&icon_bitmap_info));
+
+  base::win::ScopedGetDC dc(NULL);
+  base::win::ScopedCreateDC working_dc(CreateCompatibleDC(dc));
+  base::win::ScopedGDIObject<HBITMAP> bitmap_handle(
+      CreateDIBSection(dc,
+                       &icon_bitmap_info,
+                       DIB_RGB_COLORS,
+                       0,
+                       0,
+                       0));
+  SetDIBits(0, bitmap_handle.get(), 0, bitmap.height(), bitmap.getPixels(),
+            &icon_bitmap_info, DIB_RGB_COLORS);
+
+  HBITMAP old_bitmap = reinterpret_cast<HBITMAP>(
+      SelectObject(working_dc.Get(), bitmap_handle.get()));
+  SetBkMode(working_dc.Get(), TRANSPARENT);
+  SelectObject(working_dc.Get(), old_bitmap);
+
+  base::win::ScopedGDIObject<HBITMAP> mask(
+      CreateBitmap(bitmap.width(), bitmap.height(), 1, 1, NULL));
+  ICONINFO ii = {0};
+  ii.fIcon = FALSE;
+  ii.xHotspot = hotspot.x();
+  ii.yHotspot = hotspot.y();
+  ii.hbmMask = mask.get();
+  ii.hbmColor = bitmap_handle.get();
+
+  return base::win::ScopedHICON(CreateIconIndirect(&ii));
+}
+
+gfx::Point IconUtil::GetHotSpotFromHICON(HICON icon) {
+  ScopedICONINFO icon_info;
+  gfx::Point hotspot;
+  if (::GetIconInfo(icon, &icon_info))
+    hotspot = gfx::Point(icon_info.xHotspot, icon_info.yHotspot);
+
+  return hotspot;
+}
+
+// static
+SkBitmap IconUtil::CreateSkBitmapFromHICONHelper(HICON icon,
+                                                 const gfx::Size& s) {
+  DCHECK(icon);
+  DCHECK(!s.IsEmpty());
+
+  // Allocating memory for the SkBitmap object. We are going to create an ARGB
+  // bitmap so we should set the configuration appropriately.
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(s.width(), s.height());
+  bitmap.eraseARGB(0, 0, 0, 0);
+
+  // Now we should create a DIB so that we can use ::DrawIconEx in order to
+  // obtain the icon's image.
+  BITMAPV5HEADER h;
+  InitializeBitmapHeader(&h, s.width(), s.height());
+  HDC hdc = ::GetDC(NULL);
+  uint32_t* bits;
+  HBITMAP dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&h),
+      DIB_RGB_COLORS, reinterpret_cast<void**>(&bits), NULL, 0);
+  DCHECK(dib);
+  HDC dib_dc = CreateCompatibleDC(hdc);
+  ::ReleaseDC(NULL, hdc);
+  DCHECK(dib_dc);
+  HGDIOBJ old_obj = ::SelectObject(dib_dc, dib);
+
+  // Windows icons are defined using two different masks. The XOR mask, which
+  // represents the icon image and an AND mask which is a monochrome bitmap
+  // which indicates the transparency of each pixel.
+  //
+  // To make things more complex, the icon image itself can be an ARGB bitmap
+  // and therefore contain an alpha channel which specifies the transparency
+  // for each pixel. Unfortunately, there is no easy way to determine whether
+  // or not a bitmap has an alpha channel and therefore constructing the bitmap
+  // for the icon is nothing but straightforward.
+  //
+  // The idea is to read the AND mask but use it only if we know for sure that
+  // the icon image does not have an alpha channel. The only way to tell if the
+  // bitmap has an alpha channel is by looking through the pixels and checking
+  // whether there are non-zero alpha bytes.
+  //
+  // We start by drawing the AND mask into our DIB.
+  size_t num_pixels = s.GetArea();
+  memset(bits, 0, num_pixels * 4);
+  ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_MASK);
+
+  // Capture boolean opacity. We may not use it if we find out the bitmap has
+  // an alpha channel.
+  std::unique_ptr<bool[]> opaque(new bool[num_pixels]);
+  for (size_t i = 0; i < num_pixels; ++i)
+    opaque[i] = !bits[i];
+
+  // Then draw the image itself which is really the XOR mask.
+  memset(bits, 0, num_pixels * 4);
+  ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_NORMAL);
+  memcpy(bitmap.getPixels(), static_cast<void*>(bits), num_pixels * 4);
+
+  // Finding out whether the bitmap has an alpha channel.
+  bool bitmap_has_alpha_channel = PixelsHaveAlpha(
+      static_cast<const uint32_t*>(bitmap.getPixels()), num_pixels);
+
+  // If the bitmap does not have an alpha channel, we need to build it using
+  // the previously captured AND mask. Otherwise, we are done.
+  if (!bitmap_has_alpha_channel) {
+    uint32_t* p = static_cast<uint32_t*>(bitmap.getPixels());
+    for (size_t i = 0; i < num_pixels; ++p, ++i) {
+      DCHECK_EQ((*p & 0xff000000), 0u);
+      if (opaque[i])
+        *p |= 0xff000000;
+      else
+        *p &= 0x00ffffff;
+    }
+  }
+
+  ::SelectObject(dib_dc, old_obj);
+  ::DeleteObject(dib);
+  ::DeleteDC(dib_dc);
+
+  return bitmap;
+}
+
+// static
+bool IconUtil::CreateIconFileFromImageFamily(
+    const gfx::ImageFamily& image_family,
+    const base::FilePath& icon_path,
+    WriteType write_type) {
+  // Creating a set of bitmaps corresponding to the icon images we'll end up
+  // storing in the icon file. Each bitmap is created by resizing the most
+  // appropriate image from |image_family| to the desired size.
+  gfx::ImageFamily resized_image_family;
+  if (!BuildResizedImageFamily(image_family, &resized_image_family))
+    return false;
+
+  std::vector<SkBitmap> bitmaps;
+  scoped_refptr<base::RefCountedMemory> png_bytes;
+  ConvertImageFamilyToBitmaps(resized_image_family, &bitmaps, &png_bytes);
+
+  // Guaranteed true because BuildResizedImageFamily will provide at least one
+  // image < 256x256.
+  DCHECK(!bitmaps.empty());
+  // ICONDIR's idCount is a WORD, so check for overflow.
+  DCHECK_LE(bitmaps.size(),
+            static_cast<size_t>(USHRT_MAX - (png_bytes.get() ? 1 : 0)));
+  WORD bitmap_count =
+      static_cast<WORD>(bitmaps.size());  // Not including PNG image.
+  // Including PNG image, if any.
+  WORD image_count = bitmap_count + (png_bytes.get() ? 1 : 0);
+
+  // Computing the total size of the buffer we need in order to store the
+  // images in the desired icon format.
+  size_t buffer_size = ComputeIconFileBufferSize(bitmaps);
+  // Account for the bytes needed for the PNG entry.
+  if (png_bytes.get())
+    buffer_size += sizeof(ICONDIRENTRY) + png_bytes->size();
+
+  // Setting the information in the structures residing within the buffer.
+  // First, we set the information which doesn't require iterating through the
+  // bitmap set and then we set the bitmap specific structures. In the latter
+  // step we also copy the actual bits.
+  std::vector<uint8_t> buffer(buffer_size);
+  ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(&buffer[0]);
+  icon_dir->idType = kResourceTypeIcon;
+  icon_dir->idCount = image_count;
+  // - 1 because there is already one ICONDIRENTRY in ICONDIR.
+  DWORD icon_dir_count = image_count - 1;
+
+  DWORD offset = sizeof(ICONDIR) + (sizeof(ICONDIRENTRY) * icon_dir_count);
+  for (size_t i = 0; i < bitmap_count; i++) {
+    ICONIMAGE* image = reinterpret_cast<ICONIMAGE*>(&buffer[offset]);
+    DCHECK_LT(offset, buffer_size);
+    size_t icon_image_size = 0;
+    SetSingleIconImageInformation(bitmaps[i], i, icon_dir, image, offset,
+                                  &icon_image_size);
+    DCHECK_GT(icon_image_size, 0U);
+    offset += icon_image_size;
+  }
+
+  // Add the PNG entry, if necessary.
+  if (png_bytes.get()) {
+    ICONDIRENTRY* entry = &icon_dir->idEntries[bitmap_count];
+    entry->bWidth = 0;
+    entry->bHeight = 0;
+    entry->wPlanes = 1;
+    entry->wBitCount = 32;
+    entry->dwBytesInRes = static_cast<DWORD>(png_bytes->size());
+    entry->dwImageOffset = offset;
+    memcpy(&buffer[offset], png_bytes->front(), png_bytes->size());
+    offset += png_bytes->size();
+  }
+
+  DCHECK_EQ(offset, buffer_size);
+
+  if (write_type == NORMAL_WRITE) {
+    if (base::WriteFile(icon_path, buffer))
+      return true;
+    bool delete_success = base::DeleteFile(icon_path);
+    DCHECK(delete_success);
+    return false;
+  }
+
+  std::string data(buffer.begin(), buffer.end());
+  return base::ImportantFileWriter::WriteFileAtomically(icon_path, data);
+}
+
+bool IconUtil::PixelsHaveAlpha(const uint32_t* pixels, size_t num_pixels) {
+  for (const uint32_t* end = pixels + num_pixels; pixels != end; ++pixels) {
+    if ((*pixels & 0xff000000) != 0)
+      return true;
+  }
+
+  return false;
+}
+
+void IconUtil::InitializeBitmapHeader(BITMAPV5HEADER* header, int width,
+                                      int height) {
+  DCHECK(header);
+  memset(header, 0, sizeof(BITMAPV5HEADER));
+  header->bV5Size = sizeof(BITMAPV5HEADER);
+
+  // Note that icons are created using top-down DIBs so we must negate the
+  // value used for the icon's height.
+  header->bV5Width = width;
+  header->bV5Height = -height;
+  header->bV5Planes = 1;
+  header->bV5Compression = BI_RGB;
+
+  // Initializing the bitmap format to 32 bit ARGB.
+  header->bV5BitCount = 32;
+  header->bV5RedMask = 0x00FF0000;
+  header->bV5GreenMask = 0x0000FF00;
+  header->bV5BlueMask = 0x000000FF;
+  header->bV5AlphaMask = 0xFF000000;
+
+  // Use the system color space.  The default value is LCS_CALIBRATED_RGB, which
+  // causes us to crash if we don't specify the approprite gammas, etc.  See
+  // <http://msdn.microsoft.com/en-us/library/ms536531(VS.85).aspx> and
+  // <http://b/1283121>.
+  header->bV5CSType = LCS_WINDOWS_COLOR_SPACE;
+
+  // Use a valid value for bV5Intent as 0 is not a valid one.
+  // <http://msdn.microsoft.com/en-us/library/dd183381(VS.85).aspx>
+  header->bV5Intent = LCS_GM_IMAGES;
+}
+
+void IconUtil::SetSingleIconImageInformation(const SkBitmap& bitmap,
+                                             size_t index,
+                                             ICONDIR* icon_dir,
+                                             ICONIMAGE* icon_image,
+                                             DWORD image_offset,
+                                             size_t* image_byte_count) {
+  DCHECK(icon_dir != NULL);
+  DCHECK(icon_image != NULL);
+  DCHECK_GT(image_offset, 0U);
+  DCHECK(image_byte_count != NULL);
+  DCHECK_LT(bitmap.width(), kLargeIconSize);
+  DCHECK_LT(bitmap.height(), kLargeIconSize);
+
+  // We start by computing certain image values we'll use later on.
+  size_t xor_mask_size;
+  DWORD bytes_in_resource;
+  ComputeBitmapSizeComponents(bitmap,
+                              &xor_mask_size,
+                              &bytes_in_resource);
+
+  icon_dir->idEntries[index].bWidth = static_cast<BYTE>(bitmap.width());
+  icon_dir->idEntries[index].bHeight = static_cast<BYTE>(bitmap.height());
+  icon_dir->idEntries[index].wPlanes = 1;
+  icon_dir->idEntries[index].wBitCount = 32;
+  icon_dir->idEntries[index].dwBytesInRes = bytes_in_resource;
+  icon_dir->idEntries[index].dwImageOffset = image_offset;
+  icon_image->icHeader.biSize = sizeof(BITMAPINFOHEADER);
+
+  // The width field in the BITMAPINFOHEADER structure accounts for the height
+  // of both the AND mask and the XOR mask so we need to multiply the bitmap's
+  // height by 2. The same does NOT apply to the width field.
+  icon_image->icHeader.biHeight = bitmap.height() * 2;
+  icon_image->icHeader.biWidth = bitmap.width();
+  icon_image->icHeader.biPlanes = 1;
+  icon_image->icHeader.biBitCount = 32;
+
+  // We use a helper function for copying to actual bits from the SkBitmap
+  // object into the appropriate space in the buffer. We use a helper function
+  // (rather than just copying the bits) because there is no way to specify the
+  // orientation (bottom-up vs. top-down) of a bitmap residing in a .ico file.
+  // Thus, if we just copy the bits, we'll end up with a bottom up bitmap in
+  // the .ico file which will result in the icon being displayed upside down.
+  // The helper function copies the image into the buffer one scanline at a
+  // time.
+  //
+  // Note that we don't need to initialize the AND mask since the memory
+  // allocated for the icon data buffer was initialized to zero. The icon we
+  // create will therefore use an AND mask containing only zeros, which is OK
+  // because the underlying image has an alpha channel. An AND mask containing
+  // only zeros essentially means we'll initially treat all the pixels as
+  // opaque.
+  unsigned char* image_addr = reinterpret_cast<unsigned char*>(icon_image);
+  unsigned char* xor_mask_addr = image_addr + sizeof(BITMAPINFOHEADER);
+
+  // Make sure pixels are not premultiplied by alpha.
+  SkBitmap unpremul_bitmap = SkBitmapOperations::UnPreMultiply(bitmap);
+  CopySkBitmapBitsIntoIconBuffer(unpremul_bitmap, xor_mask_addr, xor_mask_size);
+
+  *image_byte_count = bytes_in_resource;
+}
+
+void IconUtil::CopySkBitmapBitsIntoIconBuffer(const SkBitmap& bitmap,
+                                              unsigned char* buffer,
+                                              size_t buffer_size) {
+  unsigned char* bitmap_ptr = static_cast<unsigned char*>(bitmap.getPixels());
+  size_t bitmap_size = bitmap.height() * bitmap.width() * 4;
+  DCHECK_EQ(buffer_size, bitmap_size);
+  for (size_t i = 0; i < bitmap_size; i += bitmap.width() * 4) {
+    memcpy(buffer + bitmap_size - bitmap.width() * 4 - i,
+           bitmap_ptr + i,
+           bitmap.width() * 4);
+  }
+}
+
+size_t IconUtil::ComputeIconFileBufferSize(const std::vector<SkBitmap>& set) {
+  DCHECK(!set.empty());
+
+  // We start by counting the bytes for the structures that don't depend on the
+  // number of icon images. Note that sizeof(ICONDIR) already accounts for a
+  // single ICONDIRENTRY structure, which is why we subtract one from the
+  // number of bitmaps.
+  size_t total_buffer_size = sizeof(ICONDIR);
+  size_t bitmap_count = set.size();
+  total_buffer_size += sizeof(ICONDIRENTRY) * (bitmap_count - 1);
+  // May not have all icon sizes, but must have at least up to medium icon size.
+  DCHECK_GE(bitmap_count, kNumIconDimensionsUpToMediumSize);
+
+  // Add the bitmap specific structure sizes.
+  for (size_t i = 0; i < bitmap_count; i++) {
+    size_t xor_mask_size;
+    DWORD bytes_in_resource;
+    ComputeBitmapSizeComponents(set[i],
+                                &xor_mask_size,
+                                &bytes_in_resource);
+    total_buffer_size += bytes_in_resource;
+  }
+  return total_buffer_size;
+}
+
+void IconUtil::ComputeBitmapSizeComponents(const SkBitmap& bitmap,
+                                           size_t* xor_mask_size,
+                                           DWORD* bytes_in_resource) {
+  // The XOR mask size is easy to calculate since we only deal with 32bpp
+  // images.
+  *xor_mask_size = bitmap.width() * bitmap.height() * 4;
+
+  // Computing the AND mask is a little trickier since it is a monochrome
+  // bitmap (regardless of the number of bits per pixels used in the XOR mask).
+  // There are two things we must make sure we do when computing the AND mask
+  // size:
+  //
+  // 1. Make sure the right number of bytes is allocated for each AND mask
+  //    scan line in case the number of pixels in the image is not divisible by
+  //    8. For example, in a 15X15 image, 15 / 8 is one byte short of
+  //    containing the number of bits we need in order to describe a single
+  //    image scan line so we need to add a byte. Thus, we need 2 bytes instead
+  //    of 1 for each scan line.
+  //
+  // 2. Make sure each scan line in the AND mask is 4 byte aligned (so that the
+  //    total icon image has a 4 byte alignment). In the 15X15 image example
+  //    above, we can not use 2 bytes so we increase it to the next multiple of
+  //    4 which is 4.
+  //
+  // Once we compute the size for a singe AND mask scan line, we multiply that
+  // number by the image height in order to get the total number of bytes for
+  // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes
+  // for the monochrome bitmap representing the AND mask.
+  size_t and_line_length = (bitmap.width() + 7) >> 3;
+  and_line_length = (and_line_length + 3) & ~3;
+  size_t and_mask_size = and_line_length * bitmap.height();
+  size_t masks_size = *xor_mask_size + and_mask_size;
+  *bytes_in_resource =
+      static_cast<DWORD>(masks_size + sizeof(BITMAPINFOHEADER));
+}
diff --git a/ui/gfx/icon_util.h b/ui/gfx/icon_util.h
new file mode 100644
index 0000000..22b2e72
--- /dev/null
+++ b/ui/gfx/icon_util.h
@@ -0,0 +1,272 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ICON_UTIL_H_
+#define UI_GFX_ICON_UTIL_H_
+
+#include <windows.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <memory>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/win/scoped_gdi_object.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace base {
+class FilePath;
+}
+
+namespace gfx {
+class ImageFamily;
+class Size;
+}
+class SkBitmap;
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// The IconUtil class contains helper functions for manipulating Windows icons.
+// The class interface contains methods for converting an HICON handle into an
+// SkBitmap object and vice versa. The class can also create a .ico file given
+// a PNG image contained in an SkBitmap object. The following code snippet
+// shows an example usage of IconUtil::CreateHICONFromSkBitmap():
+//
+//   SkBitmap bitmap;
+//
+//   // Fill |bitmap| with valid data
+//   bitmap.setConfig(...);
+//   bitmap.allocPixels();
+//
+//   ...
+//
+//   // Convert the bitmap into a Windows HICON
+//   base::win::ScopedHICON icon(IconUtil::CreateHICONFromSkBitmap(bitmap));
+//   if (!icon.is_valid()) {
+//     // Handle error
+//     ...
+//   }
+//
+//   // Use the icon with a WM_SETICON message
+//   ::SendMessage(hwnd, WM_SETICON, static_cast<WPARAM>(ICON_BIG),
+//                 reinterpret_cast<LPARAM>(icon.get()));
+//
+///////////////////////////////////////////////////////////////////////////////
+class GFX_EXPORT IconUtil {
+ public:
+  // ATOMIC_WRITE ensures that a partially written icon won't be created even if
+  // Chrome crashes part way through, but ATOMIC_WRITE is more expensive than
+  // NORMAL_WRITE. See CreateIconFileFromImageFamily. ATOMIC_WRITE is the
+  // default for historical reasons.
+  enum WriteType { ATOMIC_WRITE, NORMAL_WRITE };
+  // The size of the large icon entries in .ico files on Windows Vista+.
+  enum { kLargeIconSize = 256 };
+  // The size of icons in the medium icons view on Windows Vista+. This is the
+  // maximum size Windows will display an icon that does not have a 256x256
+  // image, even at the large or extra large icons views.
+  enum { kMediumIconSize = 48 };
+
+  // The dimensions for icon images in Windows icon files. All sizes are square;
+  // that is, the value 48 means a 48x48 pixel image. Sizes are listed in
+  // ascending order.
+  static const int kIconDimensions[];
+
+  // The number of elements in kIconDimensions.
+  static const size_t kNumIconDimensions;
+  // The number of elements in kIconDimensions <= kMediumIconSize.
+  static const size_t kNumIconDimensionsUpToMediumSize;
+
+  // Prevent clients from instantiating objects of that class.
+  IconUtil() = delete;
+  IconUtil(const IconUtil&) = delete;
+  IconUtil& operator=(const IconUtil&) = delete;
+
+  // Given an SkBitmap object, the function converts the bitmap to a Windows
+  // icon and returns the corresponding HICON handle. If the function cannot
+  // convert the bitmap, NULL is returned.
+  //
+  // The client is responsible for destroying the icon when it is no longer
+  // needed by calling ::DestroyIcon().
+  static base::win::ScopedHICON CreateHICONFromSkBitmap(const SkBitmap& bitmap);
+
+  // Given a valid HICON handle representing an icon, this function converts
+  // the icon into an SkBitmap object containing an ARGB bitmap using the
+  // dimensions specified in |s|. |s| must specify valid dimensions (both
+  // width() an height() must be greater than zero). If the function cannot
+  // convert the icon to a bitmap (most probably due to an invalid parameter),
+  // the returned SkBitmap's isNull() method will return true.
+  static SkBitmap CreateSkBitmapFromHICON(HICON icon, const gfx::Size& s);
+
+  // Loads an icon resource  as a SkBitmap for the specified |size| from a
+  // loaded .dll or .exe |module|. Supports loading smaller icon sizes as well
+  // as the Vista+ 256x256 PNG icon size. If the icon could not be loaded or
+  // found, returns a NULL scoped_ptr.
+  static std::unique_ptr<gfx::ImageFamily> CreateImageFamilyFromIconResource(
+      HMODULE module,
+      int resource_id);
+
+  // Given a valid HICON handle representing an icon, this function converts
+  // the icon into an SkBitmap object containing an ARGB bitmap using the
+  // dimensions of HICON. If the function cannot convert the icon to a bitmap
+  // (most probably due to an invalid parameter), the returned SkBitmap's
+  // isNull() method will return true.
+  static SkBitmap CreateSkBitmapFromHICON(HICON icon);
+
+  // Creates Windows .ico file at |icon_path|. The icon file is created with
+  // multiple BMP representations at varying predefined dimensions (by resizing
+  // an appropriately sized image from |image_family|) because Windows uses
+  // different image sizes when loading icons, depending on where the icon is
+  // drawn (ALT+TAB window, desktop shortcut, Quick Launch, etc.).
+  //
+  // If |image_family| contains an image larger than 48x48, the resulting icon
+  // will contain all sizes up to 256x256. The 256x256 image will be stored in
+  // PNG format inside the .ico file. If not, the resulting icon will contain
+  // all sizes up to 48x48.
+  //
+  // The function returns true on success and false otherwise. Returns false if
+  // |image_family| is empty.
+  static bool CreateIconFileFromImageFamily(
+      const gfx::ImageFamily& image_family,
+      const base::FilePath& icon_path,
+      WriteType write_type = ATOMIC_WRITE);
+
+  // Creates a cursor of the specified size from the SkBitmap passed in.
+  // Returns the cursor on success or NULL on failure.
+  static base::win::ScopedHICON CreateCursorFromSkBitmap(
+      const SkBitmap& bitmap,
+      const gfx::Point& hotspot);
+
+  // Given a valid HICON handle representing an icon, this function retrieves
+  // the hot spot of the icon.
+  static gfx::Point GetHotSpotFromHICON(HICON icon);
+
+ private:
+  // The icon format is published in the MSDN but there is no definition of
+  // the icon file structures in any of the Windows header files so we need to
+  // define these structure within the class. We must make sure we use 2 byte
+  // packing so that the structures are laid out properly within the file.
+  // See: http://msdn.microsoft.com/en-us/library/ms997538.aspx
+#pragma pack(push)
+#pragma pack(2)
+
+  // ICONDIRENTRY contains meta data for an individual icon image within a
+  // .ico file.
+  struct ICONDIRENTRY {
+    BYTE bWidth;
+    BYTE bHeight;
+    BYTE bColorCount;
+    BYTE bReserved;
+    WORD wPlanes;
+    WORD wBitCount;
+    DWORD dwBytesInRes;
+    DWORD dwImageOffset;
+  };
+
+  // ICONDIR Contains information about all the icon images contained within a
+  // single .ico file.
+  struct ICONDIR {
+    WORD idReserved;
+    WORD idType;
+    WORD idCount;
+    ICONDIRENTRY idEntries[1];
+  };
+
+  // GRPICONDIRENTRY contains meta data for an individual icon image within a
+  // RT_GROUP_ICON resource in an .exe or .dll.
+  struct GRPICONDIRENTRY {
+    BYTE bWidth;
+    BYTE bHeight;
+    BYTE bColorCount;
+    BYTE bReserved;
+    WORD wPlanes;
+    WORD wBitCount;
+    DWORD dwBytesInRes;
+    WORD nID;
+  };
+
+  // GRPICONDIR Contains information about all the icon images contained within
+  // a RT_GROUP_ICON resource in an .exe or .dll.
+  struct GRPICONDIR {
+    WORD idReserved;
+    WORD idType;
+    WORD idCount;
+    GRPICONDIRENTRY idEntries[1];
+  };
+
+  // Contains the actual icon image.
+  struct ICONIMAGE {
+    BITMAPINFOHEADER icHeader;
+    RGBQUAD icColors[1];
+    BYTE icXOR[1];
+    BYTE icAND[1];
+  };
+#pragma pack(pop)
+
+  friend class IconUtilTest;
+
+  // Returns true if any pixel in the given pixels buffer has an non-zero alpha.
+  static bool PixelsHaveAlpha(const uint32_t* pixels, size_t num_pixels);
+
+  // A helper function that initializes a BITMAPV5HEADER structure with a set
+  // of values.
+  static void InitializeBitmapHeader(BITMAPV5HEADER* header, int width,
+                                     int height);
+
+  // Given a single SkBitmap object and pointers to the corresponding icon
+  // structures within the icon data buffer, this function sets the image
+  // information (dimensions, color depth, etc.) in the icon structures and
+  // also copies the underlying icon image into the appropriate location.
+  // The width and height of |bitmap| must be < 256.
+  // (Note that the 256x256 icon is treated specially, as a PNG, and should not
+  // use this method.)
+  //
+  // The function will set the data pointed to by |image_byte_count| with the
+  // number of image bytes written to the buffer. Note that the number of bytes
+  // includes only the image data written into the memory pointed to by
+  // |icon_image|.
+  static void SetSingleIconImageInformation(const SkBitmap& bitmap,
+                                            size_t index,
+                                            ICONDIR* icon_dir,
+                                            ICONIMAGE* icon_image,
+                                            DWORD image_offset,
+                                            size_t* image_byte_count);
+
+  // Copies the bits of an SkBitmap object into a buffer holding the bits of
+  // the corresponding image for an icon within the .ico file.
+  static void CopySkBitmapBitsIntoIconBuffer(const SkBitmap& bitmap,
+                                             unsigned char* buffer,
+                                             size_t buffer_size);
+
+  // Given a set of bitmaps with varying dimensions, this function computes
+  // the amount of memory needed in order to store the bitmaps as image icons
+  // in a .ico file.
+  static size_t ComputeIconFileBufferSize(const std::vector<SkBitmap>& set);
+
+  // A helper function for computing various size components of a given bitmap.
+  // The different sizes can be used within the various .ico file structures.
+  //
+  // |xor_mask_size| - the size, in bytes, of the XOR mask in the ICONIMAGE
+  //                   structure.
+  // |and_mask_size| - the size, in bytes, of the AND mask in the ICONIMAGE
+  //                   structure.
+  // |bytes_in_resource| - the total number of bytes set in the ICONIMAGE
+  //                       structure. This value is equal to the sum of the
+  //                       bytes in the AND mask and the XOR mask plus the size
+  //                       of the BITMAPINFOHEADER structure. Note that since
+  //                       only 32bpp are handled by the IconUtil class, the
+  //                       icColors field in the ICONIMAGE structure is ignored
+  //                       and is not accounted for when computing the
+  //                       different size components.
+  static void ComputeBitmapSizeComponents(const SkBitmap& bitmap,
+                                          size_t* xor_mask_size,
+                                          DWORD* bytes_in_resource);
+
+  // A helper function of CreateSkBitmapFromHICON.
+  static SkBitmap CreateSkBitmapFromHICONHelper(HICON icon,
+                                                const gfx::Size& s);
+};
+
+#endif  // UI_GFX_ICON_UTIL_H_
diff --git a/ui/gfx/icon_util_unittest.cc b/ui/gfx/icon_util_unittest.cc
new file mode 100644
index 0000000..21c228e
--- /dev/null
+++ b/ui/gfx/icon_util_unittest.cc
@@ -0,0 +1,431 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/icon_util.h"
+
+#include <stddef.h>
+
+#include <memory>
+#include <vector>
+
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/path_service.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/icon_util_unittests_resource.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_family.h"
+
+namespace {
+
+static const char kSmallIconName[] = "16_X_16_icon.ico";
+static const char kLargeIconName[] = "128_X_128_icon.ico";
+static const char kTempIconFilename[] = "temp_test_icon.ico";
+
+}  // namespace
+
+class IconUtilTest : public testing::Test {
+ public:
+  using ScopedHICON = base::win::ScopedHICON;
+
+  void SetUp() override {
+    ASSERT_TRUE(base::PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir_));
+    test_data_dir_ = test_data_dir_.Append(FILE_PATH_LITERAL("ui"))
+                         .Append(FILE_PATH_LITERAL("gfx"))
+                         .Append(FILE_PATH_LITERAL("test"))
+                         .Append(FILE_PATH_LITERAL("data"))
+                         .Append(FILE_PATH_LITERAL("icon_util"));
+    ASSERT_TRUE(base::PathExists(test_data_dir_));
+
+    ASSERT_TRUE(temp_directory_.CreateUniqueTempDir());
+  }
+
+  static const int kSmallIconWidth = 16;
+  static const int kSmallIconHeight = 16;
+  static const int kLargeIconWidth = 128;
+  static const int kLargeIconHeight = 128;
+
+  // Given a file name for an .ico file and an image dimensions, this
+  // function loads the icon and returns an HICON handle.
+  ScopedHICON LoadIconFromFile(const base::FilePath& filename,
+                               int width,
+                               int height) {
+    HICON icon = static_cast<HICON>(LoadImage(NULL,
+                                    filename.value().c_str(),
+                                    IMAGE_ICON,
+                                    width,
+                                    height,
+                                    LR_LOADTRANSPARENT | LR_LOADFROMFILE));
+    return ScopedHICON(icon);
+  }
+
+  SkBitmap CreateBlackSkBitmap(int width, int height) {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(width, height);
+    // Setting the pixels to transparent-black.
+    memset(bitmap.getPixels(), 0, width * height * 4);
+    return bitmap;
+  }
+
+  // Loads an .ico file from |icon_filename| and asserts that it contains all of
+  // the expected icon sizes up to and including |max_icon_size|, and no other
+  // icons. If |max_icon_size| >= 256, this tests for a 256x256 PNG icon entry.
+  void CheckAllIconSizes(const base::FilePath& icon_filename,
+                         int max_icon_size);
+
+ protected:
+  // The root directory for test files. This should be treated as read-only.
+  base::FilePath test_data_dir_;
+
+  // Directory for creating files by this test.
+  base::ScopedTempDir temp_directory_;
+};
+
+void IconUtilTest::CheckAllIconSizes(const base::FilePath& icon_filename,
+                                     int max_icon_size) {
+  ASSERT_TRUE(base::PathExists(icon_filename));
+
+  // Determine how many icons to expect, based on |max_icon_size|.
+  int expected_num_icons = 0;
+  for (size_t i = 0; i < IconUtil::kNumIconDimensions; ++i) {
+    if (IconUtil::kIconDimensions[i] > max_icon_size)
+      break;
+    ++expected_num_icons;
+  }
+
+  // First, use the Windows API to load the icon, a basic validity test.
+  EXPECT_TRUE(LoadIconFromFile(icon_filename, kSmallIconWidth, kSmallIconHeight)
+                  .is_valid());
+
+  // Read the file completely into memory.
+  std::string icon_data;
+  ASSERT_TRUE(base::ReadFileToString(icon_filename, &icon_data));
+  ASSERT_GE(icon_data.length(), sizeof(IconUtil::ICONDIR));
+
+  // Ensure that it has exactly the expected number and sizes of icons, in the
+  // expected order. This matches each entry of the loaded file's icon directory
+  // with the corresponding element of kIconDimensions.
+  // Also extracts the 256x256 entry as png_entry.
+  const IconUtil::ICONDIR* icon_dir =
+      reinterpret_cast<const IconUtil::ICONDIR*>(icon_data.data());
+  EXPECT_EQ(expected_num_icons, icon_dir->idCount);
+  ASSERT_GE(IconUtil::kNumIconDimensions, icon_dir->idCount);
+  ASSERT_GE(icon_data.length(),
+            sizeof(IconUtil::ICONDIR) +
+                icon_dir->idCount * sizeof(IconUtil::ICONDIRENTRY));
+  const IconUtil::ICONDIRENTRY* png_entry = NULL;
+  for (size_t i = 0; i < icon_dir->idCount; ++i) {
+    const IconUtil::ICONDIRENTRY* entry = &icon_dir->idEntries[i];
+    // Mod 256 because as a special case in ICONDIRENTRY, the value 0 represents
+    // a width or height of 256.
+    int expected_size = IconUtil::kIconDimensions[i] % 256;
+    EXPECT_EQ(expected_size, static_cast<int>(entry->bWidth));
+    EXPECT_EQ(expected_size, static_cast<int>(entry->bHeight));
+    if (entry->bWidth == 0 && entry->bHeight == 0) {
+      EXPECT_EQ(NULL, png_entry);
+      png_entry = entry;
+    }
+  }
+
+  if (max_icon_size >= 256) {
+    ASSERT_TRUE(png_entry);
+
+    // Convert the PNG entry data back to a SkBitmap to ensure it's valid.
+    ASSERT_GE(icon_data.length(),
+              png_entry->dwImageOffset + png_entry->dwBytesInRes);
+    const unsigned char* png_bytes = reinterpret_cast<const unsigned char*>(
+        icon_data.data() + png_entry->dwImageOffset);
+    gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(
+        png_bytes, png_entry->dwBytesInRes);
+    SkBitmap bitmap = image.AsBitmap();
+    EXPECT_EQ(256, bitmap.width());
+    EXPECT_EQ(256, bitmap.height());
+  }
+}
+
+// The following test case makes sure IconUtil::SkBitmapFromHICON fails
+// gracefully when called with invalid input parameters.
+TEST_F(IconUtilTest, TestIconToBitmapInvalidParameters) {
+  base::FilePath icon_filename = test_data_dir_.AppendASCII(kSmallIconName);
+  gfx::Size icon_size(kSmallIconWidth, kSmallIconHeight);
+  ScopedHICON icon(
+      LoadIconFromFile(icon_filename, icon_size.width(), icon_size.height()));
+  ASSERT_TRUE(icon.is_valid());
+
+  // Invalid size parameter.
+  gfx::Size invalid_icon_size(kSmallIconHeight, 0);
+  EXPECT_TRUE(IconUtil::CreateSkBitmapFromHICON(icon.get(), invalid_icon_size)
+                  .isNull());
+
+  // Invalid icon.
+  EXPECT_TRUE(IconUtil::CreateSkBitmapFromHICON(nullptr, icon_size).isNull());
+
+  // The following code should succeed.
+  EXPECT_FALSE(
+      IconUtil::CreateSkBitmapFromHICON(icon.get(), icon_size).drawsNothing());
+}
+
+// The following test case makes sure IconUtil::CreateHICONFromSkBitmap fails
+// gracefully when called with invalid input parameters.
+TEST_F(IconUtilTest, TestBitmapToIconInvalidParameters) {
+  ScopedHICON icon;
+  std::unique_ptr<SkBitmap> bitmap;
+
+  // Wrong bitmap format.
+  bitmap = std::make_unique<SkBitmap>();
+  ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
+  bitmap->setInfo(SkImageInfo::MakeA8(kSmallIconWidth, kSmallIconHeight));
+  icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
+  EXPECT_FALSE(icon.is_valid());
+
+  // Invalid bitmap size.
+  bitmap = std::make_unique<SkBitmap>();
+  ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
+  bitmap->setInfo(SkImageInfo::MakeN32Premul(0, 0));
+  icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
+  EXPECT_FALSE(icon.is_valid());
+
+  // Valid bitmap configuration but no pixels allocated.
+  bitmap = std::make_unique<SkBitmap>();
+  ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
+  bitmap->setInfo(SkImageInfo::MakeN32Premul(kSmallIconWidth,
+                                             kSmallIconHeight));
+  icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
+  EXPECT_FALSE(icon.is_valid());
+}
+
+// The following test case makes sure IconUtil::CreateIconFileFromImageFamily
+// fails gracefully when called with invalid input parameters.
+TEST_F(IconUtilTest, TestCreateIconFileInvalidParameters) {
+  gfx::ImageFamily image_family;
+  base::FilePath valid_icon_filename =
+      temp_directory_.GetPath().AppendASCII(kTempIconFilename);
+  base::FilePath invalid_icon_filename =
+      temp_directory_.GetPath().AppendASCII("<>?.ico");
+
+  // Invalid file name.
+  SkBitmap bitmap;
+  image_family.clear();
+  bitmap.allocN32Pixels(1, 1);
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(bitmap));
+  EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                       invalid_icon_filename));
+  EXPECT_FALSE(base::PathExists(invalid_icon_filename));
+}
+
+// This test case makes sure IconUtil::CreateIconFileFromImageFamily fails if
+// the image family is empty or invalid.
+TEST_F(IconUtilTest, TestCreateIconFileEmptyImageFamily) {
+  base::FilePath icon_filename =
+      temp_directory_.GetPath().AppendASCII(kTempIconFilename);
+
+  // Empty image family.
+  EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(gfx::ImageFamily(),
+                                                       icon_filename));
+  EXPECT_FALSE(base::PathExists(icon_filename));
+
+  // Image family with only an empty image.
+  gfx::ImageFamily image_family;
+  image_family.Add(gfx::Image());
+  EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                       icon_filename));
+  EXPECT_FALSE(base::PathExists(icon_filename));
+}
+
+// This test case makes sure that when we load an icon from disk and convert
+// the HICON into a bitmap, the bitmap has the expected format and dimensions.
+TEST_F(IconUtilTest, TestCreateSkBitmapFromHICON) {
+  base::FilePath small_icon_filename =
+      test_data_dir_.AppendASCII(kSmallIconName);
+  gfx::Size small_icon_size(kSmallIconWidth, kSmallIconHeight);
+  ScopedHICON small_icon(LoadIconFromFile(
+      small_icon_filename, small_icon_size.width(), small_icon_size.height()));
+  ASSERT_TRUE(small_icon.is_valid());
+  SkBitmap bitmap =
+      IconUtil::CreateSkBitmapFromHICON(small_icon.get(), small_icon_size);
+  ASSERT_FALSE(bitmap.isNull());
+  EXPECT_EQ(bitmap.width(), small_icon_size.width());
+  EXPECT_EQ(bitmap.height(), small_icon_size.height());
+  EXPECT_EQ(bitmap.colorType(), kN32_SkColorType);
+
+  base::FilePath large_icon_filename =
+      test_data_dir_.AppendASCII(kLargeIconName);
+  gfx::Size large_icon_size(kLargeIconWidth, kLargeIconHeight);
+  ScopedHICON large_icon(LoadIconFromFile(
+      large_icon_filename, large_icon_size.width(), large_icon_size.height()));
+  ASSERT_TRUE(large_icon.is_valid());
+  bitmap = IconUtil::CreateSkBitmapFromHICON(large_icon.get(), large_icon_size);
+  ASSERT_FALSE(bitmap.isNull());
+  EXPECT_EQ(bitmap.width(), large_icon_size.width());
+  EXPECT_EQ(bitmap.height(), large_icon_size.height());
+  EXPECT_EQ(bitmap.colorType(), kN32_SkColorType);
+}
+
+// This test case makes sure that when an HICON is created from an SkBitmap,
+// the returned handle is valid and refers to an icon with the expected
+// dimensions color depth etc.
+TEST_F(IconUtilTest, TestBasicCreateHICONFromSkBitmap) {
+  SkBitmap bitmap = CreateBlackSkBitmap(kSmallIconWidth, kSmallIconHeight);
+  ScopedHICON icon(IconUtil::CreateHICONFromSkBitmap(bitmap));
+  EXPECT_TRUE(icon.is_valid());
+  ICONINFO icon_info;
+  ASSERT_TRUE(GetIconInfo(icon.get(), &icon_info));
+  EXPECT_TRUE(icon_info.fIcon);
+
+  // Now that have the icon information, we should obtain the specification of
+  // the icon's bitmap and make sure it matches the specification of the
+  // SkBitmap we started with.
+  //
+  // The bitmap handle contained in the icon information is a handle to a
+  // compatible bitmap so we need to call ::GetDIBits() in order to retrieve
+  // the bitmap's header information.
+  BITMAPINFO bitmap_info;
+  ::ZeroMemory(&bitmap_info, sizeof(BITMAPINFO));
+  bitmap_info.bmiHeader.biSize = sizeof(BITMAPINFO);
+  HDC hdc = ::GetDC(NULL);
+  int result = ::GetDIBits(hdc,
+                           icon_info.hbmColor,
+                           0,
+                           kSmallIconWidth,
+                           NULL,
+                           &bitmap_info,
+                           DIB_RGB_COLORS);
+  ASSERT_GT(result, 0);
+  EXPECT_EQ(bitmap_info.bmiHeader.biWidth, kSmallIconWidth);
+  EXPECT_EQ(bitmap_info.bmiHeader.biHeight, kSmallIconHeight);
+  EXPECT_EQ(bitmap_info.bmiHeader.biPlanes, 1);
+  EXPECT_EQ(bitmap_info.bmiHeader.biBitCount, 32);
+  ::ReleaseDC(NULL, hdc);
+}
+
+// This test case makes sure that CreateIconFileFromImageFamily creates a
+// valid .ico file given an ImageFamily, and appropriately creates all icon
+// sizes from the given input.
+TEST_F(IconUtilTest, TestCreateIconFileFromImageFamily) {
+  gfx::ImageFamily image_family;
+  base::FilePath icon_filename =
+      temp_directory_.GetPath().AppendASCII(kTempIconFilename);
+
+  // Test with only a 16x16 icon. Should only scale up to 48x48.
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(
+      CreateBlackSkBitmap(kSmallIconWidth, kSmallIconHeight)));
+  ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                      icon_filename));
+  CheckAllIconSizes(icon_filename, 48);
+
+  // Test with a 48x48 icon. Should only scale down.
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(48, 48)));
+  ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                      icon_filename));
+  CheckAllIconSizes(icon_filename, 48);
+
+  // Test with a 64x64 icon. Should scale up to 256x256.
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(64, 64)));
+  ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                      icon_filename));
+  CheckAllIconSizes(icon_filename, 256);
+
+  // Test with a 256x256 icon. Should include the 256x256 in the output.
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(
+      CreateBlackSkBitmap(256, 256)));
+  ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                      icon_filename));
+  CheckAllIconSizes(icon_filename, 256);
+
+  // Test with a 49x49 icon. Should scale up to 256x256, but exclude the
+  // original 49x49 representation from the output.
+  image_family.clear();
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(49, 49)));
+  ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                      icon_filename));
+  CheckAllIconSizes(icon_filename, 256);
+
+  // Test with a non-square 16x32 icon. Should scale up to 48, but exclude the
+  // original 16x32 representation from the output.
+  image_family.clear();
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(16, 32)));
+  ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                      icon_filename));
+  CheckAllIconSizes(icon_filename, 48);
+
+  // Test with a non-square 32x49 icon. Should scale up to 256, but exclude the
+  // original 32x49 representation from the output.
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(32, 49)));
+  ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                      icon_filename));
+  CheckAllIconSizes(icon_filename, 256);
+
+  // Test with an empty and non-empty image.
+  // The empty image should be ignored.
+  image_family.clear();
+  image_family.Add(gfx::Image());
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(16, 16)));
+  ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
+                                                       icon_filename));
+  CheckAllIconSizes(icon_filename, 48);
+}
+
+TEST_F(IconUtilTest, TestCreateImageFamilyFromIconResource) {
+  HMODULE module = GetModuleHandle(NULL);
+  std::unique_ptr<gfx::ImageFamily> family(
+      IconUtil::CreateImageFamilyFromIconResource(module, IDR_MAINFRAME));
+  ASSERT_TRUE(family.get());
+  EXPECT_FALSE(family->empty());
+  std::vector<gfx::Image> images;
+  for (const auto& image : *family)
+    images.push_back(image);
+
+  // Assert that the family contains all of the images from the icon resource.
+  EXPECT_EQ(5u, images.size());
+  EXPECT_EQ(16, images[0].Width());
+  EXPECT_EQ(24, images[1].Width());
+  EXPECT_EQ(32, images[2].Width());
+  EXPECT_EQ(48, images[3].Width());
+  EXPECT_EQ(256, images[4].Width());
+}
+
+// This tests that kNumIconDimensionsUpToMediumSize has the correct value.
+TEST_F(IconUtilTest, TestNumIconDimensionsUpToMediumSize) {
+  ASSERT_LE(IconUtil::kNumIconDimensionsUpToMediumSize,
+            IconUtil::kNumIconDimensions);
+  EXPECT_EQ(IconUtil::kMediumIconSize,
+            IconUtil::kIconDimensions[
+                IconUtil::kNumIconDimensionsUpToMediumSize - 1]);
+}
+
+TEST_F(IconUtilTest, TestTransparentIcon) {
+  base::FilePath icon_filename =
+      temp_directory_.GetPath().AppendASCII(kTempIconFilename);
+  int size = 48;
+  auto semi_transparent_red = SkColorSetARGB(0x77, 0xFF, 0x00, 0x00);
+
+  // Create a bitmap with a semi transparent red dot.
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(size, size, false);
+  EXPECT_EQ(bitmap.alphaType(), kPremul_SkAlphaType);
+  {
+    SkCanvas canvas(bitmap, SkSurfaceProps{});
+    canvas.drawColor(SK_ColorWHITE);
+    SkPaint paint;
+    paint.setColor(semi_transparent_red);
+    paint.setBlendMode(SkBlendMode::kSrc);
+    canvas.drawPoint(1, 1, paint);
+  }
+
+  // Create icon from that bitmap.
+  gfx::ImageFamily image_family;
+  image_family.Add(gfx::Image::CreateFrom1xBitmap(bitmap));
+  ASSERT_TRUE(
+      IconUtil::CreateIconFileFromImageFamily(image_family, icon_filename));
+
+  // Load icon and check that dot has same color.
+  ScopedHICON icon(LoadIconFromFile(icon_filename, size, size));
+  ASSERT_TRUE(icon.is_valid());
+  SkBitmap bitmap_loaded =
+      IconUtil::CreateSkBitmapFromHICON(icon.get(), gfx::Size(size, size));
+  EXPECT_EQ(bitmap_loaded.getColor(1, 1), semi_transparent_red);
+}
diff --git a/ui/gfx/icon_util_unittests.ico b/ui/gfx/icon_util_unittests.ico
new file mode 100644
index 0000000..8cd57a1
--- /dev/null
+++ b/ui/gfx/icon_util_unittests.ico
Binary files differ
diff --git a/ui/gfx/icon_util_unittests.rc b/ui/gfx/icon_util_unittests.rc
new file mode 100644
index 0000000..a44a001
--- /dev/null
+++ b/ui/gfx/icon_util_unittests.rc
@@ -0,0 +1,36 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "icon_util_unittests_resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#define APSTUDIO_HIDDEN_SYMBOLS
+#include "windows.h"
+#undef APSTUDIO_HIDDEN_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDR_MAINFRAME  ICON  "icon_util_unittests.ico"
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
diff --git a/ui/gfx/icon_util_unittests_resource.h b/ui/gfx/icon_util_unittests_resource.h
new file mode 100644
index 0000000..560a0de
--- /dev/null
+++ b/ui/gfx/icon_util_unittests_resource.h
@@ -0,0 +1,10 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_ICON_UTIL_UNITTESTS_RESOURCE_H_
+#define UI_GFX_ICON_UTIL_UNITTESTS_RESOURCE_H_
+
+#define IDR_MAINFRAME               101
+
+#endif  // UI_GFX_ICON_UTIL_UNITTESTS_RESOURCE_H_
\ No newline at end of file
diff --git a/ui/gfx/image/OWNERS b/ui/gfx/image/OWNERS
new file mode 100644
index 0000000..23dbb5a
--- /dev/null
+++ b/ui/gfx/image/OWNERS
@@ -0,0 +1,4 @@
+rsesek@chromium.org
+
+# ImageSkia related classes except for _mac/_ios stuff
+per-file image_skia*=oshima@chromium.org
diff --git a/ui/gfx/image/buffer_w_stream.cc b/ui/gfx/image/buffer_w_stream.cc
new file mode 100644
index 0000000..ea9747f
--- /dev/null
+++ b/ui/gfx/image/buffer_w_stream.cc
@@ -0,0 +1,29 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/image/buffer_w_stream.h"
+
+#include <utility>
+
+namespace gfx {
+
+BufferWStream::BufferWStream() = default;
+
+BufferWStream::~BufferWStream() = default;
+
+std::vector<uint8_t> BufferWStream::TakeBuffer() {
+  return std::move(result_);
+}
+
+bool BufferWStream::write(const void* buffer, size_t size) {
+  const uint8_t* bytes = reinterpret_cast<const uint8_t*>(buffer);
+  result_.insert(result_.end(), bytes, bytes + size);
+  return true;
+}
+
+size_t BufferWStream::bytesWritten() const {
+  return result_.size();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/buffer_w_stream.h b/ui/gfx/image/buffer_w_stream.h
new file mode 100644
index 0000000..43b555f
--- /dev/null
+++ b/ui/gfx/image/buffer_w_stream.h
@@ -0,0 +1,38 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_BUFFER_W_STREAM_H_
+#define UI_GFX_IMAGE_BUFFER_W_STREAM_H_
+
+#include <stdint.h>
+#include <vector>
+
+#include "third_party/skia/include/core/SkStream.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Writes bytes to a std::vector that can be fetched. This is used to record the
+// output of skia image encoding.
+class GFX_EXPORT BufferWStream : public SkWStream {
+ public:
+  BufferWStream();
+  BufferWStream(const BufferWStream&) = delete;
+  BufferWStream& operator=(const BufferWStream&) = delete;
+  ~BufferWStream() override;
+
+  // Returns the output buffer by moving.
+  std::vector<uint8_t> TakeBuffer();
+
+  // SkWStream:
+  bool write(const void* buffer, size_t size) override;
+  size_t bytesWritten() const override;
+
+ private:
+  std::vector<uint8_t> result_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_BUFFER_W_STREAM_H_
diff --git a/ui/gfx/image/buffer_w_stream_unittest.cc b/ui/gfx/image/buffer_w_stream_unittest.cc
new file mode 100644
index 0000000..1d7e02c
--- /dev/null
+++ b/ui/gfx/image/buffer_w_stream_unittest.cc
@@ -0,0 +1,54 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/image/buffer_w_stream.h"
+
+#include <stdint.h>
+#include <algorithm>
+#include <vector>
+
+#include "base/ranges/algorithm.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+namespace {
+
+using BufferWStreamTest = testing::Test;
+
+TEST(BufferWStreamTest, WriteBuffer) {
+  BufferWStream stream;
+
+  std::vector<uint8_t> buffer;
+  for (uint8_t i = 0; i < 10; i++) {
+    buffer.push_back(i);
+  }
+  ASSERT_TRUE(stream.write(buffer.data(), buffer.size()));
+  std::vector<uint8_t> buffer_from_stream = stream.TakeBuffer();
+  EXPECT_TRUE(base::ranges::equal(buffer, buffer_from_stream));
+
+  std::vector<uint8_t> buffer2;
+  for (uint8_t i = 5; i > 0; i--) {
+    buffer2.push_back(i);
+  }
+
+  // Checks that the stream is cleared after TakeBuffer() so that it won't
+  // contain old data.
+  ASSERT_TRUE(stream.write(buffer2.data(), buffer2.size()));
+  buffer_from_stream = stream.TakeBuffer();
+  EXPECT_TRUE(base::ranges::equal(buffer2, buffer_from_stream));
+
+  // Checks that calling write() twice works expectedly.
+  ASSERT_TRUE(stream.write(buffer.data(), buffer.size()));
+  ASSERT_TRUE(stream.write(buffer2.data(), buffer2.size()));
+  buffer_from_stream = stream.TakeBuffer();
+  EXPECT_TRUE(base::ranges::equal(buffer.begin(), buffer.end(),
+                                  buffer_from_stream.begin(),
+                                  buffer_from_stream.begin() + buffer.size()));
+  EXPECT_TRUE(base::ranges::equal(buffer2.begin(), buffer2.end(),
+                                  buffer_from_stream.begin() + buffer.size(),
+                                  buffer_from_stream.end()));
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/image/canvas_image_source.cc b/ui/gfx/image/canvas_image_source.cc
new file mode 100644
index 0000000..13274ed
--- /dev/null
+++ b/ui/gfx/image/canvas_image_source.cc
@@ -0,0 +1,80 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/canvas_image_source.h"
+
+#include "base/check_op.h"
+#include "cc/paint/display_item_list.h"
+#include "cc/paint/record_paint_canvas.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+
+namespace {
+
+class PaddedImageSource : public CanvasImageSource {
+ public:
+  PaddedImageSource(const ImageSkia& image, const Insets& insets)
+      : CanvasImageSource(Size(image.width() + insets.width(),
+                               image.height() + insets.height())),
+        image_(image),
+        insets_(insets) {}
+
+  PaddedImageSource(const PaddedImageSource&) = delete;
+  PaddedImageSource& operator=(const PaddedImageSource&) = delete;
+
+  // CanvasImageSource:
+  void Draw(Canvas* canvas) override {
+    canvas->DrawImageInt(image_, insets_.left(), insets_.top());
+  }
+
+ private:
+  const ImageSkia image_;
+  const Insets insets_;
+};
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+// CanvasImageSource
+
+// static
+ImageSkia CanvasImageSource::CreatePadded(const ImageSkia& image,
+                                          const Insets& insets) {
+  return MakeImageSkia<PaddedImageSource>(image, insets);
+}
+
+CanvasImageSource::CanvasImageSource(const Size& size) : size_(size) {}
+
+ImageSkiaRep CanvasImageSource::GetImageForScale(float scale) {
+  scoped_refptr<cc::DisplayItemList> display_item_list =
+      base::MakeRefCounted<cc::DisplayItemList>(
+          cc::DisplayItemList::kToBeReleasedAsPaintOpBuffer);
+  display_item_list->StartPaint();
+
+  SizeF size_in_pixel = ScaleSize(SizeF(size_), scale);
+  cc::RecordPaintCanvas record_canvas(
+      display_item_list.get(),
+      SkRect::MakeWH(SkFloatToScalar(size_in_pixel.width()),
+                     SkFloatToScalar(size_in_pixel.height())));
+  gfx::Canvas canvas(&record_canvas, scale);
+#if DCHECK_IS_ON()
+  Rect clip_rect;
+  DCHECK(canvas.GetClipBounds(&clip_rect));
+  DCHECK(clip_rect.Contains(gfx::Rect(ToCeiledSize(size_in_pixel))));
+#endif
+  canvas.Scale(scale, scale);
+  Draw(&canvas);
+
+  display_item_list->EndPaintOfPairedEnd();
+  display_item_list->Finalize();
+  return ImageSkiaRep(display_item_list->ReleaseAsRecord(),
+                      gfx::ScaleToCeiledSize(size_, scale), scale);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/canvas_image_source.h b/ui/gfx/image/canvas_image_source.h
new file mode 100644
index 0000000..18aeb58
--- /dev/null
+++ b/ui/gfx/image/canvas_image_source.h
@@ -0,0 +1,63 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_CANVAS_IMAGE_SOURCE_H_
+#define UI_GFX_IMAGE_CANVAS_IMAGE_SOURCE_H_
+
+#include <utility>
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_skia_source.h"
+
+namespace gfx {
+class Canvas;
+class ImageSkiaRep;
+class Insets;
+
+// CanvasImageSource is useful if you need to generate an image for a scale
+// factor using Canvas. It creates a new Canvas with target scale factor and
+// generates ImageSkiaRep when drawing is completed.
+class GFX_EXPORT CanvasImageSource : public ImageSkiaSource {
+ public:
+  // Factory function to create an ImageSkia from a CanvasImageSource. Example:
+  //   ImageSkia my_image =
+  //       CanvasImageSource::MakeImageSkia<MySource>(param1, param2);
+  template <typename T, typename... Args>
+  static ImageSkia MakeImageSkia(Args&&... args) {
+    auto source = std::make_unique<T>(std::forward<Args>(args)...);
+    Size size = source->size();
+    return ImageSkia(std::move(source), size);
+  }
+
+  // Creates a Image containing |image| with transparent padding around the
+  // edges as specified by |insets|.
+  static ImageSkia CreatePadded(const ImageSkia& image, const Insets& insets);
+
+  explicit CanvasImageSource(const Size& size);
+
+  CanvasImageSource(const CanvasImageSource&) = delete;
+  CanvasImageSource& operator=(const CanvasImageSource&) = delete;
+
+  ~CanvasImageSource() override {}
+
+  // Called when a new image needs to be drawn for a scale factor.
+  virtual void Draw(Canvas* canvas) = 0;
+
+  // Returns the size of images in DIP that this source will generate.
+  const Size& size() const { return size_; }
+
+  // Overridden from ImageSkiaSource.
+  ImageSkiaRep GetImageForScale(float scale) override;
+
+ protected:
+  const Size size_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_CANVAS_IMAGE_SOURCE_H_
diff --git a/ui/gfx/image/image.cc b/ui/gfx/image/image.cc
new file mode 100644
index 0000000..8852ae9
--- /dev/null
+++ b/ui/gfx/image/image.cc
@@ -0,0 +1,648 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image.h"
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include "base/check_op.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/notreached.h"
+#include "build/build_config.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image_platform.h"
+#include "ui/gfx/image/image_png_rep.h"
+#include "ui/gfx/image/image_skia.h"
+
+#if defined(OS_IOS)
+#include "base/mac/foundation_util.h"
+#include "ui/gfx/image/image_skia_util_ios.h"
+#elif defined(OS_MAC)
+#include "base/mac/foundation_util.h"
+#include "base/mac/mac_util.h"
+#include "ui/gfx/image/image_skia_util_mac.h"
+#endif
+
+namespace gfx {
+
+namespace {
+
+using RepresentationMap =
+    std::map<Image::RepresentationType, std::unique_ptr<internal::ImageRep>>;
+
+}  // namespace
+
+namespace internal {
+
+class ImageRepPNG;
+class ImageRepSkia;
+class ImageRepCocoa;
+class ImageRepCocoaTouch;
+
+// An ImageRep is the object that holds the backing memory for an Image. Each
+// RepresentationType has an ImageRep subclass that is responsible for freeing
+// the memory that the ImageRep holds. When an ImageRep is created, it expects
+// to take ownership of the image, without having to retain it or increase its
+// reference count.
+class ImageRep {
+ public:
+  explicit ImageRep(Image::RepresentationType rep) : type_(rep) {}
+
+  // Deletes the associated pixels of an ImageRep.
+  virtual ~ImageRep() {}
+
+  // Cast helpers ("fake RTTI").
+  const ImageRepPNG* AsImageRepPNG() const {
+    CHECK_EQ(type_, Image::kImageRepPNG);
+    return reinterpret_cast<const ImageRepPNG*>(this);
+  }
+  ImageRepPNG* AsImageRepPNG() {
+    return const_cast<ImageRepPNG*>(
+        static_cast<const ImageRep*>(this)->AsImageRepPNG());
+  }
+
+  const ImageRepSkia* AsImageRepSkia() const {
+    CHECK_EQ(type_, Image::kImageRepSkia);
+    return reinterpret_cast<const ImageRepSkia*>(this);
+  }
+  ImageRepSkia* AsImageRepSkia() {
+    return const_cast<ImageRepSkia*>(
+        static_cast<const ImageRep*>(this)->AsImageRepSkia());
+  }
+
+#if defined(OS_IOS)
+  const ImageRepCocoaTouch* AsImageRepCocoaTouch() const {
+    CHECK_EQ(type_, Image::kImageRepCocoaTouch);
+    return reinterpret_cast<const ImageRepCocoaTouch*>(this);
+  }
+  ImageRepCocoaTouch* AsImageRepCocoaTouch() {
+    return const_cast<ImageRepCocoaTouch*>(
+        static_cast<const ImageRep*>(this)->AsImageRepCocoaTouch());
+  }
+#elif defined(OS_MAC)
+  const ImageRepCocoa* AsImageRepCocoa() const {
+    CHECK_EQ(type_, Image::kImageRepCocoa);
+    return reinterpret_cast<const ImageRepCocoa*>(this);
+  }
+  ImageRepCocoa* AsImageRepCocoa() {
+    return const_cast<ImageRepCocoa*>(
+        static_cast<const ImageRep*>(this)->AsImageRepCocoa());
+  }
+#endif
+
+  Image::RepresentationType type() const { return type_; }
+
+  virtual int Width() const = 0;
+  virtual int Height() const = 0;
+  virtual gfx::Size Size() const = 0;
+
+ private:
+  Image::RepresentationType type_;
+};
+
+class ImageRepPNG : public ImageRep {
+ public:
+  ImageRepPNG() : ImageRep(Image::kImageRepPNG) {
+  }
+
+  explicit ImageRepPNG(const std::vector<ImagePNGRep>& image_png_reps)
+      : ImageRep(Image::kImageRepPNG), image_png_reps_(image_png_reps) {}
+
+  ImageRepPNG(const ImageRepPNG&) = delete;
+  ImageRepPNG& operator=(const ImageRepPNG&) = delete;
+
+  ~ImageRepPNG() override {}
+
+  int Width() const override { return Size().width(); }
+
+  int Height() const override { return Size().height(); }
+
+  gfx::Size Size() const override {
+    // Read the PNG data to get the image size, caching it.
+    if (!size_cache_) {
+      for (auto it = image_reps().begin(); it != image_reps().end(); ++it) {
+        if (it->scale == 1.0f) {
+          size_cache_ = it->Size();
+          return *size_cache_;
+        }
+      }
+      size_cache_ = gfx::Size();
+    }
+
+    return *size_cache_;
+  }
+
+  const std::vector<ImagePNGRep>& image_reps() const { return image_png_reps_; }
+
+ private:
+  std::vector<ImagePNGRep> image_png_reps_;
+
+  // Cached to avoid having to parse the raw data multiple times.
+  mutable absl::optional<gfx::Size> size_cache_;
+};
+
+class ImageRepSkia : public ImageRep {
+ public:
+  explicit ImageRepSkia(ImageSkia image)
+      : ImageRep(Image::kImageRepSkia), image_(image) {}
+
+  ImageRepSkia(const ImageRepSkia&) = delete;
+  ImageRepSkia& operator=(const ImageRepSkia&) = delete;
+
+  ~ImageRepSkia() override {}
+
+  int Width() const override { return image_.width(); }
+
+  int Height() const override { return image_.height(); }
+
+  gfx::Size Size() const override { return image_.size(); }
+
+  const ImageSkia* image() const { return &image_; }
+  ImageSkia* image() { return &image_; }
+
+ private:
+  ImageSkia image_;
+};
+
+#if defined(OS_IOS)
+class ImageRepCocoaTouch : public ImageRep {
+ public:
+  explicit ImageRepCocoaTouch(UIImage* image)
+      : ImageRep(Image::kImageRepCocoaTouch),
+        image_(image) {
+    CHECK(image_);
+    base::mac::NSObjectRetain(image_);
+  }
+
+  ImageRepCocoaTouch(const ImageRepCocoaTouch&) = delete;
+  ImageRepCocoaTouch& operator=(const ImageRepCocoaTouch&) = delete;
+
+  ~ImageRepCocoaTouch() override {
+    base::mac::NSObjectRelease(image_);
+    image_ = nil;
+  }
+
+  int Width() const override { return Size().width(); }
+
+  int Height() const override { return Size().height(); }
+
+  gfx::Size Size() const override { return internal::UIImageSize(image_); }
+
+  UIImage* image() const { return image_; }
+
+ private:
+  UIImage* image_;
+};
+#elif defined(OS_MAC)
+class ImageRepCocoa : public ImageRep {
+ public:
+  explicit ImageRepCocoa(NSImage* image)
+      : ImageRep(Image::kImageRepCocoa),
+        image_(image) {
+    CHECK(image_);
+    base::mac::NSObjectRetain(image_);
+  }
+
+  ImageRepCocoa(const ImageRepCocoa&) = delete;
+  ImageRepCocoa& operator=(const ImageRepCocoa&) = delete;
+
+  ~ImageRepCocoa() override {
+    base::mac::NSObjectRelease(image_);
+    image_ = nil;
+  }
+
+  int Width() const override { return Size().width(); }
+
+  int Height() const override { return Size().height(); }
+
+  gfx::Size Size() const override { return internal::NSImageSize(image_); }
+
+  NSImage* image() const { return image_; }
+
+ private:
+  NSImage* image_;
+};
+#endif  // defined(OS_MAC)
+
+// The Storage class acts similarly to the pixels in a SkBitmap: the Image
+// class holds a refptr instance of Storage, which in turn holds all the
+// ImageReps. This way, the Image can be cheaply copied.
+//
+// This class is deliberately not RefCountedThreadSafe. Making it so does not
+// solve threading issues, as gfx::Image and its internal classes are
+// themselves not threadsafe.
+class ImageStorage : public base::RefCounted<ImageStorage> {
+ public:
+  explicit ImageStorage(Image::RepresentationType default_type)
+      : default_representation_type_(default_type)
+#if defined(OS_MAC)
+        ,
+        default_representation_color_space_(
+            base::mac::GetGenericRGBColorSpace())
+#endif  // defined(OS_MAC)
+  {
+  }
+
+  ImageStorage(const ImageStorage&) = delete;
+  ImageStorage& operator=(const ImageStorage&) = delete;
+
+  Image::RepresentationType default_representation_type() const {
+    DCHECK(IsOnValidSequence());
+    return default_representation_type_;
+  }
+
+  bool HasRepresentation(Image::RepresentationType type) const {
+    DCHECK(IsOnValidSequence());
+    return representations_.count(type) != 0;
+  }
+
+  size_t RepresentationCount() const {
+    DCHECK(IsOnValidSequence());
+    return representations_.size();
+  }
+
+  const ImageRep* GetRepresentation(Image::RepresentationType rep_type,
+                                    bool must_exist) const {
+    DCHECK(IsOnValidSequence());
+    RepresentationMap::const_iterator it = representations_.find(rep_type);
+    if (it == representations_.end()) {
+      CHECK(!must_exist);
+      return nullptr;
+    }
+    return it->second.get();
+  }
+
+  const ImageRep* AddRepresentation(std::unique_ptr<ImageRep> rep) const {
+    DCHECK(IsOnValidSequence());
+    Image::RepresentationType type = rep->type();
+    auto result = representations_.emplace(type, std::move(rep));
+
+    // insert should not fail (implies that there was already a representation
+    // of that type in the map).
+    CHECK(result.second) << "type was already in map.";
+
+    return result.first->second.get();
+  }
+
+#if defined(OS_MAC)
+  void set_default_representation_color_space(CGColorSpaceRef color_space) {
+    DCHECK(IsOnValidSequence());
+    default_representation_color_space_ = color_space;
+  }
+  CGColorSpaceRef default_representation_color_space() const {
+    DCHECK(IsOnValidSequence());
+    return default_representation_color_space_;
+  }
+#endif  // defined(OS_MAC)
+
+ private:
+  friend class base::RefCounted<ImageStorage>;
+
+  ~ImageStorage() {}
+
+  // The type of image that was passed to the constructor. This key will always
+  // exist in the |representations_| map.
+  Image::RepresentationType default_representation_type_;
+
+#if defined(OS_MAC)
+  // The default representation's colorspace. This is used for converting to
+  // NSImage. This field exists to compensate for PNGCodec not writing or
+  // reading colorspace ancillary chunks. (sRGB, iCCP).
+  // Not owned.
+  CGColorSpaceRef default_representation_color_space_;
+#endif  // defined(OS_MAC)
+
+  // All the representations of an Image. Size will always be at least one, with
+  // more for any converted representations.
+  mutable RepresentationMap representations_;
+};
+
+}  // namespace internal
+
+Image::Image() {
+  // |storage_| is null for empty Images.
+}
+
+Image::Image(const std::vector<ImagePNGRep>& image_reps) {
+  // Do not store obviously invalid ImagePNGReps.
+  std::vector<ImagePNGRep> filtered;
+  for (size_t i = 0; i < image_reps.size(); ++i) {
+    if (image_reps[i].raw_data.get() && image_reps[i].raw_data->size())
+      filtered.push_back(image_reps[i]);
+  }
+
+  if (filtered.empty())
+    return;
+
+  storage_ = new internal::ImageStorage(Image::kImageRepPNG);
+  AddRepresentation(std::make_unique<internal::ImageRepPNG>(filtered));
+}
+
+Image::Image(const ImageSkia& image) {
+  if (!image.isNull()) {
+    storage_ = new internal::ImageStorage(Image::kImageRepSkia);
+    AddRepresentation(std::make_unique<internal::ImageRepSkia>(image));
+  }
+}
+
+#if defined(OS_IOS)
+Image::Image(UIImage* image) {
+  if (image) {
+    storage_ = new internal::ImageStorage(Image::kImageRepCocoaTouch);
+    AddRepresentation(std::make_unique<internal::ImageRepCocoaTouch>(image));
+  }
+}
+#elif defined(OS_MAC)
+Image::Image(NSImage* image) {
+  if (image) {
+    storage_ = new internal::ImageStorage(Image::kImageRepCocoa);
+    AddRepresentation(std::make_unique<internal::ImageRepCocoa>(image));
+  }
+}
+#endif
+
+Image::Image(const Image& other) = default;
+
+Image::Image(Image&& other) noexcept = default;
+
+Image& Image::operator=(const Image& other) = default;
+
+Image& Image::operator=(Image&& other) noexcept = default;
+
+Image::~Image() {}
+
+bool Image::operator==(const Image& other) const {
+  return storage_ == other.storage_;
+}
+
+// static
+Image Image::CreateFrom1xBitmap(const SkBitmap& bitmap) {
+  return Image(ImageSkia::CreateFrom1xBitmap(bitmap));
+}
+
+// static
+Image Image::CreateFrom1xPNGBytes(const unsigned char* input,
+                                  size_t input_size) {
+  if (input_size == 0u)
+    return Image();
+
+  scoped_refptr<base::RefCountedBytes> raw_data(new base::RefCountedBytes());
+  raw_data->data().assign(input, input + input_size);
+
+  return CreateFrom1xPNGBytes(raw_data);
+}
+
+Image Image::CreateFrom1xPNGBytes(
+    const scoped_refptr<base::RefCountedMemory>& input) {
+  if (!input.get() || input->size() == 0u)
+    return Image();
+
+  std::vector<ImagePNGRep> image_reps;
+  image_reps.push_back(ImagePNGRep(input, 1.0f));
+  return Image(image_reps);
+}
+
+const SkBitmap* Image::ToSkBitmap() const {
+  // Possibly create and cache an intermediate ImageRepSkia.
+  return ToImageSkia()->bitmap();
+}
+
+const ImageSkia* Image::ToImageSkia() const {
+  const internal::ImageRep* rep = GetRepresentation(kImageRepSkia, false);
+  if (!rep) {
+    std::unique_ptr<internal::ImageRep> scoped_rep;
+    switch (DefaultRepresentationType()) {
+      case kImageRepPNG: {
+        const internal::ImageRepPNG* png_rep =
+            GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
+        scoped_rep = std::make_unique<internal::ImageRepSkia>(
+            internal::ImageSkiaFromPNG(png_rep->image_reps()));
+        break;
+      }
+#if defined(OS_IOS)
+      case kImageRepCocoaTouch: {
+        const internal::ImageRepCocoaTouch* native_rep =
+            GetRepresentation(kImageRepCocoaTouch, true)
+                ->AsImageRepCocoaTouch();
+        scoped_rep = std::make_unique<internal::ImageRepSkia>(
+            ImageSkia(ImageSkiaFromUIImage(native_rep->image())));
+        break;
+      }
+#elif defined(OS_MAC)
+      case kImageRepCocoa: {
+        const internal::ImageRepCocoa* native_rep =
+            GetRepresentation(kImageRepCocoa, true)->AsImageRepCocoa();
+        scoped_rep = std::make_unique<internal::ImageRepSkia>(
+            ImageSkia(ImageSkiaFromNSImage(native_rep->image())));
+        break;
+      }
+#endif
+      default:
+        NOTREACHED();
+    }
+    CHECK(scoped_rep);
+    rep = AddRepresentation(std::move(scoped_rep));
+  }
+  return rep->AsImageRepSkia()->image();
+}
+
+#if defined(OS_IOS)
+UIImage* Image::ToUIImage() const {
+  const internal::ImageRep* rep = GetRepresentation(kImageRepCocoaTouch, false);
+  if (!rep) {
+    std::unique_ptr<internal::ImageRep> scoped_rep;
+    switch (DefaultRepresentationType()) {
+      case kImageRepPNG: {
+        const internal::ImageRepPNG* png_rep =
+            GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
+        scoped_rep = std::make_unique<internal::ImageRepCocoaTouch>(
+            internal::UIImageFromPNG(png_rep->image_reps()));
+        break;
+      }
+      case kImageRepSkia: {
+        const internal::ImageRepSkia* skia_rep =
+            GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
+        UIImage* image = UIImageFromImageSkia(*skia_rep->image());
+        scoped_rep = std::make_unique<internal::ImageRepCocoaTouch>(image);
+        break;
+      }
+      default:
+        NOTREACHED();
+    }
+    CHECK(scoped_rep);
+    rep = AddRepresentation(std::move(scoped_rep));
+  }
+  return rep->AsImageRepCocoaTouch()->image();
+}
+#elif defined(OS_MAC)
+NSImage* Image::ToNSImage() const {
+  const internal::ImageRep* rep = GetRepresentation(kImageRepCocoa, false);
+  if (!rep) {
+    std::unique_ptr<internal::ImageRep> scoped_rep;
+    CGColorSpaceRef default_representation_color_space =
+        storage()->default_representation_color_space();
+
+    switch (DefaultRepresentationType()) {
+      case kImageRepPNG: {
+        const internal::ImageRepPNG* png_rep =
+            GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
+        scoped_rep =
+            std::make_unique<internal::ImageRepCocoa>(internal::NSImageFromPNG(
+                png_rep->image_reps(), default_representation_color_space));
+        break;
+      }
+      case kImageRepSkia: {
+        const internal::ImageRepSkia* skia_rep =
+            GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
+        NSImage* image = NSImageFromImageSkiaWithColorSpace(*skia_rep->image(),
+            default_representation_color_space);
+        scoped_rep = std::make_unique<internal::ImageRepCocoa>(image);
+        break;
+      }
+      default:
+        NOTREACHED();
+    }
+    CHECK(scoped_rep);
+    rep = AddRepresentation(std::move(scoped_rep));
+  }
+  return rep->AsImageRepCocoa()->image();
+}
+#endif
+
+scoped_refptr<base::RefCountedMemory> Image::As1xPNGBytes() const {
+  if (IsEmpty())
+    return new base::RefCountedBytes();
+
+  const internal::ImageRep* rep = GetRepresentation(kImageRepPNG, false);
+
+  if (rep) {
+    const std::vector<ImagePNGRep>& image_png_reps =
+        rep->AsImageRepPNG()->image_reps();
+    for (size_t i = 0; i < image_png_reps.size(); ++i) {
+      if (image_png_reps[i].scale == 1.0f)
+        return image_png_reps[i].raw_data;
+    }
+    return new base::RefCountedBytes();
+  }
+
+  scoped_refptr<base::RefCountedMemory> png_bytes;
+  switch (DefaultRepresentationType()) {
+#if defined(OS_IOS)
+    case kImageRepCocoaTouch: {
+      const internal::ImageRepCocoaTouch* cocoa_touch_rep =
+          GetRepresentation(kImageRepCocoaTouch, true)->AsImageRepCocoaTouch();
+      png_bytes = internal::Get1xPNGBytesFromUIImage(
+          cocoa_touch_rep->image());
+      break;
+    }
+#elif defined(OS_MAC)
+    case kImageRepCocoa: {
+      const internal::ImageRepCocoa* cocoa_rep =
+          GetRepresentation(kImageRepCocoa, true)->AsImageRepCocoa();
+      png_bytes = internal::Get1xPNGBytesFromNSImage(cocoa_rep->image());
+      break;
+    }
+#endif
+    case kImageRepSkia: {
+      const internal::ImageRepSkia* skia_rep =
+          GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
+      png_bytes = internal::Get1xPNGBytesFromImageSkia(skia_rep->image());
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+  if (!png_bytes.get() || !png_bytes->size()) {
+    // Add an ImageRepPNG with no data such that the conversion is not
+    // attempted each time we want the PNG bytes.
+    AddRepresentation(base::WrapUnique(new internal::ImageRepPNG()));
+    return new base::RefCountedBytes();
+  }
+
+  // Do not insert representations for scale factors other than 1x even if
+  // they are available because:
+  // - Only the 1x PNG bytes can be accessed.
+  // - ImageRepPNG is not used as an intermediate type in converting to a
+  //   final type eg (converting from ImageRepSkia to ImageRepPNG to get an
+  //   ImageRepCocoa).
+  std::vector<ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(ImagePNGRep(png_bytes, 1.0f));
+  AddRepresentation(
+      base::WrapUnique(new internal::ImageRepPNG(image_png_reps)));
+  return png_bytes;
+}
+
+SkBitmap Image::AsBitmap() const {
+  return IsEmpty() ? SkBitmap() : *ToSkBitmap();
+}
+
+ImageSkia Image::AsImageSkia() const {
+  return IsEmpty() ? ImageSkia() : *ToImageSkia();
+}
+
+#if defined(OS_MAC)
+NSImage* Image::AsNSImage() const {
+  return IsEmpty() ? nil : ToNSImage();
+}
+#endif
+
+bool Image::HasRepresentation(RepresentationType type) const {
+  return storage() && storage()->HasRepresentation(type);
+}
+
+size_t Image::RepresentationCount() const {
+  return storage() ? storage()->RepresentationCount() : 0;
+}
+
+bool Image::IsEmpty() const {
+  return RepresentationCount() == 0;
+}
+
+int Image::Width() const {
+  if (IsEmpty())
+    return 0;
+  return GetRepresentation(DefaultRepresentationType(), true)->Width();
+}
+
+int Image::Height() const {
+  if (IsEmpty())
+    return 0;
+  return GetRepresentation(DefaultRepresentationType(), true)->Height();
+}
+
+gfx::Size Image::Size() const {
+  if (IsEmpty())
+    return gfx::Size();
+  return GetRepresentation(DefaultRepresentationType(), true)->Size();
+}
+
+#if defined(OS_MAC)
+void Image::SetSourceColorSpace(CGColorSpaceRef color_space) {
+  if (storage())
+    storage()->set_default_representation_color_space(color_space);
+}
+#endif  // defined(OS_MAC)
+
+Image::RepresentationType Image::DefaultRepresentationType() const {
+  CHECK(storage());
+  return storage()->default_representation_type();
+}
+
+const internal::ImageRep* Image::GetRepresentation(RepresentationType rep_type,
+                                                   bool must_exist) const {
+  CHECK(storage());
+  return storage()->GetRepresentation(rep_type, must_exist);
+}
+
+const internal::ImageRep* Image::AddRepresentation(
+    std::unique_ptr<internal::ImageRep> rep) const {
+  CHECK(storage());
+  return storage()->AddRepresentation(std::move(rep));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image.h b/ui/gfx/image/image.h
new file mode 100644
index 0000000..52ad9fd
--- /dev/null
+++ b/ui/gfx/image/image.h
@@ -0,0 +1,194 @@
+// Copyright (c) 2012 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.
+
+// An Image wraps an image any flavor, be it platform-native GdkBitmap/NSImage,
+// or a SkBitmap. This also provides easy conversion to other image types
+// through operator overloading. It will cache the converted representations
+// internally to prevent double-conversion.
+//
+// The lifetime of both the initial representation and any converted ones are
+// tied to the lifetime of the Image's internal storage. To allow Images to be
+// cheaply passed around by value, the actual image data is stored in a ref-
+// counted member. When all Images referencing this storage are deleted, the
+// actual representations are deleted, too.
+//
+// Images can be empty, in which case they have no backing representation.
+// Attempting to use an empty Image will result in a crash.
+
+#ifndef UI_GFX_IMAGE_IMAGE_H_
+#define UI_GFX_IMAGE_IMAGE_H_
+
+#include <stddef.h>
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_policy.h"
+#include "build/build_config.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/native_widget_types.h"
+
+#if defined(OS_MAC)
+typedef struct CGColorSpace* CGColorSpaceRef;
+#endif
+
+class SkBitmap;
+
+namespace gfx {
+struct ImagePNGRep;
+class ImageSkia;
+class Size;
+
+namespace internal {
+class ImageRep;
+class ImageStorage;
+}
+
+class GFX_EXPORT Image {
+ public:
+  enum RepresentationType {
+    kImageRepCocoa,
+    kImageRepCocoaTouch,
+    kImageRepSkia,
+    kImageRepPNG,
+  };
+
+  // Creates an empty image with no representations.
+  Image();
+
+  // Creates a new image by copying the raw PNG-encoded input for use as the
+  // default representation.
+  explicit Image(const std::vector<ImagePNGRep>& image_reps);
+
+  // Creates a new image by copying the ImageSkia for use as the default
+  // representation.
+  explicit Image(const ImageSkia& image);
+
+#if defined(OS_IOS)
+  // Retains |image|.
+  explicit Image(UIImage* image);
+#elif defined(OS_MAC)
+  // Retains |image|.
+  explicit Image(NSImage* image);
+#endif
+
+  // Initializes a new Image by AddRef()ing |other|'s internal storage.
+  Image(const Image& other);
+
+  // Moves a reference from |other| to the new image without changing the
+  // reference count.
+  Image(Image&& other) noexcept;
+
+  // Copies a reference to |other|'s storage.
+  Image& operator=(const Image& other);
+
+  // Moves a reference from |other|'s storage without changing the reference
+  // count.
+  Image& operator=(Image&& other) noexcept;
+
+  // Deletes the image and, if the only owner of the storage, all of its cached
+  // representations.
+  ~Image();
+
+  // True iff both images are backed by the same storage.
+  bool operator==(const Image& other) const;
+
+  // Creates an image from the passed in 1x bitmap.
+  // WARNING: The resulting image will be pixelated when painted on a high
+  // density display.
+  static Image CreateFrom1xBitmap(const SkBitmap& bitmap);
+
+  // Creates an image from the PNG encoded input.
+  // For example (from an std::vector):
+  // std::vector<unsigned char> png = ...;
+  // gfx::Image image =
+  //     Image::CreateFrom1xPNGBytes(&png.front(), png.size());
+  static Image CreateFrom1xPNGBytes(const unsigned char* input,
+                                    size_t input_size);
+
+  // Creates an image from the PNG encoded input.
+  static Image CreateFrom1xPNGBytes(
+      const scoped_refptr<base::RefCountedMemory>& input);
+
+  // Converts the Image to the desired representation and stores it internally.
+  // The returned result is a weak pointer owned by and scoped to the life of
+  // the Image. Must only be called if IsEmpty() is false.
+  const SkBitmap* ToSkBitmap() const;
+  const ImageSkia* ToImageSkia() const;
+#if defined(OS_IOS)
+  UIImage* ToUIImage() const;
+#elif defined(OS_MAC)
+  NSImage* ToNSImage() const;
+#endif
+
+  // Returns the raw PNG-encoded data for the bitmap at 1x. If the data is
+  // unavailable, either because the image has no data for 1x or because it is
+  // empty, an empty RefCountedBytes object is returned. NULL is never
+  // returned.
+  scoped_refptr<base::RefCountedMemory> As1xPNGBytes() const;
+
+  // Same as ToSkBitmap(), but returns a null SkBitmap if this image is empty.
+  SkBitmap AsBitmap() const;
+
+  // Same as ToImageSkia(), but returns an empty ImageSkia if this
+  // image is empty.
+  ImageSkia AsImageSkia() const;
+
+  // Same as ToNSImage(), but returns nil if this image is empty.
+#if defined(OS_MAC)
+  NSImage* AsNSImage() const;
+#endif
+
+  // Inspects the representations map to see if the given type exists.
+  bool HasRepresentation(RepresentationType type) const;
+
+  // Returns the number of representations.
+  size_t RepresentationCount() const;
+
+  // Returns true if this Image has no representations.
+  bool IsEmpty() const;
+
+  // Width and height of image in DIP coordinate system.
+  int Width() const;
+  int Height() const;
+  gfx::Size Size() const;
+
+#if defined(OS_MAC)
+  // Set the default representation's color space. This is used for converting
+  // to NSImage. This is used to compensate for PNGCodec not writing or reading
+  // colorspace ancillary chunks. (sRGB, iCCP).
+  void SetSourceColorSpace(CGColorSpaceRef color_space);
+#endif  // defined(OS_MAC)
+
+ private:
+  // Returns the type of the default representation.
+  RepresentationType DefaultRepresentationType() const;
+
+  // Returns the ImageRep of the appropriate type or NULL if there is no
+  // representation of that type (and must_exist is false).
+  const internal::ImageRep* GetRepresentation(RepresentationType rep_type,
+                                              bool must_exist) const;
+
+  // Stores a representation into the map. A representation of that type must
+  // not already be in the map. Returns a pointer to the representation stored
+  // inside the map.
+  const internal::ImageRep* AddRepresentation(
+      std::unique_ptr<internal::ImageRep> rep) const;
+
+  // Getter should be used internally (unless a handle to the scoped_refptr is
+  // needed) instead of directly accessing |storage_|, to ensure logical
+  // constness is upheld.
+  const internal::ImageStorage* storage() const { return storage_.get(); }
+  internal::ImageStorage* storage() { return storage_.get(); }
+
+  // Internal class that holds all the representations. This allows the Image to
+  // be cheaply copied.
+  scoped_refptr<internal::ImageStorage> storage_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_H_
diff --git a/ui/gfx/image/image_family.cc b/ui/gfx/image/image_family.cc
new file mode 100644
index 0000000..e6fce1d
--- /dev/null
+++ b/ui/gfx/image/image_family.cc
@@ -0,0 +1,164 @@
+// 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.
+
+#include "ui/gfx/image/image_family.h"
+
+#include <cmath>
+
+#include "skia/ext/image_operations.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace gfx {
+
+ImageFamily::const_iterator::const_iterator() {}
+
+ImageFamily::const_iterator::const_iterator(const const_iterator& other)
+    : map_iterator_(other.map_iterator_) {}
+
+ImageFamily::const_iterator::const_iterator(
+    const std::map<MapKey, gfx::Image>::const_iterator& other)
+    : map_iterator_(other) {}
+
+ImageFamily::const_iterator::~const_iterator() {}
+
+ImageFamily::ImageFamily() {}
+ImageFamily::ImageFamily(ImageFamily&& other) = default;
+ImageFamily::~ImageFamily() {}
+
+ImageFamily& ImageFamily::operator=(ImageFamily&& other) = default;
+
+ImageFamily ImageFamily::Clone() const {
+  ImageFamily clone;
+  clone.map_ = map_;
+  return clone;
+}
+
+void ImageFamily::Add(const gfx::Image& image) {
+  gfx::Size size = image.Size();
+  if (size.IsEmpty()) {
+    map_[MapKey(1.0f, 0)] = image;
+  } else {
+    float aspect = static_cast<float>(size.width()) / size.height();
+    DCHECK_GT(aspect, 0.0f);
+    map_[MapKey(aspect, size.width())] = image;
+  }
+}
+
+void ImageFamily::Add(const gfx::ImageSkia& image_skia) {
+  Add(gfx::Image(image_skia));
+}
+
+const gfx::Image* ImageFamily::GetBest(int width, int height) const {
+  if (map_.empty())
+    return NULL;
+
+  // If either |width| or |height| is 0, both are.
+  float desired_aspect;
+  if (height == 0 || width == 0) {
+    desired_aspect = 1.0f;
+    height = 0;
+    width = 0;
+  } else {
+    desired_aspect = static_cast<float>(width) / height;
+  }
+  DCHECK_GT(desired_aspect, 0.0f);
+
+  float closest_aspect = GetClosestAspect(desired_aspect);
+
+  // If thinner than desired, search for images with width such that the
+  // corresponding height is greater than or equal to the desired |height|.
+  int desired_width = closest_aspect <= desired_aspect ?
+      width : static_cast<int>(ceilf(height * closest_aspect));
+
+  // Get the best-sized image with the aspect ratio.
+  return GetWithExactAspect(closest_aspect, desired_width);
+}
+
+float ImageFamily::GetClosestAspect(float desired_aspect) const {
+  // Find the two aspect ratios on either side of |desired_aspect|.
+  auto greater_or_equal = map_.lower_bound(MapKey(desired_aspect, 0));
+  // Early exit optimization if there is an exact match.
+  if (greater_or_equal != map_.end() &&
+      greater_or_equal->first.aspect() == desired_aspect) {
+    return desired_aspect;
+  }
+
+  // No exact match; |greater_or_equal| will point to the first image with
+  // aspect ratio >= |desired_aspect|, and |less_than| will point to the last
+  // image with aspect ratio < |desired_aspect|.
+  if (greater_or_equal != map_.begin()) {
+    auto less_than = greater_or_equal;
+    --less_than;
+    float thinner_aspect = less_than->first.aspect();
+    DCHECK_GT(thinner_aspect, 0.0f);
+    DCHECK_LT(thinner_aspect, desired_aspect);
+    if (greater_or_equal != map_.end()) {
+      float wider_aspect = greater_or_equal->first.aspect();
+      DCHECK_GT(wider_aspect, desired_aspect);
+      if ((wider_aspect / desired_aspect) < (desired_aspect / thinner_aspect))
+        return wider_aspect;
+    }
+    return thinner_aspect;
+  } else {
+    // No aspect ratio is less than or equal to |desired_aspect|.
+    DCHECK(greater_or_equal != map_.end());
+    float wider_aspect = greater_or_equal->first.aspect();
+    DCHECK_GT(wider_aspect, desired_aspect);
+    return wider_aspect;
+  }
+}
+
+const gfx::Image* ImageFamily::GetBest(const gfx::Size& size) const {
+  return GetBest(size.width(), size.height());
+}
+
+gfx::Image ImageFamily::CreateExact(int width, int height) const {
+  // Resize crashes if width or height is 0, so just return an empty image.
+  if (width == 0 || height == 0)
+    return gfx::Image();
+
+  const gfx::Image* image = GetBest(width, height);
+  if (!image)
+    return gfx::Image();
+
+  if (image->Width() == width && image->Height() == height) {
+    // Make a copy at gfx::ImageSkia level, so that resulting image's ref count
+    // is not racy to |image|. Since this function can run on a different thread
+    // than the thread |image| created on, we should not touch the
+    // non-thread-safe ref count in gfx::Image here.
+    return gfx::Image(image->AsImageSkia());
+  }
+
+  SkBitmap bitmap = image->AsBitmap();
+  SkBitmap resized_bitmap = skia::ImageOperations::Resize(
+      bitmap, skia::ImageOperations::RESIZE_LANCZOS3, width, height);
+  return gfx::Image::CreateFrom1xBitmap(resized_bitmap);
+}
+
+gfx::Image ImageFamily::CreateExact(const gfx::Size& size) const {
+  return CreateExact(size.width(), size.height());
+}
+
+const gfx::Image* ImageFamily::GetWithExactAspect(float aspect,
+                                                  int width) const {
+  // Find the two images of given aspect ratio on either side of |width|.
+  auto greater_or_equal = map_.lower_bound(MapKey(aspect, width));
+  if (greater_or_equal != map_.end() &&
+      greater_or_equal->first.aspect() == aspect) {
+    // We have found the smallest image of the same size or greater.
+    return &greater_or_equal->second;
+  }
+
+  DCHECK(greater_or_equal != map_.begin());
+  auto less_than = greater_or_equal;
+  --less_than;
+  // This must be true because there must be at least one image with |aspect|.
+  DCHECK_EQ(less_than->first.aspect(), aspect);
+  // We have found the largest image smaller than desired.
+  return &less_than->second;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_family.h b/ui/gfx/image/image_family.h
new file mode 100644
index 0000000..f874426
--- /dev/null
+++ b/ui/gfx/image/image_family.h
@@ -0,0 +1,184 @@
+// 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.
+
+#ifndef UI_GFX_IMAGE_IMAGE_FAMILY_H_
+#define UI_GFX_IMAGE_IMAGE_FAMILY_H_
+
+#include <iterator>
+#include <map>
+#include <utility>
+
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/image/image.h"
+
+namespace gfx {
+class ImageSkia;
+class Size;
+
+// A collection of images at different sizes. The images should be different
+// representations of the same basic concept (for example, an icon) at various
+// sizes and (optionally) aspect ratios. A method is provided for finding the
+// most appropriate image to fit in a given rectangle.
+//
+// NOTE: This is not appropriate for storing an image at a single logical pixel
+// size, with high-DPI bitmap versions; use an Image or ImageSkia for that. Each
+// image in an ImageFamily should have a different logical size (and may also
+// include high-DPI representations).
+class GFX_EXPORT ImageFamily {
+ private:
+  // An <aspect ratio, DIP width> pair.
+  // A 0x0 image has aspect ratio 1.0. 0xN and Nx0 images are treated as 0x0.
+  struct MapKey : std::pair<float, int> {
+    MapKey(float aspect, int width)
+        : std::pair<float, int>(aspect, width) {}
+
+    float aspect() const { return first; }
+
+    int width() const { return second; }
+  };
+
+ public:
+  // Type for iterating over all images in the family, in order.
+  // Dereferencing this iterator returns a gfx::Image.
+  class GFX_EXPORT const_iterator :
+    std::iterator<std::bidirectional_iterator_tag, const gfx::Image> {
+   public:
+    const_iterator();
+
+    const_iterator(const const_iterator& other);
+
+    ~const_iterator();
+
+    const_iterator& operator++() {
+      ++map_iterator_;
+      return *this;
+    }
+
+    const_iterator operator++(int /*unused*/) {
+      const_iterator result(*this);
+      ++(*this);
+      return result;
+    }
+
+    const_iterator& operator--() {
+      --map_iterator_;
+      return *this;
+    }
+
+    const_iterator operator--(int /*unused*/) {
+      const_iterator result(*this);
+      --(*this);
+      return result;
+    }
+
+    bool operator==(const const_iterator& other) const {
+      return map_iterator_ == other.map_iterator_;
+    }
+
+    bool operator!=(const const_iterator& other) const {
+      return map_iterator_ != other.map_iterator_;
+    }
+
+    const gfx::Image& operator*() const {
+      return map_iterator_->second;
+    }
+
+    const gfx::Image* operator->() const {
+      return &**this;
+    }
+
+   private:
+    friend class ImageFamily;
+
+    explicit const_iterator(
+        const std::map<MapKey, gfx::Image>::const_iterator& other);
+
+    std::map<MapKey, gfx::Image>::const_iterator map_iterator_;
+  };
+
+  ImageFamily();
+  ImageFamily(ImageFamily&& other);
+
+  // Even though the Images in the family are copyable (reference-counted), the
+  // family itself should not be implicitly copied, as it would result in a
+  // shallow clone of the entire map and updates to many reference counts.
+  // ImageFamily can be explicitly Clone()d, but std::move is preferred.
+  ImageFamily(const ImageFamily&) = delete;
+  ImageFamily& operator=(const ImageFamily&) = delete;
+
+  ~ImageFamily();
+
+  ImageFamily& operator=(ImageFamily&& other);
+
+  // Gets an iterator to the first image.
+  const_iterator begin() const { return const_iterator(map_.begin()); }
+  // Gets an iterator to one after the last image.
+  const_iterator end() const { return const_iterator(map_.end()); }
+
+  // Determines whether the image family has no images in it.
+  bool empty() const { return map_.empty(); }
+
+  // Removes all images from the family.
+  void clear() { return map_.clear(); }
+
+  // Creates a shallow copy of the family. The Images inside share their backing
+  // store with the original Images.
+  ImageFamily Clone() const;
+
+  // Adds an image to the family. If another image is already present at the
+  // same size, it will be overwritten.
+  void Add(const gfx::Image& image);
+
+  // Adds an image to the family. If another image is already present at the
+  // same size, it will be overwritten.
+  void Add(const gfx::ImageSkia& image_skia);
+
+  // Gets the best image to use in a rectangle of |width|x|height|.
+  // Gets an image at the same aspect ratio as |width|:|height|, if possible, or
+  // if not, the closest aspect ratio. Among images of that aspect ratio,
+  // returns the smallest image with both its width and height bigger or equal
+  // to the requested size. If none exists, returns the largest image of that
+  // aspect ratio. If there are no images in the family, returns NULL.
+  const gfx::Image* GetBest(int width, int height) const;
+
+  // Gets the best image to use in a rectangle of |size|.
+  // Gets an image at the same aspect ratio as |size.width()|:|size.height()|,
+  // if possible, or if not, the closest aspect ratio. Among images of that
+  // aspect ratio, returns the smallest image with both its width and height
+  // bigger or equal to the requested size. If none exists, returns the largest
+  // image of that aspect ratio. If there are no images in the family, returns
+  // NULL.
+  const gfx::Image* GetBest(const gfx::Size& size) const;
+
+  // Gets an image of size |width|x|height|. If no image of that exact size
+  // exists, chooses the nearest larger image using GetBest() and scales it to
+  // the desired size. If there are no images in the family, returns an empty
+  // image.
+  gfx::Image CreateExact(int width, int height) const;
+
+  // Gets an image of size |size|. If no image of that exact size exists,
+  // chooses the nearest larger image using GetBest() and scales it to the
+  // desired size. If there are no images in the family, returns an empty image.
+  gfx::Image CreateExact(const gfx::Size& size) const;
+
+ private:
+  // Find the closest aspect ratio in the map to |desired_aspect|.
+  // Ties are broken by the thinner aspect.
+  // |map_| must not be empty. |desired_aspect| must be > 0.0.
+  float GetClosestAspect(float desired_aspect) const;
+
+  // Gets an image with aspect ratio |aspect|, at the best size for |width|.
+  // Returns the smallest image of aspect ratio |aspect| with its width bigger
+  // or equal to |width|. If none exists, returns the largest image of aspect
+  // ratio |aspect|. Behavior is undefined if there is not at least one image in
+  // |map_| of aspect ratio |aspect|.
+  const gfx::Image* GetWithExactAspect(float aspect, int width) const;
+
+  // Map from (aspect ratio, width) to image.
+  std::map<MapKey, gfx::Image> map_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_FAMILY_H_
diff --git a/ui/gfx/image/image_family_unittest.cc b/ui/gfx/image/image_family_unittest.cc
new file mode 100644
index 0000000..4bd2dc6
--- /dev/null
+++ b/ui/gfx/image/image_family_unittest.cc
@@ -0,0 +1,249 @@
+// 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.
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_family.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_unittest_util.h"
+
+namespace {
+
+namespace gt = gfx::test;
+
+// Tests that |image| != NULL, and has the given width and height.
+// This is a macro instead of a function, so that the correct line numbers are
+// reported when a test fails.
+#define EXPECT_IMAGE_NON_NULL_AND_SIZE(image, expected_width, expected_height) \
+do { \
+  const gfx::Image* image_ = image; \
+  EXPECT_TRUE(image_); \
+  EXPECT_EQ(expected_width, image_->Width()); \
+  EXPECT_EQ(expected_height, image_->Height()); \
+} while(0)
+
+// Tests that |image| has the given width and height.
+// This is a macro instead of a function, so that the correct line numbers are
+// reported when a test fails.
+#define EXPECT_IMAGE_SIZE(image, expected_width, expected_height) \
+do { \
+  const gfx::Image& image_ = image; \
+  EXPECT_FALSE(image_.IsEmpty()); \
+  EXPECT_EQ(expected_width, image_.Width()); \
+  EXPECT_EQ(expected_height, image_.Height()); \
+} while(0)
+
+class ImageFamilyTest : public testing::Test {
+ public:
+  // Construct an ImageFamily. Implicitly tests Add and Empty.
+  void SetUp() override {
+    EXPECT_TRUE(image_family_.empty());
+
+    // Aspect ratio 1:1.
+    image_family_.Add(gt::CreateImageSkia(32, 32));
+    EXPECT_FALSE(image_family_.empty());
+    image_family_.Add(gt::CreateImageSkia(16, 16));
+    image_family_.Add(gt::CreateImageSkia(64, 64));
+    // Duplicate (should override previous one).
+    // Insert an Image directly, instead of an ImageSkia.
+    gfx::Image image(gt::CreateImageSkia(32, 32));
+    image_family_.Add(image);
+    // Aspect ratio 1:4.
+    image_family_.Add(gt::CreateImageSkia(3, 12));
+    image_family_.Add(gt::CreateImageSkia(12, 48));
+    // Aspect ratio 4:1.
+    image_family_.Add(gt::CreateImageSkia(512, 128));
+    image_family_.Add(gt::CreateImageSkia(256, 64));
+
+    EXPECT_FALSE(image_family_.empty());
+  }
+
+  gfx::ImageFamily image_family_;
+};
+
+TEST_F(ImageFamilyTest, Clear) {
+  image_family_.clear();
+  EXPECT_TRUE(image_family_.empty());
+}
+
+TEST_F(ImageFamilyTest, MoveConstructor) {
+  gfx::ImageFamily family(std::move(image_family_));
+  EXPECT_TRUE(image_family_.empty());
+  EXPECT_FALSE(family.empty());
+}
+
+TEST_F(ImageFamilyTest, MoveAssignment) {
+  gfx::ImageFamily family;
+  EXPECT_TRUE(family.empty());
+  family = std::move(image_family_);
+  EXPECT_TRUE(image_family_.empty());
+  EXPECT_FALSE(family.empty());
+}
+
+TEST_F(ImageFamilyTest, Clone) {
+  gfx::ImageFamily family = image_family_.Clone();
+  EXPECT_FALSE(image_family_.empty());
+  EXPECT_FALSE(family.empty());
+}
+
+// Tests iteration over an ImageFamily.
+TEST_F(ImageFamilyTest, Iteration) {
+  gfx::ImageFamily::const_iterator it = image_family_.begin();
+  gfx::ImageFamily::const_iterator end = image_family_.end();
+
+  // Expect iteration in order of aspect ratio (from thinnest to widest), then
+  // size.
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(3, 12), it->Size());
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(12, 48), it->Size());
+  it++;   // Test post-increment.
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(16, 16), it->Size());
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(32, 32), it->Size());
+  --it;   // Test decrement
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(16, 16), it->Size());
+  ++it;
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(64, 64), (*it).Size());   // Test operator*.
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(256, 64), it->Size());
+  ++it;
+  EXPECT_TRUE(it != end);
+  EXPECT_EQ(gfx::Size(512, 128), it->Size());
+  ++it;
+
+  EXPECT_TRUE(it == end);
+}
+
+TEST_F(ImageFamilyTest, GetBest) {
+  // Get on an empty family.
+  gfx::ImageFamily empty_family;
+  EXPECT_TRUE(empty_family.empty());
+  EXPECT_FALSE(empty_family.GetBest(32, 32));
+  EXPECT_FALSE(empty_family.GetBest(0, 32));
+  EXPECT_FALSE(empty_family.GetBest(32, 0));
+
+  // Get various aspect ratios and sizes on the sample family.
+
+  // 0x0 (expect the smallest square image).
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(0, 0), 16, 16);
+  // GetBest(0, N) or GetBest(N, 0) should be treated the same as GetBest(0, 0).
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(0, 16), 16, 16);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(0, 64), 16, 16);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(16, 0), 16, 16);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(64, 0), 16, 16);
+
+  // Thinner than thinnest image.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(2, 12), 3, 12);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(2, 13), 12, 48);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(10, 60), 12, 48);
+
+  // Between two images' aspect ratio.
+  // Note: Testing the boundary around 1:2 and 2:1, half way to 1:4 and 4:1.
+  // Ties are broken by favouring the thinner aspect ratio.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(63, 32), 64, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(64, 32), 64, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(65, 32), 256, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(32, 63), 64, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(32, 64), 12, 48);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(32, 65), 12, 48);
+
+  // Exact match aspect ratio.
+  // Exact match size.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(32, 32), 32, 32);
+  // Slightly smaller.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(31, 31), 32, 32);
+  // Much smaller.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(17, 17), 32, 32);
+  // Exact match size.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(16, 16), 16, 16);
+  // Smaller than any image.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(3, 3), 16, 16);
+  // Larger than any image.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(512, 512), 64, 64);
+  // 1:4 aspect ratio.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(16, 64), 12, 48);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(2, 8), 3, 12);
+  // 4:1 aspect ratio.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(64, 16), 256, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(260, 65), 512, 128);
+
+  // Wider than widest image.
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(255, 51), 256, 64);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(260, 52), 512, 128);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(654, 129), 512, 128);
+}
+
+TEST_F(ImageFamilyTest, CreateExact) {
+  // CreateExact on an empty family.
+  gfx::ImageFamily empty_family;
+  EXPECT_TRUE(empty_family.empty());
+  EXPECT_TRUE(empty_family.CreateExact(32, 32).IsEmpty());
+  EXPECT_TRUE(empty_family.CreateExact(0, 32).IsEmpty());
+  EXPECT_TRUE(empty_family.CreateExact(32, 0).IsEmpty());
+
+  // CreateExact on a family with only empty images results in an empty image,
+  // despite the requested image size.
+  gfx::ImageFamily family_with_empty_image;
+  family_with_empty_image.Add(gfx::Image());
+  EXPECT_FALSE(family_with_empty_image.empty());
+  EXPECT_TRUE(family_with_empty_image.CreateExact(32, 32).IsEmpty());
+
+  // CreateExact on various aspect ratios and sizes on the sample family.
+
+  // Targeting an image with width and/or height of 0 results in empty image.
+  EXPECT_TRUE(image_family_.CreateExact(0, 0).IsEmpty());
+  EXPECT_TRUE(image_family_.CreateExact(0, 64).IsEmpty());
+  EXPECT_TRUE(image_family_.CreateExact(64, 0).IsEmpty());
+
+  // Thinner than thinnest image.
+  EXPECT_IMAGE_SIZE(image_family_.CreateExact(2, 12), 2, 12);
+
+  // Exact match aspect ratio.
+  // Exact match size.
+  EXPECT_IMAGE_SIZE(image_family_.CreateExact(32, 32), 32, 32);
+  // Much smaller.
+  EXPECT_IMAGE_SIZE(image_family_.CreateExact(17, 17), 17, 17);
+  // Smaller than any image.
+  EXPECT_IMAGE_SIZE(image_family_.CreateExact(3, 3), 3, 3);
+  // Larger than any image.
+  EXPECT_IMAGE_SIZE(image_family_.CreateExact(512, 512), 512, 512);
+
+  // Wider than widest image.
+  EXPECT_IMAGE_SIZE(image_family_.CreateExact(255, 51), 255, 51);
+}
+
+// Test adding and looking up images with 0 width and height.
+TEST_F(ImageFamilyTest, ZeroWidthAndHeight) {
+  // An empty Image. Should be considered to have 0 width and height.
+  image_family_.Add(gfx::Image());
+  // Images with 0 width OR height should be treated the same as an image with 0
+  // width AND height (in fact, the ImageSkias should be indistinguishable).
+  image_family_.Add(gt::CreateImageSkia(32, 0));
+  image_family_.Add(gt::CreateImageSkia(0, 32));
+
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(0, 0), 0, 0);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(1, 1), 16, 16);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(32, 32), 32, 32);
+
+  // GetBest(0, N) or GetBest(N, 0) should be treated the same as GetBest(0, 0).
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(0, 1), 0, 0);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(0, 32), 0, 0);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(1, 0), 0, 0);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(32, 0), 0, 0);
+
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(1, 32), 12, 48);
+  EXPECT_IMAGE_NON_NULL_AND_SIZE(image_family_.GetBest(32, 1), 256, 64);
+}
+
+}  // namespace
diff --git a/ui/gfx/image/image_generic.cc b/ui/gfx/image/image_generic.cc
new file mode 100644
index 0000000..f598390
--- /dev/null
+++ b/ui/gfx/image/image_generic.cc
@@ -0,0 +1,126 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/image/image_platform.h"
+
+#include <memory>
+#include <set>
+#include <utility>
+
+#include "base/logging.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/image/image_skia_source.h"
+
+namespace gfx {
+namespace internal {
+
+namespace {
+
+// Returns a 16x16 red image to visually show error in decoding PNG.
+ImageSkia GetErrorImageSkia() {
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(16, 16);
+  bitmap.eraseARGB(0xff, 0xff, 0, 0);
+  return ImageSkia(ImageSkiaRep(bitmap, 1.0f));
+}
+
+class PNGImageSource : public ImageSkiaSource {
+ public:
+  PNGImageSource() {}
+
+  PNGImageSource(const PNGImageSource&) = delete;
+  PNGImageSource& operator=(const PNGImageSource&) = delete;
+
+  ~PNGImageSource() override {}
+
+  ImageSkiaRep GetImageForScale(float scale) override {
+    if (image_skia_reps_.empty())
+      return ImageSkiaRep();
+
+    const ImageSkiaRep* rep = nullptr;
+    // gfx::ImageSkia passes one of the resource scale factors. The source
+    // should return:
+    // 1) The ImageSkiaRep with the highest scale if all available
+    // scales are smaller than |scale|.
+    // 2) The ImageSkiaRep with the smallest one that is larger than |scale|.
+    for (auto iter = image_skia_reps_.begin(); iter != image_skia_reps_.end();
+         ++iter) {
+      if ((*iter).scale() == scale)
+        return (*iter);
+      if (!rep || rep->scale() < (*iter).scale())
+        rep = &(*iter);
+      if (rep->scale() >= scale)
+        break;
+    }
+    return rep ? *rep : ImageSkiaRep();
+  }
+
+  const gfx::Size size() const { return size_; }
+
+  bool AddPNGData(const ImagePNGRep& png_rep) {
+    const gfx::ImageSkiaRep rep = ToImageSkiaRep(png_rep);
+    if (rep.is_null())
+      return false;
+    if (size_.IsEmpty())
+      size_ = gfx::Size(rep.GetWidth(), rep.GetHeight());
+    image_skia_reps_.insert(rep);
+    return true;
+  }
+
+  static ImageSkiaRep ToImageSkiaRep(const ImagePNGRep& png_rep) {
+    scoped_refptr<base::RefCountedMemory> raw_data = png_rep.raw_data;
+    CHECK(raw_data.get());
+    SkBitmap bitmap;
+    if (!PNGCodec::Decode(raw_data->front(), raw_data->size(), &bitmap)) {
+      LOG(ERROR) << "Unable to decode PNG for " << png_rep.scale << ".";
+      return ImageSkiaRep();
+    }
+    return ImageSkiaRep(bitmap, png_rep.scale);
+  }
+
+ private:
+  struct Compare {
+    bool operator()(const ImageSkiaRep& rep1, const ImageSkiaRep& rep2) const {
+      return rep1.scale() < rep2.scale();
+    }
+  };
+
+  typedef std::set<ImageSkiaRep, Compare> ImageSkiaRepSet;
+  ImageSkiaRepSet image_skia_reps_;
+  gfx::Size size_;
+};
+
+}  // namespace
+
+ImageSkia ImageSkiaFromPNG(const std::vector<ImagePNGRep>& image_png_reps) {
+  if (image_png_reps.empty())
+    return GetErrorImageSkia();
+  std::unique_ptr<PNGImageSource> image_source(new PNGImageSource);
+
+  for (size_t i = 0; i < image_png_reps.size(); ++i) {
+    if (!image_source->AddPNGData(image_png_reps[i]))
+      return GetErrorImageSkia();
+  }
+  const gfx::Size& size = image_source->size();
+  DCHECK(!size.IsEmpty());
+  if (size.IsEmpty())
+    return GetErrorImageSkia();
+  return ImageSkia(std::move(image_source), size);
+}
+
+scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
+    const ImageSkia* image_skia) {
+  ImageSkiaRep image_skia_rep = image_skia->GetRepresentation(1.0f);
+
+  scoped_refptr<base::RefCountedBytes> png_bytes(new base::RefCountedBytes());
+  if (image_skia_rep.scale() != 1.0f ||
+      !PNGCodec::EncodeBGRASkBitmap(image_skia_rep.GetBitmap(), false,
+                                    &png_bytes->data())) {
+    return nullptr;
+  }
+  return png_bytes;
+}
+
+}  // namespace internal
+}  // namespace gfx
diff --git a/ui/gfx/image/image_ios.mm b/ui/gfx/image/image_ios.mm
new file mode 100644
index 0000000..a240131
--- /dev/null
+++ b/ui/gfx/image/image_ios.mm
@@ -0,0 +1,134 @@
+// Copyright 2012 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.
+
+#include "ui/gfx/image/image_platform.h"
+
+#include <stddef.h>
+#import <UIKit/UIKit.h>
+#include <cmath>
+#include <limits>
+
+#include "base/logging.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "base/mac/scoped_nsobject.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image_png_rep.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_skia_util_ios.h"
+
+namespace gfx {
+namespace internal {
+
+namespace {
+
+// Returns a 16x16 red UIImage to visually show when a UIImage cannot be
+// created from PNG data. Logs error as well.
+// Caller takes ownership of returned UIImage.
+UIImage* CreateErrorUIImage(float scale) {
+  LOG(ERROR) << "Unable to decode PNG into UIImage.";
+  base::ScopedCFTypeRef<CGColorSpaceRef> color_space(
+      CGColorSpaceCreateDeviceRGB());
+  base::ScopedCFTypeRef<CGContextRef> context(CGBitmapContextCreate(
+      nullptr,  // Allow CG to allocate memory.
+      16,       // width
+      16,       // height
+      8,        // bitsPerComponent
+      0,        // CG will calculate by default.
+      color_space, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host));
+  CGContextSetRGBFillColor(context, 1.0, 0.0, 0.0, 1.0);
+  CGContextFillRect(context, CGRectMake(0.0, 0.0, 16, 16));
+  base::ScopedCFTypeRef<CGImageRef> cg_image(
+      CGBitmapContextCreateImage(context));
+  return [[UIImage imageWithCGImage:cg_image.get()
+                              scale:scale
+                        orientation:UIImageOrientationUp] retain];
+}
+
+// Converts from ImagePNGRep to UIImage.
+UIImage* CreateUIImageFromImagePNGRep(const gfx::ImagePNGRep& image_png_rep) {
+  float scale = image_png_rep.scale;
+  scoped_refptr<base::RefCountedMemory> png = image_png_rep.raw_data;
+  CHECK(png.get());
+  NSData* data = [NSData dataWithBytes:png->front() length:png->size()];
+  UIImage* image = [[UIImage alloc] initWithData:data scale:scale];
+  return image ? image : CreateErrorUIImage(scale);
+}
+
+}  // namespace
+
+scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromUIImage(
+    UIImage* uiimage) {
+  NSData* data = UIImagePNGRepresentation(uiimage);
+
+  if ([data length] == 0)
+    return nullptr;
+
+  scoped_refptr<base::RefCountedBytes> png_bytes(
+      new base::RefCountedBytes());
+  png_bytes->data().resize([data length]);
+  [data getBytes:&png_bytes->data().at(0) length:[data length]];
+  return png_bytes;
+}
+
+UIImage* UIImageFromPNG(const std::vector<gfx::ImagePNGRep>& image_png_reps) {
+  float ideal_scale = ImageSkia::GetMaxSupportedScale();
+
+  if (image_png_reps.empty())
+    return CreateErrorUIImage(ideal_scale);
+
+  // Find best match for |ideal_scale|.
+  float smallest_diff = std::numeric_limits<float>::max();
+  size_t closest_index = 0u;
+  for (size_t i = 0; i < image_png_reps.size(); ++i) {
+    float scale = image_png_reps[i].scale;
+    float diff = std::abs(ideal_scale - scale);
+    if (diff < smallest_diff) {
+      smallest_diff = diff;
+      closest_index = i;
+    }
+  }
+
+  return
+      [CreateUIImageFromImagePNGRep(image_png_reps[closest_index]) autorelease];
+}
+
+scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
+    const ImageSkia* skia) {
+  // iOS does not expose libpng, so conversion from ImageSkia to PNG must go
+  // through UIImage.
+  // TODO(rohitrao): Rewrite the callers of this function to save the UIImage
+  // representation in the gfx::Image.  If we're generating it, we might as well
+  // hold on to it.
+  const gfx::ImageSkiaRep& image_skia_rep = skia->GetRepresentation(1.0f);
+  if (image_skia_rep.scale() != 1.0f)
+    return nullptr;
+
+  UIImage* image = UIImageFromImageSkiaRep(image_skia_rep);
+  return Get1xPNGBytesFromUIImage(image);
+}
+
+ImageSkia ImageSkiaFromPNG(
+    const std::vector<gfx::ImagePNGRep>& image_png_reps) {
+  // iOS does not expose libpng, so conversion from PNG to ImageSkia must go
+  // through UIImage.
+  ImageSkia image_skia;
+  for (size_t i = 0; i < image_png_reps.size(); ++i) {
+    base::scoped_nsobject<UIImage> uiimage(
+        CreateUIImageFromImagePNGRep(image_png_reps[i]));
+    gfx::ImageSkiaRep image_skia_rep = ImageSkiaRepOfScaleFromUIImage(
+        uiimage, image_png_reps[i].scale);
+    if (!image_skia_rep.is_null())
+      image_skia.AddRepresentation(image_skia_rep);
+  }
+  return image_skia;
+}
+
+gfx::Size UIImageSize(UIImage* image) {
+  int width = static_cast<int>(image.size.width);
+  int height = static_cast<int>(image.size.height);
+  return gfx::Size(width, height);
+}
+
+} // namespace internal
+} // namespace gfx
diff --git a/ui/gfx/image/image_ios_unittest.mm b/ui/gfx/image/image_ios_unittest.mm
new file mode 100644
index 0000000..c3cd639
--- /dev/null
+++ b/ui/gfx/image/image_ios_unittest.mm
@@ -0,0 +1,112 @@
+// Copyright (c) 2014 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.
+
+#import <QuartzCore/QuartzCore.h>
+#include <stddef.h>
+#import <UIKit/UIKit.h>
+
+#include "base/cxx17_backports.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace {
+
+// Helper function to return a UIImage with the given size and scale.
+UIImage* UIImageWithSizeAndScale(CGFloat width, CGFloat height, CGFloat scale) {
+  CGSize target_size = CGSizeMake(width * scale, height * scale);
+
+  // Create a UIImage directly from a CGImage in order to control the exact
+  // pixel size of the underlying image.
+  base::ScopedCFTypeRef<CGColorSpaceRef> color_space(
+      CGColorSpaceCreateDeviceRGB());
+  base::ScopedCFTypeRef<CGContextRef> context(CGBitmapContextCreate(
+      NULL,
+      target_size.width,
+      target_size.height,
+      8,
+      target_size.width * 4,
+      color_space,
+      kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host));
+
+  CGRect target_rect = CGRectMake(0, 0,
+                                  target_size.width, target_size.height);
+  CGContextSetFillColorWithColor(context, [[UIColor redColor] CGColor]);
+  CGContextFillRect(context, target_rect);
+
+  base::ScopedCFTypeRef<CGImageRef> cg_image(
+      CGBitmapContextCreateImage(context));
+  return [UIImage imageWithCGImage:cg_image
+                             scale:scale
+                       orientation:UIImageOrientationUp];
+}
+
+
+class ImageIOSTest : public testing::Test {
+ public:
+  ImageIOSTest() {}
+
+  ImageIOSTest(const ImageIOSTest&) = delete;
+  ImageIOSTest& operator=(const ImageIOSTest&) = delete;
+
+  ~ImageIOSTest() override {}
+
+  void SetUp() override {
+    original_scale_factors_ = gfx::ImageSkia::GetSupportedScales();
+  }
+
+  void TearDown() override {
+    gfx::ImageSkia::SetSupportedScales(original_scale_factors_);
+  }
+
+ private:
+  // Used to save and restore the scale factors in effect before this test.
+  std::vector<float> original_scale_factors_;
+};
+
+// Tests image conversion when the scale factor of the source image is not in
+// the list of supported scale factors.
+TEST_F(ImageIOSTest, ImageConversionWithUnsupportedScaleFactor) {
+  const CGFloat kWidth = 200;
+  const CGFloat kHeight = 100;
+  const CGFloat kTestScales[3] = { 1.0f, 2.0f, 3.0f };
+
+  for (size_t i = 0; i < base::size(kTestScales); ++i) {
+    for (size_t j = 0; j < base::size(kTestScales); ++j) {
+      const CGFloat source_scale = kTestScales[i];
+      const CGFloat supported_scale = kTestScales[j];
+
+      // Set the supported scale for testing.
+      std::vector<float> supported_scales;
+      supported_scales.push_back(supported_scale);
+      gfx::ImageSkia::SetSupportedScales(supported_scales);
+
+      // Create an UIImage with the appropriate source_scale.
+      UIImage* ui_image =
+          UIImageWithSizeAndScale(kWidth, kHeight, source_scale);
+      ASSERT_EQ(kWidth, ui_image.size.width);
+      ASSERT_EQ(kHeight, ui_image.size.height);
+      ASSERT_EQ(source_scale, ui_image.scale);
+
+      // Convert to SkBitmap and test its size.
+      gfx::Image to_skbitmap([ui_image retain]);
+      const SkBitmap* bitmap = to_skbitmap.ToSkBitmap();
+      ASSERT_TRUE(bitmap != NULL);
+      EXPECT_EQ(kWidth * supported_scale, bitmap->width());
+      EXPECT_EQ(kHeight * supported_scale, bitmap->height());
+
+      // Convert to ImageSkia and test its size.
+      gfx::Image to_imageskia([ui_image retain]);
+      const gfx::ImageSkia* imageskia = to_imageskia.ToImageSkia();
+      EXPECT_EQ(kWidth, imageskia->width());
+      EXPECT_EQ(kHeight, imageskia->height());
+
+      // TODO(rohitrao): Convert from ImageSkia back to UIImage.  This should
+      // scale the image based on the current set of supported scales.
+    }
+  }
+}
+
+} // namespace
diff --git a/ui/gfx/image/image_mac.mm b/ui/gfx/image/image_mac.mm
new file mode 100644
index 0000000..939099f
--- /dev/null
+++ b/ui/gfx/image/image_mac.mm
@@ -0,0 +1,119 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_platform.h"
+
+#import <AppKit/AppKit.h>
+#include <stddef.h>
+
+#include "base/debug/dump_without_crashing.h"
+#include "base/logging.h"
+#include "base/mac/scoped_nsobject.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image_png_rep.h"
+
+namespace gfx {
+namespace internal {
+
+namespace {
+
+// Returns a 16x16 red NSImage to visually show when a NSImage cannot be
+// created from PNG data.
+// Caller takes ownership of the returned NSImage.
+NSImage* GetErrorNSImage() {
+  NSRect rect = NSMakeRect(0, 0, 16, 16);
+  NSImage* image = [[NSImage alloc] initWithSize:rect.size];
+  [image lockFocus];
+  [[NSColor colorWithDeviceRed:1.0 green:0.0 blue:0.0 alpha:1.0] set];
+  NSRectFill(rect);
+  [image unlockFocus];
+  return image;
+}
+
+}  // namespace
+
+scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromNSImage(
+    NSImage* nsimage) {
+  DCHECK(nsimage);
+  CGImageRef cg_image = [nsimage CGImageForProposedRect:NULL
+                                                context:nil
+                                                  hints:nil];
+  if (!cg_image) {
+    // TODO(crbug.com/1271762): Look at DumpWithoutCrashing() reports to figure
+    // out what's going on here.
+    return scoped_refptr<base::RefCountedMemory>();
+  }
+  base::scoped_nsobject<NSBitmapImageRep> ns_bitmap(
+      [[NSBitmapImageRep alloc] initWithCGImage:cg_image]);
+  NSData* ns_data = [ns_bitmap representationUsingType:NSPNGFileType
+                                            properties:@{}];
+  const unsigned char* bytes =
+      static_cast<const unsigned char*>([ns_data bytes]);
+  scoped_refptr<base::RefCountedBytes> refcounted_bytes(
+      new base::RefCountedBytes());
+  refcounted_bytes->data().assign(bytes, bytes + [ns_data length]);
+  return refcounted_bytes;
+}
+
+NSImage* NSImageFromPNG(const std::vector<gfx::ImagePNGRep>& image_png_reps,
+                        CGColorSpaceRef color_space) {
+  if (image_png_reps.empty()) {
+    LOG(ERROR) << "Unable to decode PNG.";
+    return GetErrorNSImage();
+  }
+
+  base::scoped_nsobject<NSImage> image;
+  for (size_t i = 0; i < image_png_reps.size(); ++i) {
+    scoped_refptr<base::RefCountedMemory> png = image_png_reps[i].raw_data;
+    CHECK(png.get());
+    base::scoped_nsobject<NSData> ns_data(
+        [[NSData alloc] initWithBytes:png->front() length:png->size()]);
+    base::scoped_nsobject<NSBitmapImageRep> ns_image_rep(
+        [[NSBitmapImageRep alloc] initWithData:ns_data]);
+    if (!ns_image_rep) {
+      LOG(ERROR) << "Unable to decode PNG at "
+                 << image_png_reps[i].scale
+                 << ".";
+      return GetErrorNSImage();
+    }
+
+    // PNGCodec ignores colorspace related ancillary chunks (sRGB, iCCP). Ignore
+    // colorspace information when decoding directly from PNG to an NSImage so
+    // that the conversions: PNG -> SkBitmap -> NSImage and PNG -> NSImage
+    // produce visually similar results.
+    CGColorSpaceModel decoded_color_space_model = CGColorSpaceGetModel(
+        [[ns_image_rep colorSpace] CGColorSpace]);
+    CGColorSpaceModel color_space_model = CGColorSpaceGetModel(color_space);
+    if (decoded_color_space_model == color_space_model) {
+      base::scoped_nsobject<NSColorSpace> ns_color_space(
+          [[NSColorSpace alloc] initWithCGColorSpace:color_space]);
+      NSBitmapImageRep* ns_retagged_image_rep =
+          [ns_image_rep
+              bitmapImageRepByRetaggingWithColorSpace:ns_color_space];
+      if (ns_retagged_image_rep && ns_retagged_image_rep != ns_image_rep)
+        ns_image_rep.reset([ns_retagged_image_rep retain]);
+    }
+
+    if (!image.get()) {
+      float scale = image_png_reps[i].scale;
+      NSSize image_size = NSMakeSize([ns_image_rep pixelsWide] / scale,
+                                     [ns_image_rep pixelsHigh] / scale);
+      image.reset([[NSImage alloc] initWithSize:image_size]);
+    }
+    [image addRepresentation:ns_image_rep];
+  }
+
+  return image.autorelease();
+}
+
+gfx::Size NSImageSize(NSImage* image) {
+  NSSize size = [image size];
+  int width = static_cast<int>(size.width);
+  int height = static_cast<int>(size.height);
+  return gfx::Size(width, height);
+}
+
+} // namespace internal
+} // namespace gfx
+
diff --git a/ui/gfx/image/image_mac_unittest.mm b/ui/gfx/image/image_mac_unittest.mm
new file mode 100644
index 0000000..226b61d
--- /dev/null
+++ b/ui/gfx/image/image_mac_unittest.mm
@@ -0,0 +1,209 @@
+// Copyright (c) 2012 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.
+
+#include <Cocoa/Cocoa.h>
+#include <stddef.h>
+
+#include "base/mac/scoped_nsobject.h"
+#include "base/macros.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_png_rep.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_skia_util_mac.h"
+#include "ui/gfx/image/image_unittest_util.h"
+
+namespace {
+
+// Returns true if the structure of |ns_image| matches the structure
+// described by |width|, |height|, and |scales|.
+// The structure matches if:
+// - |ns_image| is not nil.
+// - |ns_image| has NSImageReps of |scales|.
+// - Each of the NSImageReps has a pixel size of [|ns_image| size] *
+//   scale.
+bool NSImageStructureMatches(
+    NSImage* ns_image,
+    int width,
+    int height,
+    const std::vector<float>& scales) {
+  if (!ns_image ||
+      [ns_image size].width != width ||
+      [ns_image size].height != height ||
+      [ns_image representations].count != scales.size()) {
+    return false;
+  }
+
+  for (size_t i = 0; i < scales.size(); ++i) {
+    float scale = scales[i];
+    bool found_match = false;
+    for (size_t j = 0; j < [ns_image representations].count; ++j) {
+      NSImageRep* ns_image_rep = [ns_image representations][j];
+      if (ns_image_rep &&
+          [ns_image_rep pixelsWide] == width * scale &&
+          [ns_image_rep pixelsHigh] == height * scale) {
+        found_match = true;
+        break;
+      }
+    }
+    if (!found_match)
+      return false;
+  }
+  return true;
+}
+
+void BitmapImageRep(int width, int height,
+     NSBitmapImageRep** image_rep) {
+  *image_rep = [[[NSBitmapImageRep alloc]
+      initWithBitmapDataPlanes:NULL
+                    pixelsWide:width
+                   pixelsHigh:height
+                bitsPerSample:8
+              samplesPerPixel:3
+                     hasAlpha:NO
+                     isPlanar:NO
+               colorSpaceName:NSDeviceRGBColorSpace
+                 bitmapFormat:0
+                  bytesPerRow:0
+                 bitsPerPixel:0]
+      autorelease];
+  unsigned char* image_rep_data = [*image_rep bitmapData];
+  for (int i = 0; i < width * height * 3; ++i)
+    image_rep_data[i] = 255;
+}
+
+class ImageMacTest : public testing::Test {
+ public:
+  ImageMacTest() {
+    gfx::ImageSkia::SetSupportedScales(gfx::test::Get1xAnd2xScales());
+  }
+
+  ImageMacTest(const ImageMacTest&) = delete;
+  ImageMacTest& operator=(const ImageMacTest&) = delete;
+};
+
+namespace gt = gfx::test;
+
+TEST_F(ImageMacTest, MultiResolutionNSImageToImageSkia) {
+  const int kWidth1x = 10;
+  const int kHeight1x = 12;
+  const int kWidth2x = 20;
+  const int kHeight2x = 24;
+
+  NSBitmapImageRep* ns_image_rep1;
+  BitmapImageRep(kWidth1x, kHeight1x, &ns_image_rep1);
+  NSBitmapImageRep* ns_image_rep2;
+  BitmapImageRep(kWidth2x, kHeight2x, &ns_image_rep2);
+  base::scoped_nsobject<NSImage> ns_image(
+      [[NSImage alloc] initWithSize:NSMakeSize(kWidth1x, kHeight1x)]);
+  [ns_image addRepresentation:ns_image_rep1];
+  [ns_image addRepresentation:ns_image_rep2];
+
+  gfx::Image image(ns_image);
+
+  EXPECT_EQ(1u, image.RepresentationCount());
+
+  const gfx::ImageSkia* image_skia = image.ToImageSkia();
+
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
+  EXPECT_TRUE(gt::ImageSkiaStructureMatches(*image_skia, kWidth1x, kHeight1x,
+                                            scales));
+
+  // ToImageSkia should create a second representation.
+  EXPECT_EQ(2u, image.RepresentationCount());
+}
+
+// Test that convertng to an ImageSkia from an NSImage with scale factors
+// other than 1x and 2x results in an ImageSkia with scale factors 1x and
+// 2x;
+TEST_F(ImageMacTest, UnalignedMultiResolutionNSImageToImageSkia) {
+  const int kWidth1x = 10;
+  const int kHeight1x= 12;
+  const int kWidth4x = 40;
+  const int kHeight4x = 48;
+
+  NSBitmapImageRep* ns_image_rep4;
+  BitmapImageRep(kWidth4x, kHeight4x, &ns_image_rep4);
+  base::scoped_nsobject<NSImage> ns_image(
+      [[NSImage alloc] initWithSize:NSMakeSize(kWidth1x, kHeight1x)]);
+  [ns_image addRepresentation:ns_image_rep4];
+
+  gfx::Image image(ns_image);
+
+  EXPECT_EQ(1u, image.RepresentationCount());
+
+  const gfx::ImageSkia* image_skia = image.ToImageSkia();
+
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
+  EXPECT_TRUE(gt::ImageSkiaStructureMatches(*image_skia, kWidth1x, kHeight1x,
+                                            scales));
+
+  // ToImageSkia should create a second representation.
+  EXPECT_EQ(2u, image.RepresentationCount());
+}
+
+TEST_F(ImageMacTest, MultiResolutionImageSkiaToNSImage) {
+  const int kWidth1x = 10;
+  const int kHeight1x= 12;
+  const int kWidth2x = 20;
+  const int kHeight2x = 24;
+
+  gfx::ImageSkia image_skia;
+  image_skia.AddRepresentation(gfx::ImageSkiaRep(
+      gt::CreateBitmap(kWidth1x, kHeight1x), 1.0f));
+  image_skia.AddRepresentation(gfx::ImageSkiaRep(
+      gt::CreateBitmap(kWidth2x, kHeight2x), 2.0f));
+
+  gfx::Image image(image_skia);
+
+  EXPECT_EQ(1u, image.RepresentationCount());
+  EXPECT_EQ(2u, image.ToImageSkia()->image_reps().size());
+
+  NSImage* ns_image = image.ToNSImage();
+
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
+  EXPECT_TRUE(NSImageStructureMatches(ns_image, kWidth1x, kHeight1x, scales));
+
+  // Request for NSImage* should create a second representation.
+  EXPECT_EQ(2u, image.RepresentationCount());
+}
+
+TEST_F(ImageMacTest, MultiResolutionPNGToNSImage) {
+  const int kSize1x = 25;
+  const int kSize2x = 50;
+
+  scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
+  scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x);
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f));
+
+  gfx::Image image(image_png_reps);
+
+  NSImage* ns_image = image.ToNSImage();
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
+  EXPECT_TRUE(NSImageStructureMatches(ns_image, kSize1x, kSize1x, scales));
+
+  // Converting from PNG to NSImage should not go through ImageSkia.
+  EXPECT_FALSE(image.HasRepresentation(gfx::Image::kImageRepSkia));
+
+  // Convert to ImageSkia to check pixel contents of NSImageReps.
+  gfx::ImageSkia image_skia = gfx::ImageSkiaFromNSImage(ns_image);
+  EXPECT_TRUE(gt::ArePNGBytesCloseToBitmap(
+      *bytes1x, image_skia.GetRepresentation(1.0f).GetBitmap(),
+      gt::MaxColorSpaceConversionColorShift()));
+  EXPECT_TRUE(gt::ArePNGBytesCloseToBitmap(
+      *bytes2x, image_skia.GetRepresentation(2.0f).GetBitmap(),
+      gt::MaxColorSpaceConversionColorShift()));
+}
+
+} // namespace
diff --git a/ui/gfx/image/image_platform.h b/ui/gfx/image/image_platform.h
new file mode 100644
index 0000000..3e37e8c
--- /dev/null
+++ b/ui/gfx/image/image_platform.h
@@ -0,0 +1,56 @@
+// Copyright 2017 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.
+
+// This file declares platform-specific helper functions in gfx::internal for
+// use by image.cc.
+//
+// The functions are implemented in image_generic.cc (all platforms other than
+// iOS), image_ios.mm and image_mac.mm.
+
+#ifndef UI_GFX_IMAGE_IMAGE_PLATFORM_H_
+#define UI_GFX_IMAGE_IMAGE_PLATFORM_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/ref_counted_memory.h"
+#include "build/build_config.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image_png_rep.h"
+#include "ui/gfx/image/image_skia.h"
+
+#if defined(OS_IOS)
+#include "base/mac/foundation_util.h"
+#include "ui/gfx/image/image_skia_util_ios.h"
+#elif defined(OS_MAC)
+#include "base/mac/foundation_util.h"
+#include "base/mac/mac_util.h"
+#include "ui/gfx/image/image_skia_util_mac.h"
+#endif
+
+namespace gfx {
+namespace internal {
+
+#if defined(OS_IOS)
+scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromUIImage(
+    UIImage* uiimage);
+UIImage* UIImageFromPNG(const std::vector<ImagePNGRep>& image_png_reps);
+gfx::Size UIImageSize(UIImage* image);
+#elif defined(OS_MAC)
+scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromNSImage(
+    NSImage* nsimage);
+NSImage* NSImageFromPNG(const std::vector<ImagePNGRep>& image_png_reps,
+                        CGColorSpaceRef color_space);
+gfx::Size NSImageSize(NSImage* image);
+#endif  // defined(OS_MAC)
+
+ImageSkia ImageSkiaFromPNG(const std::vector<ImagePNGRep>& image_png_reps);
+scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
+    const ImageSkia* image_skia);
+
+}  // namespace internal
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_PLATFORM_H_
diff --git a/ui/gfx/image/image_png_rep.cc b/ui/gfx/image/image_png_rep.cc
new file mode 100644
index 0000000..4115baf
--- /dev/null
+++ b/ui/gfx/image/image_png_rep.cc
@@ -0,0 +1,40 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_png_rep.h"
+
+#include "base/logging.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace gfx {
+
+ImagePNGRep::ImagePNGRep() = default;
+
+ImagePNGRep::ImagePNGRep(const scoped_refptr<base::RefCountedMemory>& data,
+                         float data_scale)
+    : raw_data(data),
+      scale(data_scale) {
+}
+
+ImagePNGRep::ImagePNGRep(const ImagePNGRep& other) = default;
+
+ImagePNGRep::~ImagePNGRep() {
+}
+
+gfx::Size ImagePNGRep::Size() const {
+  // The only way to get the width and height of a raw PNG stream, at least
+  // using the gfx::PNGCodec API, is to decode the whole thing.
+  CHECK(raw_data.get());
+  SkBitmap bitmap;
+  if (!gfx::PNGCodec::Decode(raw_data->front(), raw_data->size(),
+                             &bitmap)) {
+    LOG(ERROR) << "Unable to decode PNG.";
+    return gfx::Size(0, 0);
+  }
+  return gfx::Size(bitmap.width(), bitmap.height());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_png_rep.h b/ui/gfx/image/image_png_rep.h
new file mode 100644
index 0000000..0a75f19
--- /dev/null
+++ b/ui/gfx/image/image_png_rep.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_PNG_REP_H_
+#define UI_GFX_IMAGE_IMAGE_PNG_REP_H_
+
+#include "base/memory/ref_counted_memory.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+class Size;
+
+// An ImagePNGRep represents a bitmap's png encoded data and the scale factor it
+// was intended for.
+struct GFX_EXPORT ImagePNGRep {
+ public:
+  ImagePNGRep();
+  ImagePNGRep(const scoped_refptr<base::RefCountedMemory>& data,
+              float data_scale);
+  ImagePNGRep(const ImagePNGRep& other);
+  ~ImagePNGRep();
+
+  // Width and height of the image, in pixels.
+  // If the image is invalid, returns gfx::Size(0, 0).
+  // Warning: This operation processes the entire image stream, so its result
+  // should be cached if it is needed multiple times.
+  gfx::Size Size() const;
+
+  scoped_refptr<base::RefCountedMemory> raw_data;
+  float scale = 1.0f;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_PNG_REP_H_
diff --git a/ui/gfx/image/image_skia.cc b/ui/gfx/image/image_skia.cc
new file mode 100644
index 0000000..a8d7680
--- /dev/null
+++ b/ui/gfx/image/image_skia.cc
@@ -0,0 +1,554 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_skia.h"
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <memory>
+
+#include "base/check_op.h"
+#include "base/command_line.h"
+#include "base/memory/ptr_util.h"
+#include "base/no_destructor.h"
+#include "base/sequence_checker.h"
+#include "build/build_config.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/image/image_skia_source.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+namespace {
+
+// static
+gfx::ImageSkiaRep& NullImageRep() {
+  static base::NoDestructor<ImageSkiaRep> null_image_rep;
+  return *null_image_rep;
+}
+
+std::vector<float>* g_supported_scales = NULL;
+
+// The difference to fall back to the smaller scale factor rather than the
+// larger one. For example, assume 1.20 is requested but only 1.0 and 2.0 are
+// supported. In that case, not fall back to 2.0 but 1.0, and then expand
+// the image to 1.25.
+const float kFallbackToSmallerScaleDiff = 0.20f;
+
+// Maps to the closest supported scale. Returns an exact match, a smaller
+// scale within 0.2 units, the nearest larger scale, or the min/max
+// supported scale.
+float MapToSupportedScale(float scale) {
+  for (float supported_scale : *g_supported_scales) {
+    if (supported_scale + kFallbackToSmallerScaleDiff >= scale)
+      return supported_scale;
+  }
+  return g_supported_scales->back();
+}
+
+}  // namespace
+
+namespace internal {
+namespace {
+
+ImageSkiaRep ScaleImageSkiaRep(const ImageSkiaRep& rep, float target_scale) {
+  if (rep.is_null() || rep.scale() == target_scale)
+    return rep;
+
+  gfx::Size scaled_size =
+      gfx::ScaleToCeiledSize(rep.pixel_size(), target_scale / rep.scale());
+  return ImageSkiaRep(
+      skia::ImageOperations::Resize(rep.GetBitmap(),
+                                    skia::ImageOperations::RESIZE_LANCZOS3,
+                                    scaled_size.width(), scaled_size.height()),
+      target_scale);
+}
+
+}  // namespace
+
+// A helper class such that ImageSkia can be cheaply copied. ImageSkia holds a
+// refptr instance of ImageSkiaStorage, which in turn holds all of ImageSkia's
+// information.
+// The ImageSkia, and this class, are designed to be thread-safe in their const
+// methods, but also are bound to a single sequence for mutating methods.
+// NOTE: The FindRepresentation() method const and thread-safe *iff* it is
+// called with `fetch_new_image` set to true. Otherwise it may mutate the
+// class, which is not thread-safe. Internally, mutation is bound to a single
+// sequence with a `base::SequenceChecker`.
+class ImageSkiaStorage : public base::RefCountedThreadSafe<ImageSkiaStorage> {
+ public:
+  ImageSkiaStorage(std::unique_ptr<ImageSkiaSource> source,
+                   const gfx::Size& size);
+  ImageSkiaStorage(std::unique_ptr<ImageSkiaSource> source, float scale);
+
+  ImageSkiaStorage(const ImageSkiaStorage&) = delete;
+  ImageSkiaStorage& operator=(const ImageSkiaStorage&) = delete;
+
+  bool has_source() const { return source_ != nullptr; }
+  std::vector<gfx::ImageSkiaRep>& image_reps() { return image_reps_; }
+  const gfx::Size& size() const { return size_; }
+  bool read_only() const { return read_only_; }
+
+  void DeleteSource();
+  void SetReadOnly();
+  void DetachFromSequence();
+
+  // Checks if the current thread can safely modify the storage.
+  bool CanModify() const;
+
+  // Checks if the current thread can safely read the storage.
+  bool CanRead() const;
+
+  // Add a new representation. This checks if the scale of the added image
+  // is not 1.0f, and mark the existing rep as scaled to make
+  // the image high DPI aware.
+  void AddRepresentation(const ImageSkiaRep& image);
+
+  // Returns whether the underlying image source can provide a representation at
+  // any scale.  In this case, the caller is guaranteed that
+  // FindRepresentation(..., true) will always succeed.
+  bool HasRepresentationAtAllScales() const;
+
+  // Returns the iterator of the image rep whose density best matches
+  // |scale|. If the image for the |scale| doesn't exist in the storage and
+  // |storage| is set, it fetches new image by calling
+  // |ImageSkiaSource::GetImageForScale|. There are two modes to deal with
+  // arbitrary scale factors.
+  // 1: Invoke GetImageForScale with requested scale and if the source
+  //   returns the image with different scale (if the image doesn't exist in
+  //   resource, for example), it will fallback to closest image rep.
+  // 2: Invoke GetImageForScale with the closest known scale to the requested
+  //   one and rescale the image.
+  // Right now only Windows uses 2 and other platforms use 1 by default.
+  // TODO(mukai, oshima): abandon 1 code path and use 2 for every platforms.
+  std::vector<ImageSkiaRep>::const_iterator FindRepresentation(
+      float scale,
+      bool fetch_new_image) const;
+
+ private:
+  friend class base::RefCountedThreadSafe<ImageSkiaStorage>;
+
+  virtual ~ImageSkiaStorage();
+
+  // Each entry in here has a different scale and is returned when looking for
+  // an ImageSkiaRep of that scale.
+  std::vector<gfx::ImageSkiaRep> image_reps_;
+
+  // If no ImageSkiaRep exists in `image_reps_` for a given scale, the `source_`
+  // is queried to produce an ImageSkiaRep at that scale.
+  std::unique_ptr<ImageSkiaSource> source_;
+
+  // Size of the image in DIP.
+  gfx::Size size_;
+
+  bool read_only_;
+
+  // This isn't using SEQUENCE_CHECKER() macros because we use the sequence
+  // checker outside of DCHECKs to make branching decisions.
+  base::SequenceChecker sequence_checker_;  // nocheck
+};
+
+ImageSkiaStorage::ImageSkiaStorage(std::unique_ptr<ImageSkiaSource> source,
+                                   const gfx::Size& size)
+    : source_(std::move(source)), size_(size), read_only_(false) {}
+
+ImageSkiaStorage::ImageSkiaStorage(std::unique_ptr<ImageSkiaSource> source,
+                                   float scale)
+    : source_(std::move(source)), read_only_(false) {
+  DCHECK(source_);
+  auto it = FindRepresentation(scale, true);
+  if (it == image_reps_.end() || it->is_null())
+    source_.reset();
+  else
+    size_.SetSize(it->GetWidth(), it->GetHeight());
+}
+
+void ImageSkiaStorage::DeleteSource() {
+  source_.reset();
+}
+
+void ImageSkiaStorage::SetReadOnly() {
+  read_only_ = true;
+}
+
+void ImageSkiaStorage::DetachFromSequence() {
+  sequence_checker_.DetachFromSequence();
+}
+
+bool ImageSkiaStorage::CanModify() const {
+  return !read_only_ && sequence_checker_.CalledOnValidSequence();
+}
+
+bool ImageSkiaStorage::CanRead() const {
+  return (read_only_ && !source_) || sequence_checker_.CalledOnValidSequence();
+}
+
+void ImageSkiaStorage::AddRepresentation(const ImageSkiaRep& image) {
+  // Explicitly adding a representation makes no sense for images that
+  // inherently have representations at all scales already.
+  DCHECK(!HasRepresentationAtAllScales());
+
+  if (image.scale() != 1.0f) {
+    ImageSkia::ImageSkiaReps::iterator it;
+    for (it = image_reps_.begin(); it < image_reps_.end(); ++it) {
+      if (it->unscaled()) {
+        DCHECK_EQ(1.0f, it->scale());
+        *it = ImageSkiaRep(it->GetBitmap(), it->scale());
+        break;
+      }
+    }
+  }
+  image_reps_.push_back(image);
+}
+
+bool ImageSkiaStorage::HasRepresentationAtAllScales() const {
+  return source_ && source_->HasRepresentationAtAllScales();
+}
+
+std::vector<ImageSkiaRep>::const_iterator ImageSkiaStorage::FindRepresentation(
+    float scale,
+    bool fetch_new_image) const {
+  auto closest_iter = image_reps_.end();
+  auto exact_iter = image_reps_.end();
+  float smallest_diff = std::numeric_limits<float>::max();
+  for (auto it = image_reps_.begin(); it < image_reps_.end(); ++it) {
+    if (it->scale() == scale) {
+      // found exact match
+      fetch_new_image = false;
+      if (it->is_null())
+        continue;
+      exact_iter = it;
+      break;
+    }
+    float diff = std::abs(it->scale() - scale);
+    if (diff < smallest_diff && !it->is_null()) {
+      closest_iter = it;
+      smallest_diff = diff;
+    }
+  }
+
+  if (fetch_new_image && source_) {
+    DCHECK(sequence_checker_.CalledOnValidSequence())
+        << "An ImageSkia with the source must be accessed by the same "
+           "sequence.";
+    // This method is const and thread-safe, unless `fetch_new_image` is true,
+    // in which case the method is no longer considered const and we ensure
+    // that it is used in this way on a single sequence at a time with the above
+    // `sequence_checker_`.
+    auto* mutable_this = const_cast<ImageSkiaStorage*>(this);
+
+    ImageSkiaRep image;
+    float resource_scale = scale;
+    if (!HasRepresentationAtAllScales() && g_supported_scales)
+      resource_scale = MapToSupportedScale(scale);
+    if (scale != resource_scale) {
+      auto iter = FindRepresentation(resource_scale, fetch_new_image);
+      CHECK(iter != image_reps_.end());
+      image = iter->unscaled() ? (*iter) : ScaleImageSkiaRep(*iter, scale);
+    } else {
+      image = source_->GetImageForScale(scale);
+      // Image may be missing for the specified scale in some cases, such like
+      // looking up 2x resources but the 2x resource pack is missing. Fall back
+      // to 1x and re-scale it.
+      if (image.is_null() && scale != 1.0f)
+        image = ScaleImageSkiaRep(source_->GetImageForScale(1.0f), scale);
+    }
+
+    // If the source returned the new image, store it.
+    if (!image.is_null() &&
+        std::find_if(image_reps_.begin(), image_reps_.end(),
+                     [&image](const ImageSkiaRep& rep) {
+                       return rep.scale() == image.scale();
+                     }) == image_reps_.end()) {
+      mutable_this->image_reps_.push_back(image);
+    }
+
+    // image_reps_ should have the exact much now, or we will fallback
+    // to the new closest value. We pass false to prevent the generation step
+    // from running again and repeating the recursion.
+    return FindRepresentation(scale, false);
+  }
+  return exact_iter != image_reps_.end() ? exact_iter : closest_iter;
+}
+
+ImageSkiaStorage::~ImageSkiaStorage() = default;
+
+}  // internal
+
+ImageSkia::ImageSkia() {}
+
+ImageSkia::ImageSkia(std::unique_ptr<ImageSkiaSource> source,
+                     const gfx::Size& size)
+    : storage_(
+          base::MakeRefCounted<internal::ImageSkiaStorage>(std::move(source),
+                                                           size)) {
+  DCHECK(storage_->has_source());
+  // No other thread has reference to this, so it's safe to detach the sequence.
+  DetachStorageFromSequence();
+}
+
+ImageSkia::ImageSkia(std::unique_ptr<ImageSkiaSource> source, float scale)
+    : storage_(
+          base::MakeRefCounted<internal::ImageSkiaStorage>(std::move(source),
+                                                           scale)) {
+  if (!storage_->has_source())
+    storage_ = nullptr;
+  // No other thread has reference to this, so it's safe to detach the sequence.
+  DetachStorageFromSequence();
+}
+
+ImageSkia::ImageSkia(const ImageSkiaRep& image_rep) {
+  DCHECK(!image_rep.is_null());
+  Init(image_rep);
+  // No other thread has reference to this, so it's safe to detach the sequence.
+  DetachStorageFromSequence();
+}
+
+ImageSkia::ImageSkia(const ImageSkia& other) : storage_(other.storage_) {
+}
+
+ImageSkia& ImageSkia::operator=(const ImageSkia& other) {
+  storage_ = other.storage_;
+  return *this;
+}
+
+ImageSkia::~ImageSkia() {
+}
+
+// static
+void ImageSkia::SetSupportedScales(const std::vector<float>& supported_scales) {
+  if (g_supported_scales != NULL)
+    delete g_supported_scales;
+  g_supported_scales = new std::vector<float>(supported_scales);
+  std::sort(g_supported_scales->begin(), g_supported_scales->end());
+}
+
+// static
+const std::vector<float>& ImageSkia::GetSupportedScales() {
+  DCHECK(g_supported_scales != NULL);
+  return *g_supported_scales;
+}
+
+// static
+float ImageSkia::GetMaxSupportedScale() {
+  return g_supported_scales->back();
+}
+
+// static
+ImageSkia ImageSkia::CreateFromBitmap(const SkBitmap& bitmap, float scale) {
+  // An uninitialized/empty/null bitmap makes a null ImageSkia.
+  if (bitmap.drawsNothing())
+    return ImageSkia();
+  return ImageSkia(ImageSkiaRep(bitmap, scale));
+}
+
+// static
+ImageSkia ImageSkia::CreateFrom1xBitmap(const SkBitmap& bitmap) {
+  // An uninitialized/empty/null bitmap makes a null ImageSkia.
+  if (bitmap.drawsNothing())
+    return ImageSkia();
+  return ImageSkia(ImageSkiaRep(bitmap, 0.0f));
+}
+
+ImageSkia ImageSkia::DeepCopy() const {
+  ImageSkia copy;
+  if (isNull())
+    return copy;
+
+  CHECK(CanRead());
+
+  std::vector<gfx::ImageSkiaRep>& reps = storage_->image_reps();
+  for (auto iter = reps.begin(); iter != reps.end(); ++iter) {
+    copy.AddRepresentation(*iter);
+  }
+  // The copy has its own storage. Detach the copy from the current
+  // sequence so that other sequences can use this.
+  if (!copy.isNull())
+    copy.storage_->DetachFromSequence();
+  return copy;
+}
+
+bool ImageSkia::BackedBySameObjectAs(const gfx::ImageSkia& other) const {
+  return storage_.get() == other.storage_.get();
+}
+
+const void* ImageSkia::GetBackingObject() const {
+  return storage_.get();
+}
+
+void ImageSkia::AddRepresentation(const ImageSkiaRep& image_rep) {
+  DCHECK(!image_rep.is_null());
+  // TODO(oshima): This method should be called |SetRepresentation|
+  // and replace the existing rep if there is already one with the
+  // same scale so that we can guarantee that a ImageSkia instance contains only
+  // one image rep per scale. This is not possible now as ImageLoader currently
+  // stores need this feature, but this needs to be fixed.
+  if (isNull()) {
+    Init(image_rep);
+  } else {
+    CHECK(CanModify());
+    // If someone is adding ImageSkia explicitly, check if we should
+    // make the image high DPI aware.
+    storage_->AddRepresentation(image_rep);
+  }
+}
+
+void ImageSkia::RemoveRepresentation(float scale) {
+  if (isNull())
+    return;
+  CHECK(CanModify());
+
+  ImageSkiaReps& image_reps = storage_->image_reps();
+  auto it = storage_->FindRepresentation(scale, false);
+  if (it != image_reps.end() && it->scale() == scale)
+    image_reps.erase(it);
+}
+
+bool ImageSkia::HasRepresentation(float scale) const {
+  if (isNull())
+    return false;
+  CHECK(CanRead());
+
+  // This check is not only faster than FindRepresentation(), it's important for
+  // getting the right answer in cases of image types that are not based on
+  // discrete preset underlying representations, which otherwise might report
+  // "false" for this if GetRepresentation() has not yet been called for this
+  // |scale|.
+  if (storage_->HasRepresentationAtAllScales())
+    return true;
+
+  auto it = storage_->FindRepresentation(scale, false);
+  return (it != storage_->image_reps().end() && it->scale() == scale);
+}
+
+const ImageSkiaRep& ImageSkia::GetRepresentation(float scale) const {
+  if (isNull())
+    return NullImageRep();
+
+  CHECK(CanRead());
+
+  auto it = storage_->FindRepresentation(scale, true);
+  if (it == storage_->image_reps().end())
+    return NullImageRep();
+
+  return *it;
+}
+
+void ImageSkia::SetReadOnly() {
+  CHECK(storage_.get());
+  storage_->SetReadOnly();
+  DetachStorageFromSequence();
+}
+
+void ImageSkia::MakeThreadSafe() {
+  CHECK(storage_.get());
+  EnsureRepsForSupportedScales();
+  // Delete source as we no longer needs it.
+  if (storage_.get())
+    storage_->DeleteSource();
+  storage_->SetReadOnly();
+  CHECK(IsThreadSafe());
+}
+
+bool ImageSkia::IsThreadSafe() const {
+  return !storage_.get() || (storage_->read_only() && !storage_->has_source());
+}
+
+int ImageSkia::width() const {
+  return isNull() ? 0 : storage_->size().width();
+}
+
+gfx::Size ImageSkia::size() const {
+  return gfx::Size(width(), height());
+}
+
+int ImageSkia::height() const {
+  return isNull() ? 0 : storage_->size().height();
+}
+
+std::vector<ImageSkiaRep> ImageSkia::image_reps() const {
+  if (isNull())
+    return std::vector<ImageSkiaRep>();
+
+  CHECK(CanRead());
+
+  ImageSkiaReps internal_image_reps = storage_->image_reps();
+  // Create list of image reps to return, skipping null image reps which were
+  // added for caching purposes only.
+  ImageSkiaReps image_reps;
+  for (auto it = internal_image_reps.begin(); it != internal_image_reps.end();
+       ++it) {
+    if (!it->is_null())
+      image_reps.push_back(*it);
+  }
+
+  return image_reps;
+}
+
+void ImageSkia::EnsureRepsForSupportedScales() const {
+  DCHECK(g_supported_scales != NULL);
+  // Don't check ReadOnly because the source may generate images even for read
+  // only ImageSkia. Concurrent access will be protected by
+  // |DCHECK(sequence_checker_.CalledOnValidSequence())| in FindRepresentation.
+  if (storage_.get() && storage_->has_source()) {
+    for (std::vector<float>::const_iterator it = g_supported_scales->begin();
+         it != g_supported_scales->end(); ++it)
+      storage_->FindRepresentation(*it, true);
+  }
+}
+
+void ImageSkia::RemoveUnsupportedRepresentationsForScale(float scale) {
+  for (const ImageSkiaRep& image_rep_to_test : image_reps()) {
+    const float test_scale = image_rep_to_test.scale();
+    if (test_scale != scale && MapToSupportedScale(test_scale) == scale)
+      RemoveRepresentation(test_scale);
+  }
+}
+
+void ImageSkia::Init(const ImageSkiaRep& image_rep) {
+  DCHECK(!image_rep.is_null());
+  storage_ = new internal::ImageSkiaStorage(
+      NULL, gfx::Size(image_rep.GetWidth(), image_rep.GetHeight()));
+  storage_->image_reps().push_back(image_rep);
+}
+
+const SkBitmap& ImageSkia::GetBitmap() const {
+  if (isNull()) {
+    // Callers expect a ImageSkiaRep even if it is |isNull()|.
+    // TODO(pkotwicz): Fix this.
+    return NullImageRep().GetBitmap();
+  }
+
+  // TODO(oshima): This made a few tests flaky on Windows.
+  // Fix the root cause and re-enable this. crbug.com/145623.
+#if !defined(OS_WIN)
+  CHECK(CanRead());
+#endif
+
+  auto it = storage_->FindRepresentation(1.0f, true);
+  if (it != storage_->image_reps().end())
+    return it->GetBitmap();
+  return NullImageRep().GetBitmap();
+}
+
+bool ImageSkia::CanRead() const {
+  return !storage_.get() || storage_->CanRead();
+}
+
+bool ImageSkia::CanModify() const {
+  return !storage_.get() || storage_->CanModify();
+}
+
+void ImageSkia::DetachStorageFromSequence() {
+  if (storage_.get())
+    storage_->DetachFromSequence();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_skia.h b/ui/gfx/image/image_skia.h
new file mode 100644
index 0000000..156c828
--- /dev/null
+++ b/ui/gfx/image/image_skia.h
@@ -0,0 +1,198 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_SKIA_H_
+#define UI_GFX_IMAGE_IMAGE_SKIA_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/gtest_prod_util.h"
+#include "base/memory/ref_counted.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/image/image_skia_rep.h"
+
+namespace gfx {
+class ImageSkiaSource;
+class Size;
+
+namespace internal {
+class ImageSkiaStorage;
+}  // namespace internal
+
+namespace test {
+class TestOnThread;
+}
+
+// Container for the same image at different densities, similar to NSImage.
+// Image height and width are in DIP (Density Indepent Pixel) coordinates.
+//
+// ImageSkia should be used whenever possible instead of SkBitmap.
+// Functions that mutate the image should operate on the gfx::ImageSkiaRep
+// returned from ImageSkia::GetRepresentation, not on ImageSkia.
+//
+// NOTE: This class should *not* be used to store multiple logical sizes of an
+// image (e.g., small, medium and large versions of an icon); use an ImageFamily
+// for that. An ImageSkia represents an image of a single logical size, with
+// potentially many different densities for high-DPI displays.
+//
+// ImageSkia is cheap to copy and intentionally supports copy semantics.
+class GFX_EXPORT ImageSkia {
+ public:
+  typedef std::vector<ImageSkiaRep> ImageSkiaReps;
+
+  // Creates an instance with no bitmaps.
+  ImageSkia();
+
+  // Creates an instance that will use the |source| to get the image
+  // for scale factors. |size| specifes the size of the image in DIP.
+  ImageSkia(std::unique_ptr<ImageSkiaSource> source, const gfx::Size& size);
+
+  // Creates an instance that uses the |source|. The constructor loads the image
+  // at |scale| and uses its dimensions to calculate the size in DIP.
+  ImageSkia(std::unique_ptr<ImageSkiaSource> source, float scale);
+
+  explicit ImageSkia(const gfx::ImageSkiaRep& image_rep);
+
+  // Copies a reference to |other|'s storage.
+  ImageSkia(const ImageSkia& other);
+
+  // Copies a reference to |other|'s storage.
+  ImageSkia& operator=(const ImageSkia& other);
+
+  ~ImageSkia();
+
+  // Changes the value of GetSupportedScales() to |scales|.
+  static void SetSupportedScales(const std::vector<float>& scales);
+
+  // Returns a vector with the scale factors which are supported by this
+  // platform, in ascending order.
+  static const std::vector<float>& GetSupportedScales();
+
+  // Returns the maximum scale supported by this platform.
+  static float GetMaxSupportedScale();
+
+  // Creates an image from the passed in bitmap, which is designed for display
+  // at the device scale factor given in `scale`. The DIP width and height will
+  // be based on that scale factor. A scale factor of 0 is equivalent to
+  // calling CreateFrom1xBitmap(), which indicates the bitmap is not scaled.
+  // The `bitmap`, if present, will be made immutable. If the `bitmap` is
+  // uninitialized, empty, or null then the returned ImageSkia will be
+  // default-constructed and empty.
+  // WARNING: If the device scale factory differs from the scale given here,
+  // the resulting image will be pixelated when displayed.
+  static ImageSkia CreateFromBitmap(const SkBitmap& bitmap, float scale);
+
+  // Creates an image from the passed in bitmap. The DIP width and height will
+  // be based on scale factor of 1x. The `bitmap`, if present, will be made
+  // immutable. If the bitmap is uninitialized, empty, or null then the
+  // returned ImageSkia will be default-constructed and empty.
+  // WARNING: The resulting image will be pixelated when painted on a high
+  // density display.
+  static ImageSkia CreateFrom1xBitmap(const SkBitmap& bitmap);
+
+  // Returns a deep copy of this ImageSkia which has its own storage with
+  // the ImageSkiaRep instances that this ImageSkia currently has.
+  // This can be safely passed to and manipulated by another thread.
+  // Note that this does NOT generate ImageSkiaReps from its source.
+  // If you want to create a deep copy with ImageSkiaReps for supported
+  // scale factors, you need to explicitly call
+  // |EnsureRepsForSupportedScales()| first.
+  ImageSkia DeepCopy() const;
+
+  // Returns true if this object is backed by the same ImageSkiaStorage as
+  // |other|. Will also return true if both images are isNull().
+  bool BackedBySameObjectAs(const gfx::ImageSkia& other) const;
+
+  // Returns a pointer that identifies the backing ImageSkiaStorage. Comparing
+  // the results of this method from two ImageSkia objects is equivalent to
+  // using BackedBySameObjectAs().
+  const void* GetBackingObject() const;
+
+  // Adds |image_rep| to the image reps contained by this object.
+  void AddRepresentation(const gfx::ImageSkiaRep& image_rep);
+
+  // Removes the image rep of |scale| if present.
+  void RemoveRepresentation(float scale);
+
+  // Returns true if the object owns an image rep whose density matches
+  // |scale| exactly.
+  bool HasRepresentation(float scale) const;
+
+  // Returns the image rep whose density best matches |scale|.
+  // Returns a null image rep if the object contains no image reps.
+  const gfx::ImageSkiaRep& GetRepresentation(float scale) const;
+
+  // Make the ImageSkia instance read-only. Note that this only prevent
+  // modification from client code, and the storage may still be
+  // modified by the source if any (thus, it's not thread safe).  This
+  // detaches the storage from currently accessing sequence, so its safe
+  // to pass it to another sequence as long as it is accessed only by that
+  // sequence. If this ImageSkia's storage will be accessed by multiple
+  // sequences, use |MakeThreadSafe()| method.
+  void SetReadOnly();
+
+  // Make the image thread safe by making the storage read only and remove
+  // its source if any. All ImageSkia that shares the same storage will also
+  // become thread safe. Note that in order to make it 100% thread safe,
+  // this must be called before it's been passed to another sequence.
+  void MakeThreadSafe();
+  bool IsThreadSafe() const;
+
+  // Returns true if this is a null object.
+  bool isNull() const { return storage_.get() == NULL; }
+
+  // Width and height of image in DIP coordinate system.
+  int width() const;
+  int height() const;
+  gfx::Size size() const;
+
+  // Returns pointer to 1x bitmap contained by this object. If there is no 1x
+  // bitmap, the bitmap whose scale factor is closest to 1x is returned.
+  // This function should only be used in unittests and on platforms which do
+  // not support scale factors other than 1x.
+  // TODO(pkotwicz): Return null SkBitmap when the object has no 1x bitmap.
+  const SkBitmap* bitmap() const { return &GetBitmap(); }
+
+  // Returns a vector with the image reps contained in this object.
+  // There is no guarantee that this will return all images rep for
+  // supported scale factors.
+  std::vector<gfx::ImageSkiaRep> image_reps() const;
+
+  // When the source is available, generates all ImageReps for
+  // supported scale factors. This method is defined as const as
+  // the state change in the storage is agnostic to the caller.
+  void EnsureRepsForSupportedScales() const;
+
+  // Clears cached representations for non-supported scale factors that are
+  // based on |scale|.
+  void RemoveUnsupportedRepresentationsForScale(float scale);
+
+ private:
+  friend class test::TestOnThread;
+  FRIEND_TEST_ALL_PREFIXES(ImageSkiaTest, EmptyOnThreadTest);
+  FRIEND_TEST_ALL_PREFIXES(ImageSkiaTest, StaticOnThreadTest);
+  FRIEND_TEST_ALL_PREFIXES(ImageSkiaTest, SourceOnThreadTest);
+
+  // Initialize ImageSkiaStorage with passed in parameters.
+  // If the image rep's bitmap is empty, ImageStorage is set to NULL.
+  void Init(const gfx::ImageSkiaRep& image_rep);
+
+  const SkBitmap& GetBitmap() const;
+
+  // Checks if the current sequence can read/modify the ImageSkia.
+  bool CanRead() const;
+  bool CanModify() const;
+
+  // Detach the storage from the currently assigned sequence
+  // so that other sequence can access the storage.
+  void DetachStorageFromSequence();
+
+  // A refptr so that ImageRepSkia can be copied cheaply.
+  scoped_refptr<internal::ImageSkiaStorage> storage_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_SKIA_H_
diff --git a/ui/gfx/image/image_skia_operations.cc b/ui/gfx/image/image_skia_operations.cc
new file mode 100644
index 0000000..b691b2f
--- /dev/null
+++ b/ui/gfx/image/image_skia_operations.cc
@@ -0,0 +1,766 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_skia_operations.h"
+
+#include <stddef.h>
+#include <memory>
+
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/numerics/safe_conversions.h"
+#include "skia/ext/image_operations.h"
+#include "third_party/skia/include/core/SkClipOp.h"
+#include "third_party/skia/include/core/SkDrawLooper.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/image/canvas_image_source.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_skia_rep.h"
+#include "ui/gfx/image/image_skia_source.h"
+#include "ui/gfx/skbitmap_operations.h"
+#include "ui/gfx/skia_paint_util.h"
+
+namespace gfx {
+namespace {
+
+gfx::Size DIPToPixelSize(gfx::Size dip_size, float scale) {
+  return ScaleToCeiledSize(dip_size, scale);
+}
+
+gfx::Rect DIPToPixelBounds(gfx::Rect dip_bounds, float scale) {
+  return gfx::Rect(ScaleToFlooredPoint(dip_bounds.origin(), scale),
+                   DIPToPixelSize(dip_bounds.size(), scale));
+}
+
+// Returns an image rep for the ImageSkiaSource to return to visually indicate
+// an error.
+ImageSkiaRep GetErrorImageRep(float scale, const gfx::Size& pixel_size) {
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(pixel_size.width(), pixel_size.height());
+  bitmap.eraseColor(kPlaceholderColor);
+  return gfx::ImageSkiaRep(bitmap, scale);
+}
+
+// A base image source class that creates an image from two source images.
+// This class guarantees that two ImageSkiaReps have have the same pixel size.
+class BinaryImageSource : public gfx::ImageSkiaSource {
+ protected:
+  BinaryImageSource(const ImageSkia& first,
+                    const ImageSkia& second,
+                    const char* source_name)
+      : first_(first),
+        second_(second),
+        source_name_(source_name) {
+  }
+
+  BinaryImageSource(const BinaryImageSource&) = delete;
+  BinaryImageSource& operator=(const BinaryImageSource&) = delete;
+
+  ~BinaryImageSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    ImageSkiaRep first_rep = first_.GetRepresentation(scale);
+    if (first_rep.is_null())
+      return first_rep;
+    ImageSkiaRep second_rep = second_.GetRepresentation(scale);
+    if (second_rep.is_null())
+      return second_rep;
+
+    if (first_rep.pixel_size() != second_rep.pixel_size()) {
+      DCHECK_NE(first_rep.scale(), second_rep.scale());
+      if (first_rep.scale() == second_rep.scale()) {
+        LOG(ERROR) << "ImageSkiaRep size mismatch in " << source_name_;
+        return GetErrorImageRep(first_rep.scale(),first_rep.pixel_size());
+      }
+      first_rep = first_.GetRepresentation(1.0f);
+      second_rep = second_.GetRepresentation(1.0f);
+      DCHECK_EQ(first_rep.pixel_width(), second_rep.pixel_width());
+      DCHECK_EQ(first_rep.pixel_height(), second_rep.pixel_height());
+      if (first_rep.pixel_size() != second_rep.pixel_size()) {
+        LOG(ERROR) << "ImageSkiaRep size mismatch in " << source_name_;
+        return GetErrorImageRep(first_rep.scale(), first_rep.pixel_size());
+      }
+    } else {
+      DCHECK_EQ(first_rep.scale(), second_rep.scale());
+    }
+    return CreateImageSkiaRep(first_rep, second_rep);
+  }
+
+  // Creates a final image from two ImageSkiaReps. The pixel size of
+  // the two images are guaranteed to be the same.
+  virtual ImageSkiaRep CreateImageSkiaRep(
+      const ImageSkiaRep& first_rep,
+      const ImageSkiaRep& second_rep) const = 0;
+
+ private:
+  const ImageSkia first_;
+  const ImageSkia second_;
+  // The name of a class that implements the BinaryImageSource.
+  // The subclass is responsible for managing the memory.
+  const char* source_name_;
+};
+
+class BlendingImageSource : public BinaryImageSource {
+ public:
+  BlendingImageSource(const ImageSkia& first,
+                      const ImageSkia& second,
+                      double alpha)
+      : BinaryImageSource(first, second, "BlendingImageSource"),
+        alpha_(alpha) {
+  }
+
+  BlendingImageSource(const BlendingImageSource&) = delete;
+  BlendingImageSource& operator=(const BlendingImageSource&) = delete;
+
+  ~BlendingImageSource() override {}
+
+  // BinaryImageSource overrides:
+  ImageSkiaRep CreateImageSkiaRep(
+      const ImageSkiaRep& first_rep,
+      const ImageSkiaRep& second_rep) const override {
+    SkBitmap blended = SkBitmapOperations::CreateBlendedBitmap(
+        first_rep.GetBitmap(), second_rep.GetBitmap(), alpha_);
+    return ImageSkiaRep(blended, first_rep.scale());
+  }
+
+ private:
+  double alpha_;
+};
+
+class SuperimposedImageSource : public gfx::CanvasImageSource {
+ public:
+  SuperimposedImageSource(const ImageSkia& first, const ImageSkia& second)
+      : gfx::CanvasImageSource(first.size()), first_(first), second_(second) {}
+
+  SuperimposedImageSource(const SuperimposedImageSource&) = delete;
+  SuperimposedImageSource& operator=(const SuperimposedImageSource&) = delete;
+
+  ~SuperimposedImageSource() override {}
+
+  // gfx::CanvasImageSource override.
+  void Draw(Canvas* canvas) override {
+    canvas->DrawImageInt(first_, 0, 0);
+    canvas->DrawImageInt(second_,
+                         (first_.width() - second_.width()) / 2,
+                         (first_.height() - second_.height()) / 2);
+  }
+
+ private:
+  const ImageSkia first_;
+  const ImageSkia second_;
+};
+
+class TransparentImageSource : public gfx::ImageSkiaSource {
+ public:
+  TransparentImageSource(const ImageSkia& image, double alpha)
+      : image_(image),
+        alpha_(alpha) {
+  }
+
+  TransparentImageSource(const TransparentImageSource&) = delete;
+  TransparentImageSource& operator=(const TransparentImageSource&) = delete;
+
+  ~TransparentImageSource() override {}
+
+ private:
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    ImageSkiaRep image_rep = image_.GetRepresentation(scale);
+    if (image_rep.is_null())
+      return image_rep;
+
+    SkBitmap alpha;
+    alpha.allocN32Pixels(image_rep.pixel_width(),
+                         image_rep.pixel_height());
+    alpha.eraseColor(SkColorSetA(SK_ColorBLACK, SK_AlphaOPAQUE * alpha_));
+    return ImageSkiaRep(
+        SkBitmapOperations::CreateMaskedBitmap(image_rep.GetBitmap(), alpha),
+        image_rep.scale());
+  }
+
+  ImageSkia image_;
+  double alpha_;
+};
+
+class MaskedImageSource : public BinaryImageSource {
+ public:
+  MaskedImageSource(const ImageSkia& rgb, const ImageSkia& alpha)
+      : BinaryImageSource(rgb, alpha, "MaskedImageSource") {
+  }
+
+  MaskedImageSource(const MaskedImageSource&) = delete;
+  MaskedImageSource& operator=(const MaskedImageSource&) = delete;
+
+  ~MaskedImageSource() override {}
+
+  // BinaryImageSource overrides:
+  ImageSkiaRep CreateImageSkiaRep(
+      const ImageSkiaRep& first_rep,
+      const ImageSkiaRep& second_rep) const override {
+    return ImageSkiaRep(SkBitmapOperations::CreateMaskedBitmap(
+                            first_rep.GetBitmap(), second_rep.GetBitmap()),
+                        first_rep.scale());
+  }
+};
+
+class TiledImageSource : public gfx::ImageSkiaSource {
+ public:
+  TiledImageSource(const ImageSkia& source,
+                   int src_x, int src_y,
+                   int dst_w, int dst_h)
+      : source_(source),
+        src_x_(src_x),
+        src_y_(src_y),
+        dst_w_(dst_w),
+        dst_h_(dst_h) {
+  }
+
+  TiledImageSource(const TiledImageSource&) = delete;
+  TiledImageSource& operator=(const TiledImageSource&) = delete;
+
+  ~TiledImageSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    ImageSkiaRep source_rep = source_.GetRepresentation(scale);
+    if (source_rep.is_null())
+      return source_rep;
+
+    gfx::Rect bounds = DIPToPixelBounds(gfx::Rect(src_x_, src_y_, dst_w_,
+                                                  dst_h_), source_rep.scale());
+    return ImageSkiaRep(SkBitmapOperations::CreateTiledBitmap(
+                            source_rep.GetBitmap(), bounds.x(), bounds.y(),
+                            bounds.width(), bounds.height()),
+                        source_rep.scale());
+  }
+
+ private:
+  const ImageSkia source_;
+  const int src_x_;
+  const int src_y_;
+  const int dst_w_;
+  const int dst_h_;
+};
+
+class HSLImageSource : public gfx::ImageSkiaSource {
+ public:
+  HSLImageSource(const ImageSkia& image,
+                 const color_utils::HSL& hsl_shift)
+      : image_(image),
+        hsl_shift_(hsl_shift) {
+  }
+
+  HSLImageSource(const HSLImageSource&) = delete;
+  HSLImageSource& operator=(const HSLImageSource&) = delete;
+
+  ~HSLImageSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    ImageSkiaRep image_rep = image_.GetRepresentation(scale);
+    if (image_rep.is_null())
+      return image_rep;
+
+    return gfx::ImageSkiaRep(SkBitmapOperations::CreateHSLShiftedBitmap(
+                                 image_rep.GetBitmap(), hsl_shift_),
+                             image_rep.scale());
+  }
+
+ private:
+  const gfx::ImageSkia image_;
+  const color_utils::HSL hsl_shift_;
+};
+
+// ImageSkiaSource which uses SkBitmapOperations::CreateButtonBackground
+// to generate image reps for the target image.  The image and mask can be
+// diferent sizes (crbug.com/171725).
+class ButtonImageSource: public gfx::ImageSkiaSource {
+ public:
+  ButtonImageSource(SkColor color,
+                    const ImageSkia& image,
+                    const ImageSkia& mask)
+      : color_(color),
+        image_(image),
+        mask_(mask) {
+  }
+
+  ButtonImageSource(const ButtonImageSource&) = delete;
+  ButtonImageSource& operator=(const ButtonImageSource&) = delete;
+
+  ~ButtonImageSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    ImageSkiaRep image_rep = image_.GetRepresentation(scale);
+    if (image_rep.is_null())
+      return image_rep;
+    ImageSkiaRep mask_rep = mask_.GetRepresentation(scale);
+    if (mask_rep.is_null())
+      return image_rep;
+
+    if (image_rep.scale() != mask_rep.scale()) {
+      image_rep = image_.GetRepresentation(1.0f);
+      mask_rep = mask_.GetRepresentation(1.0f);
+    }
+    return gfx::ImageSkiaRep(
+        SkBitmapOperations::CreateButtonBackground(
+            color_, image_rep.GetBitmap(), mask_rep.GetBitmap()),
+        image_rep.scale());
+  }
+
+ private:
+  const SkColor color_;
+  const ImageSkia image_;
+  const ImageSkia mask_;
+};
+
+// ImageSkiaSource which uses SkBitmap::extractSubset to generate image reps
+// for the target image.
+class ExtractSubsetImageSource: public gfx::ImageSkiaSource {
+ public:
+  ExtractSubsetImageSource(const gfx::ImageSkia& image,
+                           const gfx::Rect& subset_bounds)
+      : image_(image),
+        subset_bounds_(subset_bounds) {
+  }
+
+  ExtractSubsetImageSource(const ExtractSubsetImageSource&) = delete;
+  ExtractSubsetImageSource& operator=(const ExtractSubsetImageSource&) = delete;
+
+  ~ExtractSubsetImageSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    ImageSkiaRep image_rep = image_.GetRepresentation(scale);
+    if (image_rep.is_null())
+      return image_rep;
+
+    SkIRect subset_bounds_in_pixel = RectToSkIRect(
+        DIPToPixelBounds(subset_bounds_, image_rep.scale()));
+    SkBitmap dst;
+    bool success =
+        image_rep.GetBitmap().extractSubset(&dst, subset_bounds_in_pixel);
+    DCHECK(success);
+    return gfx::ImageSkiaRep(dst, image_rep.scale());
+  }
+
+ private:
+  const gfx::ImageSkia image_;
+  const gfx::Rect subset_bounds_;
+};
+
+// ResizeSource resizes relevant image reps in |source| to |target_dip_size|
+// for requested scale factors.
+class ResizeSource : public ImageSkiaSource {
+ public:
+  ResizeSource(const ImageSkia& source,
+               skia::ImageOperations::ResizeMethod method,
+               const Size& target_dip_size)
+      : source_(source),
+        resize_method_(method),
+        target_dip_size_(target_dip_size) {
+  }
+
+  ResizeSource(const ResizeSource&) = delete;
+  ResizeSource& operator=(const ResizeSource&) = delete;
+
+  ~ResizeSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    const ImageSkiaRep& image_rep = source_.GetRepresentation(scale);
+    if (image_rep.is_null())
+      return image_rep;
+    if (image_rep.GetWidth() == target_dip_size_.width() &&
+        image_rep.GetHeight() == target_dip_size_.height())
+      return image_rep;
+
+    const Size target_pixel_size = DIPToPixelSize(target_dip_size_, scale);
+    const SkBitmap resized = skia::ImageOperations::Resize(
+        image_rep.GetBitmap(), resize_method_, target_pixel_size.width(),
+        target_pixel_size.height());
+    if (resized.colorType() == kUnknown_SkColorType)
+      return ImageSkiaRep();
+    return ImageSkiaRep(resized, scale);
+  }
+
+ private:
+  const ImageSkia source_;
+  skia::ImageOperations::ResizeMethod resize_method_;
+  const Size target_dip_size_;
+};
+
+// DropShadowSource generates image reps with drop shadow for image reps in
+// |source| that represent requested scale factors.
+class DropShadowSource : public ImageSkiaSource {
+ public:
+  DropShadowSource(const ImageSkia& source, const ShadowValues& shadows_in_dip)
+      : source_(source), shadows_in_dip_(shadows_in_dip) {}
+
+  DropShadowSource(const DropShadowSource&) = delete;
+  DropShadowSource& operator=(const DropShadowSource&) = delete;
+
+  ~DropShadowSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    const ImageSkiaRep& image_rep = source_.GetRepresentation(scale);
+    if (image_rep.is_null())
+      return image_rep;
+
+    ShadowValues shadows_in_pixel;
+    for (size_t i = 0; i < shadows_in_dip_.size(); ++i)
+      shadows_in_pixel.push_back(shadows_in_dip_[i].Scale(scale));
+
+    const SkBitmap shadow_bitmap = SkBitmapOperations::CreateDropShadow(
+        image_rep.GetBitmap(), shadows_in_pixel);
+    return ImageSkiaRep(shadow_bitmap, image_rep.scale());
+  }
+
+ private:
+  const ImageSkia source_;
+  const ShadowValues shadows_in_dip_;
+};
+
+// An image source that is 1px wide, suitable for tiling horizontally.
+class HorizontalShadowSource : public CanvasImageSource {
+ public:
+  HorizontalShadowSource(const std::vector<ShadowValue>& shadows,
+                         bool fades_down)
+      : CanvasImageSource(Size(1, GetHeightForShadows(shadows))),
+        shadows_(shadows),
+        fades_down_(fades_down) {}
+
+  HorizontalShadowSource(const HorizontalShadowSource&) = delete;
+  HorizontalShadowSource& operator=(const HorizontalShadowSource&) = delete;
+
+  ~HorizontalShadowSource() override {}
+
+  // CanvasImageSource overrides:
+  void Draw(Canvas* canvas) override {
+    cc::PaintFlags flags;
+    flags.setLooper(CreateShadowDrawLooper(shadows_));
+    canvas->DrawRect(RectF(0, fades_down_ ? -1 : size().height(), 1, 1), flags);
+  }
+
+ private:
+  static int GetHeightForShadows(const std::vector<ShadowValue>& shadows) {
+    int height = 0;
+    for (const auto& shadow : shadows) {
+      height =
+          std::max(height, shadow.y() + base::ClampCeil(shadow.blur() / 2));
+    }
+    return height;
+  }
+
+  const std::vector<ShadowValue> shadows_;
+
+  // The orientation of the shadow (true for shadows that emanate downwards).
+  bool fades_down_;
+};
+
+// RotatedSource generates image reps that are rotations of those in
+// |source| that represent requested scale factors.
+class RotatedSource : public ImageSkiaSource {
+ public:
+  RotatedSource(const ImageSkia& source,
+                SkBitmapOperations::RotationAmount rotation)
+    : source_(source),
+      rotation_(rotation) {
+  }
+
+  RotatedSource(const RotatedSource&) = delete;
+  RotatedSource& operator=(const RotatedSource&) = delete;
+
+  ~RotatedSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    const ImageSkiaRep& image_rep = source_.GetRepresentation(scale);
+    if (image_rep.is_null())
+      return image_rep;
+
+    const SkBitmap rotated_bitmap =
+        SkBitmapOperations::Rotate(image_rep.GetBitmap(), rotation_);
+    return ImageSkiaRep(rotated_bitmap, image_rep.scale());
+  }
+
+ private:
+  const ImageSkia source_;
+  const SkBitmapOperations::RotationAmount rotation_;
+};
+
+class IconWithBadgeSource : public gfx::CanvasImageSource {
+ public:
+  IconWithBadgeSource(const ImageSkia& icon, const ImageSkia& badge)
+      : gfx::CanvasImageSource(icon.size()), icon_(icon), badge_(badge) {}
+
+  IconWithBadgeSource(const IconWithBadgeSource&) = delete;
+  IconWithBadgeSource& operator=(const IconWithBadgeSource&) = delete;
+
+  ~IconWithBadgeSource() override {}
+
+  // gfx::CanvasImageSource override.
+  void Draw(Canvas* canvas) override {
+    canvas->DrawImageInt(icon_, 0, 0);
+    canvas->DrawImageInt(badge_, (icon_.width() - badge_.width()),
+                         (icon_.height() - badge_.height()));
+  }
+
+ private:
+  const ImageSkia icon_;
+  const ImageSkia badge_;
+};
+
+// ImageSkiaSource which uses SkBitmapOperations::CreateColorMask
+// to generate image reps for the target image.
+class ColorMaskSource : public gfx::ImageSkiaSource {
+ public:
+  ColorMaskSource(const ImageSkia& image, SkColor color)
+      : image_(image), color_(color) {}
+
+  ColorMaskSource(const ColorMaskSource&) = delete;
+  ColorMaskSource& operator=(const ColorMaskSource&) = delete;
+
+  ~ColorMaskSource() override {}
+
+  // gfx::ImageSkiaSource overrides:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    ImageSkiaRep image_rep = image_.GetRepresentation(scale);
+    if (image_rep.is_null())
+      return image_rep;
+
+    return ImageSkiaRep(
+        SkBitmapOperations::CreateColorMask(image_rep.GetBitmap(), color_),
+        image_rep.scale());
+  }
+
+ private:
+  const ImageSkia image_;
+  const SkColor color_;
+};
+
+// Image source to create an image with a circle background.
+class ImageWithCircleBackgroundSource : public gfx::CanvasImageSource {
+ public:
+  ImageWithCircleBackgroundSource(int radius,
+                                  SkColor color,
+                                  const gfx::ImageSkia& image)
+      : gfx::CanvasImageSource(gfx::Size(radius * 2, radius * 2)),
+        radius_(radius),
+        color_(color),
+        image_(image) {}
+
+  ImageWithCircleBackgroundSource(const ImageWithCircleBackgroundSource&) =
+      delete;
+  ImageWithCircleBackgroundSource& operator=(
+      const ImageWithCircleBackgroundSource&) = delete;
+
+  ~ImageWithCircleBackgroundSource() override = default;
+
+  // gfx::CanvasImageSource:
+  void Draw(gfx::Canvas* canvas) override {
+    cc::PaintFlags flags;
+    flags.setAntiAlias(true);
+    flags.setStyle(cc::PaintFlags::kFill_Style);
+    flags.setColor(color_);
+    canvas->DrawCircle(gfx::Point(radius_, radius_), radius_, flags);
+    const int x = radius_ - image_.width() / 2;
+    const int y = radius_ - image_.height() / 2;
+    canvas->DrawImageInt(image_, x, y);
+  }
+
+ private:
+  const int radius_;
+  const SkColor color_;
+  const gfx::ImageSkia image_;
+};
+}  // namespace
+
+// static
+ImageSkia ImageSkiaOperations::CreateBlendedImage(const ImageSkia& first,
+                                                  const ImageSkia& second,
+                                                  double alpha) {
+  if (first.isNull() || second.isNull())
+    return ImageSkia();
+
+  return ImageSkia(std::make_unique<BlendingImageSource>(first, second, alpha),
+                   first.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateSuperimposedImage(
+    const ImageSkia& first,
+    const ImageSkia& second) {
+  if (first.isNull() || second.isNull())
+    return ImageSkia();
+
+  return ImageSkia(std::make_unique<SuperimposedImageSource>(first, second),
+                   first.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateTransparentImage(const ImageSkia& image,
+                                                      double alpha) {
+  if (image.isNull())
+    return ImageSkia();
+
+  return ImageSkia(std::make_unique<TransparentImageSource>(image, alpha),
+                   image.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateMaskedImage(const ImageSkia& rgb,
+                                                 const ImageSkia& alpha) {
+  if (rgb.isNull() || alpha.isNull())
+    return ImageSkia();
+
+  return ImageSkia(std::make_unique<MaskedImageSource>(rgb, alpha), rgb.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateTiledImage(const ImageSkia& source,
+                                                int src_x, int src_y,
+                                                int dst_w, int dst_h) {
+  if (source.isNull())
+    return ImageSkia();
+
+  return ImageSkia(
+      std::make_unique<TiledImageSource>(source, src_x, src_y, dst_w, dst_h),
+      gfx::Size(dst_w, dst_h));
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateHSLShiftedImage(
+    const ImageSkia& image,
+    const color_utils::HSL& hsl_shift) {
+  if (image.isNull())
+    return ImageSkia();
+
+  return ImageSkia(std::make_unique<HSLImageSource>(image, hsl_shift),
+                   image.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateButtonBackground(SkColor color,
+                                                      const ImageSkia& image,
+                                                      const ImageSkia& mask) {
+  if (image.isNull() || mask.isNull())
+    return ImageSkia();
+
+  return ImageSkia(std::make_unique<ButtonImageSource>(color, image, mask),
+                   mask.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::ExtractSubset(const ImageSkia& image,
+                                             const Rect& subset_bounds) {
+  gfx::Rect clipped_bounds =
+      gfx::IntersectRects(subset_bounds, gfx::Rect(image.size()));
+  if (image.isNull() || clipped_bounds.IsEmpty())
+    return ImageSkia();
+  if (clipped_bounds == gfx::Rect(image.size()))
+    return image;
+
+  return ImageSkia(
+      std::make_unique<ExtractSubsetImageSource>(image, clipped_bounds),
+      clipped_bounds.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateResizedImage(
+    const ImageSkia& source,
+    skia::ImageOperations::ResizeMethod method,
+    const Size& target_dip_size) {
+  if (source.isNull())
+    return ImageSkia();
+  if (source.size() == target_dip_size)
+    return source;
+
+  return ImageSkia(
+      std::make_unique<ResizeSource>(source, method, target_dip_size),
+      target_dip_size);
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateImageWithDropShadow(
+    const ImageSkia& source,
+    const ShadowValues& shadows) {
+  if (source.isNull())
+    return ImageSkia();
+
+  const gfx::Insets shadow_padding = -gfx::ShadowValue::GetMargin(shadows);
+  gfx::Size shadow_image_size = source.size();
+  shadow_image_size.Enlarge(shadow_padding.width(),
+                            shadow_padding.height());
+  return ImageSkia(std::make_unique<DropShadowSource>(source, shadows),
+                   shadow_image_size);
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateHorizontalShadow(
+    const std::vector<ShadowValue>& shadows,
+    bool fades_down) {
+  auto* source = new HorizontalShadowSource(shadows, fades_down);
+  return ImageSkia(base::WrapUnique(source), source->size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateRotatedImage(
+      const ImageSkia& source,
+      SkBitmapOperations::RotationAmount rotation) {
+  if (source.isNull())
+    return ImageSkia();
+
+  return ImageSkia(std::make_unique<RotatedSource>(source, rotation),
+                   SkBitmapOperations::ROTATION_180_CW == rotation
+                       ? source.size()
+                       : gfx::Size(source.height(), source.width()));
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateIconWithBadge(const ImageSkia& icon,
+                                                   const ImageSkia& badge) {
+  if (icon.isNull())
+    return ImageSkia();
+
+  if (badge.isNull())
+    return icon;
+
+  return ImageSkia(std::make_unique<IconWithBadgeSource>(icon, badge),
+                   icon.size());
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateColorMask(const ImageSkia& image,
+                                               SkColor color) {
+  if (image.isNull())
+    return ImageSkia();
+
+  return ImageSkia(std::make_unique<ColorMaskSource>(image, color),
+                   image.size());
+}
+
+ImageSkia ImageSkiaOperations::CreateImageWithCircleBackground(
+    int radius,
+    SkColor color,
+    const ImageSkia& image) {
+  DCHECK_GE(radius * 2, image.width());
+  DCHECK_GE(radius * 2, image.height());
+  return gfx::CanvasImageSource::MakeImageSkia<ImageWithCircleBackgroundSource>(
+      radius, color, image);
+}
+}  // namespace gfx
diff --git a/ui/gfx/image/image_skia_operations.h b/ui/gfx/image/image_skia_operations.h
new file mode 100644
index 0000000..a25afd4
--- /dev/null
+++ b/ui/gfx/image/image_skia_operations.h
@@ -0,0 +1,128 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_SKIA_OPERATIONS_H_
+#define UI_GFX_IMAGE_IMAGE_SKIA_OPERATIONS_H_
+
+#include "skia/ext/image_operations.h"
+#include "third_party/skia/include/core/SkDrawLooper.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkRRect.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/shadow_value.h"
+#include "ui/gfx/skbitmap_operations.h"
+
+namespace gfx {
+class ImageSkia;
+class Rect;
+class Size;
+
+class GFX_EXPORT ImageSkiaOperations {
+ public:
+  // Create an image that is a blend of two others. The alpha argument
+  // specifies the opacity of the second imag. The provided image must
+  // use the kARGB_8888_Config config and be of equal dimensions.
+  static ImageSkia CreateBlendedImage(const ImageSkia& first,
+                                      const ImageSkia& second,
+                                      double alpha);
+
+  // Creates an image that is the original image with opacity set to |alpha|.
+  static ImageSkia CreateTransparentImage(const ImageSkia& image, double alpha);
+
+  // Creates new image by painting first and second image respectively.
+  // The second image is centered in respect to the first image.
+  static ImageSkia CreateSuperimposedImage(const ImageSkia& first,
+                                           const ImageSkia& second);
+
+  // Create an image that is the original image masked out by the mask defined
+  // in the alpha image. The images must use the kARGB_8888_Config config and
+  // be of equal dimensions.
+  static ImageSkia CreateMaskedImage(const ImageSkia& first,
+                                     const ImageSkia& alpha);
+
+  // Create an image that is cropped from another image. This is special
+  // because it tiles the original image, so your coordinates can extend
+  // outside the bounds of the original image.
+  static ImageSkia CreateTiledImage(const ImageSkia& image,
+                                    int src_x, int src_y,
+                                    int dst_w, int dst_h);
+
+  // Shift an image's HSL values. The shift values are in the range of 0-1,
+  // with the option to specify -1 for 'no change'. The shift values are
+  // defined as:
+  // hsl_shift[0] (hue): The absolute hue value for the image - 0 and 1 map
+  //    to 0 and 360 on the hue color wheel (red).
+  // hsl_shift[1] (saturation): A saturation shift for the image, with the
+  //    following key values:
+  //    0 = remove all color.
+  //    0.5 = leave unchanged.
+  //    1 = fully saturate the image.
+  // hsl_shift[2] (lightness): A lightness shift for the image, with the
+  //    following key values:
+  //    0 = remove all lightness (make all pixels black).
+  //    0.5 = leave unchanged.
+  //    1 = full lightness (make all pixels white).
+  static ImageSkia CreateHSLShiftedImage(const gfx::ImageSkia& image,
+                                         const color_utils::HSL& hsl_shift);
+
+  // Creates a button background image by compositing the color and image
+  // together, then applying the mask. This is a highly specialized composite
+  // operation that is the equivalent of drawing a background in |color|,
+  // tiling |image| over the top, and then masking the result out with |mask|.
+  // The images must use kARGB_8888_Config config.
+  static ImageSkia CreateButtonBackground(SkColor color,
+                                          const gfx::ImageSkia& image,
+                                          const gfx::ImageSkia& mask);
+
+  // Returns an image which is a subset of |image| with bounds |subset_bounds|.
+  // The |image| cannot use kA1_Config config.
+  static ImageSkia ExtractSubset(const gfx::ImageSkia& image,
+                                 const gfx::Rect& subset_bounds);
+
+  // Creates an image by resizing |source| to given |target_dip_size|.
+  static ImageSkia CreateResizedImage(const ImageSkia& source,
+                                      skia::ImageOperations::ResizeMethod methd,
+                                      const Size& target_dip_size);
+
+  // Creates an image with drop shadow defined in |shadows| for |source|.
+  static ImageSkia CreateImageWithDropShadow(const ImageSkia& source,
+                                             const ShadowValues& shadows);
+
+  // Creates an image that is 1dp wide, suitable for tiling horizontally to
+  // create a drop shadow effect. The purpose of tiling a static image is to
+  // avoid repeatedly asking Skia to draw a shadow.
+  static ImageSkia CreateHorizontalShadow(
+      const std::vector<ShadowValue>& shadows,
+      bool fades_down);
+
+  // Creates an image which is a rotation of the |source|. |rotation| is the
+  // amount of clockwise rotation in degrees.
+  static ImageSkia CreateRotatedImage(
+      const ImageSkia& source,
+      SkBitmapOperations::RotationAmount rotation);
+
+  // Creates an icon by painting the second icon as a badge to the first one.
+  // The second icon is in the right corner of the first icon. If the icon
+  // is valid and the badge is not, the icon will be returned.
+  static ImageSkia CreateIconWithBadge(const ImageSkia& icon,
+                                       const ImageSkia& badge);
+
+  // Creates an image by combining |image| and color |color|.
+  // The image must use the kARGB_8888_Config config.
+  static ImageSkia CreateColorMask(const gfx::ImageSkia& image, SkColor color);
+
+  // Creates an image with a circle background. |color| and |radius| is the
+  // color and radius of the circle background.
+  static ImageSkia CreateImageWithCircleBackground(int radius,
+                                                   SkColor color,
+                                                   const ImageSkia& image);
+
+ private:
+  ImageSkiaOperations();  // Class for scoping only.
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_SKIA_OPERATIONS_H_
diff --git a/ui/gfx/image/image_skia_operations_unittest.cc b/ui/gfx/image/image_skia_operations_unittest.cc
new file mode 100644
index 0000000..473e2d5
--- /dev/null
+++ b/ui/gfx/image/image_skia_operations_unittest.cc
@@ -0,0 +1,23 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/image/image_skia_operations.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace gfx {
+namespace {
+
+TEST(ImageSkiaOperationsTest, ResizeFailure) {
+  ImageSkia image(ImageSkiaRep(gfx::Size(10, 10), 1.f));
+
+  // Try to resize to empty. This isn't a valid resize and fails gracefully.
+  ImageSkia resized = ImageSkiaOperations::CreateResizedImage(
+      image, skia::ImageOperations::RESIZE_BEST, gfx::Size());
+  EXPECT_TRUE(resized.GetRepresentation(1.0f).is_null());
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/image/image_skia_rep.h b/ui/gfx/image/image_skia_rep.h
new file mode 100644
index 0000000..4f9d6b1
--- /dev/null
+++ b/ui/gfx/image/image_skia_rep.h
@@ -0,0 +1,16 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_SKIA_REP_H_
+#define UI_GFX_IMAGE_IMAGE_SKIA_REP_H_
+
+#include "build/build_config.h"
+
+#if defined(OS_IOS)
+#include "ui/gfx/image/image_skia_rep_ios.h"
+#else
+#include "ui/gfx/image/image_skia_rep_default.h"
+#endif  // defined(OS_IOS)
+
+#endif  // UI_GFX_IMAGE_IMAGE_SKIA_REP_H_
diff --git a/ui/gfx/image/image_skia_rep_default.cc b/ui/gfx/image/image_skia_rep_default.cc
new file mode 100644
index 0000000..66c7657
--- /dev/null
+++ b/ui/gfx/image/image_skia_rep_default.cc
@@ -0,0 +1,113 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_skia_rep_default.h"
+
+#include "base/check_op.h"
+#include "base/notreached.h"
+#include "cc/paint/display_item_list.h"
+#include "cc/paint/record_paint_canvas.h"
+#include "cc/paint/skia_paint_canvas.h"
+#include "skia/ext/legacy_display_globals.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "ui/gfx/color_palette.h"
+
+namespace gfx {
+
+ImageSkiaRep::ImageSkiaRep()
+    : type_(ImageRepType::kImageTypeDrawable), scale_(0.0f) {}
+
+ImageSkiaRep::ImageSkiaRep(const gfx::Size& size, float scale)
+    : type_(ImageRepType::kImageTypeBitmap), scale_(scale) {
+  bitmap_.allocN32Pixels(static_cast<int>(size.width() * this->scale()),
+                         static_cast<int>(size.height() * this->scale()));
+  bitmap_.eraseColor(kPlaceholderColor);
+  bitmap_.setImmutable();
+  pixel_size_.SetSize(bitmap_.width(), bitmap_.height());
+  paint_image_ = cc::PaintImage::CreateFromBitmap(bitmap_);
+}
+
+ImageSkiaRep::ImageSkiaRep(const SkBitmap& src, float scale)
+    : type_(ImageRepType::kImageTypeBitmap),
+      pixel_size_(gfx::Size(src.width(), src.height())),
+      bitmap_(src),
+      scale_(scale) {
+  CHECK_EQ(bitmap_.colorType(), kN32_SkColorType);
+  DCHECK(!bitmap_.drawsNothing());
+  bitmap_.setImmutable();
+  paint_image_ = cc::PaintImage::CreateFromBitmap(src);
+}
+
+ImageSkiaRep::ImageSkiaRep(sk_sp<cc::PaintRecord> paint_record,
+                           const gfx::Size& pixel_size,
+                           float scale)
+    : paint_record_(std::move(paint_record)),
+      type_(ImageRepType::kImageTypeDrawable),
+      pixel_size_(pixel_size),
+      scale_(scale) {
+  DCHECK(!pixel_size.IsEmpty());
+}
+
+ImageSkiaRep::ImageSkiaRep(const ImageSkiaRep& other)
+    : paint_image_(other.paint_image_),
+      paint_record_(other.paint_record_),
+      type_(other.type_),
+      pixel_size_(other.pixel_size_),
+      bitmap_(other.bitmap_),
+      scale_(other.scale_) {}
+
+ImageSkiaRep::~ImageSkiaRep() {}
+
+int ImageSkiaRep::GetWidth() const {
+  return static_cast<int>(pixel_width() / scale());
+}
+
+int ImageSkiaRep::GetHeight() const {
+  return static_cast<int>(pixel_height() / scale());
+}
+
+sk_sp<cc::PaintRecord> ImageSkiaRep::GetPaintRecord() const {
+  DCHECK(type_ == ImageRepType::kImageTypeBitmap || !is_null());
+  // If this image rep is of |kImageTypeDrawable| then it must have a paint
+  // record.
+  if (type_ == ImageRepType::kImageTypeDrawable || paint_record_)
+    return paint_record_;
+
+  // If this ImageRep was generated using a bitmap then it may not have a
+  // paint record generated for it yet. We would have to generate it now.
+  scoped_refptr<cc::DisplayItemList> display_item_list =
+      base::MakeRefCounted<cc::DisplayItemList>(
+          cc::DisplayItemList::kToBeReleasedAsPaintOpBuffer);
+
+  cc::RecordPaintCanvas record_canvas(
+      display_item_list.get(), SkRect::MakeIWH(pixel_width(), pixel_height()));
+
+  display_item_list->StartPaint();
+  record_canvas.drawImage(paint_image(), 0, 0);
+  display_item_list->EndPaintOfPairedEnd();
+  display_item_list->Finalize();
+
+  paint_record_ = display_item_list->ReleaseAsRecord();
+  return paint_record_;
+}
+
+const SkBitmap& ImageSkiaRep::GetBitmap() const {
+  if (type_ == ImageRepType::kImageTypeDrawable && bitmap_.isNull() &&
+      paint_record_) {
+    // TODO(malaykeshav): Add a NOTREACHED() once all instances of this call
+    // path is removed from the code base.
+
+    // A request for bitmap was made even though this ImageSkiaRep is sourced
+    // form a drawable(e.g. CanvasImageSource). This should not be happenning
+    // as it forces a rasterization on the UI thread.
+    bitmap_.allocN32Pixels(pixel_width(), pixel_height());
+    bitmap_.eraseColor(SK_ColorTRANSPARENT);
+    SkCanvas canvas(bitmap_, skia::LegacyDisplayGlobals::GetSkSurfaceProps());
+    paint_record_->Playback(&canvas);
+    bitmap_.setImmutable();
+  }
+  return bitmap_;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_skia_rep_default.h b/ui/gfx/image/image_skia_rep_default.h
new file mode 100644
index 0000000..651ff76
--- /dev/null
+++ b/ui/gfx/image/image_skia_rep_default.h
@@ -0,0 +1,102 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_SKIA_REP_DEFAULT_H_
+#define UI_GFX_IMAGE_IMAGE_SKIA_REP_DEFAULT_H_
+
+#include "build/build_config.h"
+#include "cc/paint/paint_image.h"
+#include "cc/paint/paint_op_buffer.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// An ImageSkiaRep represents an image and the scale factor it is intended for.
+// 0.0f scale is used to indicate that this ImageSkiaRep is used for unscaled
+// (ImageSkia does not automatically scale the image).
+// TODO(malaykeshav): Support transport of PaintRecord across mojo. This would
+// require adding inline serialization support for PaintRecords.
+class GFX_EXPORT ImageSkiaRep {
+ public:
+  // Create null bitmap.
+  ImageSkiaRep();
+
+  // Note: This is for testing purpose only.
+  // Creates a bitmap with kARGB_8888_Config config with given |size| in DIP.
+  // This allocates pixels in the bitmap. It is guaranteed that the data in the
+  // bitmap are initialized but the actual values are undefined.
+  // Specifying 0 scale means the image is for unscaled image (unscaled()
+  // returns true, and scale() returns 1.0f).
+  ImageSkiaRep(const gfx::Size& size, float scale);
+
+  // Creates an ImageSkiaRep that holds the `src` bitmap, which is created for
+  // display at the given device scale factor. Takes ownership of a reference to
+  // the SkBitmap's backing store. The `src` bitmap may not be uninitialized,
+  // null or empty; in that case the default constructor should be used
+  // instead.
+  ImageSkiaRep(const SkBitmap& src, float scale);
+
+  // Creates an image rep backed by a paint record of given size and scale. This
+  // is used when the image representation is sourced from a drawable such as
+  // CanvasImageSource. The `size` must not be empty; in that case the default
+  // constructor should be used instead.
+  ImageSkiaRep(sk_sp<cc::PaintRecord> paint_record,
+               const gfx::Size& size,
+               float scale);
+
+  ImageSkiaRep(const ImageSkiaRep& other);
+  ~ImageSkiaRep();
+
+  // Get width and height of the image in pixels.
+  int pixel_width() const { return pixel_size_.width(); }
+  int pixel_height() const { return pixel_size_.height(); }
+  const Size& pixel_size() const { return pixel_size_; }
+
+  // Get width and height of the image in DIP.
+  int GetWidth() const;
+  int GetHeight() const;
+
+  // Retrieves the scale for which this image is a representation of.
+  float scale() const { return unscaled() ? 1.0f : scale_; }
+  bool unscaled() const { return scale_ == 0.0f; }
+
+  bool is_null() const {
+    return type_ == ImageRepType::kImageTypeBitmap ? bitmap_.isNull()
+                                                   : !paint_record_;
+  }
+
+  // Returns the backing bitmap when the image representation is sourced from a
+  // bitmap. If this is a |kImageTypeDrawable| then it will generate(and cache)
+  // a bitmap.
+  const SkBitmap& GetBitmap() const;
+
+  // Returns the backing drawable as a PaintRecord. Use this when the type of
+  // ImageRep is |kImageTypeDrawable|.
+  sk_sp<cc::PaintRecord> GetPaintRecord() const;
+
+  const cc::PaintImage& paint_image() const { return paint_image_; }
+  bool has_paint_image() const { return !!paint_image_; }
+
+ private:
+  enum class ImageRepType {
+    kImageTypeBitmap,   // When the source image is rasterized. (Bitmaps, PNGs)
+    kImageTypeDrawable  // When the source image is a drawable generated by a
+                        // CanvasImageSource.
+  };
+
+  // TODO(malaykeshav): Remove when migration is complete and it is safe.
+  cc::PaintImage paint_image_;
+  mutable sk_sp<cc::PaintRecord> paint_record_;
+  ImageRepType type_;
+
+  Size pixel_size_;
+  mutable SkBitmap bitmap_;
+  float scale_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_SKIA_REP_DEFAULT_H_
diff --git a/ui/gfx/image/image_skia_rep_ios.cc b/ui/gfx/image/image_skia_rep_ios.cc
new file mode 100644
index 0000000..5fb5925
--- /dev/null
+++ b/ui/gfx/image/image_skia_rep_ios.cc
@@ -0,0 +1,50 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/image/image_skia_rep_ios.h"
+
+#include "base/check_op.h"
+#include "ui/gfx/color_palette.h"
+
+namespace gfx {
+
+ImageSkiaRep::ImageSkiaRep() : scale_(0.0f) {}
+
+ImageSkiaRep::ImageSkiaRep(const gfx::Size& size, float scale) : scale_(scale) {
+  bitmap_.allocN32Pixels(static_cast<int>(size.width() * this->scale()),
+                         static_cast<int>(size.height() * this->scale()));
+  bitmap_.eraseColor(kPlaceholderColor);
+  bitmap_.setImmutable();
+  pixel_size_.SetSize(bitmap_.width(), bitmap_.height());
+}
+
+ImageSkiaRep::ImageSkiaRep(const SkBitmap& src, float scale)
+    : pixel_size_(gfx::Size(src.width(), src.height())),
+      bitmap_(src),
+      scale_(scale) {
+  CHECK_EQ(src.colorType(), kN32_SkColorType);
+  DCHECK(!bitmap_.drawsNothing());
+  bitmap_.setImmutable();
+}
+
+ImageSkiaRep::ImageSkiaRep(const ImageSkiaRep& other)
+    : pixel_size_(other.pixel_size_),
+      bitmap_(other.bitmap_),
+      scale_(other.scale_) {}
+
+ImageSkiaRep::~ImageSkiaRep() {}
+
+int ImageSkiaRep::GetWidth() const {
+  return static_cast<int>(pixel_width() / scale());
+}
+
+int ImageSkiaRep::GetHeight() const {
+  return static_cast<int>(pixel_height() / scale());
+}
+
+const SkBitmap& ImageSkiaRep::GetBitmap() const {
+  return bitmap_;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_skia_rep_ios.h b/ui/gfx/image/image_skia_rep_ios.h
new file mode 100644
index 0000000..51e8f84
--- /dev/null
+++ b/ui/gfx/image/image_skia_rep_ios.h
@@ -0,0 +1,67 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_SKIA_REP_IOS_H_
+#define UI_GFX_IMAGE_IMAGE_SKIA_REP_IOS_H_
+
+#include "build/build_config.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// An ImageSkiaRep represents an image and the scale factor it is intended for.
+// 0.0f scale is used to indicate that this ImageSkiaRep is used for unscaled
+// image (ImageSkia does not automatically scale the image).
+// iOS does not support cc's PaintOpBuffer and instead uses cocoa frameworks
+// image formats.
+class GFX_EXPORT ImageSkiaRep {
+ public:
+  // Create null bitmap.
+  ImageSkiaRep();
+
+  // Note: This is for testing purpose only.
+  // Creates a bitmap with kARGB_8888_Config config with given |size| in DIP.
+  // This allocates pixels in the bitmap. It is guaranteed that the data in the
+  // bitmap are initialized but the actual values are undefined.
+  // Specifying 0 scale means the image is for unscaled image. (unscaled()
+  // returns truen, and scale() returns 1.0f;)
+  ImageSkiaRep(const gfx::Size& size, float scale);
+
+  // Creates a bitmap with given scale.
+  // Adds ref to |src|.
+  ImageSkiaRep(const SkBitmap& src, float scale);
+  ImageSkiaRep(const ImageSkiaRep& other);
+
+  ~ImageSkiaRep();
+
+  // Get width and height of the image in pixels.
+  int pixel_width() const { return bitmap_.width(); }
+  int pixel_height() const { return bitmap_.height(); }
+  Size pixel_size() const { return gfx::Size(pixel_width(), pixel_height()); }
+
+  // Get width and height of the image in DIP.
+  int GetWidth() const;
+  int GetHeight() const;
+
+  // Retrieves the scale for which this image is a representation of.
+  float scale() const { return unscaled() ? 1.0f : scale_; }
+  bool unscaled() const { return scale_ == 0.0f; }
+
+  bool is_null() const { return bitmap_.isNull(); }
+
+  // Returns the backing bitmap when the image representation is sourced from a
+  // bitmap.
+  const SkBitmap& GetBitmap() const;
+
+ private:
+  Size pixel_size_;
+  SkBitmap bitmap_;
+  float scale_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_SKIA_REP_IOS_H_
diff --git a/ui/gfx/image/image_skia_source.cc b/ui/gfx/image/image_skia_source.cc
new file mode 100644
index 0000000..53bc427
--- /dev/null
+++ b/ui/gfx/image/image_skia_source.cc
@@ -0,0 +1,13 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/image/image_skia_source.h"
+
+namespace gfx {
+
+ImageSkiaSource::~ImageSkiaSource() {}
+
+bool ImageSkiaSource::HasRepresentationAtAllScales() const { return false; }
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_skia_source.h b/ui/gfx/image/image_skia_source.h
new file mode 100644
index 0000000..9ffc135
--- /dev/null
+++ b/ui/gfx/image/image_skia_source.h
@@ -0,0 +1,32 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_SKIA_SOURCE_H_
+#define UI_GFX_IMAGE_IMAGE_SKIA_SOURCE_H_
+
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class ImageSkiaRep;
+
+class GFX_EXPORT ImageSkiaSource {
+ public:
+  virtual ~ImageSkiaSource();
+
+  // Returns the ImageSkiaRep for the given |scale|. ImageSkia caches the
+  // returned ImageSkiaRep and calls this method only if it doesn't have
+  // ImageSkiaRep for given |scale|. There is no need for the implementation to
+  // cache the image.
+  virtual gfx::ImageSkiaRep GetImageForScale(float scale) = 0;
+
+  // Subclasses should override this to return true when they are capable of
+  // providing an exact representation at any desired scale factor.
+  virtual bool HasRepresentationAtAllScales() const;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_SKIA_SOURCE_H_
diff --git a/ui/gfx/image/image_skia_unittest.cc b/ui/gfx/image/image_skia_unittest.cc
new file mode 100644
index 0000000..12b19b9
--- /dev/null
+++ b/ui/gfx/image/image_skia_unittest.cc
@@ -0,0 +1,637 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_skia.h"
+
+#include <stddef.h>
+
+#include "base/check_op.h"
+#include "base/command_line.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/threading/simple_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image_skia_rep.h"
+#include "ui/gfx/image/image_skia_source.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+
+namespace {
+
+class FixedSource : public ImageSkiaSource {
+ public:
+  explicit FixedSource(const ImageSkiaRep& image) : image_(image) {}
+
+  FixedSource(const FixedSource&) = delete;
+  FixedSource& operator=(const FixedSource&) = delete;
+
+  ~FixedSource() override {}
+
+  ImageSkiaRep GetImageForScale(float scale) override { return image_; }
+
+ private:
+  ImageSkiaRep image_;
+};
+
+class FixedScaleSource : public ImageSkiaSource {
+ public:
+  explicit FixedScaleSource(const ImageSkiaRep& image) : image_(image) {}
+
+  FixedScaleSource(const FixedScaleSource&) = delete;
+  FixedScaleSource& operator=(const FixedScaleSource&) = delete;
+
+  ~FixedScaleSource() override {}
+
+  ImageSkiaRep GetImageForScale(float scale) override {
+    if (!image_.unscaled() && image_.scale() != scale)
+      return ImageSkiaRep();
+    return image_;
+  }
+
+ private:
+  ImageSkiaRep image_;
+};
+
+class DynamicSource : public ImageSkiaSource {
+ public:
+  explicit DynamicSource(const gfx::Size& size)
+      : size_(size),
+        last_requested_scale_(0.0f) {}
+
+  DynamicSource(const DynamicSource&) = delete;
+  DynamicSource& operator=(const DynamicSource&) = delete;
+
+  ~DynamicSource() override {}
+
+  ImageSkiaRep GetImageForScale(float scale) override {
+    last_requested_scale_ = scale;
+    return gfx::ImageSkiaRep(size_, scale);
+  }
+
+  float GetLastRequestedScaleAndReset() {
+    float result = last_requested_scale_;
+    last_requested_scale_ = 0.0f;
+    return result;
+  }
+
+ private:
+  gfx::Size size_;
+  float last_requested_scale_;
+};
+
+class NullSource: public ImageSkiaSource {
+ public:
+  NullSource() {
+  }
+
+  NullSource(const NullSource&) = delete;
+  NullSource& operator=(const NullSource&) = delete;
+
+  ~NullSource() override {}
+
+  ImageSkiaRep GetImageForScale(float scale) override {
+    return gfx::ImageSkiaRep();
+  }
+};
+
+}  // namespace
+
+namespace test {
+class TestOnThread : public base::SimpleThread {
+ public:
+  explicit TestOnThread(ImageSkia* image_skia)
+      : SimpleThread("image_skia_on_thread"),
+        image_skia_(image_skia),
+        can_read_(false),
+        can_modify_(false) {
+  }
+
+  TestOnThread(const TestOnThread&) = delete;
+  TestOnThread& operator=(const TestOnThread&) = delete;
+
+  void Run() override {
+    can_read_ = image_skia_->CanRead();
+    can_modify_ = image_skia_->CanModify();
+    if (can_read_)
+      image_skia_->image_reps();
+  }
+
+  void StartAndJoin() {
+    Start();
+    Join();
+  }
+
+  bool can_read() const { return can_read_; }
+
+  bool can_modify() const { return can_modify_; }
+
+ private:
+  ImageSkia* image_skia_;
+
+  bool can_read_;
+  bool can_modify_;
+};
+
+}  // namespace test
+
+class ImageSkiaTest : public testing::Test {
+ public:
+  ImageSkiaTest() {
+    // In the test, we assume that we support 1.0f and 2.0f DSFs.
+    old_scales_ = ImageSkia::GetSupportedScales();
+
+    // Sets the list of scale factors supported by resource bundle.
+    std::vector<float> supported_scales;
+    supported_scales.push_back(1.0f);
+    supported_scales.push_back(2.0f);
+    ImageSkia::SetSupportedScales(supported_scales);
+  }
+
+  ImageSkiaTest(const ImageSkiaTest&) = delete;
+  ImageSkiaTest& operator=(const ImageSkiaTest&) = delete;
+
+  ~ImageSkiaTest() override { ImageSkia::SetSupportedScales(old_scales_); }
+
+ private:
+  std::vector<float> old_scales_;
+};
+
+TEST_F(ImageSkiaTest, FixedSource) {
+  ImageSkiaRep image(Size(100, 200), 0.0f);
+  ImageSkia image_skia(std::make_unique<FixedSource>(image), Size(100, 200));
+  EXPECT_EQ(0U, image_skia.image_reps().size());
+
+  const ImageSkiaRep& result_100p = image_skia.GetRepresentation(1.0f);
+  EXPECT_EQ(100, result_100p.GetWidth());
+  EXPECT_EQ(200, result_100p.GetHeight());
+  EXPECT_EQ(1.0f, result_100p.scale());
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+
+  const ImageSkiaRep& result_200p = image_skia.GetRepresentation(2.0f);
+
+  EXPECT_EQ(100, result_200p.GetWidth());
+  EXPECT_EQ(200, result_200p.GetHeight());
+  EXPECT_EQ(100, result_200p.pixel_width());
+  EXPECT_EQ(200, result_200p.pixel_height());
+  EXPECT_EQ(1.0f, result_200p.scale());
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+
+  const ImageSkiaRep& result_300p = image_skia.GetRepresentation(3.0f);
+
+  EXPECT_EQ(100, result_300p.GetWidth());
+  EXPECT_EQ(200, result_300p.GetHeight());
+  EXPECT_EQ(100, result_300p.pixel_width());
+  EXPECT_EQ(200, result_300p.pixel_height());
+  EXPECT_EQ(1.0f, result_300p.scale());
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+
+  // Get the representation again and make sure it doesn't
+  // generate new image skia rep.
+  image_skia.GetRepresentation(1.0f);
+  image_skia.GetRepresentation(2.0f);
+  image_skia.GetRepresentation(3.0f);
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+}
+
+TEST_F(ImageSkiaTest, FixedScaledSource) {
+  ImageSkiaRep image(Size(100, 200), 1.0f);
+  ImageSkia image_skia(std::make_unique<FixedScaleSource>(image),
+                       Size(100, 200));
+  EXPECT_EQ(0U, image_skia.image_reps().size());
+
+  const ImageSkiaRep& result_100p = image_skia.GetRepresentation(1.0f);
+  EXPECT_EQ(100, result_100p.GetWidth());
+  EXPECT_EQ(200, result_100p.GetHeight());
+  EXPECT_EQ(1.0f, result_100p.scale());
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+
+  // 2.0f data doesn't exist, then it falls back to 1.0f and rescale it.
+  const ImageSkiaRep& result_200p = image_skia.GetRepresentation(2.0f);
+
+  EXPECT_EQ(100, result_200p.GetWidth());
+  EXPECT_EQ(200, result_200p.GetHeight());
+  EXPECT_EQ(200, result_200p.pixel_width());
+  EXPECT_EQ(400, result_200p.pixel_height());
+  EXPECT_EQ(2.0f, result_200p.scale());
+  EXPECT_EQ(2U, image_skia.image_reps().size());
+
+  // Get the representation again and make sure it doesn't
+  // generate new image skia rep.
+  image_skia.GetRepresentation(1.0f);
+  image_skia.GetRepresentation(2.0f);
+  EXPECT_EQ(2U, image_skia.image_reps().size());
+}
+
+TEST_F(ImageSkiaTest, FixedUnscaledSource) {
+  ImageSkiaRep image(Size(100, 200), 0.0f);
+  ImageSkia image_skia(std::make_unique<FixedScaleSource>(image),
+                       Size(100, 200));
+  EXPECT_EQ(0U, image_skia.image_reps().size());
+
+  const ImageSkiaRep& result_100p = image_skia.GetRepresentation(1.0f);
+  EXPECT_EQ(100, result_100p.pixel_width());
+  EXPECT_EQ(200, result_100p.pixel_height());
+  EXPECT_TRUE(result_100p.unscaled());
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+
+  // 2.0f data doesn't exist, but unscaled ImageSkiaRep shouldn't be rescaled.
+  const ImageSkiaRep& result_200p = image_skia.GetRepresentation(2.0f);
+
+  EXPECT_EQ(100, result_200p.pixel_width());
+  EXPECT_EQ(200, result_200p.pixel_height());
+  EXPECT_TRUE(result_200p.unscaled());
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+
+  // Get the representation again and make sure it doesn't
+  // generate new image skia rep.
+  image_skia.GetRepresentation(1.0f);
+  image_skia.GetRepresentation(2.0f);
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+}
+
+TEST_F(ImageSkiaTest, DynamicSource) {
+  ImageSkia image_skia(std::make_unique<DynamicSource>(Size(100, 200)),
+                       Size(100, 200));
+  EXPECT_EQ(0U, image_skia.image_reps().size());
+  const ImageSkiaRep& result_100p = image_skia.GetRepresentation(1.0f);
+  EXPECT_EQ(100, result_100p.GetWidth());
+  EXPECT_EQ(200, result_100p.GetHeight());
+  EXPECT_EQ(1.0f, result_100p.scale());
+  EXPECT_EQ(1U, image_skia.image_reps().size());
+
+  const ImageSkiaRep& result_200p =
+      image_skia.GetRepresentation(2.0f);
+  EXPECT_EQ(100, result_200p.GetWidth());
+  EXPECT_EQ(200, result_200p.GetHeight());
+  EXPECT_EQ(200, result_200p.pixel_width());
+  EXPECT_EQ(400, result_200p.pixel_height());
+  EXPECT_EQ(2.0f, result_200p.scale());
+  EXPECT_EQ(2U, image_skia.image_reps().size());
+
+  // Get the representation again and make sure it doesn't
+  // generate new image skia rep.
+  image_skia.GetRepresentation(1.0f);
+  EXPECT_EQ(2U, image_skia.image_reps().size());
+  image_skia.GetRepresentation(2.0f);
+  EXPECT_EQ(2U, image_skia.image_reps().size());
+}
+
+// Tests that image_reps returns all of the representations in the
+// image when there are multiple representations for a scale factor.
+// This currently is the case with ImageLoader::LoadImages.
+TEST_F(ImageSkiaTest, ManyRepsPerScaleFactor) {
+  const int kSmallIcon1x = 16;
+  const int kSmallIcon2x = 32;
+  const int kLargeIcon1x = 32;
+
+  ImageSkia image(std::make_unique<NullSource>(),
+                  gfx::Size(kSmallIcon1x, kSmallIcon1x));
+  // Simulate a source which loads images on a delay. Upon
+  // GetImageForScaleFactor, it immediately returns null and starts loading
+  // image reps slowly.
+  image.GetRepresentation(1.0f);
+  image.GetRepresentation(2.0f);
+
+  // After a lengthy amount of simulated time, finally loaded image reps.
+  image.AddRepresentation(ImageSkiaRep(
+      gfx::Size(kSmallIcon1x, kSmallIcon1x), 1.0f));
+  image.AddRepresentation(ImageSkiaRep(
+      gfx::Size(kSmallIcon2x, kSmallIcon2x), 2.0f));
+  image.AddRepresentation(ImageSkiaRep(
+      gfx::Size(kLargeIcon1x, kLargeIcon1x), 1.0f));
+
+  std::vector<ImageSkiaRep> image_reps = image.image_reps();
+  EXPECT_EQ(3u, image_reps.size());
+
+  int num_1x = 0;
+  int num_2x = 0;
+  for (size_t i = 0; i < image_reps.size(); ++i) {
+    if (image_reps[i].scale() == 1.0f)
+      num_1x++;
+    else if (image_reps[i].scale() == 2.0f)
+      num_2x++;
+  }
+  EXPECT_EQ(2, num_1x);
+  EXPECT_EQ(1, num_2x);
+}
+
+TEST_F(ImageSkiaTest, GetBitmap) {
+  ImageSkia image_skia(std::make_unique<DynamicSource>(Size(100, 200)),
+                       Size(100, 200));
+  const SkBitmap* bitmap = image_skia.bitmap();
+  ASSERT_NE(nullptr, bitmap);
+  EXPECT_FALSE(bitmap->isNull());
+}
+
+TEST_F(ImageSkiaTest, GetBitmapFromEmpty) {
+  // Create an image with 1 representation and remove it so the ImageSkiaStorage
+  // is left with no representations.
+  ImageSkia empty_image(ImageSkiaRep(Size(100, 200), 1.0f));
+  ImageSkia empty_image_copy(empty_image);
+  empty_image.RemoveRepresentation(1.0f);
+
+  // Check that ImageSkia::bitmap() still returns a valid SkBitmap pointer for
+  // the image and all its copies.
+  const SkBitmap* bitmap = empty_image_copy.bitmap();
+  ASSERT_NE(nullptr, bitmap);
+  EXPECT_TRUE(bitmap->isNull());
+  EXPECT_TRUE(bitmap->empty());
+}
+
+TEST_F(ImageSkiaTest, BackedBySameObjectAs) {
+  // Null images should all be backed by the same object (NULL).
+  ImageSkia image;
+  ImageSkia unrelated;
+  EXPECT_TRUE(image.BackedBySameObjectAs(unrelated));
+
+  image.AddRepresentation(gfx::ImageSkiaRep(gfx::Size(10, 10),
+                                            1.0f));
+  ImageSkia copy = image;
+  copy.AddRepresentation(gfx::ImageSkiaRep(gfx::Size(10, 10),
+                                           2.0f));
+  unrelated.AddRepresentation(gfx::ImageSkiaRep(gfx::Size(10, 10),
+                                                1.0f));
+  EXPECT_TRUE(image.BackedBySameObjectAs(copy));
+  EXPECT_FALSE(image.BackedBySameObjectAs(unrelated));
+  EXPECT_FALSE(copy.BackedBySameObjectAs(unrelated));
+}
+
+#if DCHECK_IS_ON()
+TEST_F(ImageSkiaTest, EmptyOnThreadTest) {
+  ImageSkia empty;
+  test::TestOnThread empty_on_thread(&empty);
+  empty_on_thread.Start();
+  empty_on_thread.Join();
+  EXPECT_TRUE(empty_on_thread.can_read());
+  EXPECT_TRUE(empty_on_thread.can_modify());
+}
+
+TEST_F(ImageSkiaTest, StaticOnThreadTest) {
+  ImageSkia image(ImageSkiaRep(Size(100, 200), 1.0f));
+  EXPECT_FALSE(image.IsThreadSafe());
+
+  test::TestOnThread image_on_thread(&image);
+  // an image that was never accessed on this thread can be
+  // read by other thread.
+  image_on_thread.StartAndJoin();
+  EXPECT_TRUE(image_on_thread.can_read());
+  EXPECT_TRUE(image_on_thread.can_modify());
+  EXPECT_FALSE(image.CanRead());
+  EXPECT_FALSE(image.CanModify());
+
+  image.DetachStorageFromSequence();
+  // An image is accessed by this thread,
+  // so other thread cannot read/modify it.
+  image.image_reps();
+  test::TestOnThread image_on_thread2(&image);
+  image_on_thread2.StartAndJoin();
+  EXPECT_FALSE(image_on_thread2.can_read());
+  EXPECT_FALSE(image_on_thread2.can_modify());
+  EXPECT_TRUE(image.CanRead());
+  EXPECT_TRUE(image.CanModify());
+
+  image.DetachStorageFromSequence();
+  ImageSkia deep_copy(image.DeepCopy());
+  EXPECT_FALSE(deep_copy.IsThreadSafe());
+  test::TestOnThread deepcopy_on_thread(&deep_copy);
+  deepcopy_on_thread.StartAndJoin();
+  EXPECT_TRUE(deepcopy_on_thread.can_read());
+  EXPECT_TRUE(deepcopy_on_thread.can_modify());
+  EXPECT_FALSE(deep_copy.CanRead());
+  EXPECT_FALSE(deep_copy.CanModify());
+
+  ImageSkia deep_copy2(image.DeepCopy());
+  EXPECT_EQ(1U, deep_copy2.image_reps().size());
+  // Access it from current thread so that it can't be
+  // accessed from another thread.
+  deep_copy2.image_reps();
+  EXPECT_FALSE(deep_copy2.IsThreadSafe());
+  test::TestOnThread deepcopy2_on_thread(&deep_copy2);
+  deepcopy2_on_thread.StartAndJoin();
+  EXPECT_FALSE(deepcopy2_on_thread.can_read());
+  EXPECT_FALSE(deepcopy2_on_thread.can_modify());
+  EXPECT_TRUE(deep_copy2.CanRead());
+  EXPECT_TRUE(deep_copy2.CanModify());
+
+  image.DetachStorageFromSequence();
+  image.SetReadOnly();
+  // A read-only ImageSkia with no source is thread safe.
+  EXPECT_TRUE(image.IsThreadSafe());
+  test::TestOnThread readonly_on_thread(&image);
+  readonly_on_thread.StartAndJoin();
+  EXPECT_TRUE(readonly_on_thread.can_read());
+  EXPECT_FALSE(readonly_on_thread.can_modify());
+  EXPECT_TRUE(image.CanRead());
+  EXPECT_FALSE(image.CanModify());
+
+  image.DetachStorageFromSequence();
+  image.MakeThreadSafe();
+  EXPECT_TRUE(image.IsThreadSafe());
+  test::TestOnThread threadsafe_on_thread(&image);
+  threadsafe_on_thread.StartAndJoin();
+  EXPECT_TRUE(threadsafe_on_thread.can_read());
+  EXPECT_FALSE(threadsafe_on_thread.can_modify());
+  EXPECT_TRUE(image.CanRead());
+  EXPECT_FALSE(image.CanModify());
+}
+
+TEST_F(ImageSkiaTest, SourceOnThreadTest) {
+  ImageSkia image(std::make_unique<DynamicSource>(Size(100, 200)),
+                  Size(100, 200));
+  EXPECT_FALSE(image.IsThreadSafe());
+
+  test::TestOnThread image_on_thread(&image);
+  image_on_thread.StartAndJoin();
+  // an image that was never accessed on this thread can be
+  // read by other thread.
+  EXPECT_TRUE(image_on_thread.can_read());
+  EXPECT_TRUE(image_on_thread.can_modify());
+  EXPECT_FALSE(image.CanRead());
+  EXPECT_FALSE(image.CanModify());
+
+  image.DetachStorageFromSequence();
+  // An image is accessed by this thread,
+  // so other thread cannot read/modify it.
+  image.image_reps();
+  test::TestOnThread image_on_thread2(&image);
+  image_on_thread2.StartAndJoin();
+  EXPECT_FALSE(image_on_thread2.can_read());
+  EXPECT_FALSE(image_on_thread2.can_modify());
+  EXPECT_TRUE(image.CanRead());
+  EXPECT_TRUE(image.CanModify());
+
+  image.DetachStorageFromSequence();
+  image.SetReadOnly();
+  EXPECT_FALSE(image.IsThreadSafe());
+  test::TestOnThread readonly_on_thread(&image);
+  readonly_on_thread.StartAndJoin();
+  EXPECT_TRUE(readonly_on_thread.can_read());
+  EXPECT_FALSE(readonly_on_thread.can_modify());
+  EXPECT_FALSE(image.CanRead());
+  EXPECT_FALSE(image.CanModify());
+
+  image.DetachStorageFromSequence();
+  image.MakeThreadSafe();
+  EXPECT_TRUE(image.IsThreadSafe());
+  // Check if image reps are generated for supported scale factors.
+  EXPECT_EQ(ImageSkia::GetSupportedScales().size(),
+           image.image_reps().size());
+  test::TestOnThread threadsafe_on_thread(&image);
+  threadsafe_on_thread.StartAndJoin();
+  EXPECT_TRUE(threadsafe_on_thread.can_read());
+  EXPECT_FALSE(threadsafe_on_thread.can_modify());
+  EXPECT_TRUE(image.CanRead());
+  EXPECT_FALSE(image.CanModify());
+}
+#endif  // DCHECK_IS_ON()
+
+TEST_F(ImageSkiaTest, Unscaled) {
+  SkBitmap bitmap;
+
+  // An ImageSkia created with 1x bitmap is unscaled.
+  ImageSkia image_skia = ImageSkia::CreateFrom1xBitmap(bitmap);
+  EXPECT_TRUE(image_skia.GetRepresentation(1.0f).unscaled());
+  ImageSkiaRep rep_2x(Size(100, 100), 2.0f);
+
+  // When reps for other scales are added, the unscaled image
+  // becomes scaled.
+  image_skia.AddRepresentation(rep_2x);
+  EXPECT_FALSE(image_skia.GetRepresentation(1.0f).unscaled());
+  EXPECT_FALSE(image_skia.GetRepresentation(2.0f).unscaled());
+}
+
+namespace {
+
+std::vector<float> GetSortedScaleFactors(const gfx::ImageSkia& image) {
+  const std::vector<ImageSkiaRep>& image_reps = image.image_reps();
+  std::vector<float> scale_factors;
+  for (size_t i = 0; i < image_reps.size(); ++i) {
+    scale_factors.push_back(image_reps[i].scale());
+  }
+  std::sort(scale_factors.begin(), scale_factors.end());
+  return scale_factors;
+}
+
+}  // namespace
+
+TEST_F(ImageSkiaTest, ArbitraryScaleFactor) {
+  // source is owned by |image|
+  DynamicSource* source = new DynamicSource(Size(100, 200));
+  ImageSkia image(base::WrapUnique(source), gfx::Size(100, 200));
+
+  image.GetRepresentation(1.5f);
+  EXPECT_EQ(2.0f, source->GetLastRequestedScaleAndReset());
+  std::vector<ImageSkiaRep> image_reps = image.image_reps();
+  EXPECT_EQ(2u, image_reps.size());
+
+  std::vector<float> scale_factors = GetSortedScaleFactors(image);
+  EXPECT_EQ(1.5f, scale_factors[0]);
+  EXPECT_EQ(2.0f, scale_factors[1]);
+
+  // Requesting 1.75 scale factor also falls back to 2.0f and rescale.
+  // However, the image already has the 2.0f data, so it won't fetch again.
+  image.GetRepresentation(1.75f);
+  EXPECT_EQ(0.0f, source->GetLastRequestedScaleAndReset());
+  image_reps = image.image_reps();
+  EXPECT_EQ(3u, image_reps.size());
+
+  scale_factors = GetSortedScaleFactors(image);
+  EXPECT_EQ(1.5f, scale_factors[0]);
+  EXPECT_EQ(1.75f, scale_factors[1]);
+  EXPECT_EQ(2.0f, scale_factors[2]);
+
+  // Requesting 1.25 scale factor also falls back to 2.0f and rescale.
+  // However, the image already has the 2.0f data, so it won't fetch again.
+  image.GetRepresentation(1.25f);
+  EXPECT_EQ(0.0f, source->GetLastRequestedScaleAndReset());
+  image_reps = image.image_reps();
+  EXPECT_EQ(4u, image_reps.size());
+  scale_factors = GetSortedScaleFactors(image);
+  EXPECT_EQ(1.25f, scale_factors[0]);
+  EXPECT_EQ(1.5f, scale_factors[1]);
+  EXPECT_EQ(1.75f, scale_factors[2]);
+  EXPECT_EQ(2.0f, scale_factors[3]);
+
+  // 1.20 is falled back to 1.0.
+  image.GetRepresentation(1.20f);
+  EXPECT_EQ(1.0f, source->GetLastRequestedScaleAndReset());
+  image_reps = image.image_reps();
+  EXPECT_EQ(6u, image_reps.size());
+  scale_factors = GetSortedScaleFactors(image);
+  EXPECT_EQ(1.0f, scale_factors[0]);
+  EXPECT_EQ(1.2f, scale_factors[1]);
+  EXPECT_EQ(1.25f, scale_factors[2]);
+  EXPECT_EQ(1.5f, scale_factors[3]);
+  EXPECT_EQ(1.75f, scale_factors[4]);
+  EXPECT_EQ(2.0f, scale_factors[5]);
+
+  // Scale factor less than 1.0f will be falled back to 1.0f
+  image.GetRepresentation(0.75f);
+  EXPECT_EQ(0.0f, source->GetLastRequestedScaleAndReset());
+  image_reps = image.image_reps();
+  EXPECT_EQ(7u, image_reps.size());
+
+  scale_factors = GetSortedScaleFactors(image);
+  EXPECT_EQ(0.75f, scale_factors[0]);
+  EXPECT_EQ(1.0f, scale_factors[1]);
+  EXPECT_EQ(1.2f, scale_factors[2]);
+  EXPECT_EQ(1.25f, scale_factors[3]);
+  EXPECT_EQ(1.5f, scale_factors[4]);
+  EXPECT_EQ(1.75f, scale_factors[5]);
+  EXPECT_EQ(2.0f, scale_factors[6]);
+
+  // Scale factor greater than 2.0f is falled back to 2.0f because it's not
+  // supported.
+  image.GetRepresentation(3.0f);
+  EXPECT_EQ(0.0f, source->GetLastRequestedScaleAndReset());
+  image_reps = image.image_reps();
+  EXPECT_EQ(8u, image_reps.size());
+}
+
+TEST_F(ImageSkiaTest, ArbitraryScaleFactorWithMissingResource) {
+  ImageSkia image(
+      std::make_unique<FixedScaleSource>(ImageSkiaRep(Size(100, 200), 1.0f)),
+      Size(100, 200));
+
+  // Requesting 1.5f -- falls back to 2.0f, but couldn't find. It should
+  // look up 1.0f and then rescale it. Note that the rescaled ImageSkiaRep will
+  // have 2.0f scale.
+  const ImageSkiaRep& rep = image.GetRepresentation(1.5f);
+  EXPECT_EQ(1.5f, rep.scale());
+  EXPECT_EQ(2U, image.image_reps().size());
+  EXPECT_EQ(2.0f, image.image_reps()[0].scale());
+  EXPECT_EQ(1.5f, image.image_reps()[1].scale());
+}
+
+TEST_F(ImageSkiaTest, UnscaledImageForArbitraryScaleFactor) {
+  // 0.0f means unscaled.
+  ImageSkia image(
+      std::make_unique<FixedScaleSource>(ImageSkiaRep(Size(100, 200), 0.0f)),
+      Size(100, 200));
+
+  // Requesting 2.0f, which should return 1.0f unscaled image.
+  const ImageSkiaRep& rep = image.GetRepresentation(2.0f);
+  EXPECT_EQ(1.0f, rep.scale());
+  EXPECT_EQ("100x200", rep.pixel_size().ToString());
+  EXPECT_TRUE(rep.unscaled());
+  EXPECT_EQ(1U, image.image_reps().size());
+
+  // Same for any other scale factors.
+  const ImageSkiaRep& rep15 = image.GetRepresentation(1.5f);
+  EXPECT_EQ(1.0f, rep15.scale());
+  EXPECT_EQ("100x200", rep15.pixel_size().ToString());
+  EXPECT_TRUE(rep15.unscaled());
+  EXPECT_EQ(1U, image.image_reps().size());
+
+  const ImageSkiaRep& rep12 = image.GetRepresentation(1.2f);
+  EXPECT_EQ(1.0f, rep12.scale());
+  EXPECT_EQ("100x200", rep12.pixel_size().ToString());
+  EXPECT_TRUE(rep12.unscaled());
+  EXPECT_EQ(1U, image.image_reps().size());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_skia_util_ios.h b/ui/gfx/image/image_skia_util_ios.h
new file mode 100644
index 0000000..6576ff8
--- /dev/null
+++ b/ui/gfx/image/image_skia_util_ios.h
@@ -0,0 +1,41 @@
+// Copyright 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_SKIA_UTIL_IOS_H_
+#define UI_GFX_IMAGE_IMAGE_SKIA_UTIL_IOS_H_
+
+#include "ui/gfx/gfx_export.h"
+
+#ifdef __OBJC__
+@class UIImage;
+#else
+class UIImage;
+#endif
+
+namespace gfx {
+class ImageSkia;
+class ImageSkiaRep;
+
+// Converts to ImageSkia from UIImage.
+GFX_EXPORT gfx::ImageSkia ImageSkiaFromUIImage(UIImage* image);
+
+// Converts to an ImageSkiaRep of |scale_factor| from UIImage.
+// |scale| is passed explicitly in order to allow this method to be used
+// with a |scale| which is not supported by the platform.
+GFX_EXPORT gfx::ImageSkiaRep ImageSkiaRepOfScaleFromUIImage(
+    UIImage* image,
+    float scale);
+
+// Converts to UIImage from ImageSkia. The returned UIImage will be at the scale
+// of the ImageSkiaRep in |image_skia| which most closely matches the device's
+// scale factor (eg Retina iPad -> 2x). Returns an autoreleased UIImage.
+GFX_EXPORT UIImage* UIImageFromImageSkia(const gfx::ImageSkia& image_skia);
+
+// Converts to UIImage from ImageSkiaRep. Returns an autoreleased UIImage.
+GFX_EXPORT UIImage* UIImageFromImageSkiaRep(
+    const gfx::ImageSkiaRep& image_skia_rep);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_SKIA_UTIL_IOS_H_
diff --git a/ui/gfx/image/image_skia_util_ios.mm b/ui/gfx/image/image_skia_util_ios.mm
new file mode 100644
index 0000000..4ecbfdc
--- /dev/null
+++ b/ui/gfx/image/image_skia_util_ios.mm
@@ -0,0 +1,55 @@
+// Copyright 2012 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.
+
+#include "ui/gfx/image/image_skia_util_ios.h"
+
+#import <UIKit/UIKit.h>
+
+#include "base/mac/scoped_cftyperef.h"
+#include "skia/ext/skia_utils_ios.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace gfx {
+
+gfx::ImageSkia ImageSkiaFromUIImage(UIImage* image) {
+  gfx::ImageSkia image_skia;
+  float max_scale = ImageSkia::GetSupportedScales().back();
+  gfx::ImageSkiaRep image_skia_rep = ImageSkiaRepOfScaleFromUIImage(
+      image, max_scale);
+  if (!image_skia_rep.is_null())
+    image_skia.AddRepresentation(image_skia_rep);
+  return image_skia;
+}
+
+gfx::ImageSkiaRep ImageSkiaRepOfScaleFromUIImage(UIImage* image, float scale) {
+  if (!image)
+    return gfx::ImageSkiaRep();
+
+  CGSize size = image.size;
+  CGSize desired_size_for_scale =
+      CGSizeMake(size.width * scale, size.height * scale);
+  SkBitmap bitmap(skia::CGImageToSkBitmap(image.CGImage,
+                                          desired_size_for_scale,
+                                          false));
+  return gfx::ImageSkiaRep(bitmap, scale);
+}
+
+UIImage* UIImageFromImageSkia(const gfx::ImageSkia& image_skia) {
+  return UIImageFromImageSkiaRep(
+      image_skia.GetRepresentation(ImageSkia::GetSupportedScales().back()));
+}
+
+UIImage* UIImageFromImageSkiaRep(const gfx::ImageSkiaRep& image_skia_rep) {
+  if (image_skia_rep.is_null())
+    return nil;
+
+  float scale = image_skia_rep.scale();
+  base::ScopedCFTypeRef<CGColorSpaceRef> color_space(
+      CGColorSpaceCreateDeviceRGB());
+  return skia::SkBitmapToUIImageWithColorSpace(image_skia_rep.GetBitmap(),
+                                               scale, color_space);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_skia_util_mac.h b/ui/gfx/image/image_skia_util_mac.h
new file mode 100644
index 0000000..5d7af20
--- /dev/null
+++ b/ui/gfx/image/image_skia_util_mac.h
@@ -0,0 +1,40 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_SKIA_UTIL_MAC_H_
+#define UI_GFX_IMAGE_IMAGE_SKIA_UTIL_MAC_H_
+
+#include <ApplicationServices/ApplicationServices.h>
+
+#include "ui/gfx/gfx_export.h"
+
+using NSSize = CGSize;
+
+#ifdef __OBJC__
+@class NSImage;
+#else
+class NSImage;
+#endif
+
+namespace gfx {
+class ImageSkia;
+
+// Converts to ImageSkia from NSImage.
+GFX_EXPORT gfx::ImageSkia ImageSkiaFromNSImage(NSImage* image);
+
+// Resizes NSImage to |size| DIP and then converts to ImageSkia.
+GFX_EXPORT gfx::ImageSkia ImageSkiaFromResizedNSImage(NSImage* image,
+                                                      NSSize size);
+
+// Converts to NSImage from ImageSkia.
+GFX_EXPORT NSImage* NSImageFromImageSkia(const gfx::ImageSkia& image_skia);
+
+// Converts to NSImage from given ImageSkia and a color space.
+GFX_EXPORT NSImage* NSImageFromImageSkiaWithColorSpace(
+    const gfx::ImageSkia& image_skia,
+    CGColorSpaceRef color_space);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_SKIA_UTIL_MAC_H_
diff --git a/ui/gfx/image/image_skia_util_mac.mm b/ui/gfx/image/image_skia_util_mac.mm
new file mode 100644
index 0000000..35b3845
--- /dev/null
+++ b/ui/gfx/image/image_skia_util_mac.mm
@@ -0,0 +1,116 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_skia_util_mac.h"
+
+#import <AppKit/AppKit.h>
+#include <stddef.h>
+
+#include <cmath>
+#include <limits>
+#include <memory>
+
+#include "base/mac/mac_util.h"
+#include "base/mac/scoped_nsobject.h"
+#include "skia/ext/skia_utils_mac.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace {
+
+// Returns NSImageRep whose pixel size most closely matches |desired_size|.
+NSImageRep* GetNSImageRepWithPixelSize(NSImage* image,
+                                       NSSize desired_size) {
+  float smallest_diff = std::numeric_limits<float>::max();
+  NSImageRep* closest_match = nil;
+  for (NSImageRep* image_rep in [image representations]) {
+    float diff = std::abs(desired_size.width - [image_rep pixelsWide]) +
+        std::abs(desired_size.height - [image_rep pixelsHigh]);
+    if (diff < smallest_diff) {
+      smallest_diff = diff;
+      closest_match = image_rep;
+    }
+  }
+  return closest_match;
+}
+
+// Returns true if NSImage has no representations
+bool IsNSImageEmpty(NSImage* image) {
+  return ([image representations].count == 0);
+}
+
+}  // namespace
+
+namespace gfx {
+
+gfx::ImageSkia ImageSkiaFromNSImage(NSImage* image) {
+  return ImageSkiaFromResizedNSImage(image, [image size]);
+}
+
+gfx::ImageSkia ImageSkiaFromResizedNSImage(NSImage* image,
+                                           NSSize desired_size) {
+  // Resize and convert to ImageSkia simultaneously to save on computation.
+  // TODO(pkotwicz): Separate resizing NSImage and converting to ImageSkia.
+  // Convert to ImageSkia by finding the most appropriate NSImageRep for
+  // each supported scale factor and resizing if necessary.
+
+  if (IsNSImageEmpty(image))
+    return gfx::ImageSkia();
+
+  std::vector<float> supported_scales = ImageSkia::GetSupportedScales();
+
+  gfx::ImageSkia image_skia;
+  for (size_t i = 0; i < supported_scales.size(); ++i) {
+    float scale = supported_scales[i];
+    NSSize desired_size_for_scale = NSMakeSize(desired_size.width * scale,
+                                               desired_size.height * scale);
+    NSImageRep* ns_image_rep = GetNSImageRepWithPixelSize(image,
+        desired_size_for_scale);
+
+    // TODO(dcheng): Should this function take a color space argument?
+    SkBitmap bitmap(skia::NSImageRepToSkBitmapWithColorSpace(ns_image_rep,
+        desired_size_for_scale, false, base::mac::GetGenericRGBColorSpace()));
+    if (bitmap.isNull())
+      continue;
+
+    image_skia.AddRepresentation(gfx::ImageSkiaRep(bitmap, scale));
+  }
+  return image_skia;
+}
+
+NSImage* NSImageFromImageSkia(const gfx::ImageSkia& image_skia) {
+  if (image_skia.isNull())
+    return nil;
+
+  base::scoped_nsobject<NSImage> image([[NSImage alloc] init]);
+  image_skia.EnsureRepsForSupportedScales();
+  std::vector<gfx::ImageSkiaRep> image_reps = image_skia.image_reps();
+  for (std::vector<gfx::ImageSkiaRep>::const_iterator it = image_reps.begin();
+       it != image_reps.end(); ++it) {
+    [image addRepresentation:skia::SkBitmapToNSBitmapImageRep(it->GetBitmap())];
+  }
+
+  [image setSize:NSMakeSize(image_skia.width(), image_skia.height())];
+  return [image.release() autorelease];
+}
+
+NSImage* NSImageFromImageSkiaWithColorSpace(const gfx::ImageSkia& image_skia,
+                                            CGColorSpaceRef color_space) {
+  if (image_skia.isNull())
+    return nil;
+
+  base::scoped_nsobject<NSImage> image([[NSImage alloc] init]);
+  image_skia.EnsureRepsForSupportedScales();
+  std::vector<gfx::ImageSkiaRep> image_reps = image_skia.image_reps();
+  for (std::vector<gfx::ImageSkiaRep>::const_iterator it = image_reps.begin();
+       it != image_reps.end(); ++it) {
+    [image addRepresentation:skia::SkBitmapToNSBitmapImageRepWithColorSpace(
+                                 it->GetBitmap(), color_space)];
+  }
+
+  [image setSize:NSMakeSize(image_skia.width(), image_skia.height())];
+  return [image.release() autorelease];
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_unittest.cc b/ui/gfx/image/image_unittest.cc
new file mode 100644
index 0000000..94fea8b
--- /dev/null
+++ b/ui/gfx/image/image_unittest.cc
@@ -0,0 +1,708 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+
+#include <utility>
+
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_png_rep.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_unittest_util.h"
+
+#if defined(OS_IOS)
+#include "base/mac/foundation_util.h"
+#include "skia/ext/skia_utils_ios.h"
+#elif defined(OS_MAC)
+#include "base/mac/foundation_util.h"
+#include "skia/ext/skia_utils_mac.h"
+#endif
+
+namespace {
+
+#if defined(OS_APPLE)
+const bool kUsesSkiaNatively = false;
+#else
+const bool kUsesSkiaNatively = true;
+#endif
+
+class ImageTest : public testing::Test {
+ public:
+  ImageTest() {
+    std::vector<float> scales;
+    scales.push_back(1.0f);
+#if !defined(OS_IOS)
+    scales.push_back(2.0f);
+#endif
+    gfx::ImageSkia::SetSupportedScales(scales);
+  }
+};
+
+namespace gt = gfx::test;
+
+TEST_F(ImageTest, EmptyImage) {
+  // Test the default constructor.
+  gfx::Image image;
+  EXPECT_EQ(0U, image.RepresentationCount());
+  EXPECT_TRUE(image.IsEmpty());
+  EXPECT_EQ(0, image.Width());
+  EXPECT_EQ(0, image.Height());
+}
+
+// Test constructing a gfx::Image from an empty PlatformImage.
+TEST_F(ImageTest, EmptyImageFromEmptyPlatformImage) {
+#if defined(OS_APPLE)
+  gfx::Image image1(nullptr);
+  EXPECT_TRUE(image1.IsEmpty());
+  EXPECT_EQ(0, image1.Width());
+  EXPECT_EQ(0, image1.Height());
+  EXPECT_EQ(0U, image1.RepresentationCount());
+#endif
+
+  // gfx::ImageSkia and gfx::ImagePNGRep are available on all platforms.
+  gfx::ImageSkia image_skia;
+  EXPECT_TRUE(image_skia.isNull());
+  gfx::Image image2(image_skia);
+  EXPECT_TRUE(image2.IsEmpty());
+  EXPECT_EQ(0, image2.Width());
+  EXPECT_EQ(0, image2.Height());
+  EXPECT_EQ(0U, image2.RepresentationCount());
+
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  gfx::Image image3(image_png_reps);
+  EXPECT_TRUE(image3.IsEmpty());
+  EXPECT_EQ(0, image3.Width());
+  EXPECT_EQ(0, image3.Height());
+  EXPECT_EQ(0U, image3.RepresentationCount());
+}
+
+// The resulting Image should be empty when it is created using obviously
+// invalid data.
+TEST_F(ImageTest, EmptyImageFromObviouslyInvalidPNGImage) {
+  std::vector<gfx::ImagePNGRep> image_png_reps1;
+  image_png_reps1.push_back(gfx::ImagePNGRep(nullptr, 1.0f));
+  gfx::Image image1(image_png_reps1);
+  EXPECT_TRUE(image1.IsEmpty());
+  EXPECT_EQ(0U, image1.RepresentationCount());
+
+  std::vector<gfx::ImagePNGRep> image_png_reps2;
+  image_png_reps2.push_back(gfx::ImagePNGRep(
+      new base::RefCountedBytes(), 1.0f));
+  gfx::Image image2(image_png_reps2);
+  EXPECT_TRUE(image2.IsEmpty());
+  EXPECT_EQ(0U, image2.RepresentationCount());
+}
+
+// Test the Width, Height and Size of an empty and non-empty image.
+TEST_F(ImageTest, ImageSize) {
+  gfx::Image image;
+  EXPECT_EQ(0, image.Width());
+  EXPECT_EQ(0, image.Height());
+  EXPECT_EQ(gfx::Size(0, 0), image.Size());
+
+  gfx::Image image2(gt::CreateImageSkia(10, 25));
+  EXPECT_EQ(10, image2.Width());
+  EXPECT_EQ(25, image2.Height());
+  EXPECT_EQ(gfx::Size(10, 25), image2.Size());
+}
+
+TEST_F(ImageTest, SkiaToSkia) {
+  gfx::Image image(gt::CreateImageSkia(25, 25));
+  EXPECT_EQ(25, image.Width());
+  EXPECT_EQ(25, image.Height());
+
+  // Test ToImageSkia().
+  const gfx::ImageSkia* image_skia1 = image.ToImageSkia();
+  EXPECT_TRUE(image_skia1);
+  EXPECT_FALSE(image_skia1->isNull());
+  EXPECT_EQ(1U, image.RepresentationCount());
+
+  // Make sure double conversion doesn't happen.
+  const gfx::ImageSkia* image_skia2 = image.ToImageSkia();
+  EXPECT_EQ(1U, image.RepresentationCount());
+
+  // ToImageSkia() should always return the same gfx::ImageSkia.
+  EXPECT_EQ(image_skia1, image_skia2);
+
+  // Test ToSkBitmap().
+  const SkBitmap* bitmap1 = image.ToSkBitmap();
+  const SkBitmap* bitmap2 = image.ToSkBitmap();
+  EXPECT_TRUE(bitmap1);
+  EXPECT_FALSE(bitmap1->isNull());
+  EXPECT_EQ(bitmap1, bitmap2);
+
+  EXPECT_EQ(1U, image.RepresentationCount());
+  EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia));
+  if (!kUsesSkiaNatively)
+    EXPECT_FALSE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
+}
+
+TEST_F(ImageTest, EmptyImageToPNG) {
+  gfx::Image image;
+  scoped_refptr<base::RefCountedMemory> png_bytes = image.As1xPNGBytes();
+  EXPECT_TRUE(png_bytes.get());
+  EXPECT_FALSE(png_bytes->size());
+}
+
+// Check that getting the 1x PNG bytes from images which do not have a 1x
+// representation returns null.
+TEST_F(ImageTest, ImageNo1xToPNG) {
+  // Image with 2x only.
+  const int kSize2x = 50;
+  gfx::ImageSkia image_skia;
+  image_skia.AddRepresentation(gfx::ImageSkiaRep(gt::CreateBitmap(
+      kSize2x, kSize2x), 2.0f));
+  gfx::Image image1(image_skia);
+  scoped_refptr<base::RefCountedMemory> png_bytes1 = image1.As1xPNGBytes();
+  EXPECT_TRUE(png_bytes1.get());
+  EXPECT_FALSE(png_bytes1->size());
+
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(
+      gt::CreatePNGBytes(kSize2x), 2.0f));
+  gfx::Image image2(image_png_reps);
+  EXPECT_FALSE(image2.IsEmpty());
+  EXPECT_EQ(0, image2.Width());
+  EXPECT_EQ(0, image2.Height());
+  scoped_refptr<base::RefCountedMemory> png_bytes2 = image2.As1xPNGBytes();
+  EXPECT_TRUE(png_bytes2.get());
+  EXPECT_FALSE(png_bytes2->size());
+}
+
+// Check that for an image initialized with multi resolution PNG data,
+// As1xPNGBytes() returns the 1x bytes.
+TEST_F(ImageTest, CreateExtractPNGBytes) {
+  const int kSize1x = 25;
+  const int kSize2x = 50;
+
+  scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
+  image_png_reps.push_back(gfx::ImagePNGRep(
+      gt::CreatePNGBytes(kSize2x), 2.0f));
+
+  gfx::Image image(image_png_reps);
+  EXPECT_FALSE(image.IsEmpty());
+  EXPECT_EQ(25, image.Width());
+  EXPECT_EQ(25, image.Height());
+
+  EXPECT_TRUE(std::equal(bytes1x->front(), bytes1x->front() + bytes1x->size(),
+                         image.As1xPNGBytes()->front()));
+}
+
+TEST_F(ImageTest, MultiResolutionImageSkiaToPNG) {
+  const int kSize1x = 25;
+  const int kSize2x = 50;
+
+  SkBitmap bitmap_1x = gt::CreateBitmap(kSize1x, kSize1x);
+  gfx::ImageSkia image_skia;
+  image_skia.AddRepresentation(gfx::ImageSkiaRep(bitmap_1x,
+                                                 1.0f));
+  image_skia.AddRepresentation(gfx::ImageSkiaRep(gt::CreateBitmap(
+      kSize2x, kSize2x), 2.0f));
+  gfx::Image image(image_skia);
+
+  EXPECT_TRUE(
+      gt::ArePNGBytesCloseToBitmap(*image.As1xPNGBytes(), bitmap_1x,
+                                   gt::MaxColorSpaceConversionColorShift()));
+  EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepPNG));
+}
+
+TEST_F(ImageTest, MultiResolutionPNGToImageSkia) {
+  const int kSize1x = 25;
+  const int kSize2x = 50;
+
+  scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
+  scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x);
+
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f));
+  gfx::Image image(image_png_reps);
+
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
+  gfx::ImageSkia image_skia = image.AsImageSkia();
+  EXPECT_TRUE(gt::ArePNGBytesCloseToBitmap(
+      *bytes1x, image_skia.GetRepresentation(1.0f).GetBitmap(),
+      gt::MaxColorSpaceConversionColorShift()));
+  EXPECT_TRUE(gt::ArePNGBytesCloseToBitmap(
+      *bytes2x, image_skia.GetRepresentation(2.0f).GetBitmap(),
+      gt::MaxColorSpaceConversionColorShift()));
+  EXPECT_TRUE(gt::ImageSkiaStructureMatches(image_skia, kSize1x, kSize1x,
+                                            scales));
+#if !defined(OS_IOS)
+  // IOS does not support arbitrary scale factors.
+  gfx::ImageSkiaRep rep_1_6x = image_skia.GetRepresentation(1.6f);
+  ASSERT_FALSE(rep_1_6x.is_null());
+  ASSERT_EQ(1.6f, rep_1_6x.scale());
+  EXPECT_EQ("40x40", rep_1_6x.pixel_size().ToString());
+
+  gfx::ImageSkiaRep rep_0_8x = image_skia.GetRepresentation(0.8f);
+  ASSERT_FALSE(rep_0_8x.is_null());
+  ASSERT_EQ(0.8f, rep_0_8x.scale());
+  EXPECT_EQ("20x20", rep_0_8x.pixel_size().ToString());
+#endif
+}
+
+TEST_F(ImageTest, MultiResolutionPNGToPlatform) {
+  const int kSize1x = 25;
+  const int kSize2x = 50;
+
+  scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
+  scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x);
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
+  image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f));
+
+  gfx::Image from_png(image_png_reps);
+  gfx::Image from_platform(gt::CopyViaPlatformType(from_png));
+#if defined(OS_IOS)
+  // On iOS the platform type (UIImage) only supports one resolution.
+  std::vector<float> scales = gfx::ImageSkia::GetSupportedScales();
+  EXPECT_EQ(scales.size(), 1U);
+  if (scales[0] == 1.0f)
+    EXPECT_TRUE(
+        gt::ArePNGBytesCloseToBitmap(*bytes1x, from_platform.AsBitmap(),
+                                     gt::MaxColorSpaceConversionColorShift()));
+  else if (scales[0] == 2.0f)
+    EXPECT_TRUE(
+        gt::ArePNGBytesCloseToBitmap(*bytes2x, from_platform.AsBitmap(),
+                                     gt::MaxColorSpaceConversionColorShift()));
+  else
+    ADD_FAILURE() << "Unexpected platform scale factor.";
+#else
+  EXPECT_TRUE(
+      gt::ArePNGBytesCloseToBitmap(*bytes1x, from_platform.AsBitmap(),
+                                   gt::MaxColorSpaceConversionColorShift()));
+#endif  // defined(OS_IOS)
+}
+
+
+TEST_F(ImageTest, PlatformToPNGEncodeAndDecode) {
+  gfx::Image image(gt::CreatePlatformImage());
+  scoped_refptr<base::RefCountedMemory> png_data = image.As1xPNGBytes();
+  EXPECT_TRUE(png_data.get());
+  EXPECT_TRUE(png_data->size());
+  EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepPNG));
+
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(png_data, 1.0f));
+  gfx::Image from_png(image_png_reps);
+
+  EXPECT_TRUE(from_png.HasRepresentation(gfx::Image::kImageRepPNG));
+  EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(from_png)));
+}
+
+// The platform types use the platform provided encoding/decoding of PNGs. Make
+// sure these work with the Skia Encode/Decode.
+TEST_F(ImageTest, PNGEncodeFromSkiaDecodeToPlatform) {
+  // Force the conversion sequence skia to png to platform_type.
+  gfx::Image from_bitmap = gfx::Image::CreateFrom1xBitmap(
+      gt::CreateBitmap(25, 25));
+  scoped_refptr<base::RefCountedMemory> png_bytes =
+      from_bitmap.As1xPNGBytes();
+
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f));
+  gfx::Image from_png(image_png_reps);
+
+  gfx::Image from_platform(gt::CopyViaPlatformType(from_png));
+
+  EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(from_platform)));
+  EXPECT_TRUE(
+      gt::ArePNGBytesCloseToBitmap(*png_bytes, from_platform.AsBitmap(),
+                                   gt::MaxColorSpaceConversionColorShift()));
+}
+
+TEST_F(ImageTest, PNGEncodeFromPlatformDecodeToSkia) {
+  // Force the conversion sequence platform_type to png to skia.
+  gfx::Image from_platform(gt::CreatePlatformImage());
+  scoped_refptr<base::RefCountedMemory> png_bytes =
+      from_platform.As1xPNGBytes();
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f));
+  gfx::Image from_png(image_png_reps);
+
+  EXPECT_TRUE(gt::AreBitmapsClose(
+      from_platform.AsBitmap(), from_png.AsBitmap(),
+      gt::MaxColorSpaceConversionColorShift()));
+}
+
+TEST_F(ImageTest, PNGDecodeToSkiaFailure) {
+  scoped_refptr<base::RefCountedBytes> invalid_bytes(
+      new base::RefCountedBytes());
+  invalid_bytes->data().push_back('0');
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(
+      invalid_bytes, 1.0f));
+  gfx::Image image(image_png_reps);
+  gt::CheckImageIndicatesPNGDecodeFailure(image);
+}
+
+TEST_F(ImageTest, PNGDecodeToPlatformFailure) {
+  scoped_refptr<base::RefCountedBytes> invalid_bytes(
+      new base::RefCountedBytes());
+  invalid_bytes->data().push_back('0');
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(gfx::ImagePNGRep(
+      invalid_bytes, 1.0f));
+  gfx::Image from_png(image_png_reps);
+  gfx::Image from_platform(gt::CopyViaPlatformType(from_png));
+  gt::CheckImageIndicatesPNGDecodeFailure(from_platform);
+}
+
+TEST_F(ImageTest, SkiaToPlatform) {
+  gfx::Image image(gt::CreateImageSkia(25, 25));
+  EXPECT_EQ(25, image.Width());
+  EXPECT_EQ(25, image.Height());
+  const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
+
+  EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia));
+  if (!kUsesSkiaNatively)
+    EXPECT_FALSE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
+
+  EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image)));
+  EXPECT_EQ(kRepCount, image.RepresentationCount());
+
+  const SkBitmap* bitmap = image.ToSkBitmap();
+  EXPECT_FALSE(bitmap->isNull());
+  EXPECT_EQ(kRepCount, image.RepresentationCount());
+
+  EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia));
+  EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
+  EXPECT_EQ(25, image.Width());
+  EXPECT_EQ(25, image.Height());
+}
+
+TEST_F(ImageTest, PlatformToSkia) {
+  gfx::Image image(gt::CreatePlatformImage());
+  EXPECT_EQ(25, image.Width());
+  EXPECT_EQ(25, image.Height());
+  const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
+
+  EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
+  if (!kUsesSkiaNatively)
+    EXPECT_FALSE(image.HasRepresentation(gfx::Image::kImageRepSkia));
+
+  const SkBitmap* bitmap = image.ToSkBitmap();
+  EXPECT_TRUE(bitmap);
+  EXPECT_FALSE(bitmap->isNull());
+  EXPECT_EQ(kRepCount, image.RepresentationCount());
+
+  EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image)));
+  EXPECT_EQ(kRepCount, image.RepresentationCount());
+
+  EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia));
+  EXPECT_EQ(25, image.Width());
+  EXPECT_EQ(25, image.Height());
+}
+
+TEST_F(ImageTest, PlatformToPlatform) {
+  gfx::Image image(gt::CreatePlatformImage());
+  EXPECT_EQ(25, image.Width());
+  EXPECT_EQ(25, image.Height());
+  EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image)));
+  EXPECT_EQ(1U, image.RepresentationCount());
+
+  // Make sure double conversion doesn't happen.
+  EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image)));
+  EXPECT_EQ(1U, image.RepresentationCount());
+
+  EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
+  if (!kUsesSkiaNatively)
+    EXPECT_FALSE(image.HasRepresentation(gfx::Image::kImageRepSkia));
+  EXPECT_EQ(25, image.Width());
+  EXPECT_EQ(25, image.Height());
+}
+
+TEST_F(ImageTest, CheckSkiaColor) {
+  gfx::Image image(gt::CreatePlatformImage());
+
+  const SkBitmap* bitmap = image.ToSkBitmap();
+  gt::CheckColors(bitmap->getColor(10, 10), SK_ColorGREEN);
+}
+
+TEST_F(ImageTest, SkBitmapConversionPreservesOrientation) {
+  const int width = 50;
+  const int height = 50;
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(width, height);
+  bitmap.eraseARGB(255, 0, 255, 0);
+
+  // Paint the upper half of the image in red (lower half is in green).
+  SkCanvas canvas(bitmap, SkSurfaceProps{});
+  SkPaint red;
+  red.setColor(SK_ColorRED);
+  canvas.drawRect(SkRect::MakeWH(width, height / 2), red);
+  {
+    SCOPED_TRACE("Checking color of the initial SkBitmap");
+    gt::CheckColors(bitmap.getColor(10, 10), SK_ColorRED);
+    gt::CheckColors(bitmap.getColor(10, 40), SK_ColorGREEN);
+  }
+
+  // Convert from SkBitmap to a platform representation, then check the upper
+  // half of the platform image to make sure it is red, not green.
+  gfx::Image from_skbitmap = gfx::Image::CreateFrom1xBitmap(bitmap);
+  {
+    SCOPED_TRACE("Checking color of the platform image");
+    gt::CheckColors(
+        gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 10),
+        SK_ColorRED);
+    gt::CheckColors(
+        gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 40),
+        SK_ColorGREEN);
+  }
+
+  // Force a conversion back to SkBitmap and check that the upper half is red.
+  gfx::Image from_platform(gt::CopyViaPlatformType(from_skbitmap));
+  const SkBitmap* bitmap2 = from_platform.ToSkBitmap();
+  {
+    SCOPED_TRACE("Checking color after conversion back to SkBitmap");
+    gt::CheckColors(bitmap2->getColor(10, 10), SK_ColorRED);
+    gt::CheckColors(bitmap2->getColor(10, 40), SK_ColorGREEN);
+  }
+}
+
+TEST_F(ImageTest, SkBitmapConversionPreservesTransparency) {
+  const int width = 50;
+  const int height = 50;
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(width, height);
+  bitmap.eraseARGB(0, 0, 255, 0);
+
+  // Paint the upper half of the image in red (lower half is transparent).
+  SkCanvas canvas(bitmap, SkSurfaceProps{});
+  SkPaint red;
+  red.setColor(SK_ColorRED);
+  canvas.drawRect(SkRect::MakeWH(width, height / 2), red);
+  {
+    SCOPED_TRACE("Checking color of the initial SkBitmap");
+    gt::CheckColors(bitmap.getColor(10, 10), SK_ColorRED);
+    gt::CheckIsTransparent(bitmap.getColor(10, 40));
+  }
+
+  // Convert from SkBitmap to a platform representation, then check the upper
+  // half of the platform image to make sure it is red, not green.
+  gfx::Image from_skbitmap = gfx::Image::CreateFrom1xBitmap(bitmap);
+  {
+    SCOPED_TRACE("Checking color of the platform image");
+    gt::CheckColors(
+        gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 10),
+        SK_ColorRED);
+    gt::CheckIsTransparent(
+        gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 40));
+  }
+
+  // Force a conversion back to SkBitmap and check that the upper half is red.
+  gfx::Image from_platform(gt::CopyViaPlatformType(from_skbitmap));
+  const SkBitmap* bitmap2 = from_platform.ToSkBitmap();
+  {
+    SCOPED_TRACE("Checking color after conversion back to SkBitmap");
+    gt::CheckColors(bitmap2->getColor(10, 10), SK_ColorRED);
+    gt::CheckIsTransparent(bitmap.getColor(10, 40));
+  }
+}
+
+TEST_F(ImageTest, Copy) {
+  const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
+
+  gfx::Image image1(gt::CreateImageSkia(25, 25));
+  EXPECT_EQ(25, image1.Width());
+  EXPECT_EQ(25, image1.Height());
+  gfx::Image image2(image1);
+  EXPECT_EQ(25, image2.Width());
+  EXPECT_EQ(25, image2.Height());
+
+  EXPECT_EQ(1U, image1.RepresentationCount());
+  EXPECT_EQ(1U, image2.RepresentationCount());
+  EXPECT_EQ(image1.ToImageSkia(), image2.ToImageSkia());
+
+  EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image2)));
+  EXPECT_EQ(kRepCount, image2.RepresentationCount());
+  EXPECT_EQ(kRepCount, image1.RepresentationCount());
+}
+
+TEST_F(ImageTest, Assign) {
+  gfx::Image image1(gt::CreatePlatformImage());
+  EXPECT_EQ(25, image1.Width());
+  EXPECT_EQ(25, image1.Height());
+  // Assignment must be on a separate line to the declaration in order to test
+  // assignment operator (instead of copy constructor).
+  gfx::Image image2;
+  image2 = image1;
+  EXPECT_EQ(25, image2.Width());
+  EXPECT_EQ(25, image2.Height());
+
+  EXPECT_EQ(1U, image1.RepresentationCount());
+  EXPECT_EQ(1U, image2.RepresentationCount());
+  EXPECT_EQ(image1.ToSkBitmap(), image2.ToSkBitmap());
+}
+
+TEST_F(ImageTest, Move) {
+  const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
+
+  gfx::Image image1(gt::CreateImageSkia(25, 25));
+  EXPECT_EQ(25, image1.Width());
+  EXPECT_EQ(25, image1.Height());
+  gfx::Image image2(std::move(image1));
+  EXPECT_EQ(25, image2.Width());
+  EXPECT_EQ(25, image2.Height());
+
+  EXPECT_EQ(0U, image1.RepresentationCount());
+  EXPECT_EQ(1U, image2.RepresentationCount());
+
+  EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image2)));
+  EXPECT_EQ(0U, image1.RepresentationCount());
+  EXPECT_EQ(kRepCount, image2.RepresentationCount());
+}
+
+TEST_F(ImageTest, MoveAssign) {
+  gfx::Image image1(gt::CreatePlatformImage());
+  EXPECT_EQ(25, image1.Width());
+  EXPECT_EQ(25, image1.Height());
+  // Assignment must be on a separate line to the declaration in order to test
+  // move assignment operator (instead of move constructor).
+  gfx::Image image2;
+  image2 = std::move(image1);
+  EXPECT_EQ(25, image2.Width());
+  EXPECT_EQ(25, image2.Height());
+
+  EXPECT_EQ(0U, image1.RepresentationCount());
+  EXPECT_EQ(1U, image2.RepresentationCount());
+}
+
+TEST_F(ImageTest, Copy_PreservesRepresentation) {
+  const gfx::Size kSize1x(25, 25);
+  const gfx::Size kSize2x(50, 50);
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(
+      gfx::ImagePNGRep(gt::CreatePNGBytes(kSize1x.width()), 1.0f));
+  image_png_reps.push_back(
+      gfx::ImagePNGRep(gt::CreatePNGBytes(kSize2x.width()), 2.0f));
+  gfx::Image image(image_png_reps);
+
+  gfx::ImageSkia image_skia = image.AsImageSkia();
+  EXPECT_EQ(kSize1x, image_skia.size());
+  SkISize size = image_skia.GetRepresentation(2.0f).GetBitmap().dimensions();
+  EXPECT_EQ(kSize2x, gfx::Size(size.fWidth, size.fHeight));
+
+  gfx::Image image2(image);
+  gfx::ImageSkia image_skia2 = image2.AsImageSkia();
+  EXPECT_EQ(kSize1x, image_skia2.size());
+  size = image_skia2.GetRepresentation(2.0f).GetBitmap().dimensions();
+  EXPECT_EQ(kSize2x, gfx::Size(size.fWidth, size.fHeight));
+
+  EXPECT_TRUE(image_skia.BackedBySameObjectAs(image_skia2));
+}
+
+TEST_F(ImageTest, Copy_PreventsDuplication) {
+  const gfx::Size kSize1x(25, 25);
+  const gfx::Size kSize2x(50, 50);
+  std::vector<gfx::ImagePNGRep> image_png_reps;
+  image_png_reps.push_back(
+      gfx::ImagePNGRep(gt::CreatePNGBytes(kSize1x.width()), 1.0f));
+  image_png_reps.push_back(
+      gfx::ImagePNGRep(gt::CreatePNGBytes(kSize2x.width()), 2.0f));
+  gfx::Image image(image_png_reps);
+
+  gfx::Image image2(image);
+
+  gfx::ImageSkia image_skia = image.AsImageSkia();
+  EXPECT_EQ(kSize1x, image_skia.size());
+  SkISize size = image_skia.GetRepresentation(2.0f).GetBitmap().dimensions();
+  EXPECT_EQ(kSize2x, gfx::Size(size.fWidth, size.fHeight));
+
+  gfx::ImageSkia image_skia2 = image2.AsImageSkia();
+  EXPECT_EQ(kSize1x, image_skia2.size());
+  size = image_skia2.GetRepresentation(2.0f).GetBitmap().dimensions();
+  EXPECT_EQ(kSize2x, gfx::Size(size.fWidth, size.fHeight));
+
+  EXPECT_TRUE(image_skia.BackedBySameObjectAs(image_skia2));
+}
+
+TEST_F(ImageTest, Copy_PreservesBackingStore) {
+  const gfx::Size kSize1x(25, 25);
+
+  gfx::Image image(gt::CreateImageSkia(kSize1x.width(), kSize1x.height()));
+  gfx::Image image2 = gfx::Image::CreateFrom1xBitmap(image.AsBitmap());
+
+  gfx::ImageSkia image_skia = image.AsImageSkia();
+  gfx::ImageSkia image_skia2 = image2.AsImageSkia();
+
+  // Because we haven't copied the image representation (scale info, etc.) the
+  // new Skia image isn't backed by the same object, but it should still contain
+  // the same bitmap data.
+  EXPECT_FALSE(image_skia2.BackedBySameObjectAs(image_skia));
+  EXPECT_EQ(image_skia.bitmap()->getPixels(),
+            image_skia2.bitmap()->getPixels());
+}
+
+TEST_F(ImageTest, MultiResolutionImageSkia) {
+  const int kWidth1x = 10;
+  const int kHeight1x = 12;
+  const int kWidth2x = 20;
+  const int kHeight2x = 24;
+
+  gfx::ImageSkia image_skia;
+  image_skia.AddRepresentation(gfx::ImageSkiaRep(
+      gt::CreateBitmap(kWidth1x, kHeight1x),
+      1.0f));
+  image_skia.AddRepresentation(gfx::ImageSkiaRep(
+      gt::CreateBitmap(kWidth2x, kHeight2x),
+      2.0f));
+
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
+  EXPECT_TRUE(gt::ImageSkiaStructureMatches(image_skia, kWidth1x, kHeight1x,
+                                            scales));
+
+  // Check that the image has a single representation.
+  gfx::Image image(image_skia);
+  EXPECT_EQ(1u, image.RepresentationCount());
+  EXPECT_EQ(kWidth1x, image.Width());
+  EXPECT_EQ(kHeight1x, image.Height());
+}
+
+TEST_F(ImageTest, RemoveFromMultiResolutionImageSkia) {
+  const int kWidth2x = 20;
+  const int kHeight2x = 24;
+
+  gfx::ImageSkia image_skia;
+
+  image_skia.AddRepresentation(gfx::ImageSkiaRep(
+      gt::CreateBitmap(kWidth2x, kHeight2x), 2.0f));
+  EXPECT_EQ(1u, image_skia.image_reps().size());
+
+  image_skia.RemoveRepresentation(1.0f);
+  EXPECT_EQ(1u, image_skia.image_reps().size());
+
+  image_skia.RemoveRepresentation(2.0f);
+  EXPECT_EQ(0u, image_skia.image_reps().size());
+}
+
+// Tests that gfx::Image does indeed take ownership of the SkBitmap it is
+// passed.
+TEST_F(ImageTest, OwnershipTest) {
+  gfx::Image image;
+  {
+    SkBitmap bitmap(gt::CreateBitmap(10, 10));
+    EXPECT_TRUE(!bitmap.isNull());
+    image = gfx::Image(gfx::ImageSkia(
+        gfx::ImageSkiaRep(bitmap, 1.0f)));
+  }
+  EXPECT_TRUE(!image.ToSkBitmap()->isNull());
+}
+
+// Integration tests with UI toolkit frameworks require linking against the
+// Views library and cannot be here (ui_base_unittests doesn't include it). They
+// instead live in /chrome/browser/ui/tests/ui_gfx_image_unittest.cc.
+
+}  // namespace
diff --git a/ui/gfx/image/image_unittest_util.cc b/ui/gfx/image/image_unittest_util.cc
new file mode 100644
index 0000000..37f3b83
--- /dev/null
+++ b/ui/gfx/image/image_unittest_util.cc
@@ -0,0 +1,293 @@
+// Copyright (c) 2012 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.
+
+// Because the unit tests for gfx::Image are spread across multiple
+// implementation files, this header contains the reusable components.
+
+#include "ui/gfx/image/image_unittest_util.h"
+
+#include <stddef.h>
+
+#include <cmath>
+#include <memory>
+
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/image/image_skia.h"
+
+#if defined(OS_IOS)
+#include "base/mac/scoped_cftyperef.h"
+#include "skia/ext/skia_utils_ios.h"
+#elif defined(OS_MAC)
+#include "base/mac/mac_util.h"
+#include "skia/ext/skia_utils_mac.h"
+#endif
+
+namespace gfx {
+namespace test {
+
+namespace {
+
+// The maximum color shift in the red, green, and blue components caused by
+// converting a gfx::Image between colorspaces. Color shifts occur when
+// converting between NSImage & UIImage to ImageSkia. Determined by trial and
+// error.
+const int kMaxColorSpaceConversionColorShift = 40;
+
+bool ColorComponentsClose(SkColor component1,
+                          SkColor component2,
+                          int max_deviation) {
+  int c1 = static_cast<int>(component1);
+  int c2 = static_cast<int>(component2);
+  return std::abs(c1 - c2) <= max_deviation;
+}
+
+bool ColorsClose(SkColor color1, SkColor color2, int max_deviation) {
+  // Be tolerant of floating point rounding and lossy color space conversions.
+  return ColorComponentsClose(SkColorGetR(color1), SkColorGetR(color2),
+                              max_deviation) &&
+         ColorComponentsClose(SkColorGetG(color1), SkColorGetG(color2),
+                              max_deviation) &&
+         ColorComponentsClose(SkColorGetB(color1), SkColorGetB(color2),
+                              max_deviation) &&
+         ColorComponentsClose(SkColorGetA(color1), SkColorGetA(color2),
+                              max_deviation);
+}
+
+}  // namespace
+
+std::vector<float> Get1xAnd2xScales() {
+  std::vector<float> scales;
+  scales.push_back(1.0f);
+  scales.push_back(2.0f);
+  return scales;
+}
+
+const SkBitmap CreateBitmap(int width, int height) {
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(width, height);
+  bitmap.eraseARGB(255, 0, 255, 0);
+  return bitmap;
+}
+
+gfx::ImageSkia CreateImageSkia(int width, int height) {
+  return gfx::ImageSkia::CreateFrom1xBitmap(CreateBitmap(width, height));
+}
+
+scoped_refptr<base::RefCountedMemory> CreatePNGBytes(int edge_size) {
+  SkBitmap bitmap = CreateBitmap(edge_size, edge_size);
+  scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes());
+  PNGCodec::EncodeBGRASkBitmap(bitmap, false, &bytes->data());
+  return bytes;
+}
+
+gfx::Image CreateImage() {
+  return CreateImage(100, 50);
+}
+
+gfx::Image CreateImage(int width, int height) {
+  return gfx::Image::CreateFrom1xBitmap(CreateBitmap(width, height));
+}
+
+bool AreImagesEqual(const gfx::Image& img1, const gfx::Image& img2) {
+  return AreImagesClose(img1, img2, 0);
+}
+
+bool AreImagesClose(const gfx::Image& img1,
+                    const gfx::Image& img2,
+                    int max_deviation) {
+  img1.AsImageSkia().EnsureRepsForSupportedScales();
+  img2.AsImageSkia().EnsureRepsForSupportedScales();
+  std::vector<gfx::ImageSkiaRep> img1_reps = img1.AsImageSkia().image_reps();
+  gfx::ImageSkia image_skia2 = img2.AsImageSkia();
+  if (image_skia2.image_reps().size() != img1_reps.size())
+    return false;
+
+  for (size_t i = 0; i < img1_reps.size(); ++i) {
+    float scale = img1_reps[i].scale();
+    const gfx::ImageSkiaRep& image_rep2 = image_skia2.GetRepresentation(scale);
+    if (image_rep2.scale() != scale ||
+        !AreBitmapsClose(img1_reps[i].GetBitmap(), image_rep2.GetBitmap(),
+                         max_deviation)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool AreBitmapsEqual(const SkBitmap& bmp1, const SkBitmap& bmp2) {
+  return AreBitmapsClose(bmp1, bmp2, 0);
+}
+
+bool AreBitmapsClose(const SkBitmap& bmp1,
+                     const SkBitmap& bmp2,
+                     int max_deviation) {
+  if (bmp1.isNull() && bmp2.isNull())
+    return true;
+
+  if (bmp1.width() != bmp2.width() ||
+      bmp1.height() != bmp2.height() ||
+      bmp1.colorType() != kN32_SkColorType ||
+      bmp2.colorType() != kN32_SkColorType) {
+    return false;
+  }
+
+  if (!bmp1.getPixels() || !bmp2.getPixels())
+    return false;
+
+  for (int y = 0; y < bmp1.height(); ++y) {
+    for (int x = 0; x < bmp1.width(); ++x) {
+      if (!ColorsClose(bmp1.getColor(x,y), bmp2.getColor(x,y), max_deviation))
+        return false;
+    }
+  }
+
+  return true;
+}
+
+bool ArePNGBytesCloseToBitmap(base::span<const uint8_t> bytes,
+                              const SkBitmap& bitmap,
+                              int max_deviation) {
+  SkBitmap decoded;
+  if (!PNGCodec::Decode(bytes.data(), bytes.size(), &decoded))
+    return bitmap.isNull();
+
+  return AreBitmapsClose(bitmap, decoded, max_deviation);
+}
+
+int MaxColorSpaceConversionColorShift() {
+  return kMaxColorSpaceConversionColorShift;
+}
+
+void CheckImageIndicatesPNGDecodeFailure(const gfx::Image& image) {
+  SkBitmap bitmap = image.AsBitmap();
+  EXPECT_FALSE(bitmap.isNull());
+  EXPECT_LE(16, bitmap.width());
+  EXPECT_LE(16, bitmap.height());
+  CheckColors(bitmap.getColor(10, 10), SK_ColorRED);
+}
+
+bool ImageSkiaStructureMatches(
+    const gfx::ImageSkia& image_skia,
+    int width,
+    int height,
+    const std::vector<float>& scales) {
+  if (image_skia.isNull() ||
+      image_skia.width() != width ||
+      image_skia.height() != height ||
+      image_skia.image_reps().size() != scales.size()) {
+    return false;
+  }
+
+  for (size_t i = 0; i < scales.size(); ++i) {
+    gfx::ImageSkiaRep image_rep =
+        image_skia.GetRepresentation(scales[i]);
+    if (image_rep.is_null() || image_rep.scale() != scales[i])
+      return false;
+
+    if (image_rep.pixel_width() != static_cast<int>(width * scales[i]) ||
+        image_rep.pixel_height() != static_cast<int>(height * scales[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IsEmpty(const gfx::Image& image) {
+  const SkBitmap& bmp = *image.ToSkBitmap();
+  return bmp.isNull() ||
+         (bmp.width() == 0 && bmp.height() == 0);
+}
+
+PlatformImage CreatePlatformImage() {
+  SkBitmap bitmap(CreateBitmap(25, 25));
+#if defined(OS_IOS)
+  float scale = ImageSkia::GetMaxSupportedScale();
+
+  if (scale > 1.0) {
+    // Always create a 25pt x 25pt image.
+    int size = static_cast<int>(25 * scale);
+    bitmap = CreateBitmap(size, size);
+  }
+
+  base::ScopedCFTypeRef<CGColorSpaceRef> color_space(
+      CGColorSpaceCreateDeviceRGB());
+  UIImage* image =
+      skia::SkBitmapToUIImageWithColorSpace(bitmap, scale, color_space);
+  return image;
+#elif defined(OS_MAC)
+  NSImage* image = skia::SkBitmapToNSImageWithColorSpace(
+      bitmap, base::mac::GetGenericRGBColorSpace());
+  return image;
+#else
+  return gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
+#endif
+}
+
+gfx::Image::RepresentationType GetPlatformRepresentationType() {
+#if defined(OS_IOS)
+  return gfx::Image::kImageRepCocoaTouch;
+#elif defined(OS_MAC)
+  return gfx::Image::kImageRepCocoa;
+#else
+  return gfx::Image::kImageRepSkia;
+#endif
+}
+
+PlatformImage ToPlatformType(const gfx::Image& image) {
+#if defined(OS_IOS)
+  return image.ToUIImage();
+#elif defined(OS_MAC)
+  return image.ToNSImage();
+#else
+  return image.AsImageSkia();
+#endif
+}
+
+gfx::Image CopyViaPlatformType(const gfx::Image& image) {
+#if defined(OS_IOS)
+  return gfx::Image(image.ToUIImage());
+#elif defined(OS_MAC)
+  return gfx::Image(image.ToNSImage());
+#else
+  return gfx::Image(image.AsImageSkia());
+#endif
+}
+
+#if defined(OS_APPLE)
+// Defined in image_unittest_util_mac.mm.
+#else
+SkColor GetPlatformImageColor(PlatformImage image, int x, int y) {
+  return image.bitmap()->getColor(x, y);
+}
+#endif
+
+void CheckColors(SkColor color1, SkColor color2) {
+  EXPECT_TRUE(ColorsClose(color1, color2, MaxColorSpaceConversionColorShift()));
+}
+
+void CheckIsTransparent(SkColor color) {
+  EXPECT_LT(SkColorGetA(color) / 255.0, 0.05);
+}
+
+bool IsPlatformImageValid(PlatformImage image) {
+#if defined(OS_APPLE)
+  return image != NULL;
+#else
+  return !image.isNull();
+#endif
+}
+
+bool PlatformImagesEqual(PlatformImage image1, PlatformImage image2) {
+#if defined(OS_APPLE)
+  return image1 == image2;
+#else
+  return image1.BackedBySameObjectAs(image2);
+#endif
+}
+
+}  // namespace test
+}  // namespace gfx
diff --git a/ui/gfx/image/image_unittest_util.h b/ui/gfx/image/image_unittest_util.h
new file mode 100644
index 0000000..51e5a52
--- /dev/null
+++ b/ui/gfx/image/image_unittest_util.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2012 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.
+
+// Because the unit tests for gfx::Image are spread across multiple
+// implementation files, this header contains the reusable components.
+
+#ifndef UI_GFX_IMAGE_IMAGE_UNITTEST_UTIL_H_
+#define UI_GFX_IMAGE_IMAGE_UNITTEST_UTIL_H_
+
+#include <stdint.h>
+
+#include "base/containers/span.h"
+#include "build/build_config.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/image/image.h"
+
+namespace gfx {
+namespace test {
+
+#if defined(OS_IOS)
+typedef UIImage* PlatformImage;
+#elif defined(OS_MAC)
+typedef NSImage* PlatformImage;
+#else
+typedef gfx::ImageSkia PlatformImage;
+#endif
+
+std::vector<float> Get1xAnd2xScales();
+
+// Create a bitmap of |width|x|height|.
+const SkBitmap CreateBitmap(int width, int height);
+
+// Creates an ImageSkia of |width|x|height| DIP with bitmap data for an
+// arbitrary scale factor.
+gfx::ImageSkia CreateImageSkia(int width, int height);
+
+// Returns PNG encoded bytes for a bitmap of |edge_size|x|edge_size|.
+scoped_refptr<base::RefCountedMemory> CreatePNGBytes(int edge_size);
+
+// TODO(rohitrao): Remove the no-argument version of CreateImage().
+gfx::Image CreateImage();
+gfx::Image CreateImage(int width, int height);
+
+// Returns true if the images are equal. Converts the images to ImageSkia to
+// compare them.
+bool AreImagesEqual(const gfx::Image& image1, const gfx::Image& image2);
+
+// Returns true if the images are visually similar. |max_deviation| is the
+// maximum color shift in each of the red, green, and blue components for the
+// images to be considered similar. Converts to ImageSkia to compare the images.
+bool AreImagesClose(const gfx::Image& image1,
+                    const gfx::Image& image2,
+                    int max_deviation);
+
+// Returns true if the bitmaps are equal.
+bool AreBitmapsEqual(const SkBitmap& bitmap1, const SkBitmap& bitmap2);
+
+// Returns true if the bitmaps are visually similar.
+bool AreBitmapsClose(const SkBitmap& bitmap1,
+                     const SkBitmap& bitmap2,
+                     int max_deviation);
+
+// Returns true if the passed in PNG bitmap is visually similar to the passed in
+// SkBitmap.
+bool ArePNGBytesCloseToBitmap(base::span<const uint8_t> bytes,
+                              const SkBitmap& bitmap,
+                              int max_deviation);
+
+// Returns the maximum color shift in the red, green, and blue components caused
+// by converting a gfx::Image between colorspaces. Color shifts occur when
+// converting between NSImage & UIImage to ImageSkia.
+int MaxColorSpaceConversionColorShift();
+
+// An image which was not successfully decoded to PNG should be a red bitmap.
+// Fails if the bitmap is not red.
+void CheckImageIndicatesPNGDecodeFailure(const gfx::Image& image);
+
+// Returns true if the structure of |image_skia| matches the structure
+// described by |width|, |height|, and |scale_factors|.
+// The structure matches if:
+// - |image_skia| is non null.
+// - |image_skia| has ImageSkiaReps of |scale_factors|.
+// - Each of the ImageSkiaReps has a pixel size of |image_skia|.size() *
+//   scale_factor.
+bool ImageSkiaStructureMatches(
+    const gfx::ImageSkia& image_skia,
+    int width,
+    int height,
+    const std::vector<float>& scale_factors);
+
+bool IsEmpty(const gfx::Image& image);
+
+PlatformImage CreatePlatformImage();
+
+gfx::Image::RepresentationType GetPlatformRepresentationType();
+
+PlatformImage ToPlatformType(const gfx::Image& image);
+gfx::Image CopyViaPlatformType(const gfx::Image& image);
+
+SkColor GetPlatformImageColor(PlatformImage image, int x, int y);
+void CheckColors(SkColor color1, SkColor color2);
+void CheckIsTransparent(SkColor color);
+
+bool IsPlatformImageValid(PlatformImage image);
+
+bool PlatformImagesEqual(PlatformImage image1, PlatformImage image2);
+
+}  // namespace test
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_UNITTEST_UTIL_H_
diff --git a/ui/gfx/image/image_unittest_util_ios.mm b/ui/gfx/image/image_unittest_util_ios.mm
new file mode 100644
index 0000000..ba55030
--- /dev/null
+++ b/ui/gfx/image/image_unittest_util_ios.mm
@@ -0,0 +1,42 @@
+// Copyright 2012 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.
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <UIKit/UIKit.h>
+
+#include "base/mac/scoped_cftyperef.h"
+#include "skia/ext/skia_utils_ios.h"
+#include "ui/gfx/image/image_unittest_util.h"
+
+namespace gfx {
+namespace test {
+
+// The |x| and |y| coordinates are interpreted as scale-independent in ios.
+SkColor GetPlatformImageColor(PlatformImage image, int x, int y) {
+  // Start by extracting the target pixel into a 1x1 CGImage.
+  base::ScopedCFTypeRef<CGImageRef> pixel_image(CGImageCreateWithImageInRect(
+      image.CGImage, CGRectMake(x * image.scale, y * image.scale, 1, 1)));
+
+  // Draw that pixel into a 1x1 bitmap context.
+  base::ScopedCFTypeRef<CGColorSpaceRef> color_space(
+      CGColorSpaceCreateDeviceRGB());
+  base::ScopedCFTypeRef<CGContextRef> bitmap_context(CGBitmapContextCreate(
+      /*data=*/ NULL,
+      /*width=*/ 1,
+      /*height=*/ 1,
+      /*bitsPerComponent=*/ 8,
+      /*bytesPerRow=*/ 4,
+      color_space,
+      kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host));
+  CGContextDrawImage(bitmap_context, CGRectMake(0, 0, 1, 1), pixel_image);
+
+  // The CGBitmapContext has the same memory layout as SkColor, so we can just
+  // read an SkColor straight out of the context.
+  SkColor* data =
+      reinterpret_cast<SkColor*>(CGBitmapContextGetData(bitmap_context));
+  return *data;
+}
+
+}  // namespace test
+}  // namespace gfx
diff --git a/ui/gfx/image/image_unittest_util_mac.mm b/ui/gfx/image/image_unittest_util_mac.mm
new file mode 100644
index 0000000..99aaf6a
--- /dev/null
+++ b/ui/gfx/image/image_unittest_util_mac.mm
@@ -0,0 +1,25 @@
+// Copyright (c) 2012 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.
+
+#import <AppKit/AppKit.h>
+
+#include "skia/ext/skia_utils_mac.h"
+#include "ui/gfx/image/image_unittest_util.h"
+
+namespace gfx {
+namespace test {
+
+SkColor GetPlatformImageColor(PlatformImage image, int x, int y) {
+  // AppKit's coordinate system is flipped.
+  y = [image size].height - y;
+
+  [image lockFocus];
+  NSColor* color = NSReadPixel(NSMakePoint(x, y));
+  [image unlockFocus];
+  return skia::NSDeviceColorToSkColor(
+      [color colorUsingColorSpace:[NSColorSpace deviceRGBColorSpace]]);
+}
+
+}  // namespace test
+}  // namespace gfx
diff --git a/ui/gfx/image/image_util.cc b/ui/gfx/image/image_util.cc
new file mode 100644
index 0000000..ce94c77
--- /dev/null
+++ b/ui/gfx/image/image_util.cc
@@ -0,0 +1,160 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_util.h"
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <memory>
+
+#include "base/cxx17_backports.h"
+#include "build/build_config.h"
+#include "skia/ext/image_operations.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/codec/jpeg_codec.h"
+#include "ui/gfx/codec/webp_codec.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/resize_image_dimensions.h"
+
+namespace {
+
+// Returns whether column |x| of |bitmap| has any "visible pixels", where
+// "visible" is defined as having an opactiy greater than an arbitrary small
+// value.
+bool ColumnHasVisiblePixels(const SkBitmap& bitmap, int x) {
+  const SkAlpha kMinimumVisibleOpacity = 12;
+  for (int y = 0; y < bitmap.height(); ++y) {
+    if (SkColorGetA(bitmap.getColor(x, y)) > kMinimumVisibleOpacity)
+      return true;
+  }
+  return false;
+}
+
+}  // namespace
+
+namespace gfx {
+
+// The iOS implementations of the JPEG functions are in image_util_ios.mm.
+#if !defined(OS_IOS)
+
+Image ImageFrom1xJPEGEncodedData(const unsigned char* input,
+                                 size_t input_size) {
+  std::unique_ptr<SkBitmap> bitmap(gfx::JPEGCodec::Decode(input, input_size));
+  if (bitmap.get())
+    return Image::CreateFrom1xBitmap(*bitmap);
+
+  return Image();
+}
+
+Image ResizedImageForSearchByImage(const Image& image) {
+  return ResizedImageForSearchByImageSkiaRepresentation(image);
+}
+
+Image ResizedImageForMaxDimensions(const Image& image,
+                                   int max_width,
+                                   int max_height,
+                                   int max_area) {
+  return ResizedImageForMaxDimensionsSkiaRepresentation(image, max_width,
+                                                        max_height, max_area);
+}
+
+// The MacOS implementation of this function is in image_utils_mac.mm.
+#if !defined(OS_MAC)
+bool JPEG1xEncodedDataFromImage(const Image& image,
+                                int quality,
+                                std::vector<unsigned char>* dst) {
+  return JPEG1xEncodedDataFromSkiaRepresentation(image, quality, dst);
+}
+#endif  // !defined(OS_MAC)
+
+bool JPEG1xEncodedDataFromSkiaRepresentation(const Image& image,
+                                             int quality,
+                                             std::vector<unsigned char>* dst) {
+  const gfx::ImageSkiaRep& image_skia_rep =
+      image.AsImageSkia().GetRepresentation(1.0f);
+  if (image_skia_rep.scale() != 1.0f)
+    return false;
+
+  const SkBitmap& bitmap = image_skia_rep.GetBitmap();
+  if (!bitmap.readyToDraw())
+    return false;
+
+  return gfx::JPEGCodec::Encode(bitmap, quality, dst);
+}
+
+bool WebpEncodedDataFromImage(const Image& image,
+                              int quality,
+                              std::vector<unsigned char>* dst) {
+  const SkBitmap bitmap = image.AsBitmap();
+  return gfx::WebpCodec::Encode(bitmap, quality, dst);
+}
+
+Image ResizedImageForSearchByImageSkiaRepresentation(const Image& image) {
+  return ResizedImageForMaxDimensionsSkiaRepresentation(
+      image, kSearchByImageMaxImageWidth, kSearchByImageMaxImageHeight,
+      kSearchByImageMaxImageArea);
+}
+
+Image ResizedImageForMaxDimensionsSkiaRepresentation(const Image& image,
+                                                     int max_width,
+                                                     int max_height,
+                                                     int max_area) {
+  const gfx::ImageSkiaRep& image_skia_rep =
+      image.AsImageSkia().GetRepresentation(1.0f);
+  if (image_skia_rep.scale() != 1.0f)
+    return image;
+
+  const SkBitmap& bitmap = image_skia_rep.GetBitmap();
+  if (bitmap.height() * bitmap.width() > max_area &&
+      (bitmap.width() > max_width || bitmap.height() > max_height)) {
+    double scale = std::min(static_cast<double>(max_width) / bitmap.width(),
+                            static_cast<double>(max_height) / bitmap.height());
+    int width = base::clamp<int>(scale * bitmap.width(), 1, max_width);
+    int height = base::clamp<int>(scale * bitmap.height(), 1, max_height);
+    SkBitmap new_bitmap = skia::ImageOperations::Resize(
+        bitmap, skia::ImageOperations::RESIZE_GOOD, width, height);
+    return Image(ImageSkia(ImageSkiaRep(new_bitmap, 0.0f)));
+  }
+
+  return image;
+}
+#endif  // !defined(OS_IOS)
+
+void GetVisibleMargins(const ImageSkia& image, int* left, int* right) {
+  *left = 0;
+  *right = 0;
+  if (!image.HasRepresentation(1.f))
+    return;
+  const SkBitmap& bitmap = image.GetRepresentation(1.f).GetBitmap();
+  if (bitmap.drawsNothing() || bitmap.isOpaque())
+    return;
+
+  int x = 0;
+  for (; x < bitmap.width(); ++x) {
+    if (ColumnHasVisiblePixels(bitmap, x)) {
+      *left = x;
+      break;
+    }
+  }
+
+  if (x == bitmap.width()) {
+    // Image is fully transparent.  Divide the width in half, giving the leading
+    // region the extra pixel for odd widths.
+    *left = (bitmap.width() + 1) / 2;
+    *right = bitmap.width() - *left;
+    return;
+  }
+
+  // Since we already know column *left is non-transparent, we can avoid
+  // rechecking that column; hence the '>' here.
+  for (x = bitmap.width() - 1; x > *left; --x) {
+    if (ColumnHasVisiblePixels(bitmap, x))
+      break;
+  }
+  *right = bitmap.width() - 1 - x;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/image_util.h b/ui/gfx/image/image_util.h
new file mode 100644
index 0000000..aa954a2
--- /dev/null
+++ b/ui/gfx/image/image_util.h
@@ -0,0 +1,79 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_IMAGE_UTIL_H_
+#define UI_GFX_IMAGE_IMAGE_UTIL_H_
+
+#include <stddef.h>
+
+#include <vector>
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+class Image;
+class ImageSkia;
+}
+
+namespace gfx {
+
+// Creates an image from the given JPEG-encoded input. If there was an error
+// creating the image, returns an IsEmpty() Image.
+GFX_EXPORT Image ImageFrom1xJPEGEncodedData(const unsigned char* input,
+                                            size_t input_size);
+
+// Fills the |dst| vector with JPEG-encoded bytes of the 1x representation of
+// the given image.
+// Returns true if the image has a 1x representation and the 1x representation
+// was encoded successfully.
+// |quality| determines the compression level, 0 == lowest, 100 == highest.
+// Returns true if the Image was encoded successfully.
+GFX_EXPORT bool JPEG1xEncodedDataFromImage(const Image& image,
+                                           int quality,
+                                           std::vector<unsigned char>* dst);
+
+bool JPEG1xEncodedDataFromSkiaRepresentation(const Image& image,
+                                             int quality,
+                                             std::vector<unsigned char>* dst);
+
+// Fills the |dst| vector with WebP-encoded bytes of the the given image.
+// Returns true if the image was encoded (lossy) successfully.
+// |quality| determines the visual quality, 0 == lowest, 100 == highest.
+// Returns true if the Image was encoded successfully.
+GFX_EXPORT bool WebpEncodedDataFromImage(const Image& image,
+                                         int quality,
+                                         std::vector<unsigned char>* dst);
+
+// Computes the width of any nearly-transparent regions at the sides of the
+// image and returns them in |left| and |right|.  This checks each column of
+// pixels from the outsides in, looking for anything with alpha above a
+// reasonably small value.  For a fully-opaque image, the margins will thus be
+// (0, 0); for a fully-transparent image, the margins will be
+// (width / 2, width / 2), with |left| getting the extra pixel for odd widths.
+GFX_EXPORT void GetVisibleMargins(const ImageSkia& image,
+                                  int* left,
+                                  int* right);
+
+// Downsizes the image if its area exceeds kSearchByImageMaxImageArea AND
+// (either its width exceeds kSearchByImageMaxImageWidth OR its height exceeds
+// kSearchByImageMaxImageHeight) in preparation for searching.
+GFX_EXPORT Image ResizedImageForSearchByImage(const Image& image);
+
+// Downsizes the image if its area exceeds the max_area defined AND (either its
+// width exceeds the max_width defined OR its height exceeds the max_height
+// defined).
+GFX_EXPORT Image ResizedImageForMaxDimensions(const Image& image,
+                                              int max_width,
+                                              int max_height,
+                                              int max_area);
+
+Image ResizedImageForSearchByImageSkiaRepresentation(const Image& image);
+Image ResizedImageForMaxDimensionsSkiaRepresentation(const Image& image,
+                                                     int max_width,
+                                                     int max_height,
+                                                     int max_area);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_IMAGE_UTIL_H_
diff --git a/ui/gfx/image/image_util_ios.mm b/ui/gfx/image/image_util_ios.mm
new file mode 100644
index 0000000..81ac792
--- /dev/null
+++ b/ui/gfx/image/image_util_ios.mm
@@ -0,0 +1,114 @@
+// Copyright (c) 2012 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.
+
+#import <UIKit/UIKit.h>
+
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_util.h"
+#include "ui/gfx/image/resize_image_dimensions.h"
+
+
+namespace {
+// Copied from GTMUIImage+Resize in //third_party/google_toolbox_for_mac to
+// avoid depending on other GTM* classes unnecessarily.
+UIImage* ResizeUIImage(UIImage* image,
+                       CGSize target_size,
+                       BOOL preserve_aspect_ratio,
+                       BOOL trim_to_fit) {
+  CGSize imageSize = [image size];
+  if (imageSize.height < 1 || imageSize.width < 1) {
+    return nil;
+  }
+  if (target_size.height < 1 || target_size.width < 1) {
+    return nil;
+  }
+  CGFloat aspectRatio = imageSize.width / imageSize.height;
+  CGFloat targetAspectRatio = target_size.width / target_size.height;
+  CGRect projectTo = CGRectZero;
+  if (preserve_aspect_ratio) {
+    if (trim_to_fit) {
+      // Scale and clip image so that the aspect ratio is preserved and the
+      // target size is filled.
+      if (targetAspectRatio < aspectRatio) {
+        // clip the x-axis.
+        projectTo.size.width = target_size.height * aspectRatio;
+        projectTo.size.height = target_size.height;
+        projectTo.origin.x = (target_size.width - projectTo.size.width) / 2;
+        projectTo.origin.y = 0;
+      } else {
+        // clip the y-axis.
+        projectTo.size.width = target_size.width;
+        projectTo.size.height = target_size.width / aspectRatio;
+        projectTo.origin.x = 0;
+        projectTo.origin.y = (target_size.height - projectTo.size.height) / 2;
+      }
+    } else {
+      // Scale image to ensure it fits inside the specified target_size.
+      if (targetAspectRatio < aspectRatio) {
+        // target is less wide than the original.
+        projectTo.size.width = target_size.width;
+        projectTo.size.height = projectTo.size.width / aspectRatio;
+        target_size = projectTo.size;
+      } else {
+        // target is wider than the original.
+        projectTo.size.height = target_size.height;
+        projectTo.size.width = projectTo.size.height * aspectRatio;
+        target_size = projectTo.size;
+      }
+    }  // if (clip)
+  } else {
+    // Don't preserve the aspect ratio.
+    projectTo.size = target_size;
+  }
+
+  projectTo = CGRectIntegral(projectTo);
+  // There's no CGSizeIntegral, so we fake our own.
+  CGRect integralRect = CGRectZero;
+  integralRect.size = target_size;
+  target_size = CGRectIntegral(integralRect).size;
+
+  // Resize photo. Use UIImage drawing methods because they respect
+  // UIImageOrientation as opposed to CGContextDrawImage().
+  UIGraphicsBeginImageContext(target_size);
+  [image drawInRect:projectTo];
+  UIImage* resizedPhoto = UIGraphicsGetImageFromCurrentImageContext();
+  UIGraphicsEndImageContext();
+  return resizedPhoto;
+}
+}  // namespace
+
+namespace gfx {
+
+bool JPEG1xEncodedDataFromImage(const Image& image,
+                                int quality,
+                                std::vector<unsigned char>* dst) {
+  NSData* data = UIImageJPEGRepresentation(image.ToUIImage(), quality / 100.0);
+
+  if ([data length] == 0)
+    return false;
+
+  dst->resize([data length]);
+  [data getBytes:&dst->at(0) length:[data length]];
+  return true;
+}
+
+Image ResizedImageForSearchByImage(const Image& image) {
+  if (image.IsEmpty()) {
+    return image;
+  }
+  UIImage* ui_image = image.ToUIImage();
+
+  if (ui_image &&
+      ui_image.size.height * ui_image.size.width > kSearchByImageMaxImageArea &&
+      (ui_image.size.width > kSearchByImageMaxImageWidth ||
+       ui_image.size.height > kSearchByImageMaxImageHeight)) {
+    CGSize new_image_size =
+        CGSizeMake(kSearchByImageMaxImageWidth, kSearchByImageMaxImageHeight);
+    ui_image = ResizeUIImage(ui_image, new_image_size,
+                             /*preserve_aspect_ratio=*/YES, /*trim_to_fit=*/NO);
+  }
+  return Image(ui_image);
+}
+
+}  // end namespace gfx
diff --git a/ui/gfx/image/image_util_mac.mm b/ui/gfx/image/image_util_mac.mm
new file mode 100644
index 0000000..5be20b0
--- /dev/null
+++ b/ui/gfx/image/image_util_mac.mm
@@ -0,0 +1,40 @@
+// Copyright (c) 2017 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.
+
+#include "ui/gfx/image/image_util.h"
+
+#import <Cocoa/Cocoa.h>
+
+#include "base/mac/scoped_nsobject.h"
+#include "ui/gfx/image/image.h"
+
+namespace gfx {
+
+bool JPEG1xEncodedDataFromImage(const Image& image,
+                                int quality,
+                                std::vector<unsigned char>* dst) {
+  if (!image.HasRepresentation(gfx::Image::kImageRepCocoa))
+    return JPEG1xEncodedDataFromSkiaRepresentation(image, quality, dst);
+
+  NSImage* nsImage = image.ToNSImage();
+
+  CGImageRef cgImage =
+      [nsImage CGImageForProposedRect:nil context:nil hints:nil];
+  base::scoped_nsobject<NSBitmapImageRep> rep(
+      [[NSBitmapImageRep alloc] initWithCGImage:cgImage]);
+
+  float compressionFactor = quality / 100.0;
+  NSDictionary* options = @{ NSImageCompressionFactor : @(compressionFactor)};
+  NSData* data =
+      [rep representationUsingType:NSJPEGFileType properties:options];
+
+  if ([data length] == 0)
+    return false;
+
+  dst->resize([data length]);
+  [data getBytes:&dst->at(0) length:[data length]];
+  return true;
+}
+
+}  // end namespace gfx
diff --git a/ui/gfx/image/image_util_unittest.cc b/ui/gfx/image/image_util_unittest.cc
new file mode 100644
index 0000000..0ef65fd
--- /dev/null
+++ b/ui/gfx/image/image_util_unittest.cc
@@ -0,0 +1,159 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/image/image_util.h"
+
+#include <memory>
+#include <vector>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkRect.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_unittest_util.h"
+#include "ui/gfx/image/resize_image_dimensions.h"
+
+TEST(ImageUtilTest, JPEGEncodeAndDecode) {
+  gfx::Image original = gfx::test::CreateImage(100, 100);
+
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(gfx::JPEG1xEncodedDataFromImage(original, 80, &encoded));
+
+  gfx::Image decoded =
+      gfx::ImageFrom1xJPEGEncodedData(&encoded.front(), encoded.size());
+
+  // JPEG is lossy, so simply check that the image decoded successfully.
+  EXPECT_FALSE(decoded.IsEmpty());
+}
+
+TEST(ImageUtilTest, GetVisibleMargins) {
+  int left, right;
+
+  // Fully transparent image.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 14);
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(8, left);
+    EXPECT_EQ(8, right);
+  }
+
+  // Fully non-transparent image.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 14);
+    bitmap.eraseColor(SK_ColorYELLOW);
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(0, left);
+    EXPECT_EQ(0, right);
+  }
+
+  // Image with non-transparent section in center.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 14);
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    bitmap.eraseArea(SkIRect::MakeLTRB(3, 2, 13, 13), SK_ColorYELLOW);
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(3, left);
+    EXPECT_EQ(3, right);
+  }
+
+  // Image with non-transparent section skewed to one side.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 14);
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    bitmap.eraseArea(SkIRect::MakeLTRB(3, 2, 5, 5), SK_ColorYELLOW);
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(3, left);
+    EXPECT_EQ(11, right);
+  }
+
+  // Image with non-transparent section at leading edge.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 14);
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    bitmap.eraseArea(SkIRect::MakeLTRB(0, 3, 5, 5), SK_ColorYELLOW);
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(0, left);
+    EXPECT_EQ(11, right);
+  }
+
+  // Image with non-transparent section at trailing edge.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 14);
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    bitmap.eraseArea(SkIRect::MakeLTRB(4, 3, 16, 13), SK_ColorYELLOW);
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(4, left);
+    EXPECT_EQ(0, right);
+  }
+
+  // Image with narrow non-transparent section.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 14);
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    bitmap.eraseArea(SkIRect::MakeLTRB(8, 3, 9, 5), SK_ColorYELLOW);
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(8, left);
+    EXPECT_EQ(7, right);
+  }
+
+  // Image with faint pixels.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(16, 14);
+    bitmap.eraseColor(SkColorSetA(SK_ColorYELLOW, 0x02));
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(8, left);
+    EXPECT_EQ(8, right);
+  }
+
+  // Fully transparent image with odd width.
+  {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(17, 14);
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    gfx::ImageSkia img(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+    gfx::GetVisibleMargins(img, &left, &right);
+    EXPECT_EQ(9, left);
+    EXPECT_EQ(8, right);
+  }
+}
+
+TEST(ImageUtilTest, ResizedImageForSearchByImage) {
+  // Make sure the image large enough to let ResizedImageForSearchByImage to
+  // resize the image.
+  gfx::Image original_image =
+      gfx::test::CreateImage(gfx::kSearchByImageMaxImageWidth * 2,
+                             gfx::kSearchByImageMaxImageHeight * 2);
+
+  gfx::Image resized_image = gfx::ResizedImageForSearchByImage(original_image);
+  EXPECT_FALSE(resized_image.IsEmpty());
+  EXPECT_EQ(resized_image.Width(), gfx::kSearchByImageMaxImageWidth);
+  EXPECT_EQ(resized_image.Height(), gfx::kSearchByImageMaxImageHeight);
+}
+
+TEST(ImageUtilTest, ResizedImageForSearchByImageShouldKeepRatio) {
+  // Make sure the image large enough to let ResizedImageForSearchByImage to
+  // resize the image.
+  gfx::Image original_image = gfx::test::CreateImage(600, 600);
+
+  gfx::Image resized_image = gfx::ResizedImageForSearchByImage(original_image);
+  EXPECT_EQ(resized_image.Width(), 400);
+  EXPECT_EQ(resized_image.Height(), 400);
+}
diff --git a/ui/gfx/image/mojom/BUILD.gn b/ui/gfx/image/mojom/BUILD.gn
new file mode 100644
index 0000000..dd07e3c
--- /dev/null
+++ b/ui/gfx/image/mojom/BUILD.gn
@@ -0,0 +1,67 @@
+# Copyright 2017 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.
+
+import("//mojo/public/tools/bindings/mojom.gni")
+
+mojom("mojom") {
+  sources = [ "image.mojom" ]
+
+  public_deps = [ "//skia/public/mojom" ]
+
+  cpp_typemaps = [
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.ImageSkia"
+          cpp = "::gfx::ImageSkia"
+          nullable_is_same_type = true
+        },
+        {
+          mojom = "gfx.mojom.ImageSkiaRep"
+          cpp = "::gfx::ImageSkiaRep"
+        },
+      ]
+      traits_headers = [ "image_skia_mojom_traits.h" ]
+      traits_public_deps = [ ":mojom_traits" ]
+    },
+  ]
+}
+
+source_set("mojom_traits") {
+  sources = [
+    "image_skia_mojom_traits.cc",
+    "image_skia_mojom_traits.h",
+  ]
+
+  public_deps = [
+    ":mojom_shared_cpp_sources",
+    "//skia/public/mojom",
+    "//ui/gfx",
+  ]
+}
+
+# Using a test service because the traits need to pass handles around. Revisit
+# this after Deserialize(Serialize()) API works with handles.
+mojom("test_interfaces") {
+  sources = [ "image_traits_test_service.mojom" ]
+
+  public_deps = [ ":mojom" ]
+}
+
+source_set("unit_test") {
+  testonly = true
+
+  sources = [ "image_traits_unittest.cc" ]
+
+  deps = [
+    ":mojom_traits",
+    ":test_interfaces",
+    "//base",
+    "//base/test:test_support",
+    "//mojo/public/cpp/bindings",
+    "//mojo/public/cpp/test_support:test_utils",
+    "//testing/gtest",
+    "//ui/gfx:test_support",
+  ]
+}
diff --git a/ui/gfx/image/mojom/DEPS b/ui/gfx/image/mojom/DEPS
new file mode 100644
index 0000000..2f6a444
--- /dev/null
+++ b/ui/gfx/image/mojom/DEPS
@@ -0,0 +1,5 @@
+include_rules = [
+  "+mojo/public",
+  "+skia/public/mojom",
+  "+ui/gfx/image",
+]
diff --git a/ui/gfx/image/mojom/OWNERS b/ui/gfx/image/mojom/OWNERS
new file mode 100644
index 0000000..ab87d1e
--- /dev/null
+++ b/ui/gfx/image/mojom/OWNERS
@@ -0,0 +1,8 @@
+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS
+
+per-file *_mojom_traits*.*=set noparent
+per-file *_mojom_traits*.*=file://ipc/SECURITY_OWNERS
+
+per-file *.typemap=set noparent
+per-file *.typemap=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/image/mojom/image.mojom b/ui/gfx/image/mojom/image.mojom
new file mode 100644
index 0000000..e875200
--- /dev/null
+++ b/ui/gfx/image/mojom/image.mojom
@@ -0,0 +1,27 @@
+// Copyright 2017 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.
+
+module gfx.mojom;
+
+import "skia/public/mojom/bitmap.mojom";
+
+[Stable]
+struct ImageSkiaRep {
+  // Transport of the bitmap in this representation. The type here is
+  // BitmapWithArbitraryBpp because this structure is marked Stable, however
+  // only N32-format bitmaps are allowed, similar to the skia.mojom.BitmapN32
+  // type.
+  skia.mojom.BitmapWithArbitraryBpp bitmap;
+
+  // Corresponding scale of the bitmap or 0 if unscaled.
+  float scale;
+};
+
+// Mojo transport for an ImageSkia via shared buffer. Note that transporting an
+// ImageSkia over mojo will load all of its image representations for supported
+// scales.
+[Stable]
+struct ImageSkia {
+  array<ImageSkiaRep> image_reps;
+};
diff --git a/ui/gfx/image/mojom/image_skia_mojom_traits.cc b/ui/gfx/image/mojom/image_skia_mojom_traits.cc
new file mode 100644
index 0000000..cda3a62
--- /dev/null
+++ b/ui/gfx/image/mojom/image_skia_mojom_traits.cc
@@ -0,0 +1,84 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/image/mojom/image_skia_mojom_traits.h"
+
+#include <string.h>
+
+#include "base/check_op.h"
+
+namespace mojo {
+
+// static
+SkBitmap
+StructTraits<gfx::mojom::ImageSkiaRepDataView, gfx::ImageSkiaRep>::bitmap(
+    const gfx::ImageSkiaRep& input) {
+  SkBitmap bitmap = input.GetBitmap();
+  DCHECK(!bitmap.drawsNothing());
+  CHECK_EQ(bitmap.colorType(), kN32_SkColorType);
+  return bitmap;
+}
+
+// static
+float StructTraits<gfx::mojom::ImageSkiaRepDataView, gfx::ImageSkiaRep>::scale(
+    const gfx::ImageSkiaRep& input) {
+  const float scale = input.unscaled() ? 0.0f : input.scale();
+  DCHECK_GE(scale, 0.0f);
+  return scale;
+}
+
+// static
+bool StructTraits<gfx::mojom::ImageSkiaRepDataView, gfx::ImageSkiaRep>::Read(
+    gfx::mojom::ImageSkiaRepDataView data,
+    gfx::ImageSkiaRep* out) {
+  // An acceptable scale must be greater than or equal to 0.
+  if (data.scale() < 0)
+    return false;
+
+  SkBitmap bitmap;
+  if (!data.ReadBitmap(&bitmap))
+    return false;
+  // Null/uninitialized bitmaps are not allowed, and an ImageSkiaRep is never
+  // empty-sized either.
+  if (bitmap.drawsNothing())
+    return false;
+  // Similar to BitmapN32, ImageSkiaReps are expected to have an N32 bitmap
+  // type.
+  if (bitmap.colorType() != kN32_SkColorType)
+    return false;
+
+  *out = gfx::ImageSkiaRep(bitmap, data.scale());
+  return true;
+}
+
+// static
+std::vector<gfx::ImageSkiaRep>
+StructTraits<gfx::mojom::ImageSkiaDataView, gfx::ImageSkia>::image_reps(
+    const gfx::ImageSkia& input) {
+  // Trigger the image to load everything.
+  input.EnsureRepsForSupportedScales();
+  return input.image_reps();
+}
+
+// static
+bool StructTraits<gfx::mojom::ImageSkiaDataView, gfx::ImageSkia>::Read(
+    gfx::mojom::ImageSkiaDataView data,
+    gfx::ImageSkia* out) {
+  DCHECK(out->isNull());
+
+  std::vector<gfx::ImageSkiaRep> image_reps;
+  if (!data.ReadImageReps(&image_reps))
+    return false;
+
+  for (const auto& image_rep : image_reps)
+    out->AddRepresentation(image_rep);
+
+  if (out->isNull())
+    return false;
+
+  out->SetReadOnly();
+  return true;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/image/mojom/image_skia_mojom_traits.h b/ui/gfx/image/mojom/image_skia_mojom_traits.h
new file mode 100644
index 0000000..701b563
--- /dev/null
+++ b/ui/gfx/image/mojom/image_skia_mojom_traits.h
@@ -0,0 +1,41 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_MOJOM_IMAGE_SKIA_MOJOM_TRAITS_H_
+#define UI_GFX_IMAGE_MOJOM_IMAGE_SKIA_MOJOM_TRAITS_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+#include "skia/public/mojom/bitmap_skbitmap_mojom_traits.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_skia_rep.h"
+#include "ui/gfx/image/mojom/image.mojom-shared.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::ImageSkiaRepDataView, gfx::ImageSkiaRep> {
+  static SkBitmap bitmap(const gfx::ImageSkiaRep& input);
+  static float scale(const gfx::ImageSkiaRep& input);
+
+  static bool Read(gfx::mojom::ImageSkiaRepDataView data,
+                   gfx::ImageSkiaRep* out);
+};
+
+template <>
+struct StructTraits<gfx::mojom::ImageSkiaDataView, gfx::ImageSkia> {
+  static std::vector<gfx::ImageSkiaRep> image_reps(const gfx::ImageSkia& input);
+
+  static bool IsNull(const gfx::ImageSkia& input) { return input.isNull(); }
+  static void SetToNull(gfx::ImageSkia* out) { *out = gfx::ImageSkia(); }
+
+  static bool Read(gfx::mojom::ImageSkiaDataView data, gfx::ImageSkia* out);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_IMAGE_MOJOM_IMAGE_SKIA_MOJOM_TRAITS_H_
diff --git a/ui/gfx/image/mojom/image_traits_test_service.mojom b/ui/gfx/image/mojom/image_traits_test_service.mojom
new file mode 100644
index 0000000..72ab4b6
--- /dev/null
+++ b/ui/gfx/image/mojom/image_traits_test_service.mojom
@@ -0,0 +1,16 @@
+// Copyright 2017 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.
+
+module gfx.mojom;
+
+import "ui/gfx/image/mojom/image.mojom";
+
+// A test echo interface for traits.
+interface ImageTraitsTestService {
+  [Sync]
+  EchoImageSkiaRep(ImageSkiaRep? in) => (ImageSkiaRep? out);
+
+  [Sync]
+  EchoImageSkia(ImageSkia? in) => (ImageSkia? out);
+};
diff --git a/ui/gfx/image/mojom/image_traits_unittest.cc b/ui/gfx/image/mojom/image_traits_unittest.cc
new file mode 100644
index 0000000..297a929
--- /dev/null
+++ b/ui/gfx/image/mojom/image_traits_unittest.cc
@@ -0,0 +1,170 @@
+// Copyright 2017 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.
+
+#include <utility>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/test/task_environment.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "mojo/public/cpp/test_support/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/image/image_skia_source.h"
+#include "ui/gfx/image/image_unittest_util.h"
+#include "ui/gfx/image/mojom/image.mojom.h"
+#include "ui/gfx/image/mojom/image_skia_mojom_traits.h"
+
+namespace gfx {
+
+namespace {
+
+// A test ImageSkiaSource that creates an ImageSkiaRep for any scale.
+class TestImageSkiaSource : public ImageSkiaSource {
+ public:
+  explicit TestImageSkiaSource(const Size& dip_size) : dip_size_(dip_size) {}
+
+  TestImageSkiaSource(const TestImageSkiaSource&) = delete;
+  TestImageSkiaSource& operator=(const TestImageSkiaSource&) = delete;
+
+  ~TestImageSkiaSource() override = default;
+
+  // ImageSkiaSource:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    return ImageSkiaRep(ScaleToCeiledSize(dip_size_, scale), scale);
+  }
+
+ private:
+  const Size dip_size_;
+};
+
+// A helper to construct a skia.mojom.BitmapN32 without using StructTraits
+// to bypass checks on the sending/serialization side.
+mojo::StructPtr<mojom::ImageSkiaRep> ConstructImageSkiaRep(
+    const SkBitmap& bitmap,
+    float scale) {
+  auto mojom_rep = mojom::ImageSkiaRep::New();
+  mojom_rep->bitmap = bitmap;
+  mojom_rep->scale = scale;
+  return mojom_rep;
+}
+
+}  // namespace
+
+TEST(ImageTraitsTest, VerifyMojomConstruction) {
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(1, 1);
+  mojo::StructPtr<mojom::ImageSkiaRep> input = ConstructImageSkiaRep(bitmap, 1);
+  ImageSkiaRep output;
+  EXPECT_TRUE(
+      mojo::test::SerializeAndDeserialize<mojom::ImageSkiaRep>(input, output));
+}
+
+TEST(ImageTraitsTest, BadColorTypeImageSkiaRep_Deserialize) {
+  SkBitmap a8_bitmap;
+  a8_bitmap.allocPixels(SkImageInfo::MakeA8(1, 1));
+
+  mojo::StructPtr<mojom::ImageSkiaRep> input =
+      ConstructImageSkiaRep(a8_bitmap, 1);
+  ImageSkiaRep output;
+  EXPECT_FALSE(
+      mojo::test::SerializeAndDeserialize<mojom::ImageSkiaRep>(input, output));
+}
+
+TEST(ImageTraitsTest, EmptyImageSkiaRep_Deserialize) {
+  SkBitmap empty_bitmap;
+  empty_bitmap.allocN32Pixels(0, 0);
+  // Empty SkBitmap is not null.
+  EXPECT_FALSE(empty_bitmap.isNull());
+  EXPECT_TRUE(empty_bitmap.drawsNothing());
+
+  mojo::StructPtr<mojom::ImageSkiaRep> input =
+      ConstructImageSkiaRep(empty_bitmap, 1);
+  ImageSkiaRep output;
+  EXPECT_FALSE(
+      mojo::test::SerializeAndDeserialize<mojom::ImageSkiaRep>(input, output));
+}
+
+TEST(ImageTraitsTest, ValidImageSkiaRep) {
+  ImageSkiaRep image_rep(Size(2, 4), 2.0f);
+
+  ImageSkiaRep output;
+  ASSERT_TRUE(mojo::test::SerializeAndDeserialize<mojom::ImageSkiaRep>(
+      image_rep, output));
+
+  EXPECT_FALSE(output.is_null());
+  EXPECT_EQ(image_rep.scale(), output.scale());
+  EXPECT_TRUE(test::AreBitmapsEqual(image_rep.GetBitmap(), output.GetBitmap()));
+}
+
+TEST(ImageTraitsTest, UnscaledImageSkiaRep) {
+  ImageSkiaRep image_rep(Size(2, 4), 0.0f);
+  ASSERT_TRUE(image_rep.unscaled());
+
+  ImageSkiaRep output;
+  ASSERT_TRUE(mojo::test::SerializeAndDeserialize<mojom::ImageSkiaRep>(
+      image_rep, output));
+  EXPECT_TRUE(output.unscaled());
+  EXPECT_TRUE(test::AreBitmapsEqual(image_rep.GetBitmap(), output.GetBitmap()));
+}
+
+TEST(ImageTraitsTest, NullImageSkia) {
+  ImageSkia null_image;
+  ASSERT_TRUE(null_image.isNull());
+
+  ImageSkia output(ImageSkiaRep(Size(1, 1), 1.0f));
+  ASSERT_FALSE(output.isNull());
+  ASSERT_TRUE(mojo::test::SerializeAndDeserialize<mojom::ImageSkia>(null_image,
+                                                                    output));
+  EXPECT_TRUE(output.isNull());
+}
+
+TEST(ImageTraitsTest, ImageSkiaRepsAreCreatedAsNeeded) {
+  const Size kSize(1, 2);
+  ImageSkia image(std::make_unique<TestImageSkiaSource>(kSize), kSize);
+  EXPECT_FALSE(image.isNull());
+  EXPECT_TRUE(image.image_reps().empty());
+
+  ImageSkia output;
+  EXPECT_TRUE(output.isNull());
+  ASSERT_TRUE(
+      mojo::test::SerializeAndDeserialize<mojom::ImageSkia>(image, output));
+  EXPECT_FALSE(image.image_reps().empty());
+  EXPECT_FALSE(output.isNull());
+}
+
+TEST(ImageTraitsTest, ImageSkia) {
+  const Size kSize(1, 2);
+  ImageSkia image(std::make_unique<TestImageSkiaSource>(kSize), kSize);
+  image.GetRepresentation(1.0f);
+  image.GetRepresentation(2.0f);
+
+  ImageSkia output;
+  ASSERT_TRUE(
+      mojo::test::SerializeAndDeserialize<mojom::ImageSkia>(image, output));
+
+  EXPECT_TRUE(test::AreImagesEqual(Image(output), Image(image)));
+}
+
+TEST(ImageTraitsTest, ImageSkiaWithOperations) {
+  const Size kSize(32, 32);
+  ImageSkia image(std::make_unique<TestImageSkiaSource>(kSize), kSize);
+
+  const Size kNewSize(16, 16);
+  ImageSkia resized = ImageSkiaOperations::CreateResizedImage(
+      image, skia::ImageOperations::RESIZE_BEST, kNewSize);
+  resized.GetRepresentation(1.0f);
+  resized.GetRepresentation(2.0f);
+
+  ImageSkia output;
+  ASSERT_TRUE(
+      mojo::test::SerializeAndDeserialize<mojom::ImageSkia>(resized, output));
+
+  EXPECT_TRUE(test::AreImagesEqual(Image(output), Image(resized)));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/image/resize_image_dimensions.h b/ui/gfx/image/resize_image_dimensions.h
new file mode 100644
index 0000000..65f7925
--- /dev/null
+++ b/ui/gfx/image/resize_image_dimensions.h
@@ -0,0 +1,17 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IMAGE_RESIZE_IMAGE_DIMENSIONS_H_
+#define UI_GFX_IMAGE_RESIZE_IMAGE_DIMENSIONS_H_
+
+namespace gfx {
+
+// Dimensions to use when downsizing an image for search-by-image.
+const int kSearchByImageMaxImageArea = 90000;
+const int kSearchByImageMaxImageWidth = 600;
+const int kSearchByImageMaxImageHeight = 400;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_IMAGE_RESIZE_IMAGE_DIMENSIONS_H_
diff --git a/ui/gfx/interpolated_transform.cc b/ui/gfx/interpolated_transform.cc
new file mode 100644
index 0000000..6277fa4
--- /dev/null
+++ b/ui/gfx/interpolated_transform.cc
@@ -0,0 +1,373 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/interpolated_transform.h"
+
+#include <cmath>
+
+#include "base/check.h"
+#include "base/numerics/safe_conversions.h"
+#include "ui/gfx/animation/tween.h"
+
+namespace {
+
+static const double EPSILON = 1e-6;
+
+bool IsMultipleOfNinetyDegrees(double degrees) {
+  double remainder = fabs(fmod(degrees, 90.0));
+  return remainder < EPSILON || 90.0 - remainder < EPSILON;
+}
+
+// Returns false if |degrees| is not a multiple of ninety degrees or if
+// |rotation| is NULL. It does not affect |rotation| in this case. Otherwise
+// *rotation is set to be the appropriate sanitized rotation matrix. That is,
+// the rotation matrix corresponding to |degrees| which has entries that are all
+// either 0, 1 or -1.
+bool MassageRotationIfMultipleOfNinetyDegrees(gfx::Transform* rotation,
+                                              float degrees) {
+  if (!IsMultipleOfNinetyDegrees(degrees) || !rotation)
+    return false;
+
+  gfx::Transform transform;
+  skia::Matrix44& m = transform.matrix();
+  float degrees_by_ninety = degrees / 90.0f;
+
+  int n = base::ClampRound(degrees_by_ninety);
+
+  n %= 4;
+  if (n < 0)
+    n += 4;
+
+  // n should now be in the range [0, 3]
+  if (n == 1) {
+    m.set3x3( 0,  1,  0,
+             -1,  0,  0,
+              0,  0,  1);
+  } else if (n == 2) {
+    m.set3x3(-1,  0,  0,
+              0, -1,  0,
+              0,  0,  1);
+  } else if (n == 3) {
+    m.set3x3( 0, -1,  0,
+              1,  0,  0,
+              0,  0,  1);
+  }
+
+  *rotation = transform;
+  return true;
+}
+
+} // namespace
+
+namespace ui {
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedTransform
+//
+
+InterpolatedTransform::InterpolatedTransform()
+    : start_time_(0.0f),
+      end_time_(1.0f),
+      reversed_(false) {
+}
+
+InterpolatedTransform::InterpolatedTransform(float start_time,
+                                             float end_time)
+    : start_time_(start_time),
+      end_time_(end_time),
+      reversed_(false) {
+}
+
+InterpolatedTransform::~InterpolatedTransform() {}
+
+gfx::Transform InterpolatedTransform::Interpolate(float t) const {
+  if (reversed_)
+    t = 1.0f - t;
+  gfx::Transform result = InterpolateButDoNotCompose(t);
+  if (child_.get()) {
+    result.ConcatTransform(child_->Interpolate(t));
+  }
+  return result;
+}
+
+void InterpolatedTransform::SetChild(
+    std::unique_ptr<InterpolatedTransform> child) {
+  child_ = std::move(child);
+}
+
+inline float InterpolatedTransform::ValueBetween(float time,
+                                                 float start_value,
+                                                 float end_value) const {
+  // can't handle NaN
+  DCHECK(time == time && start_time_ == start_time_ && end_time_ == end_time_);
+  if (time != time || start_time_ != start_time_ || end_time_ != end_time_)
+    return start_value;
+
+  // Ok if equal -- we'll get a step function. Note: if end_time_ ==
+  // start_time_ == x, then if none of the numbers are NaN, then it
+  // must be true that time < x or time >= x, so we will return early
+  // due to one of the following if statements.
+  DCHECK(end_time_ >= start_time_);
+
+  if (time < start_time_)
+    return start_value;
+
+  if (time >= end_time_)
+    return end_value;
+
+  float t = (time - start_time_) / (end_time_ - start_time_);
+  return static_cast<float>(
+      gfx::Tween::DoubleValueBetween(t, start_value, end_value));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedRotation
+//
+
+InterpolatedRotation::InterpolatedRotation(float start_degrees,
+                                           float end_degrees)
+    : InterpolatedTransform(),
+      start_degrees_(start_degrees),
+      end_degrees_(end_degrees) {
+}
+
+InterpolatedRotation::InterpolatedRotation(float start_degrees,
+                                           float end_degrees,
+                                           float start_time,
+                                           float end_time)
+    : InterpolatedTransform(start_time, end_time),
+      start_degrees_(start_degrees),
+      end_degrees_(end_degrees) {
+}
+
+InterpolatedRotation::~InterpolatedRotation() {}
+
+gfx::Transform InterpolatedRotation::InterpolateButDoNotCompose(float t) const {
+  gfx::Transform result;
+  float interpolated_degrees = ValueBetween(t, start_degrees_, end_degrees_);
+  result.Rotate(interpolated_degrees);
+  if (t == 0.0f || t == 1.0f)
+    MassageRotationIfMultipleOfNinetyDegrees(&result, interpolated_degrees);
+  return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedAxisAngleRotation
+//
+
+InterpolatedAxisAngleRotation::InterpolatedAxisAngleRotation(
+    const gfx::Vector3dF& axis,
+    float start_degrees,
+    float end_degrees)
+    : InterpolatedTransform(),
+      axis_(axis),
+      start_degrees_(start_degrees),
+      end_degrees_(end_degrees) {
+}
+
+InterpolatedAxisAngleRotation::InterpolatedAxisAngleRotation(
+    const gfx::Vector3dF& axis,
+    float start_degrees,
+    float end_degrees,
+    float start_time,
+    float end_time)
+    : InterpolatedTransform(start_time, end_time),
+      axis_(axis),
+      start_degrees_(start_degrees),
+      end_degrees_(end_degrees) {
+}
+
+InterpolatedAxisAngleRotation::~InterpolatedAxisAngleRotation() {}
+
+gfx::Transform
+InterpolatedAxisAngleRotation::InterpolateButDoNotCompose(float t) const {
+  gfx::Transform result;
+  result.RotateAbout(axis_, ValueBetween(t, start_degrees_, end_degrees_));
+  return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedScale
+//
+
+InterpolatedScale::InterpolatedScale(float start_scale, float end_scale)
+    : InterpolatedTransform(),
+      start_scale_(gfx::Point3F(start_scale, start_scale, start_scale)),
+      end_scale_(gfx::Point3F(end_scale, end_scale, end_scale)) {
+}
+
+InterpolatedScale::InterpolatedScale(float start_scale, float end_scale,
+                                     float start_time, float end_time)
+    : InterpolatedTransform(start_time, end_time),
+      start_scale_(gfx::Point3F(start_scale, start_scale, start_scale)),
+      end_scale_(gfx::Point3F(end_scale, end_scale, end_scale)) {
+}
+
+InterpolatedScale::InterpolatedScale(const gfx::Point3F& start_scale,
+                                     const gfx::Point3F& end_scale)
+    : InterpolatedTransform(),
+      start_scale_(start_scale),
+      end_scale_(end_scale) {
+}
+
+InterpolatedScale::InterpolatedScale(const gfx::Point3F& start_scale,
+                                     const gfx::Point3F& end_scale,
+                                     float start_time,
+                                     float end_time)
+    : InterpolatedTransform(start_time, end_time),
+      start_scale_(start_scale),
+      end_scale_(end_scale) {
+}
+
+InterpolatedScale::~InterpolatedScale() {}
+
+gfx::Transform InterpolatedScale::InterpolateButDoNotCompose(float t) const {
+  gfx::Transform result;
+  float scale_x = ValueBetween(t, start_scale_.x(), end_scale_.x());
+  float scale_y = ValueBetween(t, start_scale_.y(), end_scale_.y());
+  float scale_z = ValueBetween(t, start_scale_.z(), end_scale_.z());
+  result.Scale3d(scale_x, scale_y, scale_z);
+  return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedTranslation
+//
+
+InterpolatedTranslation::InterpolatedTranslation(const gfx::PointF& start_pos,
+                                                 const gfx::PointF& end_pos)
+    : InterpolatedTransform(), start_pos_(start_pos), end_pos_(end_pos) {}
+
+InterpolatedTranslation::InterpolatedTranslation(const gfx::PointF& start_pos,
+                                                 const gfx::PointF& end_pos,
+                                                 float start_time,
+                                                 float end_time)
+    : InterpolatedTransform(start_time, end_time),
+      start_pos_(start_pos),
+      end_pos_(end_pos) {}
+
+InterpolatedTranslation::InterpolatedTranslation(const gfx::Point3F& start_pos,
+                                                 const gfx::Point3F& end_pos)
+    : InterpolatedTransform(), start_pos_(start_pos), end_pos_(end_pos) {
+}
+
+InterpolatedTranslation::InterpolatedTranslation(const gfx::Point3F& start_pos,
+                                                 const gfx::Point3F& end_pos,
+                                                 float start_time,
+                                                 float end_time)
+    : InterpolatedTransform(start_time, end_time),
+      start_pos_(start_pos),
+      end_pos_(end_pos) {
+}
+
+InterpolatedTranslation::~InterpolatedTranslation() {}
+
+gfx::Transform
+InterpolatedTranslation::InterpolateButDoNotCompose(float t) const {
+  gfx::Transform result;
+  result.Translate3d(ValueBetween(t, start_pos_.x(), end_pos_.x()),
+                     ValueBetween(t, start_pos_.y(), end_pos_.y()),
+                     ValueBetween(t, start_pos_.z(), end_pos_.z()));
+  return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedConstantTransform
+//
+
+InterpolatedConstantTransform::InterpolatedConstantTransform(
+  const gfx::Transform& transform)
+    : InterpolatedTransform(),
+  transform_(transform) {
+}
+
+gfx::Transform
+InterpolatedConstantTransform::InterpolateButDoNotCompose(float t) const {
+  return transform_;
+}
+
+InterpolatedConstantTransform::~InterpolatedConstantTransform() {}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedTransformAboutPivot
+//
+
+InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot(
+    const gfx::Point& pivot,
+    std::unique_ptr<InterpolatedTransform> transform)
+    : InterpolatedTransform() {
+  Init(pivot, std::move(transform));
+}
+
+InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot(
+    const gfx::Point& pivot,
+    std::unique_ptr<InterpolatedTransform> transform,
+    float start_time,
+    float end_time)
+    : InterpolatedTransform() {
+  Init(pivot, std::move(transform));
+}
+
+InterpolatedTransformAboutPivot::~InterpolatedTransformAboutPivot() {}
+
+gfx::Transform
+InterpolatedTransformAboutPivot::InterpolateButDoNotCompose(float t) const {
+  if (transform_.get()) {
+    return transform_->Interpolate(t);
+  }
+  return gfx::Transform();
+}
+
+void InterpolatedTransformAboutPivot::Init(
+    const gfx::Point& pivot,
+    std::unique_ptr<InterpolatedTransform> xform) {
+  gfx::Transform to_pivot;
+  gfx::Transform from_pivot;
+  to_pivot.Translate(SkIntToScalar(-pivot.x()), SkIntToScalar(-pivot.y()));
+  from_pivot.Translate(SkIntToScalar(pivot.x()), SkIntToScalar(pivot.y()));
+
+  std::unique_ptr<InterpolatedTransform> pre_transform =
+      std::make_unique<InterpolatedConstantTransform>(to_pivot);
+  std::unique_ptr<InterpolatedTransform> post_transform =
+      std::make_unique<InterpolatedConstantTransform>(from_pivot);
+
+  xform->SetChild(std::move(post_transform));
+  pre_transform->SetChild(std::move(xform));
+  transform_ = std::move(pre_transform);
+}
+
+InterpolatedMatrixTransform::InterpolatedMatrixTransform(
+    const gfx::Transform& start_transform,
+    const gfx::Transform& end_transform)
+    : InterpolatedTransform() {
+  Init(start_transform, end_transform);
+}
+
+InterpolatedMatrixTransform::InterpolatedMatrixTransform(
+    const gfx::Transform& start_transform,
+    const gfx::Transform& end_transform,
+    float start_time,
+    float end_time)
+    : InterpolatedTransform() {
+  Init(start_transform, end_transform);
+}
+
+InterpolatedMatrixTransform::~InterpolatedMatrixTransform() {}
+
+gfx::Transform
+InterpolatedMatrixTransform::InterpolateButDoNotCompose(float t) const {
+  gfx::DecomposedTransform blended =
+      gfx::BlendDecomposedTransforms(end_decomp_, start_decomp_, t);
+  return gfx::ComposeTransform(blended);
+}
+
+void InterpolatedMatrixTransform::Init(const gfx::Transform& start_transform,
+                                       const gfx::Transform& end_transform) {
+  bool success = gfx::DecomposeTransform(&start_decomp_, start_transform);
+  DCHECK(success);
+  success = gfx::DecomposeTransform(&end_decomp_, end_transform);
+  DCHECK(success);
+}
+
+} // namespace ui
diff --git a/ui/gfx/interpolated_transform.h b/ui/gfx/interpolated_transform.h
new file mode 100644
index 0000000..b836e24
--- /dev/null
+++ b/ui/gfx/interpolated_transform.h
@@ -0,0 +1,294 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_INTERPOLATED_TRANSFORM_H_
+#define UI_GFX_INTERPOLATED_TRANSFORM_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/geometry/transform_util.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace ui {
+
+///////////////////////////////////////////////////////////////////////////////
+// class InterpolatedTransform
+//
+// Abstract base class for transforms that animate over time. These
+// interpolated transforms can be combined to allow for more sophisticated
+// animations. For example, you might combine a rotation of 90 degrees between
+// times 0 and 1, with a scale from 1 to 0.3 between times 0 and 0.25 and a
+// scale from 0.3 to 1 from between times 0.75 and 1.
+//
+///////////////////////////////////////////////////////////////////////////////
+class GFX_EXPORT InterpolatedTransform {
+ public:
+  InterpolatedTransform();
+  // The interpolated transform varies only when t in (start_time, end_time).
+  // If t <= start_time, Interpolate(t) will return the initial transform, and
+  // if t >= end_time, Interpolate(t) will return the final transform.
+  InterpolatedTransform(float start_time, float end_time);
+
+  InterpolatedTransform(const InterpolatedTransform&) = delete;
+  InterpolatedTransform& operator=(const InterpolatedTransform&) = delete;
+
+  virtual ~InterpolatedTransform();
+
+  // Returns the interpolated transform at time t. Note: not virtual.
+  gfx::Transform Interpolate(float t) const;
+
+  // The Intepolate ultimately returns the product of our transform at time t
+  // and our child's transform at time t (if we have one).
+  //
+  // This function takes ownership of the passed InterpolatedTransform.
+  void SetChild(std::unique_ptr<InterpolatedTransform> child);
+
+  // If the interpolated transform is reversed, Interpolate(t) will return
+  // Interpolate(1 - t)
+  void SetReversed(bool reversed) { reversed_ = reversed; }
+  bool Reversed() const { return reversed_; }
+
+ protected:
+  // Calculates the interpolated transform without considering our child.
+  virtual gfx::Transform InterpolateButDoNotCompose(float t) const = 0;
+
+  // If time in (start_time_, end_time_], this function linearly interpolates
+  // between start_value and end_value.  More precisely it returns
+  // (1 - t) * start_value + t * end_value where
+  // t = (start_time_ - time) / (end_time_ - start_time_).
+  // If time < start_time_ it returns start_value, and if time >= end_time_
+  // it returns end_value.
+  float ValueBetween(float time, float start_value, float end_value) const;
+
+  float start_time() const { return start_time_; }
+  float end_time() const { return end_time_; }
+
+ private:
+  const float start_time_;
+  const float end_time_;
+
+  // The child transform. If you consider an interpolated transform as a
+  // function of t. If, without a child, we are f(t), and our child is
+  // g(t), then with a child we become f'(t) = f(t) * g(t). Using a child
+  // transform, we can chain collections of transforms together.
+  std::unique_ptr<InterpolatedTransform> child_;
+
+  bool reversed_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// class InterpolatedRotation
+//
+// Represents an animated rotation.
+//
+///////////////////////////////////////////////////////////////////////////////
+class GFX_EXPORT InterpolatedRotation : public InterpolatedTransform {
+ public:
+  InterpolatedRotation(float start_degrees, float end_degrees);
+  InterpolatedRotation(float start_degrees,
+                       float end_degrees,
+                       float start_time,
+                       float end_time);
+
+  InterpolatedRotation(const InterpolatedRotation&) = delete;
+  InterpolatedRotation& operator=(const InterpolatedRotation&) = delete;
+
+  ~InterpolatedRotation() override;
+
+ protected:
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
+
+ private:
+  const float start_degrees_;
+  const float end_degrees_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// class InterpolatedAxisAngleRotation
+//
+// Represents an animated rotation.
+//
+///////////////////////////////////////////////////////////////////////////////
+class GFX_EXPORT InterpolatedAxisAngleRotation : public InterpolatedTransform {
+ public:
+  InterpolatedAxisAngleRotation(const gfx::Vector3dF& axis,
+                                float start_degrees,
+                                float end_degrees);
+  InterpolatedAxisAngleRotation(const gfx::Vector3dF& axis,
+                                float start_degrees,
+                                float end_degrees,
+                                float start_time,
+                                float end_time);
+
+  InterpolatedAxisAngleRotation(const InterpolatedAxisAngleRotation&) = delete;
+  InterpolatedAxisAngleRotation& operator=(
+      const InterpolatedAxisAngleRotation&) = delete;
+
+  ~InterpolatedAxisAngleRotation() override;
+
+ protected:
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
+
+ private:
+  gfx::Vector3dF axis_;
+  const float start_degrees_;
+  const float end_degrees_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// class InterpolatedScale
+//
+// Represents an animated scale.
+//
+///////////////////////////////////////////////////////////////////////////////
+class GFX_EXPORT InterpolatedScale : public InterpolatedTransform {
+ public:
+  InterpolatedScale(float start_scale, float end_scale);
+  InterpolatedScale(float start_scale, float end_scale,
+                    float start_time, float end_time);
+  InterpolatedScale(const gfx::Point3F& start_scale,
+                    const gfx::Point3F& end_scale);
+  InterpolatedScale(const gfx::Point3F& start_scale,
+                    const gfx::Point3F& end_scale,
+                    float start_time,
+                    float end_time);
+
+  InterpolatedScale(const InterpolatedScale&) = delete;
+  InterpolatedScale& operator=(const InterpolatedScale&) = delete;
+
+  ~InterpolatedScale() override;
+
+ protected:
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
+
+ private:
+  const gfx::Point3F start_scale_;
+  const gfx::Point3F end_scale_;
+};
+
+class GFX_EXPORT InterpolatedTranslation : public InterpolatedTransform {
+ public:
+  InterpolatedTranslation(const gfx::PointF& start_pos,
+                          const gfx::PointF& end_pos);
+  InterpolatedTranslation(const gfx::PointF& start_pos,
+                          const gfx::PointF& end_pos,
+                          float start_time,
+                          float end_time);
+  InterpolatedTranslation(const gfx::Point3F& start_pos,
+                          const gfx::Point3F& end_pos);
+  InterpolatedTranslation(const gfx::Point3F& start_pos,
+                          const gfx::Point3F& end_pos,
+                          float start_time,
+                          float end_time);
+
+  InterpolatedTranslation(const InterpolatedTranslation&) = delete;
+  InterpolatedTranslation& operator=(const InterpolatedTranslation&) = delete;
+
+  ~InterpolatedTranslation() override;
+
+ protected:
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
+
+ private:
+  const gfx::Point3F start_pos_;
+  const gfx::Point3F end_pos_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// class InterpolatedConstantTransform
+//
+// Represents a transform that is constant over time. This is only useful when
+// composed with other interpolated transforms.
+//
+// See InterpolatedTransformAboutPivot for an example of its usage.
+//
+///////////////////////////////////////////////////////////////////////////////
+class GFX_EXPORT InterpolatedConstantTransform : public InterpolatedTransform {
+ public:
+  explicit InterpolatedConstantTransform(const gfx::Transform& transform);
+
+  InterpolatedConstantTransform(const InterpolatedConstantTransform&) = delete;
+  InterpolatedConstantTransform& operator=(
+      const InterpolatedConstantTransform&) = delete;
+
+  ~InterpolatedConstantTransform() override;
+
+ protected:
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
+
+ private:
+  const gfx::Transform transform_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// class InterpolatedTransformAboutPivot
+//
+// Represents an animated transform with a transformed origin. Essentially,
+// at each time, t, the interpolated transform is created by composing
+// P * T * P^-1 where P is a constant transform to the new origin.
+//
+///////////////////////////////////////////////////////////////////////////////
+class GFX_EXPORT InterpolatedTransformAboutPivot
+    : public InterpolatedTransform {
+ public:
+  // Takes ownership of the passed transform.
+  InterpolatedTransformAboutPivot(
+      const gfx::Point& pivot,
+      std::unique_ptr<InterpolatedTransform> transform);
+
+  // Takes ownership of the passed transform.
+  InterpolatedTransformAboutPivot(
+      const gfx::Point& pivot,
+      std::unique_ptr<InterpolatedTransform> transform,
+      float start_time,
+      float end_time);
+
+  InterpolatedTransformAboutPivot(const InterpolatedTransformAboutPivot&) =
+      delete;
+  InterpolatedTransformAboutPivot& operator=(
+      const InterpolatedTransformAboutPivot&) = delete;
+
+  ~InterpolatedTransformAboutPivot() override;
+
+ protected:
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
+
+ private:
+  void Init(const gfx::Point& pivot,
+            std::unique_ptr<InterpolatedTransform> transform);
+
+  std::unique_ptr<InterpolatedTransform> transform_;
+};
+
+class GFX_EXPORT InterpolatedMatrixTransform : public InterpolatedTransform {
+ public:
+  InterpolatedMatrixTransform(const gfx::Transform& start_transform,
+                              const gfx::Transform& end_transform);
+
+  InterpolatedMatrixTransform(const gfx::Transform& start_transform,
+                              const gfx::Transform& end_transform,
+                              float start_time,
+                              float end_time);
+
+  ~InterpolatedMatrixTransform() override;
+
+ protected:
+  gfx::Transform InterpolateButDoNotCompose(float t) const override;
+
+ private:
+  void Init(const gfx::Transform& start_transform,
+            const gfx::Transform& end_transform);
+
+  gfx::DecomposedTransform start_decomp_;
+  gfx::DecomposedTransform end_decomp_;
+};
+
+} // namespace ui
+
+#endif  // UI_GFX_INTERPOLATED_TRANSFORM_H_
diff --git a/ui/gfx/interpolated_transform_unittest.cc b/ui/gfx/interpolated_transform_unittest.cc
new file mode 100644
index 0000000..3de686d
--- /dev/null
+++ b/ui/gfx/interpolated_transform_unittest.cc
@@ -0,0 +1,237 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/interpolated_transform.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace {
+
+void CheckApproximatelyEqual(const gfx::Transform& lhs,
+                             const gfx::Transform& rhs) {
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      EXPECT_FLOAT_EQ(lhs.matrix().get(i, j), rhs.matrix().get(i, j));
+    }
+  }
+}
+
+} // namespace
+
+TEST(InterpolatedTransformTest, InterpolatedRotation) {
+  ui::InterpolatedRotation interpolated_rotation(0, 100);
+  ui::InterpolatedRotation interpolated_rotation_diff_start_end(
+      0, 100, 100, 200);
+
+  for (int i = 0; i <= 100; ++i) {
+    gfx::Transform rotation;
+    rotation.Rotate(i);
+    gfx::Transform interpolated = interpolated_rotation.Interpolate(i / 100.0f);
+    CheckApproximatelyEqual(rotation, interpolated);
+    interpolated = interpolated_rotation_diff_start_end.Interpolate(i + 100);
+    CheckApproximatelyEqual(rotation, interpolated);
+  }
+}
+
+TEST(InterpolatedTransformTest, InterpolatedScale) {
+  ui::InterpolatedScale interpolated_scale(gfx::Point3F(0, 0, 0),
+                                           gfx::Point3F(100, 100, 100));
+  ui::InterpolatedScale interpolated_scale_diff_start_end(
+      gfx::Point3F(0, 0, 0), gfx::Point3F(100, 100, 100), 100, 200);
+
+  for (int i = 0; i <= 100; ++i) {
+    gfx::Transform scale;
+    scale.Scale3d(i, i, i);
+    gfx::Transform interpolated = interpolated_scale.Interpolate(i / 100.0f);
+    CheckApproximatelyEqual(scale, interpolated);
+    interpolated = interpolated_scale_diff_start_end.Interpolate(i + 100);
+    CheckApproximatelyEqual(scale, interpolated);
+  }
+}
+
+TEST(InterpolatedTransformTest, InterpolatedTranslate) {
+  ui::InterpolatedTranslation interpolated_xform(gfx::PointF(),
+                                                 gfx::PointF(100.f, 100.f));
+
+  ui::InterpolatedTranslation interpolated_xform_diff_start_end(
+      gfx::PointF(), gfx::PointF(100.f, 100.f), 100, 200);
+
+  for (int i = 0; i <= 100; ++i) {
+    gfx::Transform xform;
+    xform.Translate(i, i);
+    gfx::Transform interpolated = interpolated_xform.Interpolate(i / 100.0f);
+    CheckApproximatelyEqual(xform, interpolated);
+    interpolated = interpolated_xform_diff_start_end.Interpolate(i + 100);
+    CheckApproximatelyEqual(xform, interpolated);
+  }
+}
+
+TEST(InterpolatedTransformTest, InterpolatedTranslate3d) {
+  ui::InterpolatedTranslation interpolated_xform(gfx::Point3F(0, 0, 0),
+                                                 gfx::Point3F(100, 100, 100));
+
+  ui::InterpolatedTranslation interpolated_xform_diff_start_end(
+      gfx::Point3F(0, 0, 0), gfx::Point3F(100, 100, 100), 100, 200);
+
+  for (int i = 0; i <= 100; ++i) {
+    gfx::Transform xform;
+    xform.Translate3d(i, i, i);
+    gfx::Transform interpolated = interpolated_xform.Interpolate(i / 100.0f);
+    CheckApproximatelyEqual(xform, interpolated);
+    interpolated = interpolated_xform_diff_start_end.Interpolate(i + 100);
+    CheckApproximatelyEqual(xform, interpolated);
+  }
+}
+
+TEST(InterpolatedTransformTest, InterpolatedRotationAboutPivot) {
+  gfx::Point pivot(100, 100);
+  gfx::Point above_pivot(100, 200);
+  ui::InterpolatedRotation rot(0, 90);
+  ui::InterpolatedTransformAboutPivot interpolated_xform(
+      pivot, std::make_unique<ui::InterpolatedRotation>(0, 90));
+  gfx::Transform result = interpolated_xform.Interpolate(0.0f);
+  CheckApproximatelyEqual(gfx::Transform(), result);
+  result = interpolated_xform.Interpolate(1.0f);
+  gfx::Point expected_result = pivot;
+  result.TransformPoint(&pivot);
+  EXPECT_EQ(expected_result, pivot);
+  expected_result = gfx::Point(0, 100);
+  result.TransformPoint(&above_pivot);
+  EXPECT_EQ(expected_result, above_pivot);
+}
+
+TEST(InterpolatedTransformTest, InterpolatedScaleAboutPivot) {
+  gfx::Point pivot(100, 100);
+  gfx::Point above_pivot(100, 200);
+  ui::InterpolatedTransformAboutPivot interpolated_xform(
+      pivot, std::make_unique<ui::InterpolatedScale>(gfx::Point3F(1, 1, 1),
+                                                     gfx::Point3F(2, 2, 2)));
+  gfx::Transform result = interpolated_xform.Interpolate(0.0f);
+  CheckApproximatelyEqual(gfx::Transform(), result);
+  result = interpolated_xform.Interpolate(1.0f);
+  gfx::Point expected_result = pivot;
+  result.TransformPoint(&pivot);
+  EXPECT_EQ(expected_result, pivot);
+  expected_result = gfx::Point(100, 300);
+  result.TransformPoint(&above_pivot);
+  EXPECT_EQ(expected_result, above_pivot);
+}
+
+ui::InterpolatedTransform* GetScreenRotation(int degrees, bool reversed) {
+  gfx::Point old_pivot;
+  gfx::Point new_pivot;
+
+  int width = 1920;
+  int height = 180;
+
+  switch (degrees) {
+    case 90:
+      new_pivot = gfx::Point(width, 0);
+      break;
+    case -90:
+      new_pivot = gfx::Point(0, height);
+      break;
+    case 180:
+    case 360:
+      new_pivot = old_pivot = gfx::Point(width / 2, height / 2);
+      break;
+  }
+
+  std::unique_ptr<ui::InterpolatedTransform> rotation =
+      std::make_unique<ui::InterpolatedTransformAboutPivot>(
+          old_pivot, std::make_unique<ui::InterpolatedRotation>(
+                         reversed ? degrees : 0, reversed ? 0 : degrees));
+
+  std::unique_ptr<ui::InterpolatedTransform> translation =
+      std::make_unique<ui::InterpolatedTranslation>(
+          gfx::PointF(), gfx::PointF(new_pivot.x() - old_pivot.x(),
+                                     new_pivot.y() - old_pivot.y()));
+
+  float scale_factor = 0.9f;
+  std::unique_ptr<ui::InterpolatedTransform> scale_down =
+      std::make_unique<ui::InterpolatedScale>(1.0f, scale_factor, 0.0f, 0.5f);
+
+  std::unique_ptr<ui::InterpolatedTransform> scale_up =
+      std::make_unique<ui::InterpolatedScale>(1.0f, 1.0f / scale_factor, 0.5f,
+                                              1.0f);
+
+  std::unique_ptr<ui::InterpolatedTransform> to_return =
+      std::make_unique<ui::InterpolatedConstantTransform>(gfx::Transform());
+
+  scale_up->SetChild(std::move(scale_down));
+  translation->SetChild(std::move(scale_up));
+  rotation->SetChild(std::move(translation));
+  to_return->SetChild(std::move(rotation));
+  to_return->SetReversed(reversed);
+
+  return to_return.release();
+}
+
+TEST(InterpolatedTransformTest, ScreenRotationEndsCleanly) {
+  for (int i = 0; i < 2; ++i) {
+    for (int degrees = -360; degrees <= 360; degrees += 90) {
+      const bool reversed = i == 1;
+      std::unique_ptr<ui::InterpolatedTransform> screen_rotation(
+          GetScreenRotation(degrees, reversed));
+      gfx::Transform interpolated = screen_rotation->Interpolate(1.0f);
+      skia::Matrix44& m = interpolated.matrix();
+      // Upper-left 3x3 matrix should all be 0, 1 or -1.
+      for (int row = 0; row < 3; ++row) {
+        for (int col = 0; col < 3; ++col) {
+          float entry = m.get(row, col);
+          EXPECT_TRUE(entry == 0 || entry == 1 || entry == -1);
+        }
+      }
+    }
+  }
+}
+
+ui::InterpolatedTransform* GetMaximize() {
+  gfx::Rect target_bounds(0, 0, 1920, 1080);
+  gfx::Rect initial_bounds(30, 1000, 192, 108);
+
+  float scale_x = static_cast<float>(
+      target_bounds.height()) / initial_bounds.width();
+  float scale_y = static_cast<float>(
+      target_bounds.width()) / initial_bounds.height();
+
+  std::unique_ptr<ui::InterpolatedTransform> scale =
+      std::make_unique<ui::InterpolatedScale>(
+          gfx::Point3F(1, 1, 1), gfx::Point3F(scale_x, scale_y, 1));
+
+  std::unique_ptr<ui::InterpolatedTransform> translation =
+      std::make_unique<ui::InterpolatedTranslation>(
+          gfx::PointF(), gfx::PointF(target_bounds.x() - initial_bounds.x(),
+                                     target_bounds.y() - initial_bounds.y()));
+
+  std::unique_ptr<ui::InterpolatedTransform> rotation =
+      std::make_unique<ui::InterpolatedRotation>(0, 4.0f);
+
+  std::unique_ptr<ui::InterpolatedTransform> rotation_about_pivot(
+      std::make_unique<ui::InterpolatedTransformAboutPivot>(
+          gfx::Point(initial_bounds.width() * 0.5,
+                     initial_bounds.height() * 0.5),
+          std::move(rotation)));
+
+  scale->SetChild(std::move(translation));
+  rotation_about_pivot->SetChild(std::move(scale));
+
+  rotation_about_pivot->SetReversed(true);
+
+  return rotation_about_pivot.release();
+}
+
+TEST(InterpolatedTransformTest, MaximizeEndsCleanly) {
+  std::unique_ptr<ui::InterpolatedTransform> maximize(GetMaximize());
+  gfx::Transform interpolated = maximize->Interpolate(1.0f);
+  skia::Matrix44& m = interpolated.matrix();
+  // Upper-left 3x3 matrix should all be 0, 1 or -1.
+  for (int row = 0; row < 3; ++row) {
+    for (int col = 0; col < 3; ++col) {
+      float entry = m.get(row, col);
+      EXPECT_TRUE(entry == 0 || entry == 1 || entry == -1);
+    }
+  }
+}
diff --git a/ui/gfx/ios/NSString+CrStringDrawing.h b/ui/gfx/ios/NSString+CrStringDrawing.h
new file mode 100644
index 0000000..d7c6c49
--- /dev/null
+++ b/ui/gfx/ios/NSString+CrStringDrawing.h
@@ -0,0 +1,65 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IOS_NSSTRING_CRSTRINGDRAWING_H_
+#define UI_GFX_IOS_NSSTRING_CRSTRINGDRAWING_H_
+
+#import <UIKit/UIKit.h>
+
+@interface NSString (CrStringDrawing)
+
+// Calculates and returns the bounding rect for the receiver drawn using the
+// given size and font.
+// This method is implemented as a wrapper around
+// |boundingRectWithSize:options:attributes:context:| using the following values
+// for the parameters:
+//  - size: the provided |size|
+//  - options: NSStringDrawingUsesLineFragmentOrigin
+//  - attributes: a NSDictionary with the provided |font|
+//  - context: nil.
+//
+// Note that the rect returned may contain fractional values.
+- (CGRect)cr_boundingRectWithSize:(CGSize)size
+                             font:(UIFont*)font;
+
+// Convenience wrapper to just return the size of |boundingRectWithSize:font:|.
+//
+// Note that the size returned may contain fractional values.
+- (CGSize)cr_boundingSizeWithSize:(CGSize)size
+                             font:(UIFont*)font;
+
+// Returns the size of the string if it were to be rendered with the specified
+// font on a single line. The width and height of the CGSize returned are
+// pixel-aligned.
+//
+// This method is a convenience wrapper around sizeWithAttributes: to avoid
+// boilerplate required to put |font| in a dictionary of attributes. Do not pass
+// nil into this method.
+- (CGSize)cr_pixelAlignedSizeWithFont:(UIFont*)font;
+
+// Deprecated: Use cr_pixelAlignedSizeWithFont: or sizeWithAttributes:
+// Provides a drop-in replacement for sizeWithFont:, which was deprecated in iOS
+// 7 in favor of -sizeWithAttributes:. Specifically, this method will return
+// CGSizeZero if |font| is nil, and the width and height returned are rounded up
+// to integer values.
+// TODO(lliabraa): This method was added to ease the transition off of the
+// deprecated sizeWithFont: method. New call sites should not be added and
+// existing call sites should be audited to determine the correct behavior for
+// nil |font| and rounding, then replaced with cr_pixelAlignedSizeWithFont: or
+// sizeWithAttributes: (crbug.com/364419).
+- (CGSize)cr_sizeWithFont:(UIFont*)font;
+
+// If |index| is 0, returns an empty string.
+// If |index| is >= than self.length, returns self.
+// Otherwise, returns string cut to have |index| characters with an
+// ellipsis at the end.
+- (NSString*)cr_stringByCuttingToIndex:(NSUInteger)index;
+
+// Returns an elided version of string that fits in |bounds|.
+// System font of Label size is used for determining the string drawing size.
+- (NSString*)cr_stringByElidingToFitSize:(CGSize)bounds;
+
+@end
+
+#endif  // UI_GFX_IOS_NSSTRING_CRSTRINGDRAWING_H_
diff --git a/ui/gfx/ios/NSString+CrStringDrawing.mm b/ui/gfx/ios/NSString+CrStringDrawing.mm
new file mode 100644
index 0000000..f482ea1
--- /dev/null
+++ b/ui/gfx/ios/NSString+CrStringDrawing.mm
@@ -0,0 +1,74 @@
+// Copyright 2014 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.
+
+#import "ui/gfx/ios/NSString+CrStringDrawing.h"
+
+#include <ostream>
+
+#include <stddef.h>
+
+#include "base/check.h"
+#include "ui/gfx/ios/uikit_util.h"
+
+@implementation NSString (CrStringDrawing)
+
+- (CGRect)cr_boundingRectWithSize:(CGSize)size
+                             font:(UIFont*)font {
+  NSDictionary* attributes = font ? @{NSFontAttributeName: font} : @{};
+  return [self boundingRectWithSize:size
+                            options:NSStringDrawingUsesLineFragmentOrigin
+                         attributes:attributes
+                            context:nil];
+}
+
+- (CGSize)cr_boundingSizeWithSize:(CGSize)size
+                             font:(UIFont*)font {
+  return [self cr_boundingRectWithSize:size font:font].size;
+}
+
+- (CGSize)cr_pixelAlignedSizeWithFont:(UIFont*)font {
+  DCHECK(font) << "|font| can not be nil; it is used as a NSDictionary value";
+  NSDictionary* attributes = @{ NSFontAttributeName : font };
+  return ui::AlignSizeToUpperPixel([self sizeWithAttributes:attributes]);
+}
+
+- (CGSize)cr_sizeWithFont:(UIFont*)font {
+  if (!font)
+    return CGSizeZero;
+  NSDictionary* attributes = @{ NSFontAttributeName : font };
+  CGSize size = [self sizeWithAttributes:attributes];
+  return CGSizeMake(ceil(size.width), ceil(size.height));
+}
+
+- (NSString*)cr_stringByCuttingToIndex:(NSUInteger)index {
+  if (index == 0)
+    return @"";
+  if (index >= [self length])
+    return [[self retain] autorelease];
+  return [[self substringToIndex:(index - 1)] stringByAppendingString:@"…"];
+}
+
+- (NSString*)cr_stringByElidingToFitSize:(CGSize)bounds {
+  CGSize sizeForGuess = CGSizeMake(bounds.width, CGFLOAT_MAX);
+  // Use binary search on the string's length.
+  size_t lo = 0;
+  size_t hi = [self length];
+  size_t guess = 0;
+  for (guess = (lo + hi) / 2; lo < hi; guess = (lo + hi) / 2) {
+    NSString* tempString = [self cr_stringByCuttingToIndex:guess];
+    UIFont* font = [UIFont systemFontOfSize:[UIFont labelFontSize]];
+    CGSize sizeGuess =
+        [tempString cr_boundingSizeWithSize:sizeForGuess font:font];
+    if (sizeGuess.height > bounds.height) {
+      hi = guess - 1;
+      if (hi < lo)
+        hi = lo;
+    } else {
+      lo = guess + 1;
+    }
+  }
+  return [self cr_stringByCuttingToIndex:lo];
+}
+
+@end
diff --git a/ui/gfx/ios/NSString+CrStringDrawing_unittest.mm b/ui/gfx/ios/NSString+CrStringDrawing_unittest.mm
new file mode 100644
index 0000000..b33a895
--- /dev/null
+++ b/ui/gfx/ios/NSString+CrStringDrawing_unittest.mm
@@ -0,0 +1,172 @@
+// Copyright 2014 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.
+#import "ui/gfx/ios/NSString+CrStringDrawing.h"
+
+#include "base/mac/scoped_nsobject.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/sys_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/gtest_mac.h"
+#include "testing/platform_test.h"
+
+namespace {
+
+typedef PlatformTest NSStringCrStringDrawing;
+
+// These tests verify that the category methods return the same values as the
+// deprecated methods, so ignore warnings about using deprecated methods.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+// Verifies that |cr_boundingSizeWithSize| returns the same size as the
+// deprecated |sizeWithFont:constrainedToSize| for most values.
+// Note that the methods return different values in a few cases (so they are not
+// included in the test cases):
+//  - the constrained size.width is less than a character.
+//  - the constrained size.height is less than the font height.
+//  - the string is empty.
+TEST_F(NSStringCrStringDrawing, BoundingSizeWithSize) {
+  NSArray* fonts = @[
+    [UIFont systemFontOfSize:16],
+    [UIFont boldSystemFontOfSize:10],
+    [UIFont fontWithName:@"Helvetica" size:12.0],
+  ];
+  NSArray* strings = @[
+    @"Test",
+    @"multi word test",
+    @"你好",
+    @"★ This is a test string that is very long.",
+  ];
+  NSArray* sizes = @[
+    [NSValue valueWithCGSize:CGSizeMake(20, 100)],
+    [NSValue valueWithCGSize:CGSizeMake(100, 100)],
+    [NSValue valueWithCGSize:CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX)],
+  ];
+  for (UIFont* font in fonts) {
+    for (NSString* string in strings) {
+      for (NSValue* sizeValue in sizes) {
+        CGSize test_size = [sizeValue CGSizeValue];
+        std::string test_tag = base::StringPrintf(
+            "for string '%s' with font %s and size %s",
+            base::SysNSStringToUTF8(string).c_str(),
+            base::SysNSStringToUTF8([font description]).c_str(),
+            base::SysNSStringToUTF8(NSStringFromCGSize(test_size)).c_str());
+
+        CGSize size_with_font =
+            [string sizeWithFont:font constrainedToSize:test_size];
+        CGSize bounding_size =
+            [string cr_boundingSizeWithSize:test_size font:font];
+        EXPECT_EQ(size_with_font.width, bounding_size.width) << test_tag;
+        EXPECT_EQ(size_with_font.height, bounding_size.height) << test_tag;
+      }
+    }
+  }
+}
+
+TEST_F(NSStringCrStringDrawing, SizeWithFont) {
+  NSArray* fonts = @[
+    [NSNull null],
+    [UIFont systemFontOfSize:16],
+    [UIFont boldSystemFontOfSize:10],
+    [UIFont fontWithName:@"Helvetica" size:12.0],
+  ];
+  for (UIFont* font in fonts) {
+    if ([font isEqual:[NSNull null]])
+      font = nil;
+    std::string font_tag = "with font ";
+    font_tag.append(
+        base::SysNSStringToUTF8(font ? [font description] : @"nil"));
+    EXPECT_EQ([@"" sizeWithFont:font].width,
+              [@"" cr_sizeWithFont:font].width) << font_tag;
+    EXPECT_EQ([@"" sizeWithFont:font].height,
+              [@"" cr_sizeWithFont:font].height) << font_tag;
+    EXPECT_EQ([@"Test" sizeWithFont:font].width,
+              [@"Test" cr_sizeWithFont:font].width) << font_tag;
+    EXPECT_EQ([@"Test" sizeWithFont:font].height,
+              [@"Test" cr_sizeWithFont:font].height) << font_tag;
+    EXPECT_EQ([@"你好" sizeWithFont:font].width,
+              [@"你好" cr_sizeWithFont:font].width) << font_tag;
+    EXPECT_EQ([@"你好" sizeWithFont:font].height,
+              [@"你好" cr_sizeWithFont:font].height) << font_tag;
+    NSString* long_string = @"★ This is a test string that is very long.";
+    EXPECT_EQ([long_string sizeWithFont:font].width,
+              [long_string cr_sizeWithFont:font].width) << font_tag;
+    EXPECT_EQ([long_string sizeWithFont:font].height,
+              [long_string cr_sizeWithFont:font].height) << font_tag;
+  }
+}
+#pragma clang diagnostic pop  // ignored "-Wdeprecated-declarations"
+
+TEST_F(NSStringCrStringDrawing, PixelAlignedSizeWithFont) {
+  NSArray* fonts = @[
+    [UIFont systemFontOfSize:16],
+    [UIFont boldSystemFontOfSize:10],
+    [UIFont fontWithName:@"Helvetica" size:12.0],
+  ];
+  NSArray* strings = @[
+    @"",
+    @"Test",
+    @"你好",
+    @"★ This is a test string that is very long.",
+  ];
+  for (UIFont* font in fonts) {
+    NSDictionary* attributes = @{ NSFontAttributeName : font };
+
+    for (NSString* string in strings) {
+      std::string test_tag = base::StringPrintf("for string '%s' with font %s",
+          base::SysNSStringToUTF8(string).c_str(),
+          base::SysNSStringToUTF8([font description]).c_str());
+
+      CGSize size_with_attributes = [string sizeWithAttributes:attributes];
+      CGSize size_with_pixel_aligned =
+          [string cr_pixelAlignedSizeWithFont:font];
+
+      // Verify that the pixel_aligned size is always rounded up (i.e. the size
+      // returned from sizeWithAttributes: is less than or equal to the pixel-
+      // aligned size).
+      EXPECT_LE(size_with_attributes.width,
+                size_with_pixel_aligned.width) << test_tag;
+      EXPECT_LE(size_with_attributes.height,
+                size_with_pixel_aligned.height) << test_tag;
+
+      // Verify that the pixel_aligned size is never more than a pixel different
+      // than the size returned from sizeWithAttributes:.
+      static CGFloat scale = [[UIScreen mainScreen] scale];
+      EXPECT_NEAR(size_with_attributes.width * scale,
+                  size_with_pixel_aligned.width * scale,
+                  0.9999) << test_tag;
+      EXPECT_NEAR(size_with_attributes.height * scale,
+                  size_with_pixel_aligned.height * scale,
+                  0.9999) << test_tag;
+
+      // Verify that the pixel-aligned value is pixel-aligned.
+      EXPECT_FLOAT_EQ(roundf(size_with_pixel_aligned.width * scale),
+                      size_with_pixel_aligned.width * scale) << test_tag;
+      EXPECT_FLOAT_EQ(roundf(size_with_pixel_aligned.height * scale),
+                      size_with_pixel_aligned.height * scale) << test_tag;
+    }
+  }
+}
+
+TEST_F(NSStringCrStringDrawing, CutString) {
+  EXPECT_NSEQ(@"foo", [@"foo" cr_stringByCuttingToIndex:4]);
+  EXPECT_NSEQ(@"bar", [@"bar" cr_stringByCuttingToIndex:3]);
+  EXPECT_NSEQ(@"f…", [@"foo" cr_stringByCuttingToIndex:2]);
+  EXPECT_NSEQ(@"…", [@"bar" cr_stringByCuttingToIndex:1]);
+  EXPECT_NSEQ(@"", [@"foo" cr_stringByCuttingToIndex:0]);
+}
+
+TEST_F(NSStringCrStringDrawing, ElideStringToFitInRect) {
+  NSString* result =
+      [@"lorem ipsum dolores" cr_stringByElidingToFitSize:CGSizeZero];
+  EXPECT_NSEQ(@"", result);
+  result = [@"lorem ipsum dolores"
+      cr_stringByElidingToFitSize:CGSizeMake(1000, 1000)];
+  EXPECT_NSEQ(@"lorem ipsum dolores", result);
+  result =
+      [@"lorem ipsum dolores" cr_stringByElidingToFitSize:CGSizeMake(30, 50)];
+  EXPECT_TRUE([@"lorem ipsum dolores" length] > [result length]);
+}
+
+}  // namespace
diff --git a/ui/gfx/ios/OWNERS b/ui/gfx/ios/OWNERS
new file mode 100644
index 0000000..ae82009
--- /dev/null
+++ b/ui/gfx/ios/OWNERS
@@ -0,0 +1,2 @@
+rohitrao@chromium.org
+sdefresne@chromium.org
diff --git a/ui/gfx/ios/uikit_util.h b/ui/gfx/ios/uikit_util.h
new file mode 100644
index 0000000..fbacda3
--- /dev/null
+++ b/ui/gfx/ios/uikit_util.h
@@ -0,0 +1,26 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IOS_UIKIT_UTIL_H_
+#define UI_GFX_IOS_UIKIT_UTIL_H_
+
+#import <UIKit/UIKit.h>
+
+#include "base/compiler_specific.h"
+
+// UI Util containing functions that require UIKit.
+
+namespace ui {
+
+// Returns the closest pixel-aligned value higher than |value|, taking the scale
+// factor into account. At a scale of 1, equivalent to ceil().
+CGFloat AlignValueToUpperPixel(CGFloat value) WARN_UNUSED_RESULT;
+
+// Returns the size resulting from applying AlignToUpperPixel to both
+// components.
+CGSize AlignSizeToUpperPixel(CGSize size) WARN_UNUSED_RESULT;
+
+} // namespace ui
+
+#endif  // UI_GFX_IOS_UIKIT_UTIL_H_
diff --git a/ui/gfx/ios/uikit_util.mm b/ui/gfx/ios/uikit_util.mm
new file mode 100644
index 0000000..2e0bfdb
--- /dev/null
+++ b/ui/gfx/ios/uikit_util.mm
@@ -0,0 +1,23 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/ios/uikit_util.h"
+
+#import <UIKit/UIKit.h>
+
+#include <cmath>
+
+namespace ui {
+
+CGFloat AlignValueToUpperPixel(CGFloat value) {
+  CGFloat scale = [[UIScreen mainScreen] scale];
+  return std::ceil(value * scale) / scale;
+}
+
+CGSize AlignSizeToUpperPixel(CGSize size) {
+  return CGSizeMake(AlignValueToUpperPixel(size.width),
+                    AlignValueToUpperPixel(size.height));
+}
+
+} // namespace ui
diff --git a/ui/gfx/ios/uikit_util_unittest.mm b/ui/gfx/ios/uikit_util_unittest.mm
new file mode 100644
index 0000000..269b4b3
--- /dev/null
+++ b/ui/gfx/ios/uikit_util_unittest.mm
@@ -0,0 +1,52 @@
+// Copyright 2014 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.
+
+#import <Foundation/Foundation.h>
+#include <stddef.h>
+
+#include "base/cxx17_backports.h"
+#include "testing/platform_test.h"
+#import "ui/gfx/ios/uikit_util.h"
+
+namespace {
+
+typedef PlatformTest UIKitUtilTest;
+
+TEST_F(UIKitUtilTest, AlignValueToUpperPixel) {
+   CGFloat scale = [[UIScreen mainScreen] scale];
+   // Pick a few interesting values: already aligned, aligned on retina, and
+   // some unaligned values that would round differently. Ensure that all are
+   // "integer" values within <1 of the original value in the scaled space.
+   CGFloat test_values[] = { 10.0, 55.5, 3.1, 2.9 };
+   const CGFloat kMaxAlignDelta = 0.9999;
+   size_t value_count = base::size(test_values);
+   for (unsigned int i = 0; i < value_count; ++i) {
+     CGFloat aligned = ui::AlignValueToUpperPixel(test_values[i]);
+     EXPECT_FLOAT_EQ(aligned * scale, floor(aligned * scale));
+     EXPECT_NEAR(aligned * scale, test_values[i] * scale, kMaxAlignDelta);
+   }
+}
+
+TEST_F(UIKitUtilTest, AlignSizeToUpperPixel) {
+  CGFloat scale = [[UIScreen mainScreen] scale];
+  // Pick a few interesting values: already aligned, aligned on retina, and
+  // some unaligned values that would round differently. Ensure that all are
+  // "integer" values within <1 of the original value in the scaled space.
+  CGFloat test_values[] = { 10.0, 55.5, 3.1, 2.9 };
+  const CGFloat kMaxAlignDelta = 0.9999;
+  size_t value_count = base::size(test_values);
+  for (unsigned int i = 0; i < value_count; ++i) {
+    CGFloat width = test_values[i];
+    CGFloat height = test_values[(i + 1) % value_count];
+    CGSize alignedSize = ui::AlignSizeToUpperPixel(CGSizeMake(width, height));
+    EXPECT_FLOAT_EQ(floor(alignedSize.width * scale),
+                    alignedSize.width * scale);
+    EXPECT_FLOAT_EQ(floor(alignedSize.height * scale),
+                    alignedSize.height * scale);
+    EXPECT_NEAR(width * scale, alignedSize.width * scale, kMaxAlignDelta);
+    EXPECT_NEAR(height * scale, alignedSize.height * scale, kMaxAlignDelta);
+  }
+}
+
+}  // namespace
diff --git a/ui/gfx/ipc/BUILD.gn b/ui/gfx/ipc/BUILD.gn
new file mode 100644
index 0000000..9767b92
--- /dev/null
+++ b/ui/gfx/ipc/BUILD.gn
@@ -0,0 +1,30 @@
+# Copyright 2014 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.
+
+component("ipc") {
+  output_name = "gfx_ipc"
+
+  sources = [
+    "gfx_ipc_export.h",
+    "gfx_param_traits.cc",
+    "gfx_param_traits.h",
+    "gfx_param_traits_macros.h",
+  ]
+
+  defines = [ "GFX_IPC_IMPLEMENTATION" ]
+
+  public_deps = [
+    "//base",
+    "//ipc",
+    "//ui/gfx:memory_buffer",
+    "//ui/gfx:selection_bound",
+    "//ui/gfx/ipc/geometry",
+    "//ui/gfx/range",
+  ]
+
+  frameworks = [
+    "CoreFoundation.framework",
+    "IOSurface.framework",
+  ]
+}
diff --git a/ui/gfx/ipc/OWNERS b/ui/gfx/ipc/OWNERS
new file mode 100644
index 0000000..146c3c3
--- /dev/null
+++ b/ui/gfx/ipc/OWNERS
@@ -0,0 +1,2 @@
+per-file *_param_traits*.*=set noparent
+per-file *_param_traits*.*=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/ipc/buffer_types/BUILD.gn b/ui/gfx/ipc/buffer_types/BUILD.gn
new file mode 100644
index 0000000..3cf5eca
--- /dev/null
+++ b/ui/gfx/ipc/buffer_types/BUILD.gn
@@ -0,0 +1,22 @@
+# Copyright 2018 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.
+
+component("buffer_types") {
+  output_name = "gfx_ipc_buffer_types"
+
+  sources = [
+    "gfx_ipc_export.h",
+    "gfx_param_traits.cc",
+    "gfx_param_traits.h",
+    "gfx_param_traits_macros.h",
+  ]
+
+  defines = [ "GFX_IPC_BUFFER_TYPES_IMPLEMENTATION" ]
+
+  public_deps = [
+    "//base",
+    "//ipc",
+    "//ui/gfx:buffer_types",
+  ]
+}
diff --git a/ui/gfx/ipc/buffer_types/OWNERS b/ui/gfx/ipc/buffer_types/OWNERS
new file mode 100644
index 0000000..146c3c3
--- /dev/null
+++ b/ui/gfx/ipc/buffer_types/OWNERS
@@ -0,0 +1,2 @@
+per-file *_param_traits*.*=set noparent
+per-file *_param_traits*.*=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/ipc/buffer_types/gfx_ipc_export.h b/ui/gfx/ipc/buffer_types/gfx_ipc_export.h
new file mode 100644
index 0000000..83a48df
--- /dev/null
+++ b/ui/gfx/ipc/buffer_types/gfx_ipc_export.h
@@ -0,0 +1,29 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_BUFFER_TYPES_GFX_IPC_EXPORT_H_
+#define UI_GFX_IPC_BUFFER_TYPES_GFX_IPC_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_IPC_BUFFER_TYPES_IMPLEMENTATION)
+#define GFX_IPC_BUFFER_TYPES_EXPORT __declspec(dllexport)
+#else
+#define GFX_IPC_BUFFER_TYPES_EXPORT __declspec(dllimport)
+#endif  // defined(GFX_IPC_BUFFER_TYPES_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_IPC_BUFFER_TYPES_IMPLEMENTATION)
+#define GFX_IPC_BUFFER_TYPES_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_IPC_BUFFER_TYPES_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_IPC_BUFFER_TYPES_EXPORT
+#endif
+
+#endif  // UI_GFX_IPC_BUFFER_TYPES_GFX_IPC_EXPORT_H_
diff --git a/ui/gfx/ipc/buffer_types/gfx_param_traits.cc b/ui/gfx/ipc/buffer_types/gfx_param_traits.cc
new file mode 100644
index 0000000..507b1e7
--- /dev/null
+++ b/ui/gfx/ipc/buffer_types/gfx_param_traits.cc
@@ -0,0 +1,59 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/ipc/buffer_types/gfx_param_traits.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <string>
+
+#include "base/strings/stringprintf.h"
+
+namespace IPC {
+
+void ParamTraits<gfx::BufferUsageAndFormat>::Write(
+    base::Pickle* m,
+    const gfx::BufferUsageAndFormat& p) {
+  WriteParam(m, p.usage);
+  WriteParam(m, p.format);
+}
+
+bool ParamTraits<gfx::BufferUsageAndFormat>::Read(
+    const base::Pickle* m,
+    base::PickleIterator* iter,
+    gfx::BufferUsageAndFormat* r) {
+  if (!ReadParam(m, iter, &r->usage) || !ReadParam(m, iter, &r->format))
+    return false;
+  return true;
+}
+
+void ParamTraits<gfx::BufferUsageAndFormat>::Log(
+    const gfx::BufferUsageAndFormat& p,
+    std::string* l) {
+  l->append(base::StringPrintf("(%d, %d)", p.usage, p.format));
+}
+
+}  // namespace IPC
+
+// Generate param traits write methods.
+#include "ipc/param_traits_write_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_GFX_BUFFER_TYPES_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/buffer_types/gfx_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits read methods.
+#include "ipc/param_traits_read_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_GFX_BUFFER_TYPES_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/buffer_types/gfx_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits log methods.
+#include "ipc/param_traits_log_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_GFX_BUFFER_TYPES_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/buffer_types/gfx_param_traits_macros.h"
+}  // namespace IPC
diff --git a/ui/gfx/ipc/buffer_types/gfx_param_traits.h b/ui/gfx/ipc/buffer_types/gfx_param_traits.h
new file mode 100644
index 0000000..6bef3e5
--- /dev/null
+++ b/ui/gfx/ipc/buffer_types/gfx_param_traits.h
@@ -0,0 +1,29 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_BUFFER_TYPES_GFX_PARAM_TRAITS_H_
+#define UI_GFX_IPC_BUFFER_TYPES_GFX_PARAM_TRAITS_H_
+
+#include <string>
+
+#include "ipc/ipc_message_utils.h"
+#include "ipc/param_traits_macros.h"
+#include "ui/gfx/ipc/buffer_types/gfx_ipc_export.h"
+#include "ui/gfx/ipc/buffer_types/gfx_param_traits_macros.h"
+
+namespace IPC {
+
+template <>
+struct GFX_IPC_BUFFER_TYPES_EXPORT ParamTraits<gfx::BufferUsageAndFormat> {
+  typedef gfx::BufferUsageAndFormat param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+}  // namespace IPC
+
+#endif  // UI_GFX_IPC_BUFFER_TYPES_GFX_PARAM_TRAITS_H_
diff --git a/ui/gfx/ipc/buffer_types/gfx_param_traits_macros.h b/ui/gfx/ipc/buffer_types/gfx_param_traits_macros.h
new file mode 100644
index 0000000..502a4f1
--- /dev/null
+++ b/ui/gfx/ipc/buffer_types/gfx_param_traits_macros.h
@@ -0,0 +1,27 @@
+// Copyright 2018 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.
+
+// Singly or multiply-included shared traits file depending upon circumstances.
+// This allows the use of IPC serialization macros in more than one IPC message
+// file.
+#ifndef UI_GFX_IPC_GFX_BUFFER_TYPES_PARAM_TRAITS_MACROS_H_
+#define UI_GFX_IPC_GFX_BUFFER_TYPES_PARAM_TRAITS_MACROS_H_
+
+#include "build/build_config.h"
+#include "ipc/ipc_message_macros.h"
+#include "ui/gfx/buffer_types.h"
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT GFX_IPC_BUFFER_TYPES_EXPORT
+
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::BufferFormat, gfx::BufferFormat::LAST)
+
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::BufferUsage, gfx::BufferUsage::LAST)
+
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::BufferPlane, gfx::BufferPlane::LAST)
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT
+
+#endif  // UI_GFX_IPC_GFX_BUFFER_TYPES_PARAM_TRAITS_MACROS_H_
diff --git a/ui/gfx/ipc/color/BUILD.gn b/ui/gfx/ipc/color/BUILD.gn
new file mode 100644
index 0000000..a9ab032
--- /dev/null
+++ b/ui/gfx/ipc/color/BUILD.gn
@@ -0,0 +1,23 @@
+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+component("color") {
+  output_name = "gfx_ipc_color"
+
+  sources = [
+    "gfx_ipc_color_export.h",
+    "gfx_param_traits.cc",
+    "gfx_param_traits.h",
+    "gfx_param_traits_macros.h",
+  ]
+
+  defines = [ "GFX_IPC_COLOR_IMPLEMENTATION" ]
+
+  public_deps = [
+    "//base",
+    "//ipc",
+    "//ui/gfx:color_space",
+    "//ui/gfx/ipc/buffer_types",
+  ]
+}
diff --git a/ui/gfx/ipc/color/OWNERS b/ui/gfx/ipc/color/OWNERS
new file mode 100644
index 0000000..146c3c3
--- /dev/null
+++ b/ui/gfx/ipc/color/OWNERS
@@ -0,0 +1,2 @@
+per-file *_param_traits*.*=set noparent
+per-file *_param_traits*.*=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/ipc/color/gfx_ipc_color_export.h b/ui/gfx/ipc/color/gfx_ipc_color_export.h
new file mode 100644
index 0000000..eae168d
--- /dev/null
+++ b/ui/gfx/ipc/color/gfx_ipc_color_export.h
@@ -0,0 +1,29 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_COLOR_GFX_IPC_COLOR_EXPORT_H_
+#define UI_GFX_IPC_COLOR_GFX_IPC_COLOR_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_IPC_COLOR_IMPLEMENTATION)
+#define GFX_IPC_COLOR_EXPORT __declspec(dllexport)
+#else
+#define GFX_IPC_COLOR_EXPORT __declspec(dllimport)
+#endif  // defined(GFX_IPC_COLOR_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_IPC_COLOR_IMPLEMENTATION)
+#define GFX_IPC_COLOR_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_IPC_COLOR_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_IPC_COLOR_EXPORT
+#endif
+
+#endif  // UI_GFX_IPC_COLOR_GFX_IPC_COLOR_EXPORT_H_
diff --git a/ui/gfx/ipc/color/gfx_param_traits.cc b/ui/gfx/ipc/color/gfx_param_traits.cc
new file mode 100644
index 0000000..2e9b2b5
--- /dev/null
+++ b/ui/gfx/ipc/color/gfx_param_traits.cc
@@ -0,0 +1,95 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/ipc/color/gfx_param_traits.h"
+
+#include "ipc/ipc_message_utils.h"
+#include "ipc/param_traits_macros.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/display_color_spaces.h"
+#include "ui/gfx/ipc/buffer_types/gfx_ipc_export.h"
+#include "ui/gfx/ipc/buffer_types/gfx_param_traits_macros.h"
+
+namespace IPC {
+
+void ParamTraits<gfx::ColorSpace>::Write(base::Pickle* m,
+                                         const gfx::ColorSpace& p) {
+  WriteParam(m, p.primaries_);
+  WriteParam(m, p.transfer_);
+  WriteParam(m, p.matrix_);
+  WriteParam(m, p.range_);
+  WriteParam(m, p.custom_primary_matrix_);
+  WriteParam(m, p.transfer_params_);
+}
+
+bool ParamTraits<gfx::ColorSpace>::Read(const base::Pickle* m,
+                                        base::PickleIterator* iter,
+                                        gfx::ColorSpace* r) {
+  if (!ReadParam(m, iter, &r->primaries_))
+    return false;
+  if (!ReadParam(m, iter, &r->transfer_))
+    return false;
+  if (!ReadParam(m, iter, &r->matrix_))
+    return false;
+  if (!ReadParam(m, iter, &r->range_))
+    return false;
+  if (!ReadParam(m, iter, &r->custom_primary_matrix_))
+    return false;
+  if (!ReadParam(m, iter, &r->transfer_params_))
+    return false;
+  return true;
+}
+
+void ParamTraits<gfx::ColorSpace>::Log(const gfx::ColorSpace& p,
+                                       std::string* l) {
+  l->append("<gfx::ColorSpace>");
+}
+
+void ParamTraits<gfx::DisplayColorSpaces>::Write(
+    base::Pickle* m,
+    const gfx::DisplayColorSpaces& p) {
+  WriteParam(m, p.color_spaces_);
+  WriteParam(m, p.buffer_formats_);
+  WriteParam(m, p.sdr_white_level_);
+}
+
+bool ParamTraits<gfx::DisplayColorSpaces>::Read(const base::Pickle* m,
+                                                base::PickleIterator* iter,
+                                                gfx::DisplayColorSpaces* r) {
+  if (!ReadParam(m, iter, &r->color_spaces_))
+    return false;
+  if (!ReadParam(m, iter, &r->buffer_formats_))
+    return false;
+  if (!ReadParam(m, iter, &r->sdr_white_level_))
+    return false;
+  return true;
+}
+
+void ParamTraits<gfx::DisplayColorSpaces>::Log(const gfx::DisplayColorSpaces& p,
+                                               std::string* l) {
+  l->append("<gfx::DisplayColorSpaces>");
+}
+
+}  // namespace IPC
+
+// Generate param traits write methods.
+#include "ipc/param_traits_write_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/color/gfx_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits read methods.
+#include "ipc/param_traits_read_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/color/gfx_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits log methods.
+#include "ipc/param_traits_log_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/color/gfx_param_traits_macros.h"
+}  // namespace IPC
diff --git a/ui/gfx/ipc/color/gfx_param_traits.h b/ui/gfx/ipc/color/gfx_param_traits.h
new file mode 100644
index 0000000..8969194
--- /dev/null
+++ b/ui/gfx/ipc/color/gfx_param_traits.h
@@ -0,0 +1,44 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_H_
+#define UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_H_
+
+#include "ipc/ipc_message_utils.h"
+#include "ipc/param_traits_macros.h"
+#include "ipc/ipc_message_macros.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/ipc/color/gfx_ipc_color_export.h"
+#include "ui/gfx/ipc/color/gfx_param_traits_macros.h"
+
+namespace gfx {
+class ColorSpace;
+class DisplayColorSpaces;
+}
+
+namespace IPC {
+
+template <>
+struct GFX_IPC_COLOR_EXPORT ParamTraits<gfx::ColorSpace> {
+  typedef gfx::ColorSpace param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_COLOR_EXPORT ParamTraits<gfx::DisplayColorSpaces> {
+  typedef gfx::DisplayColorSpaces param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+}  // namespace IPC
+
+#endif  // UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_H_
diff --git a/ui/gfx/ipc/color/gfx_param_traits_macros.h b/ui/gfx/ipc/color/gfx_param_traits_macros.h
new file mode 100644
index 0000000..bd05adb
--- /dev/null
+++ b/ui/gfx/ipc/color/gfx_param_traits_macros.h
@@ -0,0 +1,44 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_MACROS_H_
+#define UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_MACROS_H_
+
+#include "ipc/ipc_message_utils.h"
+#include "ipc/param_traits_macros.h"
+#include "ipc/ipc_message_macros.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/icc_profile.h"
+#include "ui/gfx/ipc/color/gfx_ipc_color_export.h"
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT GFX_IPC_COLOR_EXPORT
+
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::ColorSpace::PrimaryID,
+                          gfx::ColorSpace::PrimaryID::kMaxValue)
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::ColorSpace::TransferID,
+                          gfx::ColorSpace::TransferID::kMaxValue)
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::ColorSpace::MatrixID,
+                          gfx::ColorSpace::MatrixID::kMaxValue)
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::ColorSpace::RangeID,
+                          gfx::ColorSpace::RangeID::kMaxValue)
+
+IPC_STRUCT_TRAITS_BEGIN(skcms_Matrix3x3)
+  IPC_STRUCT_TRAITS_MEMBER(vals)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(skcms_TransferFunction)
+  IPC_STRUCT_TRAITS_MEMBER(a)
+  IPC_STRUCT_TRAITS_MEMBER(b)
+  IPC_STRUCT_TRAITS_MEMBER(c)
+  IPC_STRUCT_TRAITS_MEMBER(d)
+  IPC_STRUCT_TRAITS_MEMBER(e)
+  IPC_STRUCT_TRAITS_MEMBER(f)
+  IPC_STRUCT_TRAITS_MEMBER(g)
+IPC_STRUCT_TRAITS_END()
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT
+
+#endif  // UI_GFX_IPC_COLOR_GFX_PARAM_TRAITS_MACROS_H_
diff --git a/ui/gfx/ipc/geometry/BUILD.gn b/ui/gfx/ipc/geometry/BUILD.gn
new file mode 100644
index 0000000..b8796b2
--- /dev/null
+++ b/ui/gfx/ipc/geometry/BUILD.gn
@@ -0,0 +1,21 @@
+# Copyright 2014 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.
+
+component("geometry") {
+  output_name = "gfx_ipc_geometry"
+
+  sources = [
+    "gfx_ipc_geometry_export.h",
+    "gfx_param_traits.cc",
+    "gfx_param_traits.h",
+  ]
+
+  defines = [ "GFX_IPC_GEOMETRY_IMPLEMENTATION" ]
+
+  public_deps = [
+    "//base",
+    "//ipc",
+    "//ui/gfx/geometry",
+  ]
+}
diff --git a/ui/gfx/ipc/geometry/OWNERS b/ui/gfx/ipc/geometry/OWNERS
new file mode 100644
index 0000000..146c3c3
--- /dev/null
+++ b/ui/gfx/ipc/geometry/OWNERS
@@ -0,0 +1,2 @@
+per-file *_param_traits*.*=set noparent
+per-file *_param_traits*.*=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/ipc/geometry/gfx_ipc_geometry_export.h b/ui/gfx/ipc/geometry/gfx_ipc_geometry_export.h
new file mode 100644
index 0000000..32a07cd
--- /dev/null
+++ b/ui/gfx/ipc/geometry/gfx_ipc_geometry_export.h
@@ -0,0 +1,29 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_GEOMETRY_GFX_IPC_GEOMETRY_EXPORT_H_
+#define UI_GFX_IPC_GEOMETRY_GFX_IPC_GEOMETRY_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_IPC_GEOMETRY_IMPLEMENTATION)
+#define GFX_IPC_GEOMETRY_EXPORT __declspec(dllexport)
+#else
+#define GFX_IPC_GEOMETRY_EXPORT __declspec(dllimport)
+#endif  // defined(GFX_IPC_GEOMETRY_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_IPC_GEOMETRY_IMPLEMENTATION)
+#define GFX_IPC_GEOMETRY_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_IPC_GEOMETRY_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_IPC_GEOMETRY_EXPORT
+#endif
+
+#endif  // UI_GFX_IPC_GEOMETRY_GFX_IPC_GEOMETRY_EXPORT_H_
diff --git a/ui/gfx/ipc/geometry/gfx_param_traits.cc b/ui/gfx/ipc/geometry/gfx_param_traits.cc
new file mode 100644
index 0000000..20bc0882
--- /dev/null
+++ b/ui/gfx/ipc/geometry/gfx_param_traits.cc
@@ -0,0 +1,217 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/ipc/geometry/gfx_param_traits.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <string>
+
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+
+namespace IPC {
+
+void ParamTraits<gfx::Point>::Write(base::Pickle* m, const gfx::Point& p) {
+  WriteParam(m, p.x());
+  WriteParam(m, p.y());
+}
+
+bool ParamTraits<gfx::Point>::Read(const base::Pickle* m,
+                                   base::PickleIterator* iter,
+                                   gfx::Point* r) {
+  int x, y;
+  if (!ReadParam(m, iter, &x) || !ReadParam(m, iter, &y))
+    return false;
+  r->set_x(x);
+  r->set_y(y);
+  return true;
+}
+
+void ParamTraits<gfx::Point>::Log(const gfx::Point& p, std::string* l) {
+  l->append(base::StringPrintf("(%d, %d)", p.x(), p.y()));
+}
+
+void ParamTraits<gfx::PointF>::Write(base::Pickle* m, const gfx::PointF& p) {
+  WriteParam(m, p.x());
+  WriteParam(m, p.y());
+}
+
+bool ParamTraits<gfx::PointF>::Read(const base::Pickle* m,
+                                    base::PickleIterator* iter,
+                                    gfx::PointF* r) {
+  float x, y;
+  if (!ReadParam(m, iter, &x) || !ReadParam(m, iter, &y))
+    return false;
+  r->set_x(x);
+  r->set_y(y);
+  return true;
+}
+
+void ParamTraits<gfx::PointF>::Log(const gfx::PointF& p, std::string* l) {
+  l->append(base::StringPrintf("(%f, %f)", p.x(), p.y()));
+}
+
+void ParamTraits<gfx::Point3F>::Write(base::Pickle* m, const gfx::Point3F& p) {
+  WriteParam(m, p.x());
+  WriteParam(m, p.y());
+  WriteParam(m, p.z());
+}
+
+bool ParamTraits<gfx::Point3F>::Read(const base::Pickle* m,
+                                     base::PickleIterator* iter,
+                                     gfx::Point3F* r) {
+  float x, y, z;
+  if (!ReadParam(m, iter, &x) || !ReadParam(m, iter, &y) ||
+      !ReadParam(m, iter, &z))
+    return false;
+  r->set_x(x);
+  r->set_y(y);
+  r->set_z(z);
+  return true;
+}
+
+void ParamTraits<gfx::Point3F>::Log(const gfx::Point3F& p, std::string* l) {
+  l->append(base::StringPrintf("(%f, %f, %f)", p.x(), p.y(), p.z()));
+}
+
+void ParamTraits<gfx::Size>::Write(base::Pickle* m, const gfx::Size& p) {
+  DCHECK_GE(p.width(), 0);
+  DCHECK_GE(p.height(), 0);
+  int values[2] = {p.width(), p.height()};
+  m->WriteBytes(&values, sizeof(int) * 2);
+}
+
+bool ParamTraits<gfx::Size>::Read(const base::Pickle* m,
+                                  base::PickleIterator* iter,
+                                  gfx::Size* r) {
+  const char* char_values;
+  if (!iter->ReadBytes(&char_values, sizeof(int) * 2))
+    return false;
+  const int* values = reinterpret_cast<const int*>(char_values);
+  if (values[0] < 0 || values[1] < 0)
+    return false;
+  r->set_width(values[0]);
+  r->set_height(values[1]);
+  return true;
+}
+
+void ParamTraits<gfx::Size>::Log(const gfx::Size& p, std::string* l) {
+  l->append(base::StringPrintf("(%d, %d)", p.width(), p.height()));
+}
+
+void ParamTraits<gfx::SizeF>::Write(base::Pickle* m, const gfx::SizeF& p) {
+  float values[2] = {p.width(), p.height()};
+  m->WriteBytes(&values, sizeof(float) * 2);
+}
+
+bool ParamTraits<gfx::SizeF>::Read(const base::Pickle* m,
+                                   base::PickleIterator* iter,
+                                   gfx::SizeF* r) {
+  const char* char_values;
+  if (!iter->ReadBytes(&char_values, sizeof(float) * 2))
+    return false;
+  const float* values = reinterpret_cast<const float*>(char_values);
+  r->set_width(values[0]);
+  r->set_height(values[1]);
+  return true;
+}
+
+void ParamTraits<gfx::SizeF>::Log(const gfx::SizeF& p, std::string* l) {
+  l->append(base::StringPrintf("(%f, %f)", p.width(), p.height()));
+}
+
+void ParamTraits<gfx::Vector2d>::Write(base::Pickle* m,
+                                       const gfx::Vector2d& p) {
+  int values[2] = {p.x(), p.y()};
+  m->WriteBytes(&values, sizeof(int) * 2);
+}
+
+bool ParamTraits<gfx::Vector2d>::Read(const base::Pickle* m,
+                                      base::PickleIterator* iter,
+                                      gfx::Vector2d* r) {
+  const char* char_values;
+  if (!iter->ReadBytes(&char_values, sizeof(int) * 2))
+    return false;
+  const int* values = reinterpret_cast<const int*>(char_values);
+  r->set_x(values[0]);
+  r->set_y(values[1]);
+  return true;
+}
+
+void ParamTraits<gfx::Vector2d>::Log(const gfx::Vector2d& v, std::string* l) {
+  l->append(base::StringPrintf("(%d, %d)", v.x(), v.y()));
+}
+
+void ParamTraits<gfx::Vector2dF>::Write(base::Pickle* m,
+                                        const gfx::Vector2dF& p) {
+  float values[2] = {p.x(), p.y()};
+  m->WriteBytes(&values, sizeof(float) * 2);
+}
+
+bool ParamTraits<gfx::Vector2dF>::Read(const base::Pickle* m,
+                                       base::PickleIterator* iter,
+                                       gfx::Vector2dF* r) {
+  const char* char_values;
+  if (!iter->ReadBytes(&char_values, sizeof(float) * 2))
+    return false;
+  const float* values = reinterpret_cast<const float*>(char_values);
+  r->set_x(values[0]);
+  r->set_y(values[1]);
+  return true;
+}
+
+void ParamTraits<gfx::Vector2dF>::Log(const gfx::Vector2dF& v, std::string* l) {
+  l->append(base::StringPrintf("(%f, %f)", v.x(), v.y()));
+}
+
+void ParamTraits<gfx::Rect>::Write(base::Pickle* m, const gfx::Rect& p) {
+  int values[4] = {p.x(), p.y(), p.width(), p.height()};
+  m->WriteBytes(&values, sizeof(int) * 4);
+}
+
+bool ParamTraits<gfx::Rect>::Read(const base::Pickle* m,
+                                  base::PickleIterator* iter,
+                                  gfx::Rect* r) {
+  const char* char_values;
+  if (!iter->ReadBytes(&char_values, sizeof(int) * 4))
+    return false;
+  const int* values = reinterpret_cast<const int*>(char_values);
+  if (values[2] < 0 || values[3] < 0)
+    return false;
+  r->SetRect(values[0], values[1], values[2], values[3]);
+  return true;
+}
+
+void ParamTraits<gfx::Rect>::Log(const gfx::Rect& p, std::string* l) {
+  l->append(base::StringPrintf("(%d, %d, %d, %d)", p.x(), p.y(), p.width(),
+                               p.height()));
+}
+
+void ParamTraits<gfx::RectF>::Write(base::Pickle* m, const gfx::RectF& p) {
+  float values[4] = {p.x(), p.y(), p.width(), p.height()};
+  m->WriteBytes(&values, sizeof(float) * 4);
+}
+
+bool ParamTraits<gfx::RectF>::Read(const base::Pickle* m,
+                                   base::PickleIterator* iter,
+                                   gfx::RectF* r) {
+  const char* char_values;
+  if (!iter->ReadBytes(&char_values, sizeof(float) * 4))
+    return false;
+  const float* values = reinterpret_cast<const float*>(char_values);
+  r->SetRect(values[0], values[1], values[2], values[3]);
+  return true;
+}
+
+void ParamTraits<gfx::RectF>::Log(const gfx::RectF& p, std::string* l) {
+  l->append(base::StringPrintf("(%f, %f, %f, %f)", p.x(), p.y(), p.width(),
+                               p.height()));
+}
+
+}  // namespace IPC
diff --git a/ui/gfx/ipc/geometry/gfx_param_traits.h b/ui/gfx/ipc/geometry/gfx_param_traits.h
new file mode 100644
index 0000000..3020a09
--- /dev/null
+++ b/ui/gfx/ipc/geometry/gfx_param_traits.h
@@ -0,0 +1,120 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_GEOMETRY_GFX_PARAM_TRAITS_H_
+#define UI_GFX_IPC_GEOMETRY_GFX_PARAM_TRAITS_H_
+
+#include <string>
+
+#include "ipc/ipc_message_utils.h"
+#include "ipc/param_traits_macros.h"
+#include "ui/gfx/ipc/geometry/gfx_ipc_geometry_export.h"
+
+namespace gfx {
+class Point;
+class PointF;
+class Point3F;
+class Rect;
+class RectF;
+class Size;
+class SizeF;
+class Vector2d;
+class Vector2dF;
+}  // namespace gfx
+
+namespace IPC {
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::Point> {
+  typedef gfx::Point param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::PointF> {
+  typedef gfx::PointF param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::Point3F> {
+  typedef gfx::Point3F param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::Size> {
+  typedef gfx::Size param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::SizeF> {
+  typedef gfx::SizeF param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::Vector2d> {
+  typedef gfx::Vector2d param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::Vector2dF> {
+  typedef gfx::Vector2dF param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::Rect> {
+  typedef gfx::Rect param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_GEOMETRY_EXPORT ParamTraits<gfx::RectF> {
+  typedef gfx::RectF param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+}  // namespace IPC
+
+#endif  // UI_GFX_IPC_GEOMETRY_GFX_PARAM_TRAITS_H_
diff --git a/ui/gfx/ipc/gfx_ipc_export.h b/ui/gfx/ipc/gfx_ipc_export.h
new file mode 100644
index 0000000..0362b5b
--- /dev/null
+++ b/ui/gfx/ipc/gfx_ipc_export.h
@@ -0,0 +1,29 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_GFX_IPC_EXPORT_H_
+#define UI_GFX_IPC_GFX_IPC_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_IPC_IMPLEMENTATION)
+#define GFX_IPC_EXPORT __declspec(dllexport)
+#else
+#define GFX_IPC_EXPORT __declspec(dllimport)
+#endif  // defined(GFX_IPC_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_IPC_IMPLEMENTATION)
+#define GFX_IPC_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_IPC_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_IPC_EXPORT
+#endif
+
+#endif  // UI_GFX_IPC_GFX_IPC_EXPORT_H_
diff --git a/ui/gfx/ipc/gfx_param_traits.cc b/ui/gfx/ipc/gfx_param_traits.cc
new file mode 100644
index 0000000..49e2135
--- /dev/null
+++ b/ui/gfx/ipc/gfx_param_traits.cc
@@ -0,0 +1,176 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/ipc/gfx_param_traits.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <string>
+
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/ipc/geometry/gfx_param_traits.h"
+#include "ui/gfx/range/range.h"
+
+#if defined(OS_APPLE)
+#include "ipc/mach_port_mac.h"
+#endif
+
+namespace IPC {
+
+void ParamTraits<gfx::Range>::Write(base::Pickle* m, const gfx::Range& r) {
+  m->WriteUInt32(r.start());
+  m->WriteUInt32(r.end());
+}
+
+bool ParamTraits<gfx::Range>::Read(const base::Pickle* m,
+                                   base::PickleIterator* iter,
+                                   gfx::Range* r) {
+  uint32_t start, end;
+  if (!iter->ReadUInt32(&start) || !iter->ReadUInt32(&end))
+    return false;
+  r->set_start(start);
+  r->set_end(end);
+  return true;
+}
+
+void ParamTraits<gfx::Range>::Log(const gfx::Range& r, std::string* l) {
+  l->append(base::StringPrintf("(%d, %d)", r.start(), r.end()));
+}
+
+#if defined(OS_MAC)
+void ParamTraits<gfx::ScopedRefCountedIOSurfaceMachPort>::Write(
+    base::Pickle* m,
+    const param_type p) {
+  MachPortMac mach_port_mac(p.get());
+  ParamTraits<MachPortMac>::Write(m, mach_port_mac);
+}
+
+bool ParamTraits<gfx::ScopedRefCountedIOSurfaceMachPort>::Read(
+    const base::Pickle* m,
+    base::PickleIterator* iter,
+    param_type* r) {
+  MachPortMac mach_port_mac;
+  if (!ParamTraits<MachPortMac>::Read(m, iter, &mach_port_mac))
+    return false;
+  r->reset(mach_port_mac.get_mach_port());
+  return true;
+}
+
+void ParamTraits<gfx::ScopedRefCountedIOSurfaceMachPort>::Log(
+    const param_type& p,
+    std::string* l) {
+  l->append("IOSurface Mach send right: ");
+  LogParam(p.get(), l);
+}
+
+void ParamTraits<gfx::ScopedIOSurface>::Write(base::Pickle* m,
+                                              const param_type p) {
+  gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port(
+      IOSurfaceCreateMachPort(p.get()));
+  MachPortMac mach_port_mac(io_surface_mach_port.get());
+  ParamTraits<MachPortMac>::Write(m, mach_port_mac);
+}
+
+bool ParamTraits<gfx::ScopedIOSurface>::Read(const base::Pickle* m,
+                                             base::PickleIterator* iter,
+                                             param_type* r) {
+  MachPortMac mach_port_mac;
+  if (!ParamTraits<MachPortMac>::Read(m, iter, &mach_port_mac))
+    return false;
+  gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port(
+      mach_port_mac.get_mach_port());
+  if (io_surface_mach_port)
+    r->reset(IOSurfaceLookupFromMachPort(io_surface_mach_port.get()));
+  else
+    r->reset();
+  return true;
+}
+
+void ParamTraits<gfx::ScopedIOSurface>::Log(const param_type& p,
+                                            std::string* l) {
+  l->append("IOSurface(");
+  if (p) {
+    uint32_t io_surface_id = IOSurfaceGetID(p.get());
+    LogParam(io_surface_id, l);
+  }
+  l->append(")");
+}
+#endif  // defined(OS_MAC)
+
+void ParamTraits<gfx::SelectionBound>::Write(base::Pickle* m,
+                                             const param_type& p) {
+  WriteParam(m, static_cast<uint32_t>(p.type()));
+  WriteParam(m, p.edge_start());
+  WriteParam(m, p.edge_end());
+  WriteParam(m, p.visible_edge_start());
+  WriteParam(m, p.visible_edge_end());
+  WriteParam(m, p.visible());
+}
+
+bool ParamTraits<gfx::SelectionBound>::Read(const base::Pickle* m,
+                                            base::PickleIterator* iter,
+                                            param_type* r) {
+  gfx::SelectionBound::Type type;
+  gfx::PointF edge_start;
+  gfx::PointF edge_end;
+  gfx::PointF visible_edge_start;
+  gfx::PointF visible_edge_end;
+  bool visible = false;
+
+  if (!ReadParam(m, iter, &type) || !ReadParam(m, iter, &edge_start) ||
+      !ReadParam(m, iter, &edge_end) ||
+      !ReadParam(m, iter, &visible_edge_start) ||
+      !ReadParam(m, iter, &visible_edge_end) || !ReadParam(m, iter, &visible)) {
+    return false;
+  }
+
+  r->set_type(type);
+  r->SetEdgeStart(edge_start);
+  r->SetEdgeEnd(edge_end);
+  r->SetVisibleEdgeStart(visible_edge_start);
+  r->SetVisibleEdgeEnd(visible_edge_end);
+  r->set_visible(visible);
+  return true;
+}
+
+void ParamTraits<gfx::SelectionBound>::Log(const param_type& p,
+                                           std::string* l) {
+  l->append("gfx::SelectionBound(");
+  LogParam(static_cast<uint32_t>(p.type()), l);
+  l->append(", ");
+  LogParam(p.edge_start(), l);
+  l->append(", ");
+  LogParam(p.edge_end(), l);
+  l->append(", ");
+  LogParam(p.visible_edge_start(), l);
+  l->append(", ");
+  LogParam(p.visible_edge_end(), l);
+  l->append(", ");
+  LogParam(p.visible(), l);
+  l->append(")");
+}
+
+}  // namespace IPC
+
+// Generate param traits write methods.
+#include "ipc/param_traits_write_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/gfx_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits read methods.
+#include "ipc/param_traits_read_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/gfx_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits log methods.
+#include "ipc/param_traits_log_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/gfx_param_traits_macros.h"
+}  // namespace IPC
diff --git a/ui/gfx/ipc/gfx_param_traits.h b/ui/gfx/ipc/gfx_param_traits.h
new file mode 100644
index 0000000..e9ae63a
--- /dev/null
+++ b/ui/gfx/ipc/gfx_param_traits.h
@@ -0,0 +1,75 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_GFX_PARAM_TRAITS_H_
+#define UI_GFX_IPC_GFX_PARAM_TRAITS_H_
+
+#include <string>
+
+#include "ipc/ipc_message_utils.h"
+#include "ipc/param_traits_macros.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/ipc/gfx_ipc_export.h"
+#include "ui/gfx/ipc/gfx_param_traits_macros.h"
+#include "ui/gfx/selection_bound.h"
+
+#if defined(OS_MAC)
+#include "ui/gfx/mac/io_surface.h"
+#endif
+
+namespace gfx {
+class Range;
+}
+
+namespace IPC {
+
+template <>
+struct GFX_IPC_EXPORT ParamTraits<gfx::Range> {
+  typedef gfx::Range param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+#if defined(OS_MAC)
+template <>
+struct GFX_IPC_EXPORT ParamTraits<gfx::ScopedRefCountedIOSurfaceMachPort> {
+  typedef gfx::ScopedRefCountedIOSurfaceMachPort param_type;
+  static void Write(base::Pickle* m, const param_type p);
+  // Note: Read() passes ownership of the Mach send right from the IPC message
+  // to the ScopedRefCountedIOSurfaceMachPort. Therefore, Read() may only be
+  // called once for a given message, otherwise the singular right will be
+  // managed and released by two objects.
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_IPC_EXPORT ParamTraits<gfx::ScopedIOSurface> {
+  typedef gfx::ScopedIOSurface param_type;
+  static void Write(base::Pickle* m, const param_type p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+#endif  // defined(OS_MAC)
+
+template <>
+struct GFX_IPC_EXPORT ParamTraits<gfx::SelectionBound> {
+  typedef gfx::SelectionBound param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+}  // namespace IPC
+
+#endif  // UI_GFX_IPC_GFX_PARAM_TRAITS_H_
diff --git a/ui/gfx/ipc/gfx_param_traits_macros.h b/ui/gfx/ipc/gfx_param_traits_macros.h
new file mode 100644
index 0000000..d8ce305
--- /dev/null
+++ b/ui/gfx/ipc/gfx_param_traits_macros.h
@@ -0,0 +1,120 @@
+// Copyright 2015 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.
+
+// Singly or multiply-included shared traits file depending upon circumstances.
+// This allows the use of IPC serialization macros in more than one IPC message
+// file.
+#ifndef UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
+#define UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
+
+#include "build/build_config.h"
+#include "ipc/ipc_message_macros.h"
+#include "ui/gfx/ca_layer_params.h"
+#include "ui/gfx/gpu_fence_handle.h"
+#include "ui/gfx/gpu_memory_buffer.h"
+#include "ui/gfx/ipc/gfx_ipc_export.h"
+#include "ui/gfx/presentation_feedback.h"
+#include "ui/gfx/selection_bound.h"
+#include "ui/gfx/swap_result.h"
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+#include "ui/gfx/native_pixmap_handle.h"
+#endif
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT GFX_IPC_EXPORT
+
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::GpuMemoryBufferType,
+                          gfx::GPU_MEMORY_BUFFER_TYPE_LAST)
+
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::SwapResult, gfx::SwapResult::SWAP_RESULT_LAST)
+
+IPC_ENUM_TRAITS_MAX_VALUE(gfx::SelectionBound::Type, gfx::SelectionBound::LAST)
+
+IPC_STRUCT_TRAITS_BEGIN(gfx::CALayerParams)
+  IPC_STRUCT_TRAITS_MEMBER(is_empty)
+#if defined(OS_MAC)
+  IPC_STRUCT_TRAITS_MEMBER(ca_context_id)
+  IPC_STRUCT_TRAITS_MEMBER(io_surface_mach_port)
+  IPC_STRUCT_TRAITS_MEMBER(pixel_size)
+  IPC_STRUCT_TRAITS_MEMBER(scale_factor)
+#endif
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(gfx::GpuMemoryBufferHandle)
+  IPC_STRUCT_TRAITS_MEMBER(id)
+  IPC_STRUCT_TRAITS_MEMBER(type)
+  IPC_STRUCT_TRAITS_MEMBER(region)
+  IPC_STRUCT_TRAITS_MEMBER(offset)
+  IPC_STRUCT_TRAITS_MEMBER(stride)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_FUCHSIA)
+  IPC_STRUCT_TRAITS_MEMBER(native_pixmap_handle)
+#elif defined(OS_APPLE)
+  IPC_STRUCT_TRAITS_MEMBER(io_surface)
+#elif defined(OS_WIN)
+  IPC_STRUCT_TRAITS_MEMBER(dxgi_handle)
+#elif defined(OS_ANDROID)
+  IPC_STRUCT_TRAITS_MEMBER(android_hardware_buffer)
+#endif
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(gfx::GpuMemoryBufferId)
+  IPC_STRUCT_TRAITS_MEMBER(id)
+IPC_STRUCT_TRAITS_END()
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_FUCHSIA)
+IPC_STRUCT_TRAITS_BEGIN(gfx::NativePixmapPlane)
+  IPC_STRUCT_TRAITS_MEMBER(stride)
+  IPC_STRUCT_TRAITS_MEMBER(offset)
+  IPC_STRUCT_TRAITS_MEMBER(size)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  IPC_STRUCT_TRAITS_MEMBER(fd)
+#elif defined(OS_FUCHSIA)
+  IPC_STRUCT_TRAITS_MEMBER(vmo)
+#endif
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(gfx::NativePixmapHandle)
+  IPC_STRUCT_TRAITS_MEMBER(planes)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  IPC_STRUCT_TRAITS_MEMBER(modifier)
+#endif
+#if defined(OS_FUCHSIA)
+  IPC_STRUCT_TRAITS_MEMBER(buffer_collection_id)
+  IPC_STRUCT_TRAITS_MEMBER(buffer_index)
+  IPC_STRUCT_TRAITS_MEMBER(ram_coherency)
+#endif
+IPC_STRUCT_TRAITS_END()
+#endif
+
+IPC_STRUCT_TRAITS_BEGIN(gfx::SwapTimings)
+  IPC_STRUCT_TRAITS_MEMBER(swap_start)
+  IPC_STRUCT_TRAITS_MEMBER(swap_end)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(gfx::SwapResponse)
+  IPC_STRUCT_TRAITS_MEMBER(swap_id)
+  IPC_STRUCT_TRAITS_MEMBER(result)
+  IPC_STRUCT_TRAITS_MEMBER(timings)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(gfx::PresentationFeedback)
+  IPC_STRUCT_TRAITS_MEMBER(timestamp)
+  IPC_STRUCT_TRAITS_MEMBER(interval)
+  IPC_STRUCT_TRAITS_MEMBER(flags)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(gfx::GpuFenceHandle)
+#if defined(OS_POSIX)
+  IPC_STRUCT_TRAITS_MEMBER(owned_fd)
+#endif
+#if defined(OS_WIN)
+  IPC_STRUCT_TRAITS_MEMBER(owned_handle)
+#endif
+IPC_STRUCT_TRAITS_END()
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT
+
+#endif  // UI_GFX_IPC_GFX_PARAM_TRAITS_MACROS_H_
diff --git a/ui/gfx/ipc/skia/BUILD.gn b/ui/gfx/ipc/skia/BUILD.gn
new file mode 100644
index 0000000..fcb670e
--- /dev/null
+++ b/ui/gfx/ipc/skia/BUILD.gn
@@ -0,0 +1,27 @@
+# Copyright 2014 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.
+
+component("skia") {
+  output_name = "gfx_ipc_skia"
+
+  sources = [
+    "gfx_skia_ipc_export.h",
+    "gfx_skia_param_traits.cc",
+    "gfx_skia_param_traits.h",
+  ]
+
+  defines = [ "GFX_SKIA_IPC_IMPLEMENTATION" ]
+
+  deps = [
+    "//base",
+    "//skia",
+    "//ui/gfx",
+    "//ui/gfx/geometry",
+  ]
+
+  public_deps = [
+    "//ipc",
+    "//ui/gfx/ipc",
+  ]
+}
diff --git a/ui/gfx/ipc/skia/OWNERS b/ui/gfx/ipc/skia/OWNERS
new file mode 100644
index 0000000..146c3c3
--- /dev/null
+++ b/ui/gfx/ipc/skia/OWNERS
@@ -0,0 +1,2 @@
+per-file *_param_traits*.*=set noparent
+per-file *_param_traits*.*=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/ipc/skia/gfx_skia_ipc_export.h b/ui/gfx/ipc/skia/gfx_skia_ipc_export.h
new file mode 100644
index 0000000..8ea331d
--- /dev/null
+++ b/ui/gfx/ipc/skia/gfx_skia_ipc_export.h
@@ -0,0 +1,29 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_SKIA_GFX_SKIA_IPC_EXPORT_H_
+#define UI_GFX_IPC_SKIA_GFX_SKIA_IPC_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_SKIA_IPC_IMPLEMENTATION)
+#define GFX_SKIA_IPC_EXPORT __declspec(dllexport)
+#else
+#define GFX_SKIA_IPC_EXPORT __declspec(dllimport)
+#endif  // defined(GFX_SKIA_IPC_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_SKIA_IPC_IMPLEMENTATION)
+#define GFX_SKIA_IPC_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_SKIA_IPC_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_SKIA_IPC_EXPORT
+#endif
+
+#endif  // UI_GFX_IPC_SKIA_GFX_SKIA_IPC_EXPORT_H_
diff --git a/ui/gfx/ipc/skia/gfx_skia_param_traits.cc b/ui/gfx/ipc/skia/gfx_skia_param_traits.cc
new file mode 100644
index 0000000..9da1955
--- /dev/null
+++ b/ui/gfx/ipc/skia/gfx_skia_param_traits.cc
@@ -0,0 +1,134 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/ipc/skia/gfx_skia_param_traits.h"
+
+#include <string>
+
+#include "base/pickle.h"
+#include "ipc/ipc_message_utils.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
+#include "ui/gfx/geometry/transform.h"
+
+// Generate param traits write methods.
+#include "ipc/param_traits_write_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/skia/gfx_skia_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits read methods.
+#include "ipc/param_traits_read_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/skia/gfx_skia_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits log methods.
+#include "ipc/param_traits_log_macros.h"
+namespace IPC {
+#undef UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_MACROS_H_
+#include "ui/gfx/ipc/skia/gfx_skia_param_traits_macros.h"
+}  // namespace IPC
+
+namespace IPC {
+
+void ParamTraits<SkImageInfo>::Write(base::Pickle* m, const SkImageInfo& p) {
+  WriteParam(m, p.colorType());
+  WriteParam(m, p.alphaType());
+  WriteParam(m, p.width());
+  WriteParam(m, p.height());
+}
+
+bool ParamTraits<SkImageInfo>::Read(const base::Pickle* m,
+                                    base::PickleIterator* iter,
+                                    SkImageInfo* r) {
+  SkColorType color_type;
+  SkAlphaType alpha_type;
+  uint32_t width;
+  uint32_t height;
+  if (!ReadParam(m, iter, &color_type) || !ReadParam(m, iter, &alpha_type) ||
+      !ReadParam(m, iter, &width) || !ReadParam(m, iter, &height)) {
+    return false;
+  }
+
+  *r = SkImageInfo::Make(width, height, color_type, alpha_type);
+  return true;
+}
+
+void ParamTraits<SkImageInfo>::Log(const SkImageInfo& p, std::string* l) {
+  l->append("<SkImageInfo>");
+}
+
+void ParamTraits<SkBitmap>::Write(base::Pickle* m, const SkBitmap& p) {
+  WriteParam(m, p.info());
+  size_t pixel_size = p.computeByteSize();
+  m->WriteData(reinterpret_cast<const char*>(p.getPixels()),
+               static_cast<int>(pixel_size));
+}
+
+bool ParamTraits<SkBitmap>::Read(const base::Pickle* m,
+                                 base::PickleIterator* iter,
+                                 SkBitmap* r) {
+  SkImageInfo image_info;
+  if (!ReadParam(m, iter, &image_info))
+    return false;
+
+  const char* bitmap_data;
+  int bitmap_data_size = 0;
+  if (!iter->ReadData(&bitmap_data, &bitmap_data_size))
+    return false;
+  // ReadData() only returns true if bitmap_data_size >= 0.
+
+  if (!r->tryAllocPixels(image_info))
+    return false;
+
+  if (static_cast<size_t>(bitmap_data_size) != r->computeByteSize())
+    return false;
+  memcpy(r->getPixels(), bitmap_data, bitmap_data_size);
+  return true;
+}
+
+void ParamTraits<SkBitmap>::Log(const SkBitmap& p, std::string* l) {
+  l->append("<SkBitmap>");
+  LogParam(p.info(), l);
+}
+
+void ParamTraits<gfx::Transform>::Write(base::Pickle* m, const param_type& p) {
+  SkScalar column_major_data[16];
+  p.matrix().asColMajorf(column_major_data);
+  // We do this in a single write for performance reasons.
+  m->WriteBytes(&column_major_data, sizeof(SkScalar) * 16);
+}
+
+bool ParamTraits<gfx::Transform>::Read(const base::Pickle* m,
+                                       base::PickleIterator* iter,
+                                       param_type* r) {
+  const char* column_major_data;
+  if (!iter->ReadBytes(&column_major_data, sizeof(SkScalar) * 16))
+    return false;
+  r->matrix().setColMajor(reinterpret_cast<const SkScalar*>(column_major_data));
+  return true;
+}
+
+void ParamTraits<gfx::Transform>::Log(
+    const param_type& p, std::string* l) {
+#ifdef SK_SCALAR_IS_FLOAT
+  float row_major_data[16];
+  p.matrix().asRowMajorf(row_major_data);
+#else
+  double row_major_data[16];
+  p.matrix().asRowMajord(row_major_data);
+#endif
+  l->append("(");
+  for (int i = 0; i < 16; ++i) {
+    if (i > 0)
+      l->append(", ");
+    LogParam(row_major_data[i], l);
+  }
+  l->append(") ");
+}
+
+}  // namespace IPC
diff --git a/ui/gfx/ipc/skia/gfx_skia_param_traits.h b/ui/gfx/ipc/skia/gfx_skia_param_traits.h
new file mode 100644
index 0000000..3267c7d
--- /dev/null
+++ b/ui/gfx/ipc/skia/gfx_skia_param_traits.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_H_
+#define UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_H_
+
+#include <string>
+
+#include "ipc/ipc_message_utils.h"
+#include "ipc/ipc_param_traits.h"
+#include "ui/gfx/ipc/skia/gfx_skia_ipc_export.h"
+#include "ui/gfx/ipc/skia/gfx_skia_param_traits_macros.h"
+
+class SkBitmap;
+struct SkImageInfo;
+
+namespace base {
+class Pickle;
+class PickleIterator;
+}
+
+namespace gfx {
+class Transform;
+}
+
+namespace IPC {
+
+template <>
+struct GFX_SKIA_IPC_EXPORT ParamTraits<SkImageInfo> {
+  using param_type = SkImageInfo;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_SKIA_IPC_EXPORT ParamTraits<SkBitmap> {
+  using param_type = SkBitmap;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct GFX_SKIA_IPC_EXPORT ParamTraits<gfx::Transform> {
+  using param_type = gfx::Transform;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+}  // namespace IPC
+
+#endif  // UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_H_
diff --git a/ui/gfx/ipc/skia/gfx_skia_param_traits_macros.h b/ui/gfx/ipc/skia/gfx_skia_param_traits_macros.h
new file mode 100644
index 0000000..ada9951
--- /dev/null
+++ b/ui/gfx/ipc/skia/gfx_skia_param_traits_macros.h
@@ -0,0 +1,22 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_MACROS_H_
+#define UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_MACROS_H_
+
+#include <stdint.h>
+
+#include "ipc/ipc_message_macros.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT GFX_SKIA_IPC_EXPORT
+
+IPC_ENUM_TRAITS_MAX_VALUE(SkColorType, kLastEnum_SkColorType)
+IPC_ENUM_TRAITS_MAX_VALUE(SkAlphaType, kLastEnum_SkAlphaType)
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT
+
+#endif  // UI_GFX_IPC_SKIA_GFX_SKIA_PARAM_TRAITS_MACROS_H_
diff --git a/ui/gfx/linux/BUILD.gn b/ui/gfx/linux/BUILD.gn
new file mode 100644
index 0000000..3d02d93
--- /dev/null
+++ b/ui/gfx/linux/BUILD.gn
@@ -0,0 +1,84 @@
+# Copyright 2018 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.
+
+import("//build/config/ozone.gni")
+import("//build/config/ui.gni")
+
+assert(use_x11 || ozone_platform_drm || ozone_platform_wayland ||
+       ozone_platform_x11)
+
+source_set("drm") {
+  sources = [
+    "drm_util_linux.cc",
+    "drm_util_linux.h",
+  ]
+
+  deps = [
+    "//base:base",
+    "//build/config/linux/libdrm",
+    "//ui/gfx:buffer_types",
+  ]
+}
+
+source_set("gbm") {
+  sources = [
+    "gbm_buffer.h",
+    "gbm_defines.h",
+    "gbm_device.h",
+    "gbm_util.cc",
+    "gbm_util.h",
+    "gbm_wrapper.cc",
+    "gbm_wrapper.h",
+    "scoped_gbm_device.cc",
+    "scoped_gbm_device.h",
+  ]
+
+  deps = [
+    ":drm",
+    "//base:base",
+    "//build/config/linux/libdrm",
+    "//skia",
+    "//third_party/minigbm",
+    "//ui/gfx:buffer_types",
+    "//ui/gfx:memory_buffer",
+    "//ui/gfx/geometry:geometry",
+  ]
+}
+
+if (use_x11 || ozone_platform_x11) {
+  component("gpu_memory_buffer_support_x11") {
+    sources = [
+      "gpu_memory_buffer_support_x11.cc",
+      "gpu_memory_buffer_support_x11.h",
+    ]
+    deps = [
+      ":drm",
+      ":gbm",
+      "//base",
+      "//skia",
+      "//ui/gfx:buffer_types",
+      "//ui/gfx:memory_buffer",
+      "//ui/gfx/x",
+    ]
+    defines = [ "IS_GBM_SUPPORT_X11_IMPL" ]
+  }
+}
+
+source_set("test_support") {
+  testonly = true
+
+  sources = [
+    "test/mock_gbm_device.cc",
+    "test/mock_gbm_device.h",
+  ]
+
+  deps = [
+    ":drm",
+    ":gbm",
+    "//base",
+    "//build/config/linux/libdrm",
+    "//skia",
+    "//testing/gtest",
+  ]
+}
diff --git a/ui/gfx/linux/OWNERS b/ui/gfx/linux/OWNERS
new file mode 100644
index 0000000..c46d06f
--- /dev/null
+++ b/ui/gfx/linux/OWNERS
@@ -0,0 +1,6 @@
+dcastagna@chromium.org
+dnicoara@chromium.org
+dongseong.hwang@chromium.org
+msisov@igalia.com
+rjkroege@chromium.org
+spang@chromium.org
diff --git a/ui/gfx/linux/client_native_pixmap_dmabuf.cc b/ui/gfx/linux/client_native_pixmap_dmabuf.cc
new file mode 100644
index 0000000..1befc6b
--- /dev/null
+++ b/ui/gfx/linux/client_native_pixmap_dmabuf.cc
@@ -0,0 +1,283 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/linux/client_native_pixmap_dmabuf.h"
+
+#include <fcntl.h>
+#include <linux/version.h>
+#include <stddef.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <xf86drm.h>
+
+#include <utility>
+
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/process/memory.h"
+#include "base/process/process_metrics.h"
+#include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
+#include "build/chromecast_buildflags.h"
+#include "build/chromeos_buildflags.h"
+#include "ui/gfx/buffer_format_util.h"
+#include "ui/gfx/switches.h"
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
+#include <linux/dma-buf.h>
+#else
+#include <linux/types.h>
+
+struct dma_buf_sync {
+  __u64 flags;
+};
+
+#define DMA_BUF_SYNC_READ (1 << 0)
+#define DMA_BUF_SYNC_WRITE (2 << 0)
+#define DMA_BUF_SYNC_RW (DMA_BUF_SYNC_READ | DMA_BUF_SYNC_WRITE)
+#define DMA_BUF_SYNC_START (0 << 2)
+#define DMA_BUF_SYNC_END (1 << 2)
+
+#define DMA_BUF_BASE 'b'
+#define DMA_BUF_IOCTL_SYNC _IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
+#endif
+
+namespace gfx {
+
+namespace {
+
+void PrimeSyncStart(int dmabuf_fd) {
+  struct dma_buf_sync sync_start = {0};
+
+  sync_start.flags = DMA_BUF_SYNC_START | DMA_BUF_SYNC_RW;
+  int rv = HANDLE_EINTR(ioctl(dmabuf_fd, DMA_BUF_IOCTL_SYNC, &sync_start));
+  PLOG_IF(ERROR, rv) << "Failed DMA_BUF_SYNC_START";
+}
+
+void PrimeSyncEnd(int dmabuf_fd) {
+  struct dma_buf_sync sync_end = {0};
+
+  sync_end.flags = DMA_BUF_SYNC_END | DMA_BUF_SYNC_RW;
+  int rv = HANDLE_EINTR(ioctl(dmabuf_fd, DMA_BUF_IOCTL_SYNC, &sync_end));
+  PLOG_IF(ERROR, rv) << "Failed DMA_BUF_SYNC_END";
+}
+
+bool AllowCpuMappableBuffers() {
+  static bool result = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableNativeGpuMemoryBuffers);
+  return result;
+}
+
+}  // namespace
+
+ClientNativePixmapDmaBuf::PlaneInfo::PlaneInfo() {}
+
+ClientNativePixmapDmaBuf::PlaneInfo::PlaneInfo(PlaneInfo&& info)
+    : data(info.data), offset(info.offset), size(info.size) {
+  // Set nullptr to info.data in order not to call munmap in |info| dtor.
+  info.data = nullptr;
+}
+
+ClientNativePixmapDmaBuf::PlaneInfo::~PlaneInfo() {
+  if (data) {
+    int ret = munmap(data, offset + size);
+    DCHECK(!ret);
+  }
+}
+
+// static
+bool ClientNativePixmapDmaBuf::IsConfigurationSupported(
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage) {
+  switch (usage) {
+    case gfx::BufferUsage::GPU_READ:
+      return format == gfx::BufferFormat::BGR_565 ||
+             format == gfx::BufferFormat::RGBA_8888 ||
+             format == gfx::BufferFormat::RGBX_8888 ||
+             format == gfx::BufferFormat::BGRA_8888 ||
+             format == gfx::BufferFormat::BGRX_8888 ||
+             format == gfx::BufferFormat::YVU_420;
+    case gfx::BufferUsage::SCANOUT:
+      return format == gfx::BufferFormat::BGRX_8888 ||
+             format == gfx::BufferFormat::RGBX_8888 ||
+             format == gfx::BufferFormat::RGBA_8888 ||
+             format == gfx::BufferFormat::BGRA_8888 ||
+             format == gfx::BufferFormat::RGBA_1010102 ||
+             format == gfx::BufferFormat::BGRA_1010102;
+    case gfx::BufferUsage::SCANOUT_FRONT_RENDERING:
+    case gfx::BufferUsage::SCANOUT_CPU_READ_WRITE:
+      // TODO(crbug.com/954233): RG_88 is enabled only with
+      // --enable-native-gpu-memory-buffers . Otherwise it breaks some telemetry
+      // tests. Fix that issue and enable it again.
+      if (format == gfx::BufferFormat::RG_88 && !AllowCpuMappableBuffers())
+        return false;
+
+      if (format == gfx::BufferFormat::YUV_420_BIPLANAR)
+        return true;
+
+      return
+#if defined(ARCH_CPU_X86_FAMILY)
+          // The minigbm backends and Mesa drivers commonly used on x86 systems
+          // support the following formats.
+          format == gfx::BufferFormat::R_8 ||
+          format == gfx::BufferFormat::RG_88 ||
+          format == gfx::BufferFormat::YUV_420_BIPLANAR ||
+          format == gfx::BufferFormat::RGBA_1010102 ||
+          format == gfx::BufferFormat::BGRA_1010102 ||
+#endif
+
+          format == gfx::BufferFormat::BGRX_8888 ||
+          format == gfx::BufferFormat::BGRA_8888 ||
+          format == gfx::BufferFormat::RGBX_8888 ||
+          format == gfx::BufferFormat::RGBA_8888;
+    case gfx::BufferUsage::SCANOUT_VDA_WRITE:  // fallthrough
+    case gfx::BufferUsage::PROTECTED_SCANOUT_VDA_WRITE:
+      return false;
+
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+      if (!AllowCpuMappableBuffers())
+        return false;
+
+      if (format == gfx::BufferFormat::YUV_420_BIPLANAR)
+        return true;
+
+      return
+#if defined(ARCH_CPU_X86_FAMILY)
+          // The minigbm backends and Mesa drivers commonly used on x86 systems
+          // support the following formats.
+          format == gfx::BufferFormat::R_8 ||
+          format == gfx::BufferFormat::RG_88 ||
+          format == gfx::BufferFormat::YUV_420_BIPLANAR ||
+          format == gfx::BufferFormat::P010 ||
+#endif
+          format == gfx::BufferFormat::BGRA_8888;
+    case gfx::BufferUsage::SCANOUT_CAMERA_READ_WRITE:
+      // Each platform only supports one camera buffer type. We list the
+      // supported buffer formats on all platforms here. When allocating a
+      // camera buffer the caller is responsible for making sure a buffer is
+      // successfully allocated. For example, allocating YUV420_BIPLANAR
+      // for SCANOUT_CAMERA_READ_WRITE may only work on Intel boards.
+      return format == gfx::BufferFormat::YUV_420_BIPLANAR;
+    case gfx::BufferUsage::CAMERA_AND_CPU_READ_WRITE:
+      // R_8 is used as the underlying pixel format for BLOB buffers.
+      return format == gfx::BufferFormat::R_8;
+    case gfx::BufferUsage::SCANOUT_VEA_CPU_READ:
+    case gfx::BufferUsage::VEA_READ_CAMERA_AND_CPU_READ_WRITE:
+      return format == gfx::BufferFormat::YVU_420 ||
+             format == gfx::BufferFormat::YUV_420_BIPLANAR;
+  }
+  NOTREACHED();
+  return false;
+}
+
+// static
+std::unique_ptr<gfx::ClientNativePixmap>
+ClientNativePixmapDmaBuf::ImportFromDmabuf(gfx::NativePixmapHandle handle,
+                                           const gfx::Size& size,
+                                           gfx::BufferFormat format) {
+  std::array<PlaneInfo, kMaxPlanes> plane_info;
+
+  size_t expected_planes = gfx::NumberOfPlanesForLinearBufferFormat(format);
+  if (expected_planes == 0 || handle.planes.size() != expected_planes) {
+    return nullptr;
+  }
+
+  for (size_t i = 0; i < handle.planes.size(); ++i) {
+    // Verify that the plane buffer has appropriate size.
+    const size_t plane_stride =
+        base::strict_cast<size_t>(handle.planes[i].stride);
+    size_t min_stride = 0;
+    size_t subsample_factor = SubsamplingFactorForBufferFormat(format, i);
+    base::CheckedNumeric<size_t> plane_height =
+        (base::CheckedNumeric<size_t>(size.height()) + subsample_factor - 1) /
+        subsample_factor;
+    if (!gfx::RowSizeForBufferFormatChecked(size.width(), format, i,
+                                            &min_stride) ||
+        plane_stride < min_stride) {
+      return nullptr;
+    }
+    base::CheckedNumeric<size_t> min_size =
+        base::CheckedNumeric<size_t>(plane_stride) * plane_height;
+    if (!min_size.IsValid() || handle.planes[i].size < min_size.ValueOrDie())
+      return nullptr;
+
+    // The stride must be a valid integer in order to be consistent with the
+    // GpuMemoryBuffer::stride() API. Also, refer to http://crbug.com/1093644#c1
+    // for some comments on this check and others in this method.
+    if (!base::IsValueInRangeForNumericType<int>(plane_stride))
+      return nullptr;
+
+    const size_t map_size = base::checked_cast<size_t>(handle.planes[i].size);
+    plane_info[i].offset = handle.planes[i].offset;
+    plane_info[i].size = map_size;
+
+    void* data = mmap(nullptr, map_size + handle.planes[i].offset,
+                      (PROT_READ | PROT_WRITE), MAP_SHARED,
+                      handle.planes[i].fd.get(), 0);
+
+    if (data == MAP_FAILED) {
+      logging::SystemErrorCode mmap_error = logging::GetLastSystemErrorCode();
+      if (mmap_error == ENOMEM)
+        base::TerminateBecauseOutOfMemory(map_size +
+                                          handle.planes[i].offset);
+      LOG(ERROR) << "Failed to mmap dmabuf: "
+                 << logging::SystemErrorCodeToString(mmap_error);
+      return nullptr;
+    }
+    plane_info[i].data = data;
+  }
+
+  return base::WrapUnique(new ClientNativePixmapDmaBuf(std::move(handle), size,
+                                                       std::move(plane_info)));
+}
+
+ClientNativePixmapDmaBuf::ClientNativePixmapDmaBuf(
+    gfx::NativePixmapHandle handle,
+    const gfx::Size& size,
+    std::array<PlaneInfo, kMaxPlanes> plane_info)
+    : pixmap_handle_(std::move(handle)),
+      size_(size),
+      plane_info_(std::move(plane_info)) {
+  TRACE_EVENT0("drm", "ClientNativePixmapDmaBuf");
+}
+
+ClientNativePixmapDmaBuf::~ClientNativePixmapDmaBuf() {
+  TRACE_EVENT0("drm", "~ClientNativePixmapDmaBuf");
+}
+
+bool ClientNativePixmapDmaBuf::Map() {
+  TRACE_EVENT0("drm", "DmaBuf:Map");
+  for (size_t i = 0; i < pixmap_handle_.planes.size(); ++i)
+    PrimeSyncStart(pixmap_handle_.planes[i].fd.get());
+  return true;
+}
+
+void ClientNativePixmapDmaBuf::Unmap() {
+  TRACE_EVENT0("drm", "DmaBuf:Unmap");
+  for (size_t i = 0; i < pixmap_handle_.planes.size(); ++i)
+    PrimeSyncEnd(pixmap_handle_.planes[i].fd.get());
+}
+
+size_t ClientNativePixmapDmaBuf::GetNumberOfPlanes() const {
+  return pixmap_handle_.planes.size();
+}
+
+void* ClientNativePixmapDmaBuf::GetMemoryAddress(size_t plane) const {
+  DCHECK_LT(plane, pixmap_handle_.planes.size());
+  return static_cast<uint8_t*>(plane_info_[plane].data) +
+         plane_info_[plane].offset;
+}
+
+int ClientNativePixmapDmaBuf::GetStride(size_t plane) const {
+  DCHECK_LT(plane, pixmap_handle_.planes.size());
+  return base::checked_cast<int>(pixmap_handle_.planes[plane].stride);
+}
+
+NativePixmapHandle ClientNativePixmapDmaBuf::CloneHandleForIPC() const {
+  return gfx::CloneHandleForIPC(pixmap_handle_);
+}
+}  // namespace gfx
diff --git a/ui/gfx/linux/client_native_pixmap_dmabuf.h b/ui/gfx/linux/client_native_pixmap_dmabuf.h
new file mode 100644
index 0000000..7c8c80e
--- /dev/null
+++ b/ui/gfx/linux/client_native_pixmap_dmabuf.h
@@ -0,0 +1,70 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_CLIENT_NATIVE_PIXMAP_DMABUF_H_
+#define UI_GFX_LINUX_CLIENT_NATIVE_PIXMAP_DMABUF_H_
+
+#include <stdint.h>
+
+#include <array>
+#include <memory>
+
+#include "base/files/scoped_file.h"
+#include "base/macros.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/client_native_pixmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/native_pixmap_handle.h"
+
+namespace gfx {
+
+class ClientNativePixmapDmaBuf : public gfx::ClientNativePixmap {
+ public:
+  static GFX_EXPORT bool IsConfigurationSupported(gfx::BufferFormat format,
+                                                  gfx::BufferUsage usage);
+
+  static std::unique_ptr<gfx::ClientNativePixmap> ImportFromDmabuf(
+      gfx::NativePixmapHandle handle,
+      const gfx::Size& size,
+      gfx::BufferFormat format);
+
+  ClientNativePixmapDmaBuf(const ClientNativePixmapDmaBuf&) = delete;
+  ClientNativePixmapDmaBuf& operator=(const ClientNativePixmapDmaBuf&) = delete;
+
+  ~ClientNativePixmapDmaBuf() override;
+
+  // Overridden from ClientNativePixmap.
+  bool Map() override;
+  void Unmap() override;
+
+  size_t GetNumberOfPlanes() const override;
+  void* GetMemoryAddress(size_t plane) const override;
+  int GetStride(size_t plane) const override;
+  NativePixmapHandle CloneHandleForIPC() const override;
+
+ private:
+  static constexpr size_t kMaxPlanes = 4;
+
+  struct PlaneInfo {
+    PlaneInfo();
+    PlaneInfo(PlaneInfo&& plane_info);
+    ~PlaneInfo();
+
+    void* data = nullptr;
+    size_t offset = 0;
+    size_t size = 0;
+  };
+  ClientNativePixmapDmaBuf(gfx::NativePixmapHandle handle,
+                           const gfx::Size& size,
+                           std::array<PlaneInfo, kMaxPlanes> plane_info);
+
+  const gfx::NativePixmapHandle pixmap_handle_;
+  const gfx::Size size_;
+  const std::array<PlaneInfo, kMaxPlanes> plane_info_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_LINUX_CLIENT_NATIVE_PIXMAP_DMABUF_H_
diff --git a/ui/gfx/linux/client_native_pixmap_factory_dmabuf.cc b/ui/gfx/linux/client_native_pixmap_factory_dmabuf.cc
new file mode 100644
index 0000000..9fe3f7d
--- /dev/null
+++ b/ui/gfx/linux/client_native_pixmap_factory_dmabuf.cc
@@ -0,0 +1,102 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/linux/client_native_pixmap_factory_dmabuf.h"
+
+#include <utility>
+
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
+#include "ui/gfx/native_pixmap_handle.h"
+
+// Although, it's compiled for all linux platforms, it does not mean dmabuf
+// will work there. Check the comment below in the
+// ClientNativePixmapFactoryDmabuf for more details.
+#include "ui/gfx/linux/client_native_pixmap_dmabuf.h"
+
+namespace gfx {
+
+namespace {
+
+class ClientNativePixmapOpaque : public ClientNativePixmap {
+ public:
+  explicit ClientNativePixmapOpaque(NativePixmapHandle pixmap_handle)
+      : pixmap_handle_(std::move(pixmap_handle)) {}
+  ~ClientNativePixmapOpaque() override = default;
+
+  bool Map() override {
+    NOTREACHED();
+    return false;
+  }
+  void Unmap() override { NOTREACHED(); }
+  size_t GetNumberOfPlanes() const override {
+    return pixmap_handle_.planes.size();
+  }
+  void* GetMemoryAddress(size_t plane) const override {
+    NOTREACHED();
+    return nullptr;
+  }
+  int GetStride(size_t plane) const override {
+    CHECK_LT(plane, pixmap_handle_.planes.size());
+    // Even though a ClientNativePixmapOpaque should not be mapped, we may still
+    // need to query the stride of each plane. See
+    // VideoFrame::WrapExternalGpuMemoryBuffer() for such a use case.
+    return base::checked_cast<int>(pixmap_handle_.planes[plane].stride);
+  }
+  NativePixmapHandle CloneHandleForIPC() const override {
+    return gfx::CloneHandleForIPC(pixmap_handle_);
+  }
+
+ private:
+  NativePixmapHandle pixmap_handle_;
+};
+
+}  // namespace
+
+class ClientNativePixmapFactoryDmabuf : public ClientNativePixmapFactory {
+ public:
+  explicit ClientNativePixmapFactoryDmabuf() {}
+
+  ClientNativePixmapFactoryDmabuf(const ClientNativePixmapFactoryDmabuf&) =
+      delete;
+  ClientNativePixmapFactoryDmabuf& operator=(
+      const ClientNativePixmapFactoryDmabuf&) = delete;
+
+  ~ClientNativePixmapFactoryDmabuf() override {}
+
+  std::unique_ptr<ClientNativePixmap> ImportFromHandle(
+      gfx::NativePixmapHandle handle,
+      const gfx::Size& size,
+      gfx::BufferFormat format,
+      gfx::BufferUsage usage) override {
+    DCHECK(!handle.planes.empty());
+    switch (usage) {
+      case gfx::BufferUsage::SCANOUT_CPU_READ_WRITE:
+      case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+      case gfx::BufferUsage::SCANOUT_CAMERA_READ_WRITE:
+      case gfx::BufferUsage::CAMERA_AND_CPU_READ_WRITE:
+      case gfx::BufferUsage::SCANOUT_VEA_CPU_READ:
+      case gfx::BufferUsage::VEA_READ_CAMERA_AND_CPU_READ_WRITE:
+      case gfx::BufferUsage::SCANOUT_FRONT_RENDERING:
+        return ClientNativePixmapDmaBuf::ImportFromDmabuf(std::move(handle),
+                                                          size, format);
+      case gfx::BufferUsage::GPU_READ:
+      case gfx::BufferUsage::SCANOUT:
+      case gfx::BufferUsage::SCANOUT_VDA_WRITE:
+      case gfx::BufferUsage::PROTECTED_SCANOUT_VDA_WRITE:
+        return base::WrapUnique(
+            new ClientNativePixmapOpaque(std::move(handle)));
+    }
+    NOTREACHED();
+    return nullptr;
+  }
+};
+
+ClientNativePixmapFactory* CreateClientNativePixmapFactoryDmabuf() {
+  return new ClientNativePixmapFactoryDmabuf();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/linux/client_native_pixmap_factory_dmabuf.h b/ui/gfx/linux/client_native_pixmap_factory_dmabuf.h
new file mode 100644
index 0000000..7f802a6
--- /dev/null
+++ b/ui/gfx/linux/client_native_pixmap_factory_dmabuf.h
@@ -0,0 +1,17 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_CLIENT_NATIVE_PIXMAP_FACTORY_DMABUF_H_
+#define UI_GFX_LINUX_CLIENT_NATIVE_PIXMAP_FACTORY_DMABUF_H_
+
+#include "ui/gfx/client_native_pixmap_factory.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+GFX_EXPORT ClientNativePixmapFactory* CreateClientNativePixmapFactoryDmabuf();
+
+}  // namespace gfx
+
+#endif  // UI_GFX_LINUX_CLIENT_NATIVE_PIXMAP_FACTORY_DMABUF_H_
diff --git a/ui/gfx/linux/drm_util_linux.cc b/ui/gfx/linux/drm_util_linux.cc
new file mode 100644
index 0000000..416fc23
--- /dev/null
+++ b/ui/gfx/linux/drm_util_linux.cc
@@ -0,0 +1,101 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/linux/drm_util_linux.h"
+
+#include <drm_fourcc.h>
+
+#include "base/notreached.h"
+
+namespace ui {
+
+int GetFourCCFormatFromBufferFormat(gfx::BufferFormat format) {
+  switch (format) {
+    case gfx::BufferFormat::R_8:
+      return DRM_FORMAT_R8;
+    case gfx::BufferFormat::R_16:
+      return DRM_FORMAT_R16;
+    case gfx::BufferFormat::RG_88:
+      return DRM_FORMAT_GR88;
+    case gfx::BufferFormat::BGR_565:
+      return DRM_FORMAT_RGB565;
+    case gfx::BufferFormat::RGBA_4444:
+      return DRM_FORMAT_INVALID;
+    case gfx::BufferFormat::RGBA_8888:
+      return DRM_FORMAT_ABGR8888;
+    case gfx::BufferFormat::RGBX_8888:
+      return DRM_FORMAT_XBGR8888;
+    case gfx::BufferFormat::BGRA_8888:
+      return DRM_FORMAT_ARGB8888;
+    case gfx::BufferFormat::BGRX_8888:
+      return DRM_FORMAT_XRGB8888;
+    case gfx::BufferFormat::BGRA_1010102:
+      return DRM_FORMAT_ARGB2101010;
+    case gfx::BufferFormat::RGBA_1010102:
+      return DRM_FORMAT_ABGR2101010;
+    case gfx::BufferFormat::RGBA_F16:
+      return DRM_FORMAT_INVALID;
+    case gfx::BufferFormat::YVU_420:
+      return DRM_FORMAT_YVU420;
+    case gfx::BufferFormat::YUV_420_BIPLANAR:
+      return DRM_FORMAT_NV12;
+    case gfx::BufferFormat::P010:
+      return DRM_FORMAT_P010;
+  }
+  return DRM_FORMAT_INVALID;
+}
+
+gfx::BufferFormat GetBufferFormatFromFourCCFormat(int format) {
+  switch (format) {
+    case DRM_FORMAT_R8:
+      return gfx::BufferFormat::R_8;
+    case DRM_FORMAT_GR88:
+      return gfx::BufferFormat::RG_88;
+    case DRM_FORMAT_ABGR8888:
+      return gfx::BufferFormat::RGBA_8888;
+    case DRM_FORMAT_XBGR8888:
+      return gfx::BufferFormat::RGBX_8888;
+    case DRM_FORMAT_ARGB8888:
+      return gfx::BufferFormat::BGRA_8888;
+    case DRM_FORMAT_XRGB8888:
+      return gfx::BufferFormat::BGRX_8888;
+    case DRM_FORMAT_ARGB2101010:
+      return gfx::BufferFormat::BGRA_1010102;
+    case DRM_FORMAT_ABGR2101010:
+      return gfx::BufferFormat::RGBA_1010102;
+    case DRM_FORMAT_RGB565:
+      return gfx::BufferFormat::BGR_565;
+    case DRM_FORMAT_NV12:
+      return gfx::BufferFormat::YUV_420_BIPLANAR;
+    case DRM_FORMAT_YVU420:
+      return gfx::BufferFormat::YVU_420;
+    case DRM_FORMAT_P010:
+      return gfx::BufferFormat::P010;
+    default:
+      NOTREACHED();
+      return gfx::BufferFormat::BGRA_8888;
+  }
+}
+
+bool IsValidBufferFormat(uint32_t current_format) {
+  switch (current_format) {
+    case DRM_FORMAT_R8:
+    case DRM_FORMAT_GR88:
+    case DRM_FORMAT_ABGR8888:
+    case DRM_FORMAT_XBGR8888:
+    case DRM_FORMAT_ARGB8888:
+    case DRM_FORMAT_XRGB8888:
+    case DRM_FORMAT_ARGB2101010:
+    case DRM_FORMAT_ABGR2101010:
+    case DRM_FORMAT_RGB565:
+    case DRM_FORMAT_NV12:
+    case DRM_FORMAT_YVU420:
+    case DRM_FORMAT_P010:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace ui
diff --git a/ui/gfx/linux/drm_util_linux.h b/ui/gfx/linux/drm_util_linux.h
new file mode 100644
index 0000000..25aa65f
--- /dev/null
+++ b/ui/gfx/linux/drm_util_linux.h
@@ -0,0 +1,22 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_DRM_UTIL_LINUX_H_
+#define UI_GFX_LINUX_DRM_UTIL_LINUX_H_
+
+#include <cstdint>
+
+#include "ui/gfx/buffer_types.h"
+
+namespace ui {
+
+int GetFourCCFormatFromBufferFormat(gfx::BufferFormat format);
+gfx::BufferFormat GetBufferFormatFromFourCCFormat(int format);
+
+// Returns true if the fourcc format is known.
+bool IsValidBufferFormat(uint32_t current_format);
+
+}  // namespace ui
+
+#endif  // UI_GFX_LINUX_DRM_UTIL_LINUX_H__
diff --git a/ui/gfx/linux/fontconfig_util.cc b/ui/gfx/linux/fontconfig_util.cc
new file mode 100644
index 0000000..6f877d8
--- /dev/null
+++ b/ui/gfx/linux/fontconfig_util.cc
@@ -0,0 +1,226 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/linux/fontconfig_util.h"
+
+#include <fontconfig/fontconfig.h>
+
+#include "base/no_destructor.h"
+#include "ui/gfx/font_render_params.h"
+
+namespace gfx {
+
+namespace {
+
+// A singleton class to wrap a global font-config configuration. The
+// configuration reference counter is incremented to avoid the deletion of the
+// structure while being used. This class is single-threaded and should only be
+// used on the UI-Thread.
+class GFX_EXPORT GlobalFontConfig {
+ public:
+  GlobalFontConfig() {
+    // Without this call, the FontConfig library gets implicitly initialized
+    // on the first call to FontConfig. Since it's not safe to initialize it
+    // concurrently from multiple threads, we explicitly initialize it here
+    // to prevent races when there are multiple renderer's querying the library:
+    // http://crbug.com/404311
+    // Note that future calls to FcInit() are safe no-ops per the FontConfig
+    // interface.
+    FcInit();
+
+    // Increment the reference counter to avoid the config to be deleted while
+    // being used (see http://crbug.com/1004254).
+    fc_config_ = FcConfigGetCurrent();
+    FcConfigReference(fc_config_);
+
+    // Set rescan interval to 0 to disable re-scan. Re-scanning in the
+    // background is a source of thread safety issues.
+    // See in http://crbug.com/1004254.
+    FcBool result = FcConfigSetRescanInterval(fc_config_, 0);
+    DCHECK_EQ(result, FcTrue);
+  }
+
+  GlobalFontConfig(const GlobalFontConfig&) = delete;
+  GlobalFontConfig& operator=(const GlobalFontConfig&) = delete;
+
+  ~GlobalFontConfig() { FcConfigDestroy(fc_config_); }
+
+  // Retrieve the native font-config FcConfig pointer.
+  FcConfig* Get() const {
+    DCHECK_EQ(fc_config_, FcConfigGetCurrent());
+    return fc_config_;
+  }
+
+  // Override the font-config configuration.
+  void OverrideForTesting(FcConfig* config) {
+    FcConfigSetCurrent(config);
+    fc_config_ = config;
+  }
+
+  // Retrieve the global font-config configuration.
+  static GlobalFontConfig* GetInstance() {
+    static base::NoDestructor<GlobalFontConfig> fontconfig;
+    return fontconfig.get();
+  }
+
+ private:
+  FcConfig* fc_config_ = nullptr;
+};
+
+// Converts Fontconfig FC_HINT_STYLE to FontRenderParams::Hinting.
+FontRenderParams::Hinting ConvertFontconfigHintStyle(int hint_style) {
+  switch (hint_style) {
+    case FC_HINT_SLIGHT:
+      return FontRenderParams::HINTING_SLIGHT;
+    case FC_HINT_MEDIUM:
+      return FontRenderParams::HINTING_MEDIUM;
+    case FC_HINT_FULL:
+      return FontRenderParams::HINTING_FULL;
+    default:
+      return FontRenderParams::HINTING_NONE;
+  }
+}
+
+// Converts Fontconfig FC_RGBA to FontRenderParams::SubpixelRendering.
+FontRenderParams::SubpixelRendering ConvertFontconfigRgba(int rgba) {
+  switch (rgba) {
+    case FC_RGBA_RGB:
+      return FontRenderParams::SUBPIXEL_RENDERING_RGB;
+    case FC_RGBA_BGR:
+      return FontRenderParams::SUBPIXEL_RENDERING_BGR;
+    case FC_RGBA_VRGB:
+      return FontRenderParams::SUBPIXEL_RENDERING_VRGB;
+    case FC_RGBA_VBGR:
+      return FontRenderParams::SUBPIXEL_RENDERING_VBGR;
+    default:
+      return FontRenderParams::SUBPIXEL_RENDERING_NONE;
+  }
+}
+
+// Extracts a string property from a font-config pattern (e.g. FcPattern).
+std::string GetFontConfigPropertyAsString(FcPattern* pattern,
+                                          const char* property) {
+  FcChar8* text = nullptr;
+  if (FcPatternGetString(pattern, property, 0, &text) != FcResultMatch ||
+      text == nullptr) {
+    return std::string();
+  }
+  return std::string(reinterpret_cast<const char*>(text));
+}
+
+// Extracts an integer property from a font-config pattern (e.g. FcPattern).
+int GetFontConfigPropertyAsInt(FcPattern* pattern,
+                               const char* property,
+                               int default_value) {
+  int value = -1;
+  if (FcPatternGetInteger(pattern, property, 0, &value) != FcResultMatch)
+    return default_value;
+  return value;
+}
+
+// Extracts an boolean property from a font-config pattern (e.g. FcPattern).
+bool GetFontConfigPropertyAsBool(FcPattern* pattern, const char* property) {
+  FcBool value = FcFalse;
+  if (FcPatternGetBool(pattern, property, 0, &value) != FcResultMatch)
+    return false;
+  return value != FcFalse;
+}
+
+}  // namespace
+
+FcConfig* GetGlobalFontConfig() {
+  return GlobalFontConfig::GetInstance()->Get();
+}
+
+void OverrideGlobalFontConfigForTesting(FcConfig* config) {
+  return GlobalFontConfig::GetInstance()->OverrideForTesting(config);
+}
+
+std::string GetFontName(FcPattern* pattern) {
+  return GetFontConfigPropertyAsString(pattern, FC_FAMILY);
+}
+
+std::string GetFilename(FcPattern* pattern) {
+  return GetFontConfigPropertyAsString(pattern, FC_FILE);
+}
+
+base::FilePath GetFontPath(FcPattern* pattern) {
+  std::string filename = GetFilename(pattern);
+
+  // Obtains the system root directory in 'config' if available. All files
+  // (including file properties in patterns) obtained from this 'config' are
+  // relative to this system root directory.
+  const char* sysroot =
+      reinterpret_cast<const char*>(FcConfigGetSysRoot(nullptr));
+  if (!sysroot)
+    return base::FilePath(filename);
+
+  // Paths may be specified with a heading slash (e.g.
+  // /test_fonts/DejaVuSans.ttf).
+  if (!filename.empty() && base::FilePath::IsSeparator(filename[0]))
+    filename = filename.substr(1);
+
+  if (filename.empty())
+    return base::FilePath();
+
+  return base::FilePath(sysroot).Append(filename);
+}
+
+int GetFontTtcIndex(FcPattern* pattern) {
+  return GetFontConfigPropertyAsInt(pattern, FC_INDEX, 0);
+}
+
+bool IsFontBold(FcPattern* pattern) {
+  int weight = GetFontConfigPropertyAsInt(pattern, FC_WEIGHT, FC_WEIGHT_NORMAL);
+  return weight >= FC_WEIGHT_BOLD;
+}
+
+bool IsFontItalic(FcPattern* pattern) {
+  int slant = GetFontConfigPropertyAsInt(pattern, FC_SLANT, FC_SLANT_ROMAN);
+  return slant != FC_SLANT_ROMAN;
+}
+
+bool IsFontScalable(FcPattern* pattern) {
+  return GetFontConfigPropertyAsBool(pattern, FC_SCALABLE);
+}
+
+std::string GetFontFormat(FcPattern* pattern) {
+  return GetFontConfigPropertyAsString(pattern, FC_FONTFORMAT);
+}
+
+void GetFontRenderParamsFromFcPattern(FcPattern* pattern,
+                                      FontRenderParams* param_out) {
+  FcBool fc_antialias = 0;
+  if (FcPatternGetBool(pattern, FC_ANTIALIAS, 0, &fc_antialias) ==
+      FcResultMatch) {
+    param_out->antialiasing = fc_antialias;
+  }
+
+  FcBool fc_autohint = 0;
+  if (FcPatternGetBool(pattern, FC_AUTOHINT, 0, &fc_autohint) ==
+      FcResultMatch) {
+    param_out->autohinter = fc_autohint;
+  }
+
+  FcBool fc_bitmap = 0;
+  if (FcPatternGetBool(pattern, FC_EMBEDDED_BITMAP, 0, &fc_bitmap) ==
+      FcResultMatch) {
+    param_out->use_bitmaps = fc_bitmap;
+  }
+
+  FcBool fc_hinting = 0;
+  if (FcPatternGetBool(pattern, FC_HINTING, 0, &fc_hinting) == FcResultMatch) {
+    int fc_hint_style = FC_HINT_NONE;
+    if (fc_hinting) {
+      FcPatternGetInteger(pattern, FC_HINT_STYLE, 0, &fc_hint_style);
+    }
+    param_out->hinting = ConvertFontconfigHintStyle(fc_hint_style);
+  }
+
+  int fc_rgba = FC_RGBA_NONE;
+  if (FcPatternGetInteger(pattern, FC_RGBA, 0, &fc_rgba) == FcResultMatch)
+    param_out->subpixel_rendering = ConvertFontconfigRgba(fc_rgba);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/linux/fontconfig_util.h b/ui/gfx/linux/fontconfig_util.h
new file mode 100644
index 0000000..c8cb2ae
--- /dev/null
+++ b/ui/gfx/linux/fontconfig_util.h
@@ -0,0 +1,45 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_FONTCONFIG_UTIL_H_
+#define UI_GFX_LINUX_FONTCONFIG_UTIL_H_
+
+#include <fontconfig/fontconfig.h>
+
+#include "base/files/file_path.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+struct FcPatternDeleter {
+  void operator()(FcPattern* ptr) const { FcPatternDestroy(ptr); }
+};
+using ScopedFcPattern = std::unique_ptr<FcPattern, FcPatternDeleter>;
+
+// Retrieve the global font config. Must be called on the main thread.
+GFX_EXPORT FcConfig* GetGlobalFontConfig();
+GFX_EXPORT void OverrideGlobalFontConfigForTesting(FcConfig* config);
+
+// FcPattern accessor wrappers.
+GFX_EXPORT std::string GetFontName(FcPattern* pattern);
+GFX_EXPORT std::string GetFilename(FcPattern* pattern);
+GFX_EXPORT int GetFontTtcIndex(FcPattern* pattern);
+GFX_EXPORT bool IsFontBold(FcPattern* pattern);
+GFX_EXPORT bool IsFontItalic(FcPattern* pattern);
+GFX_EXPORT bool IsFontScalable(FcPattern* pattern);
+GFX_EXPORT std::string GetFontFormat(FcPattern* pattern);
+
+// Return the path of the font. Relative to the sysroot config specified in the
+// font config (see: FcConfigGetSysRoot(...)).
+GFX_EXPORT base::FilePath GetFontPath(FcPattern* pattern);
+
+// Returns the appropriate parameters for rendering the font represented by the
+// font config pattern.
+GFX_EXPORT void GetFontRenderParamsFromFcPattern(FcPattern* pattern,
+                                                 FontRenderParams* param_out);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_LINUX_FONTCONFIG_UTIL_H_
\ No newline at end of file
diff --git a/ui/gfx/linux/fontconfig_util_unittest.cc b/ui/gfx/linux/fontconfig_util_unittest.cc
new file mode 100644
index 0000000..5c4d7d1
--- /dev/null
+++ b/ui/gfx/linux/fontconfig_util_unittest.cc
@@ -0,0 +1,140 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/linux/fontconfig_util.h"
+
+#include <fontconfig/fontconfig.h>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+
+TEST(FontConfigUtilTest, FcPatternAccessors) {
+  ScopedFcPattern pattern(FcPatternCreate());
+
+  const char kFamilyName[] = "sans";
+  FcPatternAddString(pattern.get(), FC_FAMILY,
+                     reinterpret_cast<const FcChar8*>(kFamilyName));
+  const char kFileName[] = "/usr/share/fonts/arial.ttf";
+  FcPatternAddString(pattern.get(), FC_FILE,
+                     reinterpret_cast<const FcChar8*>(kFileName));
+  const int kIndex = 42;
+  FcPatternAddInteger(pattern.get(), FC_INDEX, kIndex);
+  FcPatternAddInteger(pattern.get(), FC_WEIGHT, FC_WEIGHT_BOLD);
+  FcPatternAddInteger(pattern.get(), FC_SLANT, FC_SLANT_ROMAN);
+  FcPatternAddBool(pattern.get(), FC_SCALABLE, FcTrue);
+  const char kFontFormat[] = "TrueType";
+  FcPatternAddString(pattern.get(), FC_FONTFORMAT,
+                     reinterpret_cast<const FcChar8*>(kFontFormat));
+
+  EXPECT_EQ(kFamilyName, GetFontName(pattern.get()));
+  EXPECT_EQ(kFileName, GetFilename(pattern.get()));
+  EXPECT_EQ(kIndex, GetFontTtcIndex(pattern.get()));
+  EXPECT_TRUE(IsFontBold(pattern.get()));
+  EXPECT_FALSE(IsFontItalic(pattern.get()));
+  EXPECT_TRUE(IsFontScalable(pattern.get()));
+  EXPECT_EQ(kFontFormat, GetFontFormat(pattern.get()));
+}
+
+TEST(FontConfigUtilTest, GetFontPathWithSysRoot) {
+  ScopedFcPattern pattern(FcPatternCreate());
+
+  // Save the old sysroot, if specified.
+  std::string old_sysroot;
+  const FcChar8* old_sysroot_ptr = FcConfigGetSysRoot(nullptr);
+  if (old_sysroot_ptr)
+    old_sysroot = reinterpret_cast<const char*>(old_sysroot_ptr);
+
+  // Override the sysroot.
+  base::FilePath sysroot("/var/opt/fonts");
+  FcConfigSetSysRoot(nullptr, reinterpret_cast<const FcChar8*>(
+                                  sysroot.AsUTF8Unsafe().c_str()));
+
+  // Validate that path are relative to sysroot.
+  const char kFileName[] = "fonts/arial.ttf";
+  FcPatternAddString(pattern.get(), FC_FILE,
+                     reinterpret_cast<const FcChar8*>(kFileName));
+  const char kExpectedFileName[] = "/var/opt/fonts/fonts/arial.ttf";
+  EXPECT_EQ(base::FilePath(kExpectedFileName), GetFontPath(pattern.get()));
+
+  // Restore the old sysroot, if specified.
+  if (old_sysroot_ptr) {
+    FcConfigSetSysRoot(nullptr,
+                       reinterpret_cast<const FcChar8*>(old_sysroot.c_str()));
+  }
+}
+
+TEST(FontConfigUtilTest, GetFontPathWithoutSysRoot) {
+  ScopedFcPattern pattern(FcPatternCreate());
+
+  // Save the old sysroot, if specified.
+  std::string old_sysroot;
+  const FcChar8* old_sysroot_ptr = FcConfigGetSysRoot(nullptr);
+  if (old_sysroot_ptr)
+    old_sysroot = reinterpret_cast<const char*>(old_sysroot_ptr);
+
+  // Override (remove) the sysroot.
+  FcConfigSetSysRoot(nullptr, nullptr);
+
+  // Check that the filename is not changed without a sysroot present.
+  const char kFileName[] = "/var/opt/font/fonts/arial.ttf";
+  FcPatternAddString(pattern.get(), FC_FILE,
+                     reinterpret_cast<const FcChar8*>(kFileName));
+  EXPECT_EQ(base::FilePath(kFileName), GetFontPath(pattern.get()));
+
+  // Restore the old sysroot, if specified.
+  if (old_sysroot_ptr) {
+    FcConfigSetSysRoot(nullptr,
+                       reinterpret_cast<const FcChar8*>(old_sysroot.c_str()));
+  }
+}
+
+TEST(FontConfigUtilTest, GetFontRenderParamsFromFcPatternWithEmptyPattern) {
+  ScopedFcPattern pattern(FcPatternCreate());
+
+  FontRenderParams params;
+  GetFontRenderParamsFromFcPattern(pattern.get(), &params);
+
+  FontRenderParams empty_params;
+  EXPECT_EQ(params, empty_params);
+}
+
+TEST(FontConfigUtilTest, GetFontRenderParamsFromFcPatternWithFalseValues) {
+  ScopedFcPattern pattern(FcPatternCreate());
+  FcPatternAddBool(pattern.get(), FC_ANTIALIAS, FcFalse);
+  FcPatternAddBool(pattern.get(), FC_AUTOHINT, FcFalse);
+  FcPatternAddBool(pattern.get(), FC_EMBEDDED_BITMAP, FcFalse);
+
+  FontRenderParams params;
+  GetFontRenderParamsFromFcPattern(pattern.get(), &params);
+
+  FontRenderParams expected_params;
+  expected_params.antialiasing = false;
+  expected_params.autohinter = false;
+  expected_params.use_bitmaps = false;
+  EXPECT_EQ(params, expected_params);
+}
+
+TEST(FontConfigUtilTest, GetFontRenderParamsFromFcPatternWithValues) {
+  ScopedFcPattern pattern(FcPatternCreate());
+  FcPatternAddBool(pattern.get(), FC_ANTIALIAS, FcTrue);
+  FcPatternAddBool(pattern.get(), FC_AUTOHINT, FcTrue);
+  FcPatternAddInteger(pattern.get(), FC_HINT_STYLE, FC_HINT_MEDIUM);
+  FcPatternAddBool(pattern.get(), FC_EMBEDDED_BITMAP, FcTrue);
+  FcPatternAddInteger(pattern.get(), FC_RGBA, FC_RGBA_RGB);
+
+  FontRenderParams params;
+  GetFontRenderParamsFromFcPattern(pattern.get(), &params);
+
+  FontRenderParams expected_params;
+  expected_params.antialiasing = true;
+  expected_params.autohinter = true;
+  expected_params.hinting = FontRenderParams::HINTING_MEDIUM;
+  expected_params.use_bitmaps = true;
+  expected_params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_RGB;
+
+  EXPECT_EQ(params, expected_params);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/linux/gbm_buffer.h b/ui/gfx/linux/gbm_buffer.h
new file mode 100644
index 0000000..a9805d9
--- /dev/null
+++ b/ui/gfx/linux/gbm_buffer.h
@@ -0,0 +1,44 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_GBM_BUFFER_H_
+#define UI_GFX_LINUX_GBM_BUFFER_H_
+
+#include <inttypes.h>
+
+#include "third_party/skia/include/core/SkRefCnt.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/native_pixmap_handle.h"
+
+class SkSurface;
+
+namespace ui {
+
+class GbmBuffer {
+ public:
+  virtual ~GbmBuffer() {}
+
+  virtual uint32_t GetFormat() const = 0;
+  virtual uint64_t GetFormatModifier() const = 0;
+  virtual uint32_t GetFlags() const = 0;
+  // TODO(reveman): This should not be needed once crbug.com/597932 is
+  // fixed, as the size would be queried directly from the underlying bo.
+  virtual gfx::Size GetSize() const = 0;
+  virtual gfx::BufferFormat GetBufferFormat() const = 0;
+  virtual bool AreFdsValid() const = 0;
+  virtual size_t GetNumPlanes() const = 0;
+  virtual int GetPlaneFd(size_t plane) const = 0;
+  virtual uint32_t GetPlaneHandle(size_t plane) const = 0;
+  virtual uint32_t GetPlaneStride(size_t plane) const = 0;
+  virtual size_t GetPlaneOffset(size_t plane) const = 0;
+  virtual size_t GetPlaneSize(size_t plane) const = 0;
+  virtual uint32_t GetHandle() const = 0;
+  virtual gfx::NativePixmapHandle ExportHandle() const = 0;
+  virtual sk_sp<SkSurface> GetSurface() = 0;
+};
+
+}  // namespace ui
+
+#endif  // UI_GFX_LINUX_GBM_BUFFER_H_
diff --git a/ui/gfx/linux/gbm_defines.h b/ui/gfx/linux/gbm_defines.h
new file mode 100644
index 0000000..b663173
--- /dev/null
+++ b/ui/gfx/linux/gbm_defines.h
@@ -0,0 +1,27 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_GBM_DEFINES_H_
+#define UI_GFX_LINUX_GBM_DEFINES_H_
+
+#include <gbm.h>
+
+// Minigbm has some defines that are used by ozone/gbm. However, when we build
+// Ozone for Linux and use system libgbm, these defines are not present and
+// compilation fails. Thus, to fix the issue, mask out these defines and let the
+// compilation go through. The values for these are copied from the minigbm's
+// gbm.h file.
+#if !defined(MINIGBM)
+#define GBM_MAX_PLANES 4
+
+#define GBM_BO_USE_TEXTURING 0
+#define GBM_BO_USE_CAMERA_WRITE 0
+#define GBM_BO_USE_HW_VIDEO_DECODER 0
+#define GBM_BO_USE_HW_VIDEO_ENCODER 0
+#define GBM_BO_USE_PROTECTED 0
+#define GBM_BO_USE_SW_READ_OFTEN 0
+#define GBM_BO_USE_FRONT_RENDERING 0
+#endif
+
+#endif  // UI_GFX_LINUX_GBM_DEFINES_H_
diff --git a/ui/gfx/linux/gbm_device.h b/ui/gfx/linux/gbm_device.h
new file mode 100644
index 0000000..50f7fe5
--- /dev/null
+++ b/ui/gfx/linux/gbm_device.h
@@ -0,0 +1,40 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_GBM_DEVICE_H_
+#define UI_GFX_LINUX_GBM_DEVICE_H_
+
+#include <gbm.h>
+#include <memory>
+
+#include "base/files/file.h"
+#include "base/macros.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/native_pixmap_handle.h"
+
+namespace ui {
+
+class GbmBuffer;
+
+class GbmDevice {
+ public:
+  virtual ~GbmDevice() {}
+
+  virtual std::unique_ptr<GbmBuffer> CreateBuffer(uint32_t format,
+                                                  const gfx::Size& size,
+                                                  uint32_t flags) = 0;
+  virtual std::unique_ptr<GbmBuffer> CreateBufferWithModifiers(
+      uint32_t format,
+      const gfx::Size& size,
+      uint32_t flags,
+      const std::vector<uint64_t>& modifiers) = 0;
+  virtual std::unique_ptr<GbmBuffer> CreateBufferFromHandle(
+      uint32_t format,
+      const gfx::Size& size,
+      gfx::NativePixmapHandle handle) = 0;
+};
+
+}  // namespace ui
+
+#endif  // UI_GFX_LINUX_GBM_DEVICE_H_
diff --git a/ui/gfx/linux/gbm_util.cc b/ui/gfx/linux/gbm_util.cc
new file mode 100644
index 0000000..b9adad9
--- /dev/null
+++ b/ui/gfx/linux/gbm_util.cc
@@ -0,0 +1,46 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/linux/gbm_util.h"
+
+#include "base/notreached.h"
+#include "ui/gfx/linux/gbm_defines.h"
+
+namespace ui {
+
+uint32_t BufferUsageToGbmFlags(gfx::BufferUsage usage) {
+  switch (usage) {
+    case gfx::BufferUsage::GPU_READ:
+      return GBM_BO_USE_TEXTURING;
+    case gfx::BufferUsage::SCANOUT:
+      return GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT | GBM_BO_USE_TEXTURING;
+    case gfx::BufferUsage::SCANOUT_CAMERA_READ_WRITE:
+      return GBM_BO_USE_LINEAR | GBM_BO_USE_CAMERA_WRITE | GBM_BO_USE_SCANOUT |
+             GBM_BO_USE_TEXTURING;
+    case gfx::BufferUsage::CAMERA_AND_CPU_READ_WRITE:
+      return GBM_BO_USE_LINEAR | GBM_BO_USE_CAMERA_WRITE;
+    case gfx::BufferUsage::SCANOUT_CPU_READ_WRITE:
+      return GBM_BO_USE_LINEAR | GBM_BO_USE_SCANOUT | GBM_BO_USE_TEXTURING;
+    case gfx::BufferUsage::SCANOUT_VDA_WRITE:
+      return GBM_BO_USE_SCANOUT | GBM_BO_USE_TEXTURING |
+             GBM_BO_USE_HW_VIDEO_DECODER;
+    case gfx::BufferUsage::PROTECTED_SCANOUT_VDA_WRITE:
+      return GBM_BO_USE_SCANOUT | GBM_BO_USE_PROTECTED |
+             GBM_BO_USE_HW_VIDEO_DECODER;
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+      return GBM_BO_USE_LINEAR | GBM_BO_USE_TEXTURING;
+    case gfx::BufferUsage::SCANOUT_VEA_CPU_READ:
+      return GBM_BO_USE_LINEAR | GBM_BO_USE_SCANOUT | GBM_BO_USE_TEXTURING |
+             GBM_BO_USE_HW_VIDEO_ENCODER;
+    case gfx::BufferUsage::VEA_READ_CAMERA_AND_CPU_READ_WRITE:
+      return GBM_BO_USE_LINEAR | GBM_BO_USE_CAMERA_WRITE |
+             GBM_BO_USE_TEXTURING | GBM_BO_USE_HW_VIDEO_ENCODER |
+             GBM_BO_USE_SW_READ_OFTEN;
+    case gfx::BufferUsage::SCANOUT_FRONT_RENDERING:
+      return GBM_BO_USE_SCANOUT | GBM_BO_USE_TEXTURING |
+             GBM_BO_USE_FRONT_RENDERING;
+  }
+}
+
+}  // namespace ui
diff --git a/ui/gfx/linux/gbm_util.h b/ui/gfx/linux/gbm_util.h
new file mode 100644
index 0000000..7b45b4a
--- /dev/null
+++ b/ui/gfx/linux/gbm_util.h
@@ -0,0 +1,21 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_GBM_UTIL_H_
+#define UI_GFX_LINUX_GBM_UTIL_H_
+
+#include <cstdint>
+
+#include "ui/gfx/buffer_types.h"
+
+namespace ui {
+
+// Get GBM buffer object usage flags for a corresponding gfx::BufferUsage.
+// Depending on the platform, certain usage flags may not be available (eg.
+// GBM_BO_USE_HW_VIDEO_ENCODER on desktop linux).
+uint32_t BufferUsageToGbmFlags(gfx::BufferUsage usage);
+
+}  // namespace ui
+
+#endif  // UI_GFX_LINUX_GBM_UTIL_H_
diff --git a/ui/gfx/linux/gbm_wrapper.cc b/ui/gfx/linux/gbm_wrapper.cc
new file mode 100644
index 0000000..04417ff
--- /dev/null
+++ b/ui/gfx/linux/gbm_wrapper.cc
@@ -0,0 +1,399 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/linux/gbm_wrapper.h"
+
+#include <gbm.h>
+#include <memory>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "skia/ext/legacy_display_globals.h"
+#include "third_party/skia/include/core/SkSurface.h"
+#include "ui/gfx/buffer_format_util.h"
+#include "ui/gfx/linux/drm_util_linux.h"
+#include "ui/gfx/linux/gbm_buffer.h"
+#include "ui/gfx/linux/gbm_device.h"
+
+#if !defined(MINIGBM)
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <xf86drm.h>
+
+#include "base/strings/stringize_macros.h"
+#endif
+
+namespace gbm_wrapper {
+
+namespace {
+
+// Function availability can be tested by checking if the address of gbm_* is
+// not nullptr.
+#define WEAK_GBM_FN(x) extern "C" __attribute__((weak)) decltype(x) x
+
+// TODO(https://crbug.com/784010): Remove these once support for Ubuntu Trusty
+// is dropped.
+WEAK_GBM_FN(gbm_bo_map);
+WEAK_GBM_FN(gbm_bo_unmap);
+
+// TODO(https://crbug.com/784010): Remove these once support for Ubuntu Trusty
+// and Debian Stretch are dropped.
+WEAK_GBM_FN(gbm_bo_create_with_modifiers);
+WEAK_GBM_FN(gbm_bo_get_handle_for_plane);
+WEAK_GBM_FN(gbm_bo_get_modifier);
+WEAK_GBM_FN(gbm_bo_get_offset);
+WEAK_GBM_FN(gbm_bo_get_plane_count);
+WEAK_GBM_FN(gbm_bo_get_stride_for_plane);
+
+bool HaveGbmMap() {
+  return gbm_bo_map && gbm_bo_unmap;
+}
+
+bool HaveGbmModifiers() {
+  return gbm_bo_create_with_modifiers && gbm_bo_get_modifier;
+}
+
+bool HaveGbmMultiplane() {
+  return gbm_bo_get_handle_for_plane && gbm_bo_get_offset &&
+         gbm_bo_get_plane_count && gbm_bo_get_stride_for_plane;
+}
+
+uint32_t GetHandleForPlane(struct gbm_bo* bo, int plane) {
+  CHECK(HaveGbmMultiplane() || plane == 0);
+  return HaveGbmMultiplane() ? gbm_bo_get_handle_for_plane(bo, plane).u32
+                             : gbm_bo_get_handle(bo).u32;
+}
+
+uint32_t GetStrideForPlane(struct gbm_bo* bo, int plane) {
+  CHECK(HaveGbmMultiplane() || plane == 0);
+  return HaveGbmMultiplane() ? gbm_bo_get_stride_for_plane(bo, plane)
+                             : gbm_bo_get_stride(bo);
+}
+
+uint32_t GetOffsetForPlane(struct gbm_bo* bo, int plane) {
+  CHECK(HaveGbmMultiplane() || plane == 0);
+  return HaveGbmMultiplane() ? gbm_bo_get_offset(bo, plane) : 0;
+}
+
+int GetPlaneCount(struct gbm_bo* bo) {
+  return HaveGbmMultiplane() ? gbm_bo_get_plane_count(bo) : 1;
+}
+
+int GetPlaneFdForBo(gbm_bo* bo, size_t plane) {
+#if defined(MINIGBM)
+  return gbm_bo_get_plane_fd(bo, plane);
+#else
+  const int plane_count = GetPlaneCount(bo);
+  DCHECK(plane_count > 0 && plane < static_cast<size_t>(plane_count));
+
+  // System linux gbm (or Mesa gbm) does not provide fds per plane basis. Thus,
+  // get plane handle and use drm ioctl to get a prime fd out of it avoid having
+  // two different branches for minigbm and Mesa gbm here.
+  gbm_device* gbm_dev = gbm_bo_get_device(bo);
+  int dev_fd = gbm_device_get_fd(gbm_dev);
+  DCHECK_GE(dev_fd, 0);
+
+  uint32_t plane_handle = GetHandleForPlane(bo, plane);
+
+  int fd = -1;
+  int ret;
+  // Use DRM_RDWR to allow the fd to be mappable in another process.
+  ret = drmPrimeHandleToFD(dev_fd, plane_handle, DRM_CLOEXEC | DRM_RDWR, &fd);
+
+  // Older DRM implementations blocked DRM_RDWR, but gave a read/write mapping
+  // anyways
+  if (ret)
+    ret = drmPrimeHandleToFD(dev_fd, plane_handle, DRM_CLOEXEC, &fd);
+
+  return ret ? ret : fd;
+#endif
+}
+
+size_t GetSizeOfPlane(gbm_bo* bo,
+                      uint32_t format,
+                      const gfx::Size& size,
+                      size_t plane) {
+#if defined(MINIGBM)
+  return gbm_bo_get_plane_size(bo, plane);
+#else
+  DCHECK(!size.IsEmpty());
+
+  // Get row size of the plane, stride and subsampled height to finally get the
+  // size of a plane in bytes.
+  const gfx::BufferFormat buffer_format =
+      ui::GetBufferFormatFromFourCCFormat(format);
+  const base::CheckedNumeric<size_t> stride_for_plane =
+      GetStrideForPlane(bo, plane);
+  const base::CheckedNumeric<size_t> subsampled_height =
+      size.height() /
+      gfx::SubsamplingFactorForBufferFormat(buffer_format, plane);
+
+  // Apply subsampling factor to get size in bytes.
+  const base::CheckedNumeric<size_t> checked_plane_size =
+      subsampled_height * stride_for_plane;
+
+  return checked_plane_size.ValueOrDie();
+#endif
+}
+
+}  // namespace
+
+class Buffer final : public ui::GbmBuffer {
+ public:
+  Buffer(struct gbm_bo* bo,
+         uint32_t format,
+         uint32_t flags,
+         uint64_t modifier,
+         const gfx::Size& size,
+         gfx::NativePixmapHandle handle)
+      : bo_(bo),
+        format_(format),
+        format_modifier_(modifier),
+        flags_(flags),
+        size_(size),
+        handle_(std::move(handle)) {}
+
+  Buffer(const Buffer&) = delete;
+  Buffer& operator=(const Buffer&) = delete;
+
+  ~Buffer() override {
+    DCHECK(!mmap_data_);
+    gbm_bo_destroy(bo_);
+  }
+
+  uint32_t GetFormat() const override { return format_; }
+  uint64_t GetFormatModifier() const override { return format_modifier_; }
+  uint32_t GetFlags() const override { return flags_; }
+  // TODO(reveman): This should not be needed once crbug.com/597932 is fixed,
+  // as the size would be queried directly from the underlying bo.
+  gfx::Size GetSize() const override { return size_; }
+  gfx::BufferFormat GetBufferFormat() const override {
+    return ui::GetBufferFormatFromFourCCFormat(format_);
+  }
+  bool AreFdsValid() const override {
+    if (handle_.planes.empty())
+      return false;
+
+    for (const auto& plane : handle_.planes) {
+      if (!plane.fd.is_valid())
+        return false;
+    }
+    return true;
+  }
+  size_t GetNumPlanes() const override { return handle_.planes.size(); }
+  int GetPlaneFd(size_t plane) const override {
+    DCHECK_LT(plane, handle_.planes.size());
+    return handle_.planes[plane].fd.get();
+  }
+  uint32_t GetPlaneStride(size_t plane) const override {
+    DCHECK_LT(plane, handle_.planes.size());
+    return handle_.planes[plane].stride;
+  }
+  size_t GetPlaneOffset(size_t plane) const override {
+    DCHECK_LT(plane, handle_.planes.size());
+    return handle_.planes[plane].offset;
+  }
+  size_t GetPlaneSize(size_t plane) const override {
+    DCHECK_LT(plane, handle_.planes.size());
+    return static_cast<size_t>(handle_.planes[plane].size);
+  }
+  uint32_t GetPlaneHandle(size_t plane) const override {
+    DCHECK_LT(plane, handle_.planes.size());
+    return GetHandleForPlane(bo_, plane);
+  }
+  uint32_t GetHandle() const override { return gbm_bo_get_handle(bo_).u32; }
+  gfx::NativePixmapHandle ExportHandle() const override {
+    return CloneHandleForIPC(handle_);
+  }
+
+  sk_sp<SkSurface> GetSurface() override {
+    CHECK(HaveGbmMap());
+    DCHECK(!mmap_data_);
+    uint32_t stride;
+    void* addr;
+    addr =
+#if defined(MINIGBM)
+        gbm_bo_map2(bo_, 0, 0, gbm_bo_get_width(bo_), gbm_bo_get_height(bo_),
+                    GBM_BO_TRANSFER_READ_WRITE, &stride, &mmap_data_, 0);
+#else
+        gbm_bo_map(bo_, 0, 0, gbm_bo_get_width(bo_), gbm_bo_get_height(bo_),
+                   GBM_BO_TRANSFER_READ_WRITE, &stride, &mmap_data_);
+#endif
+
+    if (!addr)
+      return nullptr;
+    SkImageInfo info =
+        SkImageInfo::MakeN32Premul(size_.width(), size_.height());
+    SkSurfaceProps props = skia::LegacyDisplayGlobals::GetSkSurfaceProps();
+    return SkSurface::MakeRasterDirectReleaseProc(
+        info, addr, stride, &Buffer::UnmapGbmBo, this, &props);
+  }
+
+ private:
+  static void UnmapGbmBo(void* pixels, void* context) {
+    CHECK(HaveGbmMap());
+    Buffer* buffer = static_cast<Buffer*>(context);
+    gbm_bo_unmap(buffer->bo_, buffer->mmap_data_);
+    buffer->mmap_data_ = nullptr;
+  }
+
+  gbm_bo* const bo_;
+  void* mmap_data_ = nullptr;
+
+  const uint32_t format_;
+  const uint64_t format_modifier_;
+  const uint32_t flags_;
+
+  const gfx::Size size_;
+
+  const gfx::NativePixmapHandle handle_;
+};
+
+std::unique_ptr<Buffer> CreateBufferForBO(struct gbm_bo* bo,
+                                          uint32_t format,
+                                          const gfx::Size& size,
+                                          uint32_t flags) {
+  DCHECK(bo);
+  gfx::NativePixmapHandle handle;
+
+  const uint64_t modifier = HaveGbmModifiers() ? gbm_bo_get_modifier(bo) : 0;
+  const int plane_count = GetPlaneCount(bo);
+  // The Mesa's gbm implementation explicitly checks whether plane count <= and
+  // returns 1 if the condition is true. Nevertheless, use a DCHECK here to make
+  // sure the condition is not broken there.
+  DCHECK_GT(plane_count, 0);
+  // Ensure there are no differences in integer signs by casting any possible
+  // values to size_t.
+  for (size_t i = 0; i < static_cast<size_t>(plane_count); ++i) {
+    // The fd returned by gbm_bo_get_fd is not ref-counted and need to be
+    // kept open for the lifetime of the buffer.
+    base::ScopedFD fd(GetPlaneFdForBo(bo, i));
+
+    if (!fd.is_valid()) {
+      PLOG(ERROR) << "Failed to export buffer to dma_buf";
+      gbm_bo_destroy(bo);
+      return nullptr;
+    }
+
+    handle.planes.emplace_back(
+        GetStrideForPlane(bo, i), GetOffsetForPlane(bo, i),
+        GetSizeOfPlane(bo, format, size, i), std::move(fd));
+  }
+
+  handle.modifier = modifier;
+  return std::make_unique<Buffer>(bo, format, flags, modifier, size,
+                                  std::move(handle));
+}
+
+class Device final : public ui::GbmDevice {
+ public:
+  Device(gbm_device* device) : device_(device) {}
+
+  Device(const Device&) = delete;
+  Device& operator=(const Device&) = delete;
+
+  ~Device() override { gbm_device_destroy(device_); }
+
+  std::unique_ptr<ui::GbmBuffer> CreateBuffer(uint32_t format,
+                                              const gfx::Size& size,
+                                              uint32_t flags) override {
+    struct gbm_bo* bo =
+        gbm_bo_create(device_, size.width(), size.height(), format, flags);
+    if (!bo) {
+#if DCHECK_IS_ON()
+      const char fourcc_as_string[5] = {
+          static_cast<char>(format), static_cast<char>(format >> 8),
+          static_cast<char>(format >> 16), static_cast<char>(format >> 24), 0};
+
+      DVLOG(2) << "Failed to create GBM BO, " << fourcc_as_string << ", "
+               << size.ToString() << ", flags: 0x" << std::hex << flags
+               << "; gbm_device_is_format_supported() = "
+               << gbm_device_is_format_supported(device_, format, flags);
+#endif
+      return nullptr;
+    }
+
+    return CreateBufferForBO(bo, format, size, flags);
+  }
+
+  std::unique_ptr<ui::GbmBuffer> CreateBufferWithModifiers(
+      uint32_t format,
+      const gfx::Size& size,
+      uint32_t flags,
+      const std::vector<uint64_t>& modifiers) override {
+    if (modifiers.empty())
+      return CreateBuffer(format, size, flags);
+    CHECK(HaveGbmModifiers());
+    struct gbm_bo* bo = gbm_bo_create_with_modifiers(
+        device_, size.width(), size.height(), format, modifiers.data(),
+        modifiers.size());
+    if (!bo)
+      return nullptr;
+
+    return CreateBufferForBO(bo, format, size, flags);
+  }
+
+  std::unique_ptr<ui::GbmBuffer> CreateBufferFromHandle(
+      uint32_t format,
+      const gfx::Size& size,
+      gfx::NativePixmapHandle handle) override {
+    DCHECK_EQ(handle.planes[0].offset, 0u);
+
+    // Try to use scanout if supported.
+    int gbm_flags = GBM_BO_USE_SCANOUT;
+#if defined(MINIGBM)
+    gbm_flags |= GBM_BO_USE_TEXTURING;
+#endif
+    if (!gbm_device_is_format_supported(device_, format, gbm_flags))
+      gbm_flags &= ~GBM_BO_USE_SCANOUT;
+
+    struct gbm_bo* bo = nullptr;
+    if (!gbm_device_is_format_supported(device_, format, gbm_flags)) {
+      LOG(ERROR) << "gbm format not supported: " << format;
+      return nullptr;
+    }
+
+    struct gbm_import_fd_modifier_data fd_data;
+    fd_data.width = size.width();
+    fd_data.height = size.height();
+    fd_data.format = format;
+    fd_data.num_fds = handle.planes.size();
+    fd_data.modifier = handle.modifier;
+
+    DCHECK_LE(handle.planes.size(), 3u);
+    for (size_t i = 0; i < handle.planes.size(); ++i) {
+      fd_data.fds[i] = handle.planes[i < handle.planes.size() ? i : 0].fd.get();
+      fd_data.strides[i] = handle.planes[i].stride;
+      fd_data.offsets[i] = handle.planes[i].offset;
+    }
+
+    // The fd passed to gbm_bo_import is not ref-counted and need to be
+    // kept open for the lifetime of the buffer.
+    bo = gbm_bo_import(device_, GBM_BO_IMPORT_FD_MODIFIER, &fd_data, gbm_flags);
+    if (!bo) {
+      LOG(ERROR) << "nullptr returned from gbm_bo_import";
+      return nullptr;
+    }
+
+    return std::make_unique<Buffer>(bo, format, gbm_flags, handle.modifier,
+                                    size, std::move(handle));
+  }
+
+ private:
+  gbm_device* const device_;
+};
+
+}  // namespace gbm_wrapper
+
+namespace ui {
+
+std::unique_ptr<GbmDevice> CreateGbmDevice(int fd) {
+  gbm_device* device = gbm_create_device(fd);
+  if (!device)
+    return nullptr;
+  return std::make_unique<gbm_wrapper::Device>(device);
+}
+
+}  // namespace ui
diff --git a/ui/gfx/linux/gbm_wrapper.h b/ui/gfx/linux/gbm_wrapper.h
new file mode 100644
index 0000000..b06f44e
--- /dev/null
+++ b/ui/gfx/linux/gbm_wrapper.h
@@ -0,0 +1,18 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_GBM_WRAPPER_H_
+#define UI_GFX_LINUX_GBM_WRAPPER_H_
+
+#include <memory>
+
+#include "ui/gfx/linux/gbm_device.h"
+
+namespace ui {
+
+std::unique_ptr<ui::GbmDevice> CreateGbmDevice(int fd);
+
+}  // namespace ui
+
+#endif  // UI_GFX_LINUX_GBM_WRAPPER_H_
diff --git a/ui/gfx/linux/gpu_memory_buffer_support_x11.cc b/ui/gfx/linux/gpu_memory_buffer_support_x11.cc
new file mode 100644
index 0000000..5b89bfd
--- /dev/null
+++ b/ui/gfx/linux/gpu_memory_buffer_support_x11.cc
@@ -0,0 +1,138 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/linux/gpu_memory_buffer_support_x11.h"
+
+#include <fcntl.h>
+#include <xcb/xcb.h>
+
+#include <memory>
+
+#include "base/containers/contains.h"
+#include "base/debug/crash_logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/buffer_format_util.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/buffer_usage_util.h"
+#include "ui/gfx/linux/drm_util_linux.h"
+#include "ui/gfx/linux/gbm_buffer.h"
+#include "ui/gfx/linux/gbm_device.h"
+#include "ui/gfx/linux/gbm_util.h"
+#include "ui/gfx/linux/gbm_wrapper.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/dri3.h"
+#include "ui/gfx/x/future.h"
+
+namespace ui {
+
+namespace {
+
+// Obtain an authenticated DRM fd from X11 and create a GbmDevice with it.
+std::unique_ptr<ui::GbmDevice> CreateX11GbmDevice() {
+  auto* connection = x11::Connection::Get();
+  // |connection| may be nullptr in headless mode.
+  if (!connection)
+    return nullptr;
+
+  auto& dri3 = connection->dri3();
+  if (!dri3.present())
+    return nullptr;
+
+  // Let the X11 server know the DRI3 client version. This is required to use
+  // the DRI3 extension. We don't care about the returned server version because
+  // we only use features from the original DRI3 interface.
+  dri3.QueryVersion({x11::Dri3::major_version, x11::Dri3::minor_version});
+
+  // Obtain an authenticated DRM fd.
+  auto reply = dri3.Open({connection->default_root(), 0}).Sync();
+  if (!reply)
+    return nullptr;
+
+  base::ScopedFD fd(HANDLE_EINTR(dup(reply->device_fd.get())));
+  if (!fd.is_valid())
+    return nullptr;
+  if (HANDLE_EINTR(fcntl(fd.get(), F_SETFD, FD_CLOEXEC)) == -1)
+    return nullptr;
+
+  return ui::CreateGbmDevice(fd.release());
+}
+
+std::vector<gfx::BufferUsageAndFormat> CreateSupportedConfigList(
+    ui::GbmDevice* device) {
+  if (!device)
+    return {};
+
+  std::vector<gfx::BufferUsageAndFormat> configs;
+  for (gfx::BufferUsage usage : {
+           gfx::BufferUsage::GPU_READ,
+           gfx::BufferUsage::SCANOUT,
+           gfx::BufferUsage::SCANOUT_CPU_READ_WRITE,
+           gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
+       }) {
+    for (gfx::BufferFormat format : {
+             gfx::BufferFormat::R_8,
+             gfx::BufferFormat::RG_88,
+             gfx::BufferFormat::RGBA_8888,
+             gfx::BufferFormat::RGBX_8888,
+             gfx::BufferFormat::BGRA_8888,
+             gfx::BufferFormat::BGRX_8888,
+             gfx::BufferFormat::BGRA_1010102,
+
+             // On some Intel setups calling gbm_bo_create() with this format
+             // results in a crash caused by an integer-divide-by-zero.
+             // TODO(thomasanderson): Enable this format.
+             // gfx::BufferFormat::RGBA_1010102,
+             gfx::BufferFormat::BGR_565,
+             gfx::BufferFormat::YUV_420_BIPLANAR,
+             gfx::BufferFormat::YVU_420,
+             gfx::BufferFormat::P010,
+         }) {
+      // At least on mesa/amdgpu, gbm_device_is_format_supported() lies.  Test
+      // format support by creating a buffer directly.  Use a 2x2 buffer so that
+      // YUV420 formats get properly tested.
+      if (device->CreateBuffer(GetFourCCFormatFromBufferFormat(format),
+                               gfx::Size(2, 2), BufferUsageToGbmFlags(usage))) {
+        configs.push_back(gfx::BufferUsageAndFormat(usage, format));
+      }
+    }
+  }
+  return configs;
+}
+
+}  // namespace
+
+// static
+GpuMemoryBufferSupportX11* GpuMemoryBufferSupportX11::GetInstance() {
+  static base::NoDestructor<GpuMemoryBufferSupportX11> instance;
+  return instance.get();
+}
+
+GpuMemoryBufferSupportX11::GpuMemoryBufferSupportX11()
+    : device_(CreateX11GbmDevice()),
+      supported_configs_(CreateSupportedConfigList(device_.get())) {}
+
+GpuMemoryBufferSupportX11::~GpuMemoryBufferSupportX11() = default;
+
+std::unique_ptr<GbmBuffer> GpuMemoryBufferSupportX11::CreateBuffer(
+    gfx::BufferFormat format,
+    const gfx::Size& size,
+    gfx::BufferUsage usage) {
+  DCHECK(device_);
+  DCHECK(base::Contains(supported_configs_,
+                        gfx::BufferUsageAndFormat(usage, format)));
+
+  static base::debug::CrashKeyString* crash_key_string =
+      base::debug::AllocateCrashKeyString("buffer_usage_and_format",
+                                          base::debug::CrashKeySize::Size64);
+  std::string buffer_usage_and_format = gfx::BufferFormatToString(format) +
+                                        std::string(",") +
+                                        gfx::BufferUsageToString(usage);
+  base::debug::ScopedCrashKeyString scoped_crash_key(
+      crash_key_string, buffer_usage_and_format.c_str());
+
+  return device_->CreateBuffer(GetFourCCFormatFromBufferFormat(format), size,
+                               BufferUsageToGbmFlags(usage));
+}
+
+}  // namespace ui
diff --git a/ui/gfx/linux/gpu_memory_buffer_support_x11.h b/ui/gfx/linux/gpu_memory_buffer_support_x11.h
new file mode 100644
index 0000000..600354a
--- /dev/null
+++ b/ui/gfx/linux/gpu_memory_buffer_support_x11.h
@@ -0,0 +1,55 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_GPU_MEMORY_BUFFER_SUPPORT_X11_H_
+#define UI_GFX_LINUX_GPU_MEMORY_BUFFER_SUPPORT_X11_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/no_destructor.h"
+#include "ui/gfx/buffer_types.h"
+
+namespace gfx {
+class Size;
+}
+
+namespace ui {
+
+class GbmBuffer;
+class GbmDevice;
+
+// Obtains and holds a GbmDevice for creating GbmBuffers.  Maintains a list of
+// supported buffer configurations.
+class COMPONENT_EXPORT(GBM_SUPPORT_X11) GpuMemoryBufferSupportX11 {
+ public:
+  static GpuMemoryBufferSupportX11* GetInstance();
+
+  std::unique_ptr<GbmBuffer> CreateBuffer(gfx::BufferFormat format,
+                                          const gfx::Size& size,
+                                          gfx::BufferUsage usage);
+
+  ~GpuMemoryBufferSupportX11();
+
+  GpuMemoryBufferSupportX11(const GpuMemoryBufferSupportX11&) = delete;
+  GpuMemoryBufferSupportX11& operator=(const GpuMemoryBufferSupportX11&) =
+      delete;
+
+  const std::vector<gfx::BufferUsageAndFormat>& supported_configs() const {
+    return supported_configs_;
+  }
+
+ private:
+  friend class base::NoDestructor<GpuMemoryBufferSupportX11>;
+
+  GpuMemoryBufferSupportX11();
+
+  const std::unique_ptr<GbmDevice> device_;
+  const std::vector<gfx::BufferUsageAndFormat> supported_configs_;
+};
+
+}  // namespace ui
+
+#endif  // UI_GFX_LINUX_GPU_MEMORY_BUFFER_SUPPORT_X11_H_
diff --git a/ui/gfx/linux/native_pixmap_dmabuf.cc b/ui/gfx/linux/native_pixmap_dmabuf.cc
new file mode 100644
index 0000000..2cddfdd
--- /dev/null
+++ b/ui/gfx/linux/native_pixmap_dmabuf.cc
@@ -0,0 +1,83 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/linux/native_pixmap_dmabuf.h"
+
+#include <utility>
+
+#include "base/posix/eintr_wrapper.h"
+
+namespace gfx {
+
+NativePixmapDmaBuf::NativePixmapDmaBuf(const gfx::Size& size,
+                                       gfx::BufferFormat format,
+                                       gfx::NativePixmapHandle handle)
+    : size_(size), format_(format), handle_(std::move(handle)) {}
+
+NativePixmapDmaBuf::~NativePixmapDmaBuf() {}
+
+bool NativePixmapDmaBuf::AreDmaBufFdsValid() const {
+  if (handle_.planes.empty())
+    return false;
+
+  for (const auto& plane : handle_.planes) {
+    if (!plane.fd.is_valid())
+      return false;
+  }
+  return true;
+}
+
+int NativePixmapDmaBuf::GetDmaBufFd(size_t plane) const {
+  DCHECK_LT(plane, handle_.planes.size());
+  return handle_.planes[plane].fd.get();
+}
+
+uint32_t NativePixmapDmaBuf::GetDmaBufPitch(size_t plane) const {
+  DCHECK_LT(plane, handle_.planes.size());
+  return handle_.planes[plane].stride;
+}
+
+size_t NativePixmapDmaBuf::GetDmaBufOffset(size_t plane) const {
+  DCHECK_LT(plane, handle_.planes.size());
+  return static_cast<size_t>(handle_.planes[plane].offset);
+}
+
+size_t NativePixmapDmaBuf::GetDmaBufPlaneSize(size_t plane) const {
+  DCHECK_LT(plane, handle_.planes.size());
+  return static_cast<size_t>(handle_.planes[plane].size);
+}
+
+uint64_t NativePixmapDmaBuf::GetBufferFormatModifier() const {
+  return handle_.modifier;
+}
+
+gfx::BufferFormat NativePixmapDmaBuf::GetBufferFormat() const {
+  return format_;
+}
+
+size_t NativePixmapDmaBuf::GetNumberOfPlanes() const {
+  return handle_.planes.size();
+}
+
+gfx::Size NativePixmapDmaBuf::GetBufferSize() const {
+  return size_;
+}
+
+uint32_t NativePixmapDmaBuf::GetUniqueId() const {
+  return 0;
+}
+
+bool NativePixmapDmaBuf::ScheduleOverlayPlane(
+    gfx::AcceleratedWidget widget,
+    const gfx::OverlayPlaneData& overlay_plane_data,
+    std::vector<gfx::GpuFence> acquire_fences,
+    std::vector<gfx::GpuFence> release_fences) {
+  return false;
+}
+
+gfx::NativePixmapHandle NativePixmapDmaBuf::ExportHandle() {
+  return gfx::CloneHandleForIPC(handle_);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/linux/native_pixmap_dmabuf.h b/ui/gfx/linux/native_pixmap_dmabuf.h
new file mode 100644
index 0000000..78edc14
--- /dev/null
+++ b/ui/gfx/linux/native_pixmap_dmabuf.h
@@ -0,0 +1,61 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_NATIVE_PIXMAP_DMABUF_H_
+#define UI_GFX_LINUX_NATIVE_PIXMAP_DMABUF_H_
+
+#include <stdint.h>
+
+#include <memory>
+
+#include "base/files/scoped_file.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "ui/gfx/client_native_pixmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/native_pixmap.h"
+
+namespace gfx {
+
+// This class converts a gfx::NativePixmapHandle to a gfx::NativePixmap.
+// It is useful because gl::GLImageNativePixmap::Initialize only takes
+// a gfx::NativePixmap as input.
+class GFX_EXPORT NativePixmapDmaBuf : public gfx::NativePixmap {
+ public:
+  NativePixmapDmaBuf(const gfx::Size& size,
+                     gfx::BufferFormat format,
+                     gfx::NativePixmapHandle handle);
+
+  NativePixmapDmaBuf(const NativePixmapDmaBuf&) = delete;
+  NativePixmapDmaBuf& operator=(const NativePixmapDmaBuf&) = delete;
+
+  // NativePixmap:
+  bool AreDmaBufFdsValid() const override;
+  int GetDmaBufFd(size_t plane) const override;
+  uint32_t GetDmaBufPitch(size_t plane) const override;
+  size_t GetDmaBufOffset(size_t plane) const override;
+  size_t GetDmaBufPlaneSize(size_t plane) const override;
+  uint64_t GetBufferFormatModifier() const override;
+  gfx::BufferFormat GetBufferFormat() const override;
+  size_t GetNumberOfPlanes() const override;
+  gfx::Size GetBufferSize() const override;
+  uint32_t GetUniqueId() const override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                            const gfx::OverlayPlaneData& overlay_plane_data,
+                            std::vector<gfx::GpuFence> acquire_fences,
+                            std::vector<gfx::GpuFence> release_fences) override;
+  gfx::NativePixmapHandle ExportHandle() override;
+
+ protected:
+  ~NativePixmapDmaBuf() override;
+
+ private:
+  gfx::Size size_;
+  gfx::BufferFormat format_;
+  gfx::NativePixmapHandle handle_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_LINUX_NATIVE_PIXMAP_DMABUF_H_
diff --git a/ui/gfx/linux/native_pixmap_dmabuf_unittest.cc b/ui/gfx/linux/native_pixmap_dmabuf_unittest.cc
new file mode 100644
index 0000000..1d7ccfc
--- /dev/null
+++ b/ui/gfx/linux/native_pixmap_dmabuf_unittest.cc
@@ -0,0 +1,76 @@
+// Copyright (c) 2017 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.
+
+#include "ui/gfx/linux/native_pixmap_dmabuf.h"
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <utility>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/buffer_format_util.h"
+
+namespace gfx {
+
+class NativePixmapDmaBufTest
+    : public ::testing::TestWithParam<gfx::BufferFormat> {
+ protected:
+  gfx::NativePixmapHandle CreateMockNativePixmapHandle(
+      gfx::Size image_size,
+      const gfx::BufferFormat format) {
+    gfx::NativePixmapHandle handle;
+    handle.modifier = 1;
+    const int num_planes = gfx::NumberOfPlanesForLinearBufferFormat(format);
+    for (int i = 0; i < num_planes; ++i) {
+      // These values are arbitrarily chosen to be different from each other.
+      const int stride = (i + 1) * image_size.width();
+      const int offset = i * image_size.width() * image_size.height();
+      const uint64_t size = stride * image_size.height();
+      base::ScopedFD fd(open("/dev/zero", O_RDONLY));
+      EXPECT_TRUE(fd.is_valid());
+
+      handle.planes.emplace_back(stride, offset, size, std::move(fd));
+    }
+
+    return handle;
+  }
+};
+
+INSTANTIATE_TEST_SUITE_P(ConvertTest,
+                         NativePixmapDmaBufTest,
+                         ::testing::Values(gfx::BufferFormat::RGBX_8888,
+                                           gfx::BufferFormat::YVU_420));
+
+// Verifies NativePixmapDmaBuf conversion from and to NativePixmapHandle.
+TEST_P(NativePixmapDmaBufTest, Convert) {
+  const gfx::BufferFormat format = GetParam();
+  const gfx::Size image_size(128, 64);
+
+  gfx::NativePixmapHandle handle =
+      CreateMockNativePixmapHandle(image_size, format);
+
+  gfx::NativePixmapHandle handle_clone = CloneHandleForIPC(handle);
+
+  // NativePixmapHandle to NativePixmapDmabuf
+  scoped_refptr<gfx::NativePixmap> native_pixmap_dmabuf(
+      new gfx::NativePixmapDmaBuf(image_size, format, std::move(handle)));
+  EXPECT_TRUE(native_pixmap_dmabuf->AreDmaBufFdsValid());
+  EXPECT_EQ(native_pixmap_dmabuf->GetBufferFormatModifier(),
+            handle_clone.modifier);
+  // NativePixmap to NativePixmapHandle.
+  const size_t num_planes = gfx::NumberOfPlanesForLinearBufferFormat(
+      native_pixmap_dmabuf->GetBufferFormat());
+  for (size_t i = 0; i < num_planes; ++i) {
+    EXPECT_EQ(native_pixmap_dmabuf->GetDmaBufPitch(i),
+              handle_clone.planes[i].stride);
+    EXPECT_EQ(native_pixmap_dmabuf->GetDmaBufOffset(i),
+              handle_clone.planes[i].offset);
+    EXPECT_EQ(native_pixmap_dmabuf->GetDmaBufPlaneSize(i),
+              static_cast<size_t>(handle_clone.planes[i].size));
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/linux/scoped_gbm_device.cc b/ui/gfx/linux/scoped_gbm_device.cc
new file mode 100644
index 0000000..951a91b
--- /dev/null
+++ b/ui/gfx/linux/scoped_gbm_device.cc
@@ -0,0 +1,14 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/linux/scoped_gbm_device.h"
+
+namespace ui {
+
+void GbmDeviceDeleter::operator()(gbm_device* device) {
+  if (device)
+    gbm_device_destroy(device);
+}
+
+}  // namespace ui
diff --git a/ui/gfx/linux/scoped_gbm_device.h b/ui/gfx/linux/scoped_gbm_device.h
new file mode 100644
index 0000000..0abed15
--- /dev/null
+++ b/ui/gfx/linux/scoped_gbm_device.h
@@ -0,0 +1,22 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_SCOPED_GBM_DEVICE_H_
+#define UI_GFX_LINUX_SCOPED_GBM_DEVICE_H_
+
+#include <gbm.h>
+
+#include <memory>
+
+namespace ui {
+
+struct GbmDeviceDeleter {
+  void operator()(gbm_device* device);
+};
+
+using ScopedGbmDevice = std::unique_ptr<gbm_device, GbmDeviceDeleter>;
+
+}  // namespace ui
+
+#endif  // UI_GFX_LINUX_SCOPED_GBM_DEVICE_H_
diff --git a/ui/gfx/linux/test/mock_gbm_device.cc b/ui/gfx/linux/test/mock_gbm_device.cc
new file mode 100644
index 0000000..9ea3659
--- /dev/null
+++ b/ui/gfx/linux/test/mock_gbm_device.cc
@@ -0,0 +1,188 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/linux/test/mock_gbm_device.h"
+
+#include <xf86drm.h>
+#include <memory>
+#include <utility>
+
+#include "base/check_op.h"
+#include "base/containers/contains.h"
+#include "base/files/file_util.h"
+#include "base/logging.h"
+#include "base/notreached.h"
+#include "base/numerics/safe_math.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkSurface.h"
+#include "ui/gfx/linux/drm_util_linux.h"
+#include "ui/gfx/linux/gbm_buffer.h"
+
+namespace ui {
+namespace {
+
+base::ScopedFD MakeFD() {
+  base::FilePath temp_path;
+  if (!base::CreateTemporaryFile(&temp_path))
+    return {};
+  auto file =
+      base::File(temp_path, base::File::FLAG_READ | base::File::FLAG_WRITE |
+                                base::File::FLAG_CREATE_ALWAYS);
+  return base::ScopedFD(file.TakePlatformFile());
+}
+
+class MockGbmBuffer final : public ui::GbmBuffer {
+ public:
+  MockGbmBuffer(uint32_t format,
+                uint32_t flags,
+                uint64_t modifier,
+                const gfx::Size& size,
+                std::vector<gfx::NativePixmapPlane> planes,
+                std::vector<uint32_t> handles)
+      : format_(format),
+        format_modifier_(modifier),
+        flags_(flags),
+        size_(size),
+        planes_(std::move(planes)),
+        handles_(std::move(handles)) {}
+
+  MockGbmBuffer(const MockGbmBuffer&) = delete;
+  MockGbmBuffer& operator=(const MockGbmBuffer&) = delete;
+
+  ~MockGbmBuffer() override = default;
+
+  uint32_t GetFormat() const override { return format_; }
+  uint64_t GetFormatModifier() const override { return format_modifier_; }
+  uint32_t GetFlags() const override { return flags_; }
+  gfx::Size GetSize() const override { return size_; }
+  gfx::BufferFormat GetBufferFormat() const override {
+    return ui::GetBufferFormatFromFourCCFormat(format_);
+  }
+  bool AreFdsValid() const override {
+    if (planes_.empty())
+      return false;
+
+    for (const auto& plane : planes_) {
+      if (!plane.fd.is_valid())
+        return false;
+    }
+    return true;
+  }
+  size_t GetNumPlanes() const override { return planes_.size(); }
+  int GetPlaneFd(size_t plane) const override {
+    return planes_[plane].fd.get();
+  }
+  uint32_t GetPlaneStride(size_t plane) const override {
+    DCHECK_LT(plane, planes_.size());
+    return planes_[plane].stride;
+  }
+  size_t GetPlaneOffset(size_t plane) const override {
+    DCHECK_LT(plane, planes_.size());
+    return planes_[plane].offset;
+  }
+  size_t GetPlaneSize(size_t plane) const override {
+    DCHECK_LT(plane, planes_.size());
+    return static_cast<size_t>(planes_[plane].size);
+  }
+  uint32_t GetPlaneHandle(size_t plane) const override {
+    DCHECK_LT(plane, planes_.size());
+    return handles_[plane];
+  }
+  uint32_t GetHandle() const override { return GetPlaneHandle(0); }
+  gfx::NativePixmapHandle ExportHandle() const override {
+    NOTIMPLEMENTED();
+    return gfx::NativePixmapHandle();
+  }
+
+  sk_sp<SkSurface> GetSurface() override { return nullptr; }
+
+ private:
+  uint32_t format_ = 0;
+  uint64_t format_modifier_ = 0;
+  uint32_t flags_ = 0;
+  gfx::Size size_;
+  std::vector<gfx::NativePixmapPlane> planes_;
+  std::vector<uint32_t> handles_;
+};
+
+}  // namespace
+
+MockGbmDevice::MockGbmDevice() = default;
+
+MockGbmDevice::~MockGbmDevice() = default;
+
+void MockGbmDevice::set_allocation_failure(bool should_fail_allocations) {
+  should_fail_allocations_ = should_fail_allocations;
+}
+
+std::vector<uint64_t> MockGbmDevice::GetSupportedModifiers() const {
+  return supported_modifiers_;
+}
+
+std::unique_ptr<GbmBuffer> MockGbmDevice::CreateBuffer(uint32_t format,
+                                                       const gfx::Size& size,
+                                                       uint32_t flags) {
+  if (should_fail_allocations_)
+    return nullptr;
+
+  return CreateBufferWithModifiers(format, size, flags, {});
+}
+
+std::unique_ptr<GbmBuffer> MockGbmDevice::CreateBufferWithModifiers(
+    uint32_t format,
+    const gfx::Size& size,
+    uint32_t flags,
+    const std::vector<uint64_t>& modifiers) {
+  if (should_fail_allocations_)
+    return nullptr;
+
+  uint32_t bytes_per_pixel;
+  switch (format) {
+    case DRM_FORMAT_XRGB8888:
+    case DRM_FORMAT_ARGB8888:
+    case DRM_FORMAT_ARGB2101010:
+    case DRM_FORMAT_ABGR2101010:
+      bytes_per_pixel = 4;
+      break;
+    case DRM_FORMAT_NV12:
+      bytes_per_pixel = 2;
+      break;
+    default:
+      NOTREACHED() << "Unsupported format: " << format;
+      return nullptr;
+  }
+
+  uint64_t format_modifier =
+      modifiers.empty() ? DRM_FORMAT_MOD_NONE : modifiers.back();
+
+  if (!base::Contains(supported_modifiers_, format_modifier)) {
+    PLOG(ERROR) << "Unsupported format modifier: " << std::hex
+                << format_modifier;
+    return nullptr;
+  }
+
+  uint32_t width = base::checked_cast<uint32_t>(size.width());
+  uint32_t height = base::checked_cast<uint32_t>(size.height());
+  uint32_t plane_stride = base::CheckMul(bytes_per_pixel, width).ValueOrDie();
+  uint32_t plane_size = base::CheckMul(plane_stride, height).ValueOrDie();
+  uint32_t plane_offset = 0;
+
+  std::vector<gfx::NativePixmapPlane> planes;
+  planes.emplace_back(plane_stride, plane_offset, plane_size, MakeFD());
+  std::vector<uint32_t> handles;
+  handles.push_back(next_handle_++);
+
+  return std::make_unique<MockGbmBuffer>(format, flags, format_modifier, size,
+                                         std::move(planes), std::move(handles));
+}
+
+std::unique_ptr<GbmBuffer> MockGbmDevice::CreateBufferFromHandle(
+    uint32_t format,
+    const gfx::Size& size,
+    gfx::NativePixmapHandle handle) {
+  NOTREACHED();
+  return nullptr;
+}
+
+}  // namespace ui
diff --git a/ui/gfx/linux/test/mock_gbm_device.h b/ui/gfx/linux/test/mock_gbm_device.h
new file mode 100644
index 0000000..16c9d2d
--- /dev/null
+++ b/ui/gfx/linux/test/mock_gbm_device.h
@@ -0,0 +1,53 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_LINUX_TEST_MOCK_GBM_DEVICE_H_
+#define UI_GFX_LINUX_TEST_MOCK_GBM_DEVICE_H_
+
+#include <drm_fourcc.h>
+#include <vector>
+#include "ui/gfx/linux/gbm_device.h"
+
+namespace ui {
+
+// The real DrmDevice makes actual DRM calls which we can't use in unit tests.
+class MockGbmDevice : public GbmDevice {
+ public:
+  MockGbmDevice();
+
+  MockGbmDevice(const MockGbmDevice&) = delete;
+  MockGbmDevice& operator=(const MockGbmDevice&) = delete;
+
+  ~MockGbmDevice() override;
+
+  void set_allocation_failure(bool should_fail_allocations);
+  std::vector<uint64_t> GetSupportedModifiers() const;
+
+  // GbmDevice:
+  std::unique_ptr<GbmBuffer> CreateBuffer(uint32_t format,
+                                          const gfx::Size& size,
+                                          uint32_t flags) override;
+  std::unique_ptr<GbmBuffer> CreateBufferWithModifiers(
+      uint32_t format,
+      const gfx::Size& size,
+      uint32_t flags,
+      const std::vector<uint64_t>& modifiers) override;
+  std::unique_ptr<GbmBuffer> CreateBufferFromHandle(
+      uint32_t format,
+      const gfx::Size& size,
+      gfx::NativePixmapHandle handle) override;
+
+ private:
+  uint32_t next_handle_ = 0;
+  bool should_fail_allocations_ = false;
+
+  // List of modifiers that MockGbm validates when used.
+  const std::vector<uint64_t> supported_modifiers_ = {
+      DRM_FORMAT_MOD_LINEAR, I915_FORMAT_MOD_X_TILED, I915_FORMAT_MOD_Y_TILED,
+      I915_FORMAT_MOD_Yf_TILED_CCS};
+};
+
+}  // namespace ui
+
+#endif  // UI_GFX_LINUX_TEST_MOCK_GBM_DEVICE_H_
diff --git a/ui/gfx/mac/coordinate_conversion.h b/ui/gfx/mac/coordinate_conversion.h
new file mode 100644
index 0000000..3b75485
--- /dev/null
+++ b/ui/gfx/mac/coordinate_conversion.h
@@ -0,0 +1,35 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MAC_COORDINATE_CONVERSION_H_
+#define UI_GFX_MAC_COORDINATE_CONVERSION_H_
+
+#import <Foundation/Foundation.h>
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class Point;
+class Rect;
+
+// Convert a gfx::Rect specified with the origin at the top left of the primary
+// display into AppKit secreen coordinates (origin at the bottom left).
+GFX_EXPORT NSRect ScreenRectToNSRect(const Rect& rect);
+
+// Convert an AppKit NSRect with origin in the bottom left of the primary
+// display into a gfx::Rect with origin at the top left of the primary display.
+GFX_EXPORT Rect ScreenRectFromNSRect(const NSRect& point);
+
+// Convert a gfx::Point specified with the origin at the top left of the primary
+// display into AppKit screen coordinates (origin at the bottom left).
+GFX_EXPORT NSPoint ScreenPointToNSPoint(const Point& point);
+
+// Convert an AppKit NSPoint with origin in the bottom left of the primary
+// display into a gfx::Point with origin at the top left of the primary display.
+GFX_EXPORT Point ScreenPointFromNSPoint(const NSPoint& point);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_MAC_COORDINATE_CONVERSION_H_
diff --git a/ui/gfx/mac/coordinate_conversion.mm b/ui/gfx/mac/coordinate_conversion.mm
new file mode 100644
index 0000000..b31ce9e
--- /dev/null
+++ b/ui/gfx/mac/coordinate_conversion.mm
@@ -0,0 +1,45 @@
+// Copyright 2014 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.
+
+#import "ui/gfx/mac/coordinate_conversion.h"
+
+#import <Cocoa/Cocoa.h>
+
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace gfx {
+
+namespace {
+
+// The height of the primary display, which OSX defines as the monitor with the
+// menubar. This is always at index 0.
+CGFloat PrimaryDisplayHeight() {
+  return NSMaxY([[[NSScreen screens] firstObject] frame]);
+}
+
+}  // namespace
+
+NSRect ScreenRectToNSRect(const Rect& rect) {
+  return NSMakeRect(rect.x(),
+                    PrimaryDisplayHeight() - rect.y() - rect.height(),
+                    rect.width(),
+                    rect.height());
+}
+
+Rect ScreenRectFromNSRect(const NSRect& rect) {
+  return Rect(rect.origin.x,
+              PrimaryDisplayHeight() - rect.origin.y - rect.size.height,
+              rect.size.width, rect.size.height);
+}
+
+NSPoint ScreenPointToNSPoint(const Point& point) {
+  return NSMakePoint(point.x(), PrimaryDisplayHeight() - point.y());
+}
+
+Point ScreenPointFromNSPoint(const NSPoint& point) {
+  return Point(point.x, PrimaryDisplayHeight() - point.y);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/mac/coordinate_conversion_unittest.mm b/ui/gfx/mac/coordinate_conversion_unittest.mm
new file mode 100644
index 0000000..23f078a
--- /dev/null
+++ b/ui/gfx/mac/coordinate_conversion_unittest.mm
@@ -0,0 +1,139 @@
+// Copyright 2014 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.
+
+#import "ui/gfx/mac/coordinate_conversion.h"
+
+#import <Cocoa/Cocoa.h>
+
+#include <memory>
+
+#import "base/mac/scoped_objc_class_swizzler.h"
+#include "base/macros.h"
+#import "testing/gtest_mac.h"
+#import "testing/platform_test.h"
+#include "ui/gfx/geometry/rect.h"
+
+const int kTestWidth = 320;
+const int kTestHeight = 200;
+
+// Class to donate an implementation of -[NSScreen frame] that provides a known
+// value for robust tests.
+@interface MacCoordinateConversionTestScreenDonor : NSObject
+- (NSRect)frame;
+@end
+
+@implementation MacCoordinateConversionTestScreenDonor
+- (NSRect)frame {
+  return NSMakeRect(0, 0, kTestWidth, kTestHeight);
+}
+@end
+
+namespace gfx {
+namespace {
+
+class MacCoordinateConversionTest : public PlatformTest {
+ public:
+  MacCoordinateConversionTest() {}
+
+  MacCoordinateConversionTest(const MacCoordinateConversionTest&) = delete;
+  MacCoordinateConversionTest& operator=(const MacCoordinateConversionTest&) =
+      delete;
+
+  // Overridden from testing::Test:
+  void SetUp() override;
+  void TearDown() override;
+
+ private:
+  std::unique_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_frame_;
+};
+
+void MacCoordinateConversionTest::SetUp() {
+  // Before swizzling, do a sanity check that the primary screen's origin is
+  // (0, 0). This should always be true.
+  NSRect primary_screen_frame = [[[NSScreen screens] firstObject] frame];
+  EXPECT_EQ(0, primary_screen_frame.origin.x);
+  EXPECT_EQ(0, primary_screen_frame.origin.y);
+
+  swizzle_frame_ = std::make_unique<base::mac::ScopedObjCClassSwizzler>(
+      [NSScreen class], [MacCoordinateConversionTestScreenDonor class],
+      @selector(frame));
+
+  primary_screen_frame = [[[NSScreen screens] firstObject] frame];
+  EXPECT_EQ(kTestWidth, primary_screen_frame.size.width);
+  EXPECT_EQ(kTestHeight, primary_screen_frame.size.height);
+}
+
+void MacCoordinateConversionTest::TearDown() {
+  swizzle_frame_.reset();
+}
+
+}  // namespace
+
+// Tests for coordinate conversion on Mac. Start with the following setup:
+// AppKit ....... gfx
+// 199              0
+// 189             10   Window of height 40 fills in pixel
+// 179  ---------  20   at index 20
+// 169  |       |  30   through
+// ...  :       :  ..   to
+// 150  |       |  49   pixel
+// 140  ---------  59   at index 59
+// 130             69   (inclusive).
+//  ..             ..
+//   0            199
+TEST_F(MacCoordinateConversionTest, ScreenRectToFromNSRect) {
+  // Window on the primary screen.
+  Rect gfx_rect = Rect(10, 20, 30, 40);
+  NSRect ns_rect = ScreenRectToNSRect(gfx_rect);
+  EXPECT_NSEQ(NSMakeRect(10, 140, 30, 40), ns_rect);
+  EXPECT_EQ(gfx_rect, ScreenRectFromNSRect(ns_rect));
+
+  // Window in a screen to the left of the primary screen.
+  gfx_rect = Rect(-40, 20, 30, 40);
+  ns_rect = ScreenRectToNSRect(gfx_rect);
+  EXPECT_NSEQ(NSMakeRect(-40, 140, 30, 40), ns_rect);
+  EXPECT_EQ(gfx_rect, ScreenRectFromNSRect(ns_rect));
+
+  // Window in a screen below the primary screen.
+  gfx_rect = Rect(10, 220, 30, 40);
+  ns_rect = ScreenRectToNSRect(gfx_rect);
+  EXPECT_NSEQ(NSMakeRect(10, -60, 30, 40), ns_rect);
+  EXPECT_EQ(gfx_rect, ScreenRectFromNSRect(ns_rect));
+
+  // Window in a screen below and to the left primary screen.
+  gfx_rect = Rect(-40, 220, 30, 40);
+  ns_rect = ScreenRectToNSRect(gfx_rect);
+  EXPECT_NSEQ(NSMakeRect(-40, -60, 30, 40), ns_rect);
+  EXPECT_EQ(gfx_rect, ScreenRectFromNSRect(ns_rect));
+}
+
+// Test point conversions using the same setup as ScreenRectToFromNSRect, but
+// using only the origin.
+TEST_F(MacCoordinateConversionTest, ScreenPointToFromNSPoint) {
+  // Point on the primary screen.
+  Point gfx_point = Point(10, 20);
+  NSPoint ns_point = ScreenPointToNSPoint(gfx_point);
+  EXPECT_NSEQ(NSMakePoint(10, 180), ns_point);
+  EXPECT_EQ(gfx_point, ScreenPointFromNSPoint(ns_point));
+
+  // Point in a screen to the left of the primary screen.
+  gfx_point = Point(-40, 20);
+  ns_point = ScreenPointToNSPoint(gfx_point);
+  EXPECT_NSEQ(NSMakePoint(-40, 180), ns_point);
+  EXPECT_EQ(gfx_point, ScreenPointFromNSPoint(ns_point));
+
+  // Point in a screen below the primary screen.
+  gfx_point = Point(10, 220);
+  ns_point = ScreenPointToNSPoint(gfx_point);
+  EXPECT_NSEQ(NSMakePoint(10, -20), ns_point);
+  EXPECT_EQ(gfx_point, ScreenPointFromNSPoint(ns_point));
+
+  // Point in a screen below and to the left primary screen.
+  gfx_point = Point(-40, 220);
+  ns_point = ScreenPointToNSPoint(gfx_point);
+  EXPECT_NSEQ(NSMakePoint(-40, -20), ns_point);
+  EXPECT_EQ(gfx_point, ScreenPointFromNSPoint(ns_point));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/mac/display_icc_profiles.cc b/ui/gfx/mac/display_icc_profiles.cc
new file mode 100644
index 0000000..119b652
--- /dev/null
+++ b/ui/gfx/mac/display_icc_profiles.cc
@@ -0,0 +1,93 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/mac/display_icc_profiles.h"
+
+#include "base/notreached.h"
+#include "ui/gfx/icc_profile.h"
+
+namespace gfx {
+
+DisplayICCProfiles* DisplayICCProfiles::GetInstance() {
+  static base::NoDestructor<DisplayICCProfiles> profiles;
+  return profiles.get();
+}
+
+base::ScopedCFTypeRef<CFDataRef> DisplayICCProfiles::GetDataForColorSpace(
+    const ColorSpace& color_space) {
+  UpdateIfNeeded();
+  base::ScopedCFTypeRef<CFDataRef> result;
+  auto found = map_.find(color_space);
+  if (found != map_.end())
+    result = found->second;
+  return result;
+}
+
+DisplayICCProfiles::DisplayICCProfiles() {
+  CGDisplayRegisterReconfigurationCallback(
+      DisplayICCProfiles::DisplayReconfigurationCallBack, this);
+}
+
+DisplayICCProfiles::~DisplayICCProfiles() {
+  NOTREACHED();
+}
+
+void DisplayICCProfiles::UpdateIfNeeded() {
+  if (!needs_update_)
+    return;
+  needs_update_ = false;
+  map_.clear();
+
+  // Always add Apple's sRGB profile.
+  base::ScopedCFTypeRef<CFDataRef> srgb_icc(CGColorSpaceCopyICCProfile(
+      CGColorSpaceCreateWithName(kCGColorSpaceSRGB)));
+  map_[ColorSpace::CreateSRGB()] = srgb_icc;
+
+  // Add the profiles for all active displays.
+  uint32_t display_count = 0;
+  CGError error = kCGErrorSuccess;
+  error = CGGetActiveDisplayList(0, nullptr, &display_count);
+  if (error != kCGErrorSuccess)
+    return;
+  if (!display_count)
+    return;
+
+  std::vector<CGDirectDisplayID> displays(display_count);
+  error =
+      CGGetActiveDisplayList(displays.size(), displays.data(), &display_count);
+  if (error != kCGErrorSuccess)
+    return;
+
+  for (uint32_t i = 0; i < display_count; ++i) {
+    base::ScopedCFTypeRef<CGColorSpaceRef> cg_color_space(
+        CGDisplayCopyColorSpace(displays[i]));
+    if (!cg_color_space)
+      continue;
+    base::ScopedCFTypeRef<CFDataRef> icc_data(
+        CGColorSpaceCopyICCProfile(cg_color_space));
+    if (!icc_data)
+      continue;
+    ICCProfile icc_profile = ICCProfile::FromData(CFDataGetBytePtr(icc_data),
+                                                  CFDataGetLength(icc_data));
+    ColorSpace color_space = icc_profile.GetColorSpace();
+    // If the ICC profile isn't accurately parametrically approximated, then
+    // don't store its data (we will assign the best parametric fit to
+    // IOSurfaces, and rely on the system compositor to do conversion to the
+    // display profile).
+    if (color_space.IsValid() && icc_profile.IsColorSpaceAccurate())
+      map_[color_space] = icc_data;
+  }
+}
+
+// static
+void DisplayICCProfiles::DisplayReconfigurationCallBack(
+    CGDirectDisplayID display,
+    CGDisplayChangeSummaryFlags flags,
+    void* user_info) {
+  DisplayICCProfiles* profiles =
+      reinterpret_cast<DisplayICCProfiles*>(user_info);
+  profiles->needs_update_ = true;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/mac/display_icc_profiles.h b/ui/gfx/mac/display_icc_profiles.h
new file mode 100644
index 0000000..565bb0c
--- /dev/null
+++ b/ui/gfx/mac/display_icc_profiles.h
@@ -0,0 +1,61 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MAC_DISPLAY_ICC_PROFILES_H_
+#define UI_GFX_MAC_DISPLAY_ICC_PROFILES_H_
+
+#include <CoreGraphics/CoreGraphics.h>
+
+#include "base/containers/flat_map.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "base/macros.h"
+#include "base/no_destructor.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/color_space_export.h"
+
+namespace gfx {
+
+// A map from ColorSpace objects to the display ICC profile data from which the
+// ColorSpace was derived.
+//  - The color space for an IOSurface, when composited by CoreAnimation, is
+//    specified via ICC profile metadata.
+//  - The power cost of compositing an IOSurface that has the same color space
+//    as the display it is being composited to is substantially less (~0.5 W for
+//    fullscreen updates at 60fps) than the cost of compositing an IOSurface
+//    that has a different color space than the display is being composited to.
+//  - This power savings is realized only if the ICC profile metadata on the
+//    IOSurface matches, byte-for-byte, the profile of the CGDirectDisplayID it
+//    is being displayed on.
+//  - This structure maintains a map from ColorSpace objects to ICC profile data
+//    for all displays in the system (and auto-updates as displays change).
+class COLOR_SPACE_EXPORT DisplayICCProfiles {
+ public:
+  static DisplayICCProfiles* GetInstance();
+
+  DisplayICCProfiles(const DisplayICCProfiles&) = delete;
+  DisplayICCProfiles& operator=(const DisplayICCProfiles&) = delete;
+
+  // This will return null if |color_space| does not correspond to a display.
+  base::ScopedCFTypeRef<CFDataRef> GetDataForColorSpace(
+      const ColorSpace& color_space);
+
+ private:
+  friend class base::NoDestructor<DisplayICCProfiles>;
+
+  static void DisplayReconfigurationCallBack(CGDirectDisplayID display,
+                                             CGDisplayChangeSummaryFlags flags,
+                                             void* user_info);
+
+  DisplayICCProfiles();
+  ~DisplayICCProfiles();
+
+  void UpdateIfNeeded();
+
+  base::flat_map<ColorSpace, base::ScopedCFTypeRef<CFDataRef>> map_;
+  bool needs_update_ = true;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_MAC_DISPLAY_ICC_PROFILES_H_
diff --git a/ui/gfx/mac/io_surface.cc b/ui/gfx/mac/io_surface.cc
new file mode 100644
index 0000000..7a199bc
--- /dev/null
+++ b/ui/gfx/mac/io_surface.cc
@@ -0,0 +1,347 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/mac/io_surface.h"
+
+#include <Availability.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/bits.h"
+#include "base/command_line.h"
+#include "base/cxx17_backports.h"
+#include "base/feature_list.h"
+#include "base/logging.h"
+#include "base/mac/mac_util.h"
+#include "base/mac/mach_logging.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/trace_event/trace_event.h"
+#include "ui/gfx/buffer_format_util.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/icc_profile.h"
+
+namespace gfx {
+
+namespace {
+
+const base::Feature kIOSurfaceUseNamedSRGBForREC709{
+    "IOSurfaceUseNamedSRGBForREC709", base::FEATURE_ENABLED_BY_DEFAULT};
+
+void AddIntegerValue(CFMutableDictionaryRef dictionary,
+                     const CFStringRef key,
+                     int32_t value) {
+  base::ScopedCFTypeRef<CFNumberRef> number(
+      CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
+  CFDictionaryAddValue(dictionary, key, number.get());
+}
+
+int32_t BytesPerElement(gfx::BufferFormat format, int plane) {
+  switch (format) {
+    case gfx::BufferFormat::R_8:
+      DCHECK_EQ(plane, 0);
+      return 1;
+    case gfx::BufferFormat::BGRA_8888:
+    case gfx::BufferFormat::BGRX_8888:
+    case gfx::BufferFormat::RGBA_8888:
+    case gfx::BufferFormat::BGRA_1010102:
+      DCHECK_EQ(plane, 0);
+      return 4;
+    case gfx::BufferFormat::RGBA_F16:
+      DCHECK_EQ(plane, 0);
+      return 8;
+    case gfx::BufferFormat::YUV_420_BIPLANAR: {
+      constexpr int32_t bytes_per_element[] = {1, 2};
+      DCHECK_LT(static_cast<size_t>(plane), base::size(bytes_per_element));
+      return bytes_per_element[plane];
+    }
+    case gfx::BufferFormat::P010: {
+      constexpr int32_t bytes_per_element[] = {2, 4};
+      DCHECK_LT(static_cast<size_t>(plane), base::size(bytes_per_element));
+      return bytes_per_element[plane];
+    }
+    case gfx::BufferFormat::R_16:
+    case gfx::BufferFormat::RG_88:
+    case gfx::BufferFormat::BGR_565:
+    case gfx::BufferFormat::RGBA_4444:
+    case gfx::BufferFormat::RGBX_8888:
+    case gfx::BufferFormat::RGBA_1010102:
+    case gfx::BufferFormat::YVU_420:
+      NOTREACHED();
+      return 0;
+  }
+
+  NOTREACHED();
+  return 0;
+}
+
+}  // namespace
+
+uint32_t BufferFormatToIOSurfacePixelFormat(gfx::BufferFormat format) {
+  switch (format) {
+    case gfx::BufferFormat::R_8:
+      return 'L008';
+    case gfx::BufferFormat::BGRA_1010102:
+      return 'l10r';  // little-endian ARGB2101010 full-range ARGB
+    case gfx::BufferFormat::BGRA_8888:
+    case gfx::BufferFormat::BGRX_8888:
+    case gfx::BufferFormat::RGBA_8888:
+      return 'BGRA';
+    case gfx::BufferFormat::RGBA_F16:
+      return 'RGhA';
+    case gfx::BufferFormat::YUV_420_BIPLANAR:
+      return '420v';
+    case gfx::BufferFormat::P010:
+      return 'x420';
+    case gfx::BufferFormat::R_16:
+    case gfx::BufferFormat::RG_88:
+    case gfx::BufferFormat::BGR_565:
+    case gfx::BufferFormat::RGBA_4444:
+    case gfx::BufferFormat::RGBX_8888:
+    case gfx::BufferFormat::RGBA_1010102:
+    // Technically RGBA_1010102 should be accepted as 'R10k', but then it won't
+    // be supported by CGLTexImageIOSurface2D(), so it's best to reject it here.
+    case gfx::BufferFormat::YVU_420:
+      return 0;
+  }
+
+  NOTREACHED();
+  return 0;
+}
+
+namespace internal {
+
+// static
+mach_port_t IOSurfaceMachPortTraits::Retain(mach_port_t port) {
+  kern_return_t kr =
+      mach_port_mod_refs(mach_task_self(), port, MACH_PORT_RIGHT_SEND, 1);
+  MACH_LOG_IF(ERROR, kr != KERN_SUCCESS, kr)
+      << "IOSurfaceMachPortTraits::Retain mach_port_mod_refs";
+  return port;
+}
+
+// static
+void IOSurfaceMachPortTraits::Release(mach_port_t port) {
+  kern_return_t kr =
+      mach_port_mod_refs(mach_task_self(), port, MACH_PORT_RIGHT_SEND, -1);
+  MACH_LOG_IF(ERROR, kr != KERN_SUCCESS, kr)
+      << "IOSurfaceMachPortTraits::Release mach_port_mod_refs";
+}
+
+// Common method used by IOSurfaceSetColorSpace and IOSurfaceCanSetColorSpace.
+bool IOSurfaceSetColorSpace(IOSurfaceRef io_surface,
+                            const ColorSpace& color_space) {
+  // Allow but ignore invalid color spaces.
+  if (!color_space.IsValid())
+    return true;
+
+  // Prefer using named spaces.
+  CFStringRef color_space_name = nullptr;
+  if (__builtin_available(macos 10.12, *)) {
+    if (color_space == ColorSpace::CreateSRGB() ||
+        (base::FeatureList::IsEnabled(kIOSurfaceUseNamedSRGBForREC709) &&
+         color_space == ColorSpace::CreateREC709())) {
+      color_space_name = kCGColorSpaceSRGB;
+    } else if (color_space == ColorSpace::CreateDisplayP3D65()) {
+      color_space_name = kCGColorSpaceDisplayP3;
+    } else if (color_space == ColorSpace::CreateExtendedSRGB()) {
+      color_space_name = kCGColorSpaceExtendedSRGB;
+    } else if (color_space == ColorSpace::CreateSCRGBLinear()) {
+      color_space_name = kCGColorSpaceExtendedLinearSRGB;
+    }
+  }
+  // The symbols kCGColorSpaceITUR_2020_PQ_EOTF and kCGColorSpaceITUR_2020_HLG
+  // have been deprecated. Claim that we were able to set the color space,
+  // because the path that will render these color spaces will use the
+  // HDRCopier, which will manually convert them to a non-deprecated format.
+  // https://crbug.com/1108627: Bug wherein these symbols are deprecated and
+  // also not available in some SDK versions.
+  // https://crbug.com/1101041: Introduces the HDR copier.
+  // https://crbug.com/1061723: Discussion of issues related to HLG.
+  if (__builtin_available(macos 10.15, *)) {
+    if (color_space == ColorSpace(ColorSpace::PrimaryID::BT2020,
+                                  ColorSpace::TransferID::SMPTEST2084,
+                                  ColorSpace::MatrixID::BT2020_NCL,
+                                  ColorSpace::RangeID::LIMITED)) {
+      if (__builtin_available(macos 11.0, *)) {
+        color_space_name = kCGColorSpaceITUR_2100_PQ;
+      } else {
+        return true;
+      }
+    } else if (color_space == ColorSpace(ColorSpace::PrimaryID::BT2020,
+                                         ColorSpace::TransferID::ARIB_STD_B67,
+                                         ColorSpace::MatrixID::BT2020_NCL,
+                                         ColorSpace::RangeID::LIMITED)) {
+      if (__builtin_available(macos 11.0, *)) {
+        color_space_name = kCGColorSpaceITUR_2100_HLG;
+      } else {
+        return true;
+      }
+    }
+  }
+  if (color_space_name) {
+    if (io_surface) {
+      IOSurfaceSetValue(io_surface, CFSTR("IOSurfaceColorSpace"),
+                        color_space_name);
+    }
+    return true;
+  }
+
+  gfx::ColorSpace as_rgb = color_space.GetAsRGB();
+  gfx::ColorSpace as_full_range_rgb = color_space.GetAsFullRangeRGB();
+
+  // IOSurfaces do not support full-range YUV video. Fortunately, the hardware
+  // decoders never produce full-range video.
+  // https://crbug.com/882627
+  if (color_space != as_rgb && as_rgb == as_full_range_rgb)
+    return false;
+
+  // Generate an ICCProfile from the parametric color space.
+  ICCProfile icc_profile = ICCProfile::FromColorSpace(as_full_range_rgb);
+  if (!icc_profile.IsValid())
+    return false;
+
+  // Package it as a CFDataRef and send it to the IOSurface.
+  std::vector<char> icc_profile_data = icc_profile.GetData();
+  base::ScopedCFTypeRef<CFDataRef> cf_data_icc_profile(CFDataCreate(
+      nullptr, reinterpret_cast<const UInt8*>(icc_profile_data.data()),
+      icc_profile_data.size()));
+
+  IOSurfaceSetValue(io_surface, CFSTR("IOSurfaceColorSpace"),
+                    cf_data_icc_profile);
+  return true;
+}
+
+}  // namespace internal
+
+IOSurfaceRef CreateIOSurface(const gfx::Size& size,
+                             gfx::BufferFormat format,
+                             bool should_clear) {
+  TRACE_EVENT0("ui", "CreateIOSurface");
+  base::TimeTicks start_time = base::TimeTicks::Now();
+
+  base::ScopedCFTypeRef<CFMutableDictionaryRef> properties(
+      CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                &kCFTypeDictionaryKeyCallBacks,
+                                &kCFTypeDictionaryValueCallBacks));
+  AddIntegerValue(properties, kIOSurfaceWidth, size.width());
+  AddIntegerValue(properties, kIOSurfaceHeight, size.height());
+  AddIntegerValue(properties, kIOSurfacePixelFormat,
+                  BufferFormatToIOSurfacePixelFormat(format));
+
+  // Don't specify plane information unless there are indeed multiple planes
+  // because DisplayLink drivers do not support this.
+  // http://crbug.com/527556
+  size_t num_planes = gfx::NumberOfPlanesForLinearBufferFormat(format);
+  if (num_planes > 1) {
+    base::ScopedCFTypeRef<CFMutableArrayRef> planes(CFArrayCreateMutable(
+        kCFAllocatorDefault, num_planes, &kCFTypeArrayCallBacks));
+    size_t total_bytes_alloc = 0;
+    for (size_t plane = 0; plane < num_planes; ++plane) {
+      const size_t factor =
+          gfx::SubsamplingFactorForBufferFormat(format, plane);
+      const size_t plane_width = (size.width() + factor - 1) / factor;
+      const size_t plane_height = (size.height() + factor - 1) / factor;
+      const size_t plane_bytes_per_element = BytesPerElement(format, plane);
+      const size_t plane_bytes_per_row = IOSurfaceAlignProperty(
+          kIOSurfacePlaneBytesPerRow,
+          base::bits::AlignUp(plane_width, 2) * plane_bytes_per_element);
+      const size_t plane_bytes_alloc = IOSurfaceAlignProperty(
+          kIOSurfacePlaneSize,
+          base::bits::AlignUp(plane_height, 2) * plane_bytes_per_row);
+      const size_t plane_offset =
+          IOSurfaceAlignProperty(kIOSurfacePlaneOffset, total_bytes_alloc);
+
+      base::ScopedCFTypeRef<CFMutableDictionaryRef> plane_info(
+          CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                    &kCFTypeDictionaryKeyCallBacks,
+                                    &kCFTypeDictionaryValueCallBacks));
+      AddIntegerValue(plane_info, kIOSurfacePlaneWidth, plane_width);
+      AddIntegerValue(plane_info, kIOSurfacePlaneHeight, plane_height);
+      AddIntegerValue(plane_info, kIOSurfacePlaneBytesPerElement,
+                      plane_bytes_per_element);
+      AddIntegerValue(plane_info, kIOSurfacePlaneBytesPerRow,
+                      plane_bytes_per_row);
+      AddIntegerValue(plane_info, kIOSurfacePlaneSize, plane_bytes_alloc);
+      AddIntegerValue(plane_info, kIOSurfacePlaneOffset, plane_offset);
+      CFArrayAppendValue(planes, plane_info);
+      total_bytes_alloc = plane_offset + plane_bytes_alloc;
+    }
+    CFDictionaryAddValue(properties, kIOSurfacePlaneInfo, planes);
+
+    total_bytes_alloc =
+        IOSurfaceAlignProperty(kIOSurfaceAllocSize, total_bytes_alloc);
+    AddIntegerValue(properties, kIOSurfaceAllocSize, total_bytes_alloc);
+  } else {
+    const size_t bytes_per_element = BytesPerElement(format, 0);
+    const size_t bytes_per_row = IOSurfaceAlignProperty(
+        kIOSurfaceBytesPerRow,
+        base::bits::AlignUp(size.width(), 2) * bytes_per_element);
+    const size_t bytes_alloc = IOSurfaceAlignProperty(
+        kIOSurfaceAllocSize,
+        base::bits::AlignUp(size.height(), 2) * bytes_per_row);
+    AddIntegerValue(properties, kIOSurfaceBytesPerElement, bytes_per_element);
+    AddIntegerValue(properties, kIOSurfaceBytesPerRow, bytes_per_row);
+    AddIntegerValue(properties, kIOSurfaceAllocSize, bytes_alloc);
+  }
+
+  IOSurfaceRef surface = IOSurfaceCreate(properties);
+  if (!surface) {
+    LOG(ERROR) << "Failed to allocate IOSurface of size " << size.ToString()
+               << ".";
+    return nullptr;
+  }
+
+  if (should_clear) {
+    // Zero-initialize the IOSurface. Calling IOSurfaceLock/IOSurfaceUnlock
+    // appears to be sufficient. https://crbug.com/584760#c17
+    IOReturn r = IOSurfaceLock(surface, 0, nullptr);
+    DCHECK_EQ(kIOReturnSuccess, r);
+    r = IOSurfaceUnlock(surface, 0, nullptr);
+    DCHECK_EQ(kIOReturnSuccess, r);
+  }
+
+  // Ensure that all IOSurfaces start as sRGB.
+  if (__builtin_available(macos 10.12, *)) {
+    IOSurfaceSetValue(surface, CFSTR("IOSurfaceColorSpace"), kCGColorSpaceSRGB);
+  } else {
+    CGColorSpaceRef color_space = base::mac::GetSRGBColorSpace();
+    base::ScopedCFTypeRef<CFDataRef> color_space_icc(
+        CGColorSpaceCopyICCProfile(color_space));
+    IOSurfaceSetValue(surface, CFSTR("IOSurfaceColorSpace"), color_space_icc);
+  }
+
+  UMA_HISTOGRAM_TIMES("GPU.IOSurface.CreateTime",
+                      base::TimeTicks::Now() - start_time);
+  return surface;
+}
+
+bool IOSurfaceCanSetColorSpace(const ColorSpace& color_space) {
+  return internal::IOSurfaceSetColorSpace(nullptr, color_space);
+}
+
+void IOSurfaceSetColorSpace(IOSurfaceRef io_surface,
+                            const ColorSpace& color_space) {
+  if (!internal::IOSurfaceSetColorSpace(io_surface, color_space)) {
+    DLOG(ERROR) << "Failed to set color space for IOSurface: "
+                << color_space.ToString();
+  }
+}
+
+GFX_EXPORT base::ScopedCFTypeRef<IOSurfaceRef> IOSurfaceMachPortToIOSurface(
+    ScopedRefCountedIOSurfaceMachPort io_surface_mach_port) {
+  base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
+  if (!io_surface_mach_port) {
+    DLOG(ERROR) << "Invalid mach port.";
+    return io_surface;
+  }
+  io_surface.reset(IOSurfaceLookupFromMachPort(io_surface_mach_port));
+  if (!io_surface) {
+    DLOG(ERROR) << "Unable to lookup IOSurface.";
+    return io_surface;
+  }
+  return io_surface;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/mac/io_surface.h b/ui/gfx/mac/io_surface.h
new file mode 100644
index 0000000..88c6a5d
--- /dev/null
+++ b/ui/gfx/mac/io_surface.h
@@ -0,0 +1,88 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MAC_IO_SURFACE_H_
+#define UI_GFX_MAC_IO_SURFACE_H_
+
+#include <IOSurface/IOSurface.h>
+#include <mach/mach.h>
+
+#include "base/mac/scoped_cftyperef.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/generic_shared_memory_id.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+namespace internal {
+
+struct IOSurfaceMachPortTraits {
+  GFX_EXPORT static mach_port_t InvalidValue() { return MACH_PORT_NULL; }
+  GFX_EXPORT static mach_port_t Retain(mach_port_t);
+  GFX_EXPORT static void Release(mach_port_t);
+};
+
+struct ScopedInUseIOSurfaceTraits {
+  static IOSurfaceRef InvalidValue() { return nullptr; }
+  static IOSurfaceRef Retain(IOSurfaceRef io_surface) {
+    CFRetain(io_surface);
+    IOSurfaceIncrementUseCount(io_surface);
+    return io_surface;
+  }
+  static void Release(IOSurfaceRef io_surface) {
+    IOSurfaceDecrementUseCount(io_surface);
+    CFRelease(io_surface);
+  }
+};
+
+}  // namespace internal
+
+using IOSurfaceId = GenericSharedMemoryId;
+
+// Helper function to create an IOSurface with a specified size and format.
+// The surface is zero-initialized if |should_clear| is true. This is not
+// necessary for anonymous surfaces that are not exported to renderers and used
+// as render targets only.
+GFX_EXPORT IOSurfaceRef CreateIOSurface(const Size& size,
+                                        BufferFormat format,
+                                        bool should_clear = true);
+
+// A scoper for handling Mach port names that are send rights for IOSurfaces.
+// This scoper is both copyable and assignable, which will increase the kernel
+// reference count of the right. On destruction, the reference count is
+// decremented.
+using ScopedRefCountedIOSurfaceMachPort =
+    base::ScopedTypeRef<mach_port_t, internal::IOSurfaceMachPortTraits>;
+
+// A scoper for holding a reference to an IOSurface and also incrementing its
+// in-use counter while the scoper exists.
+using ScopedInUseIOSurface =
+    base::ScopedTypeRef<IOSurfaceRef, internal::ScopedInUseIOSurfaceTraits>;
+
+// A scoper for holding a reference to an IOSurface.
+using ScopedIOSurface = base::ScopedCFTypeRef<IOSurfaceRef>;
+
+// Return true if there exists a value for IOSurfaceColorSpace or
+// IOSurfaceICCProfile that will make CoreAnimation render using |color_space|.
+GFX_EXPORT bool IOSurfaceCanSetColorSpace(const gfx::ColorSpace& color_space);
+
+// Set color space for given IOSurface. IOSurfaceCanSetColorSpace must return
+// true for |color_space| otherwise this does nothing.
+GFX_EXPORT void IOSurfaceSetColorSpace(IOSurfaceRef io_surface,
+                                       const gfx::ColorSpace& color_space);
+
+// Return the expected four character code pixel format for an IOSurface with
+// the specified gfx::BufferFormat.
+GFX_EXPORT uint32_t
+BufferFormatToIOSurfacePixelFormat(gfx::BufferFormat format);
+
+// Return an IOSurface consuming |io_surface_mach_port|.
+GFX_EXPORT base::ScopedCFTypeRef<IOSurfaceRef> IOSurfaceMachPortToIOSurface(
+    ScopedRefCountedIOSurfaceMachPort io_surface_mach_port);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_MAC_IO_SURFACE_H_
diff --git a/ui/gfx/mac/io_surface_hdr_metadata.cc b/ui/gfx/mac/io_surface_hdr_metadata.cc
new file mode 100644
index 0000000..f425024
--- /dev/null
+++ b/ui/gfx/mac/io_surface_hdr_metadata.cc
@@ -0,0 +1,42 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/mac/io_surface_hdr_metadata.h"
+
+#include "base/mac/foundation_util.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "ui/gfx/mojom/hdr_metadata.mojom.h"
+
+namespace gfx {
+
+namespace {
+
+// The key under which HDR metadata is attached to an IOSurface.
+const CFStringRef kCrIOSurfaceHDRMetadataKey =
+    CFSTR("CrIOSurfaceHDRMetadataKey");
+
+}  // namespace
+
+void IOSurfaceSetHDRMetadata(IOSurfaceRef io_surface,
+                             gfx::HDRMetadata hdr_metadata) {
+  std::vector<uint8_t> std_data =
+      gfx::mojom::HDRMetadata::Serialize(&hdr_metadata);
+  base::ScopedCFTypeRef<CFDataRef> cf_data(
+      CFDataCreate(nullptr, std_data.data(), std_data.size()));
+  IOSurfaceSetValue(io_surface, kCrIOSurfaceHDRMetadataKey, cf_data);
+}
+
+bool IOSurfaceGetHDRMetadata(IOSurfaceRef io_surface,
+                             gfx::HDRMetadata& hdr_metadata) {
+  base::ScopedCFTypeRef<CFTypeRef> cf_untyped(
+      IOSurfaceCopyValue(io_surface, kCrIOSurfaceHDRMetadataKey));
+  CFDataRef cf_data = base::mac::CFCast<CFDataRef>(cf_untyped);
+  if (!cf_data)
+    return false;
+  const UInt8* raw_data = CFDataGetBytePtr(cf_data);
+  std::vector<uint8_t> std_data(raw_data, raw_data + CFDataGetLength(cf_data));
+  return gfx::mojom::HDRMetadata::Deserialize(std_data, &hdr_metadata);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/mac/io_surface_hdr_metadata.h b/ui/gfx/mac/io_surface_hdr_metadata.h
new file mode 100644
index 0000000..1bee484
--- /dev/null
+++ b/ui/gfx/mac/io_surface_hdr_metadata.h
@@ -0,0 +1,31 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MAC_IO_SURFACE_HDR_METADATA_H_
+#define UI_GFX_MAC_IO_SURFACE_HDR_METADATA_H_
+
+#include <IOSurface/IOSurface.h>
+
+#include "base/component_export.h"
+
+namespace gfx {
+
+struct HDRMetadata;
+
+// Attach |hdr_metadata| to |io_surface|. After this is called, any other
+// process that has opened |io_surface| will be able to read |hdr_metadata|
+// using the function IOSurfaceGetHDRMetadata.
+void COMPONENT_EXPORT(GFX_IO_SURFACE_HDR_METADATA)
+    IOSurfaceSetHDRMetadata(IOSurfaceRef io_surface,
+                            gfx::HDRMetadata hdr_metadata);
+
+// Retrieve in |hdr_metadata| the value that was attached to |io_surface|. This
+// will return false on failure.
+bool COMPONENT_EXPORT(GFX_IO_SURFACE_HDR_METADATA)
+    IOSurfaceGetHDRMetadata(IOSurfaceRef io_surface,
+                            gfx::HDRMetadata& hdr_metadata);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_MAC_IO_SURFACE_HDR_METADATA_H_
diff --git a/ui/gfx/mac/io_surface_unittest.cc b/ui/gfx/mac/io_surface_unittest.cc
new file mode 100644
index 0000000..31eef23
--- /dev/null
+++ b/ui/gfx/mac/io_surface_unittest.cc
@@ -0,0 +1,48 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/mac/io_surface.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/hdr_metadata.h"
+#include "ui/gfx/mac/io_surface_hdr_metadata.h"
+
+namespace gfx {
+
+namespace {
+
+// Check that empty NSBezierPath is returned for empty SkPath.
+TEST(IOSurface, HDRMetadata) {
+  gfx::HDRMetadata in;
+  in.color_volume_metadata.primary_r = PointF(1.0, 2.0);
+  in.color_volume_metadata.primary_g = PointF(4.0, 5.0);
+  in.color_volume_metadata.primary_b = PointF(7.0, 8.0);
+  in.color_volume_metadata.white_point = PointF(10.0, 11.0);
+  in.color_volume_metadata.luminance_max = 13;
+  in.color_volume_metadata.luminance_min = 14;
+  in.max_content_light_level = 15;
+  in.max_frame_average_light_level = 16;
+
+  base::ScopedCFTypeRef<IOSurfaceRef> io_surface(
+      CreateIOSurface(gfx::Size(100, 100), gfx::BufferFormat::BGRA_8888));
+
+  gfx::HDRMetadata out;
+  EXPECT_FALSE(IOSurfaceGetHDRMetadata(io_surface, out));
+  IOSurfaceSetHDRMetadata(io_surface, in);
+  EXPECT_TRUE(IOSurfaceGetHDRMetadata(io_surface, out));
+  EXPECT_EQ(in, out);
+}
+
+TEST(IOSurface, OddSizeMultiPlanar) {
+  base::ScopedCFTypeRef<IOSurfaceRef> io_surface(
+      CreateIOSurface(gfx::Size(101, 99), gfx::BufferFormat::YUV_420_BIPLANAR));
+  DCHECK(io_surface);
+  // Plane sizes are rounded up.
+  // https://crbug.com/1226056
+  EXPECT_EQ(IOSurfaceGetWidthOfPlane(io_surface, 1), 51u);
+  EXPECT_EQ(IOSurfaceGetHeightOfPlane(io_surface, 1), 50u);
+}
+
+}  // namespace
+
+}  // namespace gfx
diff --git a/ui/gfx/mac/nswindow_frame_controls.h b/ui/gfx/mac/nswindow_frame_controls.h
new file mode 100644
index 0000000..d58eeca
--- /dev/null
+++ b/ui/gfx/mac/nswindow_frame_controls.h
@@ -0,0 +1,35 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MAC_NSWINDOW_FRAME_CONTROLS_H_
+#define UI_GFX_MAC_NSWINDOW_FRAME_CONTROLS_H_
+
+#include "ui/gfx/gfx_export.h"
+
+@class NSWindow;
+
+namespace gfx {
+
+class Size;
+
+// Set whether the window can be fullscreened.
+GFX_EXPORT void SetNSWindowCanFullscreen(NSWindow* window,
+                                         bool allow_fullscreen);
+
+// Sets whether the window appears on all workspaces.
+GFX_EXPORT void SetNSWindowVisibleOnAllWorkspaces(NSWindow* window,
+                                                  bool always_visible);
+
+// Sets the min/max size of the window as well as showing/hiding resize,
+// maximize, and fullscreen controls.
+// Sizes refer to the content size (inner bounds).
+GFX_EXPORT void ApplyNSWindowSizeConstraints(NSWindow* window,
+                                             const gfx::Size& min_size,
+                                             const gfx::Size& max_size,
+                                             bool can_resize,
+                                             bool can_fullscreen);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_MAC_NSWINDOW_FRAME_CONTROLS_H_
diff --git a/ui/gfx/mac/nswindow_frame_controls.mm b/ui/gfx/mac/nswindow_frame_controls.mm
new file mode 100644
index 0000000..3802078
--- /dev/null
+++ b/ui/gfx/mac/nswindow_frame_controls.mm
@@ -0,0 +1,71 @@
+// Copyright 2015 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.
+
+#import "ui/gfx/mac/nswindow_frame_controls.h"
+
+#import <AppKit/AppKit.h>
+
+#include "ui/gfx/geometry/size.h"
+
+namespace {
+
+// The value used to represent an unbounded width or height.
+const int kUnboundedSize = 0;
+
+void SetResizableStyleMask(NSWindow* window, bool resizable) {
+  NSUInteger style_mask = [window styleMask];
+  if (resizable)
+    style_mask |= NSResizableWindowMask;
+  else
+    style_mask &= ~NSResizableWindowMask;
+  [window setStyleMask:style_mask];
+}
+
+}  // namespace
+
+namespace gfx {
+
+void SetNSWindowCanFullscreen(NSWindow* window, bool allow_fullscreen) {
+  NSWindowCollectionBehavior behavior = [window collectionBehavior];
+  if (behavior & NSWindowCollectionBehaviorFullScreenAuxiliary)
+    return;
+  if (allow_fullscreen)
+    behavior |= NSWindowCollectionBehaviorFullScreenPrimary;
+  else
+    behavior &= ~NSWindowCollectionBehaviorFullScreenPrimary;
+  [window setCollectionBehavior:behavior];
+}
+
+void SetNSWindowVisibleOnAllWorkspaces(NSWindow* window, bool always_visible) {
+  NSWindowCollectionBehavior behavior = [window collectionBehavior];
+  if (always_visible)
+    behavior |= NSWindowCollectionBehaviorCanJoinAllSpaces;
+  else
+    behavior &= ~NSWindowCollectionBehaviorCanJoinAllSpaces;
+  [window setCollectionBehavior:behavior];
+}
+
+void ApplyNSWindowSizeConstraints(NSWindow* window,
+                                  const gfx::Size& min_size,
+                                  const gfx::Size& max_size,
+                                  bool can_resize,
+                                  bool can_fullscreen) {
+  [window setContentMinSize:NSMakeSize(min_size.width(), min_size.height())];
+
+  CGFloat max_width =
+      max_size.width() == kUnboundedSize ? CGFLOAT_MAX : max_size.width();
+  CGFloat max_height =
+      max_size.height() == kUnboundedSize ? CGFLOAT_MAX : max_size.height();
+  [window setContentMaxSize:NSMakeSize(max_width, max_height)];
+
+  SetResizableStyleMask(window, can_resize);
+  [window setShowsResizeIndicator:can_resize];
+
+  // Set the window to participate in Lion Fullscreen mode.
+  SetNSWindowCanFullscreen(window, can_fullscreen);
+
+  [[window standardWindowButton:NSWindowZoomButton] setEnabled:can_fullscreen];
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/mac/scoped_cocoa_disable_screen_updates.h b/ui/gfx/mac/scoped_cocoa_disable_screen_updates.h
new file mode 100644
index 0000000..1ab2e28
--- /dev/null
+++ b/ui/gfx/mac/scoped_cocoa_disable_screen_updates.h
@@ -0,0 +1,32 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MAC_SCOPED_COCOA_DISABLE_SCREEN_UPDATES_H_
+#define UI_GFX_MAC_SCOPED_COCOA_DISABLE_SCREEN_UPDATES_H_
+
+#include "base/macros.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// A stack-based class to disable Cocoa screen updates. When instantiated, it
+// disables screen updates and enables them when destroyed. Update disabling
+// can be nested, and there is a time-maximum (about 1 second) after which
+// Cocoa will automatically re-enable updating. This class doesn't attempt to
+// overrule that.
+class GFX_EXPORT ScopedCocoaDisableScreenUpdates {
+ public:
+  ScopedCocoaDisableScreenUpdates();
+
+  ScopedCocoaDisableScreenUpdates(const ScopedCocoaDisableScreenUpdates&) =
+      delete;
+  ScopedCocoaDisableScreenUpdates& operator=(
+      const ScopedCocoaDisableScreenUpdates&) = delete;
+
+  ~ScopedCocoaDisableScreenUpdates();
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_MAC_SCOPED_COCOA_DISABLE_SCREEN_UPDATES_H_
diff --git a/ui/gfx/mac/scoped_cocoa_disable_screen_updates.mm b/ui/gfx/mac/scoped_cocoa_disable_screen_updates.mm
new file mode 100644
index 0000000..b31792b
--- /dev/null
+++ b/ui/gfx/mac/scoped_cocoa_disable_screen_updates.mm
@@ -0,0 +1,19 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/mac/scoped_cocoa_disable_screen_updates.h"
+
+#import <Cocoa/Cocoa.h>
+
+namespace gfx {
+
+ScopedCocoaDisableScreenUpdates::ScopedCocoaDisableScreenUpdates() {
+  [NSAnimationContext beginGrouping];
+}
+
+ScopedCocoaDisableScreenUpdates::~ScopedCocoaDisableScreenUpdates() {
+  [NSAnimationContext endGrouping];
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/mojom/BUILD.gn b/ui/gfx/mojom/BUILD.gn
new file mode 100644
index 0000000..7c30bf8
--- /dev/null
+++ b/ui/gfx/mojom/BUILD.gn
@@ -0,0 +1,410 @@
+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/config/ozone.gni")
+import("//mojo/public/tools/bindings/mojom.gni")
+
+mojom("mojom") {
+  generate_java = true
+  sources = [
+    "accelerated_widget.mojom",
+    "buffer_types.mojom",
+    "ca_layer_params.mojom",
+    "color_space.mojom",
+    "delegated_ink_metadata.mojom",
+    "delegated_ink_point.mojom",
+    "delegated_ink_point_renderer.mojom",
+    "display_color_spaces.mojom",
+    "font_render_params.mojom",
+    "gpu_extra_info.mojom",
+    "gpu_fence_handle.mojom",
+    "hdr_metadata.mojom",
+    "hdr_static_metadata.mojom",
+    "mask_filter_info.mojom",
+    "overlay_priority_hint.mojom",
+    "overlay_transform.mojom",
+    "presentation_feedback.mojom",
+    "rrect_f.mojom",
+    "selection_bound.mojom",
+    "swap_result.mojom",
+    "swap_timings.mojom",
+    "transform.mojom",
+  ]
+
+  public_deps = [
+    ":native_handle_types",
+    "//mojo/public/mojom/base",
+    "//skia/public/mojom",
+    "//ui/gfx/geometry/mojom",
+  ]
+
+  enabled_features = []
+  if (use_x11 || ozone_platform_x11) {
+    enabled_features += [ "enable_x11_params" ]
+  }
+
+  shared_cpp_typemaps = [
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.BufferFormat"
+          cpp = "::gfx::BufferFormat"
+        },
+        {
+          mojom = "gfx.mojom.BufferUsage"
+          cpp = "::gfx::BufferUsage"
+        },
+        {
+          mojom = "gfx.mojom.BufferUsageAndFormat"
+          cpp = "::gfx::BufferUsageAndFormat"
+        },
+        {
+          mojom = "gfx.mojom.BufferPlane"
+          cpp = "::gfx::BufferPlane"
+        },
+        {
+          mojom = "gfx.mojom.GpuMemoryBufferHandle"
+          cpp = "::gfx::GpuMemoryBufferHandle"
+          move_only = true
+          nullable_is_same_type = true
+        },
+        {
+          mojom = "gfx.mojom.GpuMemoryBufferId"
+          cpp = "::gfx::GpuMemoryBufferId"
+          copyable_pass_by_value = true
+        },
+        {
+          mojom = "gfx.mojom.GpuMemoryBufferType"
+          cpp = "::gfx::GpuMemoryBufferType"
+        },
+      ]
+
+      traits_headers = [ "buffer_types_mojom_traits.h" ]
+      traits_public_deps = [ ":shared_mojom_traits" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.ColorSpace"
+          cpp = "::gfx::ColorSpace"
+        },
+      ]
+      traits_headers = [ "color_space_mojom_traits.h" ]
+      traits_public_deps = [ ":shared_mojom_traits" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.DisplayColorSpaces"
+          cpp = "::gfx::DisplayColorSpaces"
+        },
+      ]
+      traits_headers = [ "display_color_spaces_mojom_traits.h" ]
+      traits_public_deps = [ ":shared_mojom_traits" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.GpuExtraInfo"
+          cpp = "::gfx::GpuExtraInfo"
+        },
+        {
+          mojom = "gfx.mojom.ANGLEFeature"
+          cpp = "::gfx::ANGLEFeature"
+        },
+      ]
+      traits_headers = [ "gpu_extra_info_mojom_traits.h" ]
+      traits_public_deps = [ ":shared_mojom_traits" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.GpuFenceHandle"
+          cpp = "::gfx::GpuFenceHandle"
+          move_only = true
+          nullable_is_same_type = true
+        },
+      ]
+      traits_headers = [ "gpu_fence_handle_mojom_traits.h" ]
+      traits_public_deps = [ ":shared_mojom_traits" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.HDRStaticMetadata"
+          cpp = "::gfx::HDRStaticMetadata"
+        },
+      ]
+      traits_headers = [ "hdr_static_metadata_mojom_traits.h" ]
+      traits_public_deps = [ ":shared_mojom_traits" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.PresentationFeedback"
+          cpp = "::gfx::PresentationFeedback"
+        },
+      ]
+      traits_headers = [ "presentation_feedback_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.SelectionBound"
+          cpp = "::gfx::SelectionBound"
+        },
+      ]
+      traits_headers = [ "selection_bound_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx/geometry/mojom:mojom_traits" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.SwapTimings"
+          cpp = "::gfx::SwapTimings"
+        },
+      ]
+      traits_headers = [ "swap_timings_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.Transform"
+          cpp = "::gfx::Transform"
+        },
+      ]
+      traits_headers = [ "transform_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+  ]
+
+  cpp_typemaps = [
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.AcceleratedWidget"
+          cpp = "::gfx::AcceleratedWidget"
+          copyable_pass_by_value = true
+        },
+      ]
+      traits_headers = [ "accelerated_widget_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.CALayerParams"
+          cpp = "::gfx::CALayerParams"
+        },
+      ]
+      traits_sources = [ "ca_layer_params_mojom_traits.cc" ]
+      traits_headers = [ "ca_layer_params_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.DelegatedInkMetadata"
+          cpp = "::std::unique_ptr<::gfx::DelegatedInkMetadata>"
+          move_only = true
+          nullable_is_same_type = true
+        },
+      ]
+      traits_sources = [ "delegated_ink_metadata_mojom_traits.cc" ]
+      traits_headers = [ "delegated_ink_metadata_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.DelegatedInkPoint"
+          cpp = "::gfx::DelegatedInkPoint"
+        },
+      ]
+      traits_sources = [ "delegated_ink_point_mojom_traits.cc" ]
+      traits_headers = [ "delegated_ink_point_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.ColorVolumeMetadata"
+          cpp = "::gfx::ColorVolumeMetadata"
+        },
+        {
+          mojom = "gfx.mojom.HDRMetadata"
+          cpp = "::gfx::HDRMetadata"
+        },
+      ]
+      traits_headers = [ "hdr_metadata_mojom_traits.h" ]
+      traits_sources = [ "hdr_metadata_mojom_traits.cc" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.Hinting"
+          cpp = "::gfx::FontRenderParams::Hinting"
+        },
+        {
+          mojom = "gfx.mojom.SubpixelRendering"
+          cpp = "::gfx::FontRenderParams::SubpixelRendering"
+        },
+      ]
+      traits_headers = [ "font_render_params_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.OverlayTransform"
+          cpp = "::gfx::OverlayTransform"
+        },
+      ]
+      traits_headers = [ "overlay_transform_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.OverlayPriorityHint"
+          cpp = "::gfx::OverlayPriorityHint"
+        },
+      ]
+      traits_headers = [ "overlay_priority_hint_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.RRectF"
+          cpp = "::gfx::RRectF"
+        },
+      ]
+      traits_headers = [ "rrect_f_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx/geometry/mojom:mojom_traits" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.SwapResult"
+          cpp = "::gfx::SwapResult"
+        },
+      ]
+      traits_headers = [ "swap_result_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.MaskFilterInfo"
+          cpp = "::gfx::MaskFilterInfo"
+        },
+      ]
+      traits_sources = [ "mask_filter_info_mojom_traits.cc" ]
+      traits_headers = [ "mask_filter_info_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+  ]
+
+  cpp_typemaps += shared_cpp_typemaps
+  blink_cpp_typemaps = shared_cpp_typemaps
+  blink_cpp_typemaps += [
+    {
+      types = [
+        {
+          mojom = "gfx.mojom.DelegatedInkMetadata"
+          cpp = "::std::unique_ptr<::gfx::DelegatedInkMetadata>"
+          move_only = true
+          nullable_is_same_type = true
+        },
+      ]
+      traits_headers = [ "delegated_ink_metadata_mojom_traits.h" ]
+      traits_public_deps = [ "//ui/gfx" ]
+    },
+  ]
+}
+
+mojom("native_handle_types") {
+  sources = [ "native_handle_types.mojom" ]
+  if (is_linux || is_chromeos || use_ozone) {
+    enabled_features = [ "supports_native_pixmap" ]
+  }
+  public_deps = [ "//mojo/public/mojom/base" ]
+  generate_java = true
+
+  shared_cpp_typemap = {
+    types = [
+      {
+        mojom = "gfx.mojom.NativePixmapHandle"
+        cpp = "::gfx::NativePixmapHandle"
+        move_only = true
+      },
+      {
+        mojom = "gfx.mojom.NativePixmapPlane"
+        cpp = "::gfx::NativePixmapPlane"
+        move_only = true
+      },
+    ]
+    traits_headers = [ "native_handle_types_mojom_traits.h" ]
+    traits_public_deps = [ ":native_handle_types_mojom_traits" ]
+  }
+  cpp_typemaps = [ shared_cpp_typemap ]
+  blink_cpp_typemaps = [ shared_cpp_typemap ]
+}
+
+mojom("test_interfaces") {
+  sources = [ "traits_test_service.mojom" ]
+
+  public_deps = [ ":mojom" ]
+}
+
+component("native_handle_types_mojom_traits") {
+  output_name = "gfx_native_types_shared_mojom_traits"
+  defines = [ "IS_GFX_NATIVE_HANDLE_TYPES_SHARED_MOJOM_TRAITS_IMPL" ]
+  sources = [
+    "native_handle_types_mojom_traits.cc",
+    "native_handle_types_mojom_traits.h",
+  ]
+
+  public_deps = [
+    ":native_handle_types_shared",
+    "//base",
+    "//mojo/public/mojom/base",
+    "//ui/gfx",
+  ]
+}
+
+component("shared_mojom_traits") {
+  output_name = "gfx_shared_mojom_traits"
+  defines = [ "IS_GFX_SHARED_MOJOM_TRAITS_IMPL" ]
+  sources = [
+    "buffer_types_mojom_traits.cc",
+    "buffer_types_mojom_traits.h",
+    "color_space_mojom_traits.cc",
+    "color_space_mojom_traits.h",
+    "display_color_spaces_mojom_traits.cc",
+    "display_color_spaces_mojom_traits.h",
+    "gpu_extra_info_mojom_traits.cc",
+    "gpu_extra_info_mojom_traits.h",
+    "gpu_fence_handle_mojom_traits.cc",
+    "gpu_fence_handle_mojom_traits.h",
+    "hdr_static_metadata_mojom_traits.cc",
+    "hdr_static_metadata_mojom_traits.h",
+  ]
+  public_deps = [
+    ":mojom_shared",
+    ":native_handle_types",
+    "//ui/gfx",
+  ]
+  if (use_ozone) {
+    public_deps += [ "//ui/ozone:buildflags" ]
+  }
+  frameworks = [
+    "CoreFoundation.framework",
+    "IOSurface.framework",
+  ]
+}
diff --git a/ui/gfx/mojom/DEPS b/ui/gfx/mojom/DEPS
new file mode 100644
index 0000000..507f9cd
--- /dev/null
+++ b/ui/gfx/mojom/DEPS
@@ -0,0 +1,9 @@
+include_rules = [
+  "+mojo/public",
+]
+
+specific_include_rules = {
+  "delegated_ink_metadata_mojom_traits\.h" : [
+    "+skia/public/mojom/skcolor_mojom_traits.h",
+  ],
+}
\ No newline at end of file
diff --git a/ui/gfx/mojom/OWNERS b/ui/gfx/mojom/OWNERS
new file mode 100644
index 0000000..8c29d1b
--- /dev/null
+++ b/ui/gfx/mojom/OWNERS
@@ -0,0 +1,9 @@
+set noparent
+file://ipc/SECURITY_OWNERS
+
+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS
+per-file *_mojom_traits*.*=set noparent
+per-file *_mojom_traits*.*=file://ipc/SECURITY_OWNERS
+per-file *.typemap=set noparent
+per-file *.typemap=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/mojom/accelerated_widget.mojom b/ui/gfx/mojom/accelerated_widget.mojom
new file mode 100644
index 0000000..8647d67
--- /dev/null
+++ b/ui/gfx/mojom/accelerated_widget.mojom
@@ -0,0 +1,10 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+// See ui/gfx/native_widget_types.h.
+struct AcceleratedWidget {
+  uint64 widget;
+};
diff --git a/ui/gfx/mojom/accelerated_widget_mojom_traits.h b/ui/gfx/mojom/accelerated_widget_mojom_traits.h
new file mode 100644
index 0000000..6684590
--- /dev/null
+++ b/ui/gfx/mojom/accelerated_widget_mojom_traits.h
@@ -0,0 +1,45 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_ACCELERATED_WIDGET_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_ACCELERATED_WIDGET_MOJOM_TRAITS_H_
+
+#include "build/build_config.h"
+#include "ui/gfx/mojom/accelerated_widget.mojom.h"
+#include "ui/gfx/native_widget_types.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::AcceleratedWidgetDataView,
+                    gfx::AcceleratedWidget> {
+  static uint64_t widget(gfx::AcceleratedWidget widget) {
+#if defined(OS_WIN) || defined(OS_ANDROID) || defined(OS_IOS)
+    return reinterpret_cast<uint64_t>(widget);
+#elif defined(USE_OZONE) || defined(USE_X11) || defined(OS_MAC)
+    return static_cast<uint64_t>(widget);
+#else
+    NOTREACHED();
+    return 0;
+#endif
+  }
+
+  static bool Read(gfx::mojom::AcceleratedWidgetDataView data,
+                   gfx::AcceleratedWidget* out) {
+#if defined(OS_WIN) || defined(OS_ANDROID) || defined(OS_IOS)
+    *out = reinterpret_cast<gfx::AcceleratedWidget>(data.widget());
+    return true;
+#elif defined(USE_OZONE) || defined(USE_X11) || defined(OS_MAC)
+    *out = static_cast<gfx::AcceleratedWidget>(data.widget());
+    return true;
+#else
+    NOTREACHED();
+    return false;
+#endif
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_ACCELERATED_WIDGET_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/buffer_types.mojom b/ui/gfx/mojom/buffer_types.mojom
new file mode 100644
index 0000000..1072f73
--- /dev/null
+++ b/ui/gfx/mojom/buffer_types.mojom
@@ -0,0 +1,68 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+import "ui/gfx/mojom/native_handle_types.mojom";
+
+// gfx::BufferFormat
+enum BufferFormat {
+  R_8,
+  R_16,
+  RG_88,
+  BGR_565,
+  RGBA_4444,
+  RGBX_8888,
+  RGBA_8888,
+  BGRX_8888,
+  BGRA_1010102,
+  RGBA_1010102,
+  BGRA_8888,
+  RGBA_F16,
+  YVU_420,
+  YUV_420_BIPLANAR,
+  P010,
+};
+
+// gfx::BufferUsage
+enum BufferUsage {
+  GPU_READ,
+  SCANOUT,
+  SCANOUT_CAMERA_READ_WRITE,
+  CAMERA_AND_CPU_READ_WRITE,
+  SCANOUT_CPU_READ_WRITE,
+  SCANOUT_VDA_WRITE,
+  PROTECTED_SCANOUT_VDA_WRITE,
+  GPU_READ_CPU_READ_WRITE,
+  SCANOUT_VEA_CPU_READ,
+  VEA_READ_CAMERA_AND_CPU_READ_WRITE,
+  SCANOUT_FRONT_RENDERING,
+};
+
+struct BufferUsageAndFormat {
+  BufferUsage usage;
+  BufferFormat format;
+};
+
+enum BufferPlane {
+  DEFAULT,
+  Y,
+  UV,
+  U,
+  V,
+};
+
+// gfx::GpuMemoryBufferId
+[Stable]
+struct GpuMemoryBufferId {
+  int32 id;
+};
+
+// gfx::GpuMemoryBufferHandle
+struct GpuMemoryBufferHandle {
+  GpuMemoryBufferId id;
+  uint32 offset;
+  uint32 stride;
+  GpuMemoryBufferPlatformHandle? platform_handle;
+};
diff --git a/ui/gfx/mojom/buffer_types_mojom_traits.cc b/ui/gfx/mojom/buffer_types_mojom_traits.cc
new file mode 100644
index 0000000..9af3443
--- /dev/null
+++ b/ui/gfx/mojom/buffer_types_mojom_traits.cc
@@ -0,0 +1,169 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/mojom/buffer_types_mojom_traits.h"
+
+#include "build/build_config.h"
+
+#if defined(OS_ANDROID)
+#include "base/android/scoped_hardware_buffer_handle.h"
+#include "mojo/public/cpp/system/message_pipe.h"
+#include "mojo/public/cpp/system/scope_to_message_pipe.h"
+#endif
+
+namespace mojo {
+
+// static
+bool StructTraits<gfx::mojom::BufferUsageAndFormatDataView,
+                  gfx::BufferUsageAndFormat>::
+    Read(gfx::mojom::BufferUsageAndFormatDataView data,
+         gfx::BufferUsageAndFormat* out) {
+  return data.ReadUsage(&out->usage) && data.ReadFormat(&out->format);
+}
+
+gfx::mojom::GpuMemoryBufferPlatformHandlePtr StructTraits<
+    gfx::mojom::GpuMemoryBufferHandleDataView,
+    gfx::GpuMemoryBufferHandle>::platform_handle(gfx::GpuMemoryBufferHandle&
+                                                     handle) {
+  switch (handle.type) {
+    case gfx::EMPTY_BUFFER:
+      break;
+    case gfx::SHARED_MEMORY_BUFFER:
+      return gfx::mojom::GpuMemoryBufferPlatformHandle::NewSharedMemoryHandle(
+          std::move(handle.region));
+    case gfx::NATIVE_PIXMAP:
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
+      return gfx::mojom::GpuMemoryBufferPlatformHandle::NewNativePixmapHandle(
+          std::move(handle.native_pixmap_handle));
+#else
+      break;
+#endif
+    case gfx::IO_SURFACE_BUFFER: {
+#if defined(OS_MAC)
+      gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port(
+          IOSurfaceCreateMachPort(handle.io_surface.get()));
+      return gfx::mojom::GpuMemoryBufferPlatformHandle::NewMachPort(
+          mojo::PlatformHandle(
+              base::mac::RetainMachSendRight(io_surface_mach_port.get())));
+#else
+      break;
+#endif
+    }
+    case gfx::DXGI_SHARED_HANDLE:
+#if defined(OS_WIN)
+      DCHECK(handle.dxgi_handle.IsValid());
+      return gfx::mojom::GpuMemoryBufferPlatformHandle::NewDxgiHandle(
+          gfx::mojom::DxgiHandle::New(
+              mojo::PlatformHandle(std::move(handle.dxgi_handle)),
+              std::move(handle.region)));
+#else
+      break;
+#endif
+    case gfx::ANDROID_HARDWARE_BUFFER: {
+#if defined(OS_ANDROID)
+      // We must keep a ref to the AHardwareBuffer alive until the receiver has
+      // acquired its own reference. We do this by sending a message pipe handle
+      // along with the buffer. When the receiver deserializes (or even if they
+      // die without ever reading the message) their end of the pipe will be
+      // closed. We will eventually detect this and release the AHB reference.
+      mojo::MessagePipe tracking_pipe;
+      auto wrapped_handle = gfx::mojom::AHardwareBufferHandle::New(
+          mojo::PlatformHandle(
+              handle.android_hardware_buffer.SerializeAsFileDescriptor()),
+          std::move(tracking_pipe.handle0));
+
+      // Pass ownership of the input handle to our tracking pipe to keep the AHB
+      // alive until it's deserialized.
+      mojo::ScopeToMessagePipe(std::move(handle.android_hardware_buffer),
+                               std::move(tracking_pipe.handle1));
+      return gfx::mojom::GpuMemoryBufferPlatformHandle::
+          NewAndroidHardwareBufferHandle(std::move(wrapped_handle));
+#else
+      break;
+#endif
+    }
+  }
+
+  return nullptr;
+}
+
+bool StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
+                  gfx::GpuMemoryBufferHandle>::
+    Read(gfx::mojom::GpuMemoryBufferHandleDataView data,
+         gfx::GpuMemoryBufferHandle* out) {
+  if (!data.ReadId(&out->id))
+    return false;
+
+  out->offset = data.offset();
+  out->stride = data.stride();
+
+  gfx::mojom::GpuMemoryBufferPlatformHandlePtr platform_handle;
+  if (!data.ReadPlatformHandle(&platform_handle)) {
+    return false;
+  }
+
+  if (!platform_handle) {
+    out->type = gfx::EMPTY_BUFFER;
+    return true;
+  }
+
+  switch (platform_handle->which()) {
+    case gfx::mojom::GpuMemoryBufferPlatformHandleDataView::Tag::
+        SHARED_MEMORY_HANDLE:
+      out->type = gfx::SHARED_MEMORY_BUFFER;
+      out->region = std::move(platform_handle->get_shared_memory_handle());
+      return true;
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
+    case gfx::mojom::GpuMemoryBufferPlatformHandleDataView::Tag::
+        NATIVE_PIXMAP_HANDLE:
+      out->type = gfx::NATIVE_PIXMAP;
+      out->native_pixmap_handle =
+          std::move(platform_handle->get_native_pixmap_handle());
+      return true;
+#elif defined(OS_MAC)
+    case gfx::mojom::GpuMemoryBufferPlatformHandleDataView::Tag::MACH_PORT: {
+      out->type = gfx::IO_SURFACE_BUFFER;
+      if (!platform_handle->get_mach_port().is_mach_send())
+        return false;
+      gfx::ScopedRefCountedIOSurfaceMachPort io_surface_mach_port(
+          platform_handle->get_mach_port().ReleaseMachSendRight());
+      if (io_surface_mach_port) {
+        out->io_surface.reset(
+            IOSurfaceLookupFromMachPort(io_surface_mach_port.get()));
+      } else {
+        out->io_surface.reset();
+      }
+      return true;
+    }
+#elif defined(OS_WIN)
+    case gfx::mojom::GpuMemoryBufferPlatformHandleDataView::Tag::DXGI_HANDLE: {
+      out->type = gfx::DXGI_SHARED_HANDLE;
+      auto dxgi_handle = std::move(platform_handle->get_dxgi_handle());
+      out->dxgi_handle = dxgi_handle->buffer_handle.TakeHandle();
+      out->region = std::move(dxgi_handle->shared_memory_handle);
+      return true;
+    }
+#elif defined(OS_ANDROID)
+    case gfx::mojom::GpuMemoryBufferPlatformHandleDataView::Tag::
+        ANDROID_HARDWARE_BUFFER_HANDLE: {
+      out->type = gfx::ANDROID_HARDWARE_BUFFER;
+      gfx::mojom::AHardwareBufferHandlePtr buffer_handle =
+          std::move(platform_handle->get_android_hardware_buffer_handle());
+      if (!buffer_handle)
+        return false;
+
+      base::ScopedFD scoped_fd = buffer_handle->buffer_handle.TakeFD();
+      if (!scoped_fd.is_valid())
+        return false;
+      out->android_hardware_buffer = base::android::ScopedHardwareBufferHandle::
+          DeserializeFromFileDescriptor(std::move(scoped_fd));
+      return out->android_hardware_buffer.is_valid();
+    }
+#endif
+  }
+
+  return false;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/buffer_types_mojom_traits.h b/ui/gfx/mojom/buffer_types_mojom_traits.h
new file mode 100644
index 0000000..5ed27e0
--- /dev/null
+++ b/ui/gfx/mojom/buffer_types_mojom_traits.h
@@ -0,0 +1,282 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_BUFFER_TYPES_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_BUFFER_TYPES_MOJOM_TRAITS_H_
+
+
+#include "base/component_export.h"
+#include "build/build_config.h"
+#include "mojo/public/cpp/bindings/enum_traits.h"
+#include "mojo/public/cpp/bindings/struct_traits.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/gpu_memory_buffer.h"
+#include "ui/gfx/mojom/buffer_types.mojom-shared.h"
+#include "ui/gfx/mojom/native_handle_types.mojom.h"
+
+namespace mojo {
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    EnumTraits<gfx::mojom::BufferFormat, gfx::BufferFormat> {
+  static gfx::mojom::BufferFormat ToMojom(gfx::BufferFormat format) {
+    switch (format) {
+      case gfx::BufferFormat::R_8:
+        return gfx::mojom::BufferFormat::R_8;
+      case gfx::BufferFormat::R_16:
+        return gfx::mojom::BufferFormat::R_16;
+      case gfx::BufferFormat::RG_88:
+        return gfx::mojom::BufferFormat::RG_88;
+      case gfx::BufferFormat::BGR_565:
+        return gfx::mojom::BufferFormat::BGR_565;
+      case gfx::BufferFormat::RGBA_4444:
+        return gfx::mojom::BufferFormat::RGBA_4444;
+      case gfx::BufferFormat::RGBX_8888:
+        return gfx::mojom::BufferFormat::RGBX_8888;
+      case gfx::BufferFormat::RGBA_8888:
+        return gfx::mojom::BufferFormat::RGBA_8888;
+      case gfx::BufferFormat::BGRX_8888:
+        return gfx::mojom::BufferFormat::BGRX_8888;
+      case gfx::BufferFormat::BGRA_1010102:
+        return gfx::mojom::BufferFormat::BGRA_1010102;
+      case gfx::BufferFormat::RGBA_1010102:
+        return gfx::mojom::BufferFormat::RGBA_1010102;
+      case gfx::BufferFormat::BGRA_8888:
+        return gfx::mojom::BufferFormat::BGRA_8888;
+      case gfx::BufferFormat::RGBA_F16:
+        return gfx::mojom::BufferFormat::RGBA_F16;
+      case gfx::BufferFormat::YVU_420:
+        return gfx::mojom::BufferFormat::YVU_420;
+      case gfx::BufferFormat::YUV_420_BIPLANAR:
+        return gfx::mojom::BufferFormat::YUV_420_BIPLANAR;
+      case gfx::BufferFormat::P010:
+        return gfx::mojom::BufferFormat::P010;
+    }
+    NOTREACHED();
+    return gfx::mojom::BufferFormat::kMinValue;
+  }
+
+  static bool FromMojom(gfx::mojom::BufferFormat input,
+                        gfx::BufferFormat* out) {
+    switch (input) {
+      case gfx::mojom::BufferFormat::R_8:
+        *out = gfx::BufferFormat::R_8;
+        return true;
+      case gfx::mojom::BufferFormat::R_16:
+        *out = gfx::BufferFormat::R_16;
+        return true;
+      case gfx::mojom::BufferFormat::RG_88:
+        *out = gfx::BufferFormat::RG_88;
+        return true;
+      case gfx::mojom::BufferFormat::BGR_565:
+        *out = gfx::BufferFormat::BGR_565;
+        return true;
+      case gfx::mojom::BufferFormat::RGBA_4444:
+        *out = gfx::BufferFormat::RGBA_4444;
+        return true;
+      case gfx::mojom::BufferFormat::RGBX_8888:
+        *out = gfx::BufferFormat::RGBX_8888;
+        return true;
+      case gfx::mojom::BufferFormat::BGRA_1010102:
+        *out = gfx::BufferFormat::BGRA_1010102;
+        return true;
+      case gfx::mojom::BufferFormat::RGBA_1010102:
+        *out = gfx::BufferFormat::RGBA_1010102;
+        return true;
+      case gfx::mojom::BufferFormat::RGBA_8888:
+        *out = gfx::BufferFormat::RGBA_8888;
+        return true;
+      case gfx::mojom::BufferFormat::BGRX_8888:
+        *out = gfx::BufferFormat::BGRX_8888;
+        return true;
+      case gfx::mojom::BufferFormat::BGRA_8888:
+        *out = gfx::BufferFormat::BGRA_8888;
+        return true;
+      case gfx::mojom::BufferFormat::RGBA_F16:
+        *out = gfx::BufferFormat::RGBA_F16;
+        return true;
+      case gfx::mojom::BufferFormat::YVU_420:
+        *out = gfx::BufferFormat::YVU_420;
+        return true;
+      case gfx::mojom::BufferFormat::YUV_420_BIPLANAR:
+        *out = gfx::BufferFormat::YUV_420_BIPLANAR;
+        return true;
+      case gfx::mojom::BufferFormat::P010:
+        *out = gfx::BufferFormat::P010;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    EnumTraits<gfx::mojom::BufferUsage, gfx::BufferUsage> {
+  static gfx::mojom::BufferUsage ToMojom(gfx::BufferUsage usage) {
+    switch (usage) {
+      case gfx::BufferUsage::GPU_READ:
+        return gfx::mojom::BufferUsage::GPU_READ;
+      case gfx::BufferUsage::SCANOUT:
+        return gfx::mojom::BufferUsage::SCANOUT;
+      case gfx::BufferUsage::SCANOUT_CAMERA_READ_WRITE:
+        return gfx::mojom::BufferUsage::SCANOUT_CAMERA_READ_WRITE;
+      case gfx::BufferUsage::CAMERA_AND_CPU_READ_WRITE:
+        return gfx::mojom::BufferUsage::CAMERA_AND_CPU_READ_WRITE;
+      case gfx::BufferUsage::SCANOUT_CPU_READ_WRITE:
+        return gfx::mojom::BufferUsage::SCANOUT_CPU_READ_WRITE;
+      case gfx::BufferUsage::SCANOUT_VDA_WRITE:
+        return gfx::mojom::BufferUsage::SCANOUT_VDA_WRITE;
+      case gfx::BufferUsage::PROTECTED_SCANOUT_VDA_WRITE:
+        return gfx::mojom::BufferUsage::PROTECTED_SCANOUT_VDA_WRITE;
+      case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+        return gfx::mojom::BufferUsage::GPU_READ_CPU_READ_WRITE;
+      case gfx::BufferUsage::SCANOUT_VEA_CPU_READ:
+        return gfx::mojom::BufferUsage::SCANOUT_VEA_CPU_READ;
+      case gfx::BufferUsage::VEA_READ_CAMERA_AND_CPU_READ_WRITE:
+        return gfx::mojom::BufferUsage::VEA_READ_CAMERA_AND_CPU_READ_WRITE;
+      case gfx::BufferUsage::SCANOUT_FRONT_RENDERING:
+        return gfx::mojom::BufferUsage::SCANOUT_FRONT_RENDERING;
+    }
+    NOTREACHED();
+    return gfx::mojom::BufferUsage::kMinValue;
+  }
+
+  static bool FromMojom(gfx::mojom::BufferUsage input, gfx::BufferUsage* out) {
+    switch (input) {
+      case gfx::mojom::BufferUsage::GPU_READ:
+        *out = gfx::BufferUsage::GPU_READ;
+        return true;
+      case gfx::mojom::BufferUsage::SCANOUT:
+        *out = gfx::BufferUsage::SCANOUT;
+        return true;
+      case gfx::mojom::BufferUsage::SCANOUT_CAMERA_READ_WRITE:
+        *out = gfx::BufferUsage::SCANOUT_CAMERA_READ_WRITE;
+        return true;
+      case gfx::mojom::BufferUsage::CAMERA_AND_CPU_READ_WRITE:
+        *out = gfx::BufferUsage::CAMERA_AND_CPU_READ_WRITE;
+        return true;
+      case gfx::mojom::BufferUsage::SCANOUT_CPU_READ_WRITE:
+        *out = gfx::BufferUsage::SCANOUT_CPU_READ_WRITE;
+        return true;
+      case gfx::mojom::BufferUsage::SCANOUT_VDA_WRITE:
+        *out = gfx::BufferUsage::SCANOUT_VDA_WRITE;
+        return true;
+      case gfx::mojom::BufferUsage::PROTECTED_SCANOUT_VDA_WRITE:
+        *out = gfx::BufferUsage::PROTECTED_SCANOUT_VDA_WRITE;
+        return true;
+      case gfx::mojom::BufferUsage::GPU_READ_CPU_READ_WRITE:
+        *out = gfx::BufferUsage::GPU_READ_CPU_READ_WRITE;
+        return true;
+      case gfx::mojom::BufferUsage::SCANOUT_VEA_CPU_READ:
+        *out = gfx::BufferUsage::SCANOUT_VEA_CPU_READ;
+        return true;
+      case gfx::mojom::BufferUsage::VEA_READ_CAMERA_AND_CPU_READ_WRITE:
+        *out = gfx::BufferUsage::VEA_READ_CAMERA_AND_CPU_READ_WRITE;
+        return true;
+      case gfx::mojom::BufferUsage::SCANOUT_FRONT_RENDERING:
+        *out = gfx::BufferUsage::SCANOUT_FRONT_RENDERING;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::BufferUsageAndFormatDataView,
+                 gfx::BufferUsageAndFormat> {
+  static gfx::BufferUsage usage(const gfx::BufferUsageAndFormat& input) {
+    return input.usage;
+  }
+
+  static gfx::BufferFormat format(const gfx::BufferUsageAndFormat& input) {
+    return input.format;
+  }
+
+  static bool Read(gfx::mojom::BufferUsageAndFormatDataView data,
+                   gfx::BufferUsageAndFormat* out);
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::GpuMemoryBufferIdDataView,
+                 gfx::GpuMemoryBufferId> {
+  static int32_t id(const gfx::GpuMemoryBufferId& buffer_id) {
+    return buffer_id.id;
+  }
+  static bool Read(gfx::mojom::GpuMemoryBufferIdDataView data,
+                   gfx::GpuMemoryBufferId* out) {
+    out->id = data.id();
+    return true;
+  }
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
+                 gfx::GpuMemoryBufferHandle> {
+  static gfx::GpuMemoryBufferId id(const gfx::GpuMemoryBufferHandle& handle) {
+    return handle.id;
+  }
+  static uint32_t offset(const gfx::GpuMemoryBufferHandle& handle) {
+    return handle.offset;
+  }
+  static uint32_t stride(const gfx::GpuMemoryBufferHandle& handle) {
+    return handle.stride;
+  }
+  static mojo::StructPtr<gfx::mojom::GpuMemoryBufferPlatformHandle>
+  platform_handle(gfx::GpuMemoryBufferHandle& handle);
+
+  static bool Read(gfx::mojom::GpuMemoryBufferHandleDataView data,
+                   gfx::GpuMemoryBufferHandle* handle);
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    EnumTraits<gfx::mojom::BufferPlane, gfx::BufferPlane> {
+  static gfx::mojom::BufferPlane ToMojom(gfx::BufferPlane format) {
+    switch (format) {
+      case gfx::BufferPlane::DEFAULT:
+        return gfx::mojom::BufferPlane::DEFAULT;
+      case gfx::BufferPlane::Y:
+        return gfx::mojom::BufferPlane::Y;
+      case gfx::BufferPlane::UV:
+        return gfx::mojom::BufferPlane::UV;
+      case gfx::BufferPlane::U:
+        return gfx::mojom::BufferPlane::U;
+      case gfx::BufferPlane::V:
+        return gfx::mojom::BufferPlane::V;
+    }
+    NOTREACHED();
+    return gfx::mojom::BufferPlane::kMinValue;
+  }
+
+  static bool FromMojom(gfx::mojom::BufferPlane input, gfx::BufferPlane* out) {
+    switch (input) {
+      case gfx::mojom::BufferPlane::DEFAULT:
+        *out = gfx::BufferPlane::DEFAULT;
+        return true;
+      case gfx::mojom::BufferPlane::Y:
+        *out = gfx::BufferPlane::Y;
+        return true;
+      case gfx::mojom::BufferPlane::UV:
+        *out = gfx::BufferPlane::UV;
+        return true;
+      case gfx::mojom::BufferPlane::U:
+        *out = gfx::BufferPlane::U;
+        return true;
+      case gfx::mojom::BufferPlane::V:
+        *out = gfx::BufferPlane::V;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_BUFFER_TYPES_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/ca_layer_params.mojom b/ui/gfx/mojom/ca_layer_params.mojom
new file mode 100644
index 0000000..de00e76
--- /dev/null
+++ b/ui/gfx/mojom/ca_layer_params.mojom
@@ -0,0 +1,22 @@
+// Copyright 2017 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.
+
+module gfx.mojom;
+
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+union CALayerContent {
+  uint32 ca_context_id;
+  handle<platform> io_surface_mach_port;
+};
+
+// gfx::CALayerParams
+struct CALayerParams {
+  // TODO(676224): Use preprocessor to restrict platform-specific members to
+  // desired platform.
+  bool is_empty;
+  CALayerContent content;
+  gfx.mojom.Size pixel_size;
+  float scale_factor;
+};
diff --git a/ui/gfx/mojom/ca_layer_params_mojom_traits.cc b/ui/gfx/mojom/ca_layer_params_mojom_traits.cc
new file mode 100644
index 0000000..c1f21d7
--- /dev/null
+++ b/ui/gfx/mojom/ca_layer_params_mojom_traits.cc
@@ -0,0 +1,59 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/mojom/ca_layer_params_mojom_traits.h"
+
+#include "build/build_config.h"
+#include "mojo/public/cpp/system/platform_handle.h"
+#include "ui/gfx/geometry/mojom/geometry_mojom_traits.h"
+
+namespace mojo {
+
+gfx::mojom::CALayerContentPtr
+StructTraits<gfx::mojom::CALayerParamsDataView, gfx::CALayerParams>::content(
+    const gfx::CALayerParams& ca_layer_params) {
+#if defined(OS_MAC)
+  if (ca_layer_params.io_surface_mach_port) {
+    DCHECK(!ca_layer_params.ca_context_id);
+    return gfx::mojom::CALayerContent::NewIoSurfaceMachPort(
+        mojo::PlatformHandle(base::mac::RetainMachSendRight(
+            ca_layer_params.io_surface_mach_port.get())));
+  }
+#endif
+  return gfx::mojom::CALayerContent::NewCaContextId(
+      ca_layer_params.ca_context_id);
+}
+
+bool StructTraits<gfx::mojom::CALayerParamsDataView, gfx::CALayerParams>::Read(
+    gfx::mojom::CALayerParamsDataView data,
+    gfx::CALayerParams* out) {
+  out->is_empty = data.is_empty();
+
+  gfx::mojom::CALayerContentDataView content_data;
+  data.GetContentDataView(&content_data);
+  switch (content_data.tag()) {
+    case gfx::mojom::CALayerContentDataView::Tag::CA_CONTEXT_ID:
+      out->ca_context_id = content_data.ca_context_id();
+      break;
+    case gfx::mojom::CALayerContentDataView::Tag::IO_SURFACE_MACH_PORT:
+#if defined(OS_MAC)
+      mojo::PlatformHandle platform_handle =
+          content_data.TakeIoSurfaceMachPort();
+      if (!platform_handle.is_mach_send())
+        return false;
+      out->io_surface_mach_port.reset(platform_handle.ReleaseMachSendRight());
+      break;
+#else
+      return false;
+#endif
+  }
+
+  if (!data.ReadPixelSize(&out->pixel_size))
+    return false;
+
+  out->scale_factor = data.scale_factor();
+  return true;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/ca_layer_params_mojom_traits.h b/ui/gfx/mojom/ca_layer_params_mojom_traits.h
new file mode 100644
index 0000000..4cac766
--- /dev/null
+++ b/ui/gfx/mojom/ca_layer_params_mojom_traits.h
@@ -0,0 +1,36 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_CA_LAYER_PARAMS_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_CA_LAYER_PARAMS_MOJOM_TRAITS_H_
+
+#include "ui/gfx/ca_layer_params.h"
+#include "ui/gfx/mojom/ca_layer_params.mojom.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::CALayerParamsDataView, gfx::CALayerParams> {
+  static uint32_t is_empty(const gfx::CALayerParams& ca_layer_params) {
+    return ca_layer_params.is_empty;
+  }
+
+  static gfx::Size pixel_size(const gfx::CALayerParams& ca_layer_params) {
+    return ca_layer_params.pixel_size;
+  }
+
+  static float scale_factor(const gfx::CALayerParams& ca_layer_params) {
+    return ca_layer_params.scale_factor;
+  }
+
+  static gfx::mojom::CALayerContentPtr content(
+      const gfx::CALayerParams& ca_layer_params);
+
+  static bool Read(gfx::mojom::CALayerParamsDataView data,
+                   gfx::CALayerParams* out);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_CA_LAYER_PARAMS_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/color_space.mojom b/ui/gfx/mojom/color_space.mojom
new file mode 100644
index 0000000..1955dea
--- /dev/null
+++ b/ui/gfx/mojom/color_space.mojom
@@ -0,0 +1,86 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+// Mojo equivalent of ui::gfx::ColorSpace. See ui/gfx/color_space.h for
+// additional documentation.
+
+enum ColorSpacePrimaryID {
+  INVALID,
+  BT709,
+  BT470M,
+  BT470BG,
+  SMPTE170M,
+  SMPTE240M,
+  FILM,
+  BT2020,
+  SMPTEST428_1,
+  SMPTEST431_2,
+  SMPTEST432_1,
+  XYZ_D50,
+  ADOBE_RGB,
+  APPLE_GENERIC_RGB,
+  WIDE_GAMUT_COLOR_SPIN,
+  CUSTOM
+};
+
+enum ColorSpaceTransferID {
+  INVALID,
+  BT709,
+  BT709_APPLE,
+  GAMMA18,
+  GAMMA22,
+  GAMMA24,
+  GAMMA28,
+  SMPTE170M,
+  SMPTE240M,
+  LINEAR,
+  LOG,
+  LOG_SQRT,
+  IEC61966_2_4,
+  BT1361_ECG,
+  IEC61966_2_1,
+  BT2020_10,
+  BT2020_12,
+  SMPTEST2084,
+  SMPTEST428_1,
+  ARIB_STD_B67,
+  IEC61966_2_1_HDR,
+  LINEAR_HDR,
+  CUSTOM,
+  CUSTOM_HDR,
+  PIECEWISE_HDR
+};
+
+enum ColorSpaceMatrixID {
+  INVALID,
+  RGB,
+  BT709,
+  FCC,
+  BT470BG,
+  SMPTE170M,
+  SMPTE240M,
+  YCOCG,
+  BT2020_NCL,
+  BT2020_CL,
+  YDZDX,
+  GBR
+};
+
+enum ColorSpaceRangeID {
+  INVALID,
+  LIMITED,
+  FULL,
+  DERIVED
+};
+
+struct ColorSpace {
+  ColorSpacePrimaryID primaries;
+  ColorSpaceTransferID transfer;
+  ColorSpaceMatrixID matrix;
+  ColorSpaceRangeID range;
+  array<float, 9> custom_primary_matrix;
+  array<float, 7> transfer_params;
+};
diff --git a/ui/gfx/mojom/color_space_mojom_traits.cc b/ui/gfx/mojom/color_space_mojom_traits.cc
new file mode 100644
index 0000000..6aa83b1
--- /dev/null
+++ b/ui/gfx/mojom/color_space_mojom_traits.cc
@@ -0,0 +1,35 @@
+// Copyright 2018 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.
+
+#include "ui/gfx/mojom/color_space_mojom_traits.h"
+
+
+namespace mojo {
+
+// static
+bool StructTraits<gfx::mojom::ColorSpaceDataView, gfx::ColorSpace>::Read(
+    gfx::mojom::ColorSpaceDataView input,
+    gfx::ColorSpace* out) {
+  if (!input.ReadPrimaries(&out->primaries_))
+    return false;
+  if (!input.ReadTransfer(&out->transfer_))
+    return false;
+  if (!input.ReadMatrix(&out->matrix_))
+    return false;
+  if (!input.ReadRange(&out->range_))
+    return false;
+  {
+    base::span<float> matrix(out->custom_primary_matrix_);
+    if (!input.ReadCustomPrimaryMatrix(&matrix))
+      return false;
+  }
+  {
+    base::span<float> matrix(out->transfer_params_);
+    if (!input.ReadTransferParams(&matrix))
+      return false;
+  }
+  return true;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/color_space_mojom_traits.h b/ui/gfx/mojom/color_space_mojom_traits.h
new file mode 100644
index 0000000..28943a0
--- /dev/null
+++ b/ui/gfx/mojom/color_space_mojom_traits.h
@@ -0,0 +1,409 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_COLOR_SPACE_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_COLOR_SPACE_MOJOM_TRAITS_H_
+
+#include "base/component_export.h"
+#include "base/containers/span.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/mojom/color_space.mojom-shared.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<gfx::mojom::ColorSpacePrimaryID, gfx::ColorSpace::PrimaryID> {
+  static gfx::mojom::ColorSpacePrimaryID ToMojom(
+      gfx::ColorSpace::PrimaryID input) {
+    switch (input) {
+      case gfx::ColorSpace::PrimaryID::INVALID:
+        return gfx::mojom::ColorSpacePrimaryID::INVALID;
+      case gfx::ColorSpace::PrimaryID::BT709:
+        return gfx::mojom::ColorSpacePrimaryID::BT709;
+      case gfx::ColorSpace::PrimaryID::BT470M:
+        return gfx::mojom::ColorSpacePrimaryID::BT470M;
+      case gfx::ColorSpace::PrimaryID::BT470BG:
+        return gfx::mojom::ColorSpacePrimaryID::BT470BG;
+      case gfx::ColorSpace::PrimaryID::SMPTE170M:
+        return gfx::mojom::ColorSpacePrimaryID::SMPTE170M;
+      case gfx::ColorSpace::PrimaryID::SMPTE240M:
+        return gfx::mojom::ColorSpacePrimaryID::SMPTE240M;
+      case gfx::ColorSpace::PrimaryID::FILM:
+        return gfx::mojom::ColorSpacePrimaryID::FILM;
+      case gfx::ColorSpace::PrimaryID::BT2020:
+        return gfx::mojom::ColorSpacePrimaryID::BT2020;
+      case gfx::ColorSpace::PrimaryID::SMPTEST428_1:
+        return gfx::mojom::ColorSpacePrimaryID::SMPTEST428_1;
+      case gfx::ColorSpace::PrimaryID::SMPTEST431_2:
+        return gfx::mojom::ColorSpacePrimaryID::SMPTEST431_2;
+      case gfx::ColorSpace::PrimaryID::SMPTEST432_1:
+        return gfx::mojom::ColorSpacePrimaryID::SMPTEST432_1;
+      case gfx::ColorSpace::PrimaryID::XYZ_D50:
+        return gfx::mojom::ColorSpacePrimaryID::XYZ_D50;
+      case gfx::ColorSpace::PrimaryID::ADOBE_RGB:
+        return gfx::mojom::ColorSpacePrimaryID::ADOBE_RGB;
+      case gfx::ColorSpace::PrimaryID::APPLE_GENERIC_RGB:
+        return gfx::mojom::ColorSpacePrimaryID::APPLE_GENERIC_RGB;
+      case gfx::ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN:
+        return gfx::mojom::ColorSpacePrimaryID::WIDE_GAMUT_COLOR_SPIN;
+      case gfx::ColorSpace::PrimaryID::CUSTOM:
+        return gfx::mojom::ColorSpacePrimaryID::CUSTOM;
+    }
+    NOTREACHED();
+    return gfx::mojom::ColorSpacePrimaryID::INVALID;
+  }
+
+  static bool FromMojom(gfx::mojom::ColorSpacePrimaryID input,
+                        gfx::ColorSpace::PrimaryID* out) {
+    switch (input) {
+      case gfx::mojom::ColorSpacePrimaryID::INVALID:
+        *out = gfx::ColorSpace::PrimaryID::INVALID;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::BT709:
+        *out = gfx::ColorSpace::PrimaryID::BT709;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::BT470M:
+        *out = gfx::ColorSpace::PrimaryID::BT470M;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::BT470BG:
+        *out = gfx::ColorSpace::PrimaryID::BT470BG;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::SMPTE170M:
+        *out = gfx::ColorSpace::PrimaryID::SMPTE170M;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::SMPTE240M:
+        *out = gfx::ColorSpace::PrimaryID::SMPTE240M;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::FILM:
+        *out = gfx::ColorSpace::PrimaryID::FILM;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::BT2020:
+        *out = gfx::ColorSpace::PrimaryID::BT2020;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::SMPTEST428_1:
+        *out = gfx::ColorSpace::PrimaryID::SMPTEST428_1;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::SMPTEST431_2:
+        *out = gfx::ColorSpace::PrimaryID::SMPTEST431_2;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::SMPTEST432_1:
+        *out = gfx::ColorSpace::PrimaryID::SMPTEST432_1;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::XYZ_D50:
+        *out = gfx::ColorSpace::PrimaryID::XYZ_D50;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::ADOBE_RGB:
+        *out = gfx::ColorSpace::PrimaryID::ADOBE_RGB;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::APPLE_GENERIC_RGB:
+        *out = gfx::ColorSpace::PrimaryID::APPLE_GENERIC_RGB;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::WIDE_GAMUT_COLOR_SPIN:
+        *out = gfx::ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN;
+        return true;
+      case gfx::mojom::ColorSpacePrimaryID::CUSTOM:
+        *out = gfx::ColorSpace::PrimaryID::CUSTOM;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+template <>
+struct EnumTraits<gfx::mojom::ColorSpaceTransferID,
+                  gfx::ColorSpace::TransferID> {
+  static gfx::mojom::ColorSpaceTransferID ToMojom(
+      gfx::ColorSpace::TransferID input) {
+    switch (input) {
+      case gfx::ColorSpace::TransferID::INVALID:
+        return gfx::mojom::ColorSpaceTransferID::INVALID;
+      case gfx::ColorSpace::TransferID::BT709:
+        return gfx::mojom::ColorSpaceTransferID::BT709;
+      case gfx::ColorSpace::TransferID::BT709_APPLE:
+        return gfx::mojom::ColorSpaceTransferID::BT709_APPLE;
+      case gfx::ColorSpace::TransferID::GAMMA18:
+        return gfx::mojom::ColorSpaceTransferID::GAMMA18;
+      case gfx::ColorSpace::TransferID::GAMMA22:
+        return gfx::mojom::ColorSpaceTransferID::GAMMA22;
+      case gfx::ColorSpace::TransferID::GAMMA24:
+        return gfx::mojom::ColorSpaceTransferID::GAMMA24;
+      case gfx::ColorSpace::TransferID::GAMMA28:
+        return gfx::mojom::ColorSpaceTransferID::GAMMA28;
+      case gfx::ColorSpace::TransferID::SMPTE170M:
+        return gfx::mojom::ColorSpaceTransferID::SMPTE170M;
+      case gfx::ColorSpace::TransferID::SMPTE240M:
+        return gfx::mojom::ColorSpaceTransferID::SMPTE240M;
+      case gfx::ColorSpace::TransferID::LINEAR:
+        return gfx::mojom::ColorSpaceTransferID::LINEAR;
+      case gfx::ColorSpace::TransferID::LOG:
+        return gfx::mojom::ColorSpaceTransferID::LOG;
+      case gfx::ColorSpace::TransferID::LOG_SQRT:
+        return gfx::mojom::ColorSpaceTransferID::LOG_SQRT;
+      case gfx::ColorSpace::TransferID::IEC61966_2_4:
+        return gfx::mojom::ColorSpaceTransferID::IEC61966_2_4;
+      case gfx::ColorSpace::TransferID::BT1361_ECG:
+        return gfx::mojom::ColorSpaceTransferID::BT1361_ECG;
+      case gfx::ColorSpace::TransferID::IEC61966_2_1:
+        return gfx::mojom::ColorSpaceTransferID::IEC61966_2_1;
+      case gfx::ColorSpace::TransferID::BT2020_10:
+        return gfx::mojom::ColorSpaceTransferID::BT2020_10;
+      case gfx::ColorSpace::TransferID::BT2020_12:
+        return gfx::mojom::ColorSpaceTransferID::BT2020_12;
+      case gfx::ColorSpace::TransferID::SMPTEST2084:
+        return gfx::mojom::ColorSpaceTransferID::SMPTEST2084;
+      case gfx::ColorSpace::TransferID::SMPTEST428_1:
+        return gfx::mojom::ColorSpaceTransferID::SMPTEST428_1;
+      case gfx::ColorSpace::TransferID::ARIB_STD_B67:
+        return gfx::mojom::ColorSpaceTransferID::ARIB_STD_B67;
+      case gfx::ColorSpace::TransferID::IEC61966_2_1_HDR:
+        return gfx::mojom::ColorSpaceTransferID::IEC61966_2_1_HDR;
+      case gfx::ColorSpace::TransferID::LINEAR_HDR:
+        return gfx::mojom::ColorSpaceTransferID::LINEAR_HDR;
+      case gfx::ColorSpace::TransferID::CUSTOM:
+        return gfx::mojom::ColorSpaceTransferID::CUSTOM;
+      case gfx::ColorSpace::TransferID::CUSTOM_HDR:
+        return gfx::mojom::ColorSpaceTransferID::CUSTOM_HDR;
+      case gfx::ColorSpace::TransferID::PIECEWISE_HDR:
+        return gfx::mojom::ColorSpaceTransferID::PIECEWISE_HDR;
+    }
+    NOTREACHED();
+    return gfx::mojom::ColorSpaceTransferID::INVALID;
+  }
+
+  static bool FromMojom(gfx::mojom::ColorSpaceTransferID input,
+                        gfx::ColorSpace::TransferID* out) {
+    switch (input) {
+      case gfx::mojom::ColorSpaceTransferID::INVALID:
+        *out = gfx::ColorSpace::TransferID::INVALID;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::BT709:
+        *out = gfx::ColorSpace::TransferID::BT709;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::BT709_APPLE:
+        *out = gfx::ColorSpace::TransferID::BT709_APPLE;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::GAMMA18:
+        *out = gfx::ColorSpace::TransferID::GAMMA18;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::GAMMA22:
+        *out = gfx::ColorSpace::TransferID::GAMMA22;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::GAMMA24:
+        *out = gfx::ColorSpace::TransferID::GAMMA24;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::GAMMA28:
+        *out = gfx::ColorSpace::TransferID::GAMMA28;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::SMPTE170M:
+        *out = gfx::ColorSpace::TransferID::SMPTE170M;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::SMPTE240M:
+        *out = gfx::ColorSpace::TransferID::SMPTE240M;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::LINEAR:
+        *out = gfx::ColorSpace::TransferID::LINEAR;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::LOG:
+        *out = gfx::ColorSpace::TransferID::LOG;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::LOG_SQRT:
+        *out = gfx::ColorSpace::TransferID::LOG_SQRT;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::IEC61966_2_4:
+        *out = gfx::ColorSpace::TransferID::IEC61966_2_4;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::BT1361_ECG:
+        *out = gfx::ColorSpace::TransferID::BT1361_ECG;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::IEC61966_2_1:
+        *out = gfx::ColorSpace::TransferID::IEC61966_2_1;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::BT2020_10:
+        *out = gfx::ColorSpace::TransferID::BT2020_10;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::BT2020_12:
+        *out = gfx::ColorSpace::TransferID::BT2020_12;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::SMPTEST2084:
+        *out = gfx::ColorSpace::TransferID::SMPTEST2084;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::SMPTEST428_1:
+        *out = gfx::ColorSpace::TransferID::SMPTEST428_1;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::ARIB_STD_B67:
+        *out = gfx::ColorSpace::TransferID::ARIB_STD_B67;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::IEC61966_2_1_HDR:
+        *out = gfx::ColorSpace::TransferID::IEC61966_2_1_HDR;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::LINEAR_HDR:
+        *out = gfx::ColorSpace::TransferID::LINEAR_HDR;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::CUSTOM:
+        *out = gfx::ColorSpace::TransferID::CUSTOM;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::CUSTOM_HDR:
+        *out = gfx::ColorSpace::TransferID::CUSTOM_HDR;
+        return true;
+      case gfx::mojom::ColorSpaceTransferID::PIECEWISE_HDR:
+        *out = gfx::ColorSpace::TransferID::PIECEWISE_HDR;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+template <>
+struct EnumTraits<gfx::mojom::ColorSpaceMatrixID, gfx::ColorSpace::MatrixID> {
+  static gfx::mojom::ColorSpaceMatrixID ToMojom(
+      gfx::ColorSpace::MatrixID input) {
+    switch (input) {
+      case gfx::ColorSpace::MatrixID::INVALID:
+        return gfx::mojom::ColorSpaceMatrixID::INVALID;
+      case gfx::ColorSpace::MatrixID::RGB:
+        return gfx::mojom::ColorSpaceMatrixID::RGB;
+      case gfx::ColorSpace::MatrixID::BT709:
+        return gfx::mojom::ColorSpaceMatrixID::BT709;
+      case gfx::ColorSpace::MatrixID::FCC:
+        return gfx::mojom::ColorSpaceMatrixID::FCC;
+      case gfx::ColorSpace::MatrixID::BT470BG:
+        return gfx::mojom::ColorSpaceMatrixID::BT470BG;
+      case gfx::ColorSpace::MatrixID::SMPTE170M:
+        return gfx::mojom::ColorSpaceMatrixID::SMPTE170M;
+      case gfx::ColorSpace::MatrixID::SMPTE240M:
+        return gfx::mojom::ColorSpaceMatrixID::SMPTE240M;
+      case gfx::ColorSpace::MatrixID::YCOCG:
+        return gfx::mojom::ColorSpaceMatrixID::YCOCG;
+      case gfx::ColorSpace::MatrixID::BT2020_NCL:
+        return gfx::mojom::ColorSpaceMatrixID::BT2020_NCL;
+      case gfx::ColorSpace::MatrixID::BT2020_CL:
+        return gfx::mojom::ColorSpaceMatrixID::BT2020_CL;
+      case gfx::ColorSpace::MatrixID::YDZDX:
+        return gfx::mojom::ColorSpaceMatrixID::YDZDX;
+      case gfx::ColorSpace::MatrixID::GBR:
+        return gfx::mojom::ColorSpaceMatrixID::GBR;
+    }
+    NOTREACHED();
+    return gfx::mojom::ColorSpaceMatrixID::INVALID;
+  }
+
+  static bool FromMojom(gfx::mojom::ColorSpaceMatrixID input,
+                        gfx::ColorSpace::MatrixID* out) {
+    switch (input) {
+      case gfx::mojom::ColorSpaceMatrixID::INVALID:
+        *out = gfx::ColorSpace::MatrixID::INVALID;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::RGB:
+        *out = gfx::ColorSpace::MatrixID::RGB;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::BT709:
+        *out = gfx::ColorSpace::MatrixID::BT709;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::FCC:
+        *out = gfx::ColorSpace::MatrixID::FCC;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::BT470BG:
+        *out = gfx::ColorSpace::MatrixID::BT470BG;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::SMPTE170M:
+        *out = gfx::ColorSpace::MatrixID::SMPTE170M;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::SMPTE240M:
+        *out = gfx::ColorSpace::MatrixID::SMPTE240M;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::YCOCG:
+        *out = gfx::ColorSpace::MatrixID::YCOCG;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::BT2020_NCL:
+        *out = gfx::ColorSpace::MatrixID::BT2020_NCL;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::BT2020_CL:
+        *out = gfx::ColorSpace::MatrixID::BT2020_CL;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::YDZDX:
+        *out = gfx::ColorSpace::MatrixID::YDZDX;
+        return true;
+      case gfx::mojom::ColorSpaceMatrixID::GBR:
+        *out = gfx::ColorSpace::MatrixID::GBR;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+template <>
+struct EnumTraits<gfx::mojom::ColorSpaceRangeID, gfx::ColorSpace::RangeID> {
+  static gfx::mojom::ColorSpaceRangeID ToMojom(gfx::ColorSpace::RangeID input) {
+    switch (input) {
+      case gfx::ColorSpace::RangeID::INVALID:
+        return gfx::mojom::ColorSpaceRangeID::INVALID;
+      case gfx::ColorSpace::RangeID::LIMITED:
+        return gfx::mojom::ColorSpaceRangeID::LIMITED;
+      case gfx::ColorSpace::RangeID::FULL:
+        return gfx::mojom::ColorSpaceRangeID::FULL;
+      case gfx::ColorSpace::RangeID::DERIVED:
+        return gfx::mojom::ColorSpaceRangeID::DERIVED;
+    }
+    NOTREACHED();
+    return gfx::mojom::ColorSpaceRangeID::INVALID;
+  }
+
+  static bool FromMojom(gfx::mojom::ColorSpaceRangeID input,
+                        gfx::ColorSpace::RangeID* out) {
+    switch (input) {
+      case gfx::mojom::ColorSpaceRangeID::INVALID:
+        *out = gfx::ColorSpace::RangeID::INVALID;
+        return true;
+      case gfx::mojom::ColorSpaceRangeID::LIMITED:
+        *out = gfx::ColorSpace::RangeID::LIMITED;
+        return true;
+      case gfx::mojom::ColorSpaceRangeID::FULL:
+        *out = gfx::ColorSpace::RangeID::FULL;
+        return true;
+      case gfx::mojom::ColorSpaceRangeID::DERIVED:
+        *out = gfx::ColorSpace::RangeID::DERIVED;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::ColorSpaceDataView, gfx::ColorSpace> {
+  static gfx::ColorSpace::PrimaryID primaries(const gfx::ColorSpace& input) {
+    return input.primaries_;
+  }
+
+  static gfx::ColorSpace::TransferID transfer(const gfx::ColorSpace& input) {
+    return input.transfer_;
+  }
+
+  static gfx::ColorSpace::MatrixID matrix(const gfx::ColorSpace& input) {
+    return input.matrix_;
+  }
+
+  static gfx::ColorSpace::RangeID range(const gfx::ColorSpace& input) {
+    return input.range_;
+  }
+
+  static base::span<const float> custom_primary_matrix(
+      const gfx::ColorSpace& input) {
+    return input.custom_primary_matrix_;
+  }
+
+  static base::span<const float> transfer_params(const gfx::ColorSpace& input) {
+    return input.transfer_params_;
+  }
+
+  static bool Read(gfx::mojom::ColorSpaceDataView data, gfx::ColorSpace* out);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_COLOR_SPACE_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/delegated_ink_metadata.mojom b/ui/gfx/mojom/delegated_ink_metadata.mojom
new file mode 100644
index 0000000..c3b5438
--- /dev/null
+++ b/ui/gfx/mojom/delegated_ink_metadata.mojom
@@ -0,0 +1,20 @@
+// Copyright 2020 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.
+
+module gfx.mojom;
+
+import "mojo/public/mojom/base/time.mojom";
+import "skia/public/mojom/skcolor.mojom";
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+// See ui/gfx/delegated_ink_metadata.h.
+struct DelegatedInkMetadata {
+  PointF point;
+  double diameter;
+  skia.mojom.SkColor color;
+  mojo_base.mojom.TimeTicks timestamp;
+  RectF presentation_area;
+  mojo_base.mojom.TimeTicks frame_time;
+  bool is_hovering;
+};
diff --git a/ui/gfx/mojom/delegated_ink_metadata_mojom_traits.cc b/ui/gfx/mojom/delegated_ink_metadata_mojom_traits.cc
new file mode 100644
index 0000000..f3f10a8
--- /dev/null
+++ b/ui/gfx/mojom/delegated_ink_metadata_mojom_traits.cc
@@ -0,0 +1,35 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/mojom/delegated_ink_metadata_mojom_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<gfx::mojom::DelegatedInkMetadataDataView,
+                  std::unique_ptr<gfx::DelegatedInkMetadata>>::
+    Read(gfx::mojom::DelegatedInkMetadataDataView data,
+         std::unique_ptr<gfx::DelegatedInkMetadata>* out) {
+  // Diameter isn't expected to ever be below 0, so stop here if it is in order
+  // to avoid unexpected calculations in viz.
+  if (data.diameter() < 0)
+    return false;
+
+  gfx::PointF point;
+  base::TimeTicks timestamp;
+  gfx::RectF presentation_area;
+  SkColor color;
+  base::TimeTicks frame_time;
+  if (!data.ReadPoint(&point) || !data.ReadTimestamp(&timestamp) ||
+      !data.ReadPresentationArea(&presentation_area) ||
+      !data.ReadColor(&color) || !data.ReadFrameTime(&frame_time)) {
+    return false;
+  }
+  *out = std::make_unique<gfx::DelegatedInkMetadata>(
+      point, data.diameter(), color, timestamp, presentation_area, frame_time,
+      data.is_hovering());
+  return true;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/delegated_ink_metadata_mojom_traits.h b/ui/gfx/mojom/delegated_ink_metadata_mojom_traits.h
new file mode 100644
index 0000000..b9c875d
--- /dev/null
+++ b/ui/gfx/mojom/delegated_ink_metadata_mojom_traits.h
@@ -0,0 +1,70 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_DELEGATED_INK_METADATA_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_DELEGATED_INK_METADATA_MOJOM_TRAITS_H_
+
+#include <memory>
+
+#include "mojo/public/cpp/base/time_mojom_traits.h"
+#include "skia/public/mojom/skcolor_mojom_traits.h"
+#include "ui/gfx/delegated_ink_metadata.h"
+#include "ui/gfx/mojom/delegated_ink_metadata.mojom-shared.h"
+#include "ui/gfx/mojom/rrect_f_mojom_traits.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::DelegatedInkMetadataDataView,
+                    std::unique_ptr<gfx::DelegatedInkMetadata>> {
+  static bool IsNull(const std::unique_ptr<gfx::DelegatedInkMetadata>& input) {
+    return !input;
+  }
+
+  static void SetToNull(std::unique_ptr<gfx::DelegatedInkMetadata>* input) {
+    input->reset();
+  }
+
+  static const gfx::PointF& point(
+      const std::unique_ptr<gfx::DelegatedInkMetadata>& input) {
+    return input->point();
+  }
+
+  static double diameter(
+      const std::unique_ptr<gfx::DelegatedInkMetadata>& input) {
+    return input->diameter();
+  }
+
+  static SkColor color(
+      const std::unique_ptr<gfx::DelegatedInkMetadata>& input) {
+    return input->color();
+  }
+
+  static base::TimeTicks timestamp(
+      const std::unique_ptr<gfx::DelegatedInkMetadata>& input) {
+    return input->timestamp();
+  }
+
+  static const gfx::RectF& presentation_area(
+      const std::unique_ptr<gfx::DelegatedInkMetadata>& input) {
+    return input->presentation_area();
+  }
+
+  static base::TimeTicks frame_time(
+      const std::unique_ptr<gfx::DelegatedInkMetadata>& input) {
+    return input->frame_time();
+  }
+
+  static bool is_hovering(
+      const std::unique_ptr<gfx::DelegatedInkMetadata>& input) {
+    return input->is_hovering();
+  }
+
+  static bool Read(gfx::mojom::DelegatedInkMetadataDataView data,
+                   std::unique_ptr<gfx::DelegatedInkMetadata>* out);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_DELEGATED_INK_METADATA_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/delegated_ink_point.mojom b/ui/gfx/mojom/delegated_ink_point.mojom
new file mode 100644
index 0000000..8ed6561
--- /dev/null
+++ b/ui/gfx/mojom/delegated_ink_point.mojom
@@ -0,0 +1,15 @@
+// Copyright 2020 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.
+
+module gfx.mojom;
+
+import "mojo/public/mojom/base/time.mojom";
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+// See ui/gfx/delegated_ink_point.h.
+struct DelegatedInkPoint {
+  PointF point;
+  mojo_base.mojom.TimeTicks timestamp;
+  int32 pointer_id;
+};
diff --git a/ui/gfx/mojom/delegated_ink_point_mojom_traits.cc b/ui/gfx/mojom/delegated_ink_point_mojom_traits.cc
new file mode 100644
index 0000000..97fd785
--- /dev/null
+++ b/ui/gfx/mojom/delegated_ink_point_mojom_traits.cc
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/mojom/delegated_ink_point_mojom_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<
+    gfx::mojom::DelegatedInkPointDataView,
+    gfx::DelegatedInkPoint>::Read(gfx::mojom::DelegatedInkPointDataView data,
+                                  gfx::DelegatedInkPoint* out) {
+  out->pointer_id_ = data.pointer_id();
+  return data.ReadPoint(&out->point_) && data.ReadTimestamp(&out->timestamp_);
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/delegated_ink_point_mojom_traits.h b/ui/gfx/mojom/delegated_ink_point_mojom_traits.h
new file mode 100644
index 0000000..b188b30
--- /dev/null
+++ b/ui/gfx/mojom/delegated_ink_point_mojom_traits.h
@@ -0,0 +1,36 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_DELEGATED_INK_POINT_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_DELEGATED_INK_POINT_MOJOM_TRAITS_H_
+
+#include "mojo/public/cpp/base/time_mojom_traits.h"
+#include "ui/gfx/delegated_ink_point.h"
+#include "ui/gfx/geometry/mojom/geometry_mojom_traits.h"
+#include "ui/gfx/mojom/delegated_ink_point.mojom-shared.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::DelegatedInkPointDataView,
+                    gfx::DelegatedInkPoint> {
+  static const gfx::PointF& point(const gfx::DelegatedInkPoint& input) {
+    return input.point();
+  }
+
+  static base::TimeTicks timestamp(const gfx::DelegatedInkPoint& input) {
+    return input.timestamp();
+  }
+
+  static int32_t pointer_id(const gfx::DelegatedInkPoint& input) {
+    return input.pointer_id();
+  }
+
+  static bool Read(gfx::mojom::DelegatedInkPointDataView data,
+                   gfx::DelegatedInkPoint* out);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_DELEGATED_INK_POINT_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/delegated_ink_point_renderer.mojom b/ui/gfx/mojom/delegated_ink_point_renderer.mojom
new file mode 100644
index 0000000..223f343
--- /dev/null
+++ b/ui/gfx/mojom/delegated_ink_point_renderer.mojom
@@ -0,0 +1,25 @@
+// Copyright 2021 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.
+
+module gfx.mojom;
+
+import "ui/gfx/mojom/delegated_ink_point.mojom";
+
+// This interface is used to connect the browser process to viz to support
+// delegated ink trails. A delegated ink point will be produced in the
+// browser process and sent to viz to be held until DrawAndSwap occurs, at
+// which point any delegated ink points that arrived may be used to draw the
+// ink trail. When the browser detects the end of the trail, it will call
+// ResetPrediction() so that viz does not predict any points further than what
+// the user is expecting.
+interface DelegatedInkPointRenderer {
+  // Used to send the DelegatedInkPoint that was created in the browser process
+  // to viz in order to be drawn as part of the delegated ink trail.
+  StoreDelegatedInkPoint(DelegatedInkPoint point);
+
+  // Used to reset prediction and prediction metrics that have been generated
+  // by previously received points. Used by the browser process when a delegated
+  // ink trail should end.
+  ResetPrediction();
+};
\ No newline at end of file
diff --git a/ui/gfx/mojom/display_color_spaces.mojom b/ui/gfx/mojom/display_color_spaces.mojom
new file mode 100644
index 0000000..900e43e
--- /dev/null
+++ b/ui/gfx/mojom/display_color_spaces.mojom
@@ -0,0 +1,31 @@
+// Copyright 2020 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.
+
+module gfx.mojom;
+
+import "ui/gfx/mojom/buffer_types.mojom";
+import "ui/gfx/mojom/color_space.mojom";
+import "ui/gfx/mojom/hdr_static_metadata.mojom";
+
+// See the typemapped enum gfx::ContentColorUsage.
+enum ContentColorUsage {
+  kSRGB,
+  kWideColorGamut,
+  kHDR,
+};
+
+
+// See the typemapped class gfx::DisplayColorSpaces.
+struct DisplayColorSpaces {
+  // The arrays of length 6 correspond to the 6 configurations in the
+  // cross-product of (SRGB, WCG, HDR) x (opaque, transparent). The order
+  // corresponds to the order in gfx::DisplayColorSpaces.
+  array<ColorSpace, 6> color_spaces;
+  array<BufferFormat, 6> buffer_formats;
+
+  // The SDR white level is used to composite SDR and HDR content on Windows.
+  float sdr_white_level;
+
+  gfx.mojom.HDRStaticMetadata? hdr_static_metadata;
+};
diff --git a/ui/gfx/mojom/display_color_spaces_mojom_traits.cc b/ui/gfx/mojom/display_color_spaces_mojom_traits.cc
new file mode 100644
index 0000000..1077123
--- /dev/null
+++ b/ui/gfx/mojom/display_color_spaces_mojom_traits.cc
@@ -0,0 +1,81 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/mojom/display_color_spaces_mojom_traits.h"
+
+namespace mojo {
+
+// static
+gfx::mojom::ContentColorUsage
+EnumTraits<gfx::mojom::ContentColorUsage, gfx::ContentColorUsage>::ToMojom(
+    gfx::ContentColorUsage input) {
+  switch (input) {
+    case gfx::ContentColorUsage::kSRGB:
+      return gfx::mojom::ContentColorUsage::kSRGB;
+    case gfx::ContentColorUsage::kWideColorGamut:
+      return gfx::mojom::ContentColorUsage::kWideColorGamut;
+    case gfx::ContentColorUsage::kHDR:
+      return gfx::mojom::ContentColorUsage::kHDR;
+  }
+  NOTREACHED();
+  return gfx::mojom::ContentColorUsage::kSRGB;
+}
+
+// static
+bool EnumTraits<gfx::mojom::ContentColorUsage, gfx::ContentColorUsage>::
+    FromMojom(gfx::mojom::ContentColorUsage input,
+              gfx::ContentColorUsage* output) {
+  switch (input) {
+    case gfx::mojom::ContentColorUsage::kSRGB:
+      *output = gfx::ContentColorUsage::kSRGB;
+      return true;
+    case gfx::mojom::ContentColorUsage::kWideColorGamut:
+      *output = gfx::ContentColorUsage::kWideColorGamut;
+      return true;
+    case gfx::mojom::ContentColorUsage::kHDR:
+      *output = gfx::ContentColorUsage::kHDR;
+      return true;
+  }
+  NOTREACHED();
+  return false;
+}
+
+// static
+base::span<const gfx::ColorSpace>
+StructTraits<gfx::mojom::DisplayColorSpacesDataView, gfx::DisplayColorSpaces>::
+    color_spaces(const gfx::DisplayColorSpaces& input) {
+  return input.color_spaces_;
+}
+
+// static
+base::span<const gfx::BufferFormat>
+StructTraits<gfx::mojom::DisplayColorSpacesDataView, gfx::DisplayColorSpaces>::
+    buffer_formats(const gfx::DisplayColorSpaces& input) {
+  return input.buffer_formats_;
+}
+
+// static
+bool StructTraits<
+    gfx::mojom::DisplayColorSpacesDataView,
+    gfx::DisplayColorSpaces>::Read(gfx::mojom::DisplayColorSpacesDataView input,
+                                   gfx::DisplayColorSpaces* out) {
+  base::span<gfx::BufferFormat> buffer_formats(out->buffer_formats_);
+  if (!input.ReadBufferFormats(&buffer_formats))
+    return false;
+
+  base::span<gfx::ColorSpace> color_spaces(out->color_spaces_);
+  if (!input.ReadColorSpaces(&color_spaces))
+    return false;
+
+  out->SetSDRWhiteLevel(input.sdr_white_level());
+
+  absl::optional<gfx::HDRStaticMetadata> hdr_static_metadata(
+      out->hdr_static_metadata_);
+  if (!input.ReadHdrStaticMetadata(&hdr_static_metadata))
+    return false;
+
+  return true;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/display_color_spaces_mojom_traits.h b/ui/gfx/mojom/display_color_spaces_mojom_traits.h
new file mode 100644
index 0000000..8a69547
--- /dev/null
+++ b/ui/gfx/mojom/display_color_spaces_mojom_traits.h
@@ -0,0 +1,47 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_DISPLAY_COLOR_SPACES_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_DISPLAY_COLOR_SPACES_MOJOM_TRAITS_H_
+
+#include "base/containers/span.h"
+#include "ui/gfx/display_color_spaces.h"
+#include "ui/gfx/mojom/buffer_types_mojom_traits.h"
+#include "ui/gfx/mojom/color_space_mojom_traits.h"
+#include "ui/gfx/mojom/display_color_spaces.mojom-shared.h"
+#include "ui/gfx/mojom/hdr_static_metadata_mojom_traits.h"
+
+namespace mojo {
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    EnumTraits<gfx::mojom::ContentColorUsage, gfx::ContentColorUsage> {
+  static gfx::mojom::ContentColorUsage ToMojom(gfx::ContentColorUsage input);
+  static bool FromMojom(gfx::mojom::ContentColorUsage input,
+                        gfx::ContentColorUsage* output);
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::DisplayColorSpacesDataView,
+                 gfx::DisplayColorSpaces> {
+  static base::span<const gfx::ColorSpace> color_spaces(
+      const gfx::DisplayColorSpaces& input);
+  static base::span<const gfx::BufferFormat> buffer_formats(
+      const gfx::DisplayColorSpaces& input);
+  static float sdr_white_level(const gfx::DisplayColorSpaces& input) {
+    return input.GetSDRWhiteLevel();
+  }
+  static const absl::optional<gfx::HDRStaticMetadata>& hdr_static_metadata(
+      const gfx::DisplayColorSpaces& input) {
+    return input.hdr_static_metadata();
+  }
+
+  static bool Read(gfx::mojom::DisplayColorSpacesDataView data,
+                   gfx::DisplayColorSpaces* out);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_DISPLAY_COLOR_SPACES_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/font_render_params.mojom b/ui/gfx/mojom/font_render_params.mojom
new file mode 100644
index 0000000..ac75219
--- /dev/null
+++ b/ui/gfx/mojom/font_render_params.mojom
@@ -0,0 +1,22 @@
+// Copyright 2018 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.
+
+module gfx.mojom;
+
+// gfx::FontRenderParams::Hinting
+enum Hinting {
+  kNone,
+  kSlight,
+  kMedium,
+  kFull,
+};
+
+// gfx::FontRenderParams::SubpixelRendering
+enum SubpixelRendering {
+  kNone,
+  kRGB,
+  kBGR,
+  kVRGB,
+  kVBGR,
+};
diff --git a/ui/gfx/mojom/font_render_params_mojom_traits.h b/ui/gfx/mojom/font_render_params_mojom_traits.h
new file mode 100644
index 0000000..7f2c3a3
--- /dev/null
+++ b/ui/gfx/mojom/font_render_params_mojom_traits.h
@@ -0,0 +1,98 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_FONT_RENDER_PARAMS_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_FONT_RENDER_PARAMS_MOJOM_TRAITS_H_
+
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/mojom/font_render_params.mojom.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<gfx::mojom::SubpixelRendering,
+                  gfx::FontRenderParams::SubpixelRendering> {
+  static gfx::mojom::SubpixelRendering ToMojom(
+      gfx::FontRenderParams::SubpixelRendering input) {
+    switch (input) {
+      case gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE:
+        return gfx::mojom::SubpixelRendering::kNone;
+      case gfx::FontRenderParams::SUBPIXEL_RENDERING_RGB:
+        return gfx::mojom::SubpixelRendering::kRGB;
+      case gfx::FontRenderParams::SUBPIXEL_RENDERING_BGR:
+        return gfx::mojom::SubpixelRendering::kBGR;
+      case gfx::FontRenderParams::SUBPIXEL_RENDERING_VRGB:
+        return gfx::mojom::SubpixelRendering::kVRGB;
+      case gfx::FontRenderParams::SUBPIXEL_RENDERING_VBGR:
+        return gfx::mojom::SubpixelRendering::kVBGR;
+    }
+    NOTREACHED();
+    return gfx::mojom::SubpixelRendering::kNone;
+  }
+
+  static bool FromMojom(gfx::mojom::SubpixelRendering input,
+                        gfx::FontRenderParams::SubpixelRendering* out) {
+    switch (input) {
+      case gfx::mojom::SubpixelRendering::kNone:
+        *out = gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE;
+        return true;
+      case gfx::mojom::SubpixelRendering::kRGB:
+        *out = gfx::FontRenderParams::SUBPIXEL_RENDERING_RGB;
+        return true;
+      case gfx::mojom::SubpixelRendering::kBGR:
+        *out = gfx::FontRenderParams::SUBPIXEL_RENDERING_BGR;
+        return true;
+      case gfx::mojom::SubpixelRendering::kVRGB:
+        *out = gfx::FontRenderParams::SUBPIXEL_RENDERING_VRGB;
+        return true;
+      case gfx::mojom::SubpixelRendering::kVBGR:
+        *out = gfx::FontRenderParams::SUBPIXEL_RENDERING_VBGR;
+        return true;
+    }
+    *out = gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE;
+    return false;
+  }
+};
+
+template <>
+struct EnumTraits<gfx::mojom::Hinting, gfx::FontRenderParams::Hinting> {
+  static gfx::mojom::Hinting ToMojom(gfx::FontRenderParams::Hinting input) {
+    switch (input) {
+      case gfx::FontRenderParams::HINTING_NONE:
+        return gfx::mojom::Hinting::kNone;
+      case gfx::FontRenderParams::HINTING_SLIGHT:
+        return gfx::mojom::Hinting::kSlight;
+      case gfx::FontRenderParams::HINTING_MEDIUM:
+        return gfx::mojom::Hinting::kMedium;
+      case gfx::FontRenderParams::HINTING_FULL:
+        return gfx::mojom::Hinting::kFull;
+    }
+    NOTREACHED();
+    return gfx::mojom::Hinting::kNone;
+  }
+
+  static bool FromMojom(gfx::mojom::Hinting input,
+                        gfx::FontRenderParams::Hinting* out) {
+    switch (input) {
+      case gfx::mojom::Hinting::kNone:
+        *out = gfx::FontRenderParams::HINTING_NONE;
+        return true;
+      case gfx::mojom::Hinting::kSlight:
+        *out = gfx::FontRenderParams::HINTING_SLIGHT;
+        return true;
+      case gfx::mojom::Hinting::kMedium:
+        *out = gfx::FontRenderParams::HINTING_MEDIUM;
+        return true;
+      case gfx::mojom::Hinting::kFull:
+        *out = gfx::FontRenderParams::HINTING_FULL;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_FONT_RENDER_PARAMS_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/gpu_extra_info.mojom b/ui/gfx/mojom/gpu_extra_info.mojom
new file mode 100644
index 0000000..1b7b023
--- /dev/null
+++ b/ui/gfx/mojom/gpu_extra_info.mojom
@@ -0,0 +1,27 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// ui/gfx/gpu_extra_info.h
+module gfx.mojom;
+
+import "ui/gfx/mojom/buffer_types.mojom";
+
+// gfx::ANGLEFeature
+struct ANGLEFeature {
+  string name;
+  string category;
+  string description;
+  string bug;
+  string status;
+  string condition;
+};
+
+// gfx:GpuExtraInfo
+struct GpuExtraInfo {
+  // List of features queried from ANGLE
+  array<ANGLEFeature> angle_features;
+
+  [EnableIf=enable_x11_params]
+  array<gfx.mojom.BufferUsageAndFormat> gpu_memory_buffer_support_x11;
+};
diff --git a/ui/gfx/mojom/gpu_extra_info_mojom_traits.cc b/ui/gfx/mojom/gpu_extra_info_mojom_traits.cc
new file mode 100644
index 0000000..c40726b
--- /dev/null
+++ b/ui/gfx/mojom/gpu_extra_info_mojom_traits.cc
@@ -0,0 +1,34 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/mojom/gpu_extra_info_mojom_traits.h"
+
+#include "build/build_config.h"
+#include "ui/gfx/mojom/buffer_types_mojom_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<gfx::mojom::ANGLEFeatureDataView, gfx::ANGLEFeature>::Read(
+    gfx::mojom::ANGLEFeatureDataView data,
+    gfx::ANGLEFeature* out) {
+  return data.ReadName(&out->name) && data.ReadCategory(&out->category) &&
+         data.ReadDescription(&out->description) && data.ReadBug(&out->bug) &&
+         data.ReadStatus(&out->status) && data.ReadCondition(&out->condition);
+}
+
+// static
+bool StructTraits<gfx::mojom::GpuExtraInfoDataView, gfx::GpuExtraInfo>::Read(
+    gfx::mojom::GpuExtraInfoDataView data,
+    gfx::GpuExtraInfo* out) {
+  if (!data.ReadAngleFeatures(&out->angle_features))
+    return false;
+#if defined(USE_OZONE_PLATFORM_X11) || defined(USE_X11)
+  if (!data.ReadGpuMemoryBufferSupportX11(&out->gpu_memory_buffer_support_x11))
+    return false;
+#endif
+  return true;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/gpu_extra_info_mojom_traits.h b/ui/gfx/mojom/gpu_extra_info_mojom_traits.h
new file mode 100644
index 0000000..dd6b118
--- /dev/null
+++ b/ui/gfx/mojom/gpu_extra_info_mojom_traits.h
@@ -0,0 +1,74 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_GPU_EXTRA_INFO_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_GPU_EXTRA_INFO_MOJOM_TRAITS_H_
+
+#include "base/component_export.h"
+#include "ui/gfx/gpu_extra_info.h"
+#include "ui/gfx/mojom/buffer_types_mojom_traits.h"
+#include "ui/gfx/mojom/gpu_extra_info.mojom-shared.h"
+
+#if defined(USE_OZONE)
+#include "ui/ozone/buildflags.h"
+#if BUILDFLAG(OZONE_PLATFORM_X11)
+#define USE_OZONE_PLATFORM_X11
+#endif
+#endif
+
+namespace mojo {
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::ANGLEFeatureDataView, gfx::ANGLEFeature> {
+  static bool Read(gfx::mojom::ANGLEFeatureDataView data,
+                   gfx::ANGLEFeature* out);
+
+  static const std::string& name(const gfx::ANGLEFeature& input) {
+    return input.name;
+  }
+
+  static const std::string& category(const gfx::ANGLEFeature& input) {
+    return input.category;
+  }
+
+  static const std::string& description(const gfx::ANGLEFeature& input) {
+    return input.description;
+  }
+
+  static const std::string& bug(const gfx::ANGLEFeature& input) {
+    return input.bug;
+  }
+
+  static const std::string& status(const gfx::ANGLEFeature& input) {
+    return input.status;
+  }
+
+  static const std::string& condition(const gfx::ANGLEFeature& input) {
+    return input.condition;
+  }
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::GpuExtraInfoDataView, gfx::GpuExtraInfo> {
+  static bool Read(gfx::mojom::GpuExtraInfoDataView data,
+                   gfx::GpuExtraInfo* out);
+
+  static const std::vector<gfx::ANGLEFeature>& angle_features(
+      const gfx::GpuExtraInfo& input) {
+    return input.angle_features;
+  }
+
+#if defined(USE_OZONE_PLATFORM_X11) || defined(USE_X11)
+  static const std::vector<gfx::BufferUsageAndFormat>&
+  gpu_memory_buffer_support_x11(const gfx::GpuExtraInfo& input) {
+    return input.gpu_memory_buffer_support_x11;
+  }
+#endif
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_GPU_EXTRA_INFO_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/gpu_fence_handle.mojom b/ui/gfx/mojom/gpu_fence_handle.mojom
new file mode 100644
index 0000000..18c8814
--- /dev/null
+++ b/ui/gfx/mojom/gpu_fence_handle.mojom
@@ -0,0 +1,14 @@
+// Copyright 2017 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.
+
+module gfx.mojom;
+
+// See ui/gfx/ipc/gpu_fence_handle.h
+struct GpuFenceHandle {
+  [EnableIf=is_posix]
+  handle<platform> native_fd;
+
+  [EnableIf=is_win]
+  handle<platform> native_handle;
+};
diff --git a/ui/gfx/mojom/gpu_fence_handle_mojom_traits.cc b/ui/gfx/mojom/gpu_fence_handle_mojom_traits.cc
new file mode 100644
index 0000000..02289ca
--- /dev/null
+++ b/ui/gfx/mojom/gpu_fence_handle_mojom_traits.cc
@@ -0,0 +1,54 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/mojom/gpu_fence_handle_mojom_traits.h"
+
+#include "build/build_config.h"
+#include "mojo/public/cpp/system/platform_handle.h"
+
+namespace mojo {
+
+#if defined(OS_POSIX)
+mojo::PlatformHandle
+StructTraits<gfx::mojom::GpuFenceHandleDataView,
+             gfx::GpuFenceHandle>::native_fd(gfx::GpuFenceHandle& handle) {
+  return mojo::PlatformHandle(std::move(handle.owned_fd));
+}
+#elif defined(OS_WIN)
+mojo::PlatformHandle
+StructTraits<gfx::mojom::GpuFenceHandleDataView,
+             gfx::GpuFenceHandle>::native_handle(gfx::GpuFenceHandle& handle) {
+  return mojo::PlatformHandle(std::move(handle.owned_handle));
+}
+#endif
+
+bool StructTraits<gfx::mojom::GpuFenceHandleDataView, gfx::GpuFenceHandle>::
+    Read(gfx::mojom::GpuFenceHandleDataView data, gfx::GpuFenceHandle* out) {
+#if defined(OS_POSIX)
+  out->owned_fd = data.TakeNativeFd().TakeFD();
+  return true;
+#elif defined(OS_WIN)
+  out->owned_handle = data.TakeNativeHandle().TakeHandle();
+  return true;
+#else
+  return false;
+#endif
+}
+
+void StructTraits<gfx::mojom::GpuFenceHandleDataView,
+                  gfx::GpuFenceHandle>::SetToNull(gfx::GpuFenceHandle* handle) {
+#if defined(OS_POSIX)
+  handle->owned_fd.reset();
+#elif defined(OS_WIN)
+  handle->owned_handle.Close();
+#endif
+}
+
+bool StructTraits<gfx::mojom::GpuFenceHandleDataView,
+                  gfx::GpuFenceHandle>::IsNull(const gfx::GpuFenceHandle&
+                                                   handle) {
+  return handle.is_null();
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/gpu_fence_handle_mojom_traits.h b/ui/gfx/mojom/gpu_fence_handle_mojom_traits.h
new file mode 100644
index 0000000..74c04d4
--- /dev/null
+++ b/ui/gfx/mojom/gpu_fence_handle_mojom_traits.h
@@ -0,0 +1,31 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_GPU_FENCE_HANDLE_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_GPU_FENCE_HANDLE_MOJOM_TRAITS_H_
+
+#include "base/component_export.h"
+#include "build/build_config.h"
+#include "ui/gfx/gpu_fence_handle.h"
+#include "ui/gfx/mojom/gpu_fence_handle.mojom-shared.h"
+
+namespace mojo {
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::GpuFenceHandleDataView, gfx::GpuFenceHandle> {
+#if defined(OS_POSIX)
+  static mojo::PlatformHandle native_fd(gfx::GpuFenceHandle& handle);
+#elif defined(OS_WIN)
+  static mojo::PlatformHandle native_handle(gfx::GpuFenceHandle& handle);
+#endif
+  static bool Read(gfx::mojom::GpuFenceHandleDataView data,
+                   gfx::GpuFenceHandle* handle);
+  static void SetToNull(gfx::GpuFenceHandle* handle);
+  static bool IsNull(const gfx::GpuFenceHandle& handle);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_GPU_FENCE_HANDLE_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/hdr_metadata.mojom b/ui/gfx/mojom/hdr_metadata.mojom
new file mode 100644
index 0000000..e4c8f48
--- /dev/null
+++ b/ui/gfx/mojom/hdr_metadata.mojom
@@ -0,0 +1,24 @@
+// Copyright 2020 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.
+
+module gfx.mojom;
+
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+// This defines a mojo transport format for gfx::HDRMetadata.
+// See ui/gl/hdr_metadata.h for description.
+struct ColorVolumeMetadata {
+    gfx.mojom.PointF primary_r;
+    gfx.mojom.PointF primary_g;
+    gfx.mojom.PointF primary_b;
+    gfx.mojom.PointF white_point;
+    float luminance_max;
+    float luminance_min;
+  };
+
+struct HDRMetadata {
+    ColorVolumeMetadata color_volume_metadata;
+    uint32 max_content_light_level;
+    uint32 max_frame_average_light_level;
+  };
diff --git a/ui/gfx/mojom/hdr_metadata_mojom_traits.cc b/ui/gfx/mojom/hdr_metadata_mojom_traits.cc
new file mode 100644
index 0000000..4621230
--- /dev/null
+++ b/ui/gfx/mojom/hdr_metadata_mojom_traits.cc
@@ -0,0 +1,35 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/mojom/hdr_metadata_mojom_traits.h"
+
+namespace mojo {
+
+bool StructTraits<gfx::mojom::ColorVolumeMetadataDataView,
+                  gfx::ColorVolumeMetadata>::
+    Read(gfx::mojom::ColorVolumeMetadataDataView data,
+         gfx::ColorVolumeMetadata* output) {
+  output->luminance_max = data.luminance_max();
+  output->luminance_min = data.luminance_min();
+  if (!data.ReadPrimaryR(&output->primary_r))
+    return false;
+  if (!data.ReadPrimaryG(&output->primary_g))
+    return false;
+  if (!data.ReadPrimaryB(&output->primary_b))
+    return false;
+  if (!data.ReadWhitePoint(&output->white_point))
+    return false;
+  return true;
+}
+
+bool StructTraits<gfx::mojom::HDRMetadataDataView, gfx::HDRMetadata>::Read(
+    gfx::mojom::HDRMetadataDataView data,
+    gfx::HDRMetadata* output) {
+  output->max_content_light_level = data.max_content_light_level();
+  output->max_frame_average_light_level = data.max_frame_average_light_level();
+  if (!data.ReadColorVolumeMetadata(&output->color_volume_metadata))
+    return false;
+  return true;
+}
+}  // namespace mojo
diff --git a/ui/gfx/mojom/hdr_metadata_mojom_traits.h b/ui/gfx/mojom/hdr_metadata_mojom_traits.h
new file mode 100644
index 0000000..5c477db
--- /dev/null
+++ b/ui/gfx/mojom/hdr_metadata_mojom_traits.h
@@ -0,0 +1,58 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_HDR_METADATA_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_HDR_METADATA_MOJOM_TRAITS_H_
+
+#include "ui/gfx/hdr_metadata.h"
+#include "ui/gfx/mojom/hdr_metadata.mojom.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::ColorVolumeMetadataDataView,
+                    gfx::ColorVolumeMetadata> {
+  static const gfx::PointF& primary_r(const gfx::ColorVolumeMetadata& input) {
+    return input.primary_r;
+  }
+  static const gfx::PointF& primary_g(const gfx::ColorVolumeMetadata& input) {
+    return input.primary_g;
+  }
+  static const gfx::PointF& primary_b(const gfx::ColorVolumeMetadata& input) {
+    return input.primary_b;
+  }
+  static const gfx::PointF& white_point(const gfx::ColorVolumeMetadata& input) {
+    return input.white_point;
+  }
+  static float luminance_max(const gfx::ColorVolumeMetadata& input) {
+    return input.luminance_max;
+  }
+  static float luminance_min(const gfx::ColorVolumeMetadata& input) {
+    return input.luminance_min;
+  }
+
+  static bool Read(gfx::mojom::ColorVolumeMetadataDataView data,
+                   gfx::ColorVolumeMetadata* output);
+};
+
+template <>
+struct StructTraits<gfx::mojom::HDRMetadataDataView, gfx::HDRMetadata> {
+  static unsigned max_content_light_level(const gfx::HDRMetadata& input) {
+    return input.max_content_light_level;
+  }
+  static unsigned max_frame_average_light_level(const gfx::HDRMetadata& input) {
+    return input.max_frame_average_light_level;
+  }
+  static const gfx::ColorVolumeMetadata& color_volume_metadata(
+      const gfx::HDRMetadata& input) {
+    return input.color_volume_metadata;
+  }
+
+  static bool Read(gfx::mojom::HDRMetadataDataView data,
+                   gfx::HDRMetadata* output);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_HDR_METADATA_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/hdr_static_metadata.mojom b/ui/gfx/mojom/hdr_static_metadata.mojom
new file mode 100644
index 0000000..fc2aad0
--- /dev/null
+++ b/ui/gfx/mojom/hdr_static_metadata.mojom
@@ -0,0 +1,12 @@
+// Copyright 2021 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.
+
+module gfx.mojom;
+
+// This defines a mojo transport format for gfx::HDRStaticMetadata.
+struct HDRStaticMetadata {
+  float max;
+  float max_avg;
+  float min;
+};
diff --git a/ui/gfx/mojom/hdr_static_metadata_mojom_traits.cc b/ui/gfx/mojom/hdr_static_metadata_mojom_traits.cc
new file mode 100644
index 0000000..86707e4
--- /dev/null
+++ b/ui/gfx/mojom/hdr_static_metadata_mojom_traits.cc
@@ -0,0 +1,19 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/mojom/hdr_static_metadata_mojom_traits.h"
+
+namespace mojo {
+
+bool StructTraits<
+    gfx::mojom::HDRStaticMetadataDataView,
+    gfx::HDRStaticMetadata>::Read(gfx::mojom::HDRStaticMetadataDataView data,
+                                  gfx::HDRStaticMetadata* output) {
+  output->max = data.max();
+  output->max_avg = data.max_avg();
+  output->min = data.min();
+  return true;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/hdr_static_metadata_mojom_traits.h b/ui/gfx/mojom/hdr_static_metadata_mojom_traits.h
new file mode 100644
index 0000000..411fbbb
--- /dev/null
+++ b/ui/gfx/mojom/hdr_static_metadata_mojom_traits.h
@@ -0,0 +1,30 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_HDR_STATIC_METADATA_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_HDR_STATIC_METADATA_MOJOM_TRAITS_H_
+
+#include "base/component_export.h"
+#include "ui/gfx/hdr_static_metadata.h"
+#include "ui/gfx/mojom/hdr_static_metadata.mojom-shared.h"
+
+namespace mojo {
+
+template <>
+struct COMPONENT_EXPORT(GFX_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::HDRStaticMetadataDataView,
+                 gfx::HDRStaticMetadata> {
+  static float max(const gfx::HDRStaticMetadata& input) { return input.max; }
+  static float max_avg(const gfx::HDRStaticMetadata& input) {
+    return input.max_avg;
+  }
+  static float min(const gfx::HDRStaticMetadata& input) { return input.min; }
+
+  static bool Read(gfx::mojom::HDRStaticMetadataDataView data,
+                   gfx::HDRStaticMetadata* output);
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_HDR_STATIC_METADATA_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/mask_filter_info.mojom b/ui/gfx/mojom/mask_filter_info.mojom
new file mode 100644
index 0000000..7e3b9ea
--- /dev/null
+++ b/ui/gfx/mojom/mask_filter_info.mojom
@@ -0,0 +1,12 @@
+// Copyright 2020 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.
+
+module gfx.mojom;
+
+import "ui/gfx/mojom/rrect_f.mojom";
+
+// See ui/gfx/mask_filter_info.h.
+struct MaskFilterInfo {
+  gfx.mojom.RRectF rounded_corner_bounds;
+};
diff --git a/ui/gfx/mojom/mask_filter_info_mojom_traits.cc b/ui/gfx/mojom/mask_filter_info_mojom_traits.cc
new file mode 100644
index 0000000..683762a
--- /dev/null
+++ b/ui/gfx/mojom/mask_filter_info_mojom_traits.cc
@@ -0,0 +1,19 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/mojom/mask_filter_info_mojom_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<gfx::mojom::MaskFilterInfoDataView, gfx::MaskFilterInfo>::
+    Read(gfx::mojom::MaskFilterInfoDataView data, gfx::MaskFilterInfo* out) {
+  gfx::RRectF bounds;
+  if (!data.ReadRoundedCornerBounds(&bounds))
+    return false;
+  *out = gfx::MaskFilterInfo(bounds);
+  return true;
+}
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/mask_filter_info_mojom_traits.h b/ui/gfx/mojom/mask_filter_info_mojom_traits.h
new file mode 100644
index 0000000..849742a
--- /dev/null
+++ b/ui/gfx/mojom/mask_filter_info_mojom_traits.h
@@ -0,0 +1,25 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_MASK_FILTER_INFO_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_MASK_FILTER_INFO_MOJOM_TRAITS_H_
+
+#include "ui/gfx/geometry/mask_filter_info.h"
+#include "ui/gfx/mojom/mask_filter_info.mojom-shared.h"
+#include "ui/gfx/mojom/rrect_f_mojom_traits.h"
+
+namespace mojo {
+template <>
+struct StructTraits<gfx::mojom::MaskFilterInfoDataView, gfx::MaskFilterInfo> {
+  static const gfx::RRectF& rounded_corner_bounds(
+      const gfx::MaskFilterInfo& info) {
+    return info.rounded_corner_bounds();
+  }
+
+  static bool Read(gfx::mojom::MaskFilterInfoDataView data,
+                   gfx::MaskFilterInfo* out);
+};
+
+}  // namespace mojo
+#endif  // UI_GFX_MOJOM_MASK_FILTER_INFO_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/mojom_traits_unittest.cc b/ui/gfx/mojom/mojom_traits_unittest.cc
new file mode 100644
index 0000000..c7e36bf
--- /dev/null
+++ b/ui/gfx/mojom/mojom_traits_unittest.cc
@@ -0,0 +1,300 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <utility>
+
+#include "base/test/task_environment.h"
+#include "build/build_config.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "mojo/public/cpp/test_support/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rrect_f.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/mojom/accelerated_widget_mojom_traits.h"
+#include "ui/gfx/mojom/buffer_types_mojom_traits.h"
+#include "ui/gfx/mojom/presentation_feedback.mojom.h"
+#include "ui/gfx/mojom/presentation_feedback_mojom_traits.h"
+#include "ui/gfx/mojom/traits_test_service.mojom.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/gfx/selection_bound.h"
+
+namespace gfx {
+
+namespace {
+
+gfx::AcceleratedWidget CastToAcceleratedWidget(int i) {
+#if defined(USE_OZONE) || defined(USE_X11) || defined(OS_APPLE)
+  return static_cast<gfx::AcceleratedWidget>(i);
+#else
+  return reinterpret_cast<gfx::AcceleratedWidget>(i);
+#endif
+}
+
+class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
+ public:
+  StructTraitsTest() {}
+
+  StructTraitsTest(const StructTraitsTest&) = delete;
+  StructTraitsTest& operator=(const StructTraitsTest&) = delete;
+
+ protected:
+  mojo::Remote<mojom::TraitsTestService> GetTraitsTestRemote() {
+    mojo::Remote<mojom::TraitsTestService> remote;
+    traits_test_receivers_.Add(this, remote.BindNewPipeAndPassReceiver());
+    return remote;
+  }
+
+ private:
+  // TraitsTestService:
+  void EchoSelectionBound(const SelectionBound& s,
+                          EchoSelectionBoundCallback callback) override {
+    std::move(callback).Run(s);
+  }
+
+  void EchoTransform(const Transform& t,
+                     EchoTransformCallback callback) override {
+    std::move(callback).Run(t);
+  }
+
+  void EchoGpuMemoryBufferHandle(
+      GpuMemoryBufferHandle handle,
+      EchoGpuMemoryBufferHandleCallback callback) override {
+    std::move(callback).Run(std::move(handle));
+  }
+
+  void EchoRRectF(const RRectF& r, EchoRRectFCallback callback) override {
+    std::move(callback).Run(r);
+  }
+
+  base::test::TaskEnvironment task_environment_;
+  mojo::ReceiverSet<TraitsTestService> traits_test_receivers_;
+};
+
+}  // namespace
+
+TEST_F(StructTraitsTest, SelectionBound) {
+  const gfx::SelectionBound::Type type = gfx::SelectionBound::CENTER;
+  const gfx::PointF edge_start(1234.5f, 5678.6f);
+  const gfx::PointF edge_end(910112.5f, 13141516.6f);
+  const bool visible = true;
+  gfx::SelectionBound input;
+  input.set_type(type);
+  input.SetEdge(edge_start, edge_end);
+  input.set_visible(visible);
+  mojo::Remote<mojom::TraitsTestService> remote = GetTraitsTestRemote();
+  gfx::SelectionBound output;
+  remote->EchoSelectionBound(input, &output);
+  EXPECT_EQ(type, output.type());
+  EXPECT_EQ(edge_start, output.edge_start());
+  EXPECT_EQ(edge_end, output.edge_end());
+  EXPECT_EQ(input.edge_start_rounded(), output.edge_start_rounded());
+  EXPECT_EQ(input.edge_end_rounded(), output.edge_end_rounded());
+  EXPECT_EQ(visible, output.visible());
+}
+
+TEST_F(StructTraitsTest, Transform) {
+  const float col1row1 = 1.f;
+  const float col2row1 = 2.f;
+  const float col3row1 = 3.f;
+  const float col4row1 = 4.f;
+  const float col1row2 = 5.f;
+  const float col2row2 = 6.f;
+  const float col3row2 = 7.f;
+  const float col4row2 = 8.f;
+  const float col1row3 = 9.f;
+  const float col2row3 = 10.f;
+  const float col3row3 = 11.f;
+  const float col4row3 = 12.f;
+  const float col1row4 = 13.f;
+  const float col2row4 = 14.f;
+  const float col3row4 = 15.f;
+  const float col4row4 = 16.f;
+  gfx::Transform input(col1row1, col2row1, col3row1, col4row1, col1row2,
+                       col2row2, col3row2, col4row2, col1row3, col2row3,
+                       col3row3, col4row3, col1row4, col2row4, col3row4,
+                       col4row4);
+  mojo::Remote<mojom::TraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Transform output;
+  remote->EchoTransform(input, &output);
+  EXPECT_EQ(col1row1, output.matrix().get(0, 0));
+  EXPECT_EQ(col2row1, output.matrix().get(0, 1));
+  EXPECT_EQ(col3row1, output.matrix().get(0, 2));
+  EXPECT_EQ(col4row1, output.matrix().get(0, 3));
+  EXPECT_EQ(col1row2, output.matrix().get(1, 0));
+  EXPECT_EQ(col2row2, output.matrix().get(1, 1));
+  EXPECT_EQ(col3row2, output.matrix().get(1, 2));
+  EXPECT_EQ(col4row2, output.matrix().get(1, 3));
+  EXPECT_EQ(col1row3, output.matrix().get(2, 0));
+  EXPECT_EQ(col2row3, output.matrix().get(2, 1));
+  EXPECT_EQ(col3row3, output.matrix().get(2, 2));
+  EXPECT_EQ(col4row3, output.matrix().get(2, 3));
+  EXPECT_EQ(col1row4, output.matrix().get(3, 0));
+  EXPECT_EQ(col2row4, output.matrix().get(3, 1));
+  EXPECT_EQ(col3row4, output.matrix().get(3, 2));
+  EXPECT_EQ(col4row4, output.matrix().get(3, 3));
+}
+
+TEST_F(StructTraitsTest, AcceleratedWidget) {
+  gfx::AcceleratedWidget input(CastToAcceleratedWidget(1001));
+  gfx::AcceleratedWidget output;
+  mojo::test::SerializeAndDeserialize<gfx::mojom::AcceleratedWidget>(input,
+                                                                     output);
+  EXPECT_EQ(input, output);
+}
+
+TEST_F(StructTraitsTest, GpuMemoryBufferHandle) {
+  const gfx::GpuMemoryBufferId kId(99);
+  const uint32_t kOffset = 126;
+  const int32_t kStride = 256;
+  base::UnsafeSharedMemoryRegion shared_memory_region =
+      base::UnsafeSharedMemoryRegion::Create(1024);
+  ASSERT_TRUE(shared_memory_region.IsValid());
+  ASSERT_TRUE(shared_memory_region.Map().IsValid());
+
+  gfx::GpuMemoryBufferHandle handle;
+  handle.type = gfx::SHARED_MEMORY_BUFFER;
+  handle.id = kId;
+  handle.region = shared_memory_region.Duplicate();
+  handle.offset = kOffset;
+  handle.stride = kStride;
+
+  mojo::Remote<mojom::TraitsTestService> remote = GetTraitsTestRemote();
+  gfx::GpuMemoryBufferHandle output;
+  remote->EchoGpuMemoryBufferHandle(std::move(handle), &output);
+  EXPECT_EQ(gfx::SHARED_MEMORY_BUFFER, output.type);
+  EXPECT_EQ(kId, output.id);
+  EXPECT_EQ(kOffset, output.offset);
+  EXPECT_EQ(kStride, output.stride);
+
+  base::UnsafeSharedMemoryRegion output_memory = std::move(output.region);
+  EXPECT_TRUE(output_memory.Map().IsValid());
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
+  gfx::GpuMemoryBufferHandle handle2;
+  const uint64_t kSize = kOffset + kStride;
+  handle2.type = gfx::NATIVE_PIXMAP;
+  handle2.id = kId;
+  handle2.offset = kOffset;
+  handle2.stride = kStride;
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  const uint64_t kModifier = 2;
+  base::ScopedFD buffer_handle;
+  handle2.native_pixmap_handle.modifier = kModifier;
+#elif defined(OS_FUCHSIA)
+  zx::vmo buffer_handle;
+  handle2.native_pixmap_handle.buffer_collection_id =
+      gfx::SysmemBufferCollectionId::Create();
+  handle2.native_pixmap_handle.buffer_index = 4;
+  handle2.native_pixmap_handle.ram_coherency = true;
+#endif
+  handle2.native_pixmap_handle.planes.emplace_back(kOffset, kStride, kSize,
+                                                   std::move(buffer_handle));
+  remote->EchoGpuMemoryBufferHandle(std::move(handle2), &output);
+  EXPECT_EQ(gfx::NATIVE_PIXMAP, output.type);
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  EXPECT_EQ(kModifier, output.native_pixmap_handle.modifier);
+#elif defined(OS_FUCHSIA)
+  EXPECT_EQ(handle2.native_pixmap_handle.buffer_collection_id,
+            output.native_pixmap_handle.buffer_collection_id);
+  EXPECT_EQ(handle2.native_pixmap_handle.buffer_index,
+            output.native_pixmap_handle.buffer_index);
+  EXPECT_EQ(handle2.native_pixmap_handle.ram_coherency,
+            output.native_pixmap_handle.ram_coherency);
+#endif
+  ASSERT_EQ(1u, output.native_pixmap_handle.planes.size());
+  EXPECT_EQ(kSize, output.native_pixmap_handle.planes.back().size);
+#endif
+}
+
+TEST_F(StructTraitsTest, NullGpuMemoryBufferHandle) {
+  mojo::Remote<mojom::TraitsTestService> remote = GetTraitsTestRemote();
+  GpuMemoryBufferHandle output;
+  remote->EchoGpuMemoryBufferHandle(GpuMemoryBufferHandle(), &output);
+  EXPECT_TRUE(output.is_null());
+}
+
+TEST_F(StructTraitsTest, BufferFormat) {
+  using BufferFormatTraits =
+      mojo::EnumTraits<gfx::mojom::BufferFormat, gfx::BufferFormat>;
+  BufferFormat output;
+  mojo::Remote<mojom::TraitsTestService> remote = GetTraitsTestRemote();
+  for (int i = 0; i <= static_cast<int>(BufferFormat::LAST); ++i) {
+    BufferFormat input = static_cast<BufferFormat>(i);
+    BufferFormatTraits::FromMojom(BufferFormatTraits::ToMojom(input), &output);
+    EXPECT_EQ(output, input);
+  }
+}
+
+TEST_F(StructTraitsTest, BufferUsage) {
+  using BufferUsageTraits =
+      mojo::EnumTraits<gfx::mojom::BufferUsage, gfx::BufferUsage>;
+  BufferUsage output;
+  mojo::Remote<mojom::TraitsTestService> remote = GetTraitsTestRemote();
+  for (int i = 0; i <= static_cast<int>(BufferUsage::LAST); ++i) {
+    BufferUsage input = static_cast<BufferUsage>(i);
+    BufferUsageTraits::FromMojom(BufferUsageTraits::ToMojom(input), &output);
+    EXPECT_EQ(output, input);
+  }
+}
+
+TEST_F(StructTraitsTest, PresentationFeedback) {
+  base::TimeTicks timestamp = base::TimeTicks() + base::Seconds(12);
+  base::TimeDelta interval = base::Milliseconds(23);
+  uint32_t flags =
+      PresentationFeedback::kVSync | PresentationFeedback::kZeroCopy;
+  PresentationFeedback input{timestamp, interval, flags};
+  input.available_timestamp = base::TimeTicks() + base::Milliseconds(20);
+  input.ready_timestamp = base::TimeTicks() + base::Milliseconds(21);
+  input.latch_timestamp = base::TimeTicks() + base::Milliseconds(22);
+  PresentationFeedback output;
+  mojo::test::SerializeAndDeserialize<gfx::mojom::PresentationFeedback>(input,
+                                                                        output);
+  EXPECT_EQ(timestamp, output.timestamp);
+  EXPECT_EQ(interval, output.interval);
+  EXPECT_EQ(flags, output.flags);
+  EXPECT_EQ(input.available_timestamp, output.available_timestamp);
+  EXPECT_EQ(input.ready_timestamp, output.ready_timestamp);
+  EXPECT_EQ(input.latch_timestamp, output.latch_timestamp);
+}
+
+TEST_F(StructTraitsTest, RRectF) {
+  gfx::RRectF input(40, 50, 60, 70, 1, 2);
+  input.SetCornerRadii(RRectF::Corner::kUpperRight, 3, 4);
+  input.SetCornerRadii(RRectF::Corner::kLowerRight, 5, 6);
+  input.SetCornerRadii(RRectF::Corner::kLowerLeft, 7, 8);
+  EXPECT_EQ(input.GetType(), RRectF::Type::kComplex);
+  mojo::Remote<mojom::TraitsTestService> remote = GetTraitsTestRemote();
+  gfx::RRectF output;
+  remote->EchoRRectF(input, &output);
+  EXPECT_EQ(input, output);
+  input = gfx::RRectF(40, 50, 0, 70, 0);
+  EXPECT_EQ(input.GetType(), RRectF::Type::kEmpty);
+  remote->EchoRRectF(input, &output);
+  EXPECT_EQ(input, output);
+  input = RRectF(40, 50, 60, 70, 0);
+  EXPECT_EQ(input.GetType(), RRectF::Type::kRect);
+  remote->EchoRRectF(input, &output);
+  EXPECT_EQ(input, output);
+  input = RRectF(40, 50, 60, 70, 5);
+  EXPECT_EQ(input.GetType(), RRectF::Type::kSingle);
+  remote->EchoRRectF(input, &output);
+  EXPECT_EQ(input, output);
+  input = RRectF(40, 50, 60, 70, 6, 3);
+  EXPECT_EQ(input.GetType(), RRectF::Type::kSimple);
+  remote->EchoRRectF(input, &output);
+  EXPECT_EQ(input, output);
+  input = RRectF(40, 50, 60, 70, 30, 35);
+  EXPECT_EQ(input.GetType(), RRectF::Type::kOval);
+  remote->EchoRRectF(input, &output);
+  EXPECT_EQ(input, output);
+  input.SetCornerRadii(RRectF::Corner::kUpperLeft, 50, 50);
+  input.SetCornerRadii(RRectF::Corner::kUpperRight, 20, 20);
+  input.SetCornerRadii(RRectF::Corner::kLowerRight, 0, 0);
+  input.SetCornerRadii(RRectF::Corner::kLowerLeft, 0, 0);
+  remote->EchoRRectF(input, &output);
+  EXPECT_EQ(input, output);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/mojom/native_handle_types.mojom b/ui/gfx/mojom/native_handle_types.mojom
new file mode 100644
index 0000000..e81dd83
--- /dev/null
+++ b/ui/gfx/mojom/native_handle_types.mojom
@@ -0,0 +1,79 @@
+// Copyright 2020 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.
+
+module gfx.mojom;
+
+import "mojo/public/mojom/base/shared_memory.mojom";
+import "mojo/public/mojom/base/unguessable_token.mojom";
+
+// gfx::NativePixmapPlane
+[EnableIf=supports_native_pixmap, Stable]
+struct NativePixmapPlane {
+  uint32 stride;
+  uint64 offset;
+  uint64 size;
+
+  // A platform-specific handle the underlying memory object.
+  handle<platform> buffer_handle;
+};
+
+// gfx::NativePixmapHandle
+[EnableIf=supports_native_pixmap]
+struct NativePixmapHandle {
+  array<NativePixmapPlane> planes;
+
+  [EnableIf=is_linux]
+  uint64 modifier;
+  [EnableIf=is_chromeos_ash]
+  uint64 modifier;
+
+  [EnableIf=is_fuchsia]
+  mojo_base.mojom.UnguessableToken? buffer_collection_id;
+  [EnableIf=is_fuchsia]
+  uint32 buffer_index;
+  [EnableIf=is_fuchsia]
+  bool ram_coherency;
+};
+
+[EnableIf=is_android]
+struct AHardwareBufferHandle {
+  // The actual file descriptor used to wrap the AHardwareBuffer object for
+  // serialization.
+  handle<platform> buffer_handle;
+
+  // A message pipe handle which tracks the lifetime of this
+  // AHardwareBufferHandle. The sender may use this to observe the lifetime
+  // remotely by watching the other end of this pipe. Useful for retaining a
+  // sender-side AHB ref until the receiver deserializes the AHB and acquires
+  // its own ref.
+  handle<message_pipe> tracking_pipe;
+};
+
+[EnableIf=is_win]
+struct DxgiHandle {
+  // The actual buffer windows handle.
+  handle<platform> buffer_handle;
+
+  // Shared memory copy of all the data. Valid only if requested by the
+  // consumer. It is included here because DXGI GMBs are unmappable except in
+  // the GPU process. So without it the consumer if a CPU readable frame is
+  // needed would resort to request a copy in the shared memory via GPU process.
+  mojo_base.mojom.UnsafeSharedMemoryRegion? shared_memory_handle;
+};
+
+union GpuMemoryBufferPlatformHandle {
+  mojo_base.mojom.UnsafeSharedMemoryRegion shared_memory_handle;
+
+  [EnableIf=supports_native_pixmap]
+  NativePixmapHandle native_pixmap_handle;
+
+  [EnableIf=is_mac]
+  handle<platform> mach_port;
+
+  [EnableIf=is_win]
+  DxgiHandle dxgi_handle;
+
+  [EnableIf=is_android]
+  AHardwareBufferHandle android_hardware_buffer_handle;
+};
diff --git a/ui/gfx/mojom/native_handle_types_mojom_traits.cc b/ui/gfx/mojom/native_handle_types_mojom_traits.cc
new file mode 100644
index 0000000..15e5b8b
--- /dev/null
+++ b/ui/gfx/mojom/native_handle_types_mojom_traits.cc
@@ -0,0 +1,63 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/mojom/native_handle_types_mojom_traits.h"
+
+#include "build/build_config.h"
+
+namespace mojo {
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
+mojo::PlatformHandle StructTraits<
+    gfx::mojom::NativePixmapPlaneDataView,
+    gfx::NativePixmapPlane>::buffer_handle(gfx::NativePixmapPlane& plane) {
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  return mojo::PlatformHandle(std::move(plane.fd));
+#elif defined(OS_FUCHSIA)
+  return mojo::PlatformHandle(std::move(plane.vmo));
+#endif  // defined(OS_LINUX) || defined(OS_CHROMEOS)
+}
+
+bool StructTraits<
+    gfx::mojom::NativePixmapPlaneDataView,
+    gfx::NativePixmapPlane>::Read(gfx::mojom::NativePixmapPlaneDataView data,
+                                  gfx::NativePixmapPlane* out) {
+  out->stride = data.stride();
+  out->offset = data.offset();
+  out->size = data.size();
+
+  mojo::PlatformHandle handle = data.TakeBufferHandle();
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  if (!handle.is_fd())
+    return false;
+  out->fd = handle.TakeFD();
+#elif defined(OS_FUCHSIA)
+  if (!handle.is_handle())
+    return false;
+  out->vmo = zx::vmo(handle.TakeHandle());
+#endif  // defined(OS_LINUX) || defined(OS_CHROMEOS)
+
+  return true;
+}
+
+bool StructTraits<
+    gfx::mojom::NativePixmapHandleDataView,
+    gfx::NativePixmapHandle>::Read(gfx::mojom::NativePixmapHandleDataView data,
+                                   gfx::NativePixmapHandle* out) {
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  out->modifier = data.modifier();
+#endif
+
+#if defined(OS_FUCHSIA)
+  if (!data.ReadBufferCollectionId(&out->buffer_collection_id))
+    return false;
+  out->buffer_index = data.buffer_index();
+  out->ram_coherency = data.ram_coherency();
+#endif
+
+  return data.ReadPlanes(&out->planes);
+}
+#endif  // defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
+
+}  // namespace mojo
diff --git a/ui/gfx/mojom/native_handle_types_mojom_traits.h b/ui/gfx/mojom/native_handle_types_mojom_traits.h
new file mode 100644
index 0000000..43ff149
--- /dev/null
+++ b/ui/gfx/mojom/native_handle_types_mojom_traits.h
@@ -0,0 +1,80 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_NATIVE_HANDLE_TYPES_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_NATIVE_HANDLE_TYPES_MOJOM_TRAITS_H_
+
+#include "base/component_export.h"
+#include "base/numerics/safe_conversions.h"
+#include "build/build_config.h"
+#include "mojo/public/cpp/base/unguessable_token_mojom_traits.h"
+#include "mojo/public/cpp/bindings/struct_traits.h"
+#include "mojo/public/cpp/bindings/union_traits.h"
+#include "mojo/public/cpp/system/platform_handle.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/mojom/native_handle_types.mojom-shared.h"
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
+#include "ui/gfx/native_pixmap_handle.h"
+#endif
+
+namespace mojo {
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
+template <>
+struct COMPONENT_EXPORT(GFX_NATIVE_HANDLE_TYPES_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::NativePixmapPlaneDataView,
+                 gfx::NativePixmapPlane> {
+  static uint32_t stride(const gfx::NativePixmapPlane& plane) {
+    return plane.stride;
+  }
+  static int32_t offset(const gfx::NativePixmapPlane& plane) {
+    return base::saturated_cast<int32_t>(plane.offset);
+  }
+  static uint64_t size(const gfx::NativePixmapPlane& plane) {
+    return plane.size;
+  }
+  static mojo::PlatformHandle buffer_handle(gfx::NativePixmapPlane& plane);
+  static bool Read(gfx::mojom::NativePixmapPlaneDataView data,
+                   gfx::NativePixmapPlane* out);
+};
+
+template <>
+struct COMPONENT_EXPORT(GFX_NATIVE_HANDLE_TYPES_SHARED_MOJOM_TRAITS)
+    StructTraits<gfx::mojom::NativePixmapHandleDataView,
+                 gfx::NativePixmapHandle> {
+  static std::vector<gfx::NativePixmapPlane>& planes(
+      gfx::NativePixmapHandle& pixmap_handle) {
+    return pixmap_handle.planes;
+  }
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  static uint64_t modifier(const gfx::NativePixmapHandle& pixmap_handle) {
+    return pixmap_handle.modifier;
+  }
+#endif
+
+#if defined(OS_FUCHSIA)
+  static const absl::optional<base::UnguessableToken>& buffer_collection_id(
+      const gfx::NativePixmapHandle& pixmap_handle) {
+    return pixmap_handle.buffer_collection_id;
+  }
+
+  static uint32_t buffer_index(gfx::NativePixmapHandle& pixmap_handle) {
+    return pixmap_handle.buffer_index;
+  }
+
+  static bool ram_coherency(gfx::NativePixmapHandle& pixmap_handle) {
+    return pixmap_handle.ram_coherency;
+  }
+#endif  // defined(OS_FUCHSIA)
+
+  static bool Read(gfx::mojom::NativePixmapHandleDataView data,
+                   gfx::NativePixmapHandle* out);
+};
+#endif  // defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_NATIVE_HANDLE_TYPES_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/overlay_priority_hint.mojom b/ui/gfx/mojom/overlay_priority_hint.mojom
new file mode 100644
index 0000000..9e976af
--- /dev/null
+++ b/ui/gfx/mojom/overlay_priority_hint.mojom
@@ -0,0 +1,13 @@
+// Copyright 2021 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.
+
+module gfx.mojom;
+
+// gfx::OverlayPriorityHint
+enum OverlayPriorityHint {
+  kNone = 0,
+  kRegular,
+  kLowLatencyCanvas,
+  kHardwareProtection,
+};
diff --git a/ui/gfx/mojom/overlay_priority_hint_mojom_traits.h b/ui/gfx/mojom/overlay_priority_hint_mojom_traits.h
new file mode 100644
index 0000000..ea950ec
--- /dev/null
+++ b/ui/gfx/mojom/overlay_priority_hint_mojom_traits.h
@@ -0,0 +1,54 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_OVERLAY_PRIORITY_HINT_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_OVERLAY_PRIORITY_HINT_MOJOM_TRAITS_H_
+
+#include "ui/gfx/mojom/overlay_priority_hint.mojom.h"
+#include "ui/gfx/overlay_priority_hint.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<gfx::mojom::OverlayPriorityHint, gfx::OverlayPriorityHint> {
+  static gfx::mojom::OverlayPriorityHint ToMojom(
+      gfx::OverlayPriorityHint hint) {
+    switch (hint) {
+      case gfx::OverlayPriorityHint::kNone:
+        return gfx::mojom::OverlayPriorityHint::kNone;
+      case gfx::OverlayPriorityHint::kRegular:
+        return gfx::mojom::OverlayPriorityHint::kRegular;
+      case gfx::OverlayPriorityHint::kLowLatencyCanvas:
+        return gfx::mojom::OverlayPriorityHint::kLowLatencyCanvas;
+      case gfx::OverlayPriorityHint::kHardwareProtection:
+        return gfx::mojom::OverlayPriorityHint::kHardwareProtection;
+    }
+    NOTREACHED();
+    return gfx::mojom::OverlayPriorityHint::kNone;
+  }
+
+  static bool FromMojom(gfx::mojom::OverlayPriorityHint input,
+                        gfx::OverlayPriorityHint* out) {
+    switch (input) {
+      case gfx::mojom::OverlayPriorityHint::kNone:
+        *out = gfx::OverlayPriorityHint::kNone;
+        return true;
+      case gfx::mojom::OverlayPriorityHint::kRegular:
+        *out = gfx::OverlayPriorityHint::kRegular;
+        return true;
+      case gfx::mojom::OverlayPriorityHint::kLowLatencyCanvas:
+        *out = gfx::OverlayPriorityHint::kLowLatencyCanvas;
+        return true;
+      case gfx::mojom::OverlayPriorityHint::kHardwareProtection:
+        *out = gfx::OverlayPriorityHint::kHardwareProtection;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_OVERLAY_PRIORITY_HINT_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/overlay_transform.mojom b/ui/gfx/mojom/overlay_transform.mojom
new file mode 100644
index 0000000..af64e36
--- /dev/null
+++ b/ui/gfx/mojom/overlay_transform.mojom
@@ -0,0 +1,17 @@
+// Copyright 2017 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.
+
+module gfx.mojom;
+
+// gfx::OverlayTransform
+enum OverlayTransform {
+  OVERLAY_TRANSFORM_INVALID,
+  OVERLAY_TRANSFORM_NONE,
+  OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
+  OVERLAY_TRANSFORM_FLIP_VERTICAL,
+  OVERLAY_TRANSFORM_ROTATE_90,
+  OVERLAY_TRANSFORM_ROTATE_180,
+  OVERLAY_TRANSFORM_ROTATE_270,
+  OVERLAY_TRANSFORM_LAST = OVERLAY_TRANSFORM_ROTATE_270
+};
diff --git a/ui/gfx/mojom/overlay_transform_mojom_traits.h b/ui/gfx/mojom/overlay_transform_mojom_traits.h
new file mode 100644
index 0000000..b94c5f1
--- /dev/null
+++ b/ui/gfx/mojom/overlay_transform_mojom_traits.h
@@ -0,0 +1,68 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_OVERLAY_TRANSFORM_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_OVERLAY_TRANSFORM_MOJOM_TRAITS_H_
+
+#include "ui/gfx/mojom/overlay_transform.mojom.h"
+#include "ui/gfx/overlay_transform.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<gfx::mojom::OverlayTransform, gfx::OverlayTransform> {
+  static gfx::mojom::OverlayTransform ToMojom(gfx::OverlayTransform format) {
+    switch (format) {
+      case gfx::OverlayTransform::OVERLAY_TRANSFORM_INVALID:
+        return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_INVALID;
+      case gfx::OverlayTransform::OVERLAY_TRANSFORM_NONE:
+        return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_NONE;
+      case gfx::OverlayTransform::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
+        return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_FLIP_HORIZONTAL;
+      case gfx::OverlayTransform::OVERLAY_TRANSFORM_FLIP_VERTICAL:
+        return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_FLIP_VERTICAL;
+      case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90:
+        return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90;
+      case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180:
+        return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180;
+      case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270:
+        return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270;
+    }
+    NOTREACHED();
+    return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_INVALID;
+  }
+
+  static bool FromMojom(gfx::mojom::OverlayTransform input,
+                        gfx::OverlayTransform* out) {
+    switch (input) {
+      case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_INVALID:
+        *out = gfx::OverlayTransform::OVERLAY_TRANSFORM_INVALID;
+        return true;
+      case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_NONE:
+        *out = gfx::OverlayTransform::OVERLAY_TRANSFORM_NONE;
+        return true;
+      case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
+        *out = gfx::OverlayTransform::OVERLAY_TRANSFORM_FLIP_HORIZONTAL;
+        return true;
+      case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_FLIP_VERTICAL:
+        *out = gfx::OverlayTransform::OVERLAY_TRANSFORM_FLIP_VERTICAL;
+        return true;
+      case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90:
+        *out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90;
+        return true;
+      case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180:
+        *out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180;
+        return true;
+      case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270:
+        *out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_OVERLAY_TRANSFORM_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/presentation_feedback.mojom b/ui/gfx/mojom/presentation_feedback.mojom
new file mode 100644
index 0000000..2ddc661
--- /dev/null
+++ b/ui/gfx/mojom/presentation_feedback.mojom
@@ -0,0 +1,19 @@
+// Copyright 2018 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.
+
+module gfx.mojom;
+
+import "mojo/public/mojom/base/time.mojom";
+
+// gfx::PresentationFeedback
+struct PresentationFeedback {
+  mojo_base.mojom.TimeTicks timestamp;
+  mojo_base.mojom.TimeDelta interval;
+  uint32 flags;
+
+  mojo_base.mojom.TimeTicks available_timestamp;
+  mojo_base.mojom.TimeTicks ready_timestamp;
+  mojo_base.mojom.TimeTicks latch_timestamp;
+  mojo_base.mojom.TimeTicks writes_done_timestamp;
+};
diff --git a/ui/gfx/mojom/presentation_feedback_mojom_traits.h b/ui/gfx/mojom/presentation_feedback_mojom_traits.h
new file mode 100644
index 0000000..bee9e78
--- /dev/null
+++ b/ui/gfx/mojom/presentation_feedback_mojom_traits.h
@@ -0,0 +1,64 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_PRESENTATION_FEEDBACK_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_PRESENTATION_FEEDBACK_MOJOM_TRAITS_H_
+
+#include "base/time/time.h"
+#include "mojo/public/cpp/base/time_mojom_traits.h"
+#include "ui/gfx/mojom/presentation_feedback.mojom-shared.h"
+#include "ui/gfx/presentation_feedback.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::PresentationFeedbackDataView,
+                    gfx::PresentationFeedback> {
+  static base::TimeTicks timestamp(const gfx::PresentationFeedback& input) {
+    return input.timestamp;
+  }
+
+  static base::TimeDelta interval(const gfx::PresentationFeedback& input) {
+    return input.interval;
+  }
+
+  static uint32_t flags(const gfx::PresentationFeedback& input) {
+    return input.flags;
+  }
+
+  static base::TimeTicks available_timestamp(
+      const gfx::PresentationFeedback& input) {
+    return input.available_timestamp;
+  }
+
+  static base::TimeTicks ready_timestamp(
+      const gfx::PresentationFeedback& input) {
+    return input.ready_timestamp;
+  }
+
+  static base::TimeTicks latch_timestamp(
+      const gfx::PresentationFeedback& input) {
+    return input.latch_timestamp;
+  }
+
+  static base::TimeTicks writes_done_timestamp(
+      const gfx::PresentationFeedback& input) {
+    return input.writes_done_timestamp;
+  }
+
+  static bool Read(gfx::mojom::PresentationFeedbackDataView data,
+                   gfx::PresentationFeedback* out) {
+    out->flags = data.flags();
+    return data.ReadTimestamp(&out->timestamp) &&
+           data.ReadInterval(&out->interval) &&
+           data.ReadAvailableTimestamp(&out->available_timestamp) &&
+           data.ReadReadyTimestamp(&out->ready_timestamp) &&
+           data.ReadLatchTimestamp(&out->latch_timestamp) &&
+           data.ReadWritesDoneTimestamp(&out->writes_done_timestamp);
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_PRESENTATION_FEEDBACK_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/rrect_f.mojom b/ui/gfx/mojom/rrect_f.mojom
new file mode 100644
index 0000000..c10e8f4
--- /dev/null
+++ b/ui/gfx/mojom/rrect_f.mojom
@@ -0,0 +1,26 @@
+// Copyright 2018 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.
+
+module gfx.mojom;
+
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+enum RRectFType {
+  kEmpty,
+  kRect,
+  kSingle,
+  kSimple,
+  kOval,
+  kComplex,
+};
+
+// See ui/gfx/rrect_f.h.
+struct RRectF {
+  RRectFType type;
+  gfx.mojom.RectF rect;
+  gfx.mojom.Vector2dF upper_left;
+  gfx.mojom.Vector2dF upper_right;
+  gfx.mojom.Vector2dF lower_right;
+  gfx.mojom.Vector2dF lower_left;
+};
diff --git a/ui/gfx/mojom/rrect_f_mojom_traits.h b/ui/gfx/mojom/rrect_f_mojom_traits.h
new file mode 100644
index 0000000..1e73285
--- /dev/null
+++ b/ui/gfx/mojom/rrect_f_mojom_traits.h
@@ -0,0 +1,121 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_RRECT_F_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_RRECT_F_MOJOM_TRAITS_H_
+
+#include "ui/gfx/geometry/mojom/geometry_mojom_traits.h"
+#include "ui/gfx/geometry/rrect_f.h"
+#include "ui/gfx/geometry/rrect_f_builder.h"
+#include "ui/gfx/mojom/rrect_f.mojom-shared.h"
+
+namespace mojo {
+
+namespace {
+
+gfx::mojom::RRectFType GfxRRectFTypeToMojo(gfx::RRectF::Type type) {
+  switch (type) {
+    case gfx::RRectF::Type::kEmpty:
+      return gfx::mojom::RRectFType::kEmpty;
+    case gfx::RRectF::Type::kRect:
+      return gfx::mojom::RRectFType::kRect;
+    case gfx::RRectF::Type::kSingle:
+      return gfx::mojom::RRectFType::kSingle;
+    case gfx::RRectF::Type::kSimple:
+      return gfx::mojom::RRectFType::kSimple;
+    case gfx::RRectF::Type::kOval:
+      return gfx::mojom::RRectFType::kOval;
+    case gfx::RRectF::Type::kComplex:
+      return gfx::mojom::RRectFType::kComplex;
+  }
+  NOTREACHED();
+  return gfx::mojom::RRectFType::kEmpty;
+}
+
+gfx::RRectF::Type MojoRRectFTypeToGfx(gfx::mojom::RRectFType type) {
+  switch (type) {
+    case gfx::mojom::RRectFType::kEmpty:
+      return gfx::RRectF::Type::kEmpty;
+    case gfx::mojom::RRectFType::kRect:
+      return gfx::RRectF::Type::kRect;
+    case gfx::mojom::RRectFType::kSingle:
+      return gfx::RRectF::Type::kSingle;
+    case gfx::mojom::RRectFType::kSimple:
+      return gfx::RRectF::Type::kSimple;
+    case gfx::mojom::RRectFType::kOval:
+      return gfx::RRectF::Type::kOval;
+    case gfx::mojom::RRectFType::kComplex:
+      return gfx::RRectF::Type::kComplex;
+  }
+  NOTREACHED();
+  return gfx::RRectF::Type::kEmpty;
+}
+
+}  // namespace
+
+template <>
+struct StructTraits<gfx::mojom::RRectFDataView, gfx::RRectF> {
+  static gfx::mojom::RRectFType type(const gfx::RRectF& input) {
+    return GfxRRectFTypeToMojo(input.GetType());
+  }
+
+  static gfx::RectF rect(const gfx::RRectF& input) { return input.rect(); }
+
+  static gfx::Vector2dF upper_left(const gfx::RRectF& input) {
+    return input.GetCornerRadii(gfx::RRectF::Corner::kUpperLeft);
+  }
+
+  static gfx::Vector2dF upper_right(const gfx::RRectF& input) {
+    return input.GetCornerRadii(gfx::RRectF::Corner::kUpperRight);
+  }
+
+  static gfx::Vector2dF lower_right(const gfx::RRectF& input) {
+    return input.GetCornerRadii(gfx::RRectF::Corner::kLowerRight);
+  }
+
+  static gfx::Vector2dF lower_left(const gfx::RRectF& input) {
+    return input.GetCornerRadii(gfx::RRectF::Corner::kLowerLeft);
+  }
+
+  static bool Read(gfx::mojom::RRectFDataView data, gfx::RRectF* out) {
+    gfx::RRectF::Type type(MojoRRectFTypeToGfx(data.type()));
+    gfx::RectF rect;
+    if (!data.ReadRect(&rect))
+      return false;
+    if (type <= gfx::RRectF::Type::kRect) {
+      *out = gfx::RRectFBuilder().set_rect(rect).Build();
+      return true;
+    }
+    gfx::Vector2dF upper_left;
+    if (!data.ReadUpperLeft(&upper_left))
+      return false;
+    if (type <= gfx::RRectF::Type::kSimple) {
+      *out = gfx::RRectFBuilder()
+                 .set_rect(rect)
+                 .set_radius(upper_left.x(), upper_left.y())
+                 .Build();
+      return true;
+    }
+    gfx::Vector2dF upper_right;
+    gfx::Vector2dF lower_right;
+    gfx::Vector2dF lower_left;
+    if (!data.ReadUpperRight(&upper_right) ||
+        !data.ReadLowerRight(&lower_right) ||
+        !data.ReadLowerLeft(&lower_left)) {
+      return false;
+    }
+    *out = gfx::RRectFBuilder()
+               .set_rect(rect)
+               .set_upper_left(upper_left.x(), upper_left.y())
+               .set_upper_right(upper_right.x(), upper_right.y())
+               .set_lower_right(lower_right.x(), lower_right.y())
+               .set_lower_left(lower_left.x(), lower_left.y())
+               .Build();
+    return true;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_RRECT_F_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/selection_bound.mojom b/ui/gfx/mojom/selection_bound.mojom
new file mode 100644
index 0000000..55b56c1
--- /dev/null
+++ b/ui/gfx/mojom/selection_bound.mojom
@@ -0,0 +1,26 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+enum SelectionBoundType {
+  LEFT,
+  RIGHT,
+  CENTER,
+  EMPTY,
+  LAST = EMPTY
+};
+
+// See ui/gfx/selection_bound.h.
+struct SelectionBound {
+  SelectionBoundType type;
+  gfx.mojom.PointF edge_start;
+  gfx.mojom.PointF edge_end;
+  gfx.mojom.PointF visible_edge_start;
+  gfx.mojom.PointF visible_edge_end;
+  bool visible;
+};
+
diff --git a/ui/gfx/mojom/selection_bound_mojom_traits.h b/ui/gfx/mojom/selection_bound_mojom_traits.h
new file mode 100644
index 0000000..e001ae5
--- /dev/null
+++ b/ui/gfx/mojom/selection_bound_mojom_traits.h
@@ -0,0 +1,96 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_SELECTION_BOUND_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_SELECTION_BOUND_MOJOM_TRAITS_H_
+
+#include "ui/gfx/geometry/mojom/geometry_mojom_traits.h"
+#include "ui/gfx/mojom/selection_bound.mojom-shared.h"
+#include "ui/gfx/selection_bound.h"
+
+namespace mojo {
+
+namespace {
+
+gfx::mojom::SelectionBoundType GfxSelectionBoundTypeToMojo(
+    gfx::SelectionBound::Type type) {
+  switch (type) {
+    case gfx::SelectionBound::LEFT:
+      return gfx::mojom::SelectionBoundType::LEFT;
+    case gfx::SelectionBound::RIGHT:
+      return gfx::mojom::SelectionBoundType::RIGHT;
+    case gfx::SelectionBound::CENTER:
+      return gfx::mojom::SelectionBoundType::CENTER;
+    case gfx::SelectionBound::EMPTY:
+      return gfx::mojom::SelectionBoundType::EMPTY;
+  }
+  NOTREACHED();
+  return gfx::mojom::SelectionBoundType::EMPTY;
+}
+
+gfx::SelectionBound::Type MojoSelectionBoundTypeToGfx(
+    gfx::mojom::SelectionBoundType type) {
+  switch (type) {
+    case gfx::mojom::SelectionBoundType::LEFT:
+      return gfx::SelectionBound::LEFT;
+    case gfx::mojom::SelectionBoundType::RIGHT:
+      return gfx::SelectionBound::RIGHT;
+    case gfx::mojom::SelectionBoundType::CENTER:
+      return gfx::SelectionBound::CENTER;
+    case gfx::mojom::SelectionBoundType::EMPTY:
+      return gfx::SelectionBound::EMPTY;
+  }
+  NOTREACHED();
+  return gfx::SelectionBound::EMPTY;
+}
+
+}
+
+template <>
+struct StructTraits<gfx::mojom::SelectionBoundDataView, gfx::SelectionBound> {
+  static gfx::mojom::SelectionBoundType type(const gfx::SelectionBound& input) {
+    return GfxSelectionBoundTypeToMojo(input.type());
+  }
+
+  static gfx::PointF edge_start(const gfx::SelectionBound& input) {
+    return input.edge_start();
+  }
+
+  static gfx::PointF edge_end(const gfx::SelectionBound& input) {
+    return input.edge_end();
+  }
+
+  static gfx::PointF visible_edge_start(const gfx::SelectionBound& input) {
+    return input.visible_edge_start();
+  }
+
+  static gfx::PointF visible_edge_end(const gfx::SelectionBound& input) {
+    return input.visible_edge_end();
+  }
+
+  static bool visible(const gfx::SelectionBound& input) {
+    return input.visible();
+  }
+
+  static bool Read(gfx::mojom::SelectionBoundDataView data,
+                   gfx::SelectionBound* out) {
+    gfx::PointF edge_start;
+    gfx::PointF edge_end;
+    gfx::PointF visible_edge_start;
+    gfx::PointF visible_edge_end;
+    if (!data.ReadEdgeStart(&edge_start) || !data.ReadEdgeEnd(&edge_end) ||
+        !data.ReadVisibleEdgeStart(&visible_edge_start) ||
+        !data.ReadVisibleEdgeEnd(&visible_edge_end))
+      return false;
+    out->SetEdge(edge_start, edge_end);
+    out->SetVisibleEdge(visible_edge_start, visible_edge_end);
+    out->set_type(MojoSelectionBoundTypeToGfx(data.type()));
+    out->set_visible(data.visible());
+    return true;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_SELECTION_BOUND_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/swap_result.mojom b/ui/gfx/mojom/swap_result.mojom
new file mode 100644
index 0000000..f206fee
--- /dev/null
+++ b/ui/gfx/mojom/swap_result.mojom
@@ -0,0 +1,17 @@
+// Copyright 2018 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.
+
+module gfx.mojom;
+
+// SwapResult information which is used to indicate whether buffer swap
+// succeeded or not. These values correspond to gfx::SwapResult values in
+// ui/gfx/swap_result.h. Currently, it is used by the Ozone/Wayland to identify
+// whether a buffer swap requested by the GPU process has been successful on
+// the browser process side or not.
+enum SwapResult {
+  ACK,
+  FAILED,
+  SKIPPED,
+  NAK_RECREATE_BUFFERS,
+};
diff --git a/ui/gfx/mojom/swap_result_mojom_traits.h b/ui/gfx/mojom/swap_result_mojom_traits.h
new file mode 100644
index 0000000..245a5a3
--- /dev/null
+++ b/ui/gfx/mojom/swap_result_mojom_traits.h
@@ -0,0 +1,53 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_SWAP_RESULT_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_SWAP_RESULT_MOJOM_TRAITS_H_
+
+#include "mojo/public/cpp/bindings/enum_traits.h"
+#include "ui/gfx/mojom/swap_result.mojom-shared.h"
+#include "ui/gfx/swap_result.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<gfx::mojom::SwapResult, gfx::SwapResult> {
+  static gfx::mojom::SwapResult ToMojom(gfx::SwapResult input) {
+    switch (input) {
+      case gfx::SwapResult::SWAP_ACK:
+        return gfx::mojom::SwapResult::ACK;
+      case gfx::SwapResult::SWAP_FAILED:
+        return gfx::mojom::SwapResult::FAILED;
+      case gfx::SwapResult::SWAP_SKIPPED:
+        return gfx::mojom::SwapResult::SKIPPED;
+      case gfx::SwapResult::SWAP_NAK_RECREATE_BUFFERS:
+        return gfx::mojom::SwapResult::NAK_RECREATE_BUFFERS;
+    }
+    NOTREACHED();
+    return gfx::mojom::SwapResult::FAILED;
+  }
+
+  static bool FromMojom(gfx::mojom::SwapResult input, gfx::SwapResult* out) {
+    switch (input) {
+      case gfx::mojom::SwapResult::ACK:
+        *out = gfx::SwapResult::SWAP_ACK;
+        return true;
+      case gfx::mojom::SwapResult::FAILED:
+        *out = gfx::SwapResult::SWAP_FAILED;
+        return true;
+      case gfx::mojom::SwapResult::SKIPPED:
+        *out = gfx::SwapResult::SWAP_SKIPPED;
+        return true;
+      case gfx::mojom::SwapResult::NAK_RECREATE_BUFFERS:
+        *out = gfx::SwapResult::SWAP_NAK_RECREATE_BUFFERS;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_SWAP_RESULT_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/swap_timings.mojom b/ui/gfx/mojom/swap_timings.mojom
new file mode 100644
index 0000000..af51a0b
--- /dev/null
+++ b/ui/gfx/mojom/swap_timings.mojom
@@ -0,0 +1,13 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+import "mojo/public/mojom/base/time.mojom";
+
+// gfx::SwapTimings
+struct SwapTimings {
+  mojo_base.mojom.TimeTicks swap_start;
+  mojo_base.mojom.TimeTicks swap_end;
+};
diff --git a/ui/gfx/mojom/swap_timings_mojom_traits.h b/ui/gfx/mojom/swap_timings_mojom_traits.h
new file mode 100644
index 0000000..96ea989
--- /dev/null
+++ b/ui/gfx/mojom/swap_timings_mojom_traits.h
@@ -0,0 +1,34 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_SWAP_TIMINGS_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_SWAP_TIMINGS_MOJOM_TRAITS_H_
+
+#include "base/time/time.h"
+#include "mojo/public/cpp/base/time_mojom_traits.h"
+#include "ui/gfx/mojom/swap_timings.mojom-shared.h"
+#include "ui/gfx/swap_result.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::SwapTimingsDataView, gfx::SwapTimings> {
+  static base::TimeTicks swap_start(const gfx::SwapTimings& input) {
+    return input.swap_start;
+  }
+
+  static base::TimeTicks swap_end(const gfx::SwapTimings& input) {
+    return input.swap_end;
+  }
+
+  static bool Read(gfx::mojom::SwapTimingsDataView data,
+                   gfx::SwapTimings* out) {
+    return data.ReadSwapStart(&out->swap_start) &&
+           data.ReadSwapEnd(&out->swap_end);
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_SWAP_TIMINGS_MOJOM_TRAITS_H_
diff --git a/ui/gfx/mojom/traits_test_service.mojom b/ui/gfx/mojom/traits_test_service.mojom
new file mode 100644
index 0000000..7cdcb7f
--- /dev/null
+++ b/ui/gfx/mojom/traits_test_service.mojom
@@ -0,0 +1,28 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+import "ui/gfx/mojom/accelerated_widget.mojom";
+import "ui/gfx/mojom/buffer_types.mojom";
+import "ui/gfx/mojom/rrect_f.mojom";
+import "ui/gfx/mojom/selection_bound.mojom";
+import "ui/gfx/mojom/transform.mojom";
+
+// All functions on this interface echo their arguments to test StructTraits
+// serialization and deserialization.
+interface TraitsTestService {
+  [Sync]
+  EchoSelectionBound(SelectionBound s) => (SelectionBound pass);
+
+  [Sync]
+  EchoTransform(Transform t) => (Transform pass);
+
+  [Sync]
+  EchoGpuMemoryBufferHandle(GpuMemoryBufferHandle g)
+      => (GpuMemoryBufferHandle pass);
+
+  [Sync]
+  EchoRRectF(RRectF t) => (RRectF pass);
+};
diff --git a/ui/gfx/mojom/transform.mojom b/ui/gfx/mojom/transform.mojom
new file mode 100644
index 0000000..badc081
--- /dev/null
+++ b/ui/gfx/mojom/transform.mojom
@@ -0,0 +1,14 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+// See ui/gfx/transform.h.
+[Stable]
+struct Transform {
+  // Column major order.
+  // The identity matrix is considered null and will not be serialized. This
+  // saves the cost of serialization and deserialization.
+  array<float, 16>? matrix;
+};
diff --git a/ui/gfx/mojom/transform_mojom_traits.h b/ui/gfx/mojom/transform_mojom_traits.h
new file mode 100644
index 0000000..b8c3887
--- /dev/null
+++ b/ui/gfx/mojom/transform_mojom_traits.h
@@ -0,0 +1,48 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_MOJOM_TRANSFORM_MOJOM_TRAITS_H_
+#define UI_GFX_MOJOM_TRANSFORM_MOJOM_TRAITS_H_
+
+#include "mojo/public/cpp/bindings/array_traits.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/mojom/transform.mojom-shared.h"
+
+namespace mojo {
+
+template <>
+struct ArrayTraits<skia::Matrix44> {
+  using Element = float;
+
+  static bool IsNull(const skia::Matrix44& input) { return input.isIdentity(); }
+
+  static size_t GetSize(const skia::Matrix44& input) { return 16; }
+
+  static float GetAt(const skia::Matrix44& input, size_t index) {
+    return input.getFloat(static_cast<int>(index % 4),
+                          static_cast<int>(index / 4));
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::TransformDataView, gfx::Transform> {
+  static const skia::Matrix44& matrix(const gfx::Transform& transform) {
+    return transform.matrix();
+  }
+
+  static bool Read(gfx::mojom::TransformDataView data, gfx::Transform* out) {
+    ArrayDataView<float> matrix;
+    data.GetMatrixDataView(&matrix);
+    if (matrix.is_null()) {
+      out->MakeIdentity();
+      return true;
+    }
+    out->matrix().setColMajorf(matrix.data());
+    return true;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_MOJOM_TRANSFORM_MOJOM_TRAITS_H_
diff --git a/ui/gfx/native_pixmap.h b/ui/gfx/native_pixmap.h
new file mode 100644
index 0000000..c90af23
--- /dev/null
+++ b/ui/gfx/native_pixmap.h
@@ -0,0 +1,79 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_NATIVE_PIXMAP_H_
+#define UI_GFX_NATIVE_PIXMAP_H_
+
+#include "base/bind.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/native_pixmap_handle.h"
+#include "ui/gfx/native_widget_types.h"
+
+namespace gfx {
+struct OverlayPlaneData;
+class GpuFence;
+
+// This represents a buffer that can be directly imported via GL for
+// rendering, or exported via dma-buf fds.
+class NativePixmap : public base::RefCountedThreadSafe<NativePixmap> {
+ public:
+  NativePixmap() {}
+
+  NativePixmap(const NativePixmap&) = delete;
+  NativePixmap& operator=(const NativePixmap&) = delete;
+
+  virtual bool AreDmaBufFdsValid() const = 0;
+  virtual int GetDmaBufFd(size_t plane) const = 0;
+  virtual uint32_t GetDmaBufPitch(size_t plane) const = 0;
+  virtual size_t GetDmaBufOffset(size_t plane) const = 0;
+  virtual size_t GetDmaBufPlaneSize(size_t plane) const = 0;
+  // Return the number of non-interleaved "color" planes.
+  virtual size_t GetNumberOfPlanes() const = 0;
+
+  // The following methods return format, modifier and size of the buffer,
+  // respectively.
+  virtual gfx::BufferFormat GetBufferFormat() const = 0;
+  virtual uint64_t GetBufferFormatModifier() const = 0;
+  virtual gfx::Size GetBufferSize() const = 0;
+
+  // Return an id that is guaranteed to be unique and equal for all instances
+  // of this NativePixmap backed by the same buffer, for the duration of its
+  // lifetime. If such id cannot be generated, 0 (an invalid id) is returned.
+  //
+  // TODO(posciak): crbug.com/771863, remove this once a different mechanism
+  // for protected shared memory buffers is implemented.
+  virtual uint32_t GetUniqueId() const = 0;
+
+  // Sets the overlay plane to switch to at the next page flip.
+  // |widget| specifies the screen to display this overlay plane on.
+  // |acquire_fences| specifies gpu fences to wait on before the pixmap is ready
+  // to be displayed. These fence are fired when the gpu has finished writing to
+  // the pixmap.
+  // |release_fences| specifies gpu fences that are signalled when the pixmap
+  // has been displayed and is ready for reuse.
+  // |overlay_plane_data| specifies overlay data such as opacity, z_order, size,
+  // etc.
+  virtual bool ScheduleOverlayPlane(
+      gfx::AcceleratedWidget widget,
+      const gfx::OverlayPlaneData& overlay_plane_data,
+      std::vector<gfx::GpuFence> acquire_fences,
+      std::vector<gfx::GpuFence> release_fences) = 0;
+
+  // Export the buffer for sharing across processes.
+  // Any file descriptors in the exported handle are owned by the caller.
+  virtual gfx::NativePixmapHandle ExportHandle() = 0;
+
+ protected:
+  virtual ~NativePixmap() {}
+
+ private:
+  friend class base::RefCountedThreadSafe<NativePixmap>;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_NATIVE_PIXMAP_H_
diff --git a/ui/gfx/native_pixmap_handle.cc b/ui/gfx/native_pixmap_handle.cc
new file mode 100644
index 0000000..137056b
--- /dev/null
+++ b/ui/gfx/native_pixmap_handle.cc
@@ -0,0 +1,113 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/native_pixmap_handle.h"
+
+#include <utility>
+
+#include "base/logging.h"
+#include "build/build_config.h"
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+#include <drm_fourcc.h>
+#include "base/posix/eintr_wrapper.h"
+#endif
+
+#if defined(OS_FUCHSIA)
+#include <lib/zx/vmo.h>
+#include "base/fuchsia/fuchsia_logging.h"
+#endif
+
+namespace gfx {
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+static_assert(NativePixmapHandle::kNoModifier == DRM_FORMAT_MOD_INVALID,
+              "gfx::NativePixmapHandle::kNoModifier should be an alias for"
+              "DRM_FORMAT_MOD_INVALID");
+#endif
+
+NativePixmapPlane::NativePixmapPlane() : stride(0), offset(0), size(0) {}
+
+NativePixmapPlane::NativePixmapPlane(int stride,
+                                     int offset,
+                                     uint64_t size
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+                                     ,
+                                     base::ScopedFD fd
+#elif defined(OS_FUCHSIA)
+                                     ,
+                                     zx::vmo vmo
+#endif
+                                     )
+    : stride(stride),
+      offset(offset),
+      size(size)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+      ,
+      fd(std::move(fd))
+#elif defined(OS_FUCHSIA)
+      ,
+      vmo(std::move(vmo))
+#endif
+{
+}
+
+NativePixmapPlane::NativePixmapPlane(NativePixmapPlane&& other) = default;
+
+NativePixmapPlane::~NativePixmapPlane() = default;
+
+NativePixmapPlane& NativePixmapPlane::operator=(NativePixmapPlane&& other) =
+    default;
+
+NativePixmapHandle::NativePixmapHandle() = default;
+NativePixmapHandle::NativePixmapHandle(NativePixmapHandle&& other) = default;
+
+NativePixmapHandle::~NativePixmapHandle() = default;
+
+NativePixmapHandle& NativePixmapHandle::operator=(NativePixmapHandle&& other) =
+    default;
+
+NativePixmapHandle CloneHandleForIPC(const NativePixmapHandle& handle) {
+  NativePixmapHandle clone;
+  for (auto& plane : handle.planes) {
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+    DCHECK(plane.fd.is_valid());
+    base::ScopedFD fd_dup(HANDLE_EINTR(dup(plane.fd.get())));
+    if (!fd_dup.is_valid()) {
+      PLOG(ERROR) << "dup";
+      return NativePixmapHandle();
+    }
+    clone.planes.emplace_back(plane.stride, plane.offset, plane.size,
+                              std::move(fd_dup));
+#elif defined(OS_FUCHSIA)
+    zx::vmo vmo_dup;
+    // VMO may be set to NULL for pixmaps that cannot be mapped.
+    if (plane.vmo) {
+      zx_status_t status = plane.vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &vmo_dup);
+      if (status != ZX_OK) {
+        ZX_DLOG(ERROR, status) << "zx_handle_duplicate";
+        return NativePixmapHandle();
+      }
+    }
+    clone.planes.emplace_back(plane.stride, plane.offset, plane.size,
+                              std::move(vmo_dup));
+#else
+#error Unsupported OS
+#endif
+  }
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+  clone.modifier = handle.modifier;
+#endif
+
+#if defined(OS_FUCHSIA)
+  clone.buffer_collection_id = handle.buffer_collection_id;
+  clone.buffer_index = handle.buffer_index;
+  clone.ram_coherency = handle.ram_coherency;
+#endif
+
+  return clone;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/native_pixmap_handle.h b/ui/gfx/native_pixmap_handle.h
new file mode 100644
index 0000000..d0d769b
--- /dev/null
+++ b/ui/gfx/native_pixmap_handle.h
@@ -0,0 +1,20 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_NATIVE_PIXMAP_HANDLE_H_
+#define UI_GFX_NATIVE_PIXMAP_HANDLE_H_
+
+// A reduced version of `native_pixmap_handle.h` enough to make required files
+// in Chromium media to be built.
+
+namespace gfx {
+
+class NativePixmapHandle {
+ public:
+  static constexpr uint64_t kNoModifier = 0x00ffffffffffffff;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_NATIVE_PIXMAP_HANDLE_H_
diff --git a/ui/gfx/native_widget_types.h b/ui/gfx/native_widget_types.h
new file mode 100644
index 0000000..334d61f
--- /dev/null
+++ b/ui/gfx/native_widget_types.h
@@ -0,0 +1,259 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_NATIVE_WIDGET_TYPES_H_
+#define UI_GFX_NATIVE_WIDGET_TYPES_H_
+
+#include <stdint.h>
+
+#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
+#include "ui/gfx/gfx_export.h"
+
+#if defined(OS_ANDROID)
+#include "base/android/scoped_java_ref.h"
+#elif defined(OS_APPLE)
+#include <objc/objc.h>
+#elif defined(OS_WIN)
+#include "base/win/windows_types.h"
+#endif
+
+// This file provides cross platform typedefs for native widget types.
+//   NativeWindow: this is a handle to a native, top-level window
+//   NativeView: this is a handle to a native UI element. It may be the
+//     same type as a NativeWindow on some platforms.
+//   NativeViewId: Often, in our cross process model, we need to pass around a
+//     reference to a "window". This reference will, say, be echoed back from a
+//     renderer to the browser when it wishes to query its size. On Windows we
+//     use an HWND for this.
+//
+//     As a rule of thumb - if you're in the renderer, you should be dealing
+//     with NativeViewIds. This should remind you that you shouldn't be doing
+//     direct operations on platform widgets from the renderer process.
+//
+//     If you're in the browser, you're probably dealing with NativeViews,
+//     unless you're in the IPC layer, which will be translating between
+//     NativeViewIds from the renderer and NativeViews.
+//
+// The name 'View' here meshes with OS X where the UI elements are called
+// 'views' and with our Chrome UI code where the elements are also called
+// 'views'.
+
+#if defined(USE_AURA)
+namespace aura {
+class Window;
+}
+namespace ui {
+class Cursor;
+class Event;
+namespace mojom {
+enum class CursorType;
+}
+}  // namespace ui
+
+#endif  // defined(USE_AURA)
+
+#if defined(OS_WIN)
+typedef struct HFONT__* HFONT;
+struct IAccessible;
+#elif defined(OS_IOS)
+struct CGContext;
+#ifdef __OBJC__
+@class UIEvent;
+@class UIFont;
+@class UIImage;
+@class UIView;
+@class UIWindow;
+@class UITextField;
+#else
+class UIEvent;
+class UIFont;
+class UIImage;
+class UIView;
+class UIWindow;
+class UITextField;
+#endif  // __OBJC__
+#elif defined(OS_MAC)
+struct CGContext;
+#ifdef __OBJC__
+@class NSCursor;
+@class NSEvent;
+@class NSFont;
+@class NSImage;
+@class NSView;
+@class NSWindow;
+@class NSTextField;
+#else
+class NSCursor;
+class NSEvent;
+class NSFont;
+class NSImage;
+struct NSView;
+class NSWindow;
+class NSTextField;
+#endif  // __OBJC__
+#endif
+
+#if defined(OS_ANDROID)
+struct ANativeWindow;
+namespace ui {
+class WindowAndroid;
+class ViewAndroid;
+}  // namespace ui
+#endif
+class SkBitmap;
+
+// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
+// of lacros-chrome is complete.
+#if defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
+extern "C" {
+struct _AtkObject;
+typedef struct _AtkObject AtkObject;
+}
+#endif
+
+namespace gfx {
+
+#if defined(USE_AURA)
+typedef ui::Cursor NativeCursor;
+typedef aura::Window* NativeView;
+typedef aura::Window* NativeWindow;
+typedef ui::Event* NativeEvent;
+constexpr NativeView kNullNativeView = nullptr;
+constexpr NativeWindow kNullNativeWindow = nullptr;
+#elif defined(OS_IOS)
+typedef void* NativeCursor;
+typedef UIView* NativeView;
+typedef UIWindow* NativeWindow;
+typedef UIEvent* NativeEvent;
+constexpr NativeView kNullNativeView = nullptr;
+constexpr NativeWindow kNullNativeWindow = nullptr;
+#elif defined(OS_MAC)
+typedef NSCursor* NativeCursor;
+typedef NSEvent* NativeEvent;
+// NativeViews and NativeWindows on macOS are not necessarily in the same
+// process as the NSViews and NSWindows that they represent. Require an
+// explicit function call (GetNativeNSView or GetNativeNSWindow) to retrieve
+// the underlying NSView or NSWindow.
+// https://crbug.com/893719
+class GFX_EXPORT NativeView {
+ public:
+  constexpr NativeView() {}
+  // TODO(ccameron): Make this constructor explicit.
+  constexpr NativeView(NSView* ns_view) : ns_view_(ns_view) {}
+
+  // This function name is verbose (that is, not just GetNSView) so that it
+  // is easily grep-able.
+  NSView* GetNativeNSView() const { return ns_view_; }
+
+  operator bool() const { return ns_view_ != 0; }
+  bool operator==(const NativeView& other) const {
+    return ns_view_ == other.ns_view_;
+  }
+  bool operator!=(const NativeView& other) const {
+    return ns_view_ != other.ns_view_;
+  }
+  bool operator<(const NativeView& other) const {
+    return ns_view_ < other.ns_view_;
+  }
+
+ private:
+  NSView* ns_view_ = nullptr;
+};
+class GFX_EXPORT NativeWindow {
+ public:
+  constexpr NativeWindow() {}
+  // TODO(ccameron): Make this constructor explicit.
+  constexpr NativeWindow(NSWindow* ns_window) : ns_window_(ns_window) {}
+
+  // This function name is verbose (that is, not just GetNSWindow) so that it
+  // is easily grep-able.
+  NSWindow* GetNativeNSWindow() const { return ns_window_; }
+
+  operator bool() const { return ns_window_ != 0; }
+  bool operator==(const NativeWindow& other) const {
+    return ns_window_ == other.ns_window_;
+  }
+  bool operator!=(const NativeWindow& other) const {
+    return ns_window_ != other.ns_window_;
+  }
+  bool operator<(const NativeWindow& other) const {
+    return ns_window_ < other.ns_window_;
+  }
+
+ private:
+  NSWindow* ns_window_ = nullptr;
+};
+constexpr NativeView kNullNativeView = NativeView(nullptr);
+constexpr NativeWindow kNullNativeWindow = NativeWindow(nullptr);
+#elif defined(OS_ANDROID)
+typedef void* NativeCursor;
+typedef ui::ViewAndroid* NativeView;
+typedef ui::WindowAndroid* NativeWindow;
+typedef base::android::ScopedJavaGlobalRef<jobject> NativeEvent;
+constexpr NativeView kNullNativeView = nullptr;
+constexpr NativeWindow kNullNativeWindow = nullptr;
+#else
+#error Unknown build environment.
+#endif
+
+#if defined(OS_WIN)
+typedef HFONT NativeFont;
+typedef IAccessible* NativeViewAccessible;
+#elif defined(OS_IOS)
+typedef UIFont* NativeFont;
+typedef id NativeViewAccessible;
+#elif defined(OS_MAC)
+typedef NSFont* NativeFont;
+typedef id NativeViewAccessible;
+// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
+// of lacros-chrome is complete.
+#elif defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
+// Linux doesn't have a native font type.
+typedef AtkObject* NativeViewAccessible;
+#else
+// Android, Chrome OS, etc.
+typedef struct _UnimplementedNativeViewAccessible
+    UnimplementedNativeViewAccessible;
+typedef UnimplementedNativeViewAccessible* NativeViewAccessible;
+#endif
+
+// A constant value to indicate that gfx::NativeCursor refers to no cursor.
+#if defined(USE_AURA)
+const ui::mojom::CursorType kNullCursor =
+    static_cast<ui::mojom::CursorType>(-1);
+#else
+const gfx::NativeCursor kNullCursor = static_cast<gfx::NativeCursor>(nullptr);
+#endif
+
+// Note: for test_shell we're packing a pointer into the NativeViewId. So, if
+// you make it a type which is smaller than a pointer, you have to fix
+// test_shell.
+//
+// See comment at the top of the file for usage.
+typedef intptr_t NativeViewId;
+
+// AcceleratedWidget provides a surface to compositors to paint pixels.
+#if defined(OS_WIN)
+typedef HWND AcceleratedWidget;
+constexpr AcceleratedWidget kNullAcceleratedWidget = nullptr;
+#elif defined(OS_IOS)
+typedef UIView* AcceleratedWidget;
+constexpr AcceleratedWidget kNullAcceleratedWidget = 0;
+#elif defined(OS_MAC)
+typedef uint64_t AcceleratedWidget;
+constexpr AcceleratedWidget kNullAcceleratedWidget = 0;
+#elif defined(OS_ANDROID)
+typedef ANativeWindow* AcceleratedWidget;
+constexpr AcceleratedWidget kNullAcceleratedWidget = 0;
+#elif defined(USE_OZONE) || defined(USE_X11)
+typedef uint32_t AcceleratedWidget;
+constexpr AcceleratedWidget kNullAcceleratedWidget = 0;
+#else
+#error unknown platform
+#endif
+
+}  // namespace gfx
+
+#endif  // UI_GFX_NATIVE_WIDGET_TYPES_H_
diff --git a/ui/gfx/nine_image_painter.cc b/ui/gfx/nine_image_painter.cc
new file mode 100644
index 0000000..b2292b3
--- /dev/null
+++ b/ui/gfx/nine_image_painter.cc
@@ -0,0 +1,197 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/nine_image_painter.h"
+
+#include <stddef.h>
+
+#include <limits>
+
+#include "base/cxx17_backports.h"
+#include "base/numerics/safe_conversions.h"
+#include "cc/paint/paint_flags.h"
+#include "third_party/skia/include/core/SkRect.h"
+#include "third_party/skia/include/core/SkScalar.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/scoped_canvas.h"
+
+namespace gfx {
+
+namespace {
+
+int ImageRepWidthInPixels(const ImageSkiaRep& rep) {
+  if (rep.is_null())
+    return 0;
+  return rep.pixel_width();
+}
+
+int ImageRepHeightInPixels(const ImageSkiaRep& rep) {
+  if (rep.is_null())
+    return 0;
+  return rep.pixel_height();
+}
+
+void Fill(Canvas* c,
+          const ImageSkiaRep& rep,
+          int x,
+          int y,
+          int w,
+          int h,
+          const cc::PaintFlags& flags) {
+  if (rep.is_null())
+    return;
+  c->DrawImageIntInPixel(rep, x, y, w, h, false, flags);
+}
+
+}  // namespace
+
+NineImagePainter::NineImagePainter(const std::vector<ImageSkia>& images) {
+  DCHECK_EQ(base::size(images_), images.size());
+  for (size_t i = 0; i < base::size(images_); ++i)
+    images_[i] = images[i];
+}
+
+NineImagePainter::NineImagePainter(const ImageSkia& image,
+                                   const Insets& insets) {
+  std::vector<gfx::Rect> regions;
+  GetSubsetRegions(image, insets, &regions);
+  DCHECK_EQ(9u, regions.size());
+
+  for (size_t i = 0; i < 9; ++i)
+    images_[i] = ImageSkiaOperations::ExtractSubset(image, regions[i]);
+}
+
+NineImagePainter::~NineImagePainter() {
+}
+
+bool NineImagePainter::IsEmpty() const {
+  return images_[0].isNull();
+}
+
+Size NineImagePainter::GetMinimumSize() const {
+  return IsEmpty() ? Size() : Size(
+      images_[0].width() + images_[1].width() + images_[2].width(),
+      images_[0].height() + images_[3].height() + images_[6].height());
+}
+
+void NineImagePainter::Paint(Canvas* canvas, const Rect& bounds) {
+  // When no alpha value is specified, use default value of 100% opacity.
+  Paint(canvas, bounds, std::numeric_limits<uint8_t>::max());
+}
+
+void NineImagePainter::Paint(Canvas* canvas,
+                             const Rect& bounds,
+                             const uint8_t alpha) {
+  if (IsEmpty())
+    return;
+
+  ScopedCanvas scoped_canvas(canvas);
+
+  // Painting and doing layout at physical device pixels to avoid cracks or
+  // overlap.
+  const float scale = canvas->UndoDeviceScaleFactor();
+
+  // Since the drawing from the following Fill() calls assumes the mapped origin
+  // is at (0,0), we need to translate the canvas to the mapped origin.
+  const int left_in_pixels = base::ClampRound(bounds.x() * scale);
+  const int top_in_pixels = base::ClampRound(bounds.y() * scale);
+  const int right_in_pixels = base::ClampRound(bounds.right() * scale);
+  const int bottom_in_pixels = base::ClampRound(bounds.bottom() * scale);
+
+  const int width_in_pixels = right_in_pixels - left_in_pixels;
+  const int height_in_pixels = bottom_in_pixels - top_in_pixels;
+
+  // Since the drawing from the following Fill() calls assumes the mapped origin
+  // is at (0,0), we need to translate the canvas to the mapped origin.
+  canvas->Translate(gfx::Vector2d(left_in_pixels, top_in_pixels));
+
+  ImageSkiaRep image_reps[9];
+  static_assert(base::size(image_reps) == std::extent<decltype(images_)>(), "");
+  for (size_t i = 0; i < base::size(image_reps); ++i) {
+    image_reps[i] = images_[i].GetRepresentation(scale);
+    DCHECK(image_reps[i].is_null() || image_reps[i].scale() == scale);
+  }
+
+  // In case the corners and edges don't all have the same width/height, we draw
+  // the center first, and extend it out in all directions to the edges of the
+  // images with the smallest widths/heights.  This way there will be no
+  // unpainted areas, though some corners or edges might overlap the center.
+  int i0w = ImageRepWidthInPixels(image_reps[0]);
+  int i2w = ImageRepWidthInPixels(image_reps[2]);
+  int i3w = ImageRepWidthInPixels(image_reps[3]);
+  int i5w = ImageRepWidthInPixels(image_reps[5]);
+  int i6w = ImageRepWidthInPixels(image_reps[6]);
+  int i8w = ImageRepWidthInPixels(image_reps[8]);
+
+  int i0h = ImageRepHeightInPixels(image_reps[0]);
+  int i1h = ImageRepHeightInPixels(image_reps[1]);
+  int i2h = ImageRepHeightInPixels(image_reps[2]);
+  int i6h = ImageRepHeightInPixels(image_reps[6]);
+  int i7h = ImageRepHeightInPixels(image_reps[7]);
+  int i8h = ImageRepHeightInPixels(image_reps[8]);
+
+  i0w = std::min(i0w, width_in_pixels);
+  i2w = std::min(i2w, width_in_pixels - i0w);
+  i3w = std::min(i3w, width_in_pixels);
+  i5w = std::min(i5w, width_in_pixels - i3w);
+  i6w = std::min(i6w, width_in_pixels);
+  i8w = std::min(i8w, width_in_pixels - i6w);
+
+  i0h = std::min(i0h, height_in_pixels);
+  i1h = std::min(i1h, height_in_pixels);
+  i2h = std::min(i2h, height_in_pixels);
+  i6h = std::min(i6h, height_in_pixels - i0h);
+  i7h = std::min(i7h, height_in_pixels - i1h);
+  i8h = std::min(i8h, height_in_pixels - i2h);
+
+  int i4x = std::min({i0w, i3w, i6w});
+  int i4y = std::min({i0h, i1h, i2h});
+  int i4w = std::max(width_in_pixels - i4x - std::min({i2w, i5w, i8w}), 0);
+  int i4h = std::max(height_in_pixels - i4y - std::min({i6h, i7h, i8h}), 0);
+
+  cc::PaintFlags flags;
+  flags.setAlpha(alpha);
+
+  Fill(canvas, image_reps[4], i4x, i4y, i4w, i4h, flags);
+  Fill(canvas, image_reps[0], 0, 0, i0w, i0h, flags);
+  Fill(canvas, image_reps[1], i0w, 0, width_in_pixels - i0w - i2w, i1h, flags);
+  Fill(canvas, image_reps[2], width_in_pixels - i2w, 0, i2w, i2h, flags);
+  Fill(canvas, image_reps[3], 0, i0h, i3w, height_in_pixels - i0h - i6h, flags);
+  Fill(canvas, image_reps[5], width_in_pixels - i5w, i2h, i5w,
+       height_in_pixels - i2h - i8h, flags);
+  Fill(canvas, image_reps[6], 0, height_in_pixels - i6h, i6w, i6h, flags);
+  Fill(canvas, image_reps[7], i6w, height_in_pixels - i7h,
+       width_in_pixels - i6w - i8w, i7h, flags);
+  Fill(canvas, image_reps[8], width_in_pixels - i8w, height_in_pixels - i8h,
+       i8w, i8h, flags);
+}
+
+// static
+void NineImagePainter::GetSubsetRegions(const ImageSkia& image,
+                                        const Insets& insets,
+                                        std::vector<Rect>* regions) {
+  DCHECK_GE(image.width(), insets.width());
+  DCHECK_GE(image.height(), insets.height());
+
+  std::vector<Rect> result(9);
+
+  const int x[] = {
+      0, insets.left(), image.width() - insets.right(), image.width()};
+  const int y[] = {
+      0, insets.top(), image.height() - insets.bottom(), image.height()};
+
+  for (size_t j = 0; j < 3; ++j) {
+    for (size_t i = 0; i < 3; ++i) {
+      result[i + j * 3] = Rect(x[i], y[j], x[i + 1] - x[i], y[j + 1] - y[j]);
+    }
+  }
+  result.swap(*regions);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/nine_image_painter.h b/ui/gfx/nine_image_painter.h
new file mode 100644
index 0000000..caa6e3a
--- /dev/null
+++ b/ui/gfx/nine_image_painter.h
@@ -0,0 +1,57 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_NINE_IMAGE_PAINTER_H_
+#define UI_GFX_NINE_IMAGE_PAINTER_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+#include "base/gtest_prod_util.h"
+#include "base/macros.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace gfx {
+
+class Canvas;
+class Insets;
+class Rect;
+
+class GFX_EXPORT NineImagePainter {
+ public:
+  explicit NineImagePainter(const std::vector<ImageSkia>& images);
+  NineImagePainter(const ImageSkia& image, const Insets& insets);
+
+  NineImagePainter(const NineImagePainter&) = delete;
+  NineImagePainter& operator=(const NineImagePainter&) = delete;
+
+  ~NineImagePainter();
+
+  bool IsEmpty() const;
+  Size GetMinimumSize() const;
+  void Paint(Canvas* canvas, const Rect& bounds);
+  void Paint(Canvas* canvas, const Rect& bounds, uint8_t alpha);
+
+ private:
+  friend class NineImagePainterTest;
+  FRIEND_TEST_ALL_PREFIXES(NineImagePainterTest, GetSubsetRegions);
+
+  // Gets the regions for the subimages into |regions|.
+  static void GetSubsetRegions(const ImageSkia& image,
+                               const Insets& insets,
+                               std::vector<Rect>* regions);
+
+  // Images are numbered as depicted below.
+  //  ____________________
+  // |__i0__|__i1__|__i2__|
+  // |__i3__|__i4__|__i5__|
+  // |__i6__|__i7__|__i8__|
+  ImageSkia images_[9];
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_NINE_IMAGE_PAINTER_H_
diff --git a/ui/gfx/nine_image_painter_unittest.cc b/ui/gfx/nine_image_painter_unittest.cc
new file mode 100644
index 0000000..9897d00
--- /dev/null
+++ b/ui/gfx/nine_image_painter_unittest.cc
@@ -0,0 +1,225 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/nine_image_painter.h"
+
+#include "base/base64.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/geometry/vector2d_conversions.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace gfx {
+
+static std::string GetPNGDataUrl(const SkBitmap& bitmap) {
+  std::vector<unsigned char> png_data;
+  gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &png_data);
+  std::string data_url;
+  data_url.insert(data_url.end(), png_data.begin(), png_data.end());
+  base::Base64Encode(data_url, &data_url);
+  data_url.insert(0, "data:image/png;base64,");
+
+  return data_url;
+}
+
+void ExpectRedWithGreenRect(const SkBitmap& bitmap,
+                            const Rect& outer_rect,
+                            const Rect& green_rect) {
+  for (int y = outer_rect.y(); y < outer_rect.bottom(); y++) {
+    SCOPED_TRACE(y);
+    for (int x = outer_rect.x(); x < outer_rect.right(); x++) {
+      SCOPED_TRACE(x);
+      if (green_rect.Contains(x, y)) {
+        ASSERT_EQ(SK_ColorGREEN, bitmap.getColor(x, y))
+            << "Output image:\n" << GetPNGDataUrl(bitmap);
+      } else {
+        ASSERT_EQ(SK_ColorRED, bitmap.getColor(x, y)) << "Output image:\n"
+                                                      << GetPNGDataUrl(bitmap);
+      }
+    }
+  }
+}
+
+TEST(NineImagePainterTest, GetSubsetRegions) {
+  SkBitmap src;
+  src.allocN32Pixels(40, 50);
+  const ImageSkia image_skia(ImageSkiaRep(src, 1.0));
+  const Insets insets(1, 2, 3, 4);
+  std::vector<Rect> rects;
+  NineImagePainter::GetSubsetRegions(image_skia, insets, &rects);
+  ASSERT_EQ(9u, rects.size());
+  EXPECT_EQ(gfx::Rect(0, 0, 2, 1), rects[0]);
+  EXPECT_EQ(gfx::Rect(2, 0, 34, 1), rects[1]);
+  EXPECT_EQ(gfx::Rect(36, 0, 4, 1), rects[2]);
+  EXPECT_EQ(gfx::Rect(0, 1, 2, 46), rects[3]);
+  EXPECT_EQ(gfx::Rect(2, 1, 34, 46), rects[4]);
+  EXPECT_EQ(gfx::Rect(36, 1, 4, 46), rects[5]);
+  EXPECT_EQ(gfx::Rect(0, 47, 2, 3), rects[6]);
+  EXPECT_EQ(gfx::Rect(2, 47, 34, 3), rects[7]);
+  EXPECT_EQ(gfx::Rect(36, 47, 4, 3), rects[8]);
+}
+
+TEST(NineImagePainterTest, PaintHighDPI) {
+  SkBitmap src;
+  src.allocN32Pixels(100, 100);
+  src.eraseColor(SK_ColorRED);
+  src.eraseArea(SkIRect::MakeXYWH(10, 10, 80, 80), SK_ColorGREEN);
+
+  float image_scale = 2.f;
+
+  gfx::ImageSkia image = gfx::ImageSkia::CreateFromBitmap(src, image_scale);
+  gfx::Insets insets(10, 10, 10, 10);
+  gfx::NineImagePainter painter(image, insets);
+
+  bool is_opaque = true;
+  gfx::Canvas canvas(gfx::Size(100, 100), image_scale, is_opaque);
+
+  gfx::Vector2d offset(20, 10);
+  canvas.Translate(offset);
+
+  gfx::Rect bounds(0, 0, 50, 50);
+  painter.Paint(&canvas, bounds);
+
+  SkBitmap result = canvas.GetBitmap();
+
+  gfx::Vector2d paint_offset =
+      gfx::ToFlooredVector2d(gfx::ScaleVector2d(offset, image_scale));
+  gfx::Rect green_rect = gfx::Rect(10, 10, 80, 80) + paint_offset;
+  gfx::Rect outer_rect = gfx::Rect(100, 100) + paint_offset;
+  ExpectRedWithGreenRect(result, outer_rect, green_rect);
+}
+
+TEST(NineImagePainterTest, PaintStaysInBounds) {
+  // In this test the bounds rect is 1x1 but each image is 2x2.
+  // The NineImagePainter should not paint outside the bounds.
+  // The border images should be cropped, but still painted.
+
+  SkBitmap src;
+  src.allocN32Pixels(6, 6);
+  src.eraseColor(SK_ColorGREEN);
+  src.erase(SK_ColorRED, SkIRect::MakeXYWH(2, 2, 2, 2));
+
+  gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(src);
+  gfx::Insets insets(2, 2, 2, 2);
+  gfx::NineImagePainter painter(image, insets);
+
+  int image_scale = 1;
+  bool is_opaque = true;
+  gfx::Canvas canvas(gfx::Size(3, 3), image_scale, is_opaque);
+  canvas.DrawColor(SK_ColorBLACK);
+
+  gfx::Rect bounds(1, 1, 1, 1);
+  painter.Paint(&canvas, bounds);
+
+  SkBitmap result = canvas.GetBitmap();
+
+  EXPECT_EQ(SK_ColorGREEN, result.getColor(1, 1));
+
+  EXPECT_EQ(SK_ColorBLACK, result.getColor(0, 0));
+  EXPECT_EQ(SK_ColorBLACK, result.getColor(0, 1));
+  EXPECT_EQ(SK_ColorBLACK, result.getColor(0, 2));
+  EXPECT_EQ(SK_ColorBLACK, result.getColor(1, 0));
+  EXPECT_EQ(SK_ColorBLACK, result.getColor(1, 2));
+  EXPECT_EQ(SK_ColorBLACK, result.getColor(2, 0));
+  EXPECT_EQ(SK_ColorBLACK, result.getColor(2, 1));
+  EXPECT_EQ(SK_ColorBLACK, result.getColor(2, 2));
+}
+
+TEST(NineImagePainterTest, PaintWithBoundOffset) {
+  SkBitmap src;
+  src.allocN32Pixels(10, 10);
+  src.eraseColor(SK_ColorRED);
+  src.eraseArea(SkIRect::MakeXYWH(1, 1, 8, 8), SK_ColorGREEN);
+
+  gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(src);
+  gfx::Insets insets(1, 1, 1, 1);
+  gfx::NineImagePainter painter(image, insets);
+
+  bool is_opaque = true;
+  gfx::Canvas canvas(gfx::Size(10, 10), 1, is_opaque);
+
+  gfx::Rect bounds(1, 1, 10, 10);
+  painter.Paint(&canvas, bounds);
+
+  SkBitmap result = canvas.GetBitmap();
+
+  SkIRect green_rect = SkIRect::MakeLTRB(2, 2, 10, 10);
+  for (int y = 1; y < 10; y++) {
+    for (int x = 1; x < 10; x++) {
+      if (green_rect.contains(x, y)) {
+        ASSERT_EQ(SK_ColorGREEN, result.getColor(x, y));
+      } else {
+        ASSERT_EQ(SK_ColorRED, result.getColor(x, y));
+      }
+    }
+  }
+}
+
+TEST(NineImagePainterTest, PaintWithScale) {
+  SkBitmap src;
+  src.allocN32Pixels(100, 100);
+  src.eraseColor(SK_ColorRED);
+  src.eraseArea(SkIRect::MakeXYWH(10, 10, 80, 80), SK_ColorGREEN);
+
+  float image_scale = 2.f;
+
+  gfx::ImageSkia image = gfx::ImageSkia::CreateFromBitmap(src, image_scale);
+  gfx::Insets insets(10, 10, 10, 10);
+  gfx::NineImagePainter painter(image, insets);
+
+  bool is_opaque = true;
+  gfx::Canvas canvas(gfx::Size(400, 400), image_scale, is_opaque);
+
+  gfx::Vector2d offset(20, 10);
+  canvas.Translate(offset);
+  canvas.Scale(2, 1);
+
+  gfx::Rect bounds(0, 0, 50, 50);
+  painter.Paint(&canvas, bounds);
+
+  SkBitmap result = canvas.GetBitmap();
+
+  gfx::Vector2d paint_offset =
+      gfx::ToFlooredVector2d(gfx::ScaleVector2d(offset, image_scale));
+  gfx::Rect green_rect = gfx::Rect(20, 10, 160, 80) + paint_offset;
+  gfx::Rect outer_rect = gfx::Rect(200, 100) + paint_offset;
+  ExpectRedWithGreenRect(result, outer_rect, green_rect);
+}
+
+TEST(NineImagePainterTest, PaintWithNegativeScale) {
+  SkBitmap src;
+  src.allocN32Pixels(100, 100);
+  src.eraseColor(SK_ColorRED);
+  src.eraseArea(SkIRect::MakeXYWH(10, 10, 80, 80), SK_ColorGREEN);
+
+  float image_scale = 2.f;
+
+  gfx::ImageSkia image = gfx::ImageSkia::CreateFromBitmap(src, image_scale);
+  gfx::Insets insets(10, 10, 10, 10);
+  gfx::NineImagePainter painter(image, insets);
+
+  bool is_opaque = true;
+  gfx::Canvas canvas(gfx::Size(400, 400), image_scale, is_opaque);
+  canvas.Translate(gfx::Vector2d(70, 60));
+  canvas.Scale(-1, -1);
+
+  gfx::Rect bounds(0, 0, 50, 50);
+  painter.Paint(&canvas, bounds);
+
+  SkBitmap result = canvas.GetBitmap();
+
+  // The painting space is 50x50 and the scale of -1,-1 means an offset of 50,50
+  // would put the output in the top left corner. Since the offset is 70,60 it
+  // moves by 20,10. Since the output is 2x DPI it will become offset by 40,20.
+  gfx::Vector2d paint_offset(40, 20);
+  gfx::Rect green_rect = gfx::Rect(10, 10, 80, 80) + paint_offset;
+  gfx::Rect outer_rect = gfx::Rect(100, 100) + paint_offset;
+  ExpectRedWithGreenRect(result, outer_rect, green_rect);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/overlay_plane_data.cc b/ui/gfx/overlay_plane_data.cc
new file mode 100644
index 0000000..69c49bd
--- /dev/null
+++ b/ui/gfx/overlay_plane_data.cc
@@ -0,0 +1,30 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/overlay_plane_data.h"
+
+namespace gfx {
+
+OverlayPlaneData::OverlayPlaneData() = default;
+
+OverlayPlaneData::OverlayPlaneData(int z_order,
+                                   OverlayTransform plane_transform,
+                                   const Rect& display_bounds,
+                                   const RectF& crop_rect,
+                                   bool enable_blend,
+                                   const Rect& damage_rect,
+                                   float opacity,
+                                   OverlayPriorityHint priority_hint)
+    : z_order(z_order),
+      plane_transform(plane_transform),
+      display_bounds(display_bounds),
+      crop_rect(crop_rect),
+      enable_blend(enable_blend),
+      damage_rect(damage_rect),
+      opacity(opacity),
+      priority_hint(priority_hint) {}
+
+OverlayPlaneData::~OverlayPlaneData() = default;
+
+}  // namespace gfx
diff --git a/ui/gfx/overlay_plane_data.h b/ui/gfx/overlay_plane_data.h
new file mode 100644
index 0000000..272ee21
--- /dev/null
+++ b/ui/gfx/overlay_plane_data.h
@@ -0,0 +1,57 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_OVERLAY_PLANE_DATA_H_
+#define UI_GFX_OVERLAY_PLANE_DATA_H_
+
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/overlay_priority_hint.h"
+#include "ui/gfx/overlay_transform.h"
+
+namespace gfx {
+
+struct GFX_EXPORT OverlayPlaneData {
+  OverlayPlaneData();
+  OverlayPlaneData(int z_order,
+                   OverlayTransform plane_transform,
+                   const Rect& display_bounds,
+                   const RectF& crop_rect,
+                   bool enable_blend,
+                   const Rect& damage_rect,
+                   float opacity,
+                   OverlayPriorityHint priority_hint);
+  ~OverlayPlaneData();
+
+  // Specifies the stacking order of the plane relative to the main framebuffer
+  // located at index 0.
+  int z_order = 0;
+
+  // Specifies how the buffer is to be transformed during composition.
+  OverlayTransform plane_transform = OverlayTransform::OVERLAY_TRANSFORM_NONE;
+
+  // Pixel bounds within the display to position the image.
+  Rect display_bounds;
+
+  // Normalized bounds of the image to be displayed in |display_bounds|.
+  RectF crop_rect = RectF(1.f, 1.f);
+
+  // Whether alpha blending should be enabled.
+  bool enable_blend = false;
+
+  // Damage on the buffer.
+  Rect damage_rect;
+
+  // Opacity of overlay plane. For a blending buffer (|enable_blend|) the total
+  // transparency will by = channel alpha * |opacity|.
+  float opacity = 1.0f;
+
+  // Hints for overlay prioritization when delegated composition is used.
+  OverlayPriorityHint priority_hint = OverlayPriorityHint::kNone;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_OVERLAY_PLANE_DATA_H_
diff --git a/ui/gfx/overlay_priority_hint.h b/ui/gfx/overlay_priority_hint.h
new file mode 100644
index 0000000..1ae4d6e
--- /dev/null
+++ b/ui/gfx/overlay_priority_hint.h
@@ -0,0 +1,26 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_OVERLAY_PRIORITY_HINT_H_
+#define UI_GFX_OVERLAY_PRIORITY_HINT_H_
+
+namespace gfx {
+
+// Provides a hint to a system compositor how it should prioritize this
+// overlay. Used only by Wayland.
+enum OverlayPriorityHint {
+  // Overlay promotion is not necessary for this surface.
+  kNone = 0,
+  // The overlay could be considered as a candidate for promotion.
+  kRegular,
+  // Low latency quad.
+  kLowLatencyCanvas,
+  // The overlay contains protected content and requires to be promoted to
+  // overlay.
+  kHardwareProtection,
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_OVERLAY_PRIORITY_HINT_H_
diff --git a/ui/gfx/overlay_transform.h b/ui/gfx/overlay_transform.h
new file mode 100644
index 0000000..252fc73
--- /dev/null
+++ b/ui/gfx/overlay_transform.h
@@ -0,0 +1,25 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_OVERLAY_TRANSFORM_H_
+#define UI_GFX_OVERLAY_TRANSFORM_H_
+
+namespace gfx {
+
+// Describes transformation to be applied to the buffer before presenting
+// to screen.  Rotations are expressed anticlockwise.
+enum OverlayTransform {
+  OVERLAY_TRANSFORM_INVALID,
+  OVERLAY_TRANSFORM_NONE,
+  OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
+  OVERLAY_TRANSFORM_FLIP_VERTICAL,
+  OVERLAY_TRANSFORM_ROTATE_90,
+  OVERLAY_TRANSFORM_ROTATE_180,
+  OVERLAY_TRANSFORM_ROTATE_270,
+  OVERLAY_TRANSFORM_LAST = OVERLAY_TRANSFORM_ROTATE_270
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_OVERLAY_TRANSFORM_H_
diff --git a/ui/gfx/overlay_transform_utils.cc b/ui/gfx/overlay_transform_utils.cc
new file mode 100644
index 0000000..c39345e
--- /dev/null
+++ b/ui/gfx/overlay_transform_utils.cc
@@ -0,0 +1,65 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/overlay_transform_utils.h"
+
+#include "base/notreached.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+
+namespace gfx {
+
+gfx::Transform OverlayTransformToTransform(
+    gfx::OverlayTransform overlay_transform,
+    const gfx::SizeF& viewport_bounds) {
+  switch (overlay_transform) {
+    case gfx::OVERLAY_TRANSFORM_INVALID:
+      NOTREACHED();
+      return gfx::Transform();
+    case gfx::OVERLAY_TRANSFORM_NONE:
+      return gfx::Transform();
+    case gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
+      return gfx::Transform(
+          SkMatrix::MakeAll(-1, 0, viewport_bounds.width(), 0, 1, 0, 0, 0, 1));
+    case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
+      return gfx::Transform(
+          SkMatrix::MakeAll(1, 0, 0, 0, -1, viewport_bounds.height(), 0, 0, 1));
+    case gfx::OVERLAY_TRANSFORM_ROTATE_90:
+      return gfx::Transform(
+          SkMatrix::MakeAll(0, -1, viewport_bounds.height(), 1, 0, 0, 0, 0, 1));
+    case gfx::OVERLAY_TRANSFORM_ROTATE_180:
+      return gfx::Transform(SkMatrix::MakeAll(-1, 0, viewport_bounds.width(), 0,
+                                              -1, viewport_bounds.height(), 0,
+                                              0, 1));
+    case gfx::OVERLAY_TRANSFORM_ROTATE_270:
+      return gfx::Transform(
+          SkMatrix::MakeAll(0, 1, 0, -1, 0, viewport_bounds.width(), 0, 0, 1));
+  }
+
+  NOTREACHED();
+  return gfx::Transform();
+}
+
+gfx::OverlayTransform InvertOverlayTransform(gfx::OverlayTransform transform) {
+  switch (transform) {
+    case gfx::OVERLAY_TRANSFORM_INVALID:
+      NOTREACHED();
+      return gfx::OVERLAY_TRANSFORM_NONE;
+    case gfx::OVERLAY_TRANSFORM_NONE:
+      return gfx::OVERLAY_TRANSFORM_NONE;
+    case gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
+      return gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL;
+    case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
+      return gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_90:
+      return gfx::OVERLAY_TRANSFORM_ROTATE_270;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_180:
+      return gfx::OVERLAY_TRANSFORM_ROTATE_180;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_270:
+      return gfx::OVERLAY_TRANSFORM_ROTATE_90;
+  }
+  NOTREACHED();
+  return gfx::OVERLAY_TRANSFORM_NONE;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/overlay_transform_utils.h b/ui/gfx/overlay_transform_utils.h
new file mode 100644
index 0000000..5df8e43
--- /dev/null
+++ b/ui/gfx/overlay_transform_utils.h
@@ -0,0 +1,24 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_OVERLAY_TRANSFORM_UTILS_H_
+#define UI_GFX_OVERLAY_TRANSFORM_UTILS_H_
+
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/overlay_transform.h"
+
+namespace gfx {
+
+GFX_EXPORT gfx::Transform OverlayTransformToTransform(
+    gfx::OverlayTransform overlay_transform,
+    const gfx::SizeF& viewport_bounds);
+
+GFX_EXPORT gfx::OverlayTransform InvertOverlayTransform(
+    gfx::OverlayTransform transform);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_OVERLAY_TRANSFORM_UTILS_H_
diff --git a/ui/gfx/overlay_transform_utils_unittest.cc b/ui/gfx/overlay_transform_utils_unittest.cc
new file mode 100644
index 0000000..8090a0e
--- /dev/null
+++ b/ui/gfx/overlay_transform_utils_unittest.cc
@@ -0,0 +1,53 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/overlay_transform_utils.h"
+
+#include "cc/base/math_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace gfx {
+namespace {
+
+TEST(OverlayTransformUtilTest, All) {
+  const Size viewport_bounds(100, 200);
+  const Rect original(10, 10, 50, 100);
+  struct TestCase {
+    OverlayTransform overlay_transform;
+    Rect transformed;
+  };
+
+  TestCase test_cases[] = {
+      {OVERLAY_TRANSFORM_NONE, Rect(10, 10, 50, 100)},
+      {OVERLAY_TRANSFORM_FLIP_HORIZONTAL, Rect(40, 10, 50, 100)},
+      {OVERLAY_TRANSFORM_FLIP_VERTICAL, Rect(10, 90, 50, 100)},
+      {OVERLAY_TRANSFORM_ROTATE_90, Rect(90, 10, 100, 50)},
+      {OVERLAY_TRANSFORM_ROTATE_180, Rect(40, 90, 50, 100)},
+      {OVERLAY_TRANSFORM_ROTATE_270, Rect(10, 40, 100, 50)},
+  };
+
+  for (const auto& test_case : test_cases) {
+    SCOPED_TRACE(test_case.overlay_transform);
+
+    auto transform = OverlayTransformToTransform(test_case.overlay_transform,
+                                                 gfx::SizeF(viewport_bounds));
+    EXPECT_EQ(test_case.transformed,
+              cc::MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(
+                  transform, original));
+
+    auto transformed_viewport_size =
+        cc::MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(
+            transform, gfx::Rect(viewport_bounds))
+            .size();
+    auto inverse_transform = OverlayTransformToTransform(
+        InvertOverlayTransform(test_case.overlay_transform),
+        gfx::SizeF(transformed_viewport_size));
+    EXPECT_EQ(original, cc::MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(
+                            inverse_transform, test_case.transformed));
+  }
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/paint_throbber.cc b/ui/gfx/paint_throbber.cc
new file mode 100644
index 0000000..bea7d99
--- /dev/null
+++ b/ui/gfx/paint_throbber.cc
@@ -0,0 +1,266 @@
+// Copyright (c) 2015 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.
+
+#include "ui/gfx/paint_throbber.h"
+
+#include <algorithm>
+
+#include "base/numerics/safe_conversions.h"
+#include "base/time/time.h"
+#include "cc/paint/paint_flags.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "ui/gfx/animation/tween.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+
+namespace gfx {
+
+namespace {
+
+// The maximum size of the "spinning" state arc, in degrees.
+constexpr int64_t kMaxArcSize = 270;
+
+// The amount of time it takes to grow the "spinning" arc from 0 to 270 degrees.
+constexpr auto kArcTime = base::Seconds(2.0 / 3.0);
+
+// The amount of time it takes for the "spinning" throbber to make a full
+// rotation.
+constexpr auto kRotationTime = base::Milliseconds(1568);
+
+void PaintArc(Canvas* canvas,
+              const Rect& bounds,
+              SkColor color,
+              SkScalar start_angle,
+              SkScalar sweep,
+              absl::optional<SkScalar> stroke_width) {
+  if (!stroke_width) {
+    // Stroke width depends on size.
+    // . For size < 28:          3 - (28 - size) / 16
+    // . For 28 <= size:         (8 + size) / 12
+    stroke_width = bounds.width() < 28
+                       ? 3.0 - SkIntToScalar(28 - bounds.width()) / 16.0
+                       : SkIntToScalar(bounds.width() + 8) / 12.0;
+  }
+  Rect oval = bounds;
+  // Inset by half the stroke width to make sure the whole arc is inside
+  // the visible rect.
+  const int inset = SkScalarCeilToInt(*stroke_width / 2.0);
+  oval.Inset(inset, inset);
+
+  SkPath path;
+  path.arcTo(RectToSkRect(oval), start_angle, sweep, true);
+
+  cc::PaintFlags flags;
+  flags.setColor(color);
+  flags.setStrokeCap(cc::PaintFlags::kRound_Cap);
+  flags.setStrokeWidth(*stroke_width);
+  flags.setStyle(cc::PaintFlags::kStroke_Style);
+  flags.setAntiAlias(true);
+  canvas->DrawPath(path, flags);
+}
+
+void CalculateWaitingAngles(const base::TimeDelta& elapsed_time,
+                            int64_t* start_angle,
+                            int64_t* sweep) {
+  // Calculate start and end points. The angles are counter-clockwise because
+  // the throbber spins counter-clockwise. The finish angle starts at 12 o'clock
+  // (90 degrees) and rotates steadily. The start angle trails 180 degrees
+  // behind, except for the first half revolution, when it stays at 12 o'clock.
+  constexpr auto kRevolutionTime = base::Milliseconds(1320);
+  int64_t twelve_oclock = 90;
+  int64_t finish_angle_cc =
+      twelve_oclock +
+      base::ClampRound<int64_t>(elapsed_time / kRevolutionTime * 360);
+  int64_t start_angle_cc = std::max(finish_angle_cc - 180, twelve_oclock);
+
+  // Negate the angles to convert to the clockwise numbers Skia expects.
+  if (start_angle)
+    *start_angle = -finish_angle_cc;
+  if (sweep)
+    *sweep = finish_angle_cc - start_angle_cc;
+}
+
+// This is a Skia port of the MD spinner SVG. The |start_angle| rotation
+// here corresponds to the 'rotate' animation.
+ThrobberSpinningState CalculateThrobberSpinningStateWithStartAngle(
+    base::TimeDelta elapsed_time,
+    int64_t start_angle) {
+  // The sweep angle ranges from -270 to 270 over 1333ms. CSS
+  // animation timing functions apply in between key frames, so we have to
+  // break up the 1333ms into two keyframes (-270 to 0, then 0 to 270).
+  const double elapsed_ratio = elapsed_time / kArcTime;
+  const int64_t sweep_frame = base::ClampFloor<int64_t>(elapsed_ratio);
+  const double arc_progress = elapsed_ratio - sweep_frame;
+  // This tween is equivalent to cubic-bezier(0.4, 0.0, 0.2, 1).
+  double sweep = kMaxArcSize *
+                 Tween::CalculateValue(Tween::FAST_OUT_SLOW_IN, arc_progress);
+  if (sweep_frame % 2 == 0)
+    sweep -= kMaxArcSize;
+
+  // This part makes sure the sweep is at least 5 degrees long. Roughly
+  // equivalent to the "magic constants" in SVG's fillunfill animation.
+  constexpr double kMinSweepLength = 5.0;
+  if (sweep >= 0.0 && sweep < kMinSweepLength) {
+    start_angle -= (kMinSweepLength - sweep);
+    sweep = kMinSweepLength;
+  } else if (sweep <= 0.0 && sweep > -kMinSweepLength) {
+    start_angle += (-kMinSweepLength - sweep);
+    sweep = -kMinSweepLength;
+  }
+
+  // To keep the sweep smooth, we have an additional rotation after each
+  // arc period has elapsed. See SVG's 'rot' animation.
+  const int64_t rot_keyframe = (sweep_frame / 2) % 4;
+  start_angle = start_angle + rot_keyframe * kMaxArcSize;
+  return ThrobberSpinningState{
+      .start_angle = static_cast<SkScalar>(start_angle),
+      .sweep_angle = static_cast<SkScalar>(sweep)};
+}
+
+void PaintThrobberSpinningWithState(Canvas* canvas,
+                                    const Rect& bounds,
+                                    SkColor color,
+                                    const ThrobberSpinningState& state,
+                                    absl::optional<SkScalar> stroke_width) {
+  PaintArc(canvas, bounds, color, state.start_angle, state.sweep_angle,
+           stroke_width);
+}
+
+void PaintThrobberSpinningWithStartAngle(
+    Canvas* canvas,
+    const Rect& bounds,
+    SkColor color,
+    const base::TimeDelta& elapsed_time,
+    int64_t start_angle,
+    absl::optional<SkScalar> stroke_width) {
+  const ThrobberSpinningState state =
+      CalculateThrobberSpinningStateWithStartAngle(elapsed_time, start_angle);
+  PaintThrobberSpinningWithState(canvas, bounds, color, state, stroke_width);
+}
+
+}  // namespace
+
+ThrobberSpinningState CalculateThrobberSpinningState(
+    base::TimeDelta elapsed_time) {
+  const int64_t start_angle =
+      270 + base::ClampRound<int64_t>(elapsed_time / kRotationTime * 360);
+  return CalculateThrobberSpinningStateWithStartAngle(elapsed_time,
+                                                      start_angle);
+}
+
+void PaintThrobberSpinning(Canvas* canvas,
+                           const Rect& bounds,
+                           SkColor color,
+                           const base::TimeDelta& elapsed_time,
+                           absl::optional<SkScalar> stroke_width) {
+  const ThrobberSpinningState state =
+      CalculateThrobberSpinningState(elapsed_time);
+  PaintThrobberSpinningWithState(canvas, bounds, color, state, stroke_width);
+}
+
+void PaintThrobberWaiting(Canvas* canvas,
+                          const Rect& bounds,
+                          SkColor color,
+                          const base::TimeDelta& elapsed_time,
+                          absl::optional<SkScalar> stroke_width) {
+  int64_t start_angle = 0, sweep = 0;
+  CalculateWaitingAngles(elapsed_time, &start_angle, &sweep);
+  PaintArc(canvas, bounds, color, start_angle, sweep, stroke_width);
+}
+
+void PaintThrobberSpinningAfterWaiting(Canvas* canvas,
+                                       const Rect& bounds,
+                                       SkColor color,
+                                       const base::TimeDelta& elapsed_time,
+                                       ThrobberWaitingState* waiting_state,
+                                       absl::optional<SkScalar> stroke_width) {
+  int64_t waiting_start_angle = 0, waiting_sweep = 0;
+  CalculateWaitingAngles(waiting_state->elapsed_time, &waiting_start_angle,
+                         &waiting_sweep);
+
+  // |arc_time_offset| is the effective amount of time one would have to wait
+  // for the "spinning" sweep to match |waiting_sweep|. Brute force calculation.
+  if (waiting_state->arc_time_offset.is_zero()) {
+    for (int64_t arc_ms = 0; arc_ms <= kArcTime.InMillisecondsRoundedUp();
+         ++arc_ms) {
+      const base::TimeDelta arc_time =
+          std::min(base::Milliseconds(arc_ms), kArcTime);
+      if (kMaxArcSize * Tween::CalculateValue(Tween::FAST_OUT_SLOW_IN,
+                                              arc_time / kArcTime) >=
+          waiting_sweep) {
+        // Add kArcTime to sidestep the |sweep_keyframe == 0| offset below.
+        waiting_state->arc_time_offset = kArcTime + arc_time;
+        break;
+      }
+    }
+  }
+
+  // Blend the color between "waiting" and "spinning" states.
+  constexpr auto kColorFadeTime = base::Milliseconds(900);
+  const float color_progress = static_cast<float>(Tween::CalculateValue(
+      Tween::LINEAR_OUT_SLOW_IN, std::min(elapsed_time / kColorFadeTime, 1.0)));
+  const SkColor blend_color =
+      color_utils::AlphaBlend(color, waiting_state->color, color_progress);
+
+  const int64_t start_angle =
+      waiting_start_angle +
+      base::ClampRound<int64_t>(elapsed_time / kRotationTime * 360);
+  const base::TimeDelta effective_elapsed_time =
+      elapsed_time + waiting_state->arc_time_offset;
+
+  PaintThrobberSpinningWithStartAngle(canvas, bounds, blend_color,
+                                      effective_elapsed_time, start_angle,
+                                      stroke_width);
+}
+
+GFX_EXPORT void PaintNewThrobberWaiting(Canvas* canvas,
+                                        const RectF& throbber_container_bounds,
+                                        SkColor color,
+                                        const base::TimeDelta& elapsed_time) {
+  // Cycle time for the waiting throbber.
+  constexpr auto kNewThrobberWaitingCycleTime = base::Seconds(1);
+
+  // The throbber bounces back and forth. We map the elapsed time to 0->2. Time
+  // 0->1 represents when the throbber moves left to right, time 1->2 represents
+  // right to left.
+  float time = 2.0f * (elapsed_time % kNewThrobberWaitingCycleTime) /
+               kNewThrobberWaitingCycleTime;
+  // 1 -> 2 values mirror back to 1 -> 0 values to represent right-to-left.
+  const bool going_back = time > 1.0f;
+  if (going_back)
+    time = 2.0f - time;
+  // This animation should be fast in the middle and slow at the edges.
+  time = Tween::CalculateValue(Tween::EASE_IN_OUT, time);
+  const float min_width = throbber_container_bounds.height();
+  // The throbber animation stretches longer when moving in (left to right) than
+  // when going back.
+  const float throbber_width =
+      (going_back ? 0.75f : 1.0f) * throbber_container_bounds.width();
+
+  // These bounds keep at least |min_width| of the throbber visible (inside the
+  // throbber bounds).
+  const float min_x =
+      throbber_container_bounds.x() - throbber_width + min_width;
+  const float max_x = throbber_container_bounds.right() - min_width;
+
+  RectF bounds = throbber_container_bounds;
+  // Linear interpolation between |min_x| and |max_x|.
+  bounds.set_x(time * (max_x - min_x) + min_x);
+  bounds.set_width(throbber_width);
+  // The throbber is designed to go out of bounds, but it should not be rendered
+  // outside |throbber_container_bounds|. This clips the throbber to the edges,
+  // which gives a smooth bouncing effect.
+  bounds.Intersect(throbber_container_bounds);
+
+  cc::PaintFlags flags;
+  flags.setColor(color);
+  flags.setStyle(cc::PaintFlags::kFill_Style);
+
+  // Draw with circular end caps.
+  canvas->DrawRoundRect(bounds, bounds.height() / 2, flags);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/paint_throbber.h b/ui/gfx/paint_throbber.h
new file mode 100644
index 0000000..c22d0f9
--- /dev/null
+++ b/ui/gfx/paint_throbber.h
@@ -0,0 +1,92 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PAINT_THROBBER_H_
+#define UI_GFX_PAINT_THROBBER_H_
+
+#include <stdint.h>
+
+#include "base/time/time.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class Canvas;
+class Rect;
+class RectF;
+
+// This struct describes the "spinning" state of a throb animation.
+struct GFX_EXPORT ThrobberSpinningState {
+  // The start angle of the arc in degrees.
+  SkScalar start_angle = 0.f;
+
+  // The sweep angle of the arc in degrees. Positive is clockwise.
+  SkScalar sweep_angle = 0.f;
+};
+
+// This struct describes the "waiting" mode of a throb animation. It's useful
+// for building a "spinning" state animation on top of a previous "waiting"
+// mode animation. See PaintThrobberSpinningAfterWaiting.
+struct GFX_EXPORT ThrobberWaitingState {
+  // The amount of time that was spent in the waiting state.
+  base::TimeDelta elapsed_time;
+
+  // The color of the arc in the waiting state.
+  SkColor color = SK_ColorTRANSPARENT;
+
+  // An opaque value used to cache calculations made by
+  // PaintThrobberSpinningAfterWaiting.
+  base::TimeDelta arc_time_offset;
+};
+
+// Returns the calculated state for a single frame of the throbber in the
+// "spinning", aka Material, state. Note that animation duration is a hardcoded
+// value in line with Material design specifications but is cyclic, so the
+// specified `elapsed_time` may exceed animation duration.
+GFX_EXPORT ThrobberSpinningState
+CalculateThrobberSpinningState(base::TimeDelta elapsed_time);
+
+// Paints a single frame of the throbber in the "spinning", aka Material, state.
+// Note that animation duration is a hardcoded value in line with Material
+// design specifications but is cyclic, so the specified `elapsed_time` may
+// exceed animation duration.
+GFX_EXPORT void PaintThrobberSpinning(
+    Canvas* canvas,
+    const Rect& bounds,
+    SkColor color,
+    const base::TimeDelta& elapsed_time,
+    absl::optional<SkScalar> stroke_width = absl::nullopt);
+
+// Paints a throbber in the "waiting" state. Used when waiting on a network
+// response, for example.
+GFX_EXPORT void PaintThrobberWaiting(
+    Canvas* canvas,
+    const Rect& bounds,
+    SkColor color,
+    const base::TimeDelta& elapsed_time,
+    absl::optional<SkScalar> stroke_width = absl::nullopt);
+
+// Paint a throbber in the "spinning" state, smoothly transitioning from a
+// previous "waiting" state described by |waiting_state|, which is an in-out
+// param.
+GFX_EXPORT void PaintThrobberSpinningAfterWaiting(
+    Canvas* canvas,
+    const Rect& bounds,
+    SkColor color,
+    const base::TimeDelta& elapsed_time,
+    ThrobberWaitingState* waiting_state,
+    absl::optional<SkScalar> stroke_width = absl::nullopt);
+
+// Paints a throbber in the "waiting" state (bouncing back and forth). Used when
+// waiting on a network response, for example.
+GFX_EXPORT void PaintNewThrobberWaiting(Canvas* canvas,
+                                        const RectF& throbber_container_bounds,
+                                        SkColor color,
+                                        const base::TimeDelta& elapsed_time);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PAINT_THROBBER_H_
diff --git a/ui/gfx/paint_vector_icon.cc b/ui/gfx/paint_vector_icon.cc
new file mode 100644
index 0000000..b998717
--- /dev/null
+++ b/ui/gfx/paint_vector_icon.cc
@@ -0,0 +1,607 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/paint_vector_icon.h"
+
+#include <algorithm>
+#include <map>
+#include <tuple>
+
+#include "base/i18n/rtl.h"
+#include "base/lazy_instance.h"
+#include "base/macros.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
+#include "base/trace_event/trace_event.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_flags.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "ui/gfx/animation/tween.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/image/canvas_image_source.h"
+#include "ui/gfx/scoped_canvas.h"
+#include "ui/gfx/vector_icon_types.h"
+#include "ui/gfx/vector_icon_utils.h"
+
+namespace gfx {
+
+namespace {
+
+// The default size of a single side of the square canvas to which path
+// coordinates are relative, in device independent pixels.
+constexpr int kReferenceSizeDip = 48;
+
+constexpr int kEmptyIconSize = -1;
+
+// Retrieves the specified CANVAS_DIMENSIONS size from a PathElement.
+int GetCanvasDimensions(const PathElement* path) {
+  if (!path)
+    return kEmptyIconSize;
+  return path[0].command == CANVAS_DIMENSIONS ? path[1].arg : kReferenceSizeDip;
+}
+
+// Retrieves the appropriate icon representation to draw when the pixel size
+// requested is |icon_size_px|.
+const VectorIconRep* GetRepForPxSize(const VectorIcon& icon, int icon_size_px) {
+  if (icon.is_empty())
+    return nullptr;
+
+  const VectorIconRep* best_rep = nullptr;
+
+  // Prefer an exact match. If none exists, prefer the largest rep that is an
+  // exact divisor of the icon size (e.g. 20 for a 40px icon). If none exists,
+  // return the smallest rep that is larger than the target. If none exists,
+  // use the largest rep. The rep array is sorted by size in descending order,
+  // so start at the back and work towards the front.
+  for (int i = static_cast<int>(icon.reps_size - 1); i >= 0; --i) {
+    const VectorIconRep* rep = &icon.reps[i];
+    int rep_size = GetCanvasDimensions(rep->path);
+    if (rep_size == icon_size_px)
+      return rep;
+
+    if (icon_size_px % rep_size == 0)
+      best_rep = rep;
+
+    if (rep_size > icon_size_px)
+      return best_rep ? best_rep : &icon.reps[i];
+  }
+  return best_rep ? best_rep : &icon.reps[0];
+}
+
+struct CompareIconDescription {
+  bool operator()(const IconDescription& a, const IconDescription& b) const {
+    const VectorIcon* a_icon = &a.icon;
+    const VectorIcon* b_icon = &b.icon;
+    const VectorIcon* a_badge = &a.badge_icon;
+    const VectorIcon* b_badge = &b.badge_icon;
+    return std::tie(a_icon, a.dip_size, a.color, a_badge) <
+           std::tie(b_icon, b.dip_size, b.color, b_badge);
+  }
+};
+
+// Helper that simplifies iterating over a sequence of PathElements.
+class PathParser {
+ public:
+  PathParser(const PathElement* path_elements, size_t path_size)
+      : path_elements_(path_elements), path_size_(path_size) {}
+
+  PathParser(const PathParser&) = delete;
+  PathParser& operator=(const PathParser&) = delete;
+
+  ~PathParser() {}
+
+  void Advance() { command_index_ += GetArgumentCount() + 1; }
+
+  bool HasCommandsRemaining() const { return command_index_ < path_size_; }
+
+  CommandType CurrentCommand() const {
+    return path_elements_[command_index_].command;
+  }
+
+  SkScalar GetArgument(int index) const {
+    DCHECK_LT(index, GetArgumentCount());
+    return path_elements_[command_index_ + 1 + index].arg;
+  }
+
+ private:
+  int GetArgumentCount() const {
+    switch (CurrentCommand()) {
+      case STROKE:
+      case H_LINE_TO:
+      case R_H_LINE_TO:
+      case V_LINE_TO:
+      case R_V_LINE_TO:
+      case CANVAS_DIMENSIONS:
+      case PATH_COLOR_ALPHA:
+        return 1;
+
+      case MOVE_TO:
+      case R_MOVE_TO:
+      case LINE_TO:
+      case R_LINE_TO:
+      case QUADRATIC_TO_SHORTHAND:
+      case R_QUADRATIC_TO_SHORTHAND:
+        return 2;
+
+      case CIRCLE:
+        return 3;
+
+      case PATH_COLOR_ARGB:
+      case CUBIC_TO_SHORTHAND:
+      case CLIP:
+      case QUADRATIC_TO:
+      case R_QUADRATIC_TO:
+      case OVAL:
+        return 4;
+
+      case ROUND_RECT:
+        return 5;
+
+      case CUBIC_TO:
+      case R_CUBIC_TO:
+        return 6;
+
+      case ARC_TO:
+      case R_ARC_TO:
+        return 7;
+
+      case NEW_PATH:
+      case PATH_MODE_CLEAR:
+      case CAP_SQUARE:
+      case CLOSE:
+      case DISABLE_AA:
+      case FLIPS_IN_RTL:
+        return 0;
+    }
+
+    NOTREACHED();
+    return 0;
+  }
+
+  const PathElement* path_elements_;
+  size_t path_size_;
+  size_t command_index_ = 0;
+};
+
+// Translates a string such as "MOVE_TO" into a command such as MOVE_TO.
+CommandType CommandFromString(const std::string& source) {
+#define RETURN_IF_IS(command) \
+  if (source == #command)     \
+    return command;
+
+  RETURN_IF_IS(NEW_PATH);
+  RETURN_IF_IS(PATH_COLOR_ALPHA);
+  RETURN_IF_IS(PATH_COLOR_ARGB);
+  RETURN_IF_IS(PATH_MODE_CLEAR);
+  RETURN_IF_IS(STROKE);
+  RETURN_IF_IS(CAP_SQUARE);
+  RETURN_IF_IS(MOVE_TO);
+  RETURN_IF_IS(R_MOVE_TO);
+  RETURN_IF_IS(ARC_TO);
+  RETURN_IF_IS(R_ARC_TO);
+  RETURN_IF_IS(LINE_TO);
+  RETURN_IF_IS(R_LINE_TO);
+  RETURN_IF_IS(H_LINE_TO);
+  RETURN_IF_IS(R_H_LINE_TO);
+  RETURN_IF_IS(V_LINE_TO);
+  RETURN_IF_IS(R_V_LINE_TO);
+  RETURN_IF_IS(CUBIC_TO);
+  RETURN_IF_IS(R_CUBIC_TO);
+  RETURN_IF_IS(CUBIC_TO_SHORTHAND);
+  RETURN_IF_IS(QUADRATIC_TO);
+  RETURN_IF_IS(R_QUADRATIC_TO);
+  RETURN_IF_IS(QUADRATIC_TO_SHORTHAND);
+  RETURN_IF_IS(R_QUADRATIC_TO_SHORTHAND);
+  RETURN_IF_IS(CIRCLE);
+  RETURN_IF_IS(OVAL);
+  RETURN_IF_IS(ROUND_RECT);
+  RETURN_IF_IS(CLOSE);
+  RETURN_IF_IS(CANVAS_DIMENSIONS);
+  RETURN_IF_IS(CLIP);
+  RETURN_IF_IS(DISABLE_AA);
+  RETURN_IF_IS(FLIPS_IN_RTL);
+#undef RETURN_IF_IS
+
+  NOTREACHED() << "Unrecognized command: " << source;
+  return CLOSE;
+}
+
+std::vector<PathElement> PathFromSource(const std::string& source) {
+  std::vector<PathElement> path;
+  std::vector<std::string> pieces = base::SplitString(
+      source, "\n ,f", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  for (const auto& piece : pieces) {
+    double value = 0;
+    int hex_value = 0;
+    if (base::StringToDouble(piece, &value))
+      path.push_back(PathElement(SkDoubleToScalar(value)));
+    else if (base::HexStringToInt(piece, &hex_value))
+      path.push_back(PathElement(SkIntToScalar(hex_value)));
+    else
+      path.push_back(PathElement(CommandFromString(piece)));
+  }
+  return path;
+}
+
+bool IsCommandTypeCurve(CommandType command) {
+  return command == CUBIC_TO || command == R_CUBIC_TO ||
+         command == CUBIC_TO_SHORTHAND || command == QUADRATIC_TO ||
+         command == R_QUADRATIC_TO || command == QUADRATIC_TO_SHORTHAND ||
+         command == R_QUADRATIC_TO_SHORTHAND;
+}
+
+void PaintPath(Canvas* canvas,
+               const PathElement* path_elements,
+               size_t path_size,
+               int dip_size,
+               SkColor color) {
+  int canvas_size = kReferenceSizeDip;
+  std::vector<SkPath> paths;
+  std::vector<cc::PaintFlags> flags_array;
+  SkRect clip_rect = SkRect::MakeEmpty();
+  bool flips_in_rtl = false;
+  CommandType previous_command_type = NEW_PATH;
+
+  for (PathParser parser(path_elements, path_size);
+       parser.HasCommandsRemaining(); parser.Advance()) {
+    auto arg = [&parser](int i) { return parser.GetArgument(i); };
+    const CommandType command_type = parser.CurrentCommand();
+    auto start_new_path = [&paths]() {
+      paths.push_back(SkPath());
+      paths.back().setFillType(SkPathFillType::kEvenOdd);
+    };
+    auto start_new_flags = [&flags_array, &color]() {
+      flags_array.push_back(cc::PaintFlags());
+      flags_array.back().setColor(color);
+      flags_array.back().setAntiAlias(true);
+      flags_array.back().setStrokeCap(cc::PaintFlags::kRound_Cap);
+    };
+
+    if (paths.empty() || command_type == NEW_PATH) {
+      start_new_path();
+      start_new_flags();
+    }
+
+    SkPath& path = paths.back();
+    cc::PaintFlags& flags = flags_array.back();
+    switch (command_type) {
+      // Handled above.
+      case NEW_PATH:
+        break;
+
+      case PATH_COLOR_ALPHA:
+        flags.setAlpha(SkScalarFloorToInt(arg(0)));
+        break;
+
+      case PATH_COLOR_ARGB:
+        flags.setColor(SkColorSetARGB(
+            SkScalarFloorToInt(arg(0)), SkScalarFloorToInt(arg(1)),
+            SkScalarFloorToInt(arg(2)), SkScalarFloorToInt(arg(3))));
+        break;
+
+      case PATH_MODE_CLEAR:
+        flags.setBlendMode(SkBlendMode::kClear);
+        break;
+
+      case STROKE:
+        flags.setStyle(cc::PaintFlags::kStroke_Style);
+        flags.setStrokeWidth(arg(0));
+        break;
+
+      case CAP_SQUARE:
+        flags.setStrokeCap(cc::PaintFlags::kSquare_Cap);
+        break;
+
+      case MOVE_TO:
+        path.moveTo(arg(0), arg(1));
+        break;
+
+      case R_MOVE_TO:
+        if (previous_command_type == CLOSE) {
+          // This triggers injectMoveToIfNeeded() so that the next subpath
+          // will start at the correct place. See [
+          // https://www.w3.org/TR/SVG/paths.html#PathDataClosePathCommand ].
+          path.rLineTo(0, 0);
+        }
+
+        path.rMoveTo(arg(0), arg(1));
+        break;
+
+      case ARC_TO:
+      case R_ARC_TO: {
+        SkScalar rx = arg(0);
+        SkScalar ry = arg(1);
+        SkScalar angle = arg(2);
+        SkScalar large_arc_flag = arg(3);
+        SkScalar arc_sweep_flag = arg(4);
+        SkScalar x = arg(5);
+        SkScalar y = arg(6);
+        SkPath::ArcSize arc_size =
+            large_arc_flag ? SkPath::kLarge_ArcSize : SkPath::kSmall_ArcSize;
+        SkPathDirection direction =
+            arc_sweep_flag ? SkPathDirection::kCW : SkPathDirection::kCCW;
+
+        if (command_type == ARC_TO)
+          path.arcTo(rx, ry, angle, arc_size, direction, x, y);
+        else
+          path.rArcTo(rx, ry, angle, arc_size, direction, x, y);
+        break;
+      }
+
+      case LINE_TO:
+        path.lineTo(arg(0), arg(1));
+        break;
+
+      case R_LINE_TO:
+        path.rLineTo(arg(0), arg(1));
+        break;
+
+      case H_LINE_TO: {
+        SkPoint last_point;
+        path.getLastPt(&last_point);
+        path.lineTo(arg(0), last_point.fY);
+        break;
+      }
+
+      case R_H_LINE_TO:
+        path.rLineTo(arg(0), 0);
+        break;
+
+      case V_LINE_TO: {
+        SkPoint last_point;
+        path.getLastPt(&last_point);
+        path.lineTo(last_point.fX, arg(0));
+        break;
+      }
+
+      case R_V_LINE_TO:
+        path.rLineTo(0, arg(0));
+        break;
+
+      case CUBIC_TO:
+        path.cubicTo(arg(0), arg(1), arg(2), arg(3), arg(4), arg(5));
+        break;
+
+      case R_CUBIC_TO:
+        path.rCubicTo(arg(0), arg(1), arg(2), arg(3), arg(4), arg(5));
+        break;
+
+      case CUBIC_TO_SHORTHAND:
+      case QUADRATIC_TO_SHORTHAND:
+      case R_QUADRATIC_TO_SHORTHAND: {
+        // Compute the first control point (|x1| and |y1|) as the reflection of
+        // the last control point on the previous command relative to the
+        // current point. If there is no previous command or if the previous
+        // command is not a Bezier curve, the first control point is coincident
+        // with the current point. Refer to the SVG path specs for further
+        // details.
+        // Note that |x1| and |y1| will correspond to the sole control point if
+        // calculating a quadratic curve.
+        SkPoint last_point;
+        path.getLastPt(&last_point);
+        SkScalar delta_x = 0;
+        SkScalar delta_y = 0;
+        if (IsCommandTypeCurve(previous_command_type)) {
+          SkPoint last_control_point = path.getPoint(path.countPoints() - 2);
+          // We find what the delta was between the last curve's starting point
+          // and the control point. This difference is what we will reflect on
+          // the current point, creating our new control point.
+          delta_x = last_point.fX - last_control_point.fX;
+          delta_y = last_point.fY - last_control_point.fY;
+        }
+
+        SkScalar x1 = last_point.fX + delta_x;
+        SkScalar y1 = last_point.fY + delta_y;
+        if (command_type == CUBIC_TO_SHORTHAND)
+          path.cubicTo(x1, y1, arg(0), arg(1), arg(2), arg(3));
+        else if (command_type == QUADRATIC_TO_SHORTHAND)
+          path.quadTo(x1, y1, arg(0), arg(1));
+        else if (command_type == R_QUADRATIC_TO_SHORTHAND)
+          path.rQuadTo(x1, y1, arg(0), arg(1));
+        break;
+      }
+
+      case QUADRATIC_TO:
+        path.quadTo(arg(0), arg(1), arg(2), arg(3));
+        break;
+
+      case R_QUADRATIC_TO:
+        path.rQuadTo(arg(0), arg(1), arg(2), arg(3));
+        break;
+
+      case OVAL: {
+        SkScalar x = arg(0);
+        SkScalar y = arg(1);
+        SkScalar rx = arg(2);
+        SkScalar ry = arg(3);
+        path.addOval(SkRect::MakeLTRB(x - rx, y - ry, x + rx, y + ry));
+        break;
+      }
+
+      case CIRCLE:
+        path.addCircle(arg(0), arg(1), arg(2));
+        break;
+
+      case ROUND_RECT:
+        path.addRoundRect(SkRect::MakeXYWH(arg(0), arg(1), arg(2), arg(3)),
+                          arg(4), arg(4));
+        break;
+
+      case CLOSE:
+        path.close();
+        break;
+
+      case CANVAS_DIMENSIONS:
+        canvas_size = SkScalarTruncToInt(arg(0));
+        break;
+
+      case CLIP:
+        clip_rect = SkRect::MakeXYWH(arg(0), arg(1), arg(2), arg(3));
+        break;
+
+      case DISABLE_AA:
+        flags.setAntiAlias(false);
+        break;
+
+      case FLIPS_IN_RTL:
+        flips_in_rtl = true;
+        break;
+    }
+
+    previous_command_type = command_type;
+  }
+
+  ScopedCanvas scoped_canvas(canvas);
+
+  if (dip_size != canvas_size) {
+    SkScalar scale = SkIntToScalar(dip_size) / SkIntToScalar(canvas_size);
+    canvas->sk_canvas()->scale(scale, scale);
+  }
+
+  if (flips_in_rtl)
+    scoped_canvas.FlipIfRTL(canvas_size);
+
+  if (!clip_rect.isEmpty())
+    canvas->sk_canvas()->clipRect(clip_rect);
+
+  DCHECK_EQ(flags_array.size(), paths.size());
+  for (size_t i = 0; i < paths.size(); ++i)
+    canvas->DrawPath(paths[i], flags_array[i]);
+}
+
+class VectorIconSource : public CanvasImageSource {
+ public:
+  explicit VectorIconSource(const IconDescription& data)
+      : CanvasImageSource(Size(data.dip_size, data.dip_size)), data_(data) {}
+
+  VectorIconSource(const std::string& definition, int dip_size, SkColor color)
+      : CanvasImageSource(Size(dip_size, dip_size)),
+        data_(kNoneIcon, dip_size, color, &kNoneIcon),
+        path_(PathFromSource(definition)) {}
+
+  VectorIconSource(const VectorIconSource&) = delete;
+  VectorIconSource& operator=(const VectorIconSource&) = delete;
+
+  ~VectorIconSource() override {}
+
+  // CanvasImageSource:
+  bool HasRepresentationAtAllScales() const override {
+    return !data_.icon.is_empty();
+  }
+
+  void Draw(Canvas* canvas) override {
+    if (path_.empty()) {
+      PaintVectorIcon(canvas, data_.icon, size_.width(), data_.color);
+      if (!data_.badge_icon.is_empty())
+        PaintVectorIcon(canvas, data_.badge_icon, size_.width(), data_.color);
+    } else {
+      PaintPath(canvas, path_.data(), path_.size(), size_.width(), data_.color);
+    }
+  }
+
+ private:
+  const IconDescription data_;
+  const std::vector<PathElement> path_;
+};
+
+// This class caches vector icons (as ImageSkia) so they don't have to be drawn
+// more than once. This also guarantees the backing data for the images returned
+// by CreateVectorIcon will persist in memory until program termination.
+class VectorIconCache {
+ public:
+  VectorIconCache() {}
+
+  VectorIconCache(const VectorIconCache&) = delete;
+  VectorIconCache& operator=(const VectorIconCache&) = delete;
+
+  ~VectorIconCache() {}
+
+  ImageSkia GetOrCreateIcon(const IconDescription& description) {
+    auto iter = images_.find(description);
+    if (iter != images_.end())
+      return iter->second;
+
+    ImageSkia icon_image(std::make_unique<VectorIconSource>(description),
+                         Size(description.dip_size, description.dip_size));
+    images_.emplace(description, icon_image);
+    return icon_image;
+  }
+
+ private:
+  std::map<IconDescription, ImageSkia, CompareIconDescription> images_;
+};
+
+static base::LazyInstance<VectorIconCache>::DestructorAtExit g_icon_cache =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+IconDescription::IconDescription(const IconDescription& other) = default;
+
+IconDescription::IconDescription(const VectorIcon& icon,
+                                 int dip_size,
+                                 SkColor color,
+                                 const VectorIcon* badge_icon)
+    : icon(icon),
+      dip_size(dip_size),
+      color(color),
+      badge_icon(badge_icon ? *badge_icon : kNoneIcon) {
+  if (dip_size == 0)
+    this->dip_size = GetDefaultSizeOfVectorIcon(icon);
+}
+
+IconDescription::~IconDescription() {}
+
+const VectorIcon kNoneIcon = {};
+
+void PaintVectorIcon(Canvas* canvas, const VectorIcon& icon, SkColor color) {
+  PaintVectorIcon(canvas, icon, GetDefaultSizeOfVectorIcon(icon), color);
+}
+
+void PaintVectorIcon(Canvas* canvas,
+                     const VectorIcon& icon,
+                     int dip_size,
+                     SkColor color) {
+  DCHECK(!icon.is_empty());
+  for (size_t i = 0; i < icon.reps_size; ++i)
+    DCHECK(icon.reps[i].path_size > 0);
+  const int px_size = base::ClampCeil(canvas->image_scale() * dip_size);
+  const VectorIconRep* rep = GetRepForPxSize(icon, px_size);
+  PaintPath(canvas, rep->path, rep->path_size, dip_size, color);
+}
+
+ImageSkia CreateVectorIcon(const IconDescription& params) {
+  if (params.icon.is_empty())
+    return ImageSkia();
+
+  return g_icon_cache.Get().GetOrCreateIcon(params);
+}
+
+ImageSkia CreateVectorIcon(const VectorIcon& icon, SkColor color) {
+  return CreateVectorIcon(icon, GetDefaultSizeOfVectorIcon(icon), color);
+}
+
+ImageSkia CreateVectorIcon(const VectorIcon& icon,
+                           int dip_size,
+                           SkColor color) {
+  return CreateVectorIcon(IconDescription(icon, dip_size, color, &kNoneIcon));
+}
+
+ImageSkia CreateVectorIconWithBadge(const VectorIcon& icon,
+                                    int dip_size,
+                                    SkColor color,
+                                    const VectorIcon& badge_icon) {
+  return CreateVectorIcon(IconDescription(icon, dip_size, color, &badge_icon));
+}
+
+ImageSkia CreateVectorIconFromSource(const std::string& source,
+                                     int dip_size,
+                                     SkColor color) {
+  return CanvasImageSource::MakeImageSkia<VectorIconSource>(source, dip_size,
+                                                            color);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/paint_vector_icon.h b/ui/gfx/paint_vector_icon.h
new file mode 100644
index 0000000..c005bfa
--- /dev/null
+++ b/ui/gfx/paint_vector_icon.h
@@ -0,0 +1,86 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PAINT_VECTOR_ICON_H_
+#define UI_GFX_PAINT_VECTOR_ICON_H_
+
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace gfx {
+
+class Canvas;
+struct VectorIcon;
+
+// Describes an instance of an icon: an icon definition and a set of drawing
+// parameters.
+struct GFX_EXPORT IconDescription {
+  IconDescription(const IconDescription& other);
+
+  // If |dip_size| is 0, the default size of |icon| will be used.
+  // If |badge_icon| is null, the icon has no badge.
+  IconDescription(const VectorIcon& icon,
+                  int dip_size = 0,
+                  SkColor color = gfx::kPlaceholderColor,
+                  const VectorIcon* badge_icon = nullptr);
+
+  ~IconDescription();
+
+  const VectorIcon& icon;
+  int dip_size;
+  SkColor color;
+  const VectorIcon& badge_icon;
+};
+
+GFX_EXPORT extern const VectorIcon kNoneIcon;
+
+// Draws a vector icon identified by |id| onto |canvas| at (0, 0). |color| is
+// used as the fill. The size will come from the .icon file (the 1x version, if
+// multiple versions exist).
+GFX_EXPORT void PaintVectorIcon(Canvas* canvas,
+                                const VectorIcon& icon,
+                                SkColor color);
+
+// As above, with a specified size. |dip_size| is the length of a single edge
+// of the square icon, in device independent pixels.
+GFX_EXPORT void PaintVectorIcon(Canvas* canvas,
+                                const VectorIcon& icon,
+                                int dip_size,
+                                SkColor color);
+
+// Creates an ImageSkia which will render the icon on demand.
+// TODO(estade): update clients to use this version and remove the other
+// CreateVectorIcon()s.
+GFX_EXPORT ImageSkia CreateVectorIcon(const IconDescription& params);
+
+// Creates an ImageSkia which will render the icon on demand. The size will come
+// from the .icon file (the 1x version, if multiple versions exist).
+GFX_EXPORT ImageSkia CreateVectorIcon(const VectorIcon& icon, SkColor color);
+
+// As above, but creates the image at the given size.
+GFX_EXPORT ImageSkia CreateVectorIcon(const VectorIcon& icon,
+                                      int dip_size,
+                                      SkColor color);
+
+// As above, but also paints a badge defined by |badge_id| on top of the icon.
+// The badge uses the same canvas size and default color as the icon.
+GFX_EXPORT ImageSkia CreateVectorIconWithBadge(const VectorIcon& icon,
+                                               int dip_size,
+                                               SkColor color,
+                                               const VectorIcon& badge_icon);
+
+#if defined(GFX_VECTOR_ICONS_UNSAFE) || defined(GFX_IMPLEMENTATION)
+// Takes a string of the format expected of .icon files and renders onto
+// a canvas. This should only be used as a debugging aid and should never be
+// used in production code.
+GFX_EXPORT ImageSkia CreateVectorIconFromSource(const std::string& source,
+                                                int dip_size,
+                                                SkColor color);
+#endif
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PAINT_VECTOR_ICON_H_
diff --git a/ui/gfx/paint_vector_icon_unittest.cc b/ui/gfx/paint_vector_icon_unittest.cc
new file mode 100644
index 0000000..ff7bd2e
--- /dev/null
+++ b/ui/gfx/paint_vector_icon_unittest.cc
@@ -0,0 +1,291 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/paint_vector_icon.h"
+
+#include <gtest/gtest.h>
+#include <vector>
+
+#include "base/cxx17_backports.h"
+#include "base/i18n/rtl.h"
+#include "cc/paint/paint_record.h"
+#include "cc/paint/paint_recorder.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/vector_icon_types.h"
+
+namespace gfx {
+
+namespace {
+
+SkColor GetColorAtTopLeft(const Canvas& canvas) {
+  return canvas.GetBitmap().getColor(0, 0);
+}
+
+class MockCanvas : public SkCanvas {
+ public:
+  MockCanvas(int width, int height) : SkCanvas(width, height) {}
+
+  MockCanvas(const MockCanvas&) = delete;
+  MockCanvas& operator=(const MockCanvas&) = delete;
+
+  // SkCanvas overrides:
+  void onDrawPath(const SkPath& path, const SkPaint& paint) override {
+    paths_.push_back(path);
+  }
+
+  const std::vector<SkPath>& paths() const { return paths_; }
+
+ private:
+  std::vector<SkPath> paths_;
+};
+
+// Tests that a relative move to command (R_MOVE_TO) after a close command
+// (CLOSE) uses the correct starting point. See crbug.com/697497
+TEST(VectorIconTest, RelativeMoveToAfterClose) {
+  cc::PaintRecorder recorder;
+  Canvas canvas(recorder.beginRecording(100, 100), 1.0f);
+
+  const PathElement elements[] = {
+      MOVE_TO, 4, 5, LINE_TO, 10, 11, CLOSE,
+      // This move should use (4, 5) as the start point rather than (10, 11).
+      R_MOVE_TO, 20, 21, R_LINE_TO, 50, 51};
+  const VectorIconRep rep_list[] = {{elements, base::size(elements)}};
+  const VectorIcon icon = {rep_list, 1u};
+
+  PaintVectorIcon(&canvas, icon, 100, SK_ColorMAGENTA);
+  sk_sp<cc::PaintRecord> record = recorder.finishRecordingAsPicture();
+
+  MockCanvas mock(100, 100);
+  record->Playback(&mock);
+
+  ASSERT_EQ(1U, mock.paths().size());
+  SkPoint last_point;
+  EXPECT_TRUE(mock.paths()[0].getLastPt(&last_point));
+  EXPECT_EQ(SkIntToScalar(74), last_point.x());
+  EXPECT_EQ(SkIntToScalar(77), last_point.y());
+}
+
+TEST(VectorIconTest, FlipsInRtl) {
+  // Set the locale to a rtl language otherwise FLIPS_IN_RTL will do nothing.
+  base::i18n::SetICUDefaultLocale("he");
+  ASSERT_TRUE(base::i18n::IsRTL());
+
+  const int canvas_size = 20;
+  const SkColor color = SK_ColorWHITE;
+
+  Canvas canvas(gfx::Size(canvas_size, canvas_size), 1.0f, true);
+
+  // Create a 20x20 square icon which has FLIPS_IN_RTL, and CANVAS_DIMENSIONS
+  // are twice as large as |canvas|.
+  const PathElement elements[] = {CANVAS_DIMENSIONS,
+                                  2 * canvas_size,
+                                  FLIPS_IN_RTL,
+                                  MOVE_TO,
+                                  10,
+                                  10,
+                                  R_H_LINE_TO,
+                                  20,
+                                  R_V_LINE_TO,
+                                  20,
+                                  R_H_LINE_TO,
+                                  -20,
+                                  CLOSE};
+  const VectorIconRep rep_list[] = {{elements, base::size(elements)}};
+  const VectorIcon icon = {rep_list, 1u};
+  PaintVectorIcon(&canvas, icon, canvas_size, color);
+
+  // Count the number of pixels in the canvas.
+  auto bitmap = canvas.GetBitmap();
+  int colored_pixel_count = 0;
+  for (int i = 0; i < bitmap.width(); ++i) {
+    for (int j = 0; j < bitmap.height(); ++j) {
+      if (bitmap.getColor(i, j) == color)
+        colored_pixel_count++;
+    }
+  }
+
+  // Verify that the amount of colored pixels on the canvas bitmap should be a
+  // quarter of the original icon, since each side should be scaled down by a
+  // factor of two.
+  EXPECT_EQ(100, colored_pixel_count);
+}
+
+TEST(VectorIconTest, CorrectSizePainted) {
+  // Create a set of 5 icons reps, sized {48, 32, 24, 20, 16} for the test icon.
+  // Color each of them differently so they can be differentiated (the parts of
+  // an icon painted with PATH_COLOR_ARGB will not be overwritten by the color
+  // provided to it at creation time).
+  const SkColor kPath48Color = SK_ColorRED;
+  const PathElement elements48[] = {CANVAS_DIMENSIONS,
+                                    48,
+                                    PATH_COLOR_ARGB,
+                                    0xFF,
+                                    SkColorGetR(kPath48Color),
+                                    SkColorGetG(kPath48Color),
+                                    SkColorGetB(kPath48Color),
+                                    MOVE_TO,
+                                    0,
+                                    0,
+                                    H_LINE_TO,
+                                    48,
+                                    V_LINE_TO,
+                                    48,
+                                    H_LINE_TO,
+                                    0,
+                                    V_LINE_TO,
+                                    0,
+                                    CLOSE};
+  const SkColor kPath32Color = SK_ColorGREEN;
+  const PathElement elements32[] = {CANVAS_DIMENSIONS,
+                                    32,
+                                    PATH_COLOR_ARGB,
+                                    0xFF,
+                                    SkColorGetR(kPath32Color),
+                                    SkColorGetG(kPath32Color),
+                                    SkColorGetB(kPath32Color),
+                                    MOVE_TO,
+                                    0,
+                                    0,
+                                    H_LINE_TO,
+                                    32,
+                                    V_LINE_TO,
+                                    32,
+                                    H_LINE_TO,
+                                    0,
+                                    V_LINE_TO,
+                                    0,
+                                    CLOSE};
+  const SkColor kPath24Color = SK_ColorBLUE;
+  const PathElement elements24[] = {CANVAS_DIMENSIONS,
+                                    24,
+                                    PATH_COLOR_ARGB,
+                                    0xFF,
+                                    SkColorGetR(kPath24Color),
+                                    SkColorGetG(kPath24Color),
+                                    SkColorGetB(kPath24Color),
+                                    MOVE_TO,
+                                    0,
+                                    0,
+                                    H_LINE_TO,
+                                    24,
+                                    V_LINE_TO,
+                                    24,
+                                    H_LINE_TO,
+                                    0,
+                                    V_LINE_TO,
+                                    0,
+                                    CLOSE};
+  const SkColor kPath20Color = SK_ColorYELLOW;
+  const PathElement elements20[] = {CANVAS_DIMENSIONS,
+                                    20,
+                                    PATH_COLOR_ARGB,
+                                    0xFF,
+                                    SkColorGetR(kPath20Color),
+                                    SkColorGetG(kPath20Color),
+                                    SkColorGetB(kPath20Color),
+                                    MOVE_TO,
+                                    0,
+                                    0,
+                                    H_LINE_TO,
+                                    20,
+                                    V_LINE_TO,
+                                    20,
+                                    H_LINE_TO,
+                                    0,
+                                    V_LINE_TO,
+                                    0,
+                                    CLOSE};
+  const SkColor kPath16Color = SK_ColorCYAN;
+  const PathElement elements16[] = {CANVAS_DIMENSIONS,
+                                    16,
+                                    PATH_COLOR_ARGB,
+                                    0xFF,
+                                    SkColorGetR(kPath16Color),
+                                    SkColorGetG(kPath16Color),
+                                    SkColorGetB(kPath16Color),
+                                    MOVE_TO,
+                                    0,
+                                    0,
+                                    H_LINE_TO,
+                                    16,
+                                    V_LINE_TO,
+                                    16,
+                                    H_LINE_TO,
+                                    0,
+                                    V_LINE_TO,
+                                    0,
+                                    CLOSE};
+  // VectorIconReps are always sorted in descending order of size.
+  const VectorIconRep rep_list[] = {{elements48, base::size(elements48)},
+                                    {elements32, base::size(elements32)},
+                                    {elements24, base::size(elements24)},
+                                    {elements20, base::size(elements20)},
+                                    {elements16, base::size(elements16)}};
+  const VectorIcon icon = {rep_list, 5u};
+
+  // Test exact sizes paint the correctly sized icon, including the largest and
+  // smallest icon.
+  Canvas canvas_100(gfx::Size(100, 100), 1.0, true);
+  PaintVectorIcon(&canvas_100, icon, 48, SK_ColorBLACK);
+  EXPECT_EQ(kPath48Color, GetColorAtTopLeft(canvas_100));
+  PaintVectorIcon(&canvas_100, icon, 32, SK_ColorBLACK);
+  EXPECT_EQ(kPath32Color, GetColorAtTopLeft(canvas_100));
+  PaintVectorIcon(&canvas_100, icon, 16, SK_ColorBLACK);
+  EXPECT_EQ(kPath16Color, GetColorAtTopLeft(canvas_100));
+
+  // The largest icon may be upscaled to a size larger than what it was
+  // designed for.
+  PaintVectorIcon(&canvas_100, icon, 50, SK_ColorBLACK);
+  EXPECT_EQ(kPath48Color, GetColorAtTopLeft(canvas_100));
+
+  // Other requests will be satisfied by downscaling.
+  PaintVectorIcon(&canvas_100, icon, 27, SK_ColorBLACK);
+  EXPECT_EQ(kPath32Color, GetColorAtTopLeft(canvas_100));
+  PaintVectorIcon(&canvas_100, icon, 8, SK_ColorBLACK);
+  EXPECT_EQ(kPath16Color, GetColorAtTopLeft(canvas_100));
+
+  // Except in cases where an exact divisor is found.
+  PaintVectorIcon(&canvas_100, icon, 40, SK_ColorBLACK);
+  EXPECT_EQ(kPath20Color, GetColorAtTopLeft(canvas_100));
+  PaintVectorIcon(&canvas_100, icon, 64, SK_ColorBLACK);
+  EXPECT_EQ(kPath32Color, GetColorAtTopLeft(canvas_100));
+
+  // Test icons at a scale factor < 100%, still with an exact size, paint the
+  // correctly sized icon.
+  Canvas canvas_75(gfx::Size(100, 100), 0.75, true);
+  PaintVectorIcon(&canvas_75, icon, 32, SK_ColorBLACK);  // 32 * 0.75 = 24.
+  EXPECT_EQ(kPath24Color, GetColorAtTopLeft(canvas_75));
+
+  // Test icons at a scale factor > 100%, still with an exact size, paint the
+  // correctly sized icon.
+  Canvas canvas_125(gfx::Size(100, 100), 1.25, true);
+  PaintVectorIcon(&canvas_125, icon, 16, SK_ColorBLACK);  // 16 * 1.25 = 20.
+  EXPECT_EQ(kPath20Color, GetColorAtTopLeft(canvas_125));
+
+  // Inexact sizes at scale factors < 100%.
+  PaintVectorIcon(&canvas_75, icon, 12, SK_ColorBLACK);  // 12 * 0.75 = 9.
+  EXPECT_EQ(kPath16Color, GetColorAtTopLeft(canvas_75));
+  PaintVectorIcon(&canvas_75, icon, 28, SK_ColorBLACK);  // 28 * 0.75 = 21.
+  EXPECT_EQ(kPath24Color, GetColorAtTopLeft(canvas_75));
+
+  // Inexact sizes at scale factors > 100%.
+  PaintVectorIcon(&canvas_125, icon, 12, SK_ColorBLACK);  // 12 * 1.25 = 15.
+  EXPECT_EQ(kPath16Color, GetColorAtTopLeft(canvas_125));
+  PaintVectorIcon(&canvas_125, icon, 28, SK_ColorBLACK);  // 28 * 1.25 = 35.
+  EXPECT_EQ(kPath48Color, GetColorAtTopLeft(canvas_125));
+
+  // Painting without a requested size will default to the smallest icon rep.
+  PaintVectorIcon(&canvas_100, icon, SK_ColorBLACK);
+  EXPECT_EQ(kPath16Color, GetColorAtTopLeft(canvas_100));
+  // But doing this in another scale factor should assume the smallest icon rep
+  // size, then scale it up by the DSF.
+  PaintVectorIcon(&canvas_125, icon, SK_ColorBLACK);  // 16 * 1.25 = 20.
+  EXPECT_EQ(kPath20Color, GetColorAtTopLeft(canvas_125));
+}
+
+}  // namespace
+
+}  // namespace gfx
diff --git a/ui/gfx/path_mac.h b/ui/gfx/path_mac.h
new file mode 100644
index 0000000..f20fa62
--- /dev/null
+++ b/ui/gfx/path_mac.h
@@ -0,0 +1,21 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PATH_MAC_H_
+#define UI_GFX_PATH_MAC_H_
+
+#include "ui/gfx/gfx_export.h"
+
+@class NSBezierPath;
+class SkPath;
+
+namespace gfx {
+
+// Returns an autoreleased NSBezierPath corresponding to |path|. Caller should
+// call retain on the returned object, if it wishes to take ownership.
+GFX_EXPORT NSBezierPath* CreateNSBezierPathFromSkPath(const SkPath& path);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PATH_MAC_H_
diff --git a/ui/gfx/path_mac.mm b/ui/gfx/path_mac.mm
new file mode 100644
index 0000000..fd82ad9
--- /dev/null
+++ b/ui/gfx/path_mac.mm
@@ -0,0 +1,129 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#import "ui/gfx/path_mac.h"
+
+#include <ostream>
+
+#import <Cocoa/Cocoa.h>
+
+#include "base/cxx17_backports.h"
+#include "base/notreached.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "third_party/skia/include/core/SkRegion.h"
+
+namespace {
+
+// Convert a quadratic bezier curve to a cubic bezier curve. Based on the
+// implementation of the private SkConvertQuadToCubic method inside Skia.
+void ConvertQuadToCubicBezier(NSPoint quad[3], NSPoint cubic[4]) {
+  // The resultant cubic will have the same endpoints.
+  cubic[0] = quad[0];
+  cubic[3] = quad[2];
+
+  const double scale = 2.0 / 3.0;
+
+  cubic[1].x = quad[0].x + scale * (quad[1].x - quad[0].x);
+  cubic[1].y = quad[0].y + scale * (quad[1].y - quad[0].y);
+
+  cubic[2].x = quad[2].x + scale * (quad[1].x - quad[2].x);
+  cubic[2].y = quad[2].y + scale * (quad[1].y - quad[2].y);
+}
+
+}  // namespace
+
+namespace gfx {
+
+NSBezierPath* CreateNSBezierPathFromSkPath(const SkPath& path) {
+  NSBezierPath* result = [NSBezierPath bezierPath];
+  SkPath::RawIter iter(path);
+  SkPoint sk_points[4] = {{0.0}};
+  SkPath::Verb verb;
+  NSPoint points[4];
+  while ((verb = iter.next(sk_points)) != SkPath::kDone_Verb) {
+    for (size_t i = 0; i < base::size(points); i++)
+      points[i] = NSMakePoint(sk_points[i].x(), sk_points[i].y());
+
+    switch (verb) {
+      case SkPath::kMove_Verb: {
+        [result moveToPoint:points[0]];
+        break;
+      }
+      case SkPath::kLine_Verb: {
+        DCHECK(NSEqualPoints([result currentPoint], points[0]));
+        [result lineToPoint:points[1]];
+        break;
+      }
+      case SkPath::kQuad_Verb: {
+        DCHECK(NSEqualPoints([result currentPoint], points[0]));
+        NSPoint quad[] = {points[0], points[1], points[2]};
+        // NSBezierPath does not support quadratic bezier curves. Hence convert
+        // to cubic bezier curve.
+        ConvertQuadToCubicBezier(quad, points);
+        [result curveToPoint:points[3]
+               controlPoint1:points[1]
+               controlPoint2:points[2]];
+        break;
+      }
+      case SkPath::kConic_Verb: {
+        DCHECK(NSEqualPoints([result currentPoint], points[0]));
+        // Approximate with quads. Use two for now, increase if more precision
+        // is needed.
+        const size_t kSubdivisionLevels = 1;
+        const size_t kQuadCount = 1 << kSubdivisionLevels;
+        // The quads will share endpoints, so we need one more point than twice
+        // the number of quads.
+        const size_t kPointCount = 1 + 2 * kQuadCount;
+        SkPoint quads[kPointCount];
+        SkPath::ConvertConicToQuads(sk_points[0], sk_points[1], sk_points[2],
+                                    iter.conicWeight(), quads,
+                                    kSubdivisionLevels);
+        NSPoint ns_quads[kPointCount];
+        for (size_t i = 0; i < kPointCount; i++)
+          ns_quads[i] = NSMakePoint(quads[i].x(), quads[i].y());
+
+        for (size_t i = 0; i < kQuadCount; i++) {
+          NSPoint quad[] = {ns_quads[2 * i], ns_quads[2 * i + 1],
+                            ns_quads[2 * i + 2]};
+          ConvertQuadToCubicBezier(quad, points);
+          DCHECK(NSEqualPoints([result currentPoint], points[0]));
+          [result curveToPoint:points[3]
+                 controlPoint1:points[1]
+                 controlPoint2:points[2]];
+        }
+        break;
+      }
+      case SkPath::kCubic_Verb: {
+        DCHECK(NSEqualPoints([result currentPoint], points[0]));
+        [result curveToPoint:points[3]
+               controlPoint1:points[1]
+               controlPoint2:points[2]];
+        break;
+      }
+      case SkPath::kClose_Verb: {
+        [result closePath];
+        break;
+      }
+      default: { NOTREACHED(); }
+    }
+  }
+
+  // Set up the fill type.
+  switch (path.getFillType()) {
+    case SkPathFillType::kWinding:
+      [result setWindingRule:NSNonZeroWindingRule];
+      break;
+    case SkPathFillType::kEvenOdd:
+      [result setWindingRule:NSEvenOddWindingRule];
+      break;
+    case SkPathFillType::kInverseWinding:
+    case SkPathFillType::kInverseEvenOdd:
+      NOTREACHED() << "NSBezierCurve does not support inverse fill types.";
+      break;
+  }
+
+  return result;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/path_mac_unittest.mm b/ui/gfx/path_mac_unittest.mm
new file mode 100644
index 0000000..149c4e3
--- /dev/null
+++ b/ui/gfx/path_mac_unittest.mm
@@ -0,0 +1,260 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#import "ui/gfx/path_mac.h"
+
+#include <cmath>
+#include <vector>
+
+#import <Cocoa/Cocoa.h>
+
+#include "base/check_op.h"
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "third_party/skia/include/core/SkRegion.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+
+namespace gfx {
+
+namespace {
+
+// Returns the point at a distance of |radius| from the point (|centre_x|,
+// |centre_y|), and angle |degrees| from the positive horizontal axis, measured
+// anti-clockwise.
+NSPoint GetRadialPoint(double radius,
+                       double degrees,
+                       double centre_x,
+                       double centre_y) {
+  const double radian = (degrees * SK_ScalarPI) / 180;
+  return NSMakePoint(centre_x + radius * std::cos(radian),
+                     centre_y + radius * std::sin(radian));
+}
+
+// Returns the area of a circle with the given |radius|.
+double CalculateCircleArea(double radius) {
+  return SK_ScalarPI * radius * radius;
+}
+
+// Returns the area of a simple polygon. |path| should represent a simple
+// polygon.
+double CalculatePolygonArea(NSBezierPath* path) {
+  // If path represents a single polygon, it will have MoveTo, followed by
+  // multiple LineTo, followed By ClosePath, followed by another MoveTo
+  // NSBezierPathElement.
+  const size_t element_count = [path elementCount];
+  NSPoint points[3];
+  std::vector<NSPoint> poly;
+
+  for (size_t i = 0; i < element_count - 1; i++) {
+    NSBezierPathElement element =
+        [path elementAtIndex:i associatedPoints:points];
+    poly.push_back(points[0]);
+    DCHECK_EQ(element,
+              i ? (i == element_count - 2 ? NSClosePathBezierPathElement
+                                          : NSLineToBezierPathElement)
+                : NSMoveToBezierPathElement);
+  }
+  DCHECK_EQ([path elementAtIndex:element_count - 1], NSMoveToBezierPathElement);
+
+  // Shoelace Algorithm to find the area of a simple polygon.
+  DCHECK(NSEqualPoints(poly.front(), poly.back()));
+  double area = 0;
+  for (size_t i = 0; i < poly.size() - 1; i++)
+    area += poly[i].x * poly[i + 1].y - poly[i].y * poly[i + 1].x;
+
+  return std::fabs(area) / 2.0;
+}
+
+// Returns the area of a rounded rectangle with the given |width|, |height| and
+// |radius|.
+double CalculateRoundedRectangleArea(double width,
+                                     double height,
+                                     double radius) {
+  const double inside_width = width - 2 * radius;
+  const double inside_height = height - 2 * radius;
+  return inside_width * inside_height +
+         2 * radius * (inside_width + inside_height) +
+         CalculateCircleArea(radius);
+}
+
+// Returns the bounding box of |path| as a Rect.
+Rect GetBoundingBox(NSBezierPath* path) {
+  const NSRect bounds = [path bounds];
+  return ToNearestRect(RectF(bounds.origin.x, bounds.origin.y,
+                             bounds.size.width, bounds.size.height));
+}
+
+}  // namespace
+
+// Check that empty NSBezierPath is returned for empty SkPath.
+TEST(CreateNSBezierPathFromSkPathTest, EmptyPath) {
+  NSBezierPath* result = CreateNSBezierPathFromSkPath(SkPath());
+  EXPECT_TRUE([result isEmpty]);
+}
+
+// Check that the returned NSBezierPath has the correct winding rule.
+TEST(CreateNSBezierPathFromSkPathTest, FillType) {
+  SkPath path;
+  path.setFillType(SkPathFillType::kWinding);
+  NSBezierPath* result = CreateNSBezierPathFromSkPath(path);
+  EXPECT_EQ(NSNonZeroWindingRule, [result windingRule]);
+
+  path.setFillType(SkPathFillType::kEvenOdd);
+  result = CreateNSBezierPathFromSkPath(path);
+  EXPECT_EQ(NSEvenOddWindingRule, [result windingRule]);
+}
+
+// Check that a path containing multiple subpaths, in this case two rectangles,
+// is correctly converted to a NSBezierPath.
+TEST(CreateNSBezierPathFromSkPathTest, TwoRectanglesPath) {
+  const SkRect rects[] = {
+      {0, 0, 50, 50}, {100, 100, 150, 150},
+  };
+  const NSPoint inside_points[] = {
+      {1, 1},     {1, 49},    {49, 49},   {49, 1},    {25, 25},
+      {101, 101}, {101, 149}, {149, 149}, {149, 101}, {125, 125}};
+  const NSPoint outside_points[] = {{-1, -1}, {-1, 51},  {51, 51},   {51, -1},
+                                    {99, 99}, {99, 151}, {151, 151}, {151, 99},
+                                    {75, 75}, {-5, -5}};
+  ASSERT_EQ(base::size(inside_points), base::size(outside_points));
+  const Rect expected_bounds(0, 0, 150, 150);
+
+  SkPath path;
+  path.addRect(rects[0]);
+  path.addRect(rects[1]);
+  NSBezierPath* result = CreateNSBezierPathFromSkPath(path);
+
+  // Check points near the boundary of the path and verify that they are
+  // reported correctly as being inside/outside the path.
+  for (size_t i = 0; i < base::size(inside_points); i++) {
+    EXPECT_TRUE([result containsPoint:inside_points[i]]);
+    EXPECT_FALSE([result containsPoint:outside_points[i]]);
+  }
+
+  // Check that the returned result has the correct bounding box. GetBoundingBox
+  // rounds the coordinates to nearest integer values.
+  EXPECT_EQ(expected_bounds, GetBoundingBox(result));
+}
+
+// Test that an SKPath containing a circle is converted correctly to a
+// NSBezierPath.
+TEST(CreateNSBezierPathFromSkPathTest, CirclePath) {
+  const int kRadius = 5;
+  const int kCentreX = 10;
+  const int kCentreY = 15;
+  const double kCushion = 0.1;
+  // Expected bounding box of the circle.
+  const Rect expected_bounds(kCentreX - kRadius, kCentreY - kRadius,
+                             2 * kRadius, 2 * kRadius);
+
+  SkPath path;
+  path.addCircle(SkIntToScalar(kCentreX), SkIntToScalar(kCentreY),
+                 SkIntToScalar(kRadius));
+  NSBezierPath* result = CreateNSBezierPathFromSkPath(path);
+
+  // Check points near the boundary of the circle and verify that they are
+  // reported correctly as being inside/outside the path.
+  for (size_t deg = 0; deg < 360; deg++) {
+    NSPoint inside_point =
+        GetRadialPoint(kRadius - kCushion, deg, kCentreX, kCentreY);
+    NSPoint outside_point =
+        GetRadialPoint(kRadius + kCushion, deg, kCentreX, kCentreY);
+    EXPECT_TRUE([result containsPoint:inside_point]);
+    EXPECT_FALSE([result containsPoint:outside_point]);
+  }
+
+  // Check that the returned result has the correct bounding box. GetBoundingBox
+  // rounds the coordinates to nearest integer values.
+  EXPECT_EQ(expected_bounds, GetBoundingBox(result));
+
+  // Check area of converted path is correct up to a certain tolerance value. To
+  // find the area of the NSBezierPath returned, flatten it i.e. convert it to a
+  // polygon.
+  [NSBezierPath setDefaultFlatness:0.01];
+  NSBezierPath* polygon = [result bezierPathByFlatteningPath];
+  const double kTolerance = 0.14;
+  EXPECT_NEAR(CalculateCircleArea(kRadius), CalculatePolygonArea(polygon),
+              kTolerance);
+}
+
+// Test that an SKPath containing a rounded rectangle is converted correctly to
+// a NSBezierPath.
+TEST(CreateNSBezierPathFromSkPathTest, RoundedRectanglePath) {
+  const int kRectangleWidth = 50;
+  const int kRectangleHeight = 100;
+  const int kCornerRadius = 5;
+  const double kCushion = 0.1;
+  // Expected bounding box of the rounded rectangle.
+  const Rect expected_bounds(kRectangleWidth, kRectangleHeight);
+
+  SkRRect rrect;
+  rrect.setRectXY(SkRect::MakeWH(kRectangleWidth, kRectangleHeight),
+                  kCornerRadius, kCornerRadius);
+
+  const NSPoint inside_points[] = {
+      // Bottom left corner.
+      {kCornerRadius / 2.0, kCornerRadius / 2.0},
+      // Bottom right corner.
+      {kRectangleWidth - kCornerRadius / 2.0, kCornerRadius / 2.0},
+      // Top Right corner.
+      {kRectangleWidth - kCornerRadius / 2.0,
+       kRectangleHeight - kCornerRadius / 2.0},
+      // Top left corner.
+      {kCornerRadius / 2.0, kRectangleHeight - kCornerRadius / 2.0},
+      // Bottom middle.
+      {kRectangleWidth / 2.0, kCushion},
+      // Right middle.
+      {kRectangleWidth - kCushion, kRectangleHeight / 2.0},
+      // Top middle.
+      {kRectangleWidth / 2.0, kRectangleHeight - kCushion},
+      // Left middle.
+      {kCushion, kRectangleHeight / 2.0}};
+  const NSPoint outside_points[] = {
+      // Bottom left corner.
+      {0, 0},
+      // Bottom right corner.
+      {kRectangleWidth, 0},
+      // Top right corner.
+      {kRectangleWidth, kRectangleHeight},
+      // Top left corner.
+      {0, kRectangleHeight},
+      // Bottom middle.
+      {kRectangleWidth / 2.0, -kCushion},
+      // Right middle.
+      {kRectangleWidth + kCushion, kRectangleHeight / 2.0},
+      // Top middle.
+      {kRectangleWidth / 2.0, kRectangleHeight + kCushion},
+      // Left middle.
+      {-kCushion, kRectangleHeight / 2.0}};
+  ASSERT_EQ(base::size(inside_points), base::size(outside_points));
+
+  SkPath path;
+  path.addRRect(rrect);
+  NSBezierPath* result = CreateNSBezierPathFromSkPath(path);
+
+  // Check points near the boundary of the path and verify that they are
+  // reported correctly as being inside/outside the path.
+  for (size_t i = 0; i < base::size(inside_points); i++) {
+    EXPECT_TRUE([result containsPoint:inside_points[i]]);
+    EXPECT_FALSE([result containsPoint:outside_points[i]]);
+  }
+
+  // Check that the returned result has the correct bounding box. GetBoundingBox
+  // rounds the coordinates to nearest integer values.
+  EXPECT_EQ(expected_bounds, GetBoundingBox(result));
+
+  // Check area of converted path is correct up to a certain tolerance value. To
+  // find the area of the NSBezierPath returned, flatten it i.e. convert it to a
+  // polygon.
+  [NSBezierPath setDefaultFlatness:0.01];
+  NSBezierPath* polygon = [result bezierPathByFlatteningPath];
+  const double kTolerance = 0.14;
+  EXPECT_NEAR(CalculateRoundedRectangleArea(kRectangleWidth, kRectangleHeight,
+                                            kCornerRadius),
+              CalculatePolygonArea(polygon), kTolerance);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/path_win.cc b/ui/gfx/path_win.cc
new file mode 100644
index 0000000..3a73d91
--- /dev/null
+++ b/ui/gfx/path_win.cc
@@ -0,0 +1,37 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/path_win.h"
+
+#include <memory>
+
+#include "base/win/scoped_gdi_object.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "third_party/skia/include/core/SkRegion.h"
+
+namespace gfx {
+
+HRGN CreateHRGNFromSkRegion(const SkRegion& region) {
+  base::win::ScopedRegion temp(::CreateRectRgn(0, 0, 0, 0));
+  base::win::ScopedRegion result(::CreateRectRgn(0, 0, 0, 0));
+
+  for (SkRegion::Iterator i(region); !i.done(); i.next()) {
+    const SkIRect& rect = i.rect();
+    ::SetRectRgn(temp.get(),
+                 rect.left(), rect.top(), rect.right(), rect.bottom());
+    ::CombineRgn(result.get(), result.get(), temp.get(), RGN_OR);
+  }
+
+  return result.release();
+}
+
+HRGN CreateHRGNFromSkPath(const SkPath& path) {
+  SkRegion clip_region;
+  clip_region.setRect(path.getBounds().round());
+  SkRegion region;
+  region.setPath(path, clip_region);
+  return CreateHRGNFromSkRegion(region);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/path_win.h b/ui/gfx/path_win.h
new file mode 100644
index 0000000..2b85075
--- /dev/null
+++ b/ui/gfx/path_win.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PATH_WIN_H_
+#define UI_GFX_PATH_WIN_H_
+
+#include <windows.h>
+
+#include "ui/gfx/gfx_export.h"
+
+class SkPath;
+class SkRegion;
+
+namespace gfx {
+
+// Creates a new HRGN given |region|. The caller is responsible for destroying
+// the returned region.
+GFX_EXPORT HRGN CreateHRGNFromSkRegion(const SkRegion& path);
+
+// Creates a new HRGN given |path|. The caller is responsible for destroying
+// the returned region. Returns empty region (not NULL) for empty path.
+GFX_EXPORT HRGN CreateHRGNFromSkPath(const SkPath& path);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PATH_WIN_H_
diff --git a/ui/gfx/path_win_unittest.cc b/ui/gfx/path_win_unittest.cc
new file mode 100644
index 0000000..c001370
--- /dev/null
+++ b/ui/gfx/path_win_unittest.cc
@@ -0,0 +1,120 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/path_win.h"
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <vector>
+
+#include "base/check_op.h"
+#include "base/cxx17_backports.h"
+#include "base/win/scoped_gdi_object.h"
+#include "skia/ext/skia_utils_win.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "third_party/skia/include/core/SkRRect.h"
+
+namespace gfx {
+
+namespace {
+
+// Get rectangles from the |region| and convert them to SkIRect.
+std::vector<SkIRect> GetRectsFromHRGN(HRGN region) {
+  // Determine the size of output buffer required to receive the region.
+  DWORD bytes_size = GetRegionData(region, 0, NULL);
+  CHECK_NE((DWORD)0, bytes_size);
+
+  // Fetch the Windows RECTs that comprise the region.
+  std::vector<char> buffer(bytes_size);
+  LPRGNDATA region_data = reinterpret_cast<LPRGNDATA>(buffer.data());
+  DWORD result = GetRegionData(region, bytes_size, region_data);
+  CHECK_EQ(bytes_size, result);
+
+  // Pull out the rectangles into a SkIRect vector to return to caller.
+  const LPRECT rects = reinterpret_cast<LPRECT>(&region_data->Buffer[0]);
+  std::vector<SkIRect> sk_rects(region_data->rdh.nCount);
+  std::transform(rects, rects + region_data->rdh.nCount,
+                 sk_rects.begin(), skia::RECTToSkIRect);
+
+  return sk_rects;
+}
+
+}  // namespace
+
+// Test that rectangle with round corners stil has round corners after
+// converting from SkPath to the HRGN.
+// FIXME: this test is fragile (it depends on rrect rasterization impl)
+TEST(CreateHRGNFromSkPathTest, RoundCornerTest) {
+  const SkIRect rects[] = {
+      { 16, 0, 34, 1 },
+      { 12, 1, 38, 2 },
+      { 10, 2, 40, 3 },
+      { 9, 3, 41, 4 },
+      { 7, 4, 43, 5 },
+      { 6, 5, 44, 6 },
+      { 5, 6, 45, 7 },
+      { 4, 7, 45, 8 },
+      { 4, 8, 46, 9 },
+      { 3, 9, 47, 10 },
+      { 2, 10, 47, 11 },
+      { 2, 11, 48, 12 },
+      { 1, 12, 49, 16 },
+      { 0, 16, 50, 34 },
+      { 1, 34, 49, 38 },
+      { 2, 38, 48, 39 },
+      { 2, 39, 47, 40 },
+      { 3, 40, 47, 41 },
+      { 4, 41, 46, 42 },
+      { 4, 42, 45, 43 },
+      { 5, 43, 45, 44 },
+      { 6, 44, 44, 45 },
+      { 8, 45, 42, 46 },
+      { 9, 46, 41, 47 },
+      { 11, 47, 39, 48 },
+      { 12, 48, 38, 49 },
+      { 16, 49, 34, 50 },
+  };
+
+  SkPath path;
+  SkRRect rrect;
+  rrect.setRectXY(SkRect::MakeWH(50, 50), 20, 20);
+  path.addRRect(rrect);
+  base::win::ScopedRegion region(CreateHRGNFromSkPath(path));
+  const std::vector<SkIRect>& region_rects = GetRectsFromHRGN(region.get());
+  EXPECT_EQ(base::size(rects), region_rects.size());
+  for (size_t i = 0; i < base::size(rects) && i < region_rects.size(); ++i)
+    EXPECT_EQ(rects[i], region_rects[i]);
+}
+
+// Check that a path enclosing two non-adjacent areas is correctly translated
+// to a non-contiguous region.
+TEST(CreateHRGNFromSkPathTest, NonContiguousPath) {
+  const SkIRect rects[] = {
+      { 0, 0, 50, 50},
+      { 100, 100, 150, 150},
+  };
+
+  SkPath path;
+  for (const SkIRect& rect : rects) {
+    path.addRect(SkRect::Make(rect));
+  }
+  base::win::ScopedRegion region(CreateHRGNFromSkPath(path));
+  const std::vector<SkIRect>& region_rects = GetRectsFromHRGN(region.get());
+  ASSERT_EQ(base::size(rects), region_rects.size());
+  for (size_t i = 0; i < base::size(rects); ++i)
+    EXPECT_EQ(rects[i], region_rects[i]);
+}
+
+// Check that empty region is returned for empty path.
+TEST(CreateHRGNFromSkPathTest, EmptyPath) {
+  SkPath path;
+  base::win::ScopedRegion empty_region(::CreateRectRgn(0, 0, 0, 0));
+  base::win::ScopedRegion region(CreateHRGNFromSkPath(path));
+  EXPECT_TRUE(::EqualRgn(empty_region.get(), region.get()));
+}
+
+}  // namespace gfx
+
diff --git a/ui/gfx/platform_font.h b/ui/gfx/platform_font.h
new file mode 100644
index 0000000..6b0025c
--- /dev/null
+++ b/ui/gfx/platform_font.h
@@ -0,0 +1,118 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PLATFORM_FONT_H_
+#define UI_GFX_PLATFORM_FONT_H_
+
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "build/build_config.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/native_widget_types.h"
+
+namespace gfx {
+
+class GFX_EXPORT PlatformFont : public base::RefCounted<PlatformFont> {
+ public:
+// The size of the font returned by CreateDefault() on a "default" platform
+// configuration. This allows UI that wants to target a particular size of font
+// to obtain that size for the majority of users, while still compensating for a
+// user preference for a larger or smaller font.
+#if defined(OS_APPLE)
+  static constexpr int kDefaultBaseFontSize = 13;
+#else
+  static constexpr int kDefaultBaseFontSize = 12;
+#endif
+
+  // Creates an appropriate PlatformFont implementation.
+  static PlatformFont* CreateDefault();
+#if defined(OS_APPLE)
+  static PlatformFont* CreateFromNativeFont(NativeFont native_font);
+#endif
+  // Creates a PlatformFont implementation with the specified |font_name|
+  // (encoded in UTF-8) and |font_size| in pixels.
+  static PlatformFont* CreateFromNameAndSize(const std::string& font_name,
+                                             int font_size);
+
+  // Creates a PlatformFont instance from the provided SkTypeface, ideally by
+  // just wrapping it without triggering a new font match. Implemented for
+  // PlatformFontSkia which provides true wrapping of the provided SkTypeface.
+  // The FontRenderParams can be provided or they will be determined by using
+  // gfx::GetFontRenderParams(...) otherwise.
+  static PlatformFont* CreateFromSkTypeface(
+      sk_sp<SkTypeface> typeface,
+      int font_size,
+      const absl::optional<FontRenderParams>& params);
+
+  // Returns a new Font derived from the existing font.
+  // |size_delta| is the size in pixels to add to the current font.
+  // The style parameter specifies the new style for the font, and is a
+  // bitmask of the values: ITALIC and UNDERLINE.
+  // The weight parameter specifies the desired weight of the font.
+  virtual Font DeriveFont(int size_delta,
+                          int style,
+                          Font::Weight weight) const = 0;
+
+  // Returns the number of vertical pixels needed to display characters from
+  // the specified font.  This may include some leading, i.e. height may be
+  // greater than just ascent + descent.  Specifically, the Windows and Mac
+  // implementations include leading and the Linux one does not.  This may
+  // need to be revisited in the future.
+  virtual int GetHeight() = 0;
+
+  // Returns the font weight.
+  virtual Font::Weight GetWeight() const = 0;
+
+  // Returns the baseline, or ascent, of the font.
+  virtual int GetBaseline() = 0;
+
+  // Returns the cap height of the font.
+  virtual int GetCapHeight() = 0;
+
+  // Returns the expected number of horizontal pixels needed to display the
+  // specified length of characters. Call GetStringWidth() to retrieve the
+  // actual number.
+  virtual int GetExpectedTextWidth(int length) = 0;
+
+  // Returns the style of the font.
+  virtual int GetStyle() const = 0;
+
+  // Returns the specified font name in UTF-8.
+  virtual const std::string& GetFontName() const = 0;
+
+  // Returns the actually used font name in UTF-8.
+  virtual std::string GetActualFontName() const = 0;
+
+  // Returns the font size in pixels.
+  virtual int GetFontSize() const = 0;
+
+  // Returns an object describing how the font should be rendered.
+  virtual const FontRenderParams& GetFontRenderParams() = 0;
+
+#if defined(OS_APPLE)
+  // Returns the native font handle.
+  virtual NativeFont GetNativeFont() const = 0;
+#endif
+
+  // Returns the underlying Skia typeface. Used in RenderTextHarfBuzz for having
+  // access to the exact Skia typeface returned by  font fallback, as we would
+  // otherwise lose the handle to the correct platform font instance.
+  virtual sk_sp<SkTypeface> GetNativeSkTypeface() const = 0;
+
+ protected:
+  virtual ~PlatformFont() {}
+
+ private:
+  friend class base::RefCounted<PlatformFont>;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PLATFORM_FONT_H_
diff --git a/ui/gfx/platform_font_ios.h b/ui/gfx/platform_font_ios.h
new file mode 100644
index 0000000..70af745
--- /dev/null
+++ b/ui/gfx/platform_font_ios.h
@@ -0,0 +1,70 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PLATFORM_FONT_IOS_H_
+#define UI_GFX_PLATFORM_FONT_IOS_H_
+
+#include "base/macros.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+
+class PlatformFontIOS : public PlatformFont {
+ public:
+  PlatformFontIOS();
+  explicit PlatformFontIOS(NativeFont native_font);
+  PlatformFontIOS(const std::string& font_name,
+                  int font_size);
+
+  PlatformFontIOS(const PlatformFontIOS&) = delete;
+  PlatformFontIOS& operator=(const PlatformFontIOS&) = delete;
+
+  // Overridden from PlatformFont:
+  Font DeriveFont(int size_delta,
+                  int style,
+                  Font::Weight weight) const override;
+  int GetHeight() override;
+  Font::Weight GetWeight() const override;
+  int GetBaseline() override;
+  int GetCapHeight() override;
+  int GetExpectedTextWidth(int length) override;
+  int GetStyle() const override;
+  const std::string& GetFontName() const override;
+  std::string GetActualFontName() const override;
+  int GetFontSize() const override;
+  const FontRenderParams& GetFontRenderParams() override;
+  NativeFont GetNativeFont() const override;
+  sk_sp<SkTypeface> GetNativeSkTypeface() const override;
+
+ private:
+  PlatformFontIOS(const std::string& font_name,
+                  int font_size,
+                  int style,
+                  Font::Weight weight);
+  ~PlatformFontIOS() override {}
+
+  // Initialize the object with the specified parameters.
+  void InitWithNameSizeAndStyle(const std::string& font_name,
+                                int font_size,
+                                int style,
+                                Font::Weight weight);
+
+  // Calculate and cache the font metrics.
+  void CalculateMetrics();
+
+  std::string font_name_;
+  int font_size_;
+  int style_;
+  Font::Weight weight_;
+
+  // Cached metrics, generated at construction.
+  int height_;
+  int ascent_;
+  int cap_height_;
+  int average_width_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PLATFORM_FONT_IOS_H_
diff --git a/ui/gfx/platform_font_ios.mm b/ui/gfx/platform_font_ios.mm
new file mode 100644
index 0000000..5a59235
--- /dev/null
+++ b/ui/gfx/platform_font_ios.mm
@@ -0,0 +1,154 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/platform_font_ios.h"
+
+#import <UIKit/UIKit.h>
+
+#include <cmath>
+
+#import "base/mac/foundation_util.h"
+#include "base/notreached.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "third_party/skia/include/ports/SkTypeface_mac.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/ios/NSString+CrStringDrawing.h"
+
+namespace gfx {
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontIOS, public:
+
+PlatformFontIOS::PlatformFontIOS() {
+  font_size_ = [UIFont systemFontSize];
+  style_ = Font::NORMAL;
+  weight_ = Font::Weight::NORMAL;
+  UIFont* system_font = [UIFont systemFontOfSize:font_size_];
+  font_name_ = base::SysNSStringToUTF8([system_font fontName]);
+  CalculateMetrics();
+}
+
+PlatformFontIOS::PlatformFontIOS(NativeFont native_font) {
+  std::string font_name = base::SysNSStringToUTF8([native_font fontName]);
+  InitWithNameSizeAndStyle(font_name, [native_font pointSize],
+                           Font::NORMAL, Font::Weight::NORMAL);
+}
+
+PlatformFontIOS::PlatformFontIOS(const std::string& font_name, int font_size) {
+  InitWithNameSizeAndStyle(font_name, font_size, Font::NORMAL,
+                           Font::Weight::NORMAL);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontIOS, PlatformFont implementation:
+
+Font PlatformFontIOS::DeriveFont(int size_delta,
+                                 int style,
+                                 Font::Weight weight) const {
+  return Font(
+      new PlatformFontIOS(font_name_, font_size_ + size_delta, style, weight));
+}
+
+int PlatformFontIOS::GetHeight() {
+  return height_;
+}
+
+int PlatformFontIOS::GetBaseline() {
+  return ascent_;
+}
+
+int PlatformFontIOS::GetCapHeight() {
+  return cap_height_;
+}
+
+int PlatformFontIOS::GetExpectedTextWidth(int length) {
+  return length * average_width_;
+}
+
+int PlatformFontIOS::GetStyle() const {
+  return style_;
+}
+
+Font::Weight PlatformFontIOS::GetWeight() const {
+  return weight_;
+}
+
+const std::string& PlatformFontIOS::GetFontName() const {
+  return font_name_;
+}
+
+std::string PlatformFontIOS::GetActualFontName() const {
+  return base::SysNSStringToUTF8([GetNativeFont() familyName]);
+}
+
+int PlatformFontIOS::GetFontSize() const {
+  return font_size_;
+}
+
+const FontRenderParams& PlatformFontIOS::GetFontRenderParams() {
+  NOTIMPLEMENTED();
+  static FontRenderParams params;
+  return params;
+}
+
+NativeFont PlatformFontIOS::GetNativeFont() const {
+  return [UIFont fontWithName:base::SysUTF8ToNSString(font_name_)
+                         size:font_size_];
+}
+
+sk_sp<SkTypeface> PlatformFontIOS::GetNativeSkTypeface() const {
+  return SkMakeTypefaceFromCTFont(base::mac::NSToCFCast(GetNativeFont()));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontIOS, private:
+
+PlatformFontIOS::PlatformFontIOS(const std::string& font_name,
+                                 int font_size,
+                                 int style,
+                                 Font::Weight weight) {
+  InitWithNameSizeAndStyle(font_name, font_size, style, weight);
+}
+
+void PlatformFontIOS::InitWithNameSizeAndStyle(const std::string& font_name,
+                                               int font_size,
+                                               int style,
+                                               Font::Weight weight) {
+  font_name_ = font_name;
+  font_size_ = font_size;
+  style_ = style;
+  weight_ = weight;
+  CalculateMetrics();
+}
+
+void PlatformFontIOS::CalculateMetrics() {
+  UIFont* font = GetNativeFont();
+  height_ = font.lineHeight;
+  ascent_ = font.ascender;
+  cap_height_ = font.capHeight;
+  average_width_ = [@"x" cr_sizeWithFont:font].width;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFont, public:
+
+// static
+PlatformFont* PlatformFont::CreateDefault() {
+  return new PlatformFontIOS;
+}
+
+// static
+PlatformFont* PlatformFont::CreateFromNativeFont(NativeFont native_font) {
+  return new PlatformFontIOS(native_font);
+}
+
+// static
+PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
+                                                  int font_size) {
+  return new PlatformFontIOS(font_name, font_size);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/platform_font_mac.h b/ui/gfx/platform_font_mac.h
new file mode 100644
index 0000000..b4e09f6
--- /dev/null
+++ b/ui/gfx/platform_font_mac.h
@@ -0,0 +1,121 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PLATFORM_FONT_MAC_H_
+#define UI_GFX_PLATFORM_FONT_MAC_H_
+
+#include "base/compiler_specific.h"
+#include "base/mac/scoped_nsobject.h"
+#include "base/macros.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+
+class GFX_EXPORT PlatformFontMac : public PlatformFont {
+ public:
+  // An enum indicating a type of system-specified font.
+  //   - kGeneral: +[NSFont systemFontOfSize:(weight:)]
+  //   - kMenu: +[NSFont menuFontOfSize:]
+  //   - kToolTip: +[NSFont toolTipsFontOfSize:]
+  enum class SystemFontType { kGeneral, kMenu, kToolTip };
+
+  // Constructs a PlatformFontMac for a system-specified font of
+  // |system_font_type| type. For a non-system-specified font, use any other
+  // constructor.
+  explicit PlatformFontMac(SystemFontType system_font_type);
+
+  // Constructs a PlatformFontMac for containing the NSFont* |native_font|. Do
+  // not call this for a system-specified font; use the |SystemFontType|
+  // constructor for that. |native_font| must not be null.
+  explicit PlatformFontMac(NativeFont native_font);
+
+  // Constructs a PlatformFontMac representing the font with name |font_name|
+  // and the size |font_size|. Do not call this for a system-specified font; use
+  // the |SystemFontType| constructor for that.
+  PlatformFontMac(const std::string& font_name,
+                  int font_size);
+
+  // Constructs a PlatformFontMac representing the font specified by |typeface|
+  // and the size |font_size_pixels|. Do not call this for a system-specified
+  // font; use the |SystemFontType| constructor for that.
+  PlatformFontMac(sk_sp<SkTypeface> typeface,
+                  int font_size_pixels,
+                  const absl::optional<FontRenderParams>& params);
+
+  PlatformFontMac(const PlatformFontMac&) = delete;
+  PlatformFontMac& operator=(const PlatformFontMac&) = delete;
+
+  // Overridden from PlatformFont:
+  Font DeriveFont(int size_delta,
+                  int style,
+                  Font::Weight weight) const override;
+  int GetHeight() override;
+  Font::Weight GetWeight() const override;
+  int GetBaseline() override;
+  int GetCapHeight() override;
+  int GetExpectedTextWidth(int length) override;
+  int GetStyle() const override;
+  const std::string& GetFontName() const override;
+  std::string GetActualFontName() const override;
+  int GetFontSize() const override;
+  const FontRenderParams& GetFontRenderParams() override;
+  NativeFont GetNativeFont() const override;
+  sk_sp<SkTypeface> GetNativeSkTypeface() const override;
+
+  // A utility function to get the weight of an NSFont. Used by the unit test.
+  static Font::Weight GetFontWeightFromNSFontForTesting(NSFont* font);
+
+ private:
+  struct FontSpec {
+    std::string name;  // Corresponds to -[NSFont fontFamily].
+    int size;
+    int style;
+    Font::Weight weight;
+  };
+
+  PlatformFontMac(NativeFont font,
+                  absl::optional<SystemFontType> system_font_type);
+
+  PlatformFontMac(NativeFont font,
+                  absl::optional<SystemFontType> system_font_type,
+                  FontSpec spec);
+
+  ~PlatformFontMac() override;
+
+  // Calculates and caches the font metrics and initializes |render_params_|.
+  void CalculateMetricsAndInitRenderParams();
+
+  // Returns an autoreleased NSFont created with the passed-in specifications.
+  NSFont* NSFontWithSpec(FontSpec font_spec) const;
+
+  // The NSFont instance for this object. If this object was constructed from an
+  // NSFont instance, this holds that NSFont instance. Otherwise this NSFont
+  // instance is constructed from the name, size, and style. If there is no
+  // active font that matched those criteria a default font is used.
+  base::scoped_nsobject<NSFont> native_font_;
+
+  // If the font is a system font, and if so, what kind.
+  const absl::optional<SystemFontType> system_font_type_;
+
+  // The name/size/style/weight quartet that specify the font. Initialized in
+  // the constructors.
+  const FontSpec font_spec_;
+
+  // Cached metrics, generated in CalculateMetrics().
+  int height_;
+  int ascent_;
+  int cap_height_;
+
+  // Cached average width, generated in GetExpectedTextWidth().
+  float average_width_ = 0.0;
+
+  // Details about how the font should be rendered.
+  FontRenderParams render_params_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PLATFORM_FONT_MAC_H_
diff --git a/ui/gfx/platform_font_mac.mm b/ui/gfx/platform_font_mac.mm
new file mode 100644
index 0000000..99b4dff
--- /dev/null
+++ b/ui/gfx/platform_font_mac.mm
@@ -0,0 +1,553 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/platform_font_mac.h"
+
+#include <cmath>
+#include <set>
+
+#include <Cocoa/Cocoa.h>
+
+#import "base/mac/foundation_util.h"
+#include "base/mac/scoped_cftyperef.h"
+#import "base/mac/scoped_nsobject.h"
+#include "base/no_destructor.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "third_party/skia/include/ports/SkTypeface_mac.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_render_params.h"
+
+namespace gfx {
+
+using Weight = Font::Weight;
+
+extern "C" {
+bool CTFontDescriptorIsSystemUIFont(CTFontDescriptorRef);
+}
+
+namespace {
+
+// Returns the font style for |font|. Disregards Font::UNDERLINE, since NSFont
+// does not support it as a trait.
+int GetFontStyleFromNSFont(NSFont* font) {
+  int font_style = Font::NORMAL;
+  NSFontSymbolicTraits traits = [[font fontDescriptor] symbolicTraits];
+  if (traits & NSFontItalicTrait)
+    font_style |= Font::ITALIC;
+  return font_style;
+}
+
+// Returns the Font::Weight for |font|.
+Weight GetFontWeightFromNSFont(NSFont* font) {
+  DCHECK(font);
+
+  // Map CoreText weights in a manner similar to ct_weight_to_fontstyle() from
+  // SkFontHost_mac.cpp, but adjusted for the weights actually used by the
+  // system fonts. See PlatformFontMacTest.FontWeightAPIConsistency for details.
+  // macOS uses specific float values in its constants, but individual fonts can
+  // and do specify arbitrary values in the -1.0 to 1.0 range. Therefore, to
+  // accomodate that, and to avoid float comparison issues, use ranges.
+  constexpr struct {
+    // A range of CoreText weights.
+    CGFloat weight_lower;
+    CGFloat weight_upper;
+    Weight gfx_weight;
+  } weight_map[] = {
+      // NSFontWeight constants introduced in 10.11:
+      //   NSFontWeightUltraLight: -0.80
+      //   NSFontWeightThin: -0.60
+      //   NSFontWeightLight: -0.40
+      //   NSFontWeightRegular: 0.0
+      //   NSFontWeightMedium: 0.23
+      //   NSFontWeightSemibold: 0.30
+      //   NSFontWeightBold: 0.40
+      //   NSFontWeightHeavy: 0.56
+      //   NSFontWeightBlack: 0.62
+      //
+      // Actual system font weights:
+      //   10.10:
+      //     .HelveticaNeueDeskInterface-UltraLightP2: -0.80
+      //     .HelveticaNeueDeskInterface-Thin: -0.50
+      //     .HelveticaNeueDeskInterface-Light: -0.425
+      //     .HelveticaNeueDeskInterface-Regular: 0.0
+      //     .HelveticaNeueDeskInterface-MediumP4: 0.23
+      //     .HelveticaNeueDeskInterface-Bold (if requested as semibold): 0.24
+      //     .HelveticaNeueDeskInterface-Bold (if requested as bold): 0.4
+      //     .HelveticaNeueDeskInterface-Heavy (if requested as heavy): 0.576
+      //     .HelveticaNeueDeskInterface-Heavy (if requested as black): 0.662
+      //   10.11-:
+      //     .AppleSystemUIFontUltraLight: -0.80
+      //     .AppleSystemUIFontThin: -0.60
+      //     .AppleSystemUIFontLight: -0.40
+      //     .AppleSystemUIFont: 0.0
+      //     .AppleSystemUIFontMedium: 0.23
+      //     .AppleSystemUIFontDemi: 0.30
+      //     .AppleSystemUIFontBold (10.11): 0.40
+      //     .AppleSystemUIFontEmphasized (10.12-): 0.40
+      //     .AppleSystemUIFontHeavy: 0.56
+      //     .AppleSystemUIFontBlack: 0.62
+      {-1.0, -0.70, Weight::THIN},          // NSFontWeightUltraLight
+      {-0.70, -0.45, Weight::EXTRA_LIGHT},  // NSFontWeightThin
+      {-0.45, -0.10, Weight::LIGHT},        // NSFontWeightLight
+      {-0.10, 0.10, Weight::NORMAL},        // NSFontWeightRegular
+      {0.10, 0.27, Weight::MEDIUM},         // NSFontWeightMedium
+      {0.27, 0.35, Weight::SEMIBOLD},       // NSFontWeightSemibold
+      {0.35, 0.50, Weight::BOLD},           // NSFontWeightBold
+      {0.50, 0.60, Weight::EXTRA_BOLD},     // NSFontWeightHeavy
+      {0.60, 1.0, Weight::BLACK},           // NSFontWeightBlack
+  };
+
+  base::ScopedCFTypeRef<CFDictionaryRef> traits(
+      CTFontCopyTraits(base::mac::NSToCFCast(font)));
+  DCHECK(traits);
+  CFNumberRef cf_weight = base::mac::GetValueFromDictionary<CFNumberRef>(
+      traits, kCTFontWeightTrait);
+  // A missing weight attribute just means 0 -> NORMAL.
+  if (!cf_weight)
+    return Weight::NORMAL;
+
+  // The value of kCTFontWeightTrait empirically is a kCFNumberFloat64Type
+  // (double) on all tested versions of macOS. However, that doesn't really
+  // matter as only the first two decimal digits need to be tested. Do not check
+  // for the success of CFNumberGetValue() as it returns false for any loss of
+  // value and all that is needed here is two digits of accuracy.
+  CGFloat weight;
+  CFNumberGetValue(cf_weight, kCFNumberCGFloatType, &weight);
+  for (const auto& item : weight_map) {
+    if (item.weight_lower <= weight && weight <= item.weight_upper)
+      return item.gfx_weight;
+  }
+  return Weight::INVALID;
+}
+
+// Converts a Font::Weight value to the corresponding NSFontWeight value.
+NSFontWeight ToNSFontWeight(Weight weight) {
+  switch (weight) {
+    case Weight::THIN:
+      return NSFontWeightUltraLight;
+    case Weight::EXTRA_LIGHT:
+      return NSFontWeightThin;
+    case Weight::LIGHT:
+      return NSFontWeightLight;
+    case Weight::INVALID:
+    case Weight::NORMAL:
+      return NSFontWeightRegular;
+    case Weight::MEDIUM:
+      return NSFontWeightMedium;
+    case Weight::SEMIBOLD:
+      return NSFontWeightSemibold;
+    case Weight::BOLD:
+      return NSFontWeightBold;
+    case Weight::EXTRA_BOLD:
+      return NSFontWeightHeavy;
+    case Weight::BLACK:
+      return NSFontWeightBlack;
+  }
+}
+
+// Chromium uses the ISO-style, 9-value ladder of font weights (THIN-BLACK). The
+// new font API in macOS also uses these weights, though they are constants
+// defined in terms of CGFloat with values from -1.0 to 1.0.
+//
+// However, the old API used by the NSFontManager uses integer values on a
+// "scale of 0 to 15". These values are used in:
+//
+//   -[NSFontManager availableMembersOfFontFamily:]
+//   -[NSFontManager convertWeight:ofFont:]
+//   -[NSFontManager fontWithFamily:traits:weight:size:]
+//   -[NSFontManager weightOfFont:]
+//
+// Apple provides a chart of how the ISO values correspond:
+// https://developer.apple.com/reference/appkit/nsfontmanager/1462321-convertweight
+// However, it's more complicated than that. A survey of fonts yields the
+// correspondence in this function, but the outliers imply that the ISO-style
+// weight is more along the lines of "weight role within the font family" vs
+// this number which is more like "how weighty is this font compared to all
+// other fonts".
+//
+// These numbers can't really be forced to line up; different fonts disagree on
+// how to map them. This function mostly follows the documented chart as
+// inspired by actual fonts, and should be good enough.
+NSInteger ToNSFontManagerWeight(Weight weight) {
+  switch (weight) {
+    case Weight::THIN:
+      return 2;
+    case Weight::EXTRA_LIGHT:
+      return 3;
+    case Weight::LIGHT:
+      return 4;
+    case Weight::INVALID:
+    case Weight::NORMAL:
+      return 5;
+    case Weight::MEDIUM:
+      return 6;
+    case Weight::SEMIBOLD:
+      return 8;
+    case Weight::BOLD:
+      return 9;
+    case Weight::EXTRA_BOLD:
+      return 10;
+    case Weight::BLACK:
+      return 11;
+  }
+}
+
+std::string GetFamilyNameFromTypeface(sk_sp<SkTypeface> typeface) {
+  SkString family;
+  typeface->getFamilyName(&family);
+  return family.c_str();
+}
+
+NSFont* SystemFontForConstructorOfType(PlatformFontMac::SystemFontType type) {
+  switch (type) {
+    case PlatformFontMac::SystemFontType::kGeneral:
+      return [NSFont systemFontOfSize:[NSFont systemFontSize]];
+    case PlatformFontMac::SystemFontType::kMenu:
+      return [NSFont menuFontOfSize:0];
+    case PlatformFontMac::SystemFontType::kToolTip:
+      return [NSFont toolTipsFontOfSize:0];
+  }
+}
+
+absl::optional<PlatformFontMac::SystemFontType>
+SystemFontTypeFromUndocumentedCTFontRefInternals(CTFontRef font) {
+  // The macOS APIs can't reliably derive one font from another. That's why for
+  // non-system fonts PlatformFontMac::DeriveFont() uses the family name of the
+  // font to find look up new fonts from scratch, and why, for system fonts, it
+  // uses the system font APIs to generate new system fonts.
+  //
+  // Skia's font handling assumes that given a font object, new fonts can be
+  // derived from it. That's absolutely not true on the Mac. However, this needs
+  // to be fixed, and a rewrite of how Skia handles fonts is not on the table.
+  //
+  // Therefore this sad hack. If Skia provides an SkTypeface, dig into the
+  // undocumented bowels of CoreText and magically determine if the font is a
+  // system font. This allows PlatformFontMac to correctly derive variants of
+  // the provided font.
+  //
+  // TODO(avi, etienneb): Figure out this font stuff.
+  base::ScopedCFTypeRef<CTFontDescriptorRef> descriptor(
+      CTFontCopyFontDescriptor(font));
+  if (CTFontDescriptorIsSystemUIFont(descriptor.get())) {
+    // Assume it's the standard system font. The fact that this much is known is
+    // enough.
+    return PlatformFontMac::SystemFontType::kGeneral;
+  } else {
+    return absl::nullopt;
+  }
+}
+
+#if DCHECK_IS_ON()
+
+const std::set<std::string>& SystemFontNames() {
+  static const base::NoDestructor<std::set<std::string>> names([] {
+    std::set<std::string> names;
+    names.insert(base::SysNSStringToUTF8(
+        [NSFont systemFontOfSize:[NSFont systemFontSize]].familyName));
+    names.insert(base::SysNSStringToUTF8([NSFont menuFontOfSize:0].familyName));
+    names.insert(
+        base::SysNSStringToUTF8([NSFont toolTipsFontOfSize:0].familyName));
+    return names;
+  }());
+
+  return *names;
+}
+
+#endif  // DCHECK_IS_ON()
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontMac, public:
+
+PlatformFontMac::PlatformFontMac(SystemFontType system_font_type)
+    : PlatformFontMac(SystemFontForConstructorOfType(system_font_type),
+                      system_font_type) {}
+
+PlatformFontMac::PlatformFontMac(NativeFont native_font)
+    : PlatformFontMac(native_font, absl::nullopt) {
+  DCHECK(native_font);  // nil should not be passed to this constructor.
+}
+
+PlatformFontMac::PlatformFontMac(const std::string& font_name, int font_size)
+    : PlatformFontMac(
+          NSFontWithSpec({font_name, font_size, Font::NORMAL, Weight::NORMAL}),
+          absl::nullopt,
+          {font_name, font_size, Font::NORMAL, Weight::NORMAL}) {}
+
+PlatformFontMac::PlatformFontMac(sk_sp<SkTypeface> typeface,
+                                 int font_size_pixels,
+                                 const absl::optional<FontRenderParams>& params)
+    : PlatformFontMac(
+          base::mac::CFToNSCast(SkTypeface_GetCTFontRef(typeface.get())),
+          SystemFontTypeFromUndocumentedCTFontRefInternals(
+              SkTypeface_GetCTFontRef(typeface.get())),
+          {GetFamilyNameFromTypeface(typeface), font_size_pixels,
+           (typeface->isItalic() ? Font::ITALIC : Font::NORMAL),
+           FontWeightFromInt(typeface->fontStyle().weight())}) {}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontMac, PlatformFont implementation:
+
+Font PlatformFontMac::DeriveFont(int size_delta,
+                                 int style,
+                                 Weight weight) const {
+  // What doesn't work?
+  //
+  // For all fonts, -[NSFontManager convertWeight:ofFont:] will reliably
+  // misbehave, skipping over particular weights of fonts, refusing to go
+  // lighter than regular unless you go heavier first, and in earlier versions
+  // of the system would accidentally introduce italic fonts when changing
+  // weights from a non-italic instance.
+  //
+  // For system fonts, -[NSFontManager convertFont:to(Not)HaveTrait:], if used
+  // to change weight, will sometimes switch to a compatibility system font that
+  // does not have all the weights available.
+  //
+  // For system fonts, the most reliable call to use is +[NSFont
+  // systemFontOfSize:weight:]. This uses the new-style NSFontWeight which maps
+  // perfectly to the ISO weights that Chromium uses. For non-system fonts,
+  // -[NSFontManager fontWithFamily:traits:weight:size:] is the only reasonable
+  // way to query fonts with more granularity than bold/non-bold short of
+  // walking the font family and querying their kCTFontWeightTrait values. Font
+  // descriptors hold promise but querying using them often fails to find fonts
+  // that match; hopefully their matching abilities will improve in future
+  // versions of the macOS.
+
+  if (system_font_type_ == SystemFontType::kGeneral) {
+    NSFont* derived = [NSFont systemFontOfSize:font_spec_.size + size_delta
+                                        weight:ToNSFontWeight(weight)];
+    NSFontTraitMask italic_trait_mask =
+        (style & Font::ITALIC) ? NSItalicFontMask : NSUnitalicFontMask;
+    derived = [[NSFontManager sharedFontManager] convertFont:derived
+                                                 toHaveTrait:italic_trait_mask];
+
+    return Font(new PlatformFontMac(
+        derived, SystemFontType::kGeneral,
+        {font_spec_.name, font_spec_.size + size_delta, style, weight}));
+  } else if (system_font_type_ == SystemFontType::kMenu) {
+    NSFont* derived = [NSFont menuFontOfSize:font_spec_.size + size_delta];
+    return Font(new PlatformFontMac(
+        derived, SystemFontType::kMenu,
+        {font_spec_.name, font_spec_.size + size_delta, style, weight}));
+  } else if (system_font_type_ == SystemFontType::kToolTip) {
+    NSFont* derived = [NSFont toolTipsFontOfSize:font_spec_.size + size_delta];
+    return Font(new PlatformFontMac(
+        derived, SystemFontType::kToolTip,
+        {font_spec_.name, font_spec_.size + size_delta, style, weight}));
+  } else {
+    NSFont* derived = NSFontWithSpec(
+        {font_spec_.name, font_spec_.size + size_delta, style, weight});
+    return Font(new PlatformFontMac(
+        derived, absl::nullopt,
+        {font_spec_.name, font_spec_.size + size_delta, style, weight}));
+  }
+}
+
+int PlatformFontMac::GetHeight() {
+  return height_;
+}
+
+int PlatformFontMac::GetBaseline() {
+  return ascent_;
+}
+
+int PlatformFontMac::GetCapHeight() {
+  return cap_height_;
+}
+
+int PlatformFontMac::GetExpectedTextWidth(int length) {
+  if (!average_width_) {
+    // -[NSFont boundingRectForGlyph:] seems to always return the largest
+    // bounding rect that could be needed, which produces very wide expected
+    // widths for strings. Instead, compute the actual width of a string
+    // containing all the lowercase characters to find a reasonable guess at the
+    // average.
+    base::scoped_nsobject<NSAttributedString> attr_string(
+        [[NSAttributedString alloc]
+            initWithString:@"abcdefghijklmnopqrstuvwxyz"
+                attributes:@{NSFontAttributeName : native_font_.get()}]);
+    average_width_ = [attr_string size].width / [attr_string length];
+    DCHECK_NE(0, average_width_);
+  }
+  return ceil(length * average_width_);
+}
+
+int PlatformFontMac::GetStyle() const {
+  return font_spec_.style;
+}
+
+Weight PlatformFontMac::GetWeight() const {
+  return font_spec_.weight;
+}
+
+const std::string& PlatformFontMac::GetFontName() const {
+  return font_spec_.name;
+}
+
+std::string PlatformFontMac::GetActualFontName() const {
+  return base::SysNSStringToUTF8([native_font_ familyName]);
+}
+
+int PlatformFontMac::GetFontSize() const {
+  return font_spec_.size;
+}
+
+const FontRenderParams& PlatformFontMac::GetFontRenderParams() {
+  return render_params_;
+}
+
+NativeFont PlatformFontMac::GetNativeFont() const {
+  return [[native_font_.get() retain] autorelease];
+}
+
+sk_sp<SkTypeface> PlatformFontMac::GetNativeSkTypeface() const {
+  return SkMakeTypefaceFromCTFont(base::mac::NSToCFCast(GetNativeFont()));
+}
+
+// static
+Weight PlatformFontMac::GetFontWeightFromNSFontForTesting(NSFont* font) {
+  return GetFontWeightFromNSFont(font);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontMac, private:
+
+PlatformFontMac::PlatformFontMac(
+    NativeFont font,
+    absl::optional<SystemFontType> system_font_type)
+    : PlatformFontMac(
+          font,
+          system_font_type,
+          {base::SysNSStringToUTF8([font familyName]),
+           base::ClampRound([font pointSize]), GetFontStyleFromNSFont(font),
+           GetFontWeightFromNSFont(font)}) {}
+
+PlatformFontMac::PlatformFontMac(
+    NativeFont font,
+    absl::optional<SystemFontType> system_font_type,
+    FontSpec spec)
+    : native_font_([font retain]),
+      system_font_type_(system_font_type),
+      font_spec_(spec) {
+#if DCHECK_IS_ON()
+  DCHECK(system_font_type.has_value() ||
+         SystemFontNames().count(spec.name) == 0)
+      << "Do not pass a system font (" << spec.name << ") to PlatformFontMac; "
+      << "use the SystemFontType constructor. Extend the SystemFontType enum "
+      << "if necessary.";
+#endif  // DCHECK_IS_ON()
+  CalculateMetricsAndInitRenderParams();
+}
+
+PlatformFontMac::~PlatformFontMac() {
+}
+
+void PlatformFontMac::CalculateMetricsAndInitRenderParams() {
+  NSFont* font = native_font_.get();
+  DCHECK(font);
+  ascent_ = ceil([font ascender]);
+  cap_height_ = ceil([font capHeight]);
+
+  // PlatformFontMac once used -[NSLayoutManager defaultLineHeightForFont:] to
+  // initialize |height_|. However, it has a silly rounding bug. Essentially, it
+  // gives round(ascent) + round(descent). E.g. Helvetica Neue at size 16 gives
+  // ascent=15.4634, descent=3.38208 -> 15 + 3 = 18. When the height should be
+  // at least 19. According to the OpenType specification, these values should
+  // simply be added, so do that. Note this uses the already-rounded |ascent_|
+  // to ensure GetBaseline() + descender fits within GetHeight() during layout.
+  height_ = ceil(ascent_ + std::abs([font descender]) + [font leading]);
+
+  FontRenderParamsQuery query;
+  query.families.push_back(font_spec_.name);
+  query.pixel_size = font_spec_.size;
+  query.style = font_spec_.style;
+  query.weight = font_spec_.weight;
+  render_params_ = gfx::GetFontRenderParams(query, nullptr);
+}
+
+NSFont* PlatformFontMac::NSFontWithSpec(FontSpec font_spec) const {
+  // One might think that a font descriptor with the NSFontWeightTrait/
+  // kCTFontWeightTrait trait could be used to look up a font with a specific
+  // weight. That doesn't work, though. You can ask a font for its weight, but
+  // you can't use weight to query for the font.
+  //
+  // The way that does work is to use the old-style integer weight API.
+
+  NSFontManager* font_manager = [NSFontManager sharedFontManager];
+
+  NSFontTraitMask traits = 0;
+  if (font_spec.style & Font::ITALIC)
+    traits |= NSItalicFontMask;
+  // The Mac doesn't support underline as a font trait, so just drop it.
+  // (Underlines must be added as an attribute on an NSAttributedString.) Do not
+  // add NSBoldFontMask here; if it is added then the weight parameter below
+  // will be ignored.
+
+  NSFont* font =
+      [font_manager fontWithFamily:base::SysUTF8ToNSString(font_spec.name)
+                            traits:traits
+                            weight:ToNSFontManagerWeight(font_spec.weight)
+                              size:font_spec.size];
+  if (font)
+    return font;
+
+  // Make one fallback attempt by looking up via font name rather than font
+  // family name. With this API, the available granularity of font weight is
+  // bold/not-bold, but that's what's available.
+  NSFontSymbolicTraits trait_bits = 0;
+  if (font_spec.weight >= Weight::BOLD)
+    trait_bits |= NSFontBoldTrait;
+  if (font_spec.style & Font::ITALIC)
+    trait_bits |= NSFontItalicTrait;
+
+  NSDictionary* attrs = @{
+    NSFontNameAttribute : base::SysUTF8ToNSString(font_spec.name),
+    NSFontTraitsAttribute : @{NSFontSymbolicTrait : @(trait_bits)},
+  };
+  NSFontDescriptor* descriptor =
+      [NSFontDescriptor fontDescriptorWithFontAttributes:attrs];
+
+  font = [NSFont fontWithDescriptor:descriptor size:font_spec.size];
+  if (font)
+    return font;
+
+  // If that doesn't find a font, whip up a system font to stand in for the
+  // specified font.
+  font = [NSFont systemFontOfSize:font_spec.size
+                           weight:ToNSFontWeight(font_spec.weight)];
+  return [font_manager convertFont:font toHaveTrait:traits];
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFont, public:
+
+// static
+PlatformFont* PlatformFont::CreateDefault() {
+  return new PlatformFontMac(PlatformFontMac::SystemFontType::kGeneral);
+}
+
+// static
+PlatformFont* PlatformFont::CreateFromNativeFont(NativeFont native_font) {
+  return new PlatformFontMac(native_font);
+}
+
+// static
+PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
+                                                  int font_size) {
+  return new PlatformFontMac(font_name, font_size);
+}
+
+// static
+PlatformFont* PlatformFont::CreateFromSkTypeface(
+    sk_sp<SkTypeface> typeface,
+    int font_size_pixels,
+    const absl::optional<FontRenderParams>& params) {
+  return new PlatformFontMac(typeface, font_size_pixels, params);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/platform_font_mac_unittest.mm b/ui/gfx/platform_font_mac_unittest.mm
new file mode 100644
index 0000000..46b2e6d
--- /dev/null
+++ b/ui/gfx/platform_font_mac_unittest.mm
@@ -0,0 +1,243 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/platform_font_mac.h"
+
+#include <Cocoa/Cocoa.h>
+#include <stddef.h>
+
+#include "base/cxx17_backports.h"
+#import "base/mac/foundation_util.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font.h"
+
+namespace gfx {
+
+using Weight = Font::Weight;
+
+TEST(PlatformFontMacTest, DeriveFont) {
+  // |weight_tri| is either -1, 0, or 1 meaning "light", "normal", or "bold".
+  auto CheckExpected = [](const Font& font, int weight_tri, bool isItalic) {
+    base::ScopedCFTypeRef<CFDictionaryRef> traits(
+        CTFontCopyTraits(base::mac::NSToCFCast(font.GetNativeFont())));
+    DCHECK(traits);
+
+    CFNumberRef cf_slant = base::mac::GetValueFromDictionary<CFNumberRef>(
+        traits, kCTFontSlantTrait);
+    CGFloat slant;
+    CFNumberGetValue(cf_slant, kCFNumberCGFloatType, &slant);
+    if (isItalic)
+      EXPECT_GT(slant, 0);
+    else
+      EXPECT_EQ(slant, 0);
+
+    CFNumberRef cf_weight = base::mac::GetValueFromDictionary<CFNumberRef>(
+        traits, kCTFontWeightTrait);
+    CGFloat weight;
+    CFNumberGetValue(cf_weight, kCFNumberCGFloatType, &weight);
+    if (weight_tri < 0)
+      EXPECT_LT(weight, 0);
+    else if (weight_tri == 0)
+      EXPECT_EQ(weight, 0);
+    else
+      EXPECT_GT(weight, 0);
+  };
+
+  // Use a base font that support all traits.
+  Font base_font("Helvetica", 13);
+  {
+    SCOPED_TRACE("plain font");
+    CheckExpected(base_font, 0, false);
+  }
+
+  // Italic
+  Font italic_font(base_font.Derive(0, Font::ITALIC, Weight::NORMAL));
+  {
+    SCOPED_TRACE("italic font");
+    CheckExpected(italic_font, 0, true);
+  }
+
+  // Bold
+  Font bold_font(base_font.Derive(0, Font::NORMAL, Weight::BOLD));
+  {
+    SCOPED_TRACE("bold font");
+    CheckExpected(bold_font, 1, false);
+  }
+
+  // Bold italic
+  Font bold_italic_font(base_font.Derive(0, Font::ITALIC, Weight::BOLD));
+  {
+    SCOPED_TRACE("bold italic font");
+    CheckExpected(bold_italic_font, 1, true);
+  }
+
+  // Non-existent thin will return the closest weight, light
+  Font thin_font(base_font.Derive(0, Font::NORMAL, Weight::THIN));
+  {
+    SCOPED_TRACE("thin font");
+    CheckExpected(thin_font, -1, false);
+  }
+
+  // Non-existent black will return the closest weight, bold
+  Font black_font(base_font.Derive(0, Font::NORMAL, Weight::BLACK));
+  {
+    SCOPED_TRACE("black font");
+    CheckExpected(black_font, 1, false);
+  }
+}
+
+TEST(PlatformFontMacTest, DeriveFontUnderline) {
+  // Create a default font.
+  Font base_font;
+
+  // Make the font underlined.
+  Font derived_font(base_font.Derive(0, base_font.GetStyle() | Font::UNDERLINE,
+                                     base_font.GetWeight()));
+
+  // Validate the derived font properties against its native font instance.
+  NSFontTraitMask traits = [[NSFontManager sharedFontManager]
+      traitsOfFont:derived_font.GetNativeFont()];
+  Weight actual_weight =
+      (traits & NSFontBoldTrait) ? Weight::BOLD : Weight::NORMAL;
+
+  int actual_style = Font::UNDERLINE;
+  if (traits & NSFontItalicTrait)
+    actual_style |= Font::ITALIC;
+
+  EXPECT_TRUE(derived_font.GetStyle() & Font::UNDERLINE);
+  EXPECT_EQ(derived_font.GetStyle(), actual_style);
+  EXPECT_EQ(derived_font.GetWeight(), actual_weight);
+}
+
+// Tests internal methods for extracting Font properties from the
+// underlying CTFont representation.
+TEST(PlatformFontMacTest, ConstructFromNativeFont) {
+  Font light_font([NSFont fontWithName:@"Helvetica-Light" size:12]);
+  EXPECT_EQ(12, light_font.GetFontSize());
+  EXPECT_EQ("Helvetica", light_font.GetFontName());
+  EXPECT_EQ(Font::NORMAL, light_font.GetStyle());
+  EXPECT_EQ(Weight::LIGHT, light_font.GetWeight());
+
+  Font light_italic_font([NSFont fontWithName:@"Helvetica-LightOblique"
+                                         size:14]);
+  EXPECT_EQ(14, light_italic_font.GetFontSize());
+  EXPECT_EQ("Helvetica", light_italic_font.GetFontName());
+  EXPECT_EQ(Font::ITALIC, light_italic_font.GetStyle());
+  EXPECT_EQ(Weight::LIGHT, light_italic_font.GetWeight());
+
+  Font normal_font([NSFont fontWithName:@"Helvetica" size:12]);
+  EXPECT_EQ(12, normal_font.GetFontSize());
+  EXPECT_EQ("Helvetica", normal_font.GetFontName());
+  EXPECT_EQ(Font::NORMAL, normal_font.GetStyle());
+  EXPECT_EQ(Weight::NORMAL, normal_font.GetWeight());
+
+  Font italic_font([NSFont fontWithName:@"Helvetica-Oblique" size:14]);
+  EXPECT_EQ(14, italic_font.GetFontSize());
+  EXPECT_EQ("Helvetica", italic_font.GetFontName());
+  EXPECT_EQ(Font::ITALIC, italic_font.GetStyle());
+  EXPECT_EQ(Weight::NORMAL, italic_font.GetWeight());
+
+  Font bold_font([NSFont fontWithName:@"Helvetica-Bold" size:12]);
+  EXPECT_EQ(12, bold_font.GetFontSize());
+  EXPECT_EQ("Helvetica", bold_font.GetFontName());
+  EXPECT_EQ(Font::NORMAL, bold_font.GetStyle());
+  EXPECT_EQ(Weight::BOLD, bold_font.GetWeight());
+
+  Font bold_italic_font([NSFont fontWithName:@"Helvetica-BoldOblique" size:14]);
+  EXPECT_EQ(14, bold_italic_font.GetFontSize());
+  EXPECT_EQ("Helvetica", bold_italic_font.GetFontName());
+  EXPECT_EQ(Font::ITALIC, bold_italic_font.GetStyle());
+  EXPECT_EQ(Weight::BOLD, bold_italic_font.GetWeight());
+}
+
+// Test font derivation for fine-grained font weights.
+TEST(PlatformFontMacTest, DerivedFineGrainedFonts) {
+  // The resulting, actual font weight after deriving |weight| from |base|.
+  auto DerivedIntWeight = [](Weight weight) {
+    Font base;  // The default system font.
+    Font derived(base.Derive(0, 0, weight));
+    // PlatformFont should always pass the requested weight, not what the OS
+    // could provide. This just checks a constructor argument, so not very
+    // interesting.
+    EXPECT_EQ(static_cast<int>(weight), static_cast<int>(derived.GetWeight()));
+
+    return static_cast<int>(PlatformFontMac::GetFontWeightFromNSFontForTesting(
+        derived.GetNativeFont()));
+  };
+
+  EXPECT_EQ(static_cast<int>(Weight::THIN), DerivedIntWeight(Weight::THIN));
+  EXPECT_EQ(static_cast<int>(Weight::EXTRA_LIGHT),
+            DerivedIntWeight(Weight::EXTRA_LIGHT));
+  EXPECT_EQ(static_cast<int>(Weight::LIGHT), DerivedIntWeight(Weight::LIGHT));
+  EXPECT_EQ(static_cast<int>(Weight::NORMAL), DerivedIntWeight(Weight::NORMAL));
+  EXPECT_EQ(static_cast<int>(Weight::MEDIUM), DerivedIntWeight(Weight::MEDIUM));
+  EXPECT_EQ(static_cast<int>(Weight::SEMIBOLD),
+            DerivedIntWeight(Weight::SEMIBOLD));
+  EXPECT_EQ(static_cast<int>(Weight::BOLD), DerivedIntWeight(Weight::BOLD));
+  EXPECT_EQ(static_cast<int>(Weight::EXTRA_BOLD),
+            DerivedIntWeight(Weight::EXTRA_BOLD));
+  EXPECT_EQ(static_cast<int>(Weight::BLACK), DerivedIntWeight(Weight::BLACK));
+}
+
+// Ensures that the Font's reported height is consistent with the native font's
+// ascender and descender metrics.
+TEST(PlatformFontMacTest, ValidateFontHeight) {
+  // Use the default ResourceBundle system font. E.g. Helvetica Neue in 10.10,
+  // Lucida Grande before that, and San Francisco after.
+  Font default_font;
+  Font::FontStyle styles[] = {Font::NORMAL, Font::ITALIC, Font::UNDERLINE};
+
+  for (size_t i = 0; i < base::size(styles); ++i) {
+    SCOPED_TRACE(testing::Message() << "Font::FontStyle: " << styles[i]);
+    // Include the range of sizes used by ResourceBundle::FontStyle (-1 to +8).
+    for (int delta = -1; delta <= 8; ++delta) {
+      Font font = default_font.Derive(delta, styles[i], Weight::NORMAL);
+      SCOPED_TRACE(testing::Message() << "FontSize(): " << font.GetFontSize());
+      NSFont* native_font = font.GetNativeFont();
+
+      // Font height (an integer) should be the sum of these.
+      CGFloat ascender = [native_font ascender];
+      CGFloat descender = [native_font descender];
+      CGFloat leading = [native_font leading];
+
+      // NSFont always gives a negative value for descender. Others positive.
+      EXPECT_GE(0, descender);
+      EXPECT_LE(0, ascender);
+      EXPECT_LE(0, leading);
+
+      int sum = ceil(ascender - descender + leading);
+
+      // Text layout is performed using an integral baseline offset derived from
+      // the ascender. The height needs to be enough to fit the full descender
+      // (plus baseline). So the height depends on the rounding of the ascender,
+      // and can be as much as 1 greater than the simple sum of floats.
+      EXPECT_LE(sum, font.GetHeight());
+      EXPECT_GE(sum + 1, font.GetHeight());
+
+      // Recreate the rounding performed for GetBaseLine().
+      EXPECT_EQ(ceil(ceil(ascender) - descender + leading), font.GetHeight());
+    }
+  }
+}
+
+// Test to ensure we cater for the AppKit quirk that can make the font italic
+// when asking for a fine-grained weight. See http://crbug.com/742261. Note that
+// Appkit's bug was detected on macOS 10.10 which uses Helvetica Neue as the
+// system font.
+TEST(PlatformFontMacTest, DerivedSemiboldFontIsNotItalic) {
+  Font base_font;
+  {
+    NSFontTraitMask traits = [[NSFontManager sharedFontManager]
+        traitsOfFont:base_font.GetNativeFont()];
+    ASSERT_FALSE(traits & NSItalicFontMask);
+  }
+
+  Font semibold_font(base_font.Derive(0, Font::NORMAL, Weight::SEMIBOLD));
+  NSFontTraitMask traits = [[NSFontManager sharedFontManager]
+      traitsOfFont:semibold_font.GetNativeFont()];
+  EXPECT_FALSE(traits & NSItalicFontMask);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/platform_font_skia.cc b/ui/gfx/platform_font_skia.cc
new file mode 100644
index 0000000..fe80a2c
--- /dev/null
+++ b/ui/gfx/platform_font_skia.cc
@@ -0,0 +1,469 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/platform_font_skia.h"
+
+#include <algorithm>
+#include <string>
+
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_split.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
+#include "third_party/skia/include/core/SkFont.h"
+#include "third_party/skia/include/core/SkFontMetrics.h"
+#include "third_party/skia/include/core/SkFontStyle.h"
+#include "third_party/skia/include/core/SkString.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/skia_font_delegate.h"
+#include "ui/gfx/text_utils.h"
+
+#if defined(OS_WIN)
+#include "ui/gfx/system_fonts_win.h"
+#endif
+
+namespace gfx {
+namespace {
+
+// The font family name which is used when a user's application font for
+// GNOME/KDE is a non-scalable one. The name should be listed in the
+// IsFallbackFontAllowed function in skia/ext/SkFontHost_fontconfig_direct.cpp.
+#if defined(OS_ANDROID)
+const char kFallbackFontFamilyName[] = "serif";
+#else
+const char kFallbackFontFamilyName[] = "sans";
+#endif
+
+constexpr SkGlyphID kUnsupportedGlyph = 0;
+
+// The default font, used for the default constructor.
+base::LazyInstance<scoped_refptr<PlatformFontSkia>>::Leaky g_default_font =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Creates a SkTypeface for the passed-in Font::FontStyle and family. If a
+// fallback typeface is used instead of the requested family, |family| will be
+// updated to contain the fallback's family name.
+sk_sp<SkTypeface> CreateSkTypeface(bool italic,
+                                   gfx::Font::Weight weight,
+                                   std::string* family,
+                                   bool* out_success) {
+  DCHECK(family);
+  TRACE_EVENT0("fonts", "gfx::CreateSkTypeface");
+
+  const int font_weight = (weight == Font::Weight::INVALID)
+                              ? static_cast<int>(Font::Weight::NORMAL)
+                              : static_cast<int>(weight);
+  SkFontStyle sk_style(
+      font_weight, SkFontStyle::kNormal_Width,
+      italic ? SkFontStyle::kItalic_Slant : SkFontStyle::kUpright_Slant);
+  sk_sp<SkTypeface> typeface;
+  {
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("fonts"), "SkTypeface::MakeFromName",
+                 "family", *family);
+    typeface = SkTypeface::MakeFromName(family->c_str(), sk_style);
+  }
+  if (!typeface) {
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("fonts"), "SkTypeface::MakeFromName",
+                 "family", kFallbackFontFamilyName);
+    // A non-scalable font such as .pcf is specified. Fall back to a default
+    // scalable font.
+    typeface = sk_sp<SkTypeface>(
+        SkTypeface::MakeFromName(kFallbackFontFamilyName, sk_style));
+    if (!typeface) {
+      *out_success = false;
+      return nullptr;
+    }
+    *family = kFallbackFontFamilyName;
+  }
+  *out_success = true;
+  return typeface;
+}
+
+}  // namespace
+
+std::string* PlatformFontSkia::default_font_description_ = NULL;
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontSkia, public:
+
+PlatformFontSkia::PlatformFontSkia() {
+  CHECK(InitDefaultFont()) << "Could not find the default font";
+  InitFromPlatformFont(g_default_font.Get().get());
+}
+
+PlatformFontSkia::PlatformFontSkia(const std::string& font_name,
+                                   int font_size_pixels) {
+  FontRenderParamsQuery query;
+  query.families.push_back(font_name);
+  query.pixel_size = font_size_pixels;
+  query.weight = Font::Weight::NORMAL;
+  InitFromDetails(nullptr, font_name, font_size_pixels, Font::NORMAL,
+                  query.weight, gfx::GetFontRenderParams(query, nullptr));
+}
+
+PlatformFontSkia::PlatformFontSkia(
+    sk_sp<SkTypeface> typeface,
+    int font_size_pixels,
+    const absl::optional<FontRenderParams>& params) {
+  DCHECK(typeface);
+
+  SkString family_name;
+  typeface->getFamilyName(&family_name);
+
+  SkFontStyle font_style = typeface->fontStyle();
+  Font::Weight font_weight = FontWeightFromInt(font_style.weight());
+
+  int style = typeface->isItalic() ? Font::ITALIC : Font::NORMAL;
+
+  FontRenderParams actual_render_params;
+  if (!params) {
+    FontRenderParamsQuery query;
+    query.families.push_back(family_name.c_str());
+    query.pixel_size = font_size_pixels;
+    query.weight = font_weight;
+    actual_render_params = gfx::GetFontRenderParams(query, nullptr);
+  } else {
+    actual_render_params = params.value();
+  }
+
+  InitFromDetails(std::move(typeface), family_name.c_str(), font_size_pixels,
+                  style, font_weight, actual_render_params);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontSkia, PlatformFont implementation:
+
+// static
+bool PlatformFontSkia::InitDefaultFont() {
+  if (g_default_font.Get())
+    return true;
+
+  bool success = false;
+  std::string family = kFallbackFontFamilyName;
+  int size_pixels = PlatformFont::kDefaultBaseFontSize;
+  int style = Font::NORMAL;
+  Font::Weight weight = Font::Weight::NORMAL;
+  FontRenderParams params;
+
+#if defined(OS_WIN)
+  // On windows, the system default font is retrieved by using the GDI API
+  // SystemParametersInfo(...) (see struct NONCLIENTMETRICS). The font
+  // properties need to be converted as close as possible to a skia font.
+  // The style must be kept (see http://crbug/989476).
+  gfx::Font system_font = win::GetDefaultSystemFont();
+  family = system_font.GetFontName();
+  size_pixels = system_font.GetFontSize();
+  style = system_font.GetStyle();
+  weight = system_font.GetWeight();
+#endif  // OS_WIN
+
+  // On Linux, SkiaFontDelegate is used to query the native toolkit (e.g.
+  // GTK+) for the default UI font.
+  const SkiaFontDelegate* delegate = SkiaFontDelegate::instance();
+  if (delegate) {
+    delegate->GetDefaultFontDescription(&family, &size_pixels, &style, &weight,
+                                        &params);
+  } else if (default_font_description_) {
+#if BUILDFLAG(IS_CHROMEOS_ASH) || BUILDFLAG(IS_CHROMEOS_LACROS)
+    // On ChromeOS, a FontList font description string is stored as a
+    // translatable resource and passed in via SetDefaultFontDescription().
+    FontRenderParamsQuery query;
+    CHECK(FontList::ParseDescription(*default_font_description_,
+                                     &query.families, &query.style,
+                                     &query.pixel_size, &query.weight))
+        << "Failed to parse font description " << *default_font_description_;
+    params = gfx::GetFontRenderParams(query, &family);
+    size_pixels = query.pixel_size;
+    style = query.style;
+    weight = query.weight;
+#else
+    NOTREACHED();
+#endif
+  } else {
+    params = gfx::GetFontRenderParams(FontRenderParamsQuery(), nullptr);
+  }
+
+  sk_sp<SkTypeface> typeface =
+      CreateSkTypeface(style & Font::ITALIC, weight, &family, &success);
+  if (!success)
+    return false;
+  g_default_font.Get() = new PlatformFontSkia(
+      std::move(typeface), family, size_pixels, style, weight, params);
+  return true;
+}
+
+// static
+void PlatformFontSkia::ReloadDefaultFont() {
+  // Reset the scoped_refptr.
+  g_default_font.Get() = nullptr;
+}
+
+// static
+void PlatformFontSkia::SetDefaultFontDescription(
+    const std::string& font_description) {
+  delete default_font_description_;
+  default_font_description_ = new std::string(font_description);
+}
+
+Font PlatformFontSkia::DeriveFont(int size_delta,
+                                  int style,
+                                  Font::Weight weight) const {
+#if defined(OS_WIN)
+  const int new_size = win::AdjustFontSize(font_size_pixels_, size_delta);
+#else
+  const int new_size = font_size_pixels_ + size_delta;
+#endif
+
+  DCHECK_GT(new_size, 0);
+
+  // If the style changed, we may need to load a new face.
+  std::string new_family = font_family_;
+  bool success = true;
+  sk_sp<SkTypeface> typeface =
+      (weight == weight_ && style == style_)
+          ? typeface_
+          : CreateSkTypeface(style, weight, &new_family, &success);
+  if (!success) {
+    LOG(ERROR) << "Could not find any font: " << new_family << ", "
+               << kFallbackFontFamilyName << ". Falling back to the default";
+    return Font(new PlatformFontSkia);
+  }
+
+  FontRenderParamsQuery query;
+  query.families.push_back(new_family);
+  query.pixel_size = new_size;
+  query.style = style;
+
+  return Font(new PlatformFontSkia(std::move(typeface), new_family, new_size,
+                                   style, weight,
+                                   gfx::GetFontRenderParams(query, NULL)));
+}
+
+int PlatformFontSkia::GetHeight() {
+  ComputeMetricsIfNecessary();
+  return height_pixels_;
+}
+
+Font::Weight PlatformFontSkia::GetWeight() const {
+  return weight_;
+}
+
+int PlatformFontSkia::GetBaseline() {
+  ComputeMetricsIfNecessary();
+  return ascent_pixels_;
+}
+
+int PlatformFontSkia::GetCapHeight() {
+  ComputeMetricsIfNecessary();
+  return cap_height_pixels_;
+}
+
+int PlatformFontSkia::GetExpectedTextWidth(int length) {
+  ComputeMetricsIfNecessary();
+  return round(static_cast<float>(length) * average_width_pixels_);
+}
+
+int PlatformFontSkia::GetStyle() const {
+  return style_;
+}
+
+const std::string& PlatformFontSkia::GetFontName() const {
+  return font_family_;
+}
+
+std::string PlatformFontSkia::GetActualFontName() const {
+  SkString family_name;
+  typeface_->getFamilyName(&family_name);
+  return family_name.c_str();
+}
+
+int PlatformFontSkia::GetFontSize() const {
+  return font_size_pixels_;
+}
+
+const FontRenderParams& PlatformFontSkia::GetFontRenderParams() {
+  TRACE_EVENT0("fonts", "PlatformFontSkia::GetFontRenderParams");
+  float current_scale_factor = GetFontRenderParamsDeviceScaleFactor();
+  if (current_scale_factor != device_scale_factor_) {
+    FontRenderParamsQuery query;
+    query.families.push_back(font_family_);
+    query.pixel_size = font_size_pixels_;
+    query.style = style_;
+    query.weight = weight_;
+    query.device_scale_factor = current_scale_factor;
+    font_render_params_ = gfx::GetFontRenderParams(query, nullptr);
+    device_scale_factor_ = current_scale_factor;
+  }
+  return font_render_params_;
+}
+
+sk_sp<SkTypeface> PlatformFontSkia::GetNativeSkTypeface() const {
+  DCHECK(typeface_);
+  return sk_sp<SkTypeface>(typeface_);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFontSkia, private:
+
+PlatformFontSkia::PlatformFontSkia(sk_sp<SkTypeface> typeface,
+                                   const std::string& family,
+                                   int size_pixels,
+                                   int style,
+                                   Font::Weight weight,
+                                   const FontRenderParams& render_params) {
+  InitFromDetails(std::move(typeface), family, size_pixels, style, weight,
+                  render_params);
+}
+
+PlatformFontSkia::~PlatformFontSkia() {}
+
+void PlatformFontSkia::InitFromDetails(sk_sp<SkTypeface> typeface,
+                                       const std::string& font_family,
+                                       int font_size_pixels,
+                                       int style,
+                                       Font::Weight weight,
+                                       const FontRenderParams& render_params) {
+  TRACE_EVENT0("fonts", "PlatformFontSkia::InitFromDetails");
+  DCHECK_GT(font_size_pixels, 0);
+
+  font_family_ = font_family;
+  bool success = true;
+  typeface_ = typeface ? std::move(typeface)
+                       : CreateSkTypeface(style & Font::ITALIC, weight,
+                                          &font_family_, &success);
+
+  if (!success) {
+    LOG(ERROR) << "Could not find any font: " << font_family << ", "
+               << kFallbackFontFamilyName << ". Falling back to the default";
+
+    InitFromPlatformFont(g_default_font.Get().get());
+    return;
+  }
+
+  font_size_pixels_ = font_size_pixels;
+  style_ = style;
+  weight_ = weight;
+  device_scale_factor_ = GetFontRenderParamsDeviceScaleFactor();
+  font_render_params_ = render_params;
+}
+
+void PlatformFontSkia::InitFromPlatformFont(const PlatformFontSkia* other) {
+  TRACE_EVENT0("fonts", "PlatformFontSkia::InitFromPlatformFont");
+  typeface_ = other->typeface_;
+  font_family_ = other->font_family_;
+  font_size_pixels_ = other->font_size_pixels_;
+  style_ = other->style_;
+  weight_ = other->weight_;
+  device_scale_factor_ = other->device_scale_factor_;
+  font_render_params_ = other->font_render_params_;
+
+  if (!other->metrics_need_computation_) {
+    metrics_need_computation_ = false;
+    ascent_pixels_ = other->ascent_pixels_;
+    height_pixels_ = other->height_pixels_;
+    cap_height_pixels_ = other->cap_height_pixels_;
+    average_width_pixels_ = other->average_width_pixels_;
+  }
+}
+
+void PlatformFontSkia::ComputeMetricsIfNecessary() {
+  if (metrics_need_computation_) {
+    TRACE_EVENT0("fonts", "PlatformFontSkia::ComputeMetricsIfNecessary");
+
+    metrics_need_computation_ = false;
+
+    SkFont font(typeface_, font_size_pixels_);
+    const FontRenderParams& params = GetFontRenderParams();
+    if (!params.antialiasing) {
+      font.setEdging(SkFont::Edging::kAlias);
+    } else if (params.subpixel_rendering ==
+               FontRenderParams::SUBPIXEL_RENDERING_NONE) {
+      font.setEdging(SkFont::Edging::kAntiAlias);
+    } else {
+      font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+    }
+
+    font.setEmbolden(weight_ >= Font::Weight::BOLD && !typeface_->isBold());
+    font.setSkewX((Font::ITALIC & style_) && !typeface_->isItalic()
+                      ? -SK_Scalar1 / 4
+                      : 0);
+    SkFontMetrics metrics;
+    font.getMetrics(&metrics);
+    ascent_pixels_ = SkScalarCeilToInt(-metrics.fAscent);
+    cap_height_pixels_ = SkScalarCeilToInt(metrics.fCapHeight);
+
+    // There is a mismatch between the way the PlatformFontWin was computing the
+    // font height in pixel. The font height may vary by one pixel due to
+    // decimal rounding.
+    //     Windows Skia implements : ceil(descent - ascent)
+    //     Linux Skia implements   : ceil(-ascent) + ceil(descent)
+    // TODO(etienneb): Make both implementation consistent and fix the broken
+    // unittests.
+#if defined(OS_WIN)
+    height_pixels_ = SkScalarCeilToInt(metrics.fDescent - metrics.fAscent);
+#else
+    height_pixels_ = ascent_pixels_ + SkScalarCeilToInt(metrics.fDescent);
+#endif
+
+    if (metrics.fAvgCharWidth) {
+      average_width_pixels_ = SkScalarToDouble(metrics.fAvgCharWidth);
+    } else {
+      // Some Skia fonts manager do not compute the average character size
+      // (e.g. Direct Write). The following code computes the average character
+      // width the same way Blink (e.g. SimpleFontData) does. Use the width of
+      // the letter 'x' when available, otherwise use the max character width.
+      SkGlyphID glyph = typeface_->unicharToGlyph('x');
+      if (glyph != kUnsupportedGlyph) {
+        SkScalar sk_width;
+        font.getWidths(&glyph, 1, &sk_width);
+        average_width_pixels_ = SkScalarToDouble(sk_width);
+      }
+      if (!average_width_pixels_) {
+        if (metrics.fMaxCharWidth) {
+          average_width_pixels_ = SkScalarToDouble(metrics.fMaxCharWidth);
+        } else {
+          // Older version of the DirectWrite API doesn't implement support for
+          // max char width. Fall back on a multiple of the ascent. This is
+          // entirely arbitrary but comes pretty close to the expected value in
+          // most cases.
+          average_width_pixels_ = ascent_pixels_ * 2;
+        }
+      }
+    }
+    DCHECK_NE(average_width_pixels_, 0);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PlatformFont, public:
+
+// static
+PlatformFont* PlatformFont::CreateDefault() {
+  return new PlatformFontSkia;
+}
+
+// static
+PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
+                                                  int font_size) {
+  TRACE_EVENT0("fonts", "PlatformFont::CreateFromNameAndSize");
+  return new PlatformFontSkia(font_name, font_size);
+}
+
+// static
+PlatformFont* PlatformFont::CreateFromSkTypeface(
+    sk_sp<SkTypeface> typeface,
+    int font_size_pixels,
+    const absl::optional<FontRenderParams>& params) {
+  TRACE_EVENT0("fonts", "PlatformFont::CreateFromSkTypeface");
+  return new PlatformFontSkia(typeface, font_size_pixels, params);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/platform_font_skia.h b/ui/gfx/platform_font_skia.h
new file mode 100644
index 0000000..7a92f59
--- /dev/null
+++ b/ui/gfx/platform_font_skia.h
@@ -0,0 +1,121 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PLATFORM_FONT_SKIA_H_
+#define UI_GFX_PLATFORM_FONT_SKIA_H_
+
+#include <memory>
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "build/build_config.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+
+class GFX_EXPORT PlatformFontSkia : public PlatformFont {
+ public:
+  // TODO(derat): Get rid of the default constructor in favor of using
+  // FontList (which also has the concept of a default font but may contain
+  // multiple font families) everywhere. See http://crbug.com/398885#c16.
+  PlatformFontSkia();
+  PlatformFontSkia(const std::string& font_name, int font_size_pixels);
+
+  // Wraps the provided SkTypeface without triggering a font rematch.
+  PlatformFontSkia(sk_sp<SkTypeface> typeface,
+                   int font_size_pixels,
+                   const absl::optional<FontRenderParams>& params);
+
+  PlatformFontSkia(const PlatformFontSkia&) = delete;
+  PlatformFontSkia& operator=(const PlatformFontSkia&) = delete;
+
+  // Initials the default PlatformFont. Returns true if this is successful, or
+  // false if fonts resources are not available. If this returns false, the
+  // calling service should shut down.
+  static bool InitDefaultFont();
+
+  // Resets and reloads the cached system font used by the default constructor.
+  // This function is useful when the system font has changed, for example, when
+  // the locale has changed.
+  static void ReloadDefaultFont();
+
+  // Sets the default font. |font_description| is a FontList font description;
+  // only the first family will be used.
+  // TODO(sergeyu): Remove this function. Currently it is used only on ChromeOS
+  // to set the default font to the one loaded from resources.
+  //
+  static void SetDefaultFontDescription(const std::string& font_description);
+
+  // Overridden from PlatformFont:
+  Font DeriveFont(int size_delta,
+                  int style,
+                  Font::Weight weight) const override;
+  int GetHeight() override;
+  Font::Weight GetWeight() const override;
+  int GetBaseline() override;
+  int GetCapHeight() override;
+  int GetExpectedTextWidth(int length) override;
+  int GetStyle() const override;
+  const std::string& GetFontName() const override;
+  std::string GetActualFontName() const override;
+  int GetFontSize() const override;
+  const FontRenderParams& GetFontRenderParams() override;
+  sk_sp<SkTypeface> GetNativeSkTypeface() const override;
+
+ private:
+  // Create a new instance of this object with the specified properties. Called
+  // from DeriveFont.
+  PlatformFontSkia(sk_sp<SkTypeface> typeface,
+                   const std::string& family,
+                   int size_pixels,
+                   int style,
+                   Font::Weight weight,
+                   const FontRenderParams& params);
+  ~PlatformFontSkia() override;
+
+  // Initializes this object based on the passed-in details. If |typeface| is
+  // empty, a new typeface will be loaded.
+  void InitFromDetails(sk_sp<SkTypeface> typeface,
+                       const std::string& font_family,
+                       int font_size_pixels,
+                       int style,
+                       Font::Weight weight,
+                       const FontRenderParams& params);
+
+  // Initializes this object as a copy of another PlatformFontSkia.
+  void InitFromPlatformFont(const PlatformFontSkia* other);
+
+  // Computes the metrics if they have not yet been computed.
+  void ComputeMetricsIfNecessary();
+
+  sk_sp<SkTypeface> typeface_;
+
+  // Additional information about the face.
+  // Skia actually expects a family name and not a font name.
+  std::string font_family_;
+  int font_size_pixels_;
+  int style_;
+  float device_scale_factor_;
+
+  // Information describing how the font should be rendered.
+  FontRenderParams font_render_params_;
+
+  // Cached metrics, generated on demand.
+  bool metrics_need_computation_ = true;
+  int ascent_pixels_;
+  int height_pixels_;
+  int cap_height_pixels_;
+  double average_width_pixels_;
+  Font::Weight weight_;
+
+  // A font description string of the format used by FontList.
+  static std::string* default_font_description_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PLATFORM_FONT_SKIA_H_
diff --git a/ui/gfx/platform_font_skia_unittest.cc b/ui/gfx/platform_font_skia_unittest.cc
new file mode 100644
index 0000000..545f3d13
--- /dev/null
+++ b/ui/gfx/platform_font_skia_unittest.cc
@@ -0,0 +1,159 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/platform_font_skia.h"
+
+#include <string>
+
+#include "base/check_op.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/notreached.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_names_testing.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/skia_font_delegate.h"
+
+#if defined(OS_WIN)
+#include "ui/gfx/system_fonts_win.h"
+#endif
+
+namespace gfx {
+
+// Implementation of SkiaFontDelegate used to control the default font
+// description.
+class TestFontDelegate : public SkiaFontDelegate {
+ public:
+  TestFontDelegate() = default;
+
+  TestFontDelegate(const TestFontDelegate&) = delete;
+  TestFontDelegate& operator=(const TestFontDelegate&) = delete;
+
+  ~TestFontDelegate() override = default;
+
+  void set_family(const std::string& family) { family_ = family; }
+  void set_size_pixels(int size_pixels) { size_pixels_ = size_pixels; }
+  void set_style(int style) { style_ = style; }
+  void set_weight(gfx::Font::Weight weight) { weight_ = weight; }
+  void set_params(const FontRenderParams& params) { params_ = params; }
+
+  FontRenderParams GetDefaultFontRenderParams() const override {
+    NOTIMPLEMENTED();
+    return FontRenderParams();
+  }
+
+  void GetDefaultFontDescription(std::string* family_out,
+                                 int* size_pixels_out,
+                                 int* style_out,
+                                 Font::Weight* weight_out,
+                                 FontRenderParams* params_out) const override {
+    *family_out = family_;
+    *size_pixels_out = size_pixels_;
+    *style_out = style_;
+    *weight_out = weight_;
+    *params_out = params_;
+  }
+
+ private:
+  // Default values to be returned.
+  std::string family_;
+  int size_pixels_ = 0;
+  int style_ = Font::NORMAL;
+  gfx::Font::Weight weight_ = Font::Weight::NORMAL;
+  FontRenderParams params_;
+};
+
+class PlatformFontSkiaTest : public testing::Test {
+ public:
+  PlatformFontSkiaTest() = default;
+
+  PlatformFontSkiaTest(const PlatformFontSkiaTest&) = delete;
+  PlatformFontSkiaTest& operator=(const PlatformFontSkiaTest&) = delete;
+
+  ~PlatformFontSkiaTest() override = default;
+
+  void SetUp() override {
+    original_font_delegate_ = SkiaFontDelegate::instance();
+    SkiaFontDelegate::SetInstance(&test_font_delegate_);
+    PlatformFontSkia::ReloadDefaultFont();
+  }
+
+  void TearDown() override {
+    DCHECK_EQ(&test_font_delegate_, SkiaFontDelegate::instance());
+    SkiaFontDelegate::SetInstance(
+        const_cast<SkiaFontDelegate*>(original_font_delegate_));
+    PlatformFontSkia::ReloadDefaultFont();
+  }
+
+ protected:
+  TestFontDelegate test_font_delegate_;
+
+ private:
+  // Originally-registered delegate.
+  const SkiaFontDelegate* original_font_delegate_;
+};
+
+// Test that PlatformFontSkia's default constructor initializes the instance
+// with the correct parameters.
+TEST_F(PlatformFontSkiaTest, DefaultFont) {
+  test_font_delegate_.set_family(kTestFontName);
+  test_font_delegate_.set_size_pixels(13);
+  test_font_delegate_.set_style(Font::NORMAL);
+  FontRenderParams params;
+  params.antialiasing = false;
+  params.hinting = FontRenderParams::HINTING_FULL;
+  test_font_delegate_.set_params(params);
+  scoped_refptr<gfx::PlatformFontSkia> font(new gfx::PlatformFontSkia());
+  EXPECT_EQ(kTestFontName, font->GetFontName());
+  EXPECT_EQ(13, font->GetFontSize());
+  EXPECT_EQ(gfx::Font::NORMAL, font->GetStyle());
+
+  EXPECT_EQ(params.antialiasing, font->GetFontRenderParams().antialiasing);
+  EXPECT_EQ(params.hinting, font->GetFontRenderParams().hinting);
+
+  // Drop the old default font and check that new settings are loaded.
+  test_font_delegate_.set_family(kSymbolFontName);
+  test_font_delegate_.set_size_pixels(15);
+  test_font_delegate_.set_style(gfx::Font::ITALIC);
+  test_font_delegate_.set_weight(gfx::Font::Weight::BOLD);
+  PlatformFontSkia::ReloadDefaultFont();
+  scoped_refptr<gfx::PlatformFontSkia> font2(new gfx::PlatformFontSkia());
+  EXPECT_EQ(kSymbolFontName, font2->GetFontName());
+  EXPECT_EQ(15, font2->GetFontSize());
+  EXPECT_NE(font2->GetStyle() & Font::ITALIC, 0);
+  EXPECT_EQ(gfx::Font::Weight::BOLD, font2->GetWeight());
+}
+
+TEST(PlatformFontSkiaRenderParamsTest, DefaultFontRenderParams) {
+  scoped_refptr<PlatformFontSkia> default_font(new PlatformFontSkia());
+  scoped_refptr<PlatformFontSkia> named_font(new PlatformFontSkia(
+      default_font->GetFontName(), default_font->GetFontSize()));
+
+  // Ensures that both constructors are producing fonts with the same render
+  // params.
+  EXPECT_EQ(default_font->GetFontRenderParams(),
+            named_font->GetFontRenderParams());
+}
+
+#if defined(OS_WIN)
+TEST(PlatformFontSkiaOnWindowsTest, SystemFont) {
+  // Ensures that the font styles are kept while creating the default font.
+  gfx::Font system_font = win::GetDefaultSystemFont();
+  gfx::Font default_font;
+
+  EXPECT_EQ(system_font.GetFontName(), default_font.GetFontName());
+  EXPECT_EQ(system_font.GetFontSize(), default_font.GetFontSize());
+  EXPECT_EQ(system_font.GetStyle(), default_font.GetStyle());
+  EXPECT_EQ(system_font.GetWeight(), default_font.GetWeight());
+  EXPECT_EQ(system_font.GetHeight(), default_font.GetHeight());
+  EXPECT_EQ(system_font.GetBaseline(), default_font.GetBaseline());
+  EXPECT_EQ(system_font.GetBaseline(), default_font.GetBaseline());
+  EXPECT_EQ(system_font.GetFontRenderParams(),
+            default_font.GetFontRenderParams());
+}
+#endif  // OS_WIN
+
+}  // namespace gfx
diff --git a/ui/gfx/presentation_feedback.h b/ui/gfx/presentation_feedback.h
new file mode 100644
index 0000000..d1b9502
--- /dev/null
+++ b/ui/gfx/presentation_feedback.h
@@ -0,0 +1,108 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_PRESENTATION_FEEDBACK_H_
+#define UI_GFX_PRESENTATION_FEEDBACK_H_
+
+#include <stdint.h>
+
+#include "base/time/time.h"
+
+namespace gfx {
+
+// The feedback for gl::GLSurface methods |SwapBuffers|, |SwapBuffersAsync|,
+// |SwapBuffersWithBounds|, |PostSubBuffer|, |PostSubBufferAsync|,
+// |CommitOverlayPlanes|,|CommitOverlayPlanesAsync|, etc.
+struct PresentationFeedback {
+  enum Flags {
+    // The presentation was synchronized to VSYNC.
+    kVSync = 1 << 0,
+
+    // The presentation |timestamp| is converted from hardware clock by driver.
+    // Sampling a clock in user space is not acceptable for this flag.
+    kHWClock = 1 << 1,
+
+    // The display hardware signalled that it started using the new content. The
+    // opposite of this is e.g. a timer being used to guess when the display
+    // hardware has switched to the new image content.
+    kHWCompletion = 1 << 2,
+
+    // The presentation of this update was done zero-copy. Possible zero-copy
+    // cases include direct scanout of a fullscreen surface and a surface on a
+    // hardware overlay.
+    kZeroCopy = 1 << 3,
+
+    // The presentation of this update failed. |timestamp| is the time of the
+    // failure.
+    kFailure = 1 << 4,
+  };
+
+  PresentationFeedback() = default;
+  PresentationFeedback(base::TimeTicks timestamp,
+                       base::TimeDelta interval,
+                       uint32_t flags)
+      : timestamp(timestamp), interval(interval), flags(flags) {}
+
+  static PresentationFeedback Failure() {
+    return {base::TimeTicks::Now(), base::TimeDelta(), Flags::kFailure};
+  }
+
+  bool failed() const { return !!(flags & Flags::kFailure); }
+
+  // The time when a buffer begins scan-out. If a buffer is never presented on
+  // a screen, the |timestamp| will be set to the time of the failure.
+  base::TimeTicks timestamp;
+
+  // An estimated interval from the |timestamp| to the next refresh.
+  base::TimeDelta interval;
+
+  // A combination of Flags. It indicates the kind of the |timestamp|.
+  uint32_t flags = 0;
+
+  // The following are additional timestamps that are reported if available on
+  // the underlying platform. If not available, the timestamp is set to 0.
+
+  // A buffer sent to the system compositor or display controller for
+  // presentation is returned to chromium's compositor with an out fence for
+  // synchronization. This fence indicates when reads from this buffer for
+  // presentation (on the GPU or display controller) have been finished and it
+  // is safe to write new data to this buffer. Since this fence may not have
+  // been signalled when the swap for a new frame is issued, this timestamp is
+  // meant to track the latency from when a swap is issued on the GPU thread to
+  // when the GPU can start rendering to this buffer.
+  base::TimeTicks available_timestamp;
+
+  // The time when the GPU has finished completing all the drawing commands on
+  // the primary plane. On Android, SurfaceFlinger does not latch to a buffer
+  // until this fence has been signalled.
+  base::TimeTicks ready_timestamp;
+
+  // The time when the primary plane is latched by the system compositor for its
+  // next rendering update. On Android this corresponds to the SurfaceFlinger
+  // latch time.
+  base::TimeTicks latch_timestamp;
+
+  // The time when write operations have completed, corresponding to the time
+  // when rendering on the GPU finished.
+  base::TimeTicks writes_done_timestamp;
+};
+
+inline bool operator==(const PresentationFeedback& lhs,
+                       const PresentationFeedback& rhs) {
+  return lhs.timestamp == rhs.timestamp && lhs.interval == rhs.interval &&
+         lhs.flags == rhs.flags &&
+         lhs.available_timestamp == rhs.available_timestamp &&
+         lhs.ready_timestamp == rhs.ready_timestamp &&
+         lhs.latch_timestamp == rhs.latch_timestamp &&
+         lhs.writes_done_timestamp == rhs.writes_done_timestamp;
+}
+
+inline bool operator!=(const PresentationFeedback& lhs,
+                       const PresentationFeedback& rhs) {
+  return !(lhs == rhs);
+}
+
+}  // namespace gfx
+
+#endif  // UI_GFX_PRESENTATION_FEEDBACK_H_
diff --git a/ui/gfx/range/BUILD.gn b/ui/gfx/range/BUILD.gn
new file mode 100644
index 0000000..a2e2219
--- /dev/null
+++ b/ui/gfx/range/BUILD.gn
@@ -0,0 +1,24 @@
+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+component("range") {
+  sources = [
+    "gfx_range_export.h",
+    "range.cc",
+    "range.h",
+    "range_f.cc",
+    "range_f.h",
+  ]
+
+  if (is_apple) {
+    sources += [ "range_mac.mm" ]
+  }
+
+  defines = [ "GFX_RANGE_IMPLEMENTATION" ]
+
+  deps = [
+    "//base",
+    "//ui/gfx:gfx_export",
+  ]
+}
diff --git a/ui/gfx/range/OWNERS b/ui/gfx/range/OWNERS
new file mode 100644
index 0000000..14fce2a
--- /dev/null
+++ b/ui/gfx/range/OWNERS
@@ -0,0 +1 @@
+rsesek@chromium.org
diff --git a/ui/gfx/range/gfx_range_export.h b/ui/gfx/range/gfx_range_export.h
new file mode 100644
index 0000000..dafcefd
--- /dev/null
+++ b/ui/gfx/range/gfx_range_export.h
@@ -0,0 +1,29 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RANGE_GFX_RANGE_EXPORT_H_
+#define UI_GFX_RANGE_GFX_RANGE_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_RANGE_IMPLEMENTATION)
+#define GFX_RANGE_EXPORT __declspec(dllexport)
+#else
+#define GFX_RANGE_EXPORT __declspec(dllimport)
+#endif  // defined(GFX_RANGE_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_RANGE_IMPLEMENTATION)
+#define GFX_RANGE_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_RANGE_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_RANGE_EXPORT
+#endif
+
+#endif  // UI_GFX_RANGE_GFX_RANGE_EXPORT_H_
diff --git a/ui/gfx/range/mojom/BUILD.gn b/ui/gfx/range/mojom/BUILD.gn
new file mode 100644
index 0000000..3f5fa85
--- /dev/null
+++ b/ui/gfx/range/mojom/BUILD.gn
@@ -0,0 +1,61 @@
+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//mojo/public/tools/bindings/mojom.gni")
+
+# This target does NOT depend on skia. One can depend on this target to avoid
+# picking up a dependency on skia.
+mojom("mojom") {
+  generate_java = true
+  sources = [ "range.mojom" ]
+
+  shared_cpp_typemap = {
+    types = [
+      {
+        mojom = "gfx.mojom.Range"
+        cpp = "::gfx::Range"
+      },
+      {
+        mojom = "gfx.mojom.RangeF"
+        cpp = "::gfx::RangeF"
+      },
+    ]
+
+    traits_headers = [ "range_mojom_traits.h" ]
+    traits_public_deps = [ ":mojom_traits" ]
+  }
+  cpp_typemaps = [ shared_cpp_typemap ]
+  blink_cpp_typemaps = [ shared_cpp_typemap ]
+
+  webui_module_path = "chrome://resources/mojo/ui/gfx/range/mojom"
+}
+
+mojom("test_interfaces") {
+  sources = [ "range_traits_test_service.mojom" ]
+
+  public_deps = [ ":mojom" ]
+}
+
+source_set("unit_test") {
+  testonly = true
+
+  sources = [ "range_mojom_traits_unittest.cc" ]
+
+  deps = [
+    ":test_interfaces",
+    "//base",
+    "//base/test:test_support",
+    "//mojo/public/cpp/bindings",
+    "//testing/gtest",
+    "//ui/gfx/range",
+  ]
+}
+
+source_set("mojom_traits") {
+  sources = [ "range_mojom_traits.h" ]
+  public_deps = [
+    ":mojom_shared",
+    "//ui/gfx/range",
+  ]
+}
diff --git a/ui/gfx/range/mojom/DEPS b/ui/gfx/range/mojom/DEPS
new file mode 100644
index 0000000..418fc69
--- /dev/null
+++ b/ui/gfx/range/mojom/DEPS
@@ -0,0 +1,4 @@
+include_rules = [
+  "+mojo/public",
+  "+ui/gfx/range",
+]
diff --git a/ui/gfx/range/mojom/OWNERS b/ui/gfx/range/mojom/OWNERS
new file mode 100644
index 0000000..ab87d1e
--- /dev/null
+++ b/ui/gfx/range/mojom/OWNERS
@@ -0,0 +1,8 @@
+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS
+
+per-file *_mojom_traits*.*=set noparent
+per-file *_mojom_traits*.*=file://ipc/SECURITY_OWNERS
+
+per-file *.typemap=set noparent
+per-file *.typemap=file://ipc/SECURITY_OWNERS
diff --git a/ui/gfx/range/mojom/range.mojom b/ui/gfx/range/mojom/range.mojom
new file mode 100644
index 0000000..079c146
--- /dev/null
+++ b/ui/gfx/range/mojom/range.mojom
@@ -0,0 +1,15 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+struct Range {
+  uint32 start;
+  uint32 end;
+};
+
+struct RangeF {
+  float start;
+  float end;
+};
diff --git a/ui/gfx/range/mojom/range_mojom_traits.h b/ui/gfx/range/mojom/range_mojom_traits.h
new file mode 100644
index 0000000..5db4501
--- /dev/null
+++ b/ui/gfx/range/mojom/range_mojom_traits.h
@@ -0,0 +1,38 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RANGE_MOJOM_RANGE_MOJOM_TRAITS_H_
+#define UI_GFX_RANGE_MOJOM_RANGE_MOJOM_TRAITS_H_
+
+#include "ui/gfx/range/mojom/range.mojom-shared.h"
+#include "ui/gfx/range/range.h"
+#include "ui/gfx/range/range_f.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gfx::mojom::RangeDataView, gfx::Range> {
+  static uint32_t start(const gfx::Range& r) { return r.start(); }
+  static uint32_t end(const gfx::Range& r) { return r.end(); }
+  static bool Read(gfx::mojom::RangeDataView data, gfx::Range* out) {
+    out->set_start(data.start());
+    out->set_end(data.end());
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<gfx::mojom::RangeFDataView, gfx::RangeF> {
+  static float start(const gfx::RangeF& r) { return r.start(); }
+  static float end(const gfx::RangeF& r) { return r.end(); }
+  static bool Read(gfx::mojom::RangeFDataView data, gfx::RangeF* out) {
+    out->set_start(data.start());
+    out->set_end(data.end());
+    return true;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_GFX_RANGE_MOJOM_RANGE_MOJOM_TRAITS_H_
diff --git a/ui/gfx/range/mojom/range_mojom_traits_unittest.cc b/ui/gfx/range/mojom/range_mojom_traits_unittest.cc
new file mode 100644
index 0000000..ba49cb8
--- /dev/null
+++ b/ui/gfx/range/mojom/range_mojom_traits_unittest.cc
@@ -0,0 +1,70 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <utility>
+
+#include "base/test/task_environment.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/range/mojom/range_traits_test_service.mojom.h"
+
+namespace gfx {
+
+namespace {
+
+class RangeStructTraitsTest : public testing::Test,
+                              public mojom::RangeTraitsTestService {
+ public:
+  RangeStructTraitsTest() {}
+
+  RangeStructTraitsTest(const RangeStructTraitsTest&) = delete;
+  RangeStructTraitsTest& operator=(const RangeStructTraitsTest&) = delete;
+
+ protected:
+  mojo::Remote<mojom::RangeTraitsTestService> GetTraitsTestRemote() {
+    mojo::Remote<mojom::RangeTraitsTestService> remote;
+    traits_test_receivers_.Add(this, remote.BindNewPipeAndPassReceiver());
+    return remote;
+  }
+
+ private:
+  // RangeTraitsTestService:
+  void EchoRange(const Range& p, EchoRangeCallback callback) override {
+    std::move(callback).Run(p);
+  }
+
+  void EchoRangeF(const RangeF& p, EchoRangeFCallback callback) override {
+    std::move(callback).Run(p);
+  }
+
+  base::test::TaskEnvironment task_environment_;
+  mojo::ReceiverSet<RangeTraitsTestService> traits_test_receivers_;
+};
+
+}  // namespace
+
+TEST_F(RangeStructTraitsTest, Range) {
+  const uint32_t start = 1234;
+  const uint32_t end = 5678;
+  gfx::Range input(start, end);
+  mojo::Remote<mojom::RangeTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::Range output;
+  remote->EchoRange(input, &output);
+  EXPECT_EQ(start, output.start());
+  EXPECT_EQ(end, output.end());
+}
+
+TEST_F(RangeStructTraitsTest, RangeF) {
+  const float start = 1234.5f;
+  const float end = 6789.6f;
+  gfx::RangeF input(start, end);
+  mojo::Remote<mojom::RangeTraitsTestService> remote = GetTraitsTestRemote();
+  gfx::RangeF output;
+  remote->EchoRangeF(input, &output);
+  EXPECT_EQ(start, output.start());
+  EXPECT_EQ(end, output.end());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/range/mojom/range_traits_test_service.mojom b/ui/gfx/range/mojom/range_traits_test_service.mojom
new file mode 100644
index 0000000..7a0f7a9
--- /dev/null
+++ b/ui/gfx/range/mojom/range_traits_test_service.mojom
@@ -0,0 +1,17 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gfx.mojom;
+
+import "ui/gfx/range/mojom/range.mojom";
+
+// All functions on this interface echo their arguments to test StructTraits
+// serialization and deserialization.
+interface RangeTraitsTestService {
+  [Sync]
+  EchoRange(Range p) => (Range pass);
+
+  [Sync]
+  EchoRangeF(RangeF p) => (RangeF pass);
+};
diff --git a/ui/gfx/range/range.cc b/ui/gfx/range/range.cc
new file mode 100644
index 0000000..2776f3d
--- /dev/null
+++ b/ui/gfx/range/range.cc
@@ -0,0 +1,23 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/range/range.h"
+
+#include <inttypes.h>
+
+#include <algorithm>
+
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+std::string Range::ToString() const {
+  return base::StringPrintf("{%" PRIu32 ",%" PRIu32 "}", start(), end());
+}
+
+std::ostream& operator<<(std::ostream& os, const Range& range) {
+  return os << range.ToString();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/range/range.h b/ui/gfx/range/range.h
new file mode 100644
index 0000000..b2f6cc4
--- /dev/null
+++ b/ui/gfx/range/range.h
@@ -0,0 +1,141 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RANGE_RANGE_H_
+#define UI_GFX_RANGE_RANGE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <limits>
+#include <ostream>
+#include <string>
+
+#include "build/build_config.h"
+#include "ui/gfx/range/gfx_range_export.h"
+
+#if defined(OS_APPLE)
+#if __OBJC__
+#import <Foundation/Foundation.h>
+#else
+typedef struct _NSRange NSRange;
+#endif
+#endif  // defined(OS_APPLE)
+
+namespace gfx {
+
+// This class represents either a forward range [min, max) or a reverse range
+// (max, min]. |start_| is always the first of these and |end_| the second; as a
+// result, the range is forward if (start_ <= end_).  The zero-width range
+// [val, val) is legal, contains and intersects itself, and is contained by and
+// intersects any nonempty range [min, max) where min <= val < max.
+class GFX_RANGE_EXPORT Range {
+ public:
+  // Creates an empty range {0,0}.
+  constexpr Range() : Range(0) {}
+
+  // Initializes the range with a start and end.
+  constexpr Range(uint32_t start, uint32_t end) : start_(start), end_(end) {}
+
+  // Initializes the range with the same start and end positions.
+  constexpr explicit Range(uint32_t position) : Range(position, position) {}
+
+  // Platform constructors.
+#if defined(OS_APPLE)
+  explicit Range(const NSRange& range);
+#endif
+
+  // Returns a range that is invalid, which is {UINT32_MAX,UINT32_MAX}.
+  static constexpr Range InvalidRange() {
+    return Range(std::numeric_limits<uint32_t>::max());
+  }
+
+  // Checks if the range is valid through comparison to InvalidRange().
+  constexpr bool IsValid() const { return *this != InvalidRange(); }
+
+  // Getters and setters.
+  constexpr uint32_t start() const { return start_; }
+  void set_start(uint32_t start) { start_ = start; }
+
+  constexpr uint32_t end() const { return end_; }
+  void set_end(uint32_t end) { end_ = end; }
+
+  // Returns the absolute value of the length.
+  constexpr uint32_t length() const { return GetMax() - GetMin(); }
+
+  constexpr bool is_reversed() const { return start() > end(); }
+  constexpr bool is_empty() const { return start() == end(); }
+
+  // Returns the minimum and maximum values.
+  constexpr uint32_t GetMin() const {
+    return start() < end() ? start() : end();
+  }
+  constexpr uint32_t GetMax() const {
+    return start() > end() ? start() : end();
+  }
+
+  constexpr bool operator==(const Range& other) const {
+    return start() == other.start() && end() == other.end();
+  }
+  constexpr bool operator!=(const Range& other) const {
+    return !(*this == other);
+  }
+  constexpr bool EqualsIgnoringDirection(const Range& other) const {
+    return GetMin() == other.GetMin() && GetMax() == other.GetMax();
+  }
+
+  // Returns true if this range intersects the specified |range|.
+  constexpr bool Intersects(const Range& range) const {
+    return Intersect(range).IsValid();
+  }
+
+  // Returns true if this range contains the specified |range|.
+  constexpr bool Contains(const Range& range) const {
+    return range.IsBoundedBy(*this) &&
+           // A non-empty range doesn't contain the range [max, max).
+           (range.GetMax() != GetMax() || range.is_empty() == is_empty());
+  }
+
+  // Returns true if this range is contained by the specified |range| or it is
+  // an empty range and ending the range |range|.
+  constexpr bool IsBoundedBy(const Range& range) const {
+    return IsValid() && range.IsValid() && GetMin() >= range.GetMin() &&
+           GetMax() <= range.GetMax();
+  }
+
+  // Computes the intersection of this range with the given |range|.
+  // If they don't intersect, it returns an InvalidRange().
+  // The returned range is always empty or forward (never reversed).
+  constexpr Range Intersect(const Range& range) const {
+    const uint32_t min = std::max(GetMin(), range.GetMin());
+    const uint32_t max = std::min(GetMax(), range.GetMax());
+    return (min < max || Contains(range) || range.Contains(*this))
+               ? Range(min, max)
+               : InvalidRange();
+  }
+
+#if defined(OS_APPLE)
+  Range& operator=(const NSRange& range);
+
+  // NSRange does not store the directionality of a range, so if this
+  // is_reversed(), the range will get flipped when converted to an NSRange.
+  NSRange ToNSRange() const;
+#endif
+  // GTK+ has no concept of a range.
+
+  std::string ToString() const;
+
+ private:
+  // Note: we use uint32_t instead of size_t because this struct is sent over
+  // IPC which could span 32 & 64 bit processes. This is fine since text spans
+  // shouldn't exceed UINT32_MAX even on 64 bit builds.
+  uint32_t start_;
+  uint32_t end_;
+};
+
+GFX_RANGE_EXPORT std::ostream& operator<<(std::ostream& os, const Range& range);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_RANGE_RANGE_H_
diff --git a/ui/gfx/range/range_f.cc b/ui/gfx/range/range_f.cc
new file mode 100644
index 0000000..f3af360
--- /dev/null
+++ b/ui/gfx/range/range_f.cc
@@ -0,0 +1,30 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/range/range_f.h"
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <cmath>
+
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+RangeF RangeF::Intersect(const Range& range) const {
+  RangeF range_f(range.start(), range.end());
+  return Intersect(range_f);
+}
+
+std::string RangeF::ToString() const {
+  return base::StringPrintf("{%f,%f}", start(), end());
+}
+
+std::ostream& operator<<(std::ostream& os, const RangeF& range) {
+  return os << range.ToString();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/range/range_f.h b/ui/gfx/range/range_f.h
new file mode 100644
index 0000000..1d51b29
--- /dev/null
+++ b/ui/gfx/range/range_f.h
@@ -0,0 +1,116 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RANGE_RANGE_F_H_
+#define UI_GFX_RANGE_RANGE_F_H_
+
+#include <limits>
+#include <ostream>
+#include <string>
+
+#include "ui/gfx/range/gfx_range_export.h"
+#include "ui/gfx/range/range.h"
+
+namespace gfx {
+
+// A float version of Range. RangeF is made of a start and end position; when
+// they are the same, the range is empty. Note that |start_| can be greater
+// than |end_| to respect the directionality of the range.
+class GFX_RANGE_EXPORT RangeF {
+ public:
+  // Creates an empty range {0,0}.
+  constexpr RangeF() : RangeF(0.f) {}
+
+  // Initializes the range with a start and end.
+  constexpr RangeF(float start, float end) : start_(start), end_(end) {}
+
+  // Initializes the range with the same start and end positions.
+  constexpr explicit RangeF(float position) : RangeF(position, position) {}
+
+  // Returns a range that is invalid, which is {float_max,float_max}.
+  static constexpr RangeF InvalidRange() {
+    return RangeF(std::numeric_limits<float>::max());
+  }
+
+  // Checks if the range is valid through comparison to InvalidRange().
+  constexpr bool IsValid() const { return *this != InvalidRange(); }
+
+  // Getters and setters.
+  constexpr float start() const { return start_; }
+  void set_start(float start) { start_ = start; }
+
+  constexpr float end() const { return end_; }
+  void set_end(float end) { end_ = end; }
+
+  // Returns the absolute value of the length.
+  constexpr float length() const { return GetMax() - GetMin(); }
+
+  constexpr bool is_reversed() const { return start() > end(); }
+  constexpr bool is_empty() const { return start() == end(); }
+
+  // Returns the minimum and maximum values.
+  constexpr float GetMin() const { return start() < end() ? start() : end(); }
+  constexpr float GetMax() const { return start() > end() ? start() : end(); }
+
+  constexpr bool operator==(const RangeF& other) const {
+    return start() == other.start() && end() == other.end();
+  }
+  constexpr bool operator!=(const RangeF& other) const {
+    return !(*this == other);
+  }
+  constexpr bool EqualsIgnoringDirection(const RangeF& other) const {
+    return GetMin() == other.GetMin() && GetMax() == other.GetMax();
+  }
+
+  // Returns true if this range intersects the specified |range|.
+  constexpr bool Intersects(const RangeF& range) const {
+    return Intersect(range).IsValid();
+  }
+
+  // Returns true if this range is contained by the specified |range| or it is
+  // an empty range and ending the range |range|. (copied from gfx::Range)
+  constexpr bool IsBoundedBy(const RangeF& range) const {
+    return IsValid() && range.IsValid() && GetMin() >= range.GetMin() &&
+           GetMax() <= range.GetMax();
+  }
+
+  // Returns true if this range contains the specified |range|.
+  constexpr bool Contains(const RangeF& range) const {
+    return range.IsBoundedBy(*this) &&
+           // A non-empty range doesn't contain the range [max, max).
+           (range.GetMax() != GetMax() || range.is_empty() == is_empty());
+  }
+
+  // Computes the intersection of this range with the given |range|.
+  // If they don't intersect, it returns an InvalidRange().
+  // The returned range is always empty or forward (never reversed).
+  constexpr RangeF Intersect(const RangeF& range) const {
+    const float min = std::max(GetMin(), range.GetMin());
+    const float max = std::min(GetMax(), range.GetMax());
+
+    return (min < max || Contains(range) || range.Contains(*this))
+               ? RangeF(min, max)
+               : InvalidRange();
+  }
+
+  RangeF Intersect(const Range& range) const;
+
+  // Floor/Ceil/Round the start and end values of the given RangeF.
+  Range Floor() const;
+  Range Ceil() const;
+  Range Round() const;
+
+  std::string ToString() const;
+
+ private:
+  float start_;
+  float end_;
+};
+
+GFX_RANGE_EXPORT std::ostream& operator<<(std::ostream& os,
+                                          const RangeF& range);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_RANGE_RANGE_F_H_
diff --git a/ui/gfx/range/range_mac.mm b/ui/gfx/range/range_mac.mm
new file mode 100644
index 0000000..cc1aa1e
--- /dev/null
+++ b/ui/gfx/range/range_mac.mm
@@ -0,0 +1,38 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/range/range.h"
+
+#include <stddef.h>
+
+#include <limits>
+
+#include "base/check_op.h"
+
+namespace gfx {
+
+Range::Range(const NSRange& range) {
+  *this = range;
+}
+
+Range& Range::operator=(const NSRange& range) {
+  if (range.location == NSNotFound) {
+    DCHECK_EQ(0U, range.length);
+    *this = InvalidRange();
+  } else {
+    set_start(range.location);
+    // Don't overflow |end_|.
+    DCHECK_LE(range.length, std::numeric_limits<size_t>::max() - start());
+    set_end(start() + range.length);
+  }
+  return *this;
+}
+
+NSRange Range::ToNSRange() const {
+  if (!IsValid())
+    return NSMakeRange(NSNotFound, 0);
+  return NSMakeRange(GetMin(), length());
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/range/range_mac_unittest.mm b/ui/gfx/range/range_mac_unittest.mm
new file mode 100644
index 0000000..85323f2
--- /dev/null
+++ b/ui/gfx/range/range_mac_unittest.mm
@@ -0,0 +1,43 @@
+// Copyright (c) 2011 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.
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/range/range.h"
+
+TEST(RangeTest, FromNSRange) {
+  NSRange nsr = NSMakeRange(10, 3);
+  gfx::Range r(nsr);
+  EXPECT_EQ(nsr.location, r.start());
+  EXPECT_EQ(13U, r.end());
+  EXPECT_EQ(nsr.length, r.length());
+  EXPECT_FALSE(r.is_reversed());
+  EXPECT_TRUE(r.IsValid());
+}
+
+TEST(RangeTest, ToNSRange) {
+  gfx::Range r(10, 12);
+  NSRange nsr = r.ToNSRange();
+  EXPECT_EQ(10U, nsr.location);
+  EXPECT_EQ(2U, nsr.length);
+}
+
+TEST(RangeTest, ReversedToNSRange) {
+  gfx::Range r(20, 10);
+  NSRange nsr = r.ToNSRange();
+  EXPECT_EQ(10U, nsr.location);
+  EXPECT_EQ(10U, nsr.length);
+}
+
+TEST(RangeTest, FromNSRangeInvalid) {
+  NSRange nsr = NSMakeRange(NSNotFound, 0);
+  gfx::Range r(nsr);
+  EXPECT_FALSE(r.IsValid());
+}
+
+TEST(RangeTest, ToNSRangeInvalid) {
+  gfx::Range r(gfx::Range::InvalidRange());
+  NSRange nsr = r.ToNSRange();
+  EXPECT_EQ(static_cast<NSUInteger>(NSNotFound), nsr.location);
+  EXPECT_EQ(0U, nsr.length);
+}
diff --git a/ui/gfx/range/range_unittest.cc b/ui/gfx/range/range_unittest.cc
new file mode 100644
index 0000000..8fba740
--- /dev/null
+++ b/ui/gfx/range/range_unittest.cc
@@ -0,0 +1,526 @@
+// Copyright (c) 2011 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.
+
+#include <sstream>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/range/range.h"
+#include "ui/gfx/range/range_f.h"
+
+namespace {
+
+template <typename T>
+class RangeTest : public testing::Test {
+};
+
+typedef testing::Types<gfx::Range, gfx::RangeF> RangeTypes;
+TYPED_TEST_SUITE(RangeTest, RangeTypes);
+
+template <typename T>
+void TestContainsAndIntersects(const T& r1,
+                               const T& r2,
+                               const T& r3) {
+  EXPECT_TRUE(r1.Intersects(r1));
+  EXPECT_TRUE(r1.Contains(r1));
+  EXPECT_EQ(T(10, 12), r1.Intersect(r1));
+
+  EXPECT_FALSE(r1.Intersects(r2));
+  EXPECT_FALSE(r1.Contains(r2));
+  EXPECT_TRUE(r1.Intersect(r2).is_empty());
+  EXPECT_FALSE(r2.Intersects(r1));
+  EXPECT_FALSE(r2.Contains(r1));
+  EXPECT_TRUE(r2.Intersect(r1).is_empty());
+
+  EXPECT_TRUE(r1.Intersects(r3));
+  EXPECT_TRUE(r3.Intersects(r1));
+  EXPECT_TRUE(r3.Contains(r1));
+  EXPECT_FALSE(r1.Contains(r3));
+  EXPECT_EQ(T(10, 12), r1.Intersect(r3));
+  EXPECT_EQ(T(10, 12), r3.Intersect(r1));
+
+  EXPECT_TRUE(r2.Intersects(r3));
+  EXPECT_TRUE(r3.Intersects(r2));
+  EXPECT_FALSE(r3.Contains(r2));
+  EXPECT_FALSE(r2.Contains(r3));
+  EXPECT_EQ(T(5, 8), r2.Intersect(r3));
+  EXPECT_EQ(T(5, 8), r3.Intersect(r2));
+}
+
+}  // namespace
+
+TYPED_TEST(RangeTest, EmptyInit) {
+  TypeParam r;
+  EXPECT_EQ(0U, r.start());
+  EXPECT_EQ(0U, r.end());
+  EXPECT_EQ(0U, r.length());
+  EXPECT_FALSE(r.is_reversed());
+  EXPECT_TRUE(r.is_empty());
+  EXPECT_TRUE(r.IsValid());
+  EXPECT_EQ(0U, r.GetMin());
+  EXPECT_EQ(0U, r.GetMax());
+}
+
+TYPED_TEST(RangeTest, StartEndInit) {
+  TypeParam r(10, 15);
+  EXPECT_EQ(10U, r.start());
+  EXPECT_EQ(15U, r.end());
+  EXPECT_EQ(5U, r.length());
+  EXPECT_FALSE(r.is_reversed());
+  EXPECT_FALSE(r.is_empty());
+  EXPECT_TRUE(r.IsValid());
+  EXPECT_EQ(10U, r.GetMin());
+  EXPECT_EQ(15U, r.GetMax());
+}
+
+TYPED_TEST(RangeTest, StartEndReversedInit) {
+  TypeParam r(10, 5);
+  EXPECT_EQ(10U, r.start());
+  EXPECT_EQ(5U, r.end());
+  EXPECT_EQ(5U, r.length());
+  EXPECT_TRUE(r.is_reversed());
+  EXPECT_FALSE(r.is_empty());
+  EXPECT_TRUE(r.IsValid());
+  EXPECT_EQ(5U, r.GetMin());
+  EXPECT_EQ(10U, r.GetMax());
+}
+
+TYPED_TEST(RangeTest, PositionInit) {
+  TypeParam r(12);
+  EXPECT_EQ(12U, r.start());
+  EXPECT_EQ(12U, r.end());
+  EXPECT_EQ(0U, r.length());
+  EXPECT_FALSE(r.is_reversed());
+  EXPECT_TRUE(r.is_empty());
+  EXPECT_TRUE(r.IsValid());
+  EXPECT_EQ(12U, r.GetMin());
+  EXPECT_EQ(12U, r.GetMax());
+}
+
+TYPED_TEST(RangeTest, InvalidRange) {
+  TypeParam r(TypeParam::InvalidRange());
+  EXPECT_EQ(0U, r.length());
+  EXPECT_EQ(r.start(), r.end());
+  EXPECT_EQ(r.GetMax(), r.GetMin());
+  EXPECT_FALSE(r.is_reversed());
+  EXPECT_TRUE(r.is_empty());
+  EXPECT_FALSE(r.IsValid());
+  EXPECT_EQ(r, TypeParam::InvalidRange());
+  EXPECT_TRUE(r.EqualsIgnoringDirection(TypeParam::InvalidRange()));
+}
+
+TYPED_TEST(RangeTest, Equality) {
+  TypeParam r1(10, 4);
+  TypeParam r2(10, 4);
+  TypeParam r3(10, 2);
+  EXPECT_EQ(r1, r2);
+  EXPECT_NE(r1, r3);
+  EXPECT_NE(r2, r3);
+
+  TypeParam r4(11, 4);
+  EXPECT_NE(r1, r4);
+  EXPECT_NE(r2, r4);
+  EXPECT_NE(r3, r4);
+
+  TypeParam r5(12, 5);
+  EXPECT_NE(r1, r5);
+  EXPECT_NE(r2, r5);
+  EXPECT_NE(r3, r5);
+}
+
+TYPED_TEST(RangeTest, EqualsIgnoringDirection) {
+  TypeParam r1(10, 5);
+  TypeParam r2(5, 10);
+  EXPECT_TRUE(r1.EqualsIgnoringDirection(r2));
+}
+
+TYPED_TEST(RangeTest, SetStart) {
+  TypeParam r(10, 20);
+  EXPECT_EQ(10U, r.start());
+  EXPECT_EQ(10U, r.length());
+
+  r.set_start(42);
+  EXPECT_EQ(42U, r.start());
+  EXPECT_EQ(20U, r.end());
+  EXPECT_EQ(22U, r.length());
+  EXPECT_TRUE(r.is_reversed());
+}
+
+TYPED_TEST(RangeTest, SetEnd) {
+  TypeParam r(10, 13);
+  EXPECT_EQ(10U, r.start());
+  EXPECT_EQ(3U, r.length());
+
+  r.set_end(20);
+  EXPECT_EQ(10U, r.start());
+  EXPECT_EQ(20U, r.end());
+  EXPECT_EQ(10U, r.length());
+}
+
+TYPED_TEST(RangeTest, SetStartAndEnd) {
+  TypeParam r;
+  r.set_end(5);
+  r.set_start(1);
+  EXPECT_EQ(1U, r.start());
+  EXPECT_EQ(5U, r.end());
+  EXPECT_EQ(4U, r.length());
+  EXPECT_EQ(1U, r.GetMin());
+  EXPECT_EQ(5U, r.GetMax());
+}
+
+TYPED_TEST(RangeTest, ReversedRange) {
+  TypeParam r(10, 5);
+  EXPECT_EQ(10U, r.start());
+  EXPECT_EQ(5U, r.end());
+  EXPECT_EQ(5U, r.length());
+  EXPECT_TRUE(r.is_reversed());
+  EXPECT_TRUE(r.IsValid());
+  EXPECT_EQ(5U, r.GetMin());
+  EXPECT_EQ(10U, r.GetMax());
+}
+
+TYPED_TEST(RangeTest, SetReversedRange) {
+  TypeParam r(10, 20);
+  r.set_start(25);
+  EXPECT_EQ(25U, r.start());
+  EXPECT_EQ(20U, r.end());
+  EXPECT_EQ(5U, r.length());
+  EXPECT_TRUE(r.is_reversed());
+  EXPECT_TRUE(r.IsValid());
+
+  r.set_end(21);
+  EXPECT_EQ(25U, r.start());
+  EXPECT_EQ(21U, r.end());
+  EXPECT_EQ(4U, r.length());
+  EXPECT_TRUE(r.IsValid());
+  EXPECT_EQ(21U, r.GetMin());
+  EXPECT_EQ(25U, r.GetMax());
+}
+
+TYPED_TEST(RangeTest, ContainAndIntersect) {
+  {
+    SCOPED_TRACE("contain and intersect");
+    TypeParam r1(10, 12);
+    TypeParam r2(1, 8);
+    TypeParam r3(5, 12);
+    TestContainsAndIntersects(r1, r2, r3);
+  }
+  {
+    SCOPED_TRACE("contain and intersect: reversed");
+    TypeParam r1(12, 10);
+    TypeParam r2(8, 1);
+    TypeParam r3(12, 5);
+    TestContainsAndIntersects(r1, r2, r3);
+  }
+  // Invalid rect tests
+  TypeParam r1(10, 12);
+  TypeParam r2(8, 1);
+  TypeParam invalid = r1.Intersect(r2);
+  EXPECT_FALSE(invalid.IsValid());
+  EXPECT_FALSE(invalid.Contains(invalid));
+  EXPECT_FALSE(invalid.Contains(r1));
+  EXPECT_FALSE(invalid.Intersects(invalid));
+  EXPECT_FALSE(invalid.Intersects(r1));
+  EXPECT_FALSE(r1.Contains(invalid));
+  EXPECT_FALSE(r1.Intersects(invalid));
+}
+
+TEST(RangeTest, RangeOperations) {
+  constexpr gfx::Range invalid_range = gfx::Range::InvalidRange();
+  constexpr gfx::Range ranges[] = {{0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1},
+                                   {1, 2}, {2, 0}, {2, 1}, {2, 2}};
+
+  // Ensures valid behavior over same range.
+  for (const auto& range : ranges) {
+    SCOPED_TRACE(range.ToString());
+    // A range should contain itself.
+    EXPECT_TRUE(range.Contains(range));
+    // A ranges should intersect with itself.
+    EXPECT_TRUE(range.Intersects(range));
+  }
+
+  // Ensures valid behavior with an invalid range.
+  for (const auto& range : ranges) {
+    SCOPED_TRACE(range.ToString());
+    EXPECT_FALSE(invalid_range.Contains(range));
+    EXPECT_FALSE(invalid_range.Intersects(range));
+    EXPECT_FALSE(range.Contains(invalid_range));
+    EXPECT_FALSE(range.Intersects(invalid_range));
+  }
+  EXPECT_FALSE(invalid_range.Contains(invalid_range));
+  EXPECT_FALSE(invalid_range.Intersects(invalid_range));
+
+  // Ensures consistent operations between Contains(...) and Intersects(...).
+  for (const auto& range1 : ranges) {
+    for (const auto& range2 : ranges) {
+      SCOPED_TRACE(testing::Message()
+                   << "range1=" << range1 << " range2=" << range2);
+      if (range1.Contains(range2)) {
+        EXPECT_TRUE(range1.Intersects(range2));
+        EXPECT_EQ(range2.Contains(range1),
+                  range1.EqualsIgnoringDirection(range2));
+      }
+      EXPECT_EQ(range2.Intersects(range1), range1.Intersects(range2));
+
+      EXPECT_EQ(range1.Intersect(range2) != invalid_range,
+                range1.Intersects(range2));
+    }
+  }
+
+  // Ranges should behave the same way no matter the direction.
+  for (const auto& range1 : ranges) {
+    for (const auto& range2 : ranges) {
+      SCOPED_TRACE(testing::Message()
+                   << "range1=" << range1 << " range2=" << range2);
+      EXPECT_EQ(range1.Contains(range2),
+                range1.Contains(gfx::Range(range2.GetMax(), range2.GetMin())));
+      EXPECT_EQ(
+          range1.Intersects(range2),
+          range1.Intersects(gfx::Range(range2.GetMax(), range2.GetMin())));
+    }
+  }
+}
+
+TEST(RangeTest, RangeFOperations) {
+  constexpr gfx::RangeF invalid_range = gfx::RangeF::InvalidRange();
+  constexpr gfx::RangeF ranges[] = {{0.f, 0.f}, {0.f, 1.f}, {0.f, 2.f},
+                                    {1.f, 0.f}, {1.f, 1.f}, {1.f, 2.f},
+                                    {2.f, 0.f}, {2.f, 1.f}, {2.f, 2.f}};
+
+  // Ensures valid behavior over same range.
+  for (const auto& range : ranges) {
+    SCOPED_TRACE(range.ToString());
+    // A range should contain itself.
+    EXPECT_TRUE(range.Contains(range));
+    // A ranges should intersect with itself.
+    EXPECT_TRUE(range.Intersects(range));
+  }
+
+  // Ensures valid behavior with an invalid range.
+  for (const auto& range : ranges) {
+    SCOPED_TRACE(range.ToString());
+    EXPECT_FALSE(invalid_range.Contains(range));
+    EXPECT_FALSE(invalid_range.Intersects(range));
+    EXPECT_FALSE(range.Contains(invalid_range));
+    EXPECT_FALSE(range.Intersects(invalid_range));
+  }
+  EXPECT_FALSE(invalid_range.Contains(invalid_range));
+  EXPECT_FALSE(invalid_range.Intersects(invalid_range));
+
+  // Ensures consistent operations between Contains(...) and Intersects(...).
+  for (const auto& range1 : ranges) {
+    for (const auto& range2 : ranges) {
+      SCOPED_TRACE(testing::Message()
+                   << "range1=" << range1 << " range2=" << range2);
+      if (range1.Contains(range2)) {
+        EXPECT_TRUE(range1.Intersects(range2));
+        EXPECT_EQ(range2.Contains(range1),
+                  range1.EqualsIgnoringDirection(range2));
+      }
+      EXPECT_EQ(range2.Intersects(range1), range1.Intersects(range2));
+
+      EXPECT_EQ(range1.Intersect(range2) != invalid_range,
+                range1.Intersects(range2));
+    }
+  }
+
+  // Ranges should behave the same way no matter the direction.
+  for (const auto& range1 : ranges) {
+    for (const auto& range2 : ranges) {
+      SCOPED_TRACE(testing::Message()
+                   << "range1=" << range1 << " range2=" << range2);
+      EXPECT_EQ(range1.Contains(range2),
+                range1.Contains(gfx::RangeF(range2.GetMax(), range2.GetMin())));
+      EXPECT_EQ(
+          range1.Intersects(range2),
+          range1.Intersects(gfx::RangeF(range2.GetMax(), range2.GetMin())));
+    }
+  }
+}
+
+TEST(RangeTest, ContainsAndIntersects) {
+  constexpr gfx::Range r1(0, 0);
+  constexpr gfx::Range r2(0, 1);
+  constexpr gfx::Range r3(1, 2);
+  constexpr gfx::Range r4(1, 0);
+  constexpr gfx::Range r5(2, 1);
+  constexpr gfx::Range r6(0, 2);
+  constexpr gfx::Range r7(2, 0);
+  constexpr gfx::Range r8(1, 1);
+
+  // Ensures Contains(...) handle the open range.
+  EXPECT_TRUE(r2.Contains(r1));
+  EXPECT_TRUE(r4.Contains(r1));
+  EXPECT_TRUE(r3.Contains(r5));
+  EXPECT_TRUE(r5.Contains(r3));
+
+  // Ensures larger ranges contains smaller ranges.
+  EXPECT_TRUE(r6.Contains(r1));
+  EXPECT_TRUE(r6.Contains(r2));
+  EXPECT_TRUE(r6.Contains(r3));
+  EXPECT_TRUE(r6.Contains(r4));
+  EXPECT_TRUE(r6.Contains(r5));
+
+  EXPECT_TRUE(r7.Contains(r1));
+  EXPECT_TRUE(r7.Contains(r2));
+  EXPECT_TRUE(r7.Contains(r3));
+  EXPECT_TRUE(r7.Contains(r4));
+  EXPECT_TRUE(r7.Contains(r5));
+
+  // Ensures Intersects(...) handle the open range.
+  EXPECT_TRUE(r2.Intersects(r1));
+  EXPECT_TRUE(r4.Intersects(r1));
+
+  // Ensures larger ranges intersects smaller ranges.
+  EXPECT_TRUE(r6.Intersects(r1));
+  EXPECT_TRUE(r6.Intersects(r2));
+  EXPECT_TRUE(r6.Intersects(r3));
+  EXPECT_TRUE(r6.Intersects(r4));
+  EXPECT_TRUE(r6.Intersects(r5));
+
+  EXPECT_TRUE(r7.Intersects(r1));
+  EXPECT_TRUE(r7.Intersects(r2));
+  EXPECT_TRUE(r7.Intersects(r3));
+  EXPECT_TRUE(r7.Intersects(r4));
+  EXPECT_TRUE(r7.Intersects(r5));
+
+  // Ensures adjacent ranges don't overlap.
+  EXPECT_FALSE(r2.Intersects(r3));
+  EXPECT_FALSE(r5.Intersects(r4));
+
+  // Ensures empty ranges are handled correctly.
+  EXPECT_FALSE(r1.Contains(r8));
+  EXPECT_FALSE(r2.Contains(r8));
+  EXPECT_TRUE(r3.Contains(r8));
+  EXPECT_TRUE(r8.Contains(r8));
+
+  EXPECT_FALSE(r1.Intersects(r8));
+  EXPECT_FALSE(r2.Intersects(r8));
+  EXPECT_TRUE(r3.Intersects(r8));
+  EXPECT_TRUE(r8.Intersects(r8));
+}
+
+TEST(RangeTest, ContainsAndIntersectsRangeF) {
+  constexpr gfx::RangeF r1(0.f, 0.f);
+  constexpr gfx::RangeF r2(0.f, 1.f);
+  constexpr gfx::RangeF r3(1.f, 2.f);
+  constexpr gfx::RangeF r4(1.f, 0.f);
+  constexpr gfx::RangeF r5(2.f, 1.f);
+  constexpr gfx::RangeF r6(0.f, 2.f);
+  constexpr gfx::RangeF r7(2.f, 0.f);
+  constexpr gfx::RangeF r8(1.f, 1.f);
+
+  // Ensures Contains(...) handle the open range.
+  EXPECT_TRUE(r2.Contains(r1));
+  EXPECT_TRUE(r4.Contains(r1));
+  EXPECT_TRUE(r3.Contains(r5));
+  EXPECT_TRUE(r5.Contains(r3));
+
+  // Ensures larger ranges contains smaller ranges.
+  EXPECT_TRUE(r6.Contains(r1));
+  EXPECT_TRUE(r6.Contains(r2));
+  EXPECT_TRUE(r6.Contains(r3));
+  EXPECT_TRUE(r6.Contains(r4));
+  EXPECT_TRUE(r6.Contains(r5));
+
+  EXPECT_TRUE(r7.Contains(r1));
+  EXPECT_TRUE(r7.Contains(r2));
+  EXPECT_TRUE(r7.Contains(r3));
+  EXPECT_TRUE(r7.Contains(r4));
+  EXPECT_TRUE(r7.Contains(r5));
+
+  // Ensures Intersects(...) handle the open range.
+  EXPECT_TRUE(r2.Intersects(r1));
+  EXPECT_TRUE(r4.Intersects(r1));
+
+  // Ensures larger ranges intersects smaller ranges.
+  EXPECT_TRUE(r6.Intersects(r1));
+  EXPECT_TRUE(r6.Intersects(r2));
+  EXPECT_TRUE(r6.Intersects(r3));
+  EXPECT_TRUE(r6.Intersects(r4));
+  EXPECT_TRUE(r6.Intersects(r5));
+
+  EXPECT_TRUE(r7.Intersects(r1));
+  EXPECT_TRUE(r7.Intersects(r2));
+  EXPECT_TRUE(r7.Intersects(r3));
+  EXPECT_TRUE(r7.Intersects(r4));
+  EXPECT_TRUE(r7.Intersects(r5));
+
+  // Ensures adjacent ranges don't overlap.
+  EXPECT_FALSE(r2.Intersects(r3));
+  EXPECT_FALSE(r5.Intersects(r4));
+
+  // Ensures empty ranges are handled correctly.
+  EXPECT_FALSE(r1.Contains(r8));
+  EXPECT_FALSE(r2.Contains(r8));
+  EXPECT_TRUE(r3.Contains(r8));
+  EXPECT_TRUE(r8.Contains(r8));
+
+  EXPECT_FALSE(r1.Intersects(r8));
+  EXPECT_FALSE(r2.Intersects(r8));
+  EXPECT_TRUE(r3.Intersects(r8));
+  EXPECT_TRUE(r8.Intersects(r8));
+}
+
+TEST(RangeTest, Intersect) {
+  EXPECT_EQ(gfx::Range(0, 1).Intersect({0, 1}), gfx::Range(0, 1));
+  EXPECT_EQ(gfx::Range(0, 1).Intersect({0, 0}), gfx::Range(0, 0));
+  EXPECT_EQ(gfx::Range(0, 0).Intersect({1, 0}), gfx::Range(0, 0));
+  EXPECT_EQ(gfx::Range(0, 4).Intersect({2, 3}), gfx::Range(2, 3));
+  EXPECT_EQ(gfx::Range(0, 4).Intersect({2, 7}), gfx::Range(2, 4));
+  EXPECT_EQ(gfx::Range(0, 4).Intersect({3, 4}), gfx::Range(3, 4));
+
+  EXPECT_EQ(gfx::Range(0, 1).Intersect({1, 1}), gfx::Range::InvalidRange());
+  EXPECT_EQ(gfx::Range(1, 1).Intersect({1, 0}), gfx::Range::InvalidRange());
+  EXPECT_EQ(gfx::Range(0, 1).Intersect({1, 2}), gfx::Range::InvalidRange());
+  EXPECT_EQ(gfx::Range(0, 1).Intersect({2, 1}), gfx::Range::InvalidRange());
+  EXPECT_EQ(gfx::Range(2, 1).Intersect({1, 0}), gfx::Range::InvalidRange());
+}
+
+TEST(RangeTest, IntersectRangeF) {
+  EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(0.f, 1.f)),
+            gfx::RangeF(0.f, 1.f));
+  EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(0.f, 0.f)),
+            gfx::RangeF(0.f, 0.f));
+  EXPECT_EQ(gfx::RangeF(0.f, 0.f).Intersect(gfx::RangeF(1.f, 0.f)),
+            gfx::RangeF(0.f, 0.f));
+  EXPECT_EQ(gfx::RangeF(0.f, 4.f).Intersect(gfx::RangeF(2.f, 3.f)),
+            gfx::RangeF(2.f, 3.f));
+  EXPECT_EQ(gfx::RangeF(0.f, 4.f).Intersect(gfx::RangeF(2.f, 7.f)),
+            gfx::RangeF(2.f, 4.f));
+  EXPECT_EQ(gfx::RangeF(0.f, 4.f).Intersect(gfx::RangeF(3.f, 4.f)),
+            gfx::RangeF(3.f, 4.f));
+
+  EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(1.f, 1.f)),
+            gfx::RangeF::InvalidRange());
+  EXPECT_EQ(gfx::RangeF(1.f, 1.f).Intersect(gfx::RangeF(1.f, 0.f)),
+            gfx::RangeF::InvalidRange());
+  EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(1.f, 2.f)),
+            gfx::RangeF::InvalidRange());
+  EXPECT_EQ(gfx::RangeF(0.f, 1.f).Intersect(gfx::RangeF(2.f, 1.f)),
+            gfx::RangeF::InvalidRange());
+  EXPECT_EQ(gfx::RangeF(2.f, 1.f).Intersect(gfx::RangeF(1.f, 0.f)),
+            gfx::RangeF::InvalidRange());
+}
+
+TEST(RangeTest, IsBoundedBy) {
+  constexpr gfx::Range r1(0, 0);
+  constexpr gfx::Range r2(0, 1);
+  EXPECT_TRUE(r1.IsBoundedBy(r1));
+  EXPECT_FALSE(r2.IsBoundedBy(r1));
+
+  constexpr gfx::Range r3(0, 2);
+  constexpr gfx::Range r4(2, 2);
+  EXPECT_TRUE(r4.IsBoundedBy(r3));
+  EXPECT_FALSE(r3.IsBoundedBy(r4));
+}
+
+TEST(RangeTest, ToString) {
+  gfx::Range range(4, 7);
+  EXPECT_EQ("{4,7}", range.ToString());
+
+  range = gfx::Range::InvalidRange();
+  std::ostringstream expected;
+  expected << "{" << range.start() << "," << range.end() << "}";
+  EXPECT_EQ(expected.str(), range.ToString());
+}
diff --git a/ui/gfx/render_text.cc b/ui/gfx/render_text.cc
new file mode 100644
index 0000000..99120dd
--- /dev/null
+++ b/ui/gfx/render_text.cc
@@ -0,0 +1,2351 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/render_text.h"
+
+#include <limits.h>
+
+#include <algorithm>
+#include <climits>
+
+#include "base/check_op.h"
+#include "base/command_line.h"
+#include "base/cxx17_backports.h"
+#include "base/i18n/break_iterator.h"
+#include "base/i18n/char_iterator.h"
+#include "base/notreached.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_shader.h"
+#include "third_party/icu/source/common/unicode/rbbi.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "third_party/icu/source/common/unicode/utf16.h"
+#include "third_party/skia/include/core/SkDrawLooper.h"
+#include "third_party/skia/include/core/SkFontStyle.h"
+#include "third_party/skia/include/core/SkTextBlob.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "third_party/skia/include/effects/SkGradientShader.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/platform_font.h"
+#include "ui/gfx/render_text_harfbuzz.h"
+#include "ui/gfx/scoped_canvas.h"
+#include "ui/gfx/skia_paint_util.h"
+#include "ui/gfx/text_elider.h"
+#include "ui/gfx/text_utils.h"
+#include "ui/gfx/utf16_indexing.h"
+
+#if defined(OS_WIN)
+#include "base/win/windows_version.h"
+#endif
+
+namespace gfx {
+
+namespace {
+
+// Replacement codepoint for elided text.
+constexpr char16_t kEllipsisCodepoint = 0x2026;
+
+// Fraction of the text size to raise the center of a strike-through line above
+// the baseline.
+const SkScalar kStrikeThroughOffset = (SK_Scalar1 * 65 / 252);
+// Fraction of the text size to lower an underline below the baseline.
+const SkScalar kUnderlineOffset = (SK_Scalar1 / 9);
+
+// Float comparison needs epsilon to consider rounding errors in float
+// arithmetic. Epsilon should be dependent on the context and here, we are
+// dealing with glyph widths, use a fairly large number.
+const float kFloatComparisonEpsilon = 0.001f;
+float Clamp(float f) {
+  return f < kFloatComparisonEpsilon ? 0 : f;
+}
+
+// Given |font| and |display_width|, returns the width of the fade gradient.
+int CalculateFadeGradientWidth(const FontList& font_list, int display_width) {
+  // Fade in/out about 3 characters of the beginning/end of the string.
+  // Use a 1/3 of the display width if the display width is very short.
+  const int narrow_width = font_list.GetExpectedTextWidth(3);
+  const int gradient_width =
+      std::min(narrow_width, base::ClampRound(display_width / 3.f));
+  DCHECK_GE(gradient_width, 0);
+  return gradient_width;
+}
+
+// Appends to |positions| and |colors| values corresponding to the fade over
+// |fade_rect| from color |c0| to color |c1|.
+void AddFadeEffect(const Rect& text_rect,
+                   const Rect& fade_rect,
+                   SkColor c0,
+                   SkColor c1,
+                   std::vector<SkScalar>* positions,
+                   std::vector<SkColor>* colors) {
+  const SkScalar left = static_cast<SkScalar>(fade_rect.x() - text_rect.x());
+  const SkScalar width = static_cast<SkScalar>(fade_rect.width());
+  const SkScalar p0 = left / text_rect.width();
+  const SkScalar p1 = (left + width) / text_rect.width();
+  // Prepend 0.0 to |positions|, as required by Skia.
+  if (positions->empty() && p0 != 0.0) {
+    positions->push_back(0.0);
+    colors->push_back(c0);
+  }
+  positions->push_back(p0);
+  colors->push_back(c0);
+  positions->push_back(p1);
+  colors->push_back(c1);
+}
+
+// Creates a SkShader to fade the text, with |left_part| specifying the left
+// fade effect, if any, and |right_part| specifying the right fade effect.
+sk_sp<cc::PaintShader> CreateFadeShader(const FontList& font_list,
+                                        const Rect& text_rect,
+                                        const Rect& left_part,
+                                        const Rect& right_part,
+                                        SkColor color) {
+  // The shader should only specify transparency of the fade itself, not the
+  // original transparency, which will be applied by the actual renderer.
+  DCHECK_EQ(SkColorGetA(color), static_cast<uint8_t>(0xff));
+
+  // In general, fade down to 0 alpha.  But when the available width is less
+  // than four characters, linearly ramp up the fade target alpha to as high as
+  // 20% at zero width.  This allows the user to see the last faded characters a
+  // little better when there are only a few characters shown.
+  const float width_fraction =
+      text_rect.width() / static_cast<float>(font_list.GetExpectedTextWidth(4));
+  const SkAlpha kAlphaAtZeroWidth = 51;
+  const SkAlpha alpha =
+      (width_fraction < 1)
+          ? base::ClampRound<SkAlpha>((1 - width_fraction) * kAlphaAtZeroWidth)
+          : 0;
+  const SkColor fade_color = SkColorSetA(color, alpha);
+
+  std::vector<SkScalar> positions;
+  std::vector<SkColor> colors;
+
+  if (!left_part.IsEmpty())
+    AddFadeEffect(text_rect, left_part, fade_color, color,
+                  &positions, &colors);
+  if (!right_part.IsEmpty())
+    AddFadeEffect(text_rect, right_part, color, fade_color,
+                  &positions, &colors);
+  DCHECK(!positions.empty());
+
+  // Terminate |positions| with 1.0, as required by Skia.
+  if (positions.back() != 1.0) {
+    positions.push_back(1.0);
+    colors.push_back(colors.back());
+  }
+
+  const SkPoint points[2] = { PointToSkPoint(text_rect.origin()),
+                              PointToSkPoint(text_rect.top_right()) };
+  return cc::PaintShader::MakeLinearGradient(
+      &points[0], &colors[0], &positions[0], static_cast<int>(colors.size()),
+      SkTileMode::kClamp);
+}
+
+// Converts a FontRenderParams::Hinting value to the corresponding
+// SkFontHinting value.
+SkFontHinting FontRenderParamsHintingToSkFontHinting(
+    FontRenderParams::Hinting params_hinting) {
+  switch (params_hinting) {
+    case FontRenderParams::HINTING_NONE:
+      return SkFontHinting::kNone;
+    case FontRenderParams::HINTING_SLIGHT:
+      return SkFontHinting::kSlight;
+    case FontRenderParams::HINTING_MEDIUM:
+      return SkFontHinting::kNormal;
+    case FontRenderParams::HINTING_FULL:
+      return SkFontHinting::kFull;
+  }
+  return SkFontHinting::kNone;
+}
+
+// Make sure ranges don't break text graphemes.  If a range in |break_list|
+// does break a grapheme in |render_text|, the range will be slightly
+// extended to encompass the grapheme.
+template <typename T>
+void RestoreBreakList(RenderText* render_text, BreakList<T>* break_list) {
+  break_list->SetMax(render_text->text().length());
+  Range range;
+  while (range.end() < break_list->max()) {
+    const auto& current_break = break_list->GetBreak(range.end());
+    range = break_list->GetRange(current_break);
+    if (range.end() < break_list->max() &&
+        !render_text->IsValidCursorIndex(range.end())) {
+      range.set_end(
+          render_text->IndexOfAdjacentGrapheme(range.end(), CURSOR_FORWARD));
+      break_list->ApplyValue(current_break->second, range);
+    }
+  }
+}
+
+// Move the iterator |iter| forward until |position| is included in the range.
+template <typename T>
+typename BreakList<T>::const_iterator IncrementBreakListIteratorToPosition(
+    const BreakList<T>& break_list,
+    typename BreakList<T>::const_iterator iter,
+    size_t position) {
+  for (; iter != break_list.breaks().end(); ++iter) {
+    const Range range = break_list.GetRange(iter);
+    if (position >= range.start() && position < range.end())
+      break;
+  }
+  return iter;
+}
+
+// Replaces the unicode control characters, control characters and PUA (Private
+// Use Areas) codepoints.
+UChar32 ReplaceControlCharacter(UChar32 codepoint) {
+  // 'REPLACEMENT CHARACTER' used to replace an unknown,
+  // unrecognized or unrepresentable character.
+  constexpr char16_t kReplacementCodepoint = 0xFFFD;
+  // Control Pictures block (see:
+  // https://unicode.org/charts/PDF/U2400.pdf).
+  constexpr char16_t kSymbolsCodepoint = 0x2400;
+
+  if (codepoint >= 0 && codepoint <= 0x1F) {
+    // Replace codepoints with their visual symbols, which are
+    // at the same offset from kSymbolsCodepoint.
+    return kSymbolsCodepoint + codepoint;
+  }
+  if (codepoint == 0x7F) {
+    // Replace the 'del' codepoint by its symbol (u2421).
+    return kSymbolsCodepoint + 0x21;
+  }
+  if (!U_IS_UNICODE_CHAR(codepoint)) {
+    // Unicode codepoint that can't be assigned a character.
+    // This handles:
+    // - single surrogate codepoints,
+    // - last two codepoints on each plane,
+    // - invalid characters (e.g. u+fdd0..u+fdef)
+    // - codepoints above u+10ffff
+    return kReplacementCodepoint;
+  }
+  if (codepoint > 0x7F) {
+    // Private use codepoints are working with a pair of font
+    // and codepoint, but they are not used in Chrome.
+#if defined(OS_MAC)
+    // Support Apple defined PUA on Mac.
+    // see: http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/CORPCHAR.TXT
+    if (codepoint == 0xF8FF)
+      return codepoint;
+#endif
+#if defined(OS_WIN)
+    // Support Microsoft defined PUA on Windows.
+    // see:
+    // https://docs.microsoft.com/en-us/windows/uwp/design/style/segoe-ui-symbol-font
+    if (base::win::GetVersion() >= base::win::Version::WIN10) {
+      switch (codepoint) {
+        case 0xF093:  // ButtonA
+        case 0xF094:  // ButtonB
+        case 0xF095:  // ButtonY
+        case 0xF096:  // ButtonX
+        case 0xF108:  // LeftStick
+        case 0xF109:  // RightStick
+        case 0xF10A:  // TriggerLeft
+        case 0xF10B:  // TriggerRight
+        case 0xF10C:  // BumperLeft
+        case 0xF10D:  // BumperRight
+        case 0xF10E:  // Dpad
+        case 0xEECA:  // ButtonView2
+        case 0xEDE3:  // ButtonMenu
+          return codepoint;
+        default:
+          break;
+      }
+    }
+#endif
+    const int8_t codepoint_category = u_charType(codepoint);
+    if (codepoint_category == U_PRIVATE_USE_CHAR ||
+        codepoint_category == U_CONTROL_CHAR) {
+      return kReplacementCodepoint;
+    }
+  }
+
+  return codepoint;
+}
+
+// Returns the line segment index for the |line|, |text_x| pair. |text_x| is
+// relative to text in the given line. Returns -1 if |text_x| is to the left
+// of text in the line and |line|.segments.size() if it's to the right.
+// |offset_relative_segment| will contain the offset of |text_x| relative to
+// the start of the segment it is contained in.
+int GetLineSegmentContainingXCoord(const internal::Line& line,
+                                   float line_x,
+                                   float* offset_relative_segment) {
+  DCHECK(offset_relative_segment);
+
+  *offset_relative_segment = 0;
+  if (line_x < 0)
+    return -1;
+  for (size_t i = 0; i < line.segments.size(); i++) {
+    const internal::LineSegment& segment = line.segments[i];
+    // segment.x_range is not used because it is in text space.
+    if (line_x < segment.width()) {
+      *offset_relative_segment = line_x;
+      return i;
+    }
+    line_x -= segment.width();
+  }
+  return line.segments.size();
+}
+
+}  // namespace
+
+namespace internal {
+
+SkiaTextRenderer::SkiaTextRenderer(Canvas* canvas)
+    : canvas_(canvas), canvas_skia_(canvas->sk_canvas()) {
+  DCHECK(canvas_skia_);
+  flags_.setStyle(cc::PaintFlags::kFill_Style);
+
+  font_.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+  font_.setSubpixel(true);
+  font_.setHinting(SkFontHinting::kNormal);
+}
+
+SkiaTextRenderer::~SkiaTextRenderer() {
+}
+
+void SkiaTextRenderer::SetDrawLooper(sk_sp<SkDrawLooper> draw_looper) {
+  flags_.setLooper(std::move(draw_looper));
+}
+
+void SkiaTextRenderer::SetFontRenderParams(const FontRenderParams& params,
+                                           bool subpixel_rendering_suppressed) {
+  ApplyRenderParams(params, subpixel_rendering_suppressed, &font_);
+}
+
+void SkiaTextRenderer::SetTypeface(sk_sp<SkTypeface> typeface) {
+  font_.setTypeface(std::move(typeface));
+}
+
+void SkiaTextRenderer::SetTextSize(SkScalar size) {
+  font_.setSize(size);
+}
+
+void SkiaTextRenderer::SetForegroundColor(SkColor foreground) {
+  flags_.setColor(foreground);
+}
+
+void SkiaTextRenderer::SetShader(sk_sp<cc::PaintShader> shader) {
+  flags_.setShader(std::move(shader));
+}
+
+void SkiaTextRenderer::DrawPosText(const SkPoint* pos,
+                                   const uint16_t* glyphs,
+                                   size_t glyph_count) {
+  SkTextBlobBuilder builder;
+  const auto& run_buffer = builder.allocRunPos(font_, glyph_count);
+
+  static_assert(sizeof(*glyphs) == sizeof(*run_buffer.glyphs), "");
+  memcpy(run_buffer.glyphs, glyphs, glyph_count * sizeof(*glyphs));
+
+  static_assert(sizeof(*pos) == 2 * sizeof(*run_buffer.pos), "");
+  memcpy(run_buffer.pos, pos, glyph_count * sizeof(*pos));
+
+  canvas_skia_->drawTextBlob(builder.make(), 0, 0, flags_);
+}
+
+void SkiaTextRenderer::DrawUnderline(int x,
+                                     int y,
+                                     int width,
+                                     SkScalar thickness_factor) {
+  SkScalar x_scalar = SkIntToScalar(x);
+  const SkScalar text_size = font_.getSize();
+  SkRect r = SkRect::MakeLTRB(
+      x_scalar, y + text_size * kUnderlineOffset, x_scalar + width,
+      y + (text_size *
+           (kUnderlineOffset +
+            (thickness_factor * RenderText::kLineThicknessFactor))));
+  canvas_skia_->drawRect(r, flags_);
+}
+
+void SkiaTextRenderer::DrawStrike(int x,
+                                  int y,
+                                  int width,
+                                  SkScalar thickness_factor) {
+  const SkScalar text_size = font_.getSize();
+  const SkScalar height = text_size * thickness_factor;
+  const SkScalar top = y - text_size * kStrikeThroughOffset - height / 2;
+  SkScalar x_scalar = SkIntToScalar(x);
+  const SkRect r =
+      SkRect::MakeLTRB(x_scalar, top, x_scalar + width, top + height);
+  canvas_skia_->drawRect(r, flags_);
+}
+
+StyleIterator::StyleIterator(const BreakList<SkColor>* colors,
+                             const BreakList<BaselineStyle>* baselines,
+                             const BreakList<int>* font_size_overrides,
+                             const BreakList<Font::Weight>* weights,
+                             const StyleArray* styles)
+    : colors_(colors),
+      baselines_(baselines),
+      font_size_overrides_(font_size_overrides),
+      weights_(weights),
+      styles_(styles) {
+  color_ = colors_->breaks().begin();
+  baseline_ = baselines_->breaks().begin();
+  font_size_override_ = font_size_overrides_->breaks().begin();
+  weight_ = weights_->breaks().begin();
+  for (size_t i = 0; i < styles_->size(); ++i)
+    style_[i] = (*styles_)[i].breaks().begin();
+}
+
+StyleIterator::StyleIterator(const StyleIterator& style) = default;
+StyleIterator::~StyleIterator() = default;
+StyleIterator& StyleIterator::operator=(const StyleIterator& style) = default;
+
+Range StyleIterator::GetRange() const {
+  return GetTextBreakingRange().Intersect(colors_->GetRange(color_));
+}
+
+Range StyleIterator::GetTextBreakingRange() const {
+  Range range = baselines_->GetRange(baseline_);
+  range = range.Intersect(font_size_overrides_->GetRange(font_size_override_));
+  range = range.Intersect(weights_->GetRange(weight_));
+  for (size_t i = 0; i < styles_->size(); ++i)
+    range = range.Intersect((*styles_)[i].GetRange(style_[i]));
+  return range;
+}
+
+void StyleIterator::IncrementToPosition(size_t position) {
+  color_ = IncrementBreakListIteratorToPosition(*colors_, color_, position);
+  baseline_ =
+      IncrementBreakListIteratorToPosition(*baselines_, baseline_, position);
+  font_size_override_ = IncrementBreakListIteratorToPosition(
+      *font_size_overrides_, font_size_override_, position);
+  weight_ = IncrementBreakListIteratorToPosition(*weights_, weight_, position);
+  for (size_t i = 0; i < styles_->size(); ++i) {
+    style_[i] = IncrementBreakListIteratorToPosition((*styles_)[i], style_[i],
+                                                     position);
+  }
+}
+
+LineSegment::LineSegment() : run(0) {}
+
+LineSegment::~LineSegment() {}
+
+Line::Line() : preceding_heights(0), baseline(0) {}
+
+Line::Line(const Line& other) = default;
+
+Line::~Line() {}
+
+ShapedText::ShapedText(std::vector<Line> lines) : lines_(std::move(lines)) {}
+ShapedText::~ShapedText() = default;
+
+void ApplyRenderParams(const FontRenderParams& params,
+                       bool subpixel_rendering_suppressed,
+                       SkFont* font) {
+  if (!params.antialiasing) {
+    font->setEdging(SkFont::Edging::kAlias);
+  } else if (subpixel_rendering_suppressed ||
+             params.subpixel_rendering ==
+                 FontRenderParams::SUBPIXEL_RENDERING_NONE) {
+    font->setEdging(SkFont::Edging::kAntiAlias);
+  } else {
+    font->setEdging(SkFont::Edging::kSubpixelAntiAlias);
+  }
+
+  font->setSubpixel(params.subpixel_positioning);
+  font->setForceAutoHinting(params.autohinter);
+  font->setHinting(FontRenderParamsHintingToSkFontHinting(params.hinting));
+}
+
+}  // namespace internal
+
+// static
+constexpr char16_t RenderText::kPasswordReplacementChar;
+constexpr bool RenderText::kDragToEndIfOutsideVerticalBounds;
+constexpr int RenderText::kInvalidBaseline;
+constexpr SkScalar RenderText::kLineThicknessFactor;
+
+RenderText::~RenderText() = default;
+
+// static
+std::unique_ptr<RenderText> RenderText::CreateRenderText() {
+  return std::make_unique<RenderTextHarfBuzz>();
+}
+
+std::unique_ptr<RenderText> RenderText::CreateInstanceOfSameStyle(
+    const std::u16string& text) const {
+  std::unique_ptr<RenderText> render_text = CreateRenderText();
+  // |SetText()| must be called before styles are set.
+  render_text->SetText(text);
+  render_text->SetFontList(font_list_);
+  render_text->SetDirectionalityMode(directionality_mode_);
+  render_text->SetCursorEnabled(cursor_enabled_);
+  render_text->set_truncate_length(truncate_length_);
+  render_text->styles_ = styles_;
+  render_text->baselines_ = baselines_;
+  render_text->font_size_overrides_ = font_size_overrides_;
+  render_text->colors_ = colors_;
+  render_text->weights_ = weights_;
+  render_text->glyph_width_for_test_ = glyph_width_for_test_;
+  return render_text;
+}
+
+void RenderText::SetText(const std::u16string& text) {
+  DCHECK(!composition_range_.IsValid());
+  if (text_ == text)
+    return;
+  text_ = text;
+  UpdateStyleLengths();
+
+  // Clear style ranges as they might break new text graphemes and apply
+  // the first style to the whole text instead.
+  colors_.SetValue(colors_.breaks().front().second);
+  baselines_.SetValue(baselines_.breaks().front().second);
+  font_size_overrides_.SetValue(font_size_overrides_.breaks().front().second);
+  weights_.SetValue(weights_.breaks().front().second);
+  for (auto& style : styles_)
+    style.SetValue(style.breaks().front().second);
+  cached_bounds_and_offset_valid_ = false;
+
+  // Reset selection model. SetText should always followed by SetSelectionModel
+  // or SetCursorPosition in upper layer.
+  SetSelectionModel(SelectionModel());
+
+  // Invalidate the cached text direction if it depends on the text contents.
+  if (directionality_mode_ == DIRECTIONALITY_FROM_TEXT)
+    text_direction_ = base::i18n::UNKNOWN_DIRECTION;
+
+  obscured_reveal_index_ = -1;
+  OnTextAttributeChanged();
+}
+
+void RenderText::AppendText(const std::u16string& text) {
+  text_ += text;
+  UpdateStyleLengths();
+  cached_bounds_and_offset_valid_ = false;
+  obscured_reveal_index_ = -1;
+
+  // Invalidate the cached text direction if it depends on the text contents.
+  if (directionality_mode_ == DIRECTIONALITY_FROM_TEXT)
+    text_direction_ = base::i18n::UNKNOWN_DIRECTION;
+
+  OnTextAttributeChanged();
+}
+
+void RenderText::SetHorizontalAlignment(HorizontalAlignment alignment) {
+  if (horizontal_alignment_ != alignment) {
+    horizontal_alignment_ = alignment;
+    display_offset_ = Vector2d();
+    cached_bounds_and_offset_valid_ = false;
+  }
+}
+
+void RenderText::SetVerticalAlignment(VerticalAlignment alignment) {
+  if (vertical_alignment_ != alignment) {
+    vertical_alignment_ = alignment;
+    display_offset_ = Vector2d();
+    cached_bounds_and_offset_valid_ = false;
+  }
+}
+
+void RenderText::SetFontList(const FontList& font_list) {
+  font_list_ = font_list;
+  const int font_style = font_list.GetFontStyle();
+  weights_.SetValue(font_list.GetFontWeight());
+  styles_[TEXT_STYLE_ITALIC].SetValue((font_style & Font::ITALIC) != 0);
+  styles_[TEXT_STYLE_UNDERLINE].SetValue((font_style & Font::UNDERLINE) != 0);
+  styles_[TEXT_STYLE_HEAVY_UNDERLINE].SetValue(false);
+  baseline_ = kInvalidBaseline;
+  cached_bounds_and_offset_valid_ = false;
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::SetCursorEnabled(bool cursor_enabled) {
+  cursor_enabled_ = cursor_enabled;
+  cached_bounds_and_offset_valid_ = false;
+}
+
+void RenderText::SetObscured(bool obscured) {
+  if (obscured != obscured_) {
+    obscured_ = obscured;
+    obscured_reveal_index_ = -1;
+    cached_bounds_and_offset_valid_ = false;
+    OnTextAttributeChanged();
+  }
+}
+
+void RenderText::SetObscuredRevealIndex(int index) {
+  if (obscured_reveal_index_ != index) {
+    obscured_reveal_index_ = index;
+    cached_bounds_and_offset_valid_ = false;
+    OnTextAttributeChanged();
+  }
+}
+
+void RenderText::SetObscuredGlyphSpacing(int spacing) {
+  if (obscured_glyph_spacing_ != spacing) {
+    obscured_glyph_spacing_ = spacing;
+    OnLayoutTextAttributeChanged(true);
+  }
+}
+
+void RenderText::SetMultiline(bool multiline) {
+  if (multiline != multiline_) {
+    multiline_ = multiline;
+    cached_bounds_and_offset_valid_ = false;
+    OnTextAttributeChanged();
+  }
+}
+
+void RenderText::SetMaxLines(size_t max_lines) {
+  max_lines_ = max_lines;
+  OnDisplayTextAttributeChanged();
+}
+
+size_t RenderText::GetNumLines() {
+  return GetShapedText()->lines().size();
+}
+
+size_t RenderText::GetTextIndexOfLine(size_t line) {
+  const std::vector<internal::Line>& lines = GetShapedText()->lines();
+  if (line >= lines.size())
+    return text_.size();
+  return DisplayIndexToTextIndex(lines[line].display_text_index);
+}
+
+void RenderText::SetWordWrapBehavior(WordWrapBehavior behavior) {
+  // TODO(1150235): ELIDE_LONG_WORDS is not supported.
+  DCHECK_NE(behavior, ELIDE_LONG_WORDS);
+
+  if (word_wrap_behavior_ != behavior) {
+    word_wrap_behavior_ = behavior;
+    if (multiline_) {
+      cached_bounds_and_offset_valid_ = false;
+      OnTextAttributeChanged();
+    }
+  }
+}
+
+void RenderText::SetMinLineHeight(int line_height) {
+  if (min_line_height_ != line_height) {
+    min_line_height_ = line_height;
+    cached_bounds_and_offset_valid_ = false;
+    OnDisplayTextAttributeChanged();
+  }
+}
+
+void RenderText::SetElideBehavior(ElideBehavior elide_behavior) {
+  if (elide_behavior_ != elide_behavior) {
+    elide_behavior_ = elide_behavior;
+    OnDisplayTextAttributeChanged();
+  }
+}
+
+void RenderText::SetWhitespaceElision(absl::optional<bool> whitespace_elision) {
+  if (whitespace_elision_ != whitespace_elision) {
+    whitespace_elision_ = whitespace_elision;
+    OnDisplayTextAttributeChanged();
+  }
+}
+
+void RenderText::SetDisplayRect(const Rect& r) {
+  if (r != display_rect_) {
+    display_rect_ = r;
+    baseline_ = kInvalidBaseline;
+    cached_bounds_and_offset_valid_ = false;
+    OnDisplayTextAttributeChanged();
+  }
+}
+
+const std::vector<Range> RenderText::GetAllSelections() const {
+  return selection_model_.GetAllSelections();
+}
+
+void RenderText::SetCursorPosition(size_t position) {
+  size_t cursor = std::min(position, text().length());
+  if (IsValidCursorIndex(cursor)) {
+    SetSelectionModel(SelectionModel(
+        cursor, (cursor == 0) ? CURSOR_FORWARD : CURSOR_BACKWARD));
+  }
+}
+
+void RenderText::MoveCursor(BreakType break_type,
+                            VisualCursorDirection direction,
+                            SelectionBehavior selection_behavior) {
+  SelectionModel cursor(cursor_position(), selection_model_.caret_affinity());
+
+  // Ensure |cursor| is at the "end" of the current selection, since this
+  // determines which side should grow or shrink. If the prior change to the
+  // selection wasn't from cursor movement, the selection may be undirected. Or,
+  // the selection may be collapsing. In these cases, pick the "end" using
+  // |direction| (e.g. the arrow key) rather than the current selection range.
+  if ((!has_directed_selection_ || selection_behavior == SELECTION_NONE) &&
+      !selection().is_empty()) {
+    SelectionModel selection_start = GetSelectionModelForSelectionStart();
+    Point start = GetCursorBounds(selection_start, true).origin();
+    Point end = GetCursorBounds(cursor, true).origin();
+
+    // Use the selection start if it is left (when |direction| is CURSOR_LEFT)
+    // or right (when |direction| is CURSOR_RIGHT) of the selection end.
+    // Consider only the y-coordinates if the selection start and end are on
+    // different lines.
+    const bool cursor_is_leading =
+        (start.y() > end.y()) ||
+        ((start.y() == end.y()) && (start.x() > end.x()));
+    const bool cursor_should_be_trailing =
+        (direction == CURSOR_RIGHT) || (direction == CURSOR_DOWN);
+    if (cursor_is_leading == cursor_should_be_trailing) {
+      // In this case, a direction has been chosen that doesn't match
+      // |selection_model|, so the range must be reversed to place the cursor at
+      // the other end. Note the affinity won't matter: only the affinity of
+      // |start| (which points "in" to the selection) determines the movement.
+      Range range = selection_model_.selection();
+      selection_model_ = SelectionModel(Range(range.end(), range.start()),
+                                        selection_model_.caret_affinity());
+      cursor = selection_start;
+    }
+  }
+
+  // Cancelling a selection moves to the edge of the selection.
+  if (break_type != FIELD_BREAK && break_type != LINE_BREAK &&
+      !selection().is_empty() && selection_behavior == SELECTION_NONE) {
+    // Use the nearest word boundary in the proper |direction| for word breaks.
+    if (break_type == WORD_BREAK)
+      cursor = GetAdjacentSelectionModel(cursor, break_type, direction);
+    // Use an adjacent selection model if the cursor is not at a valid position.
+    if (!IsValidCursorIndex(cursor.caret_pos()))
+      cursor = GetAdjacentSelectionModel(cursor, CHARACTER_BREAK, direction);
+  } else {
+    cursor = GetAdjacentSelectionModel(cursor, break_type, direction);
+  }
+
+  // |cursor| corresponds to the tentative end point of the new selection. The
+  // selection direction is reversed iff the current selection is non-empty and
+  // the old selection end point and |cursor| are at the opposite ends of the
+  // old selection start point.
+  uint32_t min_end = std::min(selection().end(), cursor.selection().end());
+  uint32_t max_end = std::max(selection().end(), cursor.selection().end());
+  uint32_t current_start = selection().start();
+
+  bool selection_reversed = !selection().is_empty() &&
+                            min_end <= current_start &&
+                            current_start <= max_end;
+
+  // Take |selection_behavior| into account.
+  switch (selection_behavior) {
+    case SELECTION_RETAIN:
+      cursor.set_selection_start(current_start);
+      break;
+    case SELECTION_EXTEND:
+      cursor.set_selection_start(selection_reversed ? selection().end()
+                                                    : current_start);
+      break;
+    case SELECTION_CARET:
+      if (selection_reversed) {
+        cursor =
+            SelectionModel(current_start, selection_model_.caret_affinity());
+      } else {
+        cursor.set_selection_start(current_start);
+      }
+      break;
+    case SELECTION_NONE:
+      // Do nothing.
+      break;
+  }
+
+  SetSelection(cursor);
+  has_directed_selection_ = true;
+
+  // |cached_cursor_x| keeps the initial x-coordinates where CURSOR_UP or
+  // CURSOR_DOWN starts. This enables the cursor to keep the same x-coordinates
+  // even when the cursor passes through empty or short lines. The cached
+  // x-coordinates should be reset when the cursor moves in a horizontal
+  // direction.
+  if (direction != CURSOR_UP && direction != CURSOR_DOWN)
+    reset_cached_cursor_x();
+}
+
+bool RenderText::SetSelection(const SelectionModel& model) {
+  // Enforce valid selection model components.
+  uint32_t text_length = static_cast<uint32_t>(text().length());
+  std::vector<Range> ranges = model.GetAllSelections();
+  for (auto& range : ranges) {
+    range = {std::min(range.start(), text_length),
+             std::min(range.end(), text_length)};
+    // The current model only supports caret positions at valid cursor indices.
+    if (!IsValidCursorIndex(range.start()) || !IsValidCursorIndex(range.end()))
+      return false;
+  }
+  SelectionModel sel = SelectionModel(ranges, model.caret_affinity());
+  bool changed = sel != selection_model_;
+  SetSelectionModel(sel);
+  return changed;
+}
+
+bool RenderText::MoveCursorToPoint(const Point& point,
+                                   bool select,
+                                   const Point& drag_origin) {
+  reset_cached_cursor_x();
+  SelectionModel model = FindCursorPosition(point, drag_origin);
+  if (select)
+    model.set_selection_start(selection().start());
+  return SetSelection(model);
+}
+
+bool RenderText::SelectRange(const Range& range, bool primary) {
+  uint32_t text_length = static_cast<uint32_t>(text().length());
+  Range sel(std::min(range.start(), text_length),
+            std::min(range.end(), text_length));
+  // Allow selection bounds at valid indices amid multi-character graphemes.
+  if (!IsValidLogicalIndex(sel.start()) || !IsValidLogicalIndex(sel.end()))
+    return false;
+  if (primary) {
+    LogicalCursorDirection affinity = (sel.is_reversed() || sel.is_empty())
+                                          ? CURSOR_FORWARD
+                                          : CURSOR_BACKWARD;
+    SetSelectionModel(SelectionModel(sel, affinity));
+  } else {
+    AddSecondarySelection(sel);
+  }
+  return true;
+}
+
+bool RenderText::IsPointInSelection(const Point& point) {
+  if (selection().is_empty())
+    return false;
+  SelectionModel cursor = FindCursorPosition(point);
+  return RangeContainsCaret(
+      selection(), cursor.caret_pos(), cursor.caret_affinity());
+}
+
+void RenderText::ClearSelection() {
+  SetSelectionModel(
+      SelectionModel(cursor_position(), selection_model_.caret_affinity()));
+}
+
+void RenderText::SelectAll(bool reversed) {
+  const size_t length = text().length();
+  const Range all = reversed ? Range(length, 0) : Range(0, length);
+  const bool success = SelectRange(all);
+  DCHECK(success);
+}
+
+void RenderText::SelectWord() {
+  SelectRange(ExpandRangeToWordBoundary(selection()));
+}
+
+void RenderText::SetCompositionRange(const Range& composition_range) {
+  CHECK(!composition_range.IsValid() ||
+        Range(0, text_.length()).Contains(composition_range));
+  composition_range_.set_end(composition_range.end());
+  composition_range_.set_start(composition_range.start());
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::SetColor(SkColor value) {
+  colors_.SetValue(value);
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::ApplyColor(SkColor value, const Range& range) {
+  colors_.ApplyValue(value, range);
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::SetBaselineStyle(BaselineStyle value) {
+  baselines_.SetValue(value);
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::ApplyBaselineStyle(BaselineStyle value, const Range& range) {
+  baselines_.ApplyValue(value, range);
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::ApplyFontSizeOverride(int font_size_override,
+                                       const Range& range) {
+  font_size_overrides_.ApplyValue(font_size_override, range);
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::SetStyle(TextStyle style, bool value) {
+  styles_[style].SetValue(value);
+
+  cached_bounds_and_offset_valid_ = false;
+  // TODO(oshima|msw): Not all style change requires layout changes.
+  // Consider optimizing based on the type of change.
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::ApplyStyle(TextStyle style, bool value, const Range& range) {
+  styles_[style].ApplyValue(value, range);
+
+  cached_bounds_and_offset_valid_ = false;
+  // TODO(oshima|msw): Not all style change requires layout changes.
+  // Consider optimizing based on the type of change.
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::SetWeight(Font::Weight weight) {
+  weights_.SetValue(weight);
+
+  cached_bounds_and_offset_valid_ = false;
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::ApplyWeight(Font::Weight weight, const Range& range) {
+  weights_.ApplyValue(weight, range);
+
+  cached_bounds_and_offset_valid_ = false;
+  OnLayoutTextAttributeChanged(false);
+}
+
+bool RenderText::GetStyle(TextStyle style) const {
+  return (styles_[style].breaks().size() == 1) &&
+         styles_[style].breaks().front().second;
+}
+
+void RenderText::SetDirectionalityMode(DirectionalityMode mode) {
+  if (mode != directionality_mode_) {
+    directionality_mode_ = mode;
+    text_direction_ = base::i18n::UNKNOWN_DIRECTION;
+    cached_bounds_and_offset_valid_ = false;
+    OnLayoutTextAttributeChanged(false);
+  }
+}
+
+base::i18n::TextDirection RenderText::GetTextDirection() const {
+  if (text_direction_ == base::i18n::UNKNOWN_DIRECTION)
+    text_direction_ = GetTextDirectionForGivenText(text_);
+  return text_direction_;
+}
+
+base::i18n::TextDirection RenderText::GetDisplayTextDirection() {
+  EnsureLayout();
+  if (display_text_direction_ == base::i18n::UNKNOWN_DIRECTION)
+    display_text_direction_ = GetTextDirectionForGivenText(GetDisplayText());
+  return display_text_direction_;
+}
+
+VisualCursorDirection RenderText::GetVisualDirectionOfLogicalEnd() {
+  return GetDisplayTextDirection() == base::i18n::LEFT_TO_RIGHT ? CURSOR_RIGHT
+                                                                : CURSOR_LEFT;
+}
+
+VisualCursorDirection RenderText::GetVisualDirectionOfLogicalBeginning() {
+  return GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT ? CURSOR_RIGHT
+                                                                : CURSOR_LEFT;
+}
+
+Size RenderText::GetStringSize() {
+  const SizeF size_f = GetStringSizeF();
+  return Size(base::ClampCeil(size_f.width()),
+              base::ClampCeil(size_f.height()));
+}
+
+float RenderText::TotalLineWidth() {
+  float total_width = 0;
+  const internal::ShapedText* shaped_text = GetShapedText();
+  for (const auto& line : shaped_text->lines())
+    total_width += line.size.width();
+  return total_width;
+}
+
+float RenderText::GetContentWidthF() {
+  const float string_size = GetStringSizeF().width();
+  // The cursor is drawn one pixel beyond the int-enclosed text bounds.
+  return cursor_enabled_ ? std::ceil(string_size) + 1 : string_size;
+}
+
+int RenderText::GetContentWidth() {
+  return base::ClampCeil(GetContentWidthF());
+}
+
+int RenderText::GetBaseline() {
+  if (baseline_ == kInvalidBaseline) {
+    baseline_ =
+        DetermineBaselineCenteringText(display_rect().height(), font_list());
+  }
+  DCHECK_NE(kInvalidBaseline, baseline_);
+  return baseline_;
+}
+
+void RenderText::Draw(Canvas* canvas, bool select_all) {
+  EnsureLayout();
+
+  if (clip_to_display_rect()) {
+    Rect clip_rect(display_rect());
+    clip_rect.Inset(ShadowValue::GetMargin(shadows_));
+
+    canvas->Save();
+    canvas->ClipRect(clip_rect);
+  }
+
+  if (!text().empty()) {
+    std::vector<Range> draw_selections;
+    if (select_all)
+      draw_selections = {Range(0, text().length())};
+    else if (focused())
+      draw_selections = GetAllSelections();
+
+    DrawSelections(canvas, draw_selections);
+    internal::SkiaTextRenderer renderer(canvas);
+    DrawVisualText(&renderer, draw_selections);
+  }
+
+  if (clip_to_display_rect())
+    canvas->Restore();
+}
+
+SelectionModel RenderText::FindCursorPosition(const Point& view_point,
+                                              const Point& drag_origin) {
+  const internal::ShapedText* shaped_text = GetShapedText();
+  DCHECK(!shaped_text->lines().empty());
+
+  int line_index = GetLineContainingYCoord((view_point - GetLineOffset(0)).y());
+  // Handle kDragToEndIfOutsideVerticalBounds above or below the text in a
+  // single-line by extending towards the mouse cursor.
+  if (RenderText::kDragToEndIfOutsideVerticalBounds && !multiline() &&
+      (line_index < 0 ||
+       line_index >= static_cast<int>(shaped_text->lines().size()))) {
+    SelectionModel selection_start = GetSelectionModelForSelectionStart();
+    int edge = drag_origin.x() == 0 ? GetCursorBounds(selection_start, true).x()
+                                    : drag_origin.x();
+    bool left = view_point.x() < edge;
+    return EdgeSelectionModel(left ? CURSOR_LEFT : CURSOR_RIGHT);
+  }
+  // Otherwise, clamp |line_index| to a valid value or drag to logical ends.
+  if (line_index < 0) {
+    if (RenderText::kDragToEndIfOutsideVerticalBounds)
+      return EdgeSelectionModel(GetVisualDirectionOfLogicalBeginning());
+    line_index = 0;
+  }
+  if (line_index >= static_cast<int>(shaped_text->lines().size())) {
+    if (RenderText::kDragToEndIfOutsideVerticalBounds)
+      return EdgeSelectionModel(GetVisualDirectionOfLogicalEnd());
+    line_index = shaped_text->lines().size() - 1;
+  }
+  const internal::Line& line = shaped_text->lines()[line_index];
+  // Newline segment should be ignored in finding segment index with x
+  // coordinate because it's not drawn.
+  Vector2d newline_offset;
+  if (line.segments.size() >= 1 && IsNewlineSegment(line.segments.front()))
+    newline_offset.set_x(line.segments.front().width());
+
+  float point_offset_relative_segment = 0;
+  const int segment_index = GetLineSegmentContainingXCoord(
+      line, (view_point - GetLineOffset(line_index) + newline_offset).x(),
+      &point_offset_relative_segment);
+  if (segment_index < 0)
+    return LineSelectionModel(line_index, CURSOR_LEFT);
+  if (segment_index >= static_cast<int>(line.segments.size()))
+    return LineSelectionModel(line_index, CURSOR_RIGHT);
+  const internal::LineSegment& segment = line.segments[segment_index];
+
+  const internal::TextRunHarfBuzz& run = *GetRunList()->runs()[segment.run];
+  const size_t segment_min_glyph_index =
+      run.CharRangeToGlyphRange(segment.char_range).GetMin();
+  const float segment_offset_relative_run =
+      segment_min_glyph_index != 0
+          ? SkScalarToFloat(run.shape.positions[segment_min_glyph_index].x())
+          : 0;
+  const float point_offset_relative_run =
+      point_offset_relative_segment + segment_offset_relative_run;
+
+  // TODO(crbug.com/676287): Use offset within the glyph to return the correct
+  // grapheme position within a multi-grapheme glyph.
+  for (size_t i = 0; i < run.shape.glyph_count; ++i) {
+    const float end = i + 1 == run.shape.glyph_count
+                          ? run.shape.width
+                          : SkScalarToFloat(run.shape.positions[i + 1].x());
+    const float middle =
+        (end + SkScalarToFloat(run.shape.positions[i].x())) / 2;
+    const size_t index = DisplayIndexToTextIndex(run.shape.glyph_to_char[i]);
+    if (point_offset_relative_run < middle) {
+      return run.font_params.is_rtl ? SelectionModel(IndexOfAdjacentGrapheme(
+                                                         index, CURSOR_FORWARD),
+                                                     CURSOR_BACKWARD)
+                                    : SelectionModel(index, CURSOR_FORWARD);
+    }
+    if (point_offset_relative_run < end) {
+      return run.font_params.is_rtl ? SelectionModel(index, CURSOR_FORWARD)
+                                    : SelectionModel(IndexOfAdjacentGrapheme(
+                                                         index, CURSOR_FORWARD),
+                                                     CURSOR_BACKWARD);
+    }
+  }
+
+  return LineSelectionModel(line_index, CURSOR_RIGHT);
+}
+
+bool RenderText::IsValidLogicalIndex(size_t index) const {
+  // Check that the index is at a valid code point (not mid-surrogate-pair) and
+  // that it's not truncated from the display text (its glyph may be shown).
+  //
+  // Indices within truncated text are disallowed so users can easily interact
+  // with the underlying truncated text using the ellipsis as a proxy. This lets
+  // users select all text, select the truncated text, and transition from the
+  // last rendered glyph to the end of the text without getting invisible cursor
+  // positions nor needing unbounded arrow key presses to traverse the ellipsis.
+  return index == 0 || index == text().length() ||
+      (index < text().length() &&
+       (truncate_length_ == 0 || index < truncate_length_) &&
+       IsValidCodePointIndex(text(), index));
+}
+
+bool RenderText::IsValidCursorIndex(size_t index) const {
+  return index == 0 || index == text().length() ||
+         (IsValidLogicalIndex(index) && IsGraphemeBoundary(index));
+}
+
+Rect RenderText::GetCursorBounds(const SelectionModel& caret,
+                                 bool insert_mode) {
+  EnsureLayout();
+  size_t caret_pos = caret.caret_pos();
+  DCHECK(IsValidLogicalIndex(caret_pos));
+
+  // In overtype mode, ignore the affinity and always indicate that we will
+  // overtype the next character.
+  LogicalCursorDirection caret_affinity =
+      insert_mode ? caret.caret_affinity() : CURSOR_FORWARD;
+  float x = 0;
+  int width = 1;
+
+  // Check whether the caret is attached to a boundary. Always return a 1-dip
+  // width caret at the boundary. Avoid calling IndexOfAdjacentGrapheme(), since
+  // it is slow and can impact browser startup here.
+  // In insert mode, index 0 is always a boundary. The end, however, is not at a
+  // boundary when the string ends in RTL text and there is LTR text around it.
+  const bool at_boundary =
+      (insert_mode && caret_pos == 0) ||
+      caret_pos == (caret_affinity == CURSOR_BACKWARD ? 0 : text().length());
+  if (at_boundary) {
+    const bool rtl = GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT;
+    if (rtl == (caret_pos == 0))
+      x = TotalLineWidth();
+  } else {
+    // Find the next grapheme continuing in the current direction. This
+    // determines the substring range that should be highlighted.
+    size_t caret_end = IndexOfAdjacentGrapheme(caret_pos, caret_affinity);
+    if (caret_end < caret_pos)
+      std::swap(caret_end, caret_pos);
+
+    const RangeF xspan = GetCursorSpan(Range(caret_pos, caret_end));
+    if (insert_mode) {
+      x = (caret_affinity == CURSOR_BACKWARD) ? xspan.end() : xspan.start();
+    } else {  // overtype mode
+      x = xspan.GetMin();
+      // Ceil the start and end of the |xspan| because the cursor x-coordinates
+      // are always ceiled.
+      width = base::ClampCeil(Clamp(xspan.GetMax())) -
+              base::ClampCeil(Clamp(xspan.GetMin()));
+    }
+  }
+  Size line_size = gfx::ToCeiledSize(GetLineSizeF(caret));
+  size_t line = GetLineContainingCaret(caret);
+  return Rect(ToViewPoint(PointF(x, 0), line), Size(width, line_size.height()));
+}
+
+const Rect& RenderText::GetUpdatedCursorBounds() {
+  UpdateCachedBoundsAndOffset();
+  return cursor_bounds_;
+}
+
+internal::GraphemeIterator RenderText::GetGraphemeIteratorAtTextIndex(
+    size_t index) const {
+  EnsureLayoutTextUpdated();
+  return GetGraphemeIteratorAtIndex(
+      text_, &internal::TextToDisplayIndex::text_index, index);
+}
+
+internal::GraphemeIterator RenderText::GetGraphemeIteratorAtDisplayTextIndex(
+    size_t index) const {
+  EnsureLayoutTextUpdated();
+  return GetGraphemeIteratorAtIndex(
+      layout_text_, &internal::TextToDisplayIndex::display_index, index);
+}
+
+size_t RenderText::GetTextIndex(internal::GraphemeIterator iter) const {
+  DCHECK(layout_text_up_to_date_);
+  return iter == text_to_display_indices_.end() ? text_.length()
+                                                : iter->text_index;
+}
+
+size_t RenderText::GetDisplayTextIndex(internal::GraphemeIterator iter) const {
+  DCHECK(layout_text_up_to_date_);
+  return iter == text_to_display_indices_.end() ? layout_text_.length()
+                                                : iter->display_index;
+}
+
+bool RenderText::IsGraphemeBoundary(size_t index) const {
+  return index >= text_.length() ||
+         GetTextIndex(GetGraphemeIteratorAtTextIndex(index)) == index;
+}
+
+size_t RenderText::IndexOfAdjacentGrapheme(
+    size_t index,
+    LogicalCursorDirection direction) const {
+  // The input is clamped if it is out of that range.
+  if (text_.empty())
+    return 0;
+  if (index > text_.length())
+    return text_.length();
+
+  EnsureLayoutTextUpdated();
+
+  internal::GraphemeIterator iter = index == text_.length()
+                                        ? text_to_display_indices_.end()
+                                        : GetGraphemeIteratorAtTextIndex(index);
+  if (direction == CURSOR_FORWARD) {
+    if (iter != text_to_display_indices_.end())
+      ++iter;
+  } else {
+    DCHECK_EQ(direction, CURSOR_BACKWARD);
+    // If the index was not at the beginning of the grapheme, it will have been
+    // moved back to the grapheme start.
+    if (iter != text_to_display_indices_.begin() && GetTextIndex(iter) == index)
+      --iter;
+  }
+  return GetTextIndex(iter);
+}
+
+SelectionModel RenderText::GetSelectionModelForSelectionStart() const {
+  const Range& sel = selection();
+  if (sel.is_empty())
+    return selection_model_;
+  return SelectionModel(sel.start(),
+                        sel.is_reversed() ? CURSOR_BACKWARD : CURSOR_FORWARD);
+}
+
+const Vector2d& RenderText::GetUpdatedDisplayOffset() {
+  UpdateCachedBoundsAndOffset();
+  return display_offset_;
+}
+
+void RenderText::SetDisplayOffset(int horizontal_offset) {
+  SetDisplayOffset({horizontal_offset, display_offset_.y()});
+}
+
+void RenderText::SetDisplayOffset(Vector2d offset) {
+  const int extra_content = GetContentWidth() - display_rect_.width();
+  const int cursor_width = cursor_enabled_ ? 1 : 0;
+
+  int min_offset = 0;
+  int max_offset = 0;
+  if (extra_content > 0) {
+    switch (GetCurrentHorizontalAlignment()) {
+      case ALIGN_LEFT:
+        min_offset = -extra_content;
+        break;
+      case ALIGN_RIGHT:
+        max_offset = extra_content;
+        break;
+      case ALIGN_CENTER:
+        // The extra space reserved for cursor at the end of the text is ignored
+        // when centering text. So, to calculate the valid range for offset, we
+        // exclude that extra space, calculate the range, and add it back to the
+        // range (if cursor is enabled).
+        min_offset = -(extra_content - cursor_width + 1) / 2 - cursor_width;
+        max_offset = (extra_content - cursor_width) / 2;
+        break;
+      default:
+        break;
+    }
+  }
+
+  const int horizontal_offset = base::clamp(offset.x(), min_offset, max_offset);
+
+  // y-offset is set only when the vertical alignment is ALIGN_TOP.
+  // TODO(jongkown.lee): Support other vertical alignments.
+  DCHECK(vertical_alignment_ == ALIGN_TOP || offset.y() == 0);
+  const int vertical_offset = base::clamp(
+      offset.y(),
+      std::min(display_rect_.height() - GetStringSize().height(), 0), 0);
+
+  cached_bounds_and_offset_valid_ = true;
+  display_offset_ = {horizontal_offset, vertical_offset};
+  cursor_bounds_ = GetCursorBounds(selection_model_, true);
+}
+
+Vector2d RenderText::GetLineOffset(size_t line_number) {
+  const internal::ShapedText* shaped_text = GetShapedText();
+  Vector2d offset = display_rect().OffsetFromOrigin();
+  if (!multiline()) {
+    offset.Add(GetUpdatedDisplayOffset());
+  } else {
+    DCHECK_LT(line_number, shaped_text->lines().size());
+    offset.Add(GetUpdatedDisplayOffset());
+    offset.Add(
+        Vector2d(0, shaped_text->lines()[line_number].preceding_heights));
+  }
+  offset.Add(GetAlignmentOffset(line_number));
+  return offset;
+}
+
+bool RenderText::GetWordLookupDataAtPoint(const Point& point,
+                                          DecoratedText* decorated_word,
+                                          Point* baseline_point) {
+  if (obscured())
+    return false;
+
+  EnsureLayout();
+  const SelectionModel model_at_point = FindCursorPosition(point);
+  const size_t word_index =
+      GetNearestWordStartBoundary(model_at_point.caret_pos());
+  if (word_index >= text().length())
+    return false;
+
+  const Range word_range = ExpandRangeToWordBoundary(Range(word_index));
+  DCHECK(!word_range.is_reversed());
+  DCHECK(!word_range.is_empty());
+
+  return GetLookupDataForRange(word_range, decorated_word, baseline_point);
+}
+
+bool RenderText::GetLookupDataForRange(const Range& range,
+                                       DecoratedText* decorated_text,
+                                       Point* baseline_point) {
+  const internal::ShapedText* shaped_text = GetShapedText();
+
+  const std::vector<Rect> word_bounds = GetSubstringBounds(range);
+  if (word_bounds.empty() || !GetDecoratedTextForRange(range, decorated_text)) {
+    return false;
+  }
+
+  // Retrieve the baseline origin of the left-most glyph.
+  const auto left_rect = std::min_element(
+      word_bounds.begin(), word_bounds.end(),
+      [](const Rect& lhs, const Rect& rhs) { return lhs.x() < rhs.x(); });
+  const int line_index = GetLineContainingYCoord(left_rect->CenterPoint().y() -
+                                                 GetLineOffset(0).y());
+  if (line_index < 0 ||
+      line_index >= static_cast<int>(shaped_text->lines().size()))
+    return false;
+  *baseline_point = left_rect->origin() +
+                    Vector2d(0, shaped_text->lines()[line_index].baseline);
+  return true;
+}
+
+std::u16string RenderText::GetTextFromRange(const Range& range) const {
+  if (range.IsValid() && range.GetMin() < text().length())
+    return text().substr(range.GetMin(), range.length());
+  return std::u16string();
+}
+
+Range RenderText::ExpandRangeToGraphemeBoundary(const Range& range) const {
+  const auto snap_to_grapheme = [this](auto index, auto direction) {
+    return IsValidCursorIndex(index)
+               ? index
+               : IndexOfAdjacentGrapheme(index, direction);
+  };
+
+  const size_t min_index = snap_to_grapheme(range.GetMin(), CURSOR_BACKWARD);
+  const size_t max_index = snap_to_grapheme(range.GetMax(), CURSOR_FORWARD);
+  return range.is_reversed() ? Range(max_index, min_index)
+                             : Range(min_index, max_index);
+}
+
+bool RenderText::IsNewlineSegment(const internal::LineSegment& segment) const {
+  return IsNewlineSegment(text_, segment);
+}
+
+bool RenderText::IsNewlineSegment(const std::u16string& text,
+                                  const internal::LineSegment& segment) const {
+  const size_t offset = segment.char_range.start();
+  const size_t length = segment.char_range.length();
+  DCHECK_LT(offset + length - 1, text.length());
+  return (length == 1 && (text[offset] == '\r' || text[offset] == '\n')) ||
+         (length == 2 && text[offset] == '\r' && text[offset + 1] == '\n');
+}
+
+Range RenderText::GetLineRange(const std::u16string& text,
+                               const internal::Line& line) const {
+  // This will find the logical start and end indices of the given line.
+  size_t max_index = 0;
+  size_t min_index = text.length();
+  for (const auto& segment : line.segments) {
+    min_index = std::min<size_t>(min_index, segment.char_range.GetMin());
+    max_index = std::max<size_t>(max_index, segment.char_range.GetMax());
+  }
+
+  // Do not include the newline character, as that could be considered leading
+  // into the next line. Note that the newline character is always the last
+  // character of the line regardless of the text direction, so decrease the
+  // |max_index|.
+  if (!line.segments.empty() &&
+      (IsNewlineSegment(text, line.segments.back()) ||
+       IsNewlineSegment(text, line.segments.front()))) {
+    --max_index;
+  }
+
+  return Range(min_index, max_index);
+}
+
+RenderText::RenderText() = default;
+
+internal::StyleIterator RenderText::GetTextStyleIterator() const {
+  return internal::StyleIterator(&colors_, &baselines_, &font_size_overrides_,
+                                 &weights_, &styles_);
+}
+
+internal::StyleIterator RenderText::GetLayoutTextStyleIterator() const {
+  EnsureLayoutTextUpdated();
+  return internal::StyleIterator(&layout_colors_, &layout_baselines_,
+                                 &layout_font_size_overrides_, &layout_weights_,
+                                 &layout_styles_);
+}
+
+bool RenderText::IsHomogeneous() const {
+  if (colors().breaks().size() > 1 || baselines().breaks().size() > 1 ||
+      font_size_overrides().breaks().size() > 1 ||
+      weights().breaks().size() > 1) {
+    return false;
+  }
+
+  return std::none_of(
+      styles().cbegin(), styles().cend(),
+      [](const auto& style) { return style.breaks().size() > 1; });
+}
+
+internal::ShapedText* RenderText::GetShapedText() {
+  EnsureLayout();
+  DCHECK(shaped_text_);
+  return shaped_text_.get();
+}
+
+int RenderText::GetDisplayTextBaseline() {
+  DCHECK(!GetShapedText()->lines().empty());
+  return GetShapedText()->lines()[0].baseline;
+}
+
+SelectionModel RenderText::GetAdjacentSelectionModel(
+    const SelectionModel& current,
+    BreakType break_type,
+    VisualCursorDirection direction) {
+  EnsureLayout();
+
+  if (direction == CURSOR_UP || direction == CURSOR_DOWN)
+    return AdjacentLineSelectionModel(current, direction);
+  if (break_type == FIELD_BREAK || text().empty())
+    return EdgeSelectionModel(direction);
+  if (break_type == LINE_BREAK)
+    return LineSelectionModel(GetLineContainingCaret(current), direction);
+  if (break_type == CHARACTER_BREAK)
+    return AdjacentCharSelectionModel(current, direction);
+  DCHECK(break_type == WORD_BREAK);
+  return AdjacentWordSelectionModel(current, direction);
+}
+
+SelectionModel RenderText::EdgeSelectionModel(
+    VisualCursorDirection direction) {
+  if (direction == GetVisualDirectionOfLogicalEnd())
+    return SelectionModel(text().length(), CURSOR_FORWARD);
+  return SelectionModel(0, CURSOR_BACKWARD);
+}
+
+SelectionModel RenderText::LineSelectionModel(size_t line_index,
+                                              VisualCursorDirection direction) {
+  DCHECK(direction == CURSOR_LEFT || direction == CURSOR_RIGHT);
+  DCHECK_LT(line_index, GetShapedText()->lines().size());
+  const internal::Line& line = GetShapedText()->lines()[line_index];
+  if (line.segments.empty()) {
+    // Only the last line can be empty.
+    DCHECK_EQ(GetShapedText()->lines().size() - 1, line_index);
+    return EdgeSelectionModel(GetVisualDirectionOfLogicalEnd());
+  }
+  if (line_index ==
+      (direction == GetVisualDirectionOfLogicalEnd() ? GetNumLines() - 1 : 0)) {
+    return EdgeSelectionModel(direction);
+  }
+
+  DCHECK_GT(GetNumLines(), 1U);
+  Range line_range = GetLineRange(text(), line);
+
+  // Cursor affinity should be the opposite of visual direction to preserve the
+  // line number of the cursor in multiline text.
+  return direction == GetVisualDirectionOfLogicalEnd()
+             ? SelectionModel(DisplayIndexToTextIndex(line_range.end()),
+                              CURSOR_BACKWARD)
+             : SelectionModel(DisplayIndexToTextIndex(line_range.start()),
+                              CURSOR_FORWARD);
+}
+
+void RenderText::SetSelectionModel(const SelectionModel& model) {
+  DCHECK_LE(model.selection().GetMax(), text().length());
+  selection_model_ = model;
+  cached_bounds_and_offset_valid_ = false;
+  has_directed_selection_ = kSelectionIsAlwaysDirected;
+}
+
+void RenderText::AddSecondarySelection(const Range selection) {
+  DCHECK_LE(selection.GetMax(), text().length());
+  selection_model_.AddSecondarySelection(selection);
+}
+
+size_t RenderText::TextIndexToDisplayIndex(size_t index) const {
+  return GetDisplayTextIndex(GetGraphemeIteratorAtTextIndex(index));
+}
+
+size_t RenderText::DisplayIndexToTextIndex(size_t index) const {
+  return GetTextIndex(GetGraphemeIteratorAtDisplayTextIndex(index));
+}
+
+void RenderText::OnLayoutTextAttributeChanged(bool text_changed) {
+  layout_text_up_to_date_ = false;
+}
+
+void RenderText::EnsureLayoutTextUpdated() const {
+  if (layout_text_up_to_date_)
+    return;
+
+  layout_text_.clear();
+  text_to_display_indices_.clear();
+
+  display_text_direction_ = base::i18n::UNKNOWN_DIRECTION;
+
+  // Reset the previous layout text attributes. Allocate enough space for
+  // layout text attributes (upper limit to 2x characters per codepoint). The
+  // actual size will be updated at the end of the function.
+  UpdateLayoutStyleLengths(2 * text_.length());
+
+  // Create an grapheme iterator to ensure layout BreakLists don't break
+  // graphemes.
+  base::i18n::BreakIterator grapheme_iter(
+      text_, base::i18n::BreakIterator::BREAK_CHARACTER);
+  bool success = grapheme_iter.Init();
+  DCHECK(success);
+
+  // Ensures the reveal index is at a codepoint boundary (e.g. not in a middle
+  // of a surrogate pairs).
+  size_t reveal_index = text_.size();
+  if (obscured_reveal_index_ != -1) {
+    reveal_index = base::checked_cast<size_t>(obscured_reveal_index_);
+    // Move |reveal_index| to the beginning of the surrogate pair, if needed.
+    if (reveal_index < text_.size())
+      U16_SET_CP_START(text_.data(), 0, reveal_index);
+  }
+
+  // Iterates through graphemes from |text_| and rewrite its codepoints to
+  // |layout_text_|.
+  base::i18n::UTF16CharIterator text_iter(text_);
+  internal::StyleIterator styles = GetTextStyleIterator();
+  bool text_truncated = false;
+  while (!text_iter.end() && !text_truncated) {
+    std::vector<uint32_t> grapheme_codepoints;
+    const size_t text_grapheme_start_position = text_iter.array_pos();
+    const size_t layout_grapheme_start_position = layout_text_.size();
+
+    // Retrieve codepoints of the current grapheme.
+    do {
+      grapheme_codepoints.push_back(text_iter.get());
+      text_iter.Advance();
+    } while (!grapheme_iter.IsGraphemeBoundary(text_iter.array_pos()) &&
+             !text_iter.end());
+    const size_t text_grapheme_end_position = text_iter.array_pos();
+
+    // Keep track of the mapping between |text_| and |layout_text_| indices.
+    internal::TextToDisplayIndex mapping = {text_grapheme_start_position,
+                                            layout_grapheme_start_position};
+    text_to_display_indices_.push_back(mapping);
+
+    // Flag telling if the current grapheme is a newline control sequence.
+    const bool is_newline_grapheme =
+        (grapheme_codepoints.size() == 1 &&
+         (grapheme_codepoints[0] == '\r' || grapheme_codepoints[0] == '\n')) ||
+        (grapheme_codepoints.size() == 2 && grapheme_codepoints[0] == '\r' &&
+         grapheme_codepoints[1] == '\n');
+
+    // Obscure the layout text by replacing the grapheme by a bullet.
+    if (obscured_ &&
+        (reveal_index < text_grapheme_start_position ||
+         reveal_index >= text_grapheme_end_position) &&
+        (!is_newline_grapheme || !multiline_)) {
+      grapheme_codepoints.clear();
+      grapheme_codepoints.push_back(RenderText::kPasswordReplacementChar);
+    }
+
+    // Rewrite each codepoint of the grapheme.
+    for (uint32_t codepoint : grapheme_codepoints) {
+      // Handle unicode control characters ISO 6429 (block C0). Range from 0 to
+      // 0x1F and 0x7F. The newline character should be kept as-is when
+      // rendertext is multiline.
+      if (!multiline_ || !is_newline_grapheme)
+        codepoint = ReplaceControlCharacter(codepoint);
+
+      // Truncate the remaining codepoints if appending the codepoint to
+      // |layout_text_| is making the text larger than |truncate_length_|.
+      size_t codepoint_length = U16_LENGTH(codepoint);
+      text_truncated =
+          (truncate_length_ != 0 &&
+           ((layout_text_.size() + codepoint_length > truncate_length_) ||
+            (!text_iter.end() &&
+             (layout_text_.size() + codepoint_length == truncate_length_))));
+
+      if (text_truncated) {
+        codepoint = kEllipsisCodepoint;
+        codepoint_length = U16_LENGTH(codepoint);
+        // On truncate, remove the whole current grapheme.
+        layout_text_.resize(layout_grapheme_start_position);
+      }
+
+      // Append the codepoint to the layout text.
+      const size_t current_layout_text_position = layout_text_.size();
+      if (codepoint_length == 1) {
+        layout_text_ += codepoint;
+      } else {
+        layout_text_ += U16_LEAD(codepoint);
+        layout_text_ += U16_TRAIL(codepoint);
+      }
+
+      // Apply the style at current grapheme position to the layout text.
+      styles.IncrementToPosition(text_grapheme_start_position);
+
+      Range range(current_layout_text_position, layout_text_.size());
+      layout_colors_.ApplyValue(styles.color(), range);
+      layout_baselines_.ApplyValue(styles.baseline(), range);
+      layout_font_size_overrides_.ApplyValue(styles.font_size_override(),
+                                             range);
+      layout_weights_.ApplyValue(styles.weight(), range);
+      for (size_t i = 0; i < layout_styles_.size(); ++i) {
+        layout_styles_[i].ApplyValue(styles.style(static_cast<TextStyle>(i)),
+                                     range);
+      }
+
+      // Apply an underline to the composition range in |underlines|.
+      const Range grapheme_start_range(text_grapheme_start_position,
+                                       text_grapheme_start_position + 1);
+      if (composition_range_.Contains(grapheme_start_range))
+        layout_styles_[TEXT_STYLE_HEAVY_UNDERLINE].ApplyValue(true, range);
+
+      // Stop appending characters if the text is truncated.
+      if (text_truncated)
+        break;
+    }
+  }
+
+  // Resize the layout text attributes to the actual layout text length.
+  UpdateLayoutStyleLengths(layout_text_.length());
+
+  // Ensures that the text got truncated correctly, when needed.
+  DCHECK(truncate_length_ == 0 || layout_text_.size() <= truncate_length_);
+
+  // Wait to reset |layout_text_up_to_date_| until the end, to ensure this
+  // function's implementation doesn't indirectly rely on it being up to date
+  // anywhere.
+  layout_text_up_to_date_ = true;
+}
+
+const std::u16string& RenderText::GetLayoutText() const {
+  EnsureLayoutTextUpdated();
+  return layout_text_;
+}
+
+void RenderText::UpdateDisplayText(float text_width) {
+  EnsureLayoutTextUpdated();
+
+  // TODO(krb): Consider other elision modes for multiline.
+  if ((multiline_ && (!max_lines_ || elide_behavior() != ELIDE_TAIL)) ||
+      elide_behavior() == NO_ELIDE || elide_behavior() == FADE_TAIL ||
+      (text_width > 0 && text_width < display_rect_.width()) ||
+      layout_text_.empty()) {
+    text_elided_ = false;
+    display_text_.clear();
+    return;
+  }
+
+  if (!multiline_) {
+    // This doesn't trim styles so ellipsis may get rendered as a different
+    // style than the preceding text. See crbug.com/327850.
+    display_text_.assign(Elide(layout_text_, text_width,
+                               static_cast<float>(display_rect_.width()),
+                               elide_behavior_));
+  } else {
+    bool was_elided = text_elided_;
+    text_elided_ = false;
+    display_text_.clear();
+
+    std::unique_ptr<RenderText> render_text(
+        CreateInstanceOfSameStyle(layout_text_));
+    render_text->SetMultiline(true);
+    render_text->SetWordWrapBehavior(word_wrap_behavior_);
+    render_text->SetDisplayRect(display_rect_);
+    // Have it arrange words on |lines_|.
+    render_text->EnsureLayout();
+
+    if (render_text->GetShapedText()->lines().size() > max_lines_) {
+      // Find the start and end index of the line to be elided.
+      Range line_range = GetLineRange(
+          layout_text_, render_text->GetShapedText()->lines()[max_lines_ - 1]);
+      // Add an ellipsis character in case the last line is short enough to fit
+      // on a single line. Otherwise that character will be elided anyway.
+      std::u16string text_to_elide =
+          layout_text_.substr(line_range.start(), line_range.length()) +
+          std::u16string(kEllipsisUTF16);
+      display_text_.assign(layout_text_.substr(0, line_range.start()) +
+                           Elide(text_to_elide, 0,
+                                 static_cast<float>(display_rect_.width()),
+                                 ELIDE_TAIL));
+      // Have GetLineBreaks() re-calculate.
+      line_breaks_.SetMax(0);
+    } else {
+      // If elision changed, re-calculate.
+      if (was_elided)
+        line_breaks_.SetMax(0);
+      // Initial state above is fine.
+      return;
+    }
+  }
+  text_elided_ = display_text_ != layout_text_;
+  if (!text_elided_)
+    display_text_.clear();
+}
+
+const BreakList<size_t>& RenderText::GetLineBreaks() {
+  if (line_breaks_.max() != 0)
+    return line_breaks_;
+
+  const std::u16string& layout_text = GetDisplayText();
+  const size_t text_length = layout_text.length();
+  line_breaks_.SetValue(0);
+  line_breaks_.SetMax(text_length);
+  base::i18n::BreakIterator iter(layout_text,
+                                 base::i18n::BreakIterator::BREAK_LINE);
+  const bool success = iter.Init();
+  DCHECK(success);
+  if (success) {
+    do {
+      line_breaks_.ApplyValue(iter.pos(), Range(iter.pos(), text_length));
+    } while (iter.Advance());
+  }
+  return line_breaks_;
+}
+
+Point RenderText::ToViewPoint(const PointF& point, size_t line) {
+  if (GetNumLines() == 1) {
+    return Point(base::ClampCeil(Clamp(point.x())),
+                 base::ClampRound(point.y())) +
+           GetLineOffset(0);
+  }
+
+  const internal::ShapedText* shaped_text = GetShapedText();
+  float x = point.x();
+
+  if (GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT) {
+    // |xspan| returned from |GetCursorSpan| in |GetCursorBounds| starts to grow
+    // from the last character in RTL. On the other hand, the last character is
+    // positioned in the last line in RTL. So, traverse from the last line.
+    for (size_t l = GetNumLines() - 1; l > line; --l) {
+      x -= shaped_text->lines()[l].size.width();
+    }
+  } else {
+    // TODO(crbug.com/1163587): This doesn't account for line breaks caused by
+    // wrapping, in which case the cursor may end up right after the trailing
+    // space on the top line instead of before the first character of the second
+    // line depending on which direction the cursor is moving. Both positions
+    // are "correct" but most text editors only allow one or the other for
+    // consistency.
+    for (size_t l = 0; l < line; ++l) {
+      x -= shaped_text->lines()[l].size.width();
+    }
+  }
+
+  return Point(base::ClampCeil(Clamp(x)), base::ClampRound(point.y())) +
+         GetLineOffset(line);
+}
+
+HorizontalAlignment RenderText::GetCurrentHorizontalAlignment() {
+  if (horizontal_alignment_ != ALIGN_TO_HEAD)
+    return horizontal_alignment_;
+  return GetDisplayTextDirection() == base::i18n::RIGHT_TO_LEFT ?
+      ALIGN_RIGHT : ALIGN_LEFT;
+}
+
+Vector2d RenderText::GetAlignmentOffset(size_t line_number) {
+  DCHECK(!multiline_ || (line_number < GetShapedText()->lines().size()));
+
+  Vector2d offset;
+  HorizontalAlignment horizontal_alignment = GetCurrentHorizontalAlignment();
+  if (horizontal_alignment != ALIGN_LEFT) {
+    const int width =
+        multiline_
+            ? std::ceil(GetShapedText()->lines()[line_number].size.width()) +
+                  (cursor_enabled_ ? 1 : 0)
+            : GetContentWidth();
+    offset.set_x(display_rect().width() - width);
+    // Put any extra margin pixel on the left to match legacy behavior.
+    if (horizontal_alignment == ALIGN_CENTER)
+      offset.set_x((offset.x() + 1) / 2);
+  }
+
+  switch (vertical_alignment_) {
+    case ALIGN_TOP:
+      offset.set_y(0);
+      break;
+    case ALIGN_MIDDLE:
+      if (multiline_)
+        offset.set_y((display_rect_.height() - GetStringSize().height()) / 2);
+      else
+        offset.set_y(GetBaseline() - GetDisplayTextBaseline());
+      break;
+    case ALIGN_BOTTOM:
+      offset.set_y(display_rect_.height() - GetStringSize().height());
+      break;
+  }
+
+  return offset;
+}
+
+void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
+  const int width = display_rect().width();
+  if (multiline() || elide_behavior_ != FADE_TAIL || GetContentWidth() <= width)
+    return;
+
+  const int gradient_width = CalculateFadeGradientWidth(font_list(), width);
+  if (gradient_width == 0)
+    return;
+
+  HorizontalAlignment horizontal_alignment = GetCurrentHorizontalAlignment();
+  Rect solid_part = display_rect();
+  Rect left_part;
+  Rect right_part;
+  if (horizontal_alignment != ALIGN_LEFT) {
+    left_part = solid_part;
+    left_part.Inset(0, 0, solid_part.width() - gradient_width, 0);
+    solid_part.Inset(gradient_width, 0, 0, 0);
+  }
+  if (horizontal_alignment != ALIGN_RIGHT) {
+    right_part = solid_part;
+    right_part.Inset(solid_part.width() - gradient_width, 0, 0, 0);
+    solid_part.Inset(0, 0, gradient_width, 0);
+  }
+
+  // CreateFadeShader() expects at least one part to not be empty.
+  // See https://crbug.com/706835.
+  if (left_part.IsEmpty() && right_part.IsEmpty())
+    return;
+
+  Rect text_rect = display_rect();
+  text_rect.Inset(GetAlignmentOffset(0).x(), 0, 0, 0);
+
+  // TODO(msw): Use the actual text colors corresponding to each faded part.
+  renderer->SetShader(
+      CreateFadeShader(font_list(), text_rect, left_part, right_part,
+                       SkColorSetA(colors_.breaks().front().second, 0xff)));
+}
+
+void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
+  renderer->SetDrawLooper(CreateShadowDrawLooper(shadows_));
+}
+
+base::i18n::TextDirection RenderText::GetTextDirectionForGivenText(
+    const std::u16string& text) const {
+  switch (directionality_mode_) {
+    case DIRECTIONALITY_FROM_TEXT:
+      // Derive the direction from the display text, which differs from text()
+      // in the case of obscured (password) textfields.
+      return base::i18n::GetFirstStrongCharacterDirection(text);
+    case DIRECTIONALITY_FROM_UI:
+      return base::i18n::IsRTL() ? base::i18n::RIGHT_TO_LEFT
+                                 : base::i18n::LEFT_TO_RIGHT;
+    case DIRECTIONALITY_FORCE_LTR:
+      return base::i18n::LEFT_TO_RIGHT;
+    case DIRECTIONALITY_FORCE_RTL:
+      return base::i18n::RIGHT_TO_LEFT;
+    case DIRECTIONALITY_AS_URL:
+      // Rendering as a URL implies left-to-right paragraph direction.
+      // URL Standard specifies that a URL "should be rendered as if it were
+      // in a left-to-right embedding".
+      // https://url.spec.whatwg.org/#url-rendering
+      //
+      // Consider logical string for domain "ABC.com/hello" (where ABC are
+      // Hebrew (RTL) characters). The normal Bidi algorithm renders this as
+      // "com/hello.CBA"; by forcing LTR, it is rendered as "CBA.com/hello".
+      //
+      // Note that this only applies a LTR embedding at the top level; it
+      // doesn't change the Bidi algorithm, so there are still some URLs that
+      // will render in a confusing order. Consider the logical string
+      // "abc.COM/HELLO/world", which will render as "abc.OLLEH/MOC/world".
+      // See https://crbug.com/351639.
+      //
+      // Note that the LeftToRightUrls feature flag enables additional
+      // behaviour for DIRECTIONALITY_AS_URL, but the left-to-right embedding
+      // behaviour is always enabled, regardless of the flag.
+      return base::i18n::LEFT_TO_RIGHT;
+    default:
+      NOTREACHED();
+      return base::i18n::UNKNOWN_DIRECTION;
+  }
+}
+
+void RenderText::UpdateStyleLengths() {
+  const size_t text_length = text_.length();
+  colors_.SetMax(text_length);
+  baselines_.SetMax(text_length);
+  font_size_overrides_.SetMax(text_length);
+  weights_.SetMax(text_length);
+  for (auto& style : styles_)
+    style.SetMax(text_length);
+}
+
+void RenderText::UpdateLayoutStyleLengths(size_t max_length) const {
+  layout_colors_.SetMax(max_length);
+  layout_baselines_.SetMax(max_length);
+  layout_font_size_overrides_.SetMax(max_length);
+  layout_weights_.SetMax(max_length);
+  for (auto& layout_style : layout_styles_)
+    layout_style.SetMax(max_length);
+}
+
+int RenderText::GetLineContainingYCoord(float text_y) {
+  if (text_y < 0)
+    return -1;
+
+  internal::ShapedText* shaper_text = GetShapedText();
+  for (size_t i = 0; i < shaper_text->lines().size(); i++) {
+    const internal::Line& line = shaper_text->lines()[i];
+
+    if (text_y <= line.size.height())
+      return i;
+    text_y -= line.size.height();
+  }
+
+  return shaper_text->lines().size();
+}
+
+// static
+bool RenderText::RangeContainsCaret(const Range& range,
+                                    size_t caret_pos,
+                                    LogicalCursorDirection caret_affinity) {
+  // NB: exploits unsigned wraparound (WG14/N1124 section 6.2.5 paragraph 9).
+  size_t adjacent = (caret_affinity == CURSOR_BACKWARD) ?
+      caret_pos - 1 : caret_pos + 1;
+  return range.Contains(Range(caret_pos, adjacent));
+}
+
+// static
+int RenderText::DetermineBaselineCenteringText(const int display_height,
+                                               const FontList& font_list) {
+  const int font_height = font_list.GetHeight();
+  // Lower and upper bound of baseline shift as we try to show as much area of
+  // text as possible.  In particular case of |display_height| == |font_height|,
+  // we do not want to shift the baseline.
+  const int min_shift = std::min(0, display_height - font_height);
+  const int max_shift = std::abs(display_height - font_height);
+  const int baseline = font_list.GetBaseline();
+  const int cap_height = font_list.GetCapHeight();
+  const int internal_leading = baseline - cap_height;
+  // Some platforms don't support getting the cap height, and simply return
+  // the entire font ascent from GetCapHeight().  Centering the ascent makes
+  // the font look too low, so if GetCapHeight() returns the ascent, center
+  // the entire font height instead.
+  const int space =
+      display_height - ((internal_leading != 0) ? cap_height : font_height);
+  const int baseline_shift = space / 2 - internal_leading;
+  return baseline + base::clamp(baseline_shift, min_shift, max_shift);
+}
+
+// static
+Rect RenderText::ExpandToBeVerticallySymmetric(const Rect& rect,
+                                               const Rect& display_rect) {
+  // Mirror |rect| across the horizontal line dividing |display_rect| in half.
+  Rect result = rect;
+  int mid_y = display_rect.CenterPoint().y();
+  // The top of the mirror rect must be equidistant with the bottom of the
+  // original rect from the mid-line.
+  result.set_y(mid_y + (mid_y - rect.bottom()));
+
+  // Now make a union with the original rect to ensure we are encompassing both.
+  result.Union(rect);
+  return result;
+}
+
+// static
+void RenderText::MergeIntersectingRects(std::vector<Rect>& rects) {
+  if (rects.size() < 2)
+    return;
+
+  std::sort(rects.begin(), rects.end(),
+            [](const Rect& a, const Rect& b) { return a.x() < b.x(); });
+
+  size_t merge_candidate = 0;
+  for (size_t i = 1; i < rects.size(); i++) {
+    if (rects[i].Intersects(rects[merge_candidate]) ||
+        rects[i].SharesEdgeWith(rects[merge_candidate])) {
+      DCHECK_EQ(rects[i].y(), rects[merge_candidate].y());
+      DCHECK_EQ(rects[i].height(), rects[merge_candidate].height());
+      rects[merge_candidate].Union(rects[i]);
+    } else {
+      merge_candidate++;
+      if (merge_candidate != i)
+        rects[merge_candidate] = rects[i];
+    }
+  }
+
+  rects.resize(merge_candidate + 1);
+}
+
+void RenderText::OnTextAttributeChanged() {
+  layout_text_.clear();
+  display_text_.clear();
+  text_elided_ = false;
+  line_breaks_.SetMax(0);
+
+  layout_text_up_to_date_ = false;
+
+  OnLayoutTextAttributeChanged(true);
+}
+
+std::u16string RenderText::Elide(const std::u16string& text,
+                                 float text_width,
+                                 float available_width,
+                                 ElideBehavior behavior) {
+  if (available_width <= 0 || text.empty())
+    return std::u16string();
+  if (behavior == ELIDE_EMAIL)
+    return ElideEmail(text, available_width);
+  if (text_width > 0 && text_width <= available_width)
+    return text;
+
+  TRACE_EVENT0("ui", "RenderText::Elide");
+
+  // Create a RenderText copy with attributes that affect the rendering width.
+  std::unique_ptr<RenderText> render_text = CreateInstanceOfSameStyle(text);
+  render_text->UpdateStyleLengths();
+  if (text_width == 0)
+    text_width = render_text->GetContentWidthF();
+  if (text_width <= available_width)
+    return text;
+
+  const std::u16string ellipsis = std::u16string(kEllipsisUTF16);
+  const bool insert_ellipsis = (behavior != TRUNCATE);
+  const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
+  const bool elide_at_beginning = (behavior == ELIDE_HEAD);
+
+  if (insert_ellipsis) {
+    render_text->SetText(ellipsis);
+    const float ellipsis_width = render_text->GetContentWidthF();
+    if (ellipsis_width > available_width)
+      return std::u16string();
+  }
+
+  StringSlicer slicer(text, ellipsis, elide_in_middle, elide_at_beginning,
+                      whitespace_elision_);
+
+  // Use binary(-like) search to compute the elided text.  In particular, do
+  // an interpolation search, which is a binary search in which each guess
+  // is an attempt to smartly calculate the right point rather than blindly
+  // guessing midway between the endpoints.
+  size_t lo = 0;
+  size_t hi = text.length() - 1;
+  size_t guess = std::string::npos;
+  // These two widths are not exactly right but they're good enough to provide
+  // some guidance to the search.  For example, |text_width| is actually the
+  // length of text.length(), not text.length()-1.
+  float lo_width = 0;
+  float hi_width = text_width;
+  const base::i18n::TextDirection text_direction = GetTextDirection();
+  while (lo <= hi) {
+    // Linearly interpolate between |lo| and |hi|, which correspond to widths
+    // of |lo_width| and |hi_width| to estimate at what position
+    // |available_width| would be at.  Because |lo_width| and |hi_width| are
+    // both estimates (may be off by a little because, for example, |lo_width|
+    // may have been calculated from |lo| minus one, not |lo|), we clamp to the
+    // the valid range.
+    // |last_guess| is merely used to verify that we're not repeating guesses.
+    const size_t last_guess = guess;
+    if (hi_width != lo_width) {
+      guess = lo + base::ClampRound<size_t>((available_width - lo_width) *
+                                            (hi - lo) / (hi_width - lo_width));
+    }
+    guess = base::clamp(guess, lo, hi);
+    DCHECK_NE(last_guess, guess);
+
+    // Restore colors. They will be truncated to size by SetText.
+    render_text->colors_ = colors_;
+    std::u16string new_text =
+        slicer.CutString(guess, insert_ellipsis && behavior != ELIDE_TAIL);
+
+    // This has to be an additional step so that the ellipsis is rendered with
+    // same style as trailing part of the text.
+    if (insert_ellipsis && behavior == ELIDE_TAIL) {
+      // When ellipsis follows text whose directionality is not the same as that
+      // of the whole text, it will be rendered with the directionality of the
+      // whole text. Since we want ellipsis to indicate continuation of the
+      // preceding text, we force the directionality of ellipsis to be same as
+      // the preceding text using LTR or RTL markers.
+      base::i18n::TextDirection trailing_text_direction =
+          base::i18n::GetLastStrongCharacterDirection(new_text);
+
+      // Ensures that the |new_text| will always be smaller or equal to the
+      // original text. There is a corner case when only one character is elided
+      // and two characters are added back (ellipsis and directional marker).
+      if (trailing_text_direction != text_direction &&
+          new_text.length() + 2 > text.length() && guess >= 1) {
+        new_text = slicer.CutString(guess - 1, false);
+        trailing_text_direction =
+            base::i18n::GetLastStrongCharacterDirection(new_text);
+      }
+
+      // Append the ellipsis and the optional directional marker characters.
+      // Do not append the BiDi marker if the only codepoint in the text is
+      // an ellipsis.
+      new_text.append(ellipsis);
+      if (new_text.size() != 1 && trailing_text_direction != text_direction) {
+        if (trailing_text_direction == base::i18n::LEFT_TO_RIGHT)
+          new_text += base::i18n::kLeftToRightMark;
+        else
+          new_text += base::i18n::kRightToLeftMark;
+      }
+    }
+
+    // The elided text must be smaller in bytes. Otherwise, break-lists are not
+    // consistent and the characters after the last range are not styled.
+    DCHECK_LE(new_text.size(), text.size());
+    render_text->SetText(new_text);
+
+    // Restore styles and baselines without breaking multi-character graphemes.
+    render_text->styles_ = styles_;
+    for (auto& style : render_text->styles_)
+      RestoreBreakList(render_text.get(), &style);
+    RestoreBreakList(render_text.get(), &render_text->baselines_);
+    RestoreBreakList(render_text.get(), &render_text->font_size_overrides_);
+    render_text->weights_ = weights_;
+    RestoreBreakList(render_text.get(), &render_text->weights_);
+
+    // We check the width of the whole desired string at once to ensure we
+    // handle kerning/ligatures/etc. correctly.
+    const float guess_width = render_text->GetContentWidthF();
+    if (guess_width == available_width)
+      break;
+    if (guess_width > available_width) {
+      hi = guess - 1;
+      hi_width = guess_width;
+      // Move back on the loop terminating condition when the guess is too wide.
+      if (hi < lo) {
+        lo = hi;
+        lo_width = guess_width;
+      }
+    } else {
+      lo = guess + 1;
+      lo_width = guess_width;
+    }
+  }
+
+  return render_text->text();
+}
+
+std::u16string RenderText::ElideEmail(const std::u16string& email,
+                                      float available_width) {
+  // The returned string will have at least one character besides the ellipsis
+  // on either side of '@'; if that's impossible, a single ellipsis is returned.
+  // If possible, only the username is elided. Otherwise, the domain is elided
+  // in the middle, splitting available width equally with the elided username.
+  // If the username is short enough that it doesn't need half the available
+  // width, the elided domain will occupy that extra width.
+
+  // Split the email into its local-part (username) and domain-part. The email
+  // spec allows for @ symbols in the username under some special requirements,
+  // but not in the domain part, so splitting at the last @ symbol is safe.
+  const size_t split_index = email.find_last_of('@');
+  if (split_index == std::u16string::npos)
+    return Elide(email, 0, available_width, ELIDE_TAIL);
+
+  std::u16string username = email.substr(0, split_index);
+  std::u16string domain = email.substr(split_index + 1);
+
+  // TODO(http://crbug.com/1085014): Fix eliding of text with styles.
+  DCHECK(IsHomogeneous())
+      << "ElideEmail(...) doesn't work with non homogeneous styles.";
+  auto render_text = CreateInstanceOfSameStyle(std::u16string());
+  auto get_string_width = [&](const std::u16string& text) {
+    render_text->SetText(text);
+    return render_text->GetStringSizeF().width();
+  };
+
+  // Subtract the @ symbol from the available width as it is mandatory.
+  const std::u16string kAtSignUTF16 = u"@";
+  float at_width = get_string_width(kAtSignUTF16);
+  if (available_width < at_width)
+    return Elide(kEllipsisUTF16, 0, available_width, ELIDE_TAIL);
+  const float remaining_width = available_width - at_width;
+
+  // Handle corner cases where one of username or domain is empty.
+  if (username.empty() && domain.empty()) {
+    return Elide(email, 0, available_width, ELIDE_TAIL);
+  } else if (username.empty()) {
+    domain = Elide(domain, 0, remaining_width, ELIDE_MIDDLE);
+    if (domain.empty() || domain == kEllipsisUTF16)
+      return Elide(kEllipsisUTF16, 0, available_width, ELIDE_TAIL);
+    return kAtSignUTF16 + domain;
+  } else if (domain.empty()) {
+    username = Elide(username, 0, remaining_width, ELIDE_TAIL);
+    if (username.empty() || username == kEllipsisUTF16)
+      return Elide(kEllipsisUTF16, 0, available_width, ELIDE_TAIL);
+    return username + kAtSignUTF16;
+  }
+
+  // Check whether eliding the domain is necessary: if eliding the username
+  // is sufficient, the domain will not be elided.
+  const float full_username_width = get_string_width(username);
+  const float available_domain_width =
+      remaining_width -
+      std::min(full_username_width,
+               get_string_width(username.substr(0, 1) + kEllipsisUTF16));
+  if (get_string_width(domain) > available_domain_width) {
+    // Elide the domain so that it only takes half of the available width.
+    // Should the username not need all the width available in its half, the
+    // domain will occupy the leftover width.
+    // If |desired_domain_width| is greater than |available_domain_width|: the
+    // minimal username elision allowed by the specifications will not fit; thus
+    // |desired_domain_width| must be <= |available_domain_width| at all cost.
+    const float desired_domain_width =
+        std::min<float>(available_domain_width,
+                        std::max<float>(remaining_width - full_username_width,
+                                        remaining_width / 2));
+    domain = Elide(domain, 0, desired_domain_width, ELIDE_MIDDLE);
+    // Failing to elide the domain such that at least one character remains
+    // (other than the ellipsis itself) remains: return a single ellipsis.
+    if (domain.empty() || domain == kEllipsisUTF16)
+      return Elide(kEllipsisUTF16, 0, available_width, ELIDE_TAIL);
+  }
+
+  // Fit the username in the remaining width (at this point the elided username
+  // is guaranteed to fit with at least one character remaining given all the
+  // precautions taken earlier).
+  const float domain_width = get_string_width(domain);
+  const float available_username_width = remaining_width - domain_width;
+  username = Elide(username, 0, available_username_width, ELIDE_TAIL);
+
+  return username + kAtSignUTF16 + domain;
+}
+
+void RenderText::UpdateCachedBoundsAndOffset() {
+  if (cached_bounds_and_offset_valid_)
+    return;
+
+  int delta_x = 0;
+  int delta_y = 0;
+
+  if (cursor_enabled()) {
+    // When cursor is enabled, ensure it is visible. For this, set the valid
+    // flag true and calculate the current cursor bounds using the stale
+    // |display_offset_|. Then calculate the change in offset needed to move the
+    // cursor into the visible area.
+    cached_bounds_and_offset_valid_ = true;
+    cursor_bounds_ = GetCursorBounds(selection_model_, true);
+
+    // TODO(bidi): Show RTL glyphs at the cursor position for ALIGN_LEFT, etc.
+    if (cursor_bounds_.right() > display_rect_.right())
+      delta_x = display_rect_.right() - cursor_bounds_.right();
+    else if (cursor_bounds_.x() < display_rect_.x())
+      delta_x = display_rect_.x() - cursor_bounds_.x();
+
+    if (vertical_alignment_ == ALIGN_TOP) {
+      if (cursor_bounds_.bottom() > display_rect_.bottom())
+        delta_y = display_rect_.bottom() - cursor_bounds_.bottom();
+      else if (cursor_bounds_.y() < display_rect_.y())
+        delta_y = display_rect_.y() - cursor_bounds_.y();
+    }
+  }
+
+  SetDisplayOffset(display_offset_ + Vector2d(delta_x, delta_y));
+}
+
+internal::GraphemeIterator RenderText::GetGraphemeIteratorAtIndex(
+    const std::u16string& text,
+    const size_t internal::TextToDisplayIndex::*field,
+    size_t index) const {
+  DCHECK_LE(index, text.length());
+  if (index == text.length())
+    return text_to_display_indices_.end();
+
+  DCHECK(layout_text_up_to_date_);
+  DCHECK(!text_to_display_indices_.empty());
+
+  // The function std::lower_bound(...) finds the first not less than |index|.
+  internal::GraphemeIterator iter = std::lower_bound(
+      text_to_display_indices_.begin(), text_to_display_indices_.end(), index,
+      [field](const internal::TextToDisplayIndex& lhs, size_t rhs) {
+        return lhs.*field < rhs;
+      });
+
+  if (iter == text_to_display_indices_.end() || *iter.*field != index) {
+    DCHECK(iter != text_to_display_indices_.begin());
+    --iter;
+  }
+
+  return iter;
+}
+
+void RenderText::DrawSelections(Canvas* canvas,
+                                const std::vector<Range>& selections) {
+  for (auto selection : selections) {
+    if (!selection.is_empty()) {
+      for (Rect s : GetSubstringBounds(selection)) {
+        if (symmetric_selection_visual_bounds() && !multiline())
+          s = ExpandToBeVerticallySymmetric(s, display_rect());
+        canvas->FillRect(s, selection_background_focused_color_);
+      }
+    }
+  }
+}
+
+size_t RenderText::GetNearestWordStartBoundary(size_t index) const {
+  const size_t length = text().length();
+  if (obscured() || length == 0)
+    return length;
+
+  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
+  const bool success = iter.Init();
+  DCHECK(success);
+  if (!success)
+    return length;
+
+  // First search for the word start boundary in the CURSOR_BACKWARD direction,
+  // then in the CURSOR_FORWARD direction.
+  for (int i = static_cast<int>(std::min(index, length - 1)); i >= 0; i--)
+    if (iter.IsStartOfWord(i))
+      return i;
+
+  for (size_t i = index + 1; i < length; i++)
+    if (iter.IsStartOfWord(i))
+      return i;
+
+  return length;
+}
+
+Range RenderText::ExpandRangeToWordBoundary(const Range& range) const {
+  const size_t length = text().length();
+  DCHECK_LE(range.GetMax(), length);
+  if (obscured())
+    return range.is_reversed() ? Range(length, 0) : Range(0, length);
+
+  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
+  const bool success = iter.Init();
+  DCHECK(success);
+  if (!success)
+    return range;
+
+  size_t range_min = range.GetMin();
+  if (range_min == length && range_min != 0)
+    --range_min;
+
+  for (; range_min != 0; --range_min)
+    if (iter.IsStartOfWord(range_min) || iter.IsEndOfWord(range_min))
+      break;
+
+  size_t range_max = range.GetMax();
+  if (range_min == range_max && range_max != length)
+    ++range_max;
+
+  for (; range_max < length; ++range_max)
+    if (iter.IsEndOfWord(range_max) || iter.IsStartOfWord(range_max))
+      break;
+
+  return range.is_reversed() ? Range(range_max, range_min)
+                             : Range(range_min, range_max);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/render_text.h b/ui/gfx/render_text.h
new file mode 100644
index 0000000..bb01b82
--- /dev/null
+++ b/ui/gfx/render_text.h
@@ -0,0 +1,1059 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RENDER_TEXT_H_
+#define UI_GFX_RENDER_TEXT_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/i18n/rtl.h"
+#include "base/macros.h"
+#include "build/build_config.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_flags.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkFont.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
+#include "ui/gfx/break_list.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/range/range.h"
+#include "ui/gfx/range/range_f.h"
+#include "ui/gfx/selection_model.h"
+#include "ui/gfx/shadow_value.h"
+#include "ui/gfx/text_constants.h"
+
+class SkDrawLooper;
+struct SkPoint;
+class SkTypeface;
+
+namespace gfx {
+namespace test {
+class RenderTextTestApi;
+}
+
+class Canvas;
+struct DecoratedText;
+class Font;
+
+namespace internal {
+
+class TextRunList;
+
+// Internal helper class used by derived classes to draw text through Skia.
+class GFX_EXPORT SkiaTextRenderer {
+ public:
+  explicit SkiaTextRenderer(Canvas* canvas);
+  SkiaTextRenderer(const SkiaTextRenderer&) = delete;
+  SkiaTextRenderer& operator=(const SkiaTextRenderer&) = delete;
+  virtual ~SkiaTextRenderer();
+
+  void SetDrawLooper(sk_sp<SkDrawLooper> draw_looper);
+  void SetFontRenderParams(const FontRenderParams& params,
+                           bool subpixel_rendering_suppressed);
+  void SetTypeface(sk_sp<SkTypeface> typeface);
+  void SetTextSize(SkScalar size);
+  void SetForegroundColor(SkColor foreground);
+  void SetShader(sk_sp<cc::PaintShader> shader);
+  // TODO(vmpstr): Change this API to mimic SkCanvas::drawTextBlob instead.
+  virtual void DrawPosText(const SkPoint* pos,
+                           const uint16_t* glyphs,
+                           size_t glyph_count);
+  void DrawUnderline(int x, int y, int width, SkScalar thickness_factor = 1.0);
+  void DrawStrike(int x, int y, int width, SkScalar thickness_factor);
+
+ private:
+  friend class test::RenderTextTestApi;
+
+  Canvas* canvas_;
+  cc::PaintCanvas* canvas_skia_;
+  cc::PaintFlags flags_;
+  SkFont font_;
+};
+
+struct TextToDisplayIndex {
+  size_t text_index = 0;
+  size_t display_index = 0;
+};
+using TextToDisplaySequence = std::vector<TextToDisplayIndex>;
+using GraphemeIterator = TextToDisplaySequence::const_iterator;
+using StyleArray = std::array<BreakList<bool>, TEXT_STYLE_COUNT>;
+
+// Internal helper class used to iterate colors, baselines, and styles.
+class StyleIterator {
+ public:
+  StyleIterator(const BreakList<SkColor>* colors,
+                const BreakList<BaselineStyle>* baselines,
+                const BreakList<int>* font_size_overrides,
+                const BreakList<Font::Weight>* weights,
+                const StyleArray* styles);
+  StyleIterator(const StyleIterator& style);
+  ~StyleIterator();
+  StyleIterator& operator=(const StyleIterator& style);
+
+  // Get the colors and styles at the current iterator position.
+  SkColor color() const { return color_->second; }
+  BaselineStyle baseline() const { return baseline_->second; }
+  int font_size_override() const { return font_size_override_->second; }
+  bool style(TextStyle s) const { return style_[s]->second; }
+  Font::Weight weight() const { return weight_->second; }
+
+  // Get the intersecting range of the current iterator set.
+  Range GetRange() const;
+
+  // Get the intersecting range of the current iterator set for attributes that
+  // can break text (e.g. not color).
+  Range GetTextBreakingRange() const;
+
+  // Update the iterator to point to colors and styles applicable at |position|.
+  void IncrementToPosition(size_t position);
+
+ private:
+  // Pointers to the breaklists to iterate through. These pointers can't be
+  // nullptr and the breaklists must outlive this object.
+  const BreakList<SkColor>* colors_;
+  const BreakList<BaselineStyle>* baselines_;
+  const BreakList<int>* font_size_overrides_;
+  const BreakList<Font::Weight>* weights_;
+  const StyleArray* styles_;
+
+  BreakList<SkColor>::const_iterator color_;
+  BreakList<BaselineStyle>::const_iterator baseline_;
+  BreakList<int>::const_iterator font_size_override_;
+  BreakList<Font::Weight>::const_iterator weight_;
+  std::array<BreakList<bool>::const_iterator, TEXT_STYLE_COUNT> style_;
+};
+
+// Line segments are slices of the display text to be rendered on a single line.
+struct LineSegment {
+  LineSegment();
+  ~LineSegment();
+
+  // X coordinates of this line segment in text space.
+  RangeF x_range;
+
+  // The character range this segment corresponds to.
+  Range char_range;
+
+  // Index of the text run that generated this segment.
+  size_t run;
+
+  // Returns the width of this line segment in text space.
+  float width() const { return x_range.length(); }
+};
+
+// A line of display text, comprised of a line segment list and some metrics.
+struct Line {
+  Line();
+  Line(const Line& other);
+  ~Line();
+
+  // Segments that make up this line in visual order.
+  std::vector<LineSegment> segments;
+
+  // The sum of segment widths and the maximum of segment heights.
+  SizeF size;
+
+  // Sum of preceding lines' heights.
+  int preceding_heights;
+
+  // Maximum baseline of all segments on this line.
+  int baseline;
+
+  // The text index of this line in |text_|.
+  int display_text_index = 0;
+};
+
+// Internal class that contains the results of the text layout and shaping.
+class ShapedText {
+ public:
+  explicit ShapedText(std::vector<Line> lines);
+  ~ShapedText();
+
+  const std::vector<Line>& lines() const { return lines_; }
+
+ private:
+  std::vector<Line> lines_;
+};
+
+// Creates an SkTypeface from a font, |italic| and a desired |weight|.
+// May return null.
+sk_sp<SkTypeface> CreateSkiaTypeface(const Font& font,
+                                     bool italic,
+                                     Font::Weight weight);
+
+// Applies the given FontRenderParams to the SkFont.
+void ApplyRenderParams(const FontRenderParams& params,
+                       bool subpixel_rendering_suppressed,
+                       SkFont* font);
+
+}  // namespace internal
+
+// RenderText represents an abstract model of styled text and its corresponding
+// visual layout. Support is built in for a cursor, selections, simple styling,
+// complex scripts, and bi-directional text. Implementations provide mechanisms
+// for rendering and translation between logical and visual data.
+class GFX_EXPORT RenderText {
+ public:
+#if defined(OS_APPLE)
+  // On Mac, while selecting text if the cursor is outside the vertical text
+  // bounds, drag to the end of the text.
+  static constexpr bool kDragToEndIfOutsideVerticalBounds = true;
+  // Mac supports a selection that is "undirected". When undirected, the cursor
+  // doesn't know which end of the selection it's at until it first moves.
+  static constexpr bool kSelectionIsAlwaysDirected = false;
+#else
+  static constexpr bool kDragToEndIfOutsideVerticalBounds = false;
+  static constexpr bool kSelectionIsAlwaysDirected = true;
+#endif
+
+  // Invalid value of baseline.  Assigning this value to |baseline_| causes
+  // re-calculation of baseline.
+  static constexpr int kInvalidBaseline = INT_MAX;
+
+  // Default fraction of the text size to use for a strike-through or underline.
+  static constexpr SkScalar kLineThicknessFactor = (SK_Scalar1 / 18);
+
+  // The character used for displaying obscured text. Use a bullet character.
+  // TODO(pbos): This is highly font dependent, consider replacing the character
+  // with a vector glyph.
+  static constexpr char16_t kPasswordReplacementChar = 0x2022;
+
+  RenderText(const RenderText&) = delete;
+  RenderText& operator=(const RenderText&) = delete;
+  virtual ~RenderText();
+
+  // Creates a RenderText instance.
+  static std::unique_ptr<RenderText> CreateRenderText();
+
+  // Like above but copies all style settings too.
+  std::unique_ptr<RenderText> CreateInstanceOfSameStyle(
+      const std::u16string& text) const;
+
+  const std::u16string& text() const { return text_; }
+  void SetText(const std::u16string& text);
+  void AppendText(const std::u16string& text);
+
+  HorizontalAlignment horizontal_alignment() const {
+    return horizontal_alignment_;
+  }
+  void SetHorizontalAlignment(HorizontalAlignment alignment);
+
+  VerticalAlignment vertical_alignment() const { return vertical_alignment_; }
+  void SetVerticalAlignment(VerticalAlignment alignment);
+
+  const FontList& font_list() const { return font_list_; }
+  void SetFontList(const FontList& font_list);
+
+  bool cursor_enabled() const { return cursor_enabled_; }
+  void SetCursorEnabled(bool cursor_enabled);
+
+  SkColor selection_color() const { return selection_color_; }
+  void set_selection_color(SkColor color) { selection_color_ = color; }
+
+  SkColor selection_background_focused_color() const {
+    return selection_background_focused_color_;
+  }
+  void set_selection_background_focused_color(SkColor color) {
+    selection_background_focused_color_ = color;
+  }
+
+  bool symmetric_selection_visual_bounds() const {
+    return symmetric_selection_visual_bounds_;
+  }
+  void set_symmetric_selection_visual_bounds(bool symmetric) {
+    symmetric_selection_visual_bounds_ = symmetric;
+  }
+
+  bool focused() const { return focused_; }
+  void set_focused(bool focused) { focused_ = focused; }
+
+  bool clip_to_display_rect() const { return clip_to_display_rect_; }
+  void set_clip_to_display_rect(bool clip) { clip_to_display_rect_ = clip; }
+
+  // In an obscured (password) field, all text is drawn as bullets.
+  bool obscured() const { return obscured_; }
+  void SetObscured(bool obscured);
+
+  // Makes a char in obscured text at |index| to be revealed. |index| should be
+  // a UTF16 text index. If there is a previous revealed index, the previous one
+  // is cleared and only the last set index will be revealed. If |index| is -1
+  // or out of range, no char will be revealed. The revealed index is also
+  // cleared when SetText or SetObscured is called.
+  void SetObscuredRevealIndex(int index);
+
+  // For obscured (password) fields, the extra spacing between glyphs.
+  int obscured_glyph_spacing() const { return obscured_glyph_spacing_; }
+  void SetObscuredGlyphSpacing(int spacing);
+
+  bool multiline() const { return multiline_; }
+  void SetMultiline(bool multiline);
+
+  // If multiline, a non-zero value will cap the number of lines rendered,
+  // and elide the rest (currently only ELIDE_TAIL supported.)
+  void SetMaxLines(size_t max_lines);
+  size_t max_lines() const { return max_lines_; }
+
+  // Returns the actual number of lines, broken by |lines_|.
+  size_t GetNumLines();
+
+  // Returns the text index of the given line |line|. Returns the text length
+  // for any |line| above the number of lines.
+  size_t GetTextIndexOfLine(size_t line);
+
+  // TODO(mukai): ELIDE_LONG_WORDS is not supported.
+  WordWrapBehavior word_wrap_behavior() const { return word_wrap_behavior_; }
+  void SetWordWrapBehavior(WordWrapBehavior behavior);
+
+  // TODO(ckocagil): Add vertical alignment and line spacing support instead.
+  int min_line_height() const { return min_line_height_; }
+  void SetMinLineHeight(int line_height);
+
+  // Set the maximum length of the layout text, not the actual text.
+  // A |length| of 0 forgoes a hard limit, but does not guarantee proper
+  // functionality of very long strings. Applies to subsequent SetText calls.
+  // WARNING: Only use this for system limits, it lacks complex text support.
+  void set_truncate_length(size_t length) { truncate_length_ = length; }
+
+  // The display text will be elided to fit |display_rect| using this behavior.
+  void SetElideBehavior(ElideBehavior elide_behavior);
+  ElideBehavior elide_behavior() const { return elide_behavior_; }
+
+  // When display text is elided, determines how whitespace is handled.
+  // If absl::nullopt is specified, the default elision for the current elide
+  // behavior will be applied.
+  void SetWhitespaceElision(absl::optional<bool> elide_whitespace);
+  absl::optional<bool> whitespace_elision() const {
+    return whitespace_elision_;
+  }
+
+  const Rect& display_rect() const { return display_rect_; }
+  void SetDisplayRect(const Rect& r);
+
+  bool subpixel_rendering_suppressed() const {
+    return subpixel_rendering_suppressed_;
+  }
+  void set_subpixel_rendering_suppressed(bool suppressed) {
+    subpixel_rendering_suppressed_ = suppressed;
+  }
+
+  const SelectionModel& selection_model() const { return selection_model_; }
+  const Range& selection() const { return selection_model_.selection(); }
+  size_t cursor_position() const { return selection_model_.caret_pos(); }
+  const std::vector<Range>& secondary_selections() const {
+    return selection_model_.secondary_selections();
+  }
+  const std::vector<Range> GetAllSelections() const;
+
+  // Set the cursor to |position|, with the caret affinity trailing the previous
+  // grapheme, or if there is no previous grapheme, leading the cursor position.
+  // See SelectionModel::caret_affinity_ for details.
+  void SetCursorPosition(size_t position);
+
+  // Moves the cursor left or right. Cursor movement is visual, meaning that
+  // left and right are relative to screen, not the directionality of the text.
+  // |selection_behavior| determines whether a selection is to be made and it's
+  // behavior.
+  void MoveCursor(BreakType break_type,
+                  VisualCursorDirection direction,
+                  SelectionBehavior selection_behavior);
+
+  // Set the selection_model_ to the value of |selection|.
+  // The selection range is clamped to text().length() if out of range.
+  // Returns true if the cursor position or selection range changed.
+  // If any index in |selection_model| is not a cursorable position (not on a
+  // grapheme boundary), it is a no-op and returns false.
+  bool SetSelection(const SelectionModel& selection);
+
+  // Moves the cursor to the text index corresponding to |point|. If |select| is
+  // true, a selection is made with the current selection start index. If the
+  // resultant text indices do not lie on valid grapheme boundaries, it is a no-
+  // op and returns false. If this move is happening because of a drag causing a
+  // selection change, and |drag_origin| is not the zero point, then
+  // |drag_origin| overrides the default origin for a select-to-drag
+  // (usually the existing text insertion cursor).
+  bool MoveCursorToPoint(const gfx::Point& point,
+                         bool select,
+                         const gfx::Point& drag_origin = gfx::Point());
+
+  // Set the |selection_model_| based on |range|. If the |range| start or end is
+  // greater than text length, it is modified to be the text length. If the
+  // |range| start or end is not a cursorable position (not on grapheme
+  // boundary), it is a NO-OP and returns false. Otherwise, returns true. If
+  // |primary| is true, secondary selections are cleared; otherwise, the range
+  // will be added as a secondary selection not associated with the cursor. In
+  // the latter case, |range| should not overlap with existing selections.
+  bool SelectRange(const Range& range, bool primary = true);
+
+  // Returns true if the local point is over selected text.
+  bool IsPointInSelection(const Point& point);
+
+  // Selects no text, keeping the current cursor position and caret affinity.
+  void ClearSelection();
+
+  // Select the entire text range. If |reversed| is true, the range will end at
+  // the logical beginning of the text; this generally shows the leading portion
+  // of text that overflows its display area.
+  void SelectAll(bool reversed);
+
+  // Selects the word at the current cursor position. If there is a non-empty
+  // selection, the selection bounds are extended to their nearest word
+  // boundaries.
+  void SelectWord();
+
+  void SetCompositionRange(const Range& composition_range);
+
+  // Set the text color over the entire text or a logical character range.
+  // The |range| should be valid, non-reversed, and within [0, text().length()].
+  void SetColor(SkColor value);
+  void ApplyColor(SkColor value, const Range& range);
+
+  // DEPRECATED.
+  // Set the baseline style over the entire text or a logical character range.
+  // The |range| should be valid, non-reversed, and within [0, text().length()].
+  // TODO(tapted): Remove this. The only client is moving to
+  // ApplyFontSizeOverride.
+  void SetBaselineStyle(BaselineStyle value);
+  void ApplyBaselineStyle(BaselineStyle value, const Range& range);
+
+  // Alters the font size in |range|.
+  void ApplyFontSizeOverride(int font_size_override, const Range& range);
+
+  // Set various text styles over the entire text or a logical character range.
+  // The respective |style| is applied if |value| is true, or removed if false.
+  // The |range| should be valid, non-reversed, and within [0, text().length()].
+  void SetStyle(TextStyle style, bool value);
+  void ApplyStyle(TextStyle style, bool value, const Range& range);
+
+  void SetWeight(Font::Weight weight);
+  void ApplyWeight(Font::Weight weight, const Range& range);
+
+  // Returns whether this style is enabled consistently across the entire
+  // RenderText.
+  bool GetStyle(TextStyle style) const;
+
+  // Set or get the text directionality mode and get the text direction yielded.
+  void SetDirectionalityMode(DirectionalityMode mode);
+  DirectionalityMode directionality_mode() const {
+    return directionality_mode_;
+  }
+
+  base::i18n::TextDirection GetTextDirection() const;
+  base::i18n::TextDirection GetDisplayTextDirection();
+
+  // Returns the visual movement direction corresponding to the logical
+  // end/beginning of the text, considering only the dominant direction returned
+  // by |GetDisplayTextDirection()|, not the direction of a particular run.
+  VisualCursorDirection GetVisualDirectionOfLogicalEnd();
+  VisualCursorDirection GetVisualDirectionOfLogicalBeginning();
+
+  // Returns the text used to display, which may be obscured, truncated or
+  // elided. The subclass may compute elided text on the fly, or use
+  // precomputed the elided text.
+  virtual const std::u16string& GetDisplayText() = 0;
+
+  // Returns the size required to display the current string (which is the
+  // wrapped size in multiline mode). The returned size does not include space
+  // reserved for the cursor or the offset text shadows.
+  Size GetStringSize();
+
+  // This is same as GetStringSize except that fractional size is returned.
+  // The default implementation is same as GetStringSize. Certain platforms that
+  // compute the text size as floating-point values, like Mac, will override
+  // this method.
+  // See comment in Canvas::GetStringWidthF for its usage.
+  virtual SizeF GetStringSizeF() = 0;
+
+  // Returns the size of the line containing |caret|.
+  virtual SizeF GetLineSizeF(const SelectionModel& caret) = 0;
+
+  // Returns the sum of all the line widths.
+  float TotalLineWidth();
+
+  // Returns the width of the content (which is the wrapped width in multiline
+  // mode). Reserves room for the cursor if |cursor_enabled_| is true.
+  float GetContentWidthF();
+
+  // Same as GetContentWidthF with the width rounded up.
+  int GetContentWidth();
+
+  // Returns the common baseline of the text. The return value is the vertical
+  // offset from the top of |display_rect_| to the text baseline, in pixels.
+  // The baseline is determined from the font list and display rect, and does
+  // not depend on the text.
+  int GetBaseline();
+
+  // If |select_all| is true, draws as focused with all text selected.
+  void Draw(Canvas* canvas, bool select_all = false);
+
+  // Gets the SelectionModel from a visual point in local coordinates. If
+  // |drag_origin| is nonzero, it is used as the baseline for
+  // out-of-vertical-bounds drags on platforms that have them, instead of the
+  // default origin (the insertion cursor's position).
+  SelectionModel FindCursorPosition(const Point& point,
+                                    const Point& drag_origin = gfx::Point());
+
+  // Returns true if the position is a valid logical index into text(). Indices
+  // amid multi-character graphemes are allowed here, unlike IsValidCursorIndex.
+  bool IsValidLogicalIndex(size_t index) const;
+
+  // Returns true if the position is a valid logical index into text(), and is
+  // also a valid grapheme boundary, which may be used as a cursor position.
+  bool IsValidCursorIndex(size_t index) const;
+
+  // Get the visual bounds of a cursor at |caret|. These bounds typically
+  // represent a vertical line if |insert_mode| is true. Pass false for
+  // |insert_mode| to retrieve the bounds of the associated glyph. These bounds
+  // are in local coordinates, but may be outside the visible region if the text
+  // is longer than the textfield. Subsequent text, cursor, or bounds changes
+  // may invalidate returned values. Note that |caret| must be placed at
+  // grapheme boundary, i.e. caret.caret_pos() must be a cursorable position.
+  // TODO(crbug.com/248597): Add multiline support.
+  Rect GetCursorBounds(const SelectionModel& caret, bool insert_mode);
+
+  // Compute the current cursor bounds, panning the text to show the cursor in
+  // the display rect if necessary. These bounds are in local coordinates.
+  // Subsequent text, cursor, or bounds changes may invalidate returned values.
+  const Rect& GetUpdatedCursorBounds();
+
+  // Returns a grapheme iterator that contains the codepoint at |index|.
+  internal::GraphemeIterator GetGraphemeIteratorAtTextIndex(size_t index) const;
+  internal::GraphemeIterator GetGraphemeIteratorAtDisplayTextIndex(
+      size_t index) const;
+
+  // For a given grapheme iterator, returns its index.
+  size_t GetTextIndex(internal::GraphemeIterator iter) const;
+  size_t GetDisplayTextIndex(internal::GraphemeIterator iter) const;
+
+  // Returns true of the current index is at the start of a grapheme.
+  bool IsGraphemeBoundary(size_t index) const;
+
+  // Given an |index| in text(), return the next or previous grapheme boundary
+  // in logical order (i.e. the nearest cursorable index). The return value is
+  // in the range 0 to text().length() inclusive (the input is clamped if it is
+  // out of that range). Always moves by at least one character index unless the
+  // supplied index is already at the boundary of the string.
+  size_t IndexOfAdjacentGrapheme(size_t index,
+                                 LogicalCursorDirection direction) const;
+
+  // Return a SelectionModel with the cursor at the current selection's start.
+  // The returned value represents a cursor/caret position without a selection.
+  SelectionModel GetSelectionModelForSelectionStart() const;
+
+  // Sets shadows to drawn with text.
+  void set_shadows(const ShadowValues& shadows) { shadows_ = shadows; }
+  const ShadowValues& shadows() const { return shadows_; }
+
+  // Get the visual bounds containing the logical substring within the |range|.
+  // If |range| is empty, the result is empty. This method rounds internally so
+  // the returned bounds may be slightly larger than the |range|, but are
+  // guaranteed not to be smaller. These bounds could be visually discontinuous
+  // if the substring is split by a LTR/RTL level change. These bounds are in
+  // local coordinates, but may be outside the visible region if the text is
+  // larger than the available space. Subsequent text, cursor, or bounds changes
+  // may invalidate returned values.
+  virtual std::vector<Rect> GetSubstringBounds(const Range& range) = 0;
+
+  // Gets the horizontal span (relative to the left of the text, not the view)
+  // of the sequence of glyphs in |text_range|, over which the cursor will
+  // jump when breaking by characters. If the glyphs are RTL then the returned
+  // Range will have is_reversed() true.  (This does not return a Rect because a
+  // Rect can't have a negative width.)
+  virtual RangeF GetCursorSpan(const Range& text_range) = 0;
+
+  const Vector2d& GetUpdatedDisplayOffset();
+  void SetDisplayOffset(int horizontal_offset);
+  void SetDisplayOffset(Vector2d offset);
+
+  // Returns the line offset from the origin after applying the text alignment
+  // and the display offset.
+  Vector2d GetLineOffset(size_t line_number);
+
+  // Retrieves the word displayed at the given |point| along with its styling
+  // information. |point| is in the view's coordinates. If no word is displayed
+  // at the point, returns a nearby word. |baseline_point| should correspond to
+  // the baseline point of the leftmost glyph of the |word| in the view's
+  // coordinates. Returns false, if no word can be retrieved.
+  bool GetWordLookupDataAtPoint(const Point& point,
+                                DecoratedText* decorated_word,
+                                Point* baseline_point);
+
+  // Retrieves the text at |range| along with its styling information.
+  // |baseline_point| should correspond to the baseline point of
+  // the leftmost glyph of the text in the view's coordinates. If the text
+  // spans multiple lines, |baseline_point| will correspond with the leftmost
+  // glyph on the first line in the range. Returns false, if no text can be
+  // retrieved.
+  bool GetLookupDataForRange(const Range& range,
+                             DecoratedText* decorated_text,
+                             Point* baseline_point);
+
+  // Retrieves the text in the given |range|.
+  std::u16string GetTextFromRange(const Range& range) const;
+
+  void set_strike_thickness_factor(SkScalar f) { strike_thickness_factor_ = f; }
+
+  // Return the line index that contains the argument; or the index of the last
+  // line if the |caret| exceeds the text length.
+  virtual size_t GetLineContainingCaret(const SelectionModel& caret) = 0;
+
+  // Expands |range| to its nearest grapheme boundaries and returns the
+  // resulting range. Maintains directionality of |range|.
+  Range ExpandRangeToGraphemeBoundary(const Range& range) const;
+
+  // Specify the width/height of a glyph for test. The width/height of glyphs is
+  // very platform-dependent and environment-dependent. Otherwise multiline text
+  // will become really flaky.
+  void set_glyph_width_for_test(float width) { glyph_width_for_test_ = width; }
+  void set_glyph_height_for_test(float height) {
+    glyph_height_for_test_ = height;
+  }
+
+ protected:
+  RenderText();
+
+  // Whether |segment| corresponds to the newline character. This uses |text_|
+  // to look up the corresponding character.
+  bool IsNewlineSegment(const internal::LineSegment& segment) const;
+
+  // Whether |segment| corresponds to the newline character inside |text|.
+  bool IsNewlineSegment(const std::u16string& text,
+                        const internal::LineSegment& segment) const;
+
+  // Returns the character range of segments in |line| excluding the trailing
+  // newline segment.
+  Range GetLineRange(const std::u16string& text,
+                     const internal::Line& line) const;
+
+  // Returns the text used for layout (e.g. after rewriting, eliding and
+  // obscuring characters).
+  const std::u16string& GetLayoutText() const;
+
+  // NOTE: The value of these accessors may be stale. Please make sure
+  // that these fields are up to date before accessing them.
+  const std::u16string& display_text() const { return display_text_; }
+  bool text_elided() const { return text_elided_; }
+
+  // Returns an iterator over the |text_| attributes.
+  internal::StyleIterator GetTextStyleIterator() const;
+  // Returns an iterator over the |layout_text_| attributes.
+  internal::StyleIterator GetLayoutTextStyleIterator() const;
+
+  const BreakList<SkColor>& colors() const { return colors_; }
+  const BreakList<BaselineStyle>& baselines() const { return baselines_; }
+  const BreakList<int>& font_size_overrides() const {
+    return font_size_overrides_;
+  }
+  const BreakList<Font::Weight>& weights() const { return weights_; }
+  const internal::StyleArray& styles() const { return styles_; }
+  SkScalar strike_thickness_factor() const { return strike_thickness_factor_; }
+
+  const BreakList<SkColor>& layout_colors() const { return layout_colors_; }
+
+  // Whether all the BreakLists have only one break.
+  bool IsHomogeneous() const;
+
+  // Returns the shaped text structure. The shaped text contains the visual
+  // positions of glyphs required to render the text.
+  bool has_shaped_text() const { return shaped_text_ != nullptr; }
+  internal::ShapedText* GetShapedText();
+  void set_shaped_text(std::unique_ptr<internal::ShapedText> shaped_text) {
+    shaped_text_ = std::move(shaped_text);
+  }
+
+  // Returns the baseline of the current text.  The return value depends on
+  // the text and its layout while the return value of GetBaseline() doesn't.
+  // GetAlignmentOffset() takes into account the difference between them.
+  //
+  // We'd like a RenderText to show the text always on the same baseline
+  // regardless of the text, so the text does not jump up or down depending
+  // on the text.  However, underlying layout engines return different baselines
+  // depending on the text.  In general, layout engines determine the minimum
+  // bounding box for the text and return the baseline from the top of the
+  // bounding box.  So the baseline changes depending on font metrics used to
+  // layout the text.
+  //
+  // For example, suppose there are FontA and FontB and the baseline of FontA
+  // is smaller than the one of FontB.  If the text is laid out only with FontA,
+  // then the baseline of FontA may be returned.  If the text includes some
+  // characters which are laid out with FontB, then the baseline of FontB may
+  // be returned.
+  //
+  // GetBaseline() returns the fixed baseline regardless of the text.
+  // GetDisplayTextBaseline() returns the baseline determined by the underlying
+  // layout engine, and it changes depending on the text.  GetAlignmentOffset()
+  // returns the difference between them.
+  int GetDisplayTextBaseline();
+
+  // Get the selection model that visually neighbors |position| by |break_type|.
+  // The returned value represents a cursor/caret position without a selection.
+  SelectionModel GetAdjacentSelectionModel(const SelectionModel& current,
+                                           BreakType break_type,
+                                           VisualCursorDirection direction);
+
+  // Get the selection model visually left/right of |selection| by one grapheme.
+  // The returned value represents a cursor/caret position without a selection.
+  virtual SelectionModel AdjacentCharSelectionModel(
+      const SelectionModel& selection,
+      VisualCursorDirection direction) = 0;
+
+  // Get the selection model visually left/right of |selection| by one word.
+  // The returned value represents a cursor/caret position without a selection.
+  virtual SelectionModel AdjacentWordSelectionModel(
+      const SelectionModel& selection,
+      VisualCursorDirection direction) = 0;
+
+  // Get the selection model visually above/below |selection| by one line.
+  // The returned value represents a cursor/caret position without a selection.
+  virtual SelectionModel AdjacentLineSelectionModel(
+      const SelectionModel& selection,
+      VisualCursorDirection direction) = 0;
+
+  // Get the selection model corresponding to visual text ends.
+  // The returned value represents a cursor/caret position without a selection.
+  SelectionModel EdgeSelectionModel(VisualCursorDirection direction);
+
+  // Get the selection model corresponding to visual text ends for |line_index|.
+  // The returned value represents a cursor/caret position without a selection.
+  SelectionModel LineSelectionModel(size_t line_index,
+                                    gfx::VisualCursorDirection direction);
+
+  // Sets the selection model. |model| should be valid.
+  void SetSelectionModel(const SelectionModel& model);
+  // Adds a secondary selection. |selection| should not overlap with existing
+  // selections.
+  void AddSecondarySelection(const Range selection);
+
+  // Convert between indices into |text_| and indices into
+  // GetDisplayText(), which differ when the text is obscured,
+  // truncated or elided.
+  size_t TextIndexToDisplayIndex(size_t index) const;
+  size_t DisplayIndexToTextIndex(size_t index) const;
+
+  // Notifies that layout text, or attributes that affect the layout text
+  // shape have changed. |text_changed| is true if the content of the
+  // |layout_text_| has changed, not just attributes.
+  virtual void OnLayoutTextAttributeChanged(bool text_changed);
+
+  // Notifies that attributes that affect the display text shape have changed.
+  virtual void OnDisplayTextAttributeChanged() = 0;
+
+  // Ensure the text is laid out, lines are computed, and |lines_| is valid.
+  virtual void EnsureLayout() = 0;
+
+  // Draw all text and make the given ranges appear selected.
+  virtual void DrawVisualText(internal::SkiaTextRenderer* renderer,
+                              const std::vector<Range>& selections) = 0;
+
+  // Update the display text.
+  void UpdateDisplayText(float text_width);
+
+  // Returns display text positions that are suitable for breaking lines.
+  const BreakList<size_t>& GetLineBreaks();
+
+  // Convert points from the text space to the view space. Handles the display
+  // area, display offset, application LTR/RTL mode and multiline. |line| is the
+  // index of the line in which |point| is found, and is required to be passed
+  // because by the time |point| is in text space, the information to account
+  // for certain zero-width characters (such as empty lines) is lost.
+  Point ToViewPoint(const PointF& point, size_t line);
+
+  // Get the alignment, resolving ALIGN_TO_HEAD with the current text direction.
+  HorizontalAlignment GetCurrentHorizontalAlignment();
+
+  // Returns the line offset from the origin, accounts for text alignment only.
+  Vector2d GetAlignmentOffset(size_t line_number);
+
+  // Applies fade effects to |renderer|.
+  void ApplyFadeEffects(internal::SkiaTextRenderer* renderer);
+
+  // Applies text shadows to |renderer|.
+  void ApplyTextShadows(internal::SkiaTextRenderer* renderer);
+
+  // Get the text direction for the current directionality mode and given
+  // |text|.
+  base::i18n::TextDirection GetTextDirectionForGivenText(
+      const std::u16string& text) const;
+
+  // Adjust ranged styles to accommodate a new |text_| length.
+  void UpdateStyleLengths();
+
+  // Adjust ranged styles to accommodate a new |layout_text_| length.
+  void UpdateLayoutStyleLengths(size_t max_length) const;
+
+  // Returns the line index for the given argument. |text_y| is relative to
+  // the text bounds. Returns -1 if |text_y| is above the text and
+  // lines().size() if |text_y| is below it.
+  int GetLineContainingYCoord(float text_y);
+
+  // A convenience function to check whether the glyph attached to the caret
+  // is within the given range.
+  static bool RangeContainsCaret(const Range& range,
+                                 size_t caret_pos,
+                                 LogicalCursorDirection caret_affinity);
+
+  // Returns the baseline, with which the text best appears vertically centered.
+  static int DetermineBaselineCenteringText(const int display_height,
+                                            const FontList& font_list);
+
+  // Returns an expanded version of |rect| that is vertically symmetric with
+  // respect to the center of |display_rect|.
+  static gfx::Rect ExpandToBeVerticallySymmetric(const gfx::Rect& rect,
+                                                 const gfx::Rect& display_rect);
+
+  // Given |rects|, sort them along the x-axis and merge intersecting rects
+  // using union. Expects all selections in the text to be from the same line.
+  static void MergeIntersectingRects(std::vector<Rect>& rects);
+
+  // Resets |cached_cursor_x_| to null. When non-null, CURSOR_UP, CURSOR_DOWN
+  // movements use this value instead of the current cursor x position to
+  // determine the next cursor x position.
+  void reset_cached_cursor_x() { cached_cursor_x_.reset(); }
+
+  void set_cached_cursor_x(int x) { cached_cursor_x_ = x; }
+  absl::optional<int> cached_cursor_x() const { return cached_cursor_x_; }
+
+  // Fixed width of glyphs. This should only be set in test environments.
+  float glyph_width_for_test_ = 0;
+  // Fixed height of glyphs. This should only be set in test environments.
+  float glyph_height_for_test_ = 0;
+
+ private:
+  friend class test::RenderTextTestApi;
+
+  // Resets |layout_text_| and |display_text_| and marks them dirty.
+  void OnTextAttributeChanged();
+
+  // Computes the |layout_text_| by rewriting it from |text_|, if needed.
+  // Computes the layout break lists, if needed.
+  void EnsureLayoutTextUpdated() const;
+
+  // Elides |text| as needed to fit in the |available_width| using |behavior|.
+  // |text_width| is the pre-calculated width of the text shaped by this render
+  // text, or pass 0 if the width is unknown.
+  std::u16string Elide(const std::u16string& text,
+                       float text_width,
+                       float available_width,
+                       ElideBehavior behavior);
+
+  // Elides |email| as needed to fit the |available_width|.
+  std::u16string ElideEmail(const std::u16string& email, float available_width);
+
+  // Update the cached bounds and display offset to ensure that the current
+  // cursor is within the visible display area.
+  void UpdateCachedBoundsAndOffset();
+
+  // Draws the specified ranges of text with a selected appearance.
+  void DrawSelections(Canvas* canvas, const std::vector<Range>& selections);
+
+  // Returns a grapheme iterator that contains the codepoint at |index|.
+  internal::GraphemeIterator GetGraphemeIteratorAtIndex(
+      const std::u16string& text,
+      const size_t internal::TextToDisplayIndex::*field,
+      size_t index) const;
+
+  // Returns the nearest word start boundary for |index|. First searches in the
+  // CURSOR_BACKWARD direction, then in the CURSOR_FORWARD direction. Returns
+  // the text length if no valid boundary is found.
+  size_t GetNearestWordStartBoundary(size_t index) const;
+
+  // Expands |range| to its nearest word boundaries and returns the resulting
+  // range. Maintains directionality of |range|.
+  Range ExpandRangeToWordBoundary(const Range& range) const;
+
+  // Returns an implementation-specific run list, if implemented.
+  virtual internal::TextRunList* GetRunList() = 0;
+  virtual const internal::TextRunList* GetRunList() const = 0;
+
+  // Returns the decorated text corresponding to |range|. Returns false if the
+  // text cannot be retrieved, e.g. if the text is obscured.
+  virtual bool GetDecoratedTextForRange(const Range& range,
+                                        DecoratedText* decorated_text) = 0;
+
+  // Logical UTF-16 string data to be drawn.
+  std::u16string text_;
+
+  // Horizontal alignment of the text with respect to |display_rect_|.  The
+  // default is to align left if the application UI is LTR and right if RTL.
+  HorizontalAlignment horizontal_alignment_{base::i18n::IsRTL() ? ALIGN_RIGHT
+                                                                : ALIGN_LEFT};
+
+  // Vertical alignment of the text with respect to |display_rect_|. Only
+  // applicable when |multiline_| is true. The default is to align center.
+  VerticalAlignment vertical_alignment_ = ALIGN_MIDDLE;
+
+  // The text directionality mode, defaults to DIRECTIONALITY_FROM_TEXT.
+  DirectionalityMode directionality_mode_ = DIRECTIONALITY_FROM_TEXT;
+
+  // The cached text direction, potentially computed from the text or UI locale.
+  // Use GetTextDirection(), do not use this potentially invalid value directly!
+  mutable base::i18n::TextDirection text_direction_ =
+      base::i18n::UNKNOWN_DIRECTION;
+  mutable base::i18n::TextDirection display_text_direction_ =
+      base::i18n::UNKNOWN_DIRECTION;
+
+  // A list of fonts used to render |text_|.
+  FontList font_list_;
+
+  // Logical selection ranges and visual cursor position.
+  SelectionModel selection_model_;
+
+  // The cached cursor bounds; get these bounds with GetUpdatedCursorBounds.
+  Rect cursor_bounds_;
+
+  // Specifies whether the cursor is enabled. If disabled, no space is reserved
+  // for the cursor when positioning text.
+  bool cursor_enabled_ = true;
+
+  // Whether the current selection has a known direction. That is, whether a
+  // directional input (e.g. arrow key) has been received for the current
+  // selection to indicate which end of the selection has the caret. When true,
+  // directed inputs preserve (rather than replace) the selection affinity.
+  bool has_directed_selection_ = kSelectionIsAlwaysDirected;
+
+  // The color used for drawing selected text.
+  SkColor selection_color_ = kPlaceholderColor;
+
+  // The background color used for drawing the selection when focused.
+  SkColor selection_background_focused_color_ = kPlaceholderColor;
+
+  // Whether the selection visual bounds should be expanded vertically to be
+  // vertically symmetric with respect to the display rect. Note this flag has
+  // no effect on multi-line text.
+  bool symmetric_selection_visual_bounds_ = false;
+
+  // The focus state of the text.
+  bool focused_ = false;
+
+  // Composition text range.
+  Range composition_range_ = Range::InvalidRange();
+
+  // Color, baseline, and style breaks, used to modify ranges of text.
+  // BreakList positions are stored with text indices, not display indices.
+  // TODO(msw): Expand to support cursor, selection, background, etc. colors.
+  BreakList<SkColor> colors_{kPlaceholderColor};
+  BreakList<BaselineStyle> baselines_{NORMAL_BASELINE};
+  BreakList<int> font_size_overrides_{0};
+  BreakList<Font::Weight> weights_{Font::Weight::NORMAL};
+  internal::StyleArray styles_;
+
+  mutable BreakList<SkColor> layout_colors_;
+  mutable BreakList<BaselineStyle> layout_baselines_;
+  mutable BreakList<int> layout_font_size_overrides_;
+  mutable BreakList<Font::Weight> layout_weights_;
+  mutable internal::StyleArray layout_styles_;
+
+  // A mapping from text to display text indices for each grapheme. The vector
+  // contains an ordered sequence of indice pairs. Both sequence |text_index|
+  // and |display_index| are sorted.
+  mutable internal::TextToDisplaySequence text_to_display_indices_;
+
+  // A flag to obscure actual text with asterisks for password fields.
+  bool obscured_ = false;
+  // The index at which the char should be revealed in the obscured text.
+  int obscured_reveal_index_ = -1;
+
+  // The maximum length of text to display, 0 forgoes a hard limit.
+  size_t truncate_length_ = 0;
+
+  // The obscured and/or truncated text used to layout the text to display.
+  mutable std::u16string layout_text_;
+
+  // The elided text displayed visually. This is empty if the text
+  // does not have to be elided, or became empty as a result of eliding.
+  // TODO(oshima): When the text is elided, painting can be done only with
+  // display text info, so it should be able to clear the |layout_text_| and
+  // associated information.
+  mutable std::u16string display_text_;
+
+  // The behavior for eliding, fading, or truncating.
+  ElideBehavior elide_behavior_ = NO_ELIDE;
+
+  // The behavior for eliding whitespace when eliding or truncating.
+  absl::optional<bool> whitespace_elision_;
+
+  // True if the text is elided given the current behavior and display area.
+  bool text_elided_ = false;
+
+  // The minimum height a line should have.
+  int min_line_height_ = 0;
+
+  // Whether the text should be broken into multiple lines. Uses the width of
+  // |display_rect_| as the width cap.
+  bool multiline_ = false;
+
+  // If multiple lines, the maximum number of lines to render, or 0.
+  size_t max_lines_ = 0;
+
+  // The wrap behavior when the text is broken into lines. Do nothing unless
+  // |multiline_| is set. The default value is IGNORE_LONG_WORDS.
+  WordWrapBehavior word_wrap_behavior_ = IGNORE_LONG_WORDS;
+
+  // Set to true to suppress subpixel rendering due to non-font reasons (eg.
+  // if the background is transparent). The default value is false.
+  bool subpixel_rendering_suppressed_ = false;
+
+  // The local display area for rendering the text.
+  Rect display_rect_;
+
+  // Flag to work around a Skia bug with the PDF path (http://crbug.com/133548)
+  // that results in incorrect clipping when drawing to the document margins.
+  // This field allows disabling clipping to work around the issue.
+  // TODO(asvitkine): Remove this when the underlying Skia bug is fixed.
+  bool clip_to_display_rect_ = true;
+
+  // The offset for the text to be drawn, relative to the display area.
+  // Get this point with GetUpdatedDisplayOffset (or risk using a stale value).
+  Vector2d display_offset_;
+
+  // The baseline of the text.  This is determined from the height of the
+  // display area and the cap height of the font list so the text is vertically
+  // centered.
+  int baseline_ = kInvalidBaseline;
+
+  // The cached bounds and offset are invalidated by changes to the cursor,
+  // selection, font, and other operations that adjust the visible text bounds.
+  bool cached_bounds_and_offset_valid_ = false;
+
+  // Text shadows to be drawn.
+  ShadowValues shadows_;
+
+  // A list of valid display text line break positions.
+  BreakList<size_t> line_breaks_;
+
+  // Text shaping computed by EnsureLayout. This should be invalidated upon
+  // OnLayoutTextAttributeChanged and OnDisplayTextAttributeChanged calls.
+  std::unique_ptr<internal::ShapedText> shaped_text_;
+
+  // The ratio of strike-through line thickness to text height.
+  SkScalar strike_thickness_factor_ = kLineThicknessFactor;
+
+  // Extra spacing placed between glyphs; used only for obscured text styling.
+  int obscured_glyph_spacing_ = 0;
+
+  // The cursor position in view space, used to traverse lines of varied widths.
+  absl::optional<int> cached_cursor_x_;
+
+  // Tell whether or not the |layout_text_| needs an update or is up to date.
+  mutable bool layout_text_up_to_date_ = false;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_RENDER_TEXT_H_
diff --git a/ui/gfx/render_text_api_fuzzer.cc b/ui/gfx/render_text_api_fuzzer.cc
new file mode 100644
index 0000000..8d39dfc
--- /dev/null
+++ b/ui/gfx/render_text_api_fuzzer.cc
@@ -0,0 +1,376 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include <algorithm>
+
+#include "base/at_exit.h"
+#include "base/command_line.h"
+#include "base/i18n/icu_util.h"
+#include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/test/task_environment.h"
+#include "base/test/test_timeouts.h"
+#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/render_text.h"
+
+// TODO(crbug.com/1052397): Revisit once build flag switch of lacros-chrome is
+// complete.
+#if defined(OS_ANDROID) || (defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS))
+#include "base/test/test_discardable_memory_allocator.h"
+#endif
+
+namespace {
+
+#if defined(OS_WIN)
+const char kFontDescription[] = "Segoe UI, 13px";
+#elif defined(OS_ANDROID)
+const char kFontDescription[] = "serif, 13px";
+#else
+const char kFontDescription[] = "sans, 13px";
+#endif
+
+struct Environment {
+  Environment()
+      : task_environment((base::CommandLine::Init(0, nullptr),
+                          TestTimeouts::Initialize(),
+                          base::test::TaskEnvironment::MainThreadType::UI)) {
+    logging::SetMinLogLevel(logging::LOG_FATAL);
+// TODO(crbug.com/1052397): Revisit once build flag switch of lacros-chrome is
+// complete.
+#if defined(OS_ANDROID) || (defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS))
+    // Some platforms require discardable memory to use bitmap fonts.
+    base::DiscardableMemoryAllocator::SetInstance(
+        &discardable_memory_allocator);
+#endif
+    CHECK(base::i18n::InitializeICU());
+    gfx::FontList::SetDefaultFontDescription(kFontDescription);
+  }
+
+// TODO(crbug.com/1052397): Revisit once build flag switch of lacros-chrome is
+// complete.
+#if defined(OS_ANDROID) || (defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS))
+  base::TestDiscardableMemoryAllocator discardable_memory_allocator;
+#endif
+
+  base::AtExitManager at_exit_manager;
+  base::test::TaskEnvironment task_environment;
+};
+
+// Commands recognized to drive the API calls on RenderText.
+enum class RenderTextAPI {
+  kDraw,
+  kSetText,
+  kAppendText,
+  kSetHorizontalAlignment,
+  kSetVerticalAlignment,
+  kSetCursorEnabled,
+  kSetSelectionColor,
+  kSetSelectionBackgroundFocusedColor,
+  kSetSymmetricSelectionVisualBounds,
+  kSetFocused,
+  kSetClipToDisplayRect,
+  kSetObscured,
+  kSetObscuredRevealIndex,
+  kSetMultiline,
+  kSetMaxLines,
+  kSetWordWrapBehavior,
+  kSetWhitespaceElision,
+  kSetSubpixelRenderingSuppressed,
+  kSetColor,
+  kApplyColor,
+  kSetStyle,
+  kApplyStyle,
+  kSetWeight,
+  kApplyWeight,
+  kSetDirectionalityMode,
+  kSetElideBehavior,
+  kIsGraphemeBoundary,
+  kIndexOfAdjacentGrapheme,
+  kSetObscuredGlyphSpacing,
+  kSetDisplayRect,
+  kGetSubstringBounds,
+  kGetCursorSpan,
+  kMaxValue = kGetCursorSpan
+};
+
+gfx::DirectionalityMode ConsumeDirectionalityMode(FuzzedDataProvider* fdp) {
+  if (fdp->ConsumeBool())
+    return gfx::DIRECTIONALITY_FORCE_RTL;
+  return gfx::DIRECTIONALITY_FORCE_LTR;
+}
+
+gfx::HorizontalAlignment ConsumeHorizontalAlignment(FuzzedDataProvider* fdp) {
+  switch (fdp->ConsumeIntegralInRange(0, 4)) {
+    case 0:
+      return gfx::ALIGN_LEFT;
+    case 1:
+      return gfx::ALIGN_CENTER;
+    case 2:
+      return gfx::ALIGN_RIGHT;
+    case 3:
+      return gfx::ALIGN_TO_HEAD;
+    default:
+      return gfx::ALIGN_LEFT;
+  }
+}
+
+gfx::VerticalAlignment ConsumeVerticalAlignment(FuzzedDataProvider* fdp) {
+  switch (fdp->ConsumeIntegralInRange(0, 3)) {
+    case 0:
+      return gfx::ALIGN_TOP;
+    case 1:
+      return gfx::ALIGN_MIDDLE;
+    case 2:
+      return gfx::ALIGN_BOTTOM;
+    default:
+      return gfx::ALIGN_TOP;
+  }
+}
+
+gfx::TextStyle ConsumeStyle(FuzzedDataProvider* fdp) {
+  switch (fdp->ConsumeIntegralInRange(0, 4)) {
+    case 0:
+      return gfx::TEXT_STYLE_ITALIC;
+    case 1:
+      return gfx::TEXT_STYLE_STRIKE;
+    case 2:
+      return gfx::TEXT_STYLE_UNDERLINE;
+    case 3:
+      return gfx::TEXT_STYLE_HEAVY_UNDERLINE;
+    default:
+      return gfx::TEXT_STYLE_ITALIC;
+  }
+}
+
+gfx::WordWrapBehavior ConsumeWordWrap(FuzzedDataProvider* fdp) {
+  // TODO(1150235): ELIDE_LONG_WORDS is not supported.
+  switch (fdp->ConsumeIntegralInRange(0, 3)) {
+    case 0:
+      return gfx::IGNORE_LONG_WORDS;
+    case 1:
+      return gfx::TRUNCATE_LONG_WORDS;
+    case 2:
+      return gfx::WRAP_LONG_WORDS;
+    default:
+      return gfx::IGNORE_LONG_WORDS;
+  }
+}
+
+gfx::ElideBehavior ConsumeElideBehavior(FuzzedDataProvider* fdp) {
+  switch (fdp->ConsumeIntegralInRange(0, 7)) {
+    case 0:
+      return gfx::NO_ELIDE;
+    case 1:
+      return gfx::TRUNCATE;
+    case 2:
+      return gfx::ELIDE_HEAD;
+    case 3:
+      return gfx::ELIDE_MIDDLE;
+    case 4:
+      return gfx::ELIDE_TAIL;
+    case 5:
+      return gfx::ELIDE_EMAIL;
+    case 6:
+      return gfx::FADE_TAIL;
+    default:
+      return gfx::NO_ELIDE;
+  }
+}
+
+gfx::LogicalCursorDirection ConsumeLogicalCursorDirection(
+    FuzzedDataProvider* fdp) {
+  switch (fdp->ConsumeIntegralInRange(0, 1)) {
+    case 0:
+      return gfx::CURSOR_BACKWARD;
+    default:
+      return gfx::CURSOR_FORWARD;
+  }
+}
+
+gfx::Font::Weight ConsumeWeight(FuzzedDataProvider* fdp) {
+  if (fdp->ConsumeBool())
+    return gfx::Font::Weight::BOLD;
+  return gfx::Font::Weight::NORMAL;
+}
+
+SkColor ConsumeSkColor(FuzzedDataProvider* fdp) {
+  return static_cast<SkColor>(fdp->ConsumeIntegral<uint32_t>());
+}
+
+gfx::Range ConsumeRange(FuzzedDataProvider* fdp, size_t max) {
+  size_t start = fdp->ConsumeIntegralInRange<size_t>(0, max);
+  size_t end = fdp->ConsumeIntegralInRange<size_t>(start, max);
+  return gfx::Range(start, end);
+}
+
+const int kMaxStringLength = 128;
+
+}  // anonymous namespace
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  static Environment env;
+
+  std::unique_ptr<gfx::RenderText> render_text =
+      gfx::RenderText::CreateRenderText();
+  gfx::Canvas canvas;
+
+  FuzzedDataProvider fdp(data, size);
+  while (fdp.remaining_bytes() != 0) {
+    const RenderTextAPI command = fdp.ConsumeEnum<RenderTextAPI>();
+    switch (command) {
+      case RenderTextAPI::kDraw:
+        render_text->Draw(&canvas);
+        break;
+
+      case RenderTextAPI::kSetText:
+        render_text->SetText(
+            base::UTF8ToUTF16(fdp.ConsumeRandomLengthString(kMaxStringLength)));
+        break;
+
+      case RenderTextAPI::kAppendText:
+        render_text->AppendText(
+            base::UTF8ToUTF16(fdp.ConsumeRandomLengthString(kMaxStringLength)));
+        break;
+
+      case RenderTextAPI::kSetHorizontalAlignment:
+        render_text->SetHorizontalAlignment(ConsumeHorizontalAlignment(&fdp));
+        break;
+
+      case RenderTextAPI::kSetVerticalAlignment:
+        render_text->SetVerticalAlignment(ConsumeVerticalAlignment(&fdp));
+        break;
+
+      case RenderTextAPI::kSetCursorEnabled:
+        render_text->SetCursorEnabled(fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kSetSelectionColor:
+        render_text->set_selection_color(ConsumeSkColor(&fdp));
+        break;
+
+      case RenderTextAPI::kSetSelectionBackgroundFocusedColor:
+        render_text->set_selection_background_focused_color(
+            ConsumeSkColor(&fdp));
+        break;
+
+      case RenderTextAPI::kSetSymmetricSelectionVisualBounds:
+        render_text->set_symmetric_selection_visual_bounds(fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kSetFocused:
+        render_text->set_focused(fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kSetClipToDisplayRect:
+        render_text->set_clip_to_display_rect(fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kSetObscured:
+        render_text->SetObscured(fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kSetObscuredRevealIndex:
+        render_text->SetObscuredRevealIndex(fdp.ConsumeIntegralInRange<size_t>(
+            0, render_text->text().length()));
+        break;
+
+      case RenderTextAPI::kSetMultiline:
+        render_text->SetMultiline(fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kSetMaxLines:
+        render_text->SetMaxLines(fdp.ConsumeIntegralInRange<size_t>(0, 5));
+        break;
+
+      case RenderTextAPI::kSetWordWrapBehavior:
+        render_text->SetWordWrapBehavior(ConsumeWordWrap(&fdp));
+        break;
+
+      case RenderTextAPI::kSetWhitespaceElision:
+        render_text->SetWhitespaceElision(fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kSetSubpixelRenderingSuppressed:
+        render_text->set_subpixel_rendering_suppressed(fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kSetColor:
+        render_text->SetColor(ConsumeSkColor(&fdp));
+        break;
+
+      case RenderTextAPI::kApplyColor:
+        render_text->ApplyColor(
+            ConsumeSkColor(&fdp),
+            ConsumeRange(&fdp, render_text->text().length()));
+        break;
+
+      case RenderTextAPI::kSetStyle:
+        render_text->SetStyle(ConsumeStyle(&fdp), fdp.ConsumeBool());
+        break;
+
+      case RenderTextAPI::kApplyStyle:
+        render_text->ApplyStyle(
+            ConsumeStyle(&fdp), fdp.ConsumeBool(),
+            ConsumeRange(&fdp, render_text->text().length()));
+        break;
+
+      case RenderTextAPI::kSetWeight:
+        render_text->SetWeight(ConsumeWeight(&fdp));
+        break;
+
+      case RenderTextAPI::kApplyWeight:
+        render_text->ApplyWeight(
+            ConsumeWeight(&fdp),
+            ConsumeRange(&fdp, render_text->text().length()));
+        break;
+
+      case RenderTextAPI::kSetDirectionalityMode:
+        render_text->SetDirectionalityMode(ConsumeDirectionalityMode(&fdp));
+        break;
+
+      case RenderTextAPI::kSetElideBehavior:
+        render_text->SetElideBehavior(ConsumeElideBehavior(&fdp));
+        break;
+
+      case RenderTextAPI::kIsGraphemeBoundary:
+        render_text->IsGraphemeBoundary(fdp.ConsumeIntegralInRange<size_t>(
+            0, render_text->text().length()));
+        break;
+
+      case RenderTextAPI::kIndexOfAdjacentGrapheme: {
+        size_t index = render_text->IndexOfAdjacentGrapheme(
+            fdp.ConsumeIntegralInRange<size_t>(0, render_text->text().length()),
+            ConsumeLogicalCursorDirection(&fdp));
+        bool is_grapheme = render_text->IsGraphemeBoundary(index);
+        DCHECK(is_grapheme);
+        break;
+      }
+      case RenderTextAPI::kSetObscuredGlyphSpacing:
+        render_text->SetObscuredGlyphSpacing(
+            fdp.ConsumeIntegralInRange<size_t>(0, 10));
+        break;
+      case RenderTextAPI::kSetDisplayRect:
+        render_text->SetDisplayRect(
+            gfx::Rect(fdp.ConsumeIntegralInRange<int>(-30, 30),
+                      fdp.ConsumeIntegralInRange<int>(-30, 30),
+                      fdp.ConsumeIntegralInRange<int>(0, 200),
+                      fdp.ConsumeIntegralInRange<int>(0, 30)));
+        break;
+      case RenderTextAPI::kGetSubstringBounds:
+        render_text->GetSubstringBounds(
+            ConsumeRange(&fdp, render_text->text().length()));
+        break;
+      case RenderTextAPI::kGetCursorSpan:
+        render_text->GetCursorSpan(
+            ConsumeRange(&fdp, render_text->text().length()));
+        break;
+    }
+  }
+
+  return 0;
+}
diff --git a/ui/gfx/render_text_fuzzer.cc b/ui/gfx/render_text_fuzzer.cc
new file mode 100644
index 0000000..9ce8bc6
--- /dev/null
+++ b/ui/gfx/render_text_fuzzer.cc
@@ -0,0 +1,53 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/at_exit.h"
+#include "base/command_line.h"
+#include "base/i18n/icu_util.h"
+#include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/test/task_environment.h"
+#include "base/test/test_timeouts.h"
+#include "build/build_config.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/render_text.h"
+
+namespace {
+
+#if defined(OS_WIN)
+const char kFontDescription[] = "Segoe UI, 13px";
+#elif defined(OS_ANDROID)
+const char kFontDescription[] = "serif, 13px";
+#else
+const char kFontDescription[] = "sans, 13px";
+#endif
+
+struct Environment {
+  Environment()
+      : task_environment((base::CommandLine::Init(0, nullptr),
+                          TestTimeouts::Initialize(),
+                          base::test::TaskEnvironment::MainThreadType::UI)) {
+    logging::SetMinLogLevel(logging::LOG_FATAL);
+
+    CHECK(base::i18n::InitializeICU());
+    gfx::FontList::SetDefaultFontDescription(kFontDescription);
+  }
+
+  base::AtExitManager at_exit_manager;
+  base::test::TaskEnvironment task_environment;
+};
+
+}  // anonymous namespace
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  static Environment env;
+
+  std::unique_ptr<gfx::RenderText> render_text =
+      gfx::RenderText::CreateRenderText();
+  gfx::Canvas canvas;
+  render_text->SetText(base::UTF8ToUTF16(
+      base::StringPiece(reinterpret_cast<const char*>(data), size)));
+  render_text->Draw(&canvas);
+  return 0;
+}
diff --git a/ui/gfx/render_text_harfbuzz.cc b/ui/gfx/render_text_harfbuzz.cc
new file mode 100644
index 0000000..9e99256
--- /dev/null
+++ b/ui/gfx/render_text_harfbuzz.cc
@@ -0,0 +1,2277 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/render_text_harfbuzz.h"
+
+#include <limits>
+#include <set>
+
+#include "base/command_line.h"
+#include "base/containers/contains.h"
+#include "base/containers/mru_cache.h"
+#include "base/containers/span.h"
+#include "base/feature_list.h"
+#include "base/hash/hash.h"
+#include "base/i18n/base_i18n_switches.h"
+#include "base/i18n/break_iterator.h"
+#include "base/i18n/char_iterator.h"
+#include "base/i18n/rtl.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/no_destructor.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/task/current_thread.h"
+#include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
+#include "third_party/icu/source/common/unicode/ubidi.h"
+#include "third_party/icu/source/common/unicode/uscript.h"
+#include "third_party/icu/source/common/unicode/utf16.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkFontMetrics.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "ui/gfx/bidi_line_iterator.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/decorated_text.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_fallback.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/harfbuzz_font_skia.h"
+#include "ui/gfx/platform_font.h"
+#include "ui/gfx/range/range_f.h"
+#include "ui/gfx/skia_util.h"
+#include "ui/gfx/switches.h"
+#include "ui/gfx/text_utils.h"
+#include "ui/gfx/utf16_indexing.h"
+
+#if defined(OS_APPLE)
+#include "base/mac/foundation_util.h"
+#include "base/mac/mac_util.h"
+#include "third_party/skia/include/ports/SkTypeface_mac.h"
+#endif
+
+#if defined(OS_ANDROID)
+#include "base/android/locale_utils.h"
+#endif  // defined(OS_ANDROID)
+
+#include <hb.h>
+
+namespace gfx {
+
+namespace {
+
+// Text length limit. Longer strings are slow and not fully tested.
+const size_t kMaxTextLength = 10000;
+
+// The maximum number of scripts a Unicode character can belong to. This value
+// is arbitrarily chosen to be a good limit because it is unlikely for a single
+// character to belong to more scripts.
+const size_t kMaxScripts = 32;
+
+// Font fallback mechanism used to Shape runs (see ShapeRuns(...)).
+// These values are persisted to logs. Entries should not be renumbered and
+// numeric values should never be reused.
+enum class ShapeRunFallback {
+  FAILED = 0,
+  NO_FALLBACK = 1,
+  FALLBACK = 2,
+  FALLBACKS = 3,
+  kMaxValue = FALLBACKS
+};
+
+// Log the fallback font mechanism used for shaping to UMA (see ShapeRuns(...)).
+void RecordShapeRunsFallback(ShapeRunFallback fallback) {
+  UMA_HISTOGRAM_ENUMERATION("RenderTextHarfBuzz.ShapeRunsFallback", fallback);
+}
+
+// Returns whether the codepoint has the 'extended pictographic' property.
+bool IsExtendedPictographicCodepoint(UChar32 codepoint) {
+  return u_hasBinaryProperty(codepoint, UCHAR_EXTENDED_PICTOGRAPHIC);
+}
+
+// Returns whether the codepoint has emoji properties.
+bool IsEmojiRelatedCodepoint(UChar32 codepoint) {
+  return u_hasBinaryProperty(codepoint, UCHAR_EMOJI) ||
+         u_hasBinaryProperty(codepoint, UCHAR_EMOJI_PRESENTATION) ||
+         u_hasBinaryProperty(codepoint, UCHAR_REGIONAL_INDICATOR);
+}
+
+// Returns true if |codepoint| is a bracket. This is used to avoid "matching"
+// brackets picking different font fallbacks, thereby appearing mismatched.
+bool IsBracket(UChar32 codepoint) {
+  return u_getIntPropertyValue(codepoint, UCHAR_BIDI_PAIRED_BRACKET_TYPE) !=
+         U_BPT_NONE;
+}
+
+// Writes the script and the script extensions of the Unicode |codepoint|.
+// Returns the number of written scripts.
+size_t GetScriptExtensions(UChar32 codepoint, UScriptCode* scripts) {
+  // Fill |scripts| with the script extensions.
+  UErrorCode icu_error = U_ZERO_ERROR;
+  size_t count =
+      uscript_getScriptExtensions(codepoint, scripts, kMaxScripts, &icu_error);
+  DCHECK_NE(icu_error, U_BUFFER_OVERFLOW_ERROR) << " #ext: " << count;
+  if (U_FAILURE(icu_error))
+    return 0;
+
+  return count;
+}
+
+// Intersects the script extensions set of |codepoint| with |result| and writes
+// to |result|, reading and updating |result_size|. The output |result| will be
+// a subset of the input |result| (thus |result_size| can only be smaller).
+void ScriptSetIntersect(UChar32 codepoint,
+                        UScriptCode* result,
+                        size_t* result_size) {
+  // Each codepoint has a Script property and a Script Extensions (Scx)
+  // property.
+  //
+  // The implicit Script property values 'Common' and 'Inherited' indicate that
+  // a codepoint is widely used in many scripts, rather than being associated
+  // to a specific script.
+  //
+  // However, some codepoints that are assigned a value of 'Common' or
+  // 'Inherited' are not commonly used with all scripts, but rather only with a
+  // limited set of scripts. The Script Extension property is used to specify
+  // the set of script which borrow the codepoint.
+  //
+  // Calls to GetScriptExtensions(...) return the set of scripts where the
+  // codepoints can be used.
+  // (see table 7 from http://www.unicode.org/reports/tr24/tr24-29.html)
+  //
+  //     Script     Script Extensions   ->  Results
+  //  1) Common       {Common}          ->  {Common}
+  //     Inherited    {Inherited}       ->  {Inherited}
+  //  2) Latin        {Latn}            ->  {Latn}
+  //     Inherited    {Latn}            ->  {Latn}
+  //  3) Common       {Hira Kana}       ->  {Hira Kana}
+  //     Inherited    {Hira Kana}       ->  {Hira Kana}
+  //  4) Devanagari   {Deva Dogr Kthi Mahj}  ->  {Deva Dogr Kthi Mahj}
+  //     Myanmar      {Cakm Mymr Tale}  ->  {Cakm Mymr Tale}
+  //
+  // For most of the codepoints, the script extensions set contains only one
+  // element. For CJK codepoints, it's common to see 3-4 scripts. For really
+  // rare cases, the set can go above 20 scripts.
+  UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE };
+  size_t count = GetScriptExtensions(codepoint, scripts);
+
+  // Implicit script 'inherited' is inheriting scripts from preceding codepoint.
+  if (count == 1 && scripts[0] == USCRIPT_INHERITED)
+    return;
+
+  // Perform the intersection of both script set.
+  auto scripts_span = base::span<UScriptCode>(scripts, count);
+  DCHECK(!base::Contains(scripts_span, USCRIPT_INHERITED));
+  auto results_span = base::span<UScriptCode>(result, *result_size);
+
+  size_t out_size = 0;
+  for (UScriptCode current : results_span) {
+    if (base::Contains(scripts_span, current))
+      result[out_size++] = current;
+  }
+
+  *result_size = out_size;
+}
+
+struct GraphemeProperties {
+  bool has_control = false;
+  bool has_bracket = false;
+  bool has_pictographic = false;
+  bool has_emoji = false;
+  UBlockCode block = UBLOCK_NO_BLOCK;
+};
+
+// Returns the properties for the codepoints part of the given text.
+GraphemeProperties RetrieveGraphemeProperties(const base::StringPiece16& text,
+                                              bool retrieve_block) {
+  GraphemeProperties properties;
+  bool first_char = true;
+  for (base::i18n::UTF16CharIterator iter(text); !iter.end(); iter.Advance()) {
+    const UChar32 codepoint = iter.get();
+
+    if (first_char) {
+      first_char = false;
+      if (retrieve_block)
+        properties.block = ublock_getCode(codepoint);
+    }
+
+    if (codepoint == '\n' || codepoint == '\r' || codepoint == ' ')
+      properties.has_control = true;
+    if (IsBracket(codepoint))
+      properties.has_bracket = true;
+    if (IsExtendedPictographicCodepoint(codepoint))
+      properties.has_pictographic = true;
+    if (IsEmojiRelatedCodepoint(codepoint))
+      properties.has_emoji = true;
+  }
+
+  return properties;
+}
+
+// Return whether the grapheme properties are compatible and the grapheme can
+// be merge together in the same grapheme cluster.
+bool AreGraphemePropertiesCompatible(const GraphemeProperties& first,
+                                     const GraphemeProperties& second) {
+  // There are 5 constrains to grapheme to be compatible.
+  // 1) The newline character and control characters should form a single run so
+  //  that the line breaker can handle them easily.
+  // 2) Parentheses should be put in a separate run to avoid using different
+  // fonts while rendering matching parentheses (see http://crbug.com/396776).
+  // 3) Pictographic graphemes should be put in separate run to avoid altering
+  // fonts selection while rendering adjacent text (see
+  // http://crbug.com/278913).
+  // 4) Emoji graphemes should be put in separate run (see
+  // http://crbug.com/530021 and http://crbug.com/533721).
+  // 5) The 'COMMON' script needs to be split by unicode block. Codepoints are
+  // spread across blocks and supported with different fonts.
+  return !first.has_control && !second.has_control &&
+         first.has_bracket == second.has_bracket &&
+         first.has_pictographic == second.has_pictographic &&
+         first.has_emoji == second.has_emoji && first.block == second.block;
+}
+
+// Returns the end of the current grapheme cluster. This function is finding the
+// breaking point where grapheme properties are no longer compatible
+// (see: UNICODE TEXT SEGMENTATION (http://unicode.org/reports/tr29/).
+// Breaks between |run_start| and |run_end| and force break after the grapheme
+// starting at |run_break|.
+size_t FindRunBreakingCharacter(const std::u16string& text,
+                                UScriptCode script,
+                                size_t run_start,
+                                size_t run_break,
+                                size_t run_end) {
+  const size_t run_length = run_end - run_start;
+  const base::StringPiece16 run_text(text.c_str() + run_start, run_length);
+  const bool is_common_script = (script == USCRIPT_COMMON);
+
+  DCHECK(!run_text.empty());
+
+  // Create an iterator to split the text in graphemes.
+  base::i18n::BreakIterator grapheme_iterator(
+      run_text, base::i18n::BreakIterator::BREAK_CHARACTER);
+  if (!grapheme_iterator.Init() || !grapheme_iterator.Advance()) {
+    // In case of error, isolate the first character in a separate run.
+    NOTREACHED();
+    return run_start + 1;
+  }
+
+  // Retrieve the first grapheme and its codepoint properties.
+  const base::StringPiece16 first_grapheme_text =
+      grapheme_iterator.GetStringPiece();
+  const GraphemeProperties first_grapheme_properties =
+      RetrieveGraphemeProperties(first_grapheme_text, is_common_script);
+
+  // Append subsequent graphemes in this grapheme cluster if they are
+  // compatible, otherwise break the current run.
+  while (grapheme_iterator.Advance()) {
+    const base::StringPiece16 current_grapheme_text =
+        grapheme_iterator.GetStringPiece();
+    const GraphemeProperties current_grapheme_properties =
+        RetrieveGraphemeProperties(current_grapheme_text, is_common_script);
+
+    const size_t current_breaking_position =
+        run_start + grapheme_iterator.prev();
+    if (!AreGraphemePropertiesCompatible(first_grapheme_properties,
+                                         current_grapheme_properties)) {
+      return current_breaking_position;
+    }
+
+    // Break if the beginning of this grapheme is after |run_break|.
+    if (run_start + grapheme_iterator.prev() >= run_break) {
+      DCHECK_LE(current_breaking_position, run_end);
+      return current_breaking_position;
+    }
+  }
+
+  // Do not break this run, returns end of the text.
+  return run_end;
+}
+
+// Find the longest sequence of characters from 0 and up to |length| that have
+// at least one common UScriptCode value. Writes the common script value to
+// |script| and returns the length of the sequence. Takes the characters' script
+// extensions into account. http://www.unicode.org/reports/tr24/#ScriptX
+//
+// Consider 3 characters with the script values {Kana}, {Hira, Kana}, {Kana}.
+// Without script extensions only the first script in each set would be taken
+// into account, resulting in 3 runs where 1 would be enough.
+size_t ScriptInterval(const std::u16string& text,
+                      size_t start,
+                      size_t length,
+                      UScriptCode* script) {
+  DCHECK_GT(length, 0U);
+
+  UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE };
+
+  base::i18n::UTF16CharIterator char_iterator(
+      base::StringPiece16(text.c_str() + start, length));
+  size_t scripts_size = GetScriptExtensions(char_iterator.get(), scripts);
+  *script = scripts[0];
+
+  while (char_iterator.Advance()) {
+    ScriptSetIntersect(char_iterator.get(), scripts, &scripts_size);
+    if (scripts_size == 0U)
+      return char_iterator.array_pos();
+    *script = scripts[0];
+  }
+
+  return length;
+}
+
+// A port of hb_icu_script_to_script because harfbuzz on CrOS is built without
+// hb-icu. See http://crbug.com/356929
+inline hb_script_t ICUScriptToHBScript(UScriptCode script) {
+  if (script == USCRIPT_INVALID_CODE)
+    return HB_SCRIPT_INVALID;
+  return hb_script_from_string(uscript_getShortName(script), -1);
+}
+
+bool FontWasAlreadyTried(sk_sp<SkTypeface> typeface,
+                         std::set<SkFontID>* fallback_fonts) {
+  return fallback_fonts->count(typeface->uniqueID()) != 0;
+}
+
+void MarkFontAsTried(sk_sp<SkTypeface> typeface,
+                     std::set<SkFontID>* fallback_fonts) {
+  fallback_fonts->insert(typeface->uniqueID());
+}
+
+// Whether |segment| corresponds to the newline character.
+bool IsNewlineSegment(const std::u16string& text,
+                      const internal::LineSegment& segment) {
+  const size_t offset = segment.char_range.start();
+  const size_t length = segment.char_range.length();
+  DCHECK_LT(segment.char_range.start() + length - 1, text.length());
+  return (length == 1 && (text[offset] == '\r' || text[offset] == '\n')) ||
+         (length == 2 && text[offset] == '\r' && text[offset + 1] == '\n');
+}
+
+// Returns the line index considering the newline character. Line index is
+// incremented if the caret is right after the newline character, i.e, the
+// cursor affinity is |CURSOR_BACKWARD| while containing the newline character.
+size_t LineIndexForNewline(const size_t line_index,
+                           const std::u16string& text,
+                           const internal::LineSegment& segment,
+                           const SelectionModel& caret) {
+  bool at_newline = IsNewlineSegment(text, segment) &&
+                    caret.caret_affinity() == CURSOR_BACKWARD;
+  return line_index + (at_newline ? 1 : 0);
+}
+
+// Helper template function for |TextRunHarfBuzz::GetClusterAt()|. |Iterator|
+// can be a forward or reverse iterator type depending on the text direction.
+// Returns true on success, or false if an error is encountered.
+template <class Iterator>
+bool GetClusterAtImpl(size_t pos,
+                      Range range,
+                      Iterator elements_begin,
+                      Iterator elements_end,
+                      bool reversed,
+                      Range* chars,
+                      Range* glyphs) {
+  Iterator element = std::upper_bound(elements_begin, elements_end, pos);
+  if (element == elements_begin) {
+    *chars = range;
+    *glyphs = Range();
+    return false;
+  }
+
+  chars->set_end(element == elements_end ? range.end() : *element);
+  glyphs->set_end(reversed ? elements_end - element : element - elements_begin);
+  while (--element != elements_begin && *element == *(element - 1));
+  chars->set_start(*element);
+  glyphs->set_start(
+      reversed ? elements_end - element : element - elements_begin);
+  if (reversed)
+    *glyphs = Range(glyphs->end(), glyphs->start());
+
+  DCHECK(!chars->is_reversed());
+  DCHECK(!chars->is_empty());
+  DCHECK(!glyphs->is_reversed());
+  DCHECK(!glyphs->is_empty());
+  return true;
+}
+
+// Internal class to generate Line structures. If |multiline| is true, the text
+// is broken into lines at |words| boundaries such that each line is no longer
+// than |max_width|. If |multiline| is false, only outputs a single Line from
+// the given runs. |min_baseline| and |min_height| are the minimum baseline and
+// height for each line.
+// TODO(ckocagil): Expose the interface of this class in the header and test
+//                 this class directly.
+class HarfBuzzLineBreaker {
+ public:
+  HarfBuzzLineBreaker(size_t max_width,
+                      int min_baseline,
+                      float min_height,
+                      float glyph_height_for_test,
+                      WordWrapBehavior word_wrap_behavior,
+                      const std::u16string& text,
+                      const BreakList<size_t>* words,
+                      const internal::TextRunList& run_list)
+      : max_width_((max_width == 0) ? SK_ScalarMax : SkIntToScalar(max_width)),
+        min_baseline_(min_baseline),
+        min_height_(min_height),
+        glyph_height_for_test_(glyph_height_for_test),
+        word_wrap_behavior_(word_wrap_behavior),
+        text_(text),
+        words_(words),
+        run_list_(run_list),
+        max_descent_(0),
+        max_ascent_(0),
+        text_x_(0),
+        available_width_(max_width_) {
+    AdvanceLine();
+  }
+
+  HarfBuzzLineBreaker(const HarfBuzzLineBreaker&) = delete;
+  HarfBuzzLineBreaker& operator=(const HarfBuzzLineBreaker&) = delete;
+
+  // Constructs a single line for |text_| using |run_list_|.
+  void ConstructSingleLine() {
+    for (size_t i = 0; i < run_list_.size(); i++) {
+      const internal::TextRunHarfBuzz& run = *(run_list_.runs()[i]);
+      internal::LineSegment segment;
+      segment.run = i;
+      segment.char_range = run.range;
+      segment.x_range = RangeF(SkScalarToFloat(text_x_),
+                               SkScalarToFloat(text_x_) + run.shape.width);
+      AddLineSegment(segment, false);
+    }
+  }
+
+  // Constructs multiple lines for |text_| based on words iteration approach.
+  void ConstructMultiLines() {
+    DCHECK(words_);
+    for (auto iter = words_->breaks().begin(); iter != words_->breaks().end();
+         iter++) {
+      const Range word_range = words_->GetRange(iter);
+      std::vector<internal::LineSegment> word_segments;
+      SkScalar word_width = GetWordWidth(word_range, &word_segments);
+
+      // If the last word is '\n', we should advance a new line after adding
+      // the word to the current line.
+      bool new_line = false;
+      if (!word_segments.empty() &&
+          IsNewlineSegment(text_, word_segments.back())) {
+        new_line = true;
+
+        // Subtract the width of newline segments, they are not drawn.
+        if (word_segments.size() != 1u || available_width_ != max_width_)
+          word_width -= word_segments.back().width();
+      }
+
+      // If the word is not the first word in the line and it can't fit into
+      // the current line, advance a new line.
+      if (word_width > available_width_ && available_width_ != max_width_)
+        AdvanceLine();
+      if (!word_segments.empty())
+        AddWordToLine(word_segments);
+      if (new_line)
+        AdvanceLine();
+    }
+  }
+
+  // Finishes line breaking and outputs the results. Can be called at most once.
+  void FinalizeLines(std::vector<internal::Line>* lines, SizeF* size) {
+    DCHECK(!lines_.empty());
+    // If the last character of the text is a new line character, then the last
+    // line is any empty string, which contains no segments. This means that the
+    // display_text_index will not have been set in AdvanceLine. So here, set
+    // display_text_index to the text length, which is the true text index of
+    // the final line.
+    internal::Line* line = &lines_.back();
+    if (line->display_text_index == 0)
+      line->display_text_index = text_.size();
+    // Add an empty line to finish the line size calculation and remove it.
+    AdvanceLine();
+    lines_.pop_back();
+    *size = total_size_;
+    lines->swap(lines_);
+  }
+
+ private:
+  // A (line index, segment index) pair that specifies a segment in |lines_|.
+  typedef std::pair<size_t, size_t> SegmentHandle;
+
+  internal::LineSegment* SegmentFromHandle(const SegmentHandle& handle) {
+    return &lines_[handle.first].segments[handle.second];
+  }
+
+  // Finishes the size calculations of the last Line in |lines_|. Adds a new
+  // Line to the back of |lines_|.
+  void AdvanceLine() {
+    if (!lines_.empty()) {
+      internal::Line* line = &lines_.back();
+      // Compute the line start while the line segments are in the logical order
+      // so that the start of the line is the start of the char range,
+      // regardless of i18n.
+      if (!line->segments.empty())
+        line->display_text_index = line->segments[0].char_range.start();
+      std::sort(line->segments.begin(), line->segments.end(),
+                [this](const internal::LineSegment& s1,
+                       const internal::LineSegment& s2) -> bool {
+                  return run_list_.logical_to_visual(s1.run) <
+                         run_list_.logical_to_visual(s2.run);
+                });
+
+      line->size.set_height(
+          glyph_height_for_test_
+              ? glyph_height_for_test_
+              : std::max(min_height_, max_descent_ + max_ascent_));
+
+      line->baseline = std::max(min_baseline_, SkScalarRoundToInt(max_ascent_));
+      line->preceding_heights = base::ClampCeil(total_size_.height());
+      // Subtract newline segment's width from |total_size_| because it's not
+      // drawn.
+      float line_width = line->size.width();
+      if (!line->segments.empty() &&
+          IsNewlineSegment(text_, line->segments.back())) {
+        line_width -= line->segments.back().width();
+      }
+      if (line->segments.size() > 1 &&
+          IsNewlineSegment(text_, line->segments.front())) {
+        line_width -= line->segments.front().width();
+      }
+      total_size_.set_height(total_size_.height() + line->size.height());
+      total_size_.set_width(std::max(total_size_.width(), line_width));
+    }
+    max_descent_ = 0;
+    max_ascent_ = 0;
+    available_width_ = max_width_;
+    lines_.push_back(internal::Line());
+  }
+
+  // Adds word to the current line. A word may contain multiple segments. If the
+  // word is the first word in line and its width exceeds |available_width_|,
+  // ignore/truncate/wrap it according to |word_wrap_behavior_|.
+  void AddWordToLine(const std::vector<internal::LineSegment>& word_segments) {
+    DCHECK(!lines_.empty());
+    DCHECK(!word_segments.empty());
+
+    bool has_truncated = false;
+    for (const internal::LineSegment& segment : word_segments) {
+      if (has_truncated)
+        break;
+
+      if (IsNewlineSegment(text_, segment) ||
+          segment.width() <= available_width_ ||
+          word_wrap_behavior_ == IGNORE_LONG_WORDS) {
+        AddLineSegment(segment, true);
+      } else {
+        DCHECK(word_wrap_behavior_ == TRUNCATE_LONG_WORDS ||
+               word_wrap_behavior_ == WRAP_LONG_WORDS);
+        has_truncated = (word_wrap_behavior_ == TRUNCATE_LONG_WORDS);
+
+        const internal::TextRunHarfBuzz& run = *(run_list_.runs()[segment.run]);
+        internal::LineSegment remaining_segment = segment;
+        while (!remaining_segment.char_range.is_empty()) {
+          size_t cutoff_pos = GetCutoffPos(remaining_segment);
+          SkScalar width = run.GetGlyphWidthForCharRange(
+              Range(remaining_segment.char_range.start(), cutoff_pos));
+          if (width > 0) {
+            internal::LineSegment cut_segment;
+            cut_segment.run = remaining_segment.run;
+            cut_segment.char_range =
+                Range(remaining_segment.char_range.start(), cutoff_pos);
+            cut_segment.x_range = RangeF(SkScalarToFloat(text_x_),
+                                         SkScalarToFloat(text_x_ + width));
+            AddLineSegment(cut_segment, true);
+            // Updates old segment range.
+            remaining_segment.char_range.set_start(cutoff_pos);
+            remaining_segment.x_range.set_start(SkScalarToFloat(text_x_));
+          }
+          if (has_truncated)
+            break;
+          if (!remaining_segment.char_range.is_empty())
+            AdvanceLine();
+        }
+      }
+    }
+  }
+
+  // Add a line segment to the current line. Note that, in order to keep the
+  // visual order correct for ltr and rtl language, we need to merge segments
+  // that belong to the same run.
+  void AddLineSegment(const internal::LineSegment& segment, bool multiline) {
+    DCHECK(!lines_.empty());
+    internal::Line* line = &lines_.back();
+    const internal::TextRunHarfBuzz& run = *(run_list_.runs()[segment.run]);
+    if (!line->segments.empty()) {
+      internal::LineSegment& last_segment = line->segments.back();
+      // Merge segments that belong to the same run.
+      if (last_segment.run == segment.run) {
+        DCHECK_EQ(last_segment.char_range.end(), segment.char_range.start());
+        // Check there is less than a pixel between one run and the next.
+        DCHECK_LE(
+            std::abs(last_segment.x_range.end() - segment.x_range.start()),
+            1.0f);
+        last_segment.char_range.set_end(segment.char_range.end());
+        last_segment.x_range.set_end(SkScalarToFloat(text_x_) +
+                                     segment.width());
+        if (run.font_params.is_rtl &&
+            last_segment.char_range.end() == run.range.end())
+          UpdateRTLSegmentRanges();
+        line->size.set_width(line->size.width() + segment.width());
+        text_x_ += segment.width();
+        available_width_ -= segment.width();
+        return;
+      }
+    }
+    line->segments.push_back(segment);
+    line->size.set_width(line->size.width() + segment.width());
+
+    // Newline characters are not drawn for multi-line, ignore their metrics.
+    if (!multiline || !IsNewlineSegment(text_, segment)) {
+      SkFont font(run.font_params.skia_face, run.font_params.font_size);
+      font.setEdging(run.font_params.render_params.antialiasing
+                         ? SkFont::Edging::kAntiAlias
+                         : SkFont::Edging::kAlias);
+      SkFontMetrics metrics;
+      font.getMetrics(&metrics);
+
+      // max_descent_ is y-down, fDescent is y-down, baseline_offset is y-down
+      max_descent_ = std::max(
+          max_descent_, metrics.fDescent + run.font_params.baseline_offset);
+      // max_ascent_ is y-up, fAscent is y-down, baseline_offset is y-down
+      max_ascent_ = std::max(
+          max_ascent_, -(metrics.fAscent + run.font_params.baseline_offset));
+    }
+
+    if (run.font_params.is_rtl) {
+      rtl_segments_.push_back(
+          SegmentHandle(lines_.size() - 1, line->segments.size() - 1));
+      // If this is the last segment of an RTL run, reprocess the text-space x
+      // ranges of all segments from the run.
+      if (segment.char_range.end() == run.range.end())
+        UpdateRTLSegmentRanges();
+    }
+    text_x_ += segment.width();
+    available_width_ -= segment.width();
+  }
+
+  // Finds the end position |end_pos| in |segment| where the preceding width is
+  // no larger than |available_width_|.
+  size_t GetCutoffPos(const internal::LineSegment& segment) const {
+    DCHECK(!segment.char_range.is_empty());
+    const internal::TextRunHarfBuzz& run =
+        *(run_list_.runs()[segment.run]).get();
+    size_t end_pos = segment.char_range.start();
+    SkScalar width = 0;
+    while (end_pos < segment.char_range.end()) {
+      const SkScalar char_width =
+          run.GetGlyphWidthForCharRange(Range(end_pos, end_pos + 1));
+      if (width + char_width > available_width_)
+        break;
+      width += char_width;
+      end_pos++;
+    }
+
+    const size_t valid_end_pos = std::max(
+        segment.char_range.start(),
+        static_cast<uint32_t>(FindValidBoundaryBefore(text_, end_pos)));
+    if (end_pos != valid_end_pos) {
+      end_pos = valid_end_pos;
+      width = run.GetGlyphWidthForCharRange(
+          Range(segment.char_range.start(), end_pos));
+    }
+
+    // |max_width_| might be smaller than a single character. In this case we
+    // need to put at least one character in the line. Note that, we should
+    // not separate surrogate pair or combining characters.
+    // See RenderTextHarfBuzzTest.Multiline_MinWidth for an example.
+    if (width == 0 && available_width_ == max_width_) {
+      end_pos = std::min(
+          segment.char_range.end(),
+          static_cast<uint32_t>(FindValidBoundaryAfter(text_, end_pos + 1)));
+    }
+
+    return end_pos;
+  }
+
+  // Gets the glyph width for |word_range|, and splits the |word| into different
+  // segments based on its runs.
+  SkScalar GetWordWidth(const Range& word_range,
+                        std::vector<internal::LineSegment>* segments) const {
+    DCHECK(words_);
+    if (word_range.is_empty() || segments == nullptr)
+      return 0;
+    size_t run_start_index = run_list_.GetRunIndexAt(word_range.start());
+    size_t run_end_index = run_list_.GetRunIndexAt(word_range.end() - 1);
+    SkScalar width = 0;
+    for (size_t i = run_start_index; i <= run_end_index; i++) {
+      const internal::TextRunHarfBuzz& run = *(run_list_.runs()[i]);
+      const Range char_range = run.range.Intersect(word_range);
+      DCHECK(!char_range.is_empty());
+      const SkScalar char_width = run.GetGlyphWidthForCharRange(char_range);
+      width += char_width;
+
+      internal::LineSegment segment;
+      segment.run = i;
+      segment.char_range = char_range;
+      segment.x_range = RangeF(SkScalarToFloat(text_x_ + width - char_width),
+                               SkScalarToFloat(text_x_ + width));
+      segments->push_back(segment);
+    }
+    return width;
+  }
+
+  // RTL runs are broken in logical order but displayed in visual order. To find
+  // the text-space coordinate (where it would fall in a single-line text)
+  // |x_range| of RTL segments, segment widths are applied in reverse order.
+  // e.g. {[5, 10], [10, 40]} will become {[35, 40], [5, 35]}.
+  void UpdateRTLSegmentRanges() {
+    if (rtl_segments_.empty())
+      return;
+    float x = SegmentFromHandle(rtl_segments_[0])->x_range.start();
+    for (size_t i = rtl_segments_.size(); i > 0; --i) {
+      internal::LineSegment* segment = SegmentFromHandle(rtl_segments_[i - 1]);
+      const float segment_width = segment->width();
+      segment->x_range = RangeF(x, x + segment_width);
+      x += segment_width;
+    }
+    rtl_segments_.clear();
+  }
+
+  const SkScalar max_width_;
+  const int min_baseline_;
+  const float min_height_;
+  const float glyph_height_for_test_;
+  const WordWrapBehavior word_wrap_behavior_;
+  const std::u16string& text_;
+  const BreakList<size_t>* const words_;
+  const internal::TextRunList& run_list_;
+
+  // Stores the resulting lines.
+  std::vector<internal::Line> lines_;
+
+  float max_descent_;
+  float max_ascent_;
+
+  // Text space x coordinates of the next segment to be added.
+  SkScalar text_x_;
+  // Stores available width in the current line.
+  SkScalar available_width_;
+
+  // Size of the multiline text, not including the currently processed line.
+  SizeF total_size_;
+
+  // The current RTL run segments, to be applied by |UpdateRTLSegmentRanges()|.
+  std::vector<SegmentHandle> rtl_segments_;
+};
+
+// Applies a forced text rendering direction if specified by a command-line
+// switch.
+void ApplyForcedDirection(UBiDiLevel* level) {
+  static bool has_switch = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kForceTextDirection);
+  if (!has_switch)
+    return;
+
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kForceTextDirection)) {
+    std::string force_flag =
+        command_line->GetSwitchValueASCII(switches::kForceTextDirection);
+
+    if (force_flag == switches::kForceDirectionRTL)
+      *level = UBIDI_RTL;
+    if (force_flag == switches::kForceDirectionLTR)
+      *level = UBIDI_LTR;
+  }
+}
+
+internal::TextRunHarfBuzz::FontParams CreateFontParams(
+    const Font& primary_font,
+    UBiDiLevel bidi_level,
+    UScriptCode script,
+    const internal::StyleIterator& style) {
+  internal::TextRunHarfBuzz::FontParams font_params(primary_font);
+  font_params.italic = style.style(TEXT_STYLE_ITALIC);
+  font_params.baseline_type = style.baseline();
+  font_params.font_size = style.font_size_override();
+  font_params.strike = style.style(TEXT_STYLE_STRIKE);
+  font_params.underline = style.style(TEXT_STYLE_UNDERLINE);
+  font_params.heavy_underline = style.style(TEXT_STYLE_HEAVY_UNDERLINE);
+  font_params.weight = style.weight();
+  font_params.level = bidi_level;
+  font_params.script = script;
+  // Odd BiDi embedding levels correspond to RTL runs.
+  font_params.is_rtl = (font_params.level % 2) == 1;
+  return font_params;
+}
+
+}  // namespace
+
+namespace internal {
+
+sk_sp<SkTypeface> CreateSkiaTypeface(const Font& font,
+                                     bool italic,
+                                     Font::Weight weight) {
+#if defined(OS_APPLE)
+  const Font::FontStyle style = italic ? Font::ITALIC : Font::NORMAL;
+  Font font_with_style = font.Derive(0, style, weight);
+  if (!font_with_style.GetNativeFont())
+    return nullptr;
+
+  return SkMakeTypefaceFromCTFont(
+      base::mac::NSToCFCast(font_with_style.GetNativeFont()));
+#else
+  SkFontStyle skia_style(
+      static_cast<int>(weight), SkFontStyle::kNormal_Width,
+      italic ? SkFontStyle::kItalic_Slant : SkFontStyle::kUpright_Slant);
+  return sk_sp<SkTypeface>(SkTypeface::MakeFromName(
+      font.GetFontName().c_str(), skia_style));
+#endif
+}
+
+TextRunHarfBuzz::FontParams::FontParams(const Font& template_font)
+    : font(template_font) {}
+TextRunHarfBuzz::FontParams::~FontParams() = default;
+TextRunHarfBuzz::FontParams::FontParams(
+    const TextRunHarfBuzz::FontParams& other) = default;
+TextRunHarfBuzz::FontParams& TextRunHarfBuzz::FontParams::operator=(
+    const TextRunHarfBuzz::FontParams& other) = default;
+
+bool TextRunHarfBuzz::FontParams::operator==(const FontParams& other) const {
+  // Empirically, |script| and |weight| are the highest entropy members.
+  return script == other.script && weight == other.weight &&
+         skia_face == other.skia_face && render_params == other.render_params &&
+         font_size == other.font_size &&
+         baseline_offset == other.baseline_offset &&
+         baseline_type == other.baseline_type && italic == other.italic &&
+         strike == other.strike && underline == other.underline &&
+         heavy_underline == other.heavy_underline && is_rtl == other.is_rtl &&
+         level == other.level;
+}
+
+void TextRunHarfBuzz::FontParams::
+    ComputeRenderParamsFontSizeAndBaselineOffset() {
+  render_params = font.GetFontRenderParams();
+  if (font_size == 0)
+    font_size = font.GetFontSize();
+  baseline_offset = 0;
+  if (baseline_type != NORMAL_BASELINE) {
+    // Calculate a slightly smaller font. The ratio here is somewhat arbitrary.
+    // Proportions from 5/9 to 5/7 all look pretty good.
+    const float ratio = 5.0f / 9.0f;
+    font_size = base::ClampRound(font.GetFontSize() * ratio);
+    switch (baseline_type) {
+      case SUPERSCRIPT:
+        baseline_offset = font.GetCapHeight() - font.GetHeight();
+        break;
+      case SUPERIOR:
+        baseline_offset =
+            base::ClampRound(font.GetCapHeight() * ratio) - font.GetCapHeight();
+        break;
+      case SUBSCRIPT:
+        baseline_offset = font.GetHeight() - font.GetBaseline();
+        break;
+      case INFERIOR:  // Fall through.
+      default:
+        break;
+    }
+  }
+}
+
+size_t TextRunHarfBuzz::FontParams::Hash::operator()(
+    const FontParams& key) const {
+  // In practice, |font|, |skia_face|, |render_params|, and |baseline_offset|
+  // have not yet been set when this is called.
+  return static_cast<size_t>(key.italic) << 0 ^
+         static_cast<size_t>(key.strike) << 1 ^
+         static_cast<size_t>(key.underline) << 2 ^
+         static_cast<size_t>(key.heavy_underline) << 3 ^
+         static_cast<size_t>(key.is_rtl) << 4 ^
+         static_cast<size_t>(key.weight) << 8 ^
+         static_cast<size_t>(key.font_size) << 12 ^
+         static_cast<size_t>(key.baseline_type) << 16 ^
+         static_cast<size_t>(key.level) << 20 ^
+         static_cast<size_t>(key.script) << 24;
+}
+
+bool TextRunHarfBuzz::FontParams::SetRenderParamsRematchFont(
+    const Font& new_font,
+    const FontRenderParams& new_render_params) {
+  // This takes the font family name from new_font, and calls
+  // SkTypeface::makeFromName() with that family name and the style information
+  // internal to this text run. So it triggers a new font match and looks for
+  // adjacent fonts in the family. This works for styling, e.g. styling a run in
+  // bold, italic or underline, but breaks font fallback in certain scenarios,
+  // as the fallback font may be of a different weight and style than the run's
+  // own, so this can lead to a failure of instantiating the correct fallback
+  // font.
+  sk_sp<SkTypeface> new_skia_face(
+      internal::CreateSkiaTypeface(new_font, italic, weight));
+  if (!new_skia_face)
+    return false;
+
+  skia_face = new_skia_face;
+  font = new_font;
+  render_params = new_render_params;
+  return true;
+}
+
+bool TextRunHarfBuzz::FontParams::SetRenderParamsOverrideSkiaFaceFromFont(
+    const Font& fallback_font,
+    const FontRenderParams& new_render_params) {
+  PlatformFont* platform_font = fallback_font.platform_font();
+  sk_sp<SkTypeface> new_skia_face = platform_font->GetNativeSkTypeface();
+
+  // If pass-through of the Skia native handle fails for PlatformFonts other
+  // than PlatformFontSkia, perform rematching.
+  if (!new_skia_face)
+    return SetRenderParamsRematchFont(fallback_font, new_render_params);
+
+  skia_face = new_skia_face;
+  font = fallback_font;
+  render_params = new_render_params;
+  return true;
+}
+
+TextRunHarfBuzz::ShapeOutput::ShapeOutput() = default;
+TextRunHarfBuzz::ShapeOutput::~ShapeOutput() = default;
+TextRunHarfBuzz::ShapeOutput::ShapeOutput(
+    const TextRunHarfBuzz::ShapeOutput& other) = default;
+TextRunHarfBuzz::ShapeOutput& TextRunHarfBuzz::ShapeOutput::operator=(
+    const TextRunHarfBuzz::ShapeOutput& other) = default;
+TextRunHarfBuzz::ShapeOutput::ShapeOutput(
+    TextRunHarfBuzz::ShapeOutput&& other) = default;
+TextRunHarfBuzz::ShapeOutput& TextRunHarfBuzz::ShapeOutput::operator=(
+    TextRunHarfBuzz::ShapeOutput&& other) = default;
+
+TextRunHarfBuzz::TextRunHarfBuzz(const Font& template_font)
+    : font_params(template_font) {}
+
+TextRunHarfBuzz::~TextRunHarfBuzz() {}
+
+Range TextRunHarfBuzz::CharRangeToGlyphRange(const Range& char_range) const {
+  DCHECK(range.Contains(char_range));
+  DCHECK(!char_range.is_reversed());
+  DCHECK(!char_range.is_empty());
+
+  Range start_glyphs;
+  Range end_glyphs;
+  Range temp_range;
+  GetClusterAt(char_range.start(), &temp_range, &start_glyphs);
+  GetClusterAt(char_range.end() - 1, &temp_range, &end_glyphs);
+
+  return font_params.is_rtl ? Range(end_glyphs.start(), start_glyphs.end())
+                            : Range(start_glyphs.start(), end_glyphs.end());
+}
+
+size_t TextRunHarfBuzz::CountMissingGlyphs() const {
+  return shape.missing_glyph_count;
+}
+
+void TextRunHarfBuzz::GetClusterAt(size_t pos,
+                                   Range* chars,
+                                   Range* glyphs) const {
+  DCHECK(chars);
+  DCHECK(glyphs);
+
+  bool success = true;
+  if (shape.glyph_count == 0 || !range.Contains(Range(pos, pos + 1))) {
+    *chars = range;
+    *glyphs = Range();
+    success = false;
+  }
+
+  if (font_params.is_rtl) {
+    success &=
+        GetClusterAtImpl(pos, range, shape.glyph_to_char.rbegin(),
+                         shape.glyph_to_char.rend(), true, chars, glyphs);
+  } else {
+    success &=
+        GetClusterAtImpl(pos, range, shape.glyph_to_char.begin(),
+                         shape.glyph_to_char.end(), false, chars, glyphs);
+  }
+
+  if (!success) {
+    std::string glyph_to_char_string;
+    for (size_t i = 0; i < shape.glyph_count && i < shape.glyph_to_char.size();
+         ++i) {
+      glyph_to_char_string += base::NumberToString(i) + "->" +
+                              base::NumberToString(shape.glyph_to_char[i]) +
+                              ", ";
+    }
+    LOG(ERROR) << " TextRunHarfBuzz error, please report at crbug.com/724880:"
+               << " range: " << range.ToString()
+               << ", rtl: " << font_params.is_rtl << ","
+               << " level: '" << font_params.level
+               << "', script: " << font_params.script << ","
+               << " font: '" << font_params.font.GetActualFontName() << "',"
+               << " glyph_count: " << shape.glyph_count << ", pos: " << pos
+               << ","
+               << " glyph_to_char: " << glyph_to_char_string;
+  }
+}
+
+RangeF TextRunHarfBuzz::GetGraphemeBounds(RenderTextHarfBuzz* render_text,
+                                          size_t text_index) const {
+  DCHECK_LT(text_index, range.end());
+  if (shape.glyph_count == 0)
+    return RangeF(preceding_run_widths, preceding_run_widths + shape.width);
+
+  Range chars;
+  Range glyphs;
+  GetClusterAt(text_index, &chars, &glyphs);
+  const float cluster_begin_x = shape.positions[glyphs.start()].x();
+  const float cluster_end_x = glyphs.end() < shape.glyph_count
+                                  ? shape.positions[glyphs.end()].x()
+                                  : SkFloatToScalar(shape.width);
+  DCHECK_LE(cluster_begin_x, cluster_end_x);
+
+  // A cluster consists of a number of code points and corresponds to a number
+  // of glyphs that should be drawn together. A cluster can contain multiple
+  // graphemes. In order to place the cursor at a grapheme boundary inside the
+  // cluster, we simply divide the cluster width by the number of graphemes.
+  ptrdiff_t code_point_count = UTF16IndexToOffset(render_text->GetDisplayText(),
+                                                  chars.start(), chars.end());
+  if (code_point_count > 1) {
+    int before = 0;
+    int total = 0;
+    for (size_t i = chars.start(); i < chars.end(); ++i) {
+      if (render_text->IsGraphemeBoundary(i)) {
+        if (i < text_index)
+          ++before;
+        ++total;
+      }
+    }
+    // With ICU 65.1, DCHECK_GT() below fails.
+    // See https://crbug.com/1017047 for more details.
+    //
+    // DCHECK_GT(total, 0);
+
+    // It's possible for |text_index| to point to a diacritical mark, at the end
+    // of |chars|. In this case all the grapheme boundaries come before it. Just
+    // provide the bounds of the last grapheme.
+    if (before == total)
+      --before;
+
+    if (total > 1) {
+      if (font_params.is_rtl)
+        before = total - before - 1;
+      DCHECK_GE(before, 0);
+      DCHECK_LT(before, total);
+      const float cluster_start = preceding_run_widths + cluster_begin_x;
+      const float average_width = (cluster_end_x - cluster_begin_x) / total;
+      return RangeF(cluster_start + average_width * before,
+                    cluster_start + average_width * (before + 1));
+    }
+  }
+
+  return RangeF(preceding_run_widths + cluster_begin_x,
+                preceding_run_widths + cluster_end_x);
+}
+
+RangeF TextRunHarfBuzz::GetGraphemeSpanForCharRange(
+    RenderTextHarfBuzz* render_text,
+    const Range& char_range) const {
+  if (char_range.is_empty())
+    return RangeF();
+
+  DCHECK(!char_range.is_reversed());
+  DCHECK(range.Contains(char_range));
+  size_t left_index = char_range.start();
+  size_t right_index =
+      UTF16OffsetToIndex(render_text->GetDisplayText(), char_range.end(), -1);
+  DCHECK_LE(left_index, right_index);
+  if (font_params.is_rtl)
+    std::swap(left_index, right_index);
+
+  const RangeF left_span = GetGraphemeBounds(render_text, left_index);
+  return left_index == right_index
+             ? left_span
+             : RangeF(left_span.start(),
+                      GetGraphemeBounds(render_text, right_index).end());
+}
+
+SkScalar TextRunHarfBuzz::GetGlyphWidthForCharRange(
+    const Range& char_range) const {
+  if (char_range.is_empty())
+    return 0;
+
+  DCHECK(range.Contains(char_range));
+  Range glyph_range = CharRangeToGlyphRange(char_range);
+
+  // The |glyph_range| might be empty or invalid on Windows if a multi-character
+  // grapheme is divided into different runs (e.g., there are two font sizes or
+  // colors for a single glyph). In this case it might cause the browser crash,
+  // see crbug.com/526234.
+  if (glyph_range.start() >= glyph_range.end()) {
+    NOTREACHED() << "The glyph range is empty or invalid! Its char range: ["
+        << char_range.start() << ", " << char_range.end()
+        << "], and its glyph range: [" << glyph_range.start() << ", "
+        << glyph_range.end() << "].";
+    return 0;
+  }
+
+  return ((glyph_range.end() == shape.glyph_count)
+              ? SkFloatToScalar(shape.width)
+              : shape.positions[glyph_range.end()].x()) -
+         shape.positions[glyph_range.start()].x();
+}
+
+void TextRunHarfBuzz::UpdateFontParamsAndShape(
+    const FontParams& new_font_params,
+    const ShapeOutput& new_shape) {
+  if (new_shape.missing_glyph_count < shape.missing_glyph_count) {
+    font_params = new_font_params;
+    shape = new_shape;
+    // Note that |new_shape.glyph_to_char| is indexed from the beginning of
+    // |range|, while |shape.glyph_to_char| is indexed from the beginning of
+    // its embedding text.
+    for (size_t i = 0; i < shape.glyph_to_char.size(); ++i)
+      shape.glyph_to_char[i] += range.start();
+  }
+}
+
+TextRunList::TextRunList() : width_(0.0f) {}
+
+TextRunList::~TextRunList() {}
+
+void TextRunList::Reset() {
+  runs_.clear();
+  width_ = 0.0f;
+}
+
+void TextRunList::InitIndexMap() {
+  if (runs_.size() == 1) {
+    visual_to_logical_ = logical_to_visual_ = std::vector<int32_t>(1, 0);
+    return;
+  }
+  const size_t num_runs = runs_.size();
+  std::vector<UBiDiLevel> levels(num_runs);
+  for (size_t i = 0; i < num_runs; ++i)
+    levels[i] = runs_[i]->font_params.level;
+  visual_to_logical_.resize(num_runs);
+  ubidi_reorderVisual(&levels[0], num_runs, &visual_to_logical_[0]);
+  logical_to_visual_.resize(num_runs);
+  ubidi_reorderLogical(&levels[0], num_runs, &logical_to_visual_[0]);
+}
+
+void TextRunList::ComputePrecedingRunWidths() {
+  // Precalculate run width information.
+  width_ = 0.0f;
+  for (size_t i = 0; i < runs_.size(); ++i) {
+    const auto& run = runs_[visual_to_logical_[i]];
+    run->preceding_run_widths = width_;
+    width_ += run->shape.width;
+  }
+}
+
+size_t TextRunList::GetRunIndexAt(size_t position) const {
+  for (size_t i = 0; i < runs_.size(); ++i) {
+    if (runs_[i]->range.start() <= position && runs_[i]->range.end() > position)
+      return i;
+  }
+  return runs_.size();
+}
+
+namespace {
+
+// ShapeRunWithFont cache. Views makes repeated calls to ShapeRunWithFont
+// with the same arguments in several places, and typesetting is very expensive.
+// To compensate for this, encapsulate all of the input arguments to
+// ShapeRunWithFont in ShapeRunWithFontInput, all of the output arguments in
+// TextRunHarfBuzz::ShapeOutput, and add ShapeRunCache to map between the two.
+// This is analogous to the blink::ShapeCache.
+// https://crbug.com/826265
+
+// Input for the stateless implementation of ShapeRunWithFont.
+struct ShapeRunWithFontInput {
+  ShapeRunWithFontInput(const std::u16string& full_text,
+                        const TextRunHarfBuzz::FontParams& font_params,
+                        Range full_range,
+                        bool obscured,
+                        float glyph_width_for_test,
+                        int obscured_glyph_spacing,
+                        bool subpixel_rendering_suppressed)
+      : skia_face(font_params.skia_face),
+        render_params(font_params.render_params),
+        script(font_params.script),
+        font_size(font_params.font_size),
+        obscured_glyph_spacing(obscured_glyph_spacing),
+        glyph_width_for_test(glyph_width_for_test),
+        is_rtl(font_params.is_rtl),
+        obscured(obscured),
+        subpixel_rendering_suppressed(subpixel_rendering_suppressed) {
+    // hb_buffer_add_utf16 will read the previous and next 5 unicode characters
+    // (which can have a maximum length of 2 uint16_t) as "context" that is used
+    // only for Arabic (which is RTL). Read the previous and next 10 uint16_ts
+    // to ensure that we capture all of this context if we're using RTL.
+    size_t kContextSize = is_rtl ? 10 : 0;
+    size_t context_start = full_range.start() < kContextSize
+                               ? 0
+                               : full_range.start() - kContextSize;
+    size_t context_end =
+        std::min(full_text.length(), full_range.end() + kContextSize);
+    range = Range(full_range.start() - context_start,
+                  full_range.end() - context_start);
+    text = full_text.substr(context_start, context_end - context_start);
+
+    // Pre-compute the hash to avoid having to re-hash at every comparison.
+    // Attempt to minimize collisions by including the typeface, script, font
+    // size, text and the text range.
+    hash = base::HashInts(hash, skia_face->uniqueID());
+    hash = base::HashInts(hash, script);
+    hash = base::HashInts(hash, font_size);
+    hash = base::Hash(text);
+    hash = base::HashInts(hash, range.start());
+    hash = base::HashInts(hash, range.length());
+  }
+
+  bool operator==(const ShapeRunWithFontInput& other) const {
+    return text == other.text && skia_face == other.skia_face &&
+           render_params == other.render_params &&
+           font_size == other.font_size && range == other.range &&
+           script == other.script && is_rtl == other.is_rtl &&
+           obscured == other.obscured &&
+           glyph_width_for_test == other.glyph_width_for_test &&
+           obscured_glyph_spacing == other.obscured_glyph_spacing &&
+           subpixel_rendering_suppressed == other.subpixel_rendering_suppressed;
+  }
+
+  struct Hash {
+    size_t operator()(const ShapeRunWithFontInput& key) const {
+      return key.hash;
+    }
+  };
+
+  sk_sp<SkTypeface> skia_face;
+  FontRenderParams render_params;
+  UScriptCode script;
+  int font_size;
+  int obscured_glyph_spacing;
+  float glyph_width_for_test;
+  bool is_rtl;
+  bool obscured;
+  bool subpixel_rendering_suppressed;
+
+  // The parts of the input text that may be read by hb_buffer_add_utf16.
+  std::u16string text;
+  // The conversion of the input range to a range within |text|.
+  Range range;
+  // The hash is cached to avoid repeated calls.
+  size_t hash = 0;
+};
+
+// An MRU cache of the results from calling ShapeRunWithFont. The maximum cache
+// size used in blink::ShapeCache is 10k. A Finch experiment showed that
+// reducing the cache size to 1k has no performance impact.
+constexpr int kShapeRunCacheSize = 1000;
+using ShapeRunCacheBase = base::HashingMRUCache<ShapeRunWithFontInput,
+                                                TextRunHarfBuzz::ShapeOutput,
+                                                ShapeRunWithFontInput::Hash>;
+class ShapeRunCache : public ShapeRunCacheBase {
+ public:
+  ShapeRunCache() : ShapeRunCacheBase(kShapeRunCacheSize) {}
+};
+
+void ShapeRunWithFont(const ShapeRunWithFontInput& in,
+                      TextRunHarfBuzz::ShapeOutput* out) {
+  TRACE_EVENT0("ui", "RenderTextHarfBuzz::ShapeRunWithFontInternal");
+
+  hb_font_t* harfbuzz_font =
+      CreateHarfBuzzFont(in.skia_face, SkIntToScalar(in.font_size),
+                         in.render_params, in.subpixel_rendering_suppressed);
+
+  // Create a HarfBuzz buffer and add the string to be shaped. The HarfBuzz
+  // buffer holds our text, run information to be used by the shaping engine,
+  // and the resulting glyph data.
+  hb_buffer_t* buffer = hb_buffer_create();
+  // Note that the value of the |item_offset| argument (here specified as
+  // |in.range.start()|) does affect the result, so we will have to adjust
+  // the computed offsets.
+  hb_buffer_add_utf16(
+      buffer, reinterpret_cast<const uint16_t*>(in.text.c_str()),
+      static_cast<int>(in.text.length()), in.range.start(), in.range.length());
+  hb_buffer_set_script(buffer, ICUScriptToHBScript(in.script));
+  hb_buffer_set_direction(buffer,
+                          in.is_rtl ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
+  // TODO(ckocagil): Should we determine the actual language?
+  hb_buffer_set_language(buffer, hb_language_get_default());
+
+  // Shape the text.
+  hb_shape(harfbuzz_font, buffer, NULL, 0);
+
+  // Populate the run fields with the resulting glyph data in the buffer.
+  unsigned int glyph_count = 0;
+  hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(buffer, &glyph_count);
+  out->glyph_count = glyph_count;
+  hb_glyph_position_t* hb_positions =
+      hb_buffer_get_glyph_positions(buffer, NULL);
+  out->glyphs.resize(out->glyph_count);
+  out->glyph_to_char.resize(out->glyph_count);
+  out->positions.resize(out->glyph_count);
+  out->width = 0.0f;
+
+  // Font on MAC like ".SF NS Text" may have a negative x_offset. Positive
+  // x_offset are also found on Windows (e.g. "Segoe UI"). It requires tests
+  // relying on the behavior of |glyph_width_for_test_| to also be given a zero
+  // x_offset, otherwise expectations get thrown off
+  // (see: http://crbug.com/1056220).
+  const bool force_zero_offset = in.glyph_width_for_test > 0;
+  constexpr uint16_t kMissingGlyphId = 0;
+
+  out->missing_glyph_count = 0;
+  for (size_t i = 0; i < out->glyph_count; ++i) {
+    DCHECK_LE(infos[i].codepoint, std::numeric_limits<uint16_t>::max());
+    uint16_t glyph = static_cast<uint16_t>(infos[i].codepoint);
+    out->glyphs[i] = glyph;
+    if (glyph == kMissingGlyphId)
+      out->missing_glyph_count += 1;
+    DCHECK_GE(infos[i].cluster, in.range.start());
+    out->glyph_to_char[i] = infos[i].cluster - in.range.start();
+    const SkScalar x_offset =
+        force_zero_offset ? 0
+                          : HarfBuzzUnitsToSkiaScalar(hb_positions[i].x_offset);
+    const SkScalar y_offset =
+        HarfBuzzUnitsToSkiaScalar(hb_positions[i].y_offset);
+    out->positions[i].set(out->width + x_offset, -y_offset);
+
+    if (in.glyph_width_for_test == 0)
+      out->width += HarfBuzzUnitsToFloat(hb_positions[i].x_advance);
+    else if (hb_positions[i].x_advance)  // Leave zero-width glyphs alone.
+      out->width += in.glyph_width_for_test;
+
+    if (in.obscured)
+      out->width += in.obscured_glyph_spacing;
+
+    // When subpixel positioning is not enabled, glyph width is rounded to avoid
+    // fractional width. Disable this conversion when a glyph width is provided
+    // for testing. Using an integral glyph width has the same behavior as
+    // disabling the subpixel positioning.
+    const bool force_subpixel_for_test = in.glyph_width_for_test != 0;
+
+    // Round run widths if subpixel positioning is off to match native behavior.
+    if (!in.render_params.subpixel_positioning && !force_subpixel_for_test)
+      out->width = std::round(out->width);
+  }
+
+  hb_buffer_destroy(buffer);
+  hb_font_destroy(harfbuzz_font);
+}
+
+std::string GetApplicationLocale() {
+#if defined(OS_ANDROID)
+  // TODO(etienneb): Android locale should work the same way than base locale.
+  return base::android::GetDefaultLocaleString();
+#else
+  return base::i18n::GetConfiguredLocale();
+#endif
+}
+
+}  // namespace
+
+}  // namespace internal
+
+RenderTextHarfBuzz::RenderTextHarfBuzz()
+    : RenderText(),
+      update_layout_run_list_(false),
+      update_display_run_list_(false),
+      update_display_text_(false),
+      locale_(internal::GetApplicationLocale()) {
+  set_truncate_length(kMaxTextLength);
+}
+
+RenderTextHarfBuzz::~RenderTextHarfBuzz() {}
+
+const std::u16string& RenderTextHarfBuzz::GetDisplayText() {
+  // TODO(krb): Consider other elision modes for multiline.
+  if ((multiline() && (max_lines() == 0 || elide_behavior() != ELIDE_TAIL)) ||
+      elide_behavior() == NO_ELIDE || elide_behavior() == FADE_TAIL) {
+    // Call UpdateDisplayText to clear |display_text_| and |text_elided_|
+    // on the RenderText class.
+    UpdateDisplayText(0);
+    update_display_text_ = false;
+    display_run_list_.reset();
+    return GetLayoutText();
+  }
+
+  EnsureLayoutRunList();
+  DCHECK(!update_display_text_);
+  return text_elided() ? display_text() : GetLayoutText();
+}
+
+SizeF RenderTextHarfBuzz::GetStringSizeF() {
+  EnsureLayout();
+  return total_size_;
+}
+
+SizeF RenderTextHarfBuzz::GetLineSizeF(const SelectionModel& caret) {
+  const internal::ShapedText* shaped_text = GetShapedText();
+  const auto& caret_run = GetRunContainingCaret(caret);
+  for (const auto& line : shaped_text->lines()) {
+    for (const internal::LineSegment& segment : line.segments) {
+      if (segment.run == caret_run)
+        return line.size;
+    }
+  }
+
+  return shaped_text->lines().back().size;
+}
+
+std::vector<Rect> RenderTextHarfBuzz::GetSubstringBounds(const Range& range) {
+  EnsureLayout();
+  DCHECK(!update_display_run_list_);
+  DCHECK(range.IsBoundedBy(Range(0, text().length())));
+  const Range grapheme_range = ExpandRangeToGraphemeBoundary(range);
+  const Range display_range(TextIndexToDisplayIndex(grapheme_range.start()),
+                            TextIndexToDisplayIndex(grapheme_range.end()));
+  DCHECK(IsValidDisplayRange(display_range));
+
+  std::vector<Rect> rects;
+  if (display_range.is_empty())
+    return rects;
+
+  internal::TextRunList* run_list = GetRunList();
+  const internal::ShapedText* shaped_text = GetShapedText();
+  for (size_t line_index = 0; line_index < shaped_text->lines().size();
+       ++line_index) {
+    const internal::Line& line = shaped_text->lines()[line_index];
+    // Only the last line can be empty.
+    DCHECK(!line.segments.empty() ||
+           (line_index == shaped_text->lines().size() - 1));
+    float line_start_x =
+        line.segments.empty()
+            ? 0
+            : run_list->runs()[line.segments[0].run]->preceding_run_widths;
+
+    if (line.segments.size() > 1 && IsNewlineSegment(line.segments[0]))
+      line_start_x += line.segments[0].width();
+
+    std::vector<Rect> current_line_rects;
+    for (const internal::LineSegment& segment : line.segments) {
+      const Range intersection = segment.char_range.Intersect(display_range);
+      DCHECK(!intersection.is_reversed());
+      if (!intersection.is_empty()) {
+        const internal::TextRunHarfBuzz& run = *run_list->runs()[segment.run];
+        RangeF selected_span =
+            run.GetGraphemeSpanForCharRange(this, intersection);
+        DCHECK(!selected_span.is_reversed());
+        int start_x = base::ClampFloor(selected_span.start() - line_start_x);
+        int end_x = base::ClampCeil(selected_span.end() - line_start_x);
+        Rect rect(start_x, 0, end_x - start_x,
+                  base::ClampCeil(line.size.height()));
+        current_line_rects.push_back(rect + GetLineOffset(line_index));
+      }
+    }
+    MergeIntersectingRects(current_line_rects);
+    rects.insert(rects.end(), current_line_rects.begin(),
+                 current_line_rects.end());
+  }
+  return rects;
+}
+
+RangeF RenderTextHarfBuzz::GetCursorSpan(const Range& text_range) {
+  DCHECK(!text_range.is_reversed());
+  EnsureLayout();
+  const size_t index = text_range.start();
+  size_t run_index =
+      GetRunContainingCaret(SelectionModel(index, CURSOR_FORWARD));
+  internal::TextRunList* run_list = GetRunList();
+
+  // Return zero if the text is empty.
+  if (run_list->size() == 0 || text().empty())
+    return RangeF(0);
+
+  // Use the last run if the index is invalid or beyond the layout text size.
+  Range valid_range(text_range.start(), text_range.end());
+  if (run_index >= run_list->size()) {
+    valid_range = Range(text().length() - 1, text().length());
+    run_index = run_list->size() - 1;
+  }
+
+  internal::TextRunHarfBuzz* run = run_list->runs()[run_index].get();
+
+  size_t next_grapheme_start = valid_range.end();
+  if (!IsValidCursorIndex(next_grapheme_start)) {
+    next_grapheme_start =
+        IndexOfAdjacentGrapheme(next_grapheme_start, CURSOR_FORWARD);
+  }
+
+  Range display_range(TextIndexToDisplayIndex(valid_range.start()),
+                      TextIndexToDisplayIndex(next_grapheme_start));
+  DCHECK(IsValidDisplayRange(display_range));
+
+  // Although highly likely, there's no guarantee that a single text run is used
+  // for the entire cursor span. For example, Unicode Variation Selectors are
+  // incorrectly placed in the next run; see crbug.com/775404. (For these, the
+  // variation selector has zero width, so it's safe to ignore the second run).
+  // TODO(tapted): Change this to a DCHECK when crbug.com/775404 is fixed.
+  display_range = display_range.Intersect(run->range);
+
+  RangeF bounds = run->GetGraphemeSpanForCharRange(this, display_range);
+  return run->font_params.is_rtl ? RangeF(bounds.end(), bounds.start())
+                                 : bounds;
+}
+
+size_t RenderTextHarfBuzz::GetLineContainingCaret(const SelectionModel& caret) {
+  EnsureLayout();
+
+  if (caret.caret_pos() == 0)
+    return 0;
+
+  if (!multiline()) {
+    DCHECK_EQ(1u, GetShapedText()->lines().size());
+    return 0;
+  }
+
+  size_t layout_position = TextIndexToDisplayIndex(caret.caret_pos());
+  LogicalCursorDirection affinity = caret.caret_affinity();
+  const internal::ShapedText* shaped_text = GetShapedText();
+  for (size_t line_index = 0; line_index < shaped_text->lines().size();
+       ++line_index) {
+    const internal::Line& line = shaped_text->lines()[line_index];
+    for (const internal::LineSegment& segment : line.segments) {
+      if (RangeContainsCaret(segment.char_range, layout_position, affinity))
+        return LineIndexForNewline(line_index, text(), segment, caret);
+    }
+  }
+
+  return shaped_text->lines().size() - 1;
+}
+
+SelectionModel RenderTextHarfBuzz::AdjacentCharSelectionModel(
+    const SelectionModel& selection,
+    VisualCursorDirection direction) {
+  DCHECK(!update_display_run_list_);
+
+  internal::TextRunList* run_list = GetRunList();
+  internal::TextRunHarfBuzz* run;
+
+  size_t run_index = GetRunContainingCaret(selection);
+  if (run_index >= run_list->size()) {
+    // The cursor is not in any run: we're at the visual and logical edge.
+    SelectionModel edge = EdgeSelectionModel(direction);
+    if (edge.caret_pos() == selection.caret_pos())
+      return edge;
+    int visual_index = (direction == CURSOR_RIGHT) ? 0 : run_list->size() - 1;
+    run = run_list->runs()[run_list->visual_to_logical(visual_index)].get();
+  } else {
+    // If the cursor is moving within the current run, just move it by one
+    // grapheme in the appropriate direction.
+    run = run_list->runs()[run_index].get();
+    size_t caret = selection.caret_pos();
+    bool forward_motion = run->font_params.is_rtl == (direction == CURSOR_LEFT);
+    if (forward_motion) {
+      if (caret < DisplayIndexToTextIndex(run->range.end())) {
+        caret = IndexOfAdjacentGrapheme(caret, CURSOR_FORWARD);
+        return SelectionModel(caret, CURSOR_BACKWARD);
+      }
+    } else {
+      if (caret > DisplayIndexToTextIndex(run->range.start())) {
+        caret = IndexOfAdjacentGrapheme(caret, CURSOR_BACKWARD);
+        return SelectionModel(caret, CURSOR_FORWARD);
+      }
+    }
+    // The cursor is at the edge of a run; move to the visually adjacent run.
+    int visual_index = run_list->logical_to_visual(run_index);
+    visual_index += (direction == CURSOR_LEFT) ? -1 : 1;
+    if (visual_index < 0 || visual_index >= static_cast<int>(run_list->size()))
+      return EdgeSelectionModel(direction);
+    run = run_list->runs()[run_list->visual_to_logical(visual_index)].get();
+  }
+  bool forward_motion = run->font_params.is_rtl == (direction == CURSOR_LEFT);
+  return forward_motion ? FirstSelectionModelInsideRun(run) :
+                          LastSelectionModelInsideRun(run);
+}
+
+SelectionModel RenderTextHarfBuzz::AdjacentWordSelectionModel(
+    const SelectionModel& selection,
+    VisualCursorDirection direction) {
+  if (obscured())
+    return EdgeSelectionModel(direction);
+
+  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
+  bool success = iter.Init();
+  DCHECK(success);
+  if (!success)
+    return selection;
+
+  internal::TextRunList* run_list = GetRunList();
+  SelectionModel current(selection);
+  for (;;) {
+    current = AdjacentCharSelectionModel(current, direction);
+    size_t run = GetRunContainingCaret(current);
+    if (run == run_list->size())
+      break;
+    size_t cursor = current.caret_pos();
+#if defined(OS_WIN)
+    // Windows generally advances to the start of a word in either direction.
+    // TODO: Break on the end of a word when the neighboring text is
+    // punctuation.
+    if (iter.IsStartOfWord(cursor))
+      break;
+#else
+    const bool is_forward =
+        run_list->runs()[run]->font_params.is_rtl == (direction == CURSOR_LEFT);
+    if (is_forward ? iter.IsEndOfWord(cursor) : iter.IsStartOfWord(cursor))
+      break;
+#endif  // defined(OS_WIN)
+  }
+  return current;
+}
+
+SelectionModel RenderTextHarfBuzz::AdjacentLineSelectionModel(
+    const SelectionModel& selection,
+    VisualCursorDirection direction) {
+  DCHECK(direction == CURSOR_UP || direction == CURSOR_DOWN);
+
+  size_t line = GetLineContainingCaret(selection);
+  if (line == 0 && direction == CURSOR_UP) {
+    reset_cached_cursor_x();
+    return SelectionModel(0, CURSOR_BACKWARD);
+  }
+  if (line == GetShapedText()->lines().size() - 1 && direction == CURSOR_DOWN) {
+    reset_cached_cursor_x();
+    return SelectionModel(text().length(), CURSOR_FORWARD);
+  }
+
+  direction == CURSOR_UP ? --line : ++line;
+  Rect bounds = GetCursorBounds(selection, true);
+  Point target = bounds.origin();
+  if (cached_cursor_x())
+    target.set_x(cached_cursor_x().value());
+  else
+    set_cached_cursor_x(target.x());
+  if (direction == CURSOR_UP)
+    target.Offset(0, -bounds.size().height() / 2);
+  else
+    target.Offset(0, bounds.size().height() * 3 / 2);
+  SelectionModel next = FindCursorPosition(target, Point());
+  size_t next_line = GetLineContainingCaret(next);
+
+  // If the |target| position is at the newline character, the caret is drawn to
+  // the next line. e.g., when the caret is at the beginning of the line in RTL
+  // text. Move the caret to the position of the previous character to move the
+  // caret to the previous line.
+  if (next_line == line + 1)
+    next = SelectionModel(next.caret_pos() - 1, next.caret_affinity());
+
+  return next;
+}
+
+void RenderTextHarfBuzz::OnLayoutTextAttributeChanged(bool text_changed) {
+  RenderText::OnLayoutTextAttributeChanged(text_changed);
+
+  update_layout_run_list_ = true;
+  OnDisplayTextAttributeChanged();
+}
+
+void RenderTextHarfBuzz::OnDisplayTextAttributeChanged() {
+  update_display_text_ = true;
+  set_shaped_text(nullptr);
+}
+
+void RenderTextHarfBuzz::EnsureLayout() {
+  EnsureLayoutRunList();
+
+  if (update_display_run_list_) {
+    DCHECK(text_elided());
+    const std::u16string& display_text = GetDisplayText();
+    display_run_list_ = std::make_unique<internal::TextRunList>();
+
+    if (!display_text.empty())
+      ItemizeAndShapeText(display_text, display_run_list_.get());
+    update_display_run_list_ = false;
+    set_shaped_text(nullptr);
+  }
+
+  if (!has_shaped_text()) {
+    internal::TextRunList* run_list = GetRunList();
+    const int height = std::max(font_list().GetHeight(), min_line_height());
+    HarfBuzzLineBreaker line_breaker(
+        display_rect().width(),
+        DetermineBaselineCenteringText(height, font_list()), height,
+        glyph_height_for_test_, word_wrap_behavior(), GetDisplayText(),
+        multiline() ? &GetLineBreaks() : nullptr, *run_list);
+
+    if (multiline())
+      line_breaker.ConstructMultiLines();
+    else
+      line_breaker.ConstructSingleLine();
+    std::vector<internal::Line> lines;
+    line_breaker.FinalizeLines(&lines, &total_size_);
+    if (multiline() && max_lines()) {
+      // TODO(crbug.com/866720): no more than max_lines() should be rendered.
+      // Remove the IsHomogeneous() condition for the following DCHECK when the
+      // bug is fixed.
+      if (IsHomogeneous()) {
+        DCHECK_LE(lines.size(), max_lines());
+      }
+    }
+
+    set_shaped_text(std::make_unique<internal::ShapedText>(lines));
+  }
+}
+
+void RenderTextHarfBuzz::DrawVisualText(internal::SkiaTextRenderer* renderer,
+                                        const std::vector<Range>& selections) {
+  DCHECK(!update_layout_run_list_);
+  DCHECK(!update_display_run_list_);
+  DCHECK(!update_display_text_);
+
+  const internal::ShapedText* shaped_text = GetShapedText();
+  if (shaped_text->lines().empty())
+    return;
+
+  ApplyFadeEffects(renderer);
+  ApplyTextShadows(renderer);
+
+  // Apply the selected text color to the [un-reversed] selection range.
+  BreakList<SkColor> colors = layout_colors();
+  for (auto selection : selections) {
+    if (!selection.is_empty()) {
+      const Range grapheme_range = ExpandRangeToGraphemeBoundary(selection);
+      colors.ApplyValue(
+          selection_color(),
+          Range(TextIndexToDisplayIndex(grapheme_range.GetMin()),
+                TextIndexToDisplayIndex(grapheme_range.GetMax())));
+    }
+  }
+
+  internal::TextRunList* run_list = GetRunList();
+  const std::u16string& display_text = GetDisplayText();
+  for (size_t i = 0; i < shaped_text->lines().size(); ++i) {
+    const internal::Line& line = shaped_text->lines()[i];
+    const Vector2d origin = GetLineOffset(i) + Vector2d(0, line.baseline);
+    SkScalar preceding_segment_widths = 0;
+    for (const internal::LineSegment& segment : line.segments) {
+      // Don't draw the newline glyph (crbug.com/680430).
+      if (IsNewlineSegment(display_text, segment))
+        continue;
+
+      const internal::TextRunHarfBuzz& run = *run_list->runs()[segment.run];
+      renderer->SetTypeface(run.font_params.skia_face);
+      renderer->SetTextSize(SkIntToScalar(run.font_params.font_size));
+      renderer->SetFontRenderParams(run.font_params.render_params,
+                                    subpixel_rendering_suppressed());
+      Range glyphs_range = run.CharRangeToGlyphRange(segment.char_range);
+      std::vector<SkPoint> positions(glyphs_range.length());
+      SkScalar offset_x = preceding_segment_widths -
+                          ((glyphs_range.GetMin() != 0)
+                               ? run.shape.positions[glyphs_range.GetMin()].x()
+                               : 0);
+      for (size_t j = 0; j < glyphs_range.length(); ++j) {
+        positions[j] = run.shape.positions[(glyphs_range.is_reversed())
+                                               ? (glyphs_range.start() - j)
+                                               : (glyphs_range.start() + j)];
+        positions[j].offset(
+            SkIntToScalar(origin.x()) + offset_x,
+            SkIntToScalar(origin.y() + run.font_params.baseline_offset));
+      }
+      for (auto it = colors.GetBreak(segment.char_range.start());
+           it != colors.breaks().end() && it->first < segment.char_range.end();
+           ++it) {
+        const Range intersection =
+            colors.GetRange(it).Intersect(segment.char_range);
+        const Range colored_glyphs = run.CharRangeToGlyphRange(intersection);
+        // The range may be empty if a portion of a multi-character grapheme is
+        // selected, yielding two colors for a single glyph. For now, this just
+        // paints the glyph with a single style, but it should paint it twice,
+        // clipped according to selection bounds. See http://crbug.com/366786
+        if (colored_glyphs.is_empty())
+          continue;
+
+        renderer->SetForegroundColor(it->second);
+        renderer->DrawPosText(
+            &positions[colored_glyphs.start() - glyphs_range.start()],
+            &run.shape.glyphs[colored_glyphs.start()], colored_glyphs.length());
+        int start_x = SkScalarRoundToInt(
+            positions[colored_glyphs.start() - glyphs_range.start()].x());
+        int end_x = SkScalarRoundToInt(
+            (colored_glyphs.end() == glyphs_range.end())
+                ? (SkFloatToScalar(segment.width()) + preceding_segment_widths +
+                   SkIntToScalar(origin.x()))
+                : positions[colored_glyphs.end() - glyphs_range.start()].x());
+        if (run.font_params.heavy_underline)
+          renderer->DrawUnderline(start_x, origin.y(), end_x - start_x, 2.0);
+        else if (run.font_params.underline)
+          renderer->DrawUnderline(start_x, origin.y(), end_x - start_x);
+        if (run.font_params.strike)
+          renderer->DrawStrike(start_x, origin.y(), end_x - start_x,
+                               strike_thickness_factor());
+      }
+      preceding_segment_widths += SkFloatToScalar(segment.width());
+    }
+  }
+}
+
+size_t RenderTextHarfBuzz::GetRunContainingCaret(
+    const SelectionModel& caret) {
+  DCHECK(!update_display_run_list_);
+  size_t layout_position = TextIndexToDisplayIndex(caret.caret_pos());
+  LogicalCursorDirection affinity = caret.caret_affinity();
+  internal::TextRunList* run_list = GetRunList();
+  for (size_t i = 0; i < run_list->size(); ++i) {
+    internal::TextRunHarfBuzz* run = run_list->runs()[i].get();
+    if (RangeContainsCaret(run->range, layout_position, affinity))
+      return i;
+  }
+  return run_list->size();
+}
+
+SelectionModel RenderTextHarfBuzz::FirstSelectionModelInsideRun(
+    const internal::TextRunHarfBuzz* run) {
+  size_t position = DisplayIndexToTextIndex(run->range.start());
+  position = IndexOfAdjacentGrapheme(position, CURSOR_FORWARD);
+  return SelectionModel(position, CURSOR_BACKWARD);
+}
+
+SelectionModel RenderTextHarfBuzz::LastSelectionModelInsideRun(
+    const internal::TextRunHarfBuzz* run) {
+  size_t position = DisplayIndexToTextIndex(run->range.end());
+  position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
+  return SelectionModel(position, CURSOR_FORWARD);
+}
+
+void RenderTextHarfBuzz::ItemizeAndShapeText(const std::u16string& text,
+                                             internal::TextRunList* run_list) {
+  CommonizedRunsMap commonized_run_map;
+  ItemizeTextToRuns(text, run_list, &commonized_run_map);
+
+  for (auto iter = commonized_run_map.begin(); iter != commonized_run_map.end();
+       ++iter) {
+    internal::TextRunHarfBuzz::FontParams font_params = iter->first;
+    font_params.ComputeRenderParamsFontSizeAndBaselineOffset();
+    ShapeRuns(text, font_params, std::move(iter->second));
+  }
+
+  run_list->InitIndexMap();
+  run_list->ComputePrecedingRunWidths();
+}
+
+void RenderTextHarfBuzz::ItemizeTextToRuns(
+    const std::u16string& text,
+    internal::TextRunList* out_run_list,
+    CommonizedRunsMap* out_commonized_run_map) {
+  TRACE_EVENT1("ui", "RenderTextHarfBuzz::ItemizeTextToRuns", "text_length",
+               text.length());
+  DCHECK(!text.empty());
+  const Font& primary_font = font_list().GetPrimaryFont();
+
+  // If ICU fails to itemize the text, we create a run that spans the entire
+  // text. This is needed because leaving the runs set empty causes some clients
+  // to misbehave since they expect non-zero text metrics from a non-empty text.
+  ui::gfx::BiDiLineIterator bidi_iterator;
+
+  if (!bidi_iterator.Open(text, GetTextDirectionForGivenText(text))) {
+    auto run = std::make_unique<internal::TextRunHarfBuzz>(
+        font_list().GetPrimaryFont());
+    run->range = Range(0, text.length());
+    internal::TextRunHarfBuzz::FontParams font_params(primary_font);
+    (*out_commonized_run_map)[font_params].push_back(run.get());
+    out_run_list->Add(std::move(run));
+    return;
+  }
+
+  // Iterator to split ranged styles and baselines. The color attributes don't
+  // break text runs to keep ligature between graphemes (e.g. Arabic word).
+  internal::StyleIterator style = GetLayoutTextStyleIterator();
+
+  // Split the original text by logical runs, then each logical run by common
+  // script and each sequence at special characters and style boundaries. This
+  // invariant holds: bidi_run_start <= script_run_start <= breaking_run_start
+  // <= breaking_run_end <= script_run_end <= bidi_run_end
+  for (size_t bidi_run_start = 0; bidi_run_start < text.length();) {
+    // Determine the longest logical run (e.g. same bidi direction) from this
+    // point.
+    int32_t bidi_run_break = 0;
+    UBiDiLevel bidi_level = 0;
+    bidi_iterator.GetLogicalRun(bidi_run_start, &bidi_run_break, &bidi_level);
+    size_t bidi_run_end = static_cast<size_t>(bidi_run_break);
+    DCHECK_LT(bidi_run_start, bidi_run_end);
+
+    ApplyForcedDirection(&bidi_level);
+
+    for (size_t script_run_start = bidi_run_start;
+         script_run_start < bidi_run_end;) {
+      // Find the longest sequence of characters that have at least one common
+      // UScriptCode value.
+      UScriptCode script = USCRIPT_INVALID_CODE;
+      size_t script_run_end =
+          ScriptInterval(text, script_run_start,
+                         bidi_run_end - script_run_start, &script) +
+          script_run_start;
+      DCHECK_LT(script_run_start, script_run_end);
+
+      for (size_t breaking_run_start = script_run_start;
+           breaking_run_start < script_run_end;) {
+        // Find the break boundary for style. The style won't break a grapheme
+        // since the style of the first character is applied to the whole
+        // grapheme.
+        style.IncrementToPosition(breaking_run_start);
+        size_t text_style_end = style.GetTextBreakingRange().end();
+
+        // Break runs at certain characters that need to be rendered separately
+        // to prevent an unusual character from forcing a fallback font on the
+        // entire run. After script intersection, many codepoints end up in the
+        // script COMMON but can't be rendered together.
+        size_t breaking_run_end = FindRunBreakingCharacter(
+            text, script, breaking_run_start, text_style_end, script_run_end);
+
+        DCHECK_LT(breaking_run_start, breaking_run_end);
+        DCHECK(IsValidCodePointIndex(text, breaking_run_end));
+
+        // Set the font params for the current run for the current run break.
+        internal::TextRunHarfBuzz::FontParams font_params =
+            CreateFontParams(primary_font, bidi_level, script, style);
+
+        // Create the current run from [breaking_run_start, breaking_run_end[.
+        auto run = std::make_unique<internal::TextRunHarfBuzz>(primary_font);
+        run->range = Range(breaking_run_start, breaking_run_end);
+
+        // Add the created run to the set of runs.
+        (*out_commonized_run_map)[font_params].push_back(run.get());
+        out_run_list->Add(std::move(run));
+
+        // Move to the next run.
+        breaking_run_start = breaking_run_end;
+      }
+
+      // Move to the next script sequence.
+      script_run_start = script_run_end;
+    }
+
+    // Move to the next direction sequence.
+    bidi_run_start = bidi_run_end;
+  }
+}
+
+void RenderTextHarfBuzz::ShapeRuns(
+    const std::u16string& text,
+    const internal::TextRunHarfBuzz::FontParams& font_params,
+    std::vector<internal::TextRunHarfBuzz*> runs) {
+  TRACE_EVENT1("ui", "RenderTextHarfBuzz::ShapeRuns", "run_count", runs.size());
+
+  // Runs with a single newline character should be skipped since they can't be
+  // rendered (see http://crbug/680430). The following code sets the runs
+  // shaping output to report report the missing glyph and removes the runs from
+  // the vector of runs to shape. The newline character doesn't have a
+  // glyph, which otherwise forces this function to go through the expensive
+  // font fallbacks before reporting a missing glyph (see http://crbug/972090).
+  std::vector<internal::TextRunHarfBuzz*> need_shaping_runs;
+  for (internal::TextRunHarfBuzz*& run : runs) {
+    if ((run->range.length() == 1 && (text[run->range.start()] == '\r' ||
+                                      text[run->range.start()] == '\n')) ||
+        (run->range.length() == 2 && text[run->range.start()] == '\r' &&
+         text[run->range.start() + 1] == '\n')) {
+      // Newline runs can't be shaped. Shape this run as if the glyph is
+      // missing.
+      run->font_params = font_params;
+      run->shape.missing_glyph_count = 1;
+      run->shape.glyph_count = 1;
+      run->shape.glyphs.resize(run->shape.glyph_count);
+      run->shape.glyph_to_char.resize(run->shape.glyph_count);
+      run->shape.positions.resize(run->shape.glyph_count);
+      // Keep width as zero since newline character doesn't have a width.
+    } else {
+      // This run needs shaping.
+      need_shaping_runs.push_back(run);
+    }
+  }
+  runs.swap(need_shaping_runs);
+  if (runs.empty()) {
+    RecordShapeRunsFallback(ShapeRunFallback::NO_FALLBACK);
+    return;
+  }
+
+  // Keep a set of fonts already tried for shaping runs.
+  std::set<SkFontID> fallback_fonts_already_tried;
+  std::vector<Font> fallback_font_candidates;
+
+  // Shaping with primary configured fonts from font_list().
+  for (const Font& font : font_list().GetFonts()) {
+    internal::TextRunHarfBuzz::FontParams test_font_params = font_params;
+    if (test_font_params.SetRenderParamsRematchFont(
+            font, font.GetFontRenderParams()) &&
+        !FontWasAlreadyTried(test_font_params.skia_face,
+                             &fallback_fonts_already_tried)) {
+      ShapeRunsWithFont(text, test_font_params, &runs);
+      MarkFontAsTried(test_font_params.skia_face,
+                      &fallback_fonts_already_tried);
+      fallback_font_candidates.push_back(font);
+    }
+    if (runs.empty()) {
+      RecordShapeRunsFallback(ShapeRunFallback::NO_FALLBACK);
+      return;
+    }
+  }
+
+  const Font& primary_font = font_list().GetPrimaryFont();
+
+  // Find fallback fonts for the remaining runs using a worklist algorithm. Try
+  // to shape the first run by using GetFallbackFont(...) and then try shaping
+  // other runs with the same font. If the first font can't be shaped, remove it
+  // and continue with the remaining runs until the worklist is empty. The
+  // fallback font returned by GetFallbackFont(...) depends on the text of the
+  // run and the results may differ between runs.
+  std::vector<internal::TextRunHarfBuzz*> remaining_unshaped_runs;
+  while (!runs.empty()) {
+    Font fallback_font(primary_font);
+    bool fallback_found;
+    internal::TextRunHarfBuzz* current_run = *runs.begin();
+    {
+      SCOPED_UMA_HISTOGRAM_LONG_TIMER("RenderTextHarfBuzz.GetFallbackFontTime");
+      TRACE_EVENT1("ui", "RenderTextHarfBuzz::GetFallbackFont", "script",
+                   TRACE_STR_COPY(uscript_getShortName(font_params.script)));
+      const base::StringPiece16 run_text(&text[current_run->range.start()],
+                                         current_run->range.length());
+      fallback_found =
+          GetFallbackFont(primary_font, locale_, run_text, &fallback_font);
+    }
+
+    if (fallback_found) {
+      internal::TextRunHarfBuzz::FontParams test_font_params = font_params;
+      if (test_font_params.SetRenderParamsOverrideSkiaFaceFromFont(
+              fallback_font, fallback_font.GetFontRenderParams()) &&
+          !FontWasAlreadyTried(test_font_params.skia_face,
+                               &fallback_fonts_already_tried)) {
+        ShapeRunsWithFont(text, test_font_params, &runs);
+        MarkFontAsTried(test_font_params.skia_face,
+                        &fallback_fonts_already_tried);
+      }
+    }
+
+    // Remove the first run if not fully shaped with its associated fallback
+    // font.
+    if (!runs.empty() && runs[0] == current_run) {
+      remaining_unshaped_runs.push_back(current_run);
+      runs.erase(runs.begin());
+    }
+  }
+  runs.swap(remaining_unshaped_runs);
+  if (runs.empty()) {
+    RecordShapeRunsFallback(ShapeRunFallback::FALLBACK);
+    return;
+  }
+
+  std::vector<Font> fallback_font_list;
+  {
+    SCOPED_UMA_HISTOGRAM_LONG_TIMER("RenderTextHarfBuzz.GetFallbackFontsTime");
+    TRACE_EVENT1("ui", "RenderTextHarfBuzz::GetFallbackFonts", "script",
+                 TRACE_STR_COPY(uscript_getShortName(font_params.script)));
+    fallback_font_list = GetFallbackFonts(primary_font);
+
+#if defined(OS_WIN)
+    // Append fonts in the fallback list of the fallback fonts.
+    // TODO(tapted): Investigate whether there's a case that benefits from this
+    // on Mac.
+    for (const auto& fallback_font : fallback_font_candidates) {
+      std::vector<Font> fallback_fonts = GetFallbackFonts(fallback_font);
+      fallback_font_list.insert(fallback_font_list.end(),
+                                fallback_fonts.begin(), fallback_fonts.end());
+    }
+
+    // Add Segoe UI and its associated linked fonts to the fallback font list to
+    // ensure that the fallback list covers the basic cases.
+    // http://crbug.com/467459. On some Windows configurations the default font
+    // could be a raster font like System, which would not give us a reasonable
+    // fallback font list.
+    Font segoe("Segoe UI", 13);
+    if (!FontWasAlreadyTried(segoe.platform_font()->GetNativeSkTypeface(),
+                             &fallback_fonts_already_tried)) {
+      std::vector<Font> default_fallback_families = GetFallbackFonts(segoe);
+      fallback_font_list.insert(fallback_font_list.end(),
+                                default_fallback_families.begin(),
+                                default_fallback_families.end());
+    }
+#endif
+  }
+
+  // Use a set to track the fallback fonts and avoid duplicate entries.
+  SCOPED_UMA_HISTOGRAM_LONG_TIMER(
+      "RenderTextHarfBuzz.ShapeRunsWithFallbackFontsTime");
+  TRACE_EVENT1("ui", "RenderTextHarfBuzz::ShapeRunsWithFallbackFonts",
+               "fonts_count", fallback_font_list.size());
+
+  // Try shaping with the fallback fonts.
+  for (const auto& font : fallback_font_list) {
+    std::string font_name = font.GetFontName();
+
+    FontRenderParamsQuery query;
+    query.families.push_back(font_name);
+    query.pixel_size = font_params.font_size;
+    query.style = font_params.italic ? Font::ITALIC : 0;
+    FontRenderParams fallback_render_params = GetFontRenderParams(query, NULL);
+    internal::TextRunHarfBuzz::FontParams test_font_params = font_params;
+    if (test_font_params.SetRenderParamsOverrideSkiaFaceFromFont(
+            font, fallback_render_params) &&
+        !FontWasAlreadyTried(test_font_params.skia_face,
+                             &fallback_fonts_already_tried)) {
+      ShapeRunsWithFont(text, test_font_params, &runs);
+      MarkFontAsTried(test_font_params.skia_face,
+                      &fallback_fonts_already_tried);
+    }
+    if (runs.empty()) {
+      TRACE_EVENT_INSTANT2("ui", "RenderTextHarfBuzz::FallbackFont",
+                           TRACE_EVENT_SCOPE_THREAD, "font_name",
+                           TRACE_STR_COPY(font_name.c_str()),
+                           "primary_font_name", primary_font.GetFontName());
+      RecordShapeRunsFallback(ShapeRunFallback::FALLBACKS);
+      return;
+    }
+  }
+
+  for (internal::TextRunHarfBuzz*& run : runs) {
+    if (run->shape.missing_glyph_count == std::numeric_limits<size_t>::max()) {
+      run->shape.glyph_count = 0;
+      run->shape.width = 0.0f;
+    }
+  }
+
+  RecordShapeRunsFallback(ShapeRunFallback::FAILED);
+}
+
+void RenderTextHarfBuzz::ShapeRunsWithFont(
+    const std::u16string& text,
+    const internal::TextRunHarfBuzz::FontParams& font_params,
+    std::vector<internal::TextRunHarfBuzz*>* in_out_runs) {
+  // ShapeRunWithFont can be extremely slow, so use cached results if possible.
+  // Only do this on the UI thread, to avoid synchronization overhead (and
+  // because almost all calls are on the UI thread. Also avoid caching long
+  // strings, to avoid blowing up the cache size.
+  constexpr size_t kMaxRunLengthToCache = 25;
+  static base::NoDestructor<internal::ShapeRunCache> cache;
+
+  std::vector<internal::TextRunHarfBuzz*> runs_with_missing_glyphs;
+  for (internal::TextRunHarfBuzz*& run : *in_out_runs) {
+    // First do a cache lookup.
+    bool can_use_cache = base::CurrentUIThread::IsSet() &&
+                         run->range.length() <= kMaxRunLengthToCache;
+    bool found_in_cache = false;
+    const internal::ShapeRunWithFontInput cache_key(
+        text, font_params, run->range, obscured(), glyph_width_for_test_,
+        obscured_glyph_spacing(), subpixel_rendering_suppressed());
+    if (can_use_cache) {
+      auto found = cache.get()->Get(cache_key);
+      if (found != cache.get()->end()) {
+        run->UpdateFontParamsAndShape(font_params, found->second);
+        found_in_cache = true;
+      }
+    }
+
+    // If that fails, compute the shape of the run, and add the result to the
+    // cache.
+    // TODO(ccameron): Coalesce calls to ShapeRunsWithFont when possible.
+    if (!found_in_cache) {
+      internal::TextRunHarfBuzz::ShapeOutput output;
+      ShapeRunWithFont(cache_key, &output);
+      run->UpdateFontParamsAndShape(font_params, output);
+      if (can_use_cache)
+        cache.get()->Put(cache_key, output);
+    }
+
+    // Check to see if we still have missing glyphs.
+    if (run->shape.missing_glyph_count)
+      runs_with_missing_glyphs.push_back(run);
+  }
+  in_out_runs->swap(runs_with_missing_glyphs);
+}
+
+void RenderTextHarfBuzz::EnsureLayoutRunList() {
+  // Update layout run list if the device scale factor has changed since the
+  // layout run list was last updated, as changes in device scale factor change
+  // subpixel positioning, at least on Linux and Chrome OS.
+  const float device_scale_factor = GetFontRenderParamsDeviceScaleFactor();
+
+  if (update_layout_run_list_ || device_scale_factor_ != device_scale_factor) {
+    device_scale_factor_ = device_scale_factor;
+    layout_run_list_.Reset();
+
+    const std::u16string& text = GetLayoutText();
+    if (!text.empty())
+      ItemizeAndShapeText(text, &layout_run_list_);
+
+    display_run_list_.reset();
+    update_display_text_ = true;
+    update_layout_run_list_ = false;
+  }
+  if (update_display_text_) {
+    set_shaped_text(nullptr);
+    UpdateDisplayText(multiline() ? 0 : layout_run_list_.width());
+    update_display_text_ = false;
+    update_display_run_list_ = text_elided();
+  }
+}
+
+// Returns the current run list, |display_run_list_| if the text is elided, or
+// |layout_run_list_| otherwise.
+internal::TextRunList* RenderTextHarfBuzz::GetRunList() {
+  DCHECK(!update_layout_run_list_);
+  DCHECK(!update_display_run_list_);
+  return text_elided() ? display_run_list_.get() : &layout_run_list_;
+}
+
+const internal::TextRunList* RenderTextHarfBuzz::GetRunList() const {
+  return const_cast<RenderTextHarfBuzz*>(this)->GetRunList();
+}
+
+bool RenderTextHarfBuzz::IsValidDisplayRange(Range display_range) {
+  // The |display_text_| is an elided version of |layout_text_|. Removing
+  // codepoints from the text may break the conversion for codepoint offsets
+  // between text to display_text offset. For elding behaviors that truncate
+  // codepoint at the end, the conversion will work just fine. But for eliding
+  // behavior that truncate at the beginning of middle of the text, the offsets
+  // are completely wrong and should not be used.
+  // TODO(http://crbug.com/1085014): Fix eliding for the broken cases.
+  switch (elide_behavior()) {
+    case NO_ELIDE:
+    case FADE_TAIL:
+      return display_range.IsBoundedBy(Range(0, GetDisplayText().length()));
+    case TRUNCATE:
+    case ELIDE_TAIL:
+      return display_range.IsBoundedBy(Range(0, GetLayoutText().length()));
+    case ELIDE_HEAD:
+    case ELIDE_MIDDLE:
+    case ELIDE_EMAIL:
+      return !text_elided();
+  }
+}
+
+bool RenderTextHarfBuzz::GetDecoratedTextForRange(
+    const Range& range,
+    DecoratedText* decorated_text) {
+  if (obscured())
+    return false;
+
+  EnsureLayout();
+
+  decorated_text->attributes.clear();
+  decorated_text->text = GetTextFromRange(range);
+
+  const internal::TextRunList* run_list = GetRunList();
+  for (size_t i = 0; i < run_list->size(); i++) {
+    const internal::TextRunHarfBuzz& run = *run_list->runs()[i];
+
+    const Range intersection = range.Intersect(run.range);
+    DCHECK(!intersection.is_reversed());
+
+    if (!intersection.is_empty()) {
+      int style = Font::NORMAL;
+      if (run.font_params.italic)
+        style |= Font::ITALIC;
+      if (run.font_params.underline || run.font_params.heavy_underline)
+        style |= Font::UNDERLINE;
+
+      // Get range relative to the decorated text.
+      DecoratedText::RangedAttribute attribute(
+          Range(intersection.start() - range.GetMin(),
+                intersection.end() - range.GetMin()),
+          run.font_params.font.Derive(0, style, run.font_params.weight));
+
+      attribute.strike = run.font_params.strike;
+      decorated_text->attributes.push_back(attribute);
+    }
+  }
+  return true;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/render_text_harfbuzz.h b/ui/gfx/render_text_harfbuzz.h
new file mode 100644
index 0000000..64a823d
--- /dev/null
+++ b/ui/gfx/render_text_harfbuzz.h
@@ -0,0 +1,329 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RENDER_TEXT_HARFBUZZ_H_
+#define UI_GFX_RENDER_TEXT_HARFBUZZ_H_
+
+#include <hb.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "base/macros.h"
+#include "third_party/icu/source/common/unicode/ubidi.h"
+#include "third_party/icu/source/common/unicode/uscript.h"
+#include "ui/gfx/render_text.h"
+
+namespace gfx {
+
+class Range;
+class RangeF;
+class RenderTextHarfBuzz;
+
+namespace internal {
+
+struct GFX_EXPORT TextRunHarfBuzz {
+  // Construct the run with |template_font| since determining the details of a
+  // default-constructed gfx::Font is expensive, but it will always be replaced.
+  explicit TextRunHarfBuzz(const Font& template_font);
+
+  TextRunHarfBuzz(const TextRunHarfBuzz&) = delete;
+  TextRunHarfBuzz& operator=(const TextRunHarfBuzz&) = delete;
+
+  ~TextRunHarfBuzz();
+
+  // Returns the corresponding glyph range of the given character range.
+  // |range| is in text-space (0 corresponds to |GetDisplayText()[0]|). Returned
+  // value is in run-space (0 corresponds to the first glyph in the run).
+  Range CharRangeToGlyphRange(const Range& range) const;
+
+  // Returns the number of missing glyphs in the shaped text run.
+  size_t CountMissingGlyphs() const;
+
+  // Writes the character and glyph ranges of the cluster containing |pos|.
+  void GetClusterAt(size_t pos, Range* chars, Range* glyphs) const;
+
+  // Returns the grapheme bounds at |text_index|. Handles multi-grapheme glyphs.
+  // Returned value is the horizontal pixel span in text-space (assumes all runs
+  // are on the same line). The returned range is never reversed.
+  RangeF GetGraphemeBounds(RenderTextHarfBuzz* render_text,
+                           size_t text_index) const;
+
+  // Returns the horizontal span of the given |char_range| handling grapheme
+  // boundaries within glyphs. This is a wrapper around one or more calls to
+  // GetGraphemeBounds(), returning a range in the same coordinate space.
+  RangeF GetGraphemeSpanForCharRange(RenderTextHarfBuzz* render_text,
+                                     const Range& char_range) const;
+
+  // Returns the glyph width for the given character range. |char_range| is in
+  // text-space (0 corresponds to |GetDisplayText()[0]|).
+  SkScalar GetGlyphWidthForCharRange(const Range& char_range) const;
+
+  // Font parameters that may be common to multiple text runs within a text run
+  // list.
+  struct GFX_EXPORT FontParams {
+    // The default constructor for Font is expensive, so always require that a
+    // Font be provided.
+    explicit FontParams(const Font& template_font);
+    ~FontParams();
+    FontParams(const FontParams& other);
+    FontParams& operator=(const FontParams& other);
+    bool operator==(const FontParams& other) const;
+
+    // Populates |render_params|, |font_size| and |baseline_offset| based on
+    // |font|.
+    void ComputeRenderParamsFontSizeAndBaselineOffset();
+
+    // Populates |font|, |skia_face|, and |render_params|. Returns false if
+    // |skia_face| is nullptr. Takes |font|'s family name and rematches this
+    // family and the run's weight and style properties to find a new font.
+    bool SetRenderParamsRematchFont(const Font& font,
+                                    const FontRenderParams& render_params);
+
+    // Populates |font|, |skia_face|, and |render_params|. Returns false if
+    // |skia_face| is nullptr. Does not perform rematching but extracts an
+    // SkTypeface from the underlying PlatformFont of font. Use this method when
+    // configuring the |TextRunHarfBuzz| for shaping with fallback fonts, where
+    // it is important to keep the underlying font handle of platform font and
+    // not perform rematching as in |SetRenderParamsRematchFont|.
+    bool SetRenderParamsOverrideSkiaFaceFromFont(
+        const Font& font,
+        const FontRenderParams& render_params);
+
+    struct Hash {
+      size_t operator()(const FontParams& key) const;
+    };
+
+    Font font;
+    sk_sp<SkTypeface> skia_face;
+    FontRenderParams render_params;
+    Font::Weight weight = Font::Weight::NORMAL;
+    int font_size = 0;
+    int baseline_offset = 0;
+    int baseline_type = 0;
+    bool italic = false;
+    bool strike = false;
+    bool underline = false;
+    bool heavy_underline = false;
+    bool is_rtl = false;
+    UBiDiLevel level = 0;
+    UScriptCode script = USCRIPT_INVALID_CODE;
+  };
+
+  // Parameters that are set by ShapeRunWithFont.
+  struct GFX_EXPORT ShapeOutput {
+    ShapeOutput();
+    ~ShapeOutput();
+    ShapeOutput(const ShapeOutput& other);
+    ShapeOutput& operator=(const ShapeOutput& other);
+    ShapeOutput(ShapeOutput&& other);
+    ShapeOutput& operator=(ShapeOutput&& other);
+
+    float width = 0.0;
+    std::vector<uint16_t> glyphs;
+    std::vector<SkPoint> positions;
+    // Note that in the context of TextRunHarfBuzz, |glyph_to_char| is indexed
+    // based off of the full string (so it is in the same domain as
+    // TextRunHarfBuzz::range).
+    std::vector<uint32_t> glyph_to_char;
+    size_t glyph_count = 0;
+    size_t missing_glyph_count = std::numeric_limits<size_t>::max();
+  };
+
+  // If |new_shape.missing_glyph_count| is less than that of |shape|, set
+  // |font_params| and |shape| to the specified values.
+  void UpdateFontParamsAndShape(const FontParams& new_font_params,
+                                const ShapeOutput& new_shape);
+
+  Range range;
+  FontParams font_params;
+  ShapeOutput shape;
+  float preceding_run_widths = 0.0;
+};
+
+// Manages the list of TextRunHarfBuzz and its logical <-> visual index mapping.
+class TextRunList {
+ public:
+  TextRunList();
+
+  TextRunList(const TextRunList&) = delete;
+  TextRunList& operator=(const TextRunList&) = delete;
+
+  ~TextRunList();
+
+  size_t size() const { return runs_.size(); }
+
+  // Converts the index between logical and visual index.
+  size_t visual_to_logical(size_t index) const {
+    return visual_to_logical_[index];
+  }
+  size_t logical_to_visual(size_t index) const {
+    return logical_to_visual_[index];
+  }
+
+  const std::vector<std::unique_ptr<TextRunHarfBuzz>>& runs() const {
+    return runs_;
+  }
+
+  // Adds the new |run| to the run list.
+  void Add(std::unique_ptr<TextRunHarfBuzz> run) {
+    runs_.push_back(std::move(run));
+  }
+
+  // Reset the run list.
+  void Reset();
+
+  // Initialize the index mapping.
+  void InitIndexMap();
+
+  // Precomputes the offsets for all runs.
+  void ComputePrecedingRunWidths();
+
+  // Get the total width of runs, as if they were shown on one line.
+  // Do not use this when multiline is enabled.
+  float width() const { return width_; }
+
+  // Get the run index applicable to |position| (at or preceeding |position|).
+  size_t GetRunIndexAt(size_t position) const;
+
+ private:
+  // Text runs in logical order.
+  std::vector<std::unique_ptr<TextRunHarfBuzz>> runs_;
+
+  // Maps visual run indices to logical run indices and vice versa.
+  std::vector<int32_t> visual_to_logical_;
+  std::vector<int32_t> logical_to_visual_;
+
+  float width_;
+};
+
+}  // namespace internal
+
+class GFX_EXPORT RenderTextHarfBuzz : public RenderText {
+ public:
+  RenderTextHarfBuzz();
+
+  RenderTextHarfBuzz(const RenderTextHarfBuzz&) = delete;
+  RenderTextHarfBuzz& operator=(const RenderTextHarfBuzz&) = delete;
+
+  ~RenderTextHarfBuzz() override;
+
+  // RenderText:
+  const std::u16string& GetDisplayText() override;
+  SizeF GetStringSizeF() override;
+  SizeF GetLineSizeF(const SelectionModel& caret) override;
+  std::vector<Rect> GetSubstringBounds(const Range& range) override;
+  RangeF GetCursorSpan(const Range& text_range) override;
+  size_t GetLineContainingCaret(const SelectionModel& caret) override;
+
+ protected:
+  // RenderText:
+  SelectionModel AdjacentCharSelectionModel(
+      const SelectionModel& selection,
+      VisualCursorDirection direction) override;
+  SelectionModel AdjacentWordSelectionModel(
+      const SelectionModel& selection,
+      VisualCursorDirection direction) override;
+  SelectionModel AdjacentLineSelectionModel(
+      const SelectionModel& selection,
+      VisualCursorDirection direction) override;
+  void OnLayoutTextAttributeChanged(bool text_changed) override;
+  void OnDisplayTextAttributeChanged() override;
+  void EnsureLayout() override;
+  void DrawVisualText(internal::SkiaTextRenderer* renderer,
+                      const std::vector<Range>& selections) override;
+
+ private:
+  friend class test::RenderTextTestApi;
+  friend class RenderTextTest;
+
+  // Return the run index that contains the argument; or the length of the
+  // |runs_| vector if argument exceeds the text length or width.
+  size_t GetRunContainingCaret(const SelectionModel& caret);
+
+  // Given a |run|, returns the SelectionModel that contains the logical first
+  // or last caret position inside (not at a boundary of) the run.
+  // The returned value represents a cursor/caret position without a selection.
+  SelectionModel FirstSelectionModelInsideRun(
+      const internal::TextRunHarfBuzz* run);
+  SelectionModel LastSelectionModelInsideRun(
+      const internal::TextRunHarfBuzz* run);
+
+  using CommonizedRunsMap =
+      std::unordered_map<internal::TextRunHarfBuzz::FontParams,
+                         std::vector<internal::TextRunHarfBuzz*>,
+                         internal::TextRunHarfBuzz::FontParams::Hash>;
+
+  // Break the text into logical runs in |out_run_list|. Populate
+  // |out_commonized_run_map| such that each run is present in the vector
+  // corresponding to its FontParams.
+  void ItemizeTextToRuns(const std::u16string& string,
+                         internal::TextRunList* out_run_list,
+                         CommonizedRunsMap* out_commonized_run_map);
+
+  // Shape the glyphs needed for each run in |runs| within |text|. This method
+  // will apply a number of fonts to |base_font_params| and assign to each
+  // run's FontParams and ShapeOutput the parameters and resulting shape that
+  // had the smallest number of missing glyphs.
+  void ShapeRuns(const std::u16string& text,
+                 const internal::TextRunHarfBuzz::FontParams& base_font_params,
+                 std::vector<internal::TextRunHarfBuzz*> runs);
+
+  // Shape the glyphs for |in_out_runs| within |text| using the parameters
+  // specified by |font_params|. If, for any run in |*in_out_runs|, the
+  // resulting shaping has fewer missing glyphs than the existing shape, then
+  // write |font_params| and the resulting ShapeOutput to that run. Remove all
+  // runs with no missing glyphs from |in_out_runs| (the caller, ShapeRuns, will
+  // terminate when no runs with missing glyphs remain).
+  void ShapeRunsWithFont(
+      const std::u16string& text,
+      const internal::TextRunHarfBuzz::FontParams& font_params,
+      std::vector<internal::TextRunHarfBuzz*>* in_out_runs);
+
+  // Itemize |text| into runs in |out_run_list|, shape the runs, and populate
+  // |out_run_list|'s visual <-> logical maps.
+  void ItemizeAndShapeText(const std::u16string& text,
+                           internal::TextRunList* out_run_list);
+
+  // Makes sure that text runs for layout text are shaped.
+  void EnsureLayoutRunList();
+
+  // Returns whether the display range is still a valid range after the eliding
+  // pass.
+  bool IsValidDisplayRange(Range display_range);
+
+  // RenderText:
+  internal::TextRunList* GetRunList() override;
+  const internal::TextRunList* GetRunList() const override;
+  bool GetDecoratedTextForRange(const Range& range,
+                                DecoratedText* decorated_text) override;
+
+  // Text run list for |layout_text_| and |display_text_|.
+  // |display_run_list_| is created only when the text is elided.
+  internal::TextRunList layout_run_list_;
+  std::unique_ptr<internal::TextRunList> display_run_list_;
+
+  bool update_layout_run_list_ : 1;
+  bool update_display_run_list_ : 1;
+  bool update_display_text_ : 1;
+
+  // The device scale factor for which the text was laid out.
+  float device_scale_factor_ = 1.0f;
+
+  // The total size of the layouted text.
+  SizeF total_size_;
+
+  // The process application locale used to configure text rendering.
+  std::string locale_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_RENDER_TEXT_HARFBUZZ_H_
diff --git a/ui/gfx/render_text_test_api.h b/ui/gfx/render_text_test_api.h
new file mode 100644
index 0000000..e7a7b33
--- /dev/null
+++ b/ui/gfx/render_text_test_api.h
@@ -0,0 +1,129 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RENDER_TEXT_TEST_API_H_
+#define UI_GFX_RENDER_TEXT_TEST_API_H_
+
+#include "base/macros.h"
+#include "ui/gfx/break_list.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/render_text.h"
+#include "ui/gfx/selection_model.h"
+
+namespace gfx {
+namespace test {
+
+class RenderTextTestApi {
+ public:
+  RenderTextTestApi(RenderText* render_text) : render_text_(render_text) {}
+
+  RenderTextTestApi(const RenderTextTestApi&) = delete;
+  RenderTextTestApi& operator=(const RenderTextTestApi&) = delete;
+
+  static const cc::PaintFlags& GetRendererPaint(
+      internal::SkiaTextRenderer* renderer) {
+    return renderer->flags_;
+  }
+
+  static const SkFont& GetRendererFont(internal::SkiaTextRenderer* renderer) {
+    return renderer->font_;
+  }
+
+  // Callers must ensure that the associated RenderText object is a
+  // RenderTextHarfBuzz instance.
+  internal::TextRunList* GetHarfBuzzRunList() {
+    return render_text_->GetRunList();
+  }
+
+  void DrawVisualText(internal::SkiaTextRenderer* renderer,
+                      const std::vector<Range> selection) {
+    render_text_->DrawVisualText(renderer, selection);
+  }
+
+  void Draw(Canvas* canvas, bool select_all = false) {
+    render_text_->Draw(canvas, select_all);
+  }
+
+  const std::u16string& GetLayoutText() {
+    return render_text_->GetLayoutText();
+  }
+
+  const BreakList<SkColor>& colors() const { return render_text_->colors(); }
+
+  const BreakList<BaselineStyle>& baselines() const {
+    return render_text_->baselines();
+  }
+
+  const BreakList<int>& font_size_overrides() const {
+    return render_text_->font_size_overrides();
+  }
+
+  const BreakList<Font::Weight>& weights() const {
+    return render_text_->weights();
+  }
+
+  const internal::StyleArray& styles() const { return render_text_->styles(); }
+
+  const std::vector<internal::Line>& lines() const {
+    return render_text_->GetShapedText()->lines();
+  }
+
+  const Vector2d& display_offset() const {
+    return render_text_->display_offset_;
+  }
+
+  SelectionModel EdgeSelectionModel(VisualCursorDirection direction) {
+    return render_text_->EdgeSelectionModel(direction);
+  }
+
+  size_t TextIndexToDisplayIndex(size_t index) {
+    return render_text_->TextIndexToDisplayIndex(index);
+  }
+
+  size_t DisplayIndexToTextIndex(size_t index) {
+    return render_text_->DisplayIndexToTextIndex(index);
+  }
+
+  void EnsureLayout() { render_text_->EnsureLayout(); }
+
+  Vector2d GetAlignmentOffset(size_t line_number) {
+    return render_text_->GetAlignmentOffset(line_number);
+  }
+
+  int GetDisplayTextBaseline() {
+    return render_text_->GetDisplayTextBaseline();
+  }
+
+  void SetGlyphWidth(float test_width) {
+    render_text_->set_glyph_width_for_test(test_width);
+  }
+
+  void SetGlyphHeight(float test_height) {
+    render_text_->set_glyph_height_for_test(test_height);
+  }
+
+  static gfx::Rect ExpandToBeVerticallySymmetric(
+      const gfx::Rect& rect,
+      const gfx::Rect& display_rect) {
+    return RenderText::ExpandToBeVerticallySymmetric(rect, display_rect);
+  }
+
+  static void MergeIntersectingRects(std::vector<Rect>& rects) {
+    RenderText::MergeIntersectingRects(rects);
+  }
+
+  void reset_cached_cursor_x() { render_text_->reset_cached_cursor_x(); }
+
+  int GetLineContainingYCoord(float text_y) {
+    return render_text_->GetLineContainingYCoord(text_y);
+  }
+
+ private:
+  RenderText* render_text_;
+};
+
+}  // namespace test
+}  // namespace gfx
+
+#endif  // UI_GFX_RENDER_TEXT_TEST_API_H_
diff --git a/ui/gfx/render_text_unittest.cc b/ui/gfx/render_text_unittest.cc
new file mode 100644
index 0000000..42f346c
--- /dev/null
+++ b/ui/gfx/render_text_unittest.cc
@@ -0,0 +1,8562 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/render_text.h"
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <memory>
+#include <numeric>
+
+#include "base/cxx17_backports.h"
+#include "base/format_macros.h"
+#include "base/i18n/break_iterator.h"
+#include "base/i18n/char_iterator.h"
+#include "base/logging.h"
+#include "base/run_loop.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/test/task_environment.h"
+#include "build/build_config.h"
+#include "cc/paint/paint_record.h"
+#include "cc/paint/paint_recorder.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkFontStyle.h"
+#include "third_party/skia/include/core/SkSurface.h"
+#include "third_party/skia/include/core/SkTextBlob.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "ui/gfx/break_list.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/decorated_text.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_names_testing.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/range/range.h"
+#include "ui/gfx/range/range_f.h"
+#include "ui/gfx/render_text_harfbuzz.h"
+#include "ui/gfx/render_text_test_api.h"
+#include "ui/gfx/switches.h"
+#include "ui/gfx/text_elider.h"
+#include "ui/gfx/text_utils.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+
+#include "base/win/windows_version.h"
+#endif
+
+#if defined(OS_APPLE)
+#include "base/mac/mac_util.h"
+#endif
+
+namespace gfx {
+
+namespace {
+
+// Various weak, LTR, RTL, and Bidi string cases with three characters each.
+const char16_t kWeak[] = u" . ";
+const char16_t kLtr[] = u"abc";
+const char16_t kRtl[] = u"אבג";
+const char16_t kLtrRtl[] = u"aאב";
+const char16_t kLtrRtlLtr[] = u"aבb";
+const char16_t kRtlLtr[] = u"אבa";
+const char16_t kRtlLtrRtl[] = u"אaב";
+
+constexpr bool kUseWordWrap = true;
+constexpr bool kUseObscuredText = true;
+
+// Bitmasks based on gfx::TextStyle.
+enum {
+  ITALIC_MASK = 1 << TEXT_STYLE_ITALIC,
+  STRIKE_MASK = 1 << TEXT_STYLE_STRIKE,
+  UNDERLINE_MASK = 1 << TEXT_STYLE_UNDERLINE,
+};
+
+using FontSpan = std::pair<Font, Range>;
+
+bool IsFontsSmoothingEnabled() {
+#if defined(OS_WIN)
+  BOOL antialiasing = TRUE;
+  BOOL result = SystemParametersInfo(SPI_GETFONTSMOOTHING, 0, &antialiasing, 0);
+  if (result == FALSE) {
+    ADD_FAILURE() << "Failed to retrieve font aliasing configuration.";
+  }
+  return antialiasing;
+#else
+  return true;
+#endif
+}
+
+// Checks whether |range| contains |index|. This is not the same as calling
+// range.Contains(Range(index)), which returns true if |index| == |range.end()|.
+bool IndexInRange(const Range& range, size_t index) {
+  return index >= range.start() && index < range.end();
+}
+
+std::u16string GetSelectedText(RenderText* render_text) {
+  return render_text->text().substr(render_text->selection().GetMin(),
+                                    render_text->selection().length());
+}
+
+// A test utility function to set the application default text direction.
+void SetRTL(bool rtl) {
+  // Override the current locale/direction.
+  base::i18n::SetICUDefaultLocale(rtl ? "he" : "en");
+  EXPECT_EQ(rtl, base::i18n::IsRTL());
+}
+
+// Execute MoveCursor on the given |render_text| instance for the given
+// arguments and verify the selected range matches |expected|. Also, clears the
+// expectations.
+void RunMoveCursorTestAndClearExpectations(RenderText* render_text,
+                                           BreakType break_type,
+                                           VisualCursorDirection direction,
+                                           SelectionBehavior selection_behavior,
+                                           std::vector<Range>* expected) {
+  for (size_t i = 0; i < expected->size(); ++i) {
+    SCOPED_TRACE(base::StringPrintf(
+        "BreakType-%d VisualCursorDirection-%d SelectionBehavior-%d Case-%d.",
+        break_type, direction, selection_behavior, static_cast<int>(i)));
+
+    render_text->MoveCursor(break_type, direction, selection_behavior);
+    EXPECT_EQ(expected->at(i), render_text->selection());
+  }
+  expected->clear();
+}
+
+// Execute MoveCursor on the given |render_text| instance for the given
+// arguments and verify the line matches |expected|. Also, clears the
+// expectations.
+void RunMoveCursorTestAndClearExpectations(RenderText* render_text,
+                                           BreakType break_type,
+                                           VisualCursorDirection direction,
+                                           SelectionBehavior selection_behavior,
+                                           std::vector<size_t>* expected) {
+  int case_index = 0;
+  for (auto expected_line : *expected) {
+    SCOPED_TRACE(testing::Message()
+                 << "Text: " << render_text->text() << " BreakType: "
+                 << break_type << " VisualCursorDirection: " << direction
+                 << " SelectionBehavior: " << selection_behavior
+                 << " Case: " << case_index++);
+    render_text->MoveCursor(break_type, direction, selection_behavior);
+    EXPECT_EQ(expected_line, render_text->GetLineContainingCaret(
+                                 render_text->selection_model()));
+  }
+  expected->clear();
+}
+
+// Ensure cursor movement in the specified |direction| yields |expected| values.
+void RunMoveCursorLeftRightTest(RenderText* render_text,
+                                const std::vector<SelectionModel>& expected,
+                                VisualCursorDirection direction) {
+  for (size_t i = 0; i < expected.size(); ++i) {
+    SCOPED_TRACE(base::StringPrintf("Going %s; expected value index %d.",
+        direction == CURSOR_LEFT ? "left" : "right", static_cast<int>(i)));
+    EXPECT_EQ(expected[i], render_text->selection_model());
+    render_text->MoveCursor(CHARACTER_BREAK, direction, SELECTION_NONE);
+  }
+  // Check that cursoring is clamped at the line edge.
+  EXPECT_EQ(expected.back(), render_text->selection_model());
+  // Check that it is the line edge.
+  render_text->MoveCursor(LINE_BREAK, direction, SELECTION_NONE);
+  EXPECT_EQ(expected.back(), render_text->selection_model());
+}
+
+// Creates a RangedAttribute instance for a single character range at the
+// given |index| with the given |weight| and |style_mask|. |index| is the
+// index of the character in the DecoratedText instance and |font_index| is
+// used to retrieve the font used from |font_spans|.
+DecoratedText::RangedAttribute CreateRangedAttribute(
+    const std::vector<FontSpan>& font_spans,
+    int index,
+    int font_index,
+    Font::Weight weight,
+    int style_mask) {
+  const auto iter = std::find_if(font_spans.cbegin(), font_spans.cend(),
+                                 [font_index](const FontSpan& span) {
+                                   return IndexInRange(span.second, font_index);
+                                 });
+  DCHECK(font_spans.end() != iter);
+  const Font& font = iter->first;
+
+  int font_style = Font::NORMAL;
+  if (style_mask & ITALIC_MASK)
+    font_style |= Font::ITALIC;
+  if (style_mask & UNDERLINE_MASK)
+    font_style |= Font::UNDERLINE;
+
+  const Font font_with_style = font.Derive(0, font_style, weight);
+  DecoratedText::RangedAttribute attributes(Range(index, index + 1),
+                                            font_with_style);
+  attributes.strike = style_mask & STRIKE_MASK;
+  return attributes;
+}
+
+// Verifies the given DecoratedText instances are equal by comparing the
+// respective strings and attributes for each index. Note, corresponding
+// ranged attributes from |expected| and |actual| can't be compared since the
+// partition of |actual| into RangedAttributes will depend on the text runs
+// generated.
+void VerifyDecoratedWordsAreEqual(const DecoratedText& expected,
+                                  const DecoratedText& actual) {
+  ASSERT_EQ(expected.text, actual.text);
+
+  // Compare attributes for each index.
+  for (size_t i = 0; i < expected.text.length(); i++) {
+    SCOPED_TRACE(base::StringPrintf("Comparing index[%" PRIuS "]", i));
+    auto find_attribute_func = [i](const DecoratedText::RangedAttribute& attr) {
+      return IndexInRange(attr.range, i);
+    };
+    const auto expected_attr =
+        std::find_if(expected.attributes.begin(), expected.attributes.end(),
+                     find_attribute_func);
+    const auto actual_attr =
+        std::find_if(actual.attributes.begin(), actual.attributes.end(),
+                     find_attribute_func);
+    ASSERT_NE(expected.attributes.end(), expected_attr);
+    ASSERT_NE(actual.attributes.end(), actual_attr);
+
+    EXPECT_EQ(expected_attr->strike, actual_attr->strike);
+    EXPECT_EQ(expected_attr->font.GetFontName(),
+              actual_attr->font.GetFontName());
+    EXPECT_EQ(expected_attr->font.GetFontSize(),
+              actual_attr->font.GetFontSize());
+    EXPECT_EQ(expected_attr->font.GetWeight(), actual_attr->font.GetWeight());
+    EXPECT_EQ(expected_attr->font.GetStyle(), actual_attr->font.GetStyle());
+  }
+}
+
+// Helper method to return an obscured string of the given |length|, with the
+// |reveal_index| filled with |reveal_char|.
+std::u16string GetObscuredString(size_t length,
+                                 size_t reveal_index,
+                                 char16_t reveal_char) {
+  std::vector<char16_t> arr(length, RenderText::kPasswordReplacementChar);
+  arr[reveal_index] = reveal_char;
+  return std::u16string(arr.begin(), arr.end());
+}
+
+// Helper method to return an obscured string of the given |length|.
+std::u16string GetObscuredString(size_t length) {
+  return std::u16string(length, RenderText::kPasswordReplacementChar);
+}
+
+// Returns the combined character range from all text runs on |line|.
+Range LineCharRange(const internal::Line& line) {
+  if (line.segments.empty())
+    return Range();
+  Range ltr(line.segments.front().char_range.start(),
+            line.segments.back().char_range.end());
+  if (ltr.end() > ltr.start())
+    return ltr;
+
+  // For RTL, the order of segments is reversed, but the ranges are not.
+  return Range(line.segments.back().char_range.start(),
+               line.segments.front().char_range.end());
+}
+
+struct GlyphCountAndColor {
+  size_t glyph_count = 0;
+  SkColor color = kPlaceholderColor;
+};
+
+class TextLog {
+ public:
+  TextLog(PointF origin, std::vector<uint16_t> glyphs, SkColor color)
+      : origin_(origin), glyphs_(glyphs), color_(color) {}
+  TextLog(const TextLog&) = default;
+
+  PointF origin() const { return origin_; }
+  SkColor color() const { return color_; }
+  const std::vector<uint16_t>& glyphs() const { return glyphs_; }
+
+ private:
+  const PointF origin_;
+  const std::vector<uint16_t> glyphs_;
+  const SkColor color_ = SK_ColorTRANSPARENT;
+};
+
+// The class which records the drawing operations so that the test case can
+// verify where exactly the glyphs are drawn.
+class TestSkiaTextRenderer : public internal::SkiaTextRenderer {
+ public:
+  explicit TestSkiaTextRenderer(Canvas* canvas)
+      : internal::SkiaTextRenderer(canvas) {}
+
+  TestSkiaTextRenderer(const TestSkiaTextRenderer&) = delete;
+  TestSkiaTextRenderer& operator=(const TestSkiaTextRenderer&) = delete;
+
+  ~TestSkiaTextRenderer() override {}
+
+  void GetTextLogAndReset(std::vector<TextLog>* text_log) {
+    text_log_.swap(*text_log);
+    text_log_.clear();
+  }
+
+ private:
+  // internal::SkiaTextRenderer overrides:
+  void DrawPosText(const SkPoint* pos,
+                   const uint16_t* glyphs,
+                   size_t glyph_count) override {
+    if (glyph_count) {
+      PointF origin =
+          PointF(SkScalarToFloat(pos[0].x()), SkScalarToFloat(pos[0].y()));
+      for (size_t i = 1U; i < glyph_count; ++i) {
+        origin.SetToMin(
+            PointF(SkScalarToFloat(pos[i].x()), SkScalarToFloat(pos[i].y())));
+      }
+      std::vector<uint16_t> run_glyphs(glyphs, glyphs + glyph_count);
+      SkColor color =
+          test::RenderTextTestApi::GetRendererPaint(this).getColor();
+      text_log_.push_back(TextLog(origin, std::move(run_glyphs), color));
+    }
+
+    internal::SkiaTextRenderer::DrawPosText(pos, glyphs, glyph_count);
+  }
+
+  std::vector<TextLog> text_log_;
+};
+
+class TestRenderTextCanvas : public SkCanvas {
+ public:
+  TestRenderTextCanvas(int width, int height) : SkCanvas(width, height) {}
+
+  // SkCanvas overrides:
+  void onDrawTextBlob(const SkTextBlob* blob,
+                      SkScalar x,
+                      SkScalar y,
+                      const SkPaint& paint) override {
+    PointF origin = PointF(SkScalarToFloat(x), SkScalarToFloat(y));
+    std::vector<uint16_t> glyphs;
+    if (blob) {
+      SkTextBlob::Iter::Run run;
+      for (SkTextBlob::Iter it(*blob); it.next(&run);) {
+        auto run_glyphs =
+            base::span<const uint16_t>(run.fGlyphIndices, run.fGlyphCount);
+        glyphs.insert(glyphs.end(), run_glyphs.begin(), run_glyphs.end());
+      }
+    }
+    text_log_.push_back(TextLog(origin, std::move(glyphs), paint.getColor()));
+
+    SkCanvas::onDrawTextBlob(blob, x, y, paint);
+  }
+
+  void GetTextLogAndReset(std::vector<TextLog>* text_log) {
+    text_log_.swap(*text_log);
+    text_log_.clear();
+  }
+
+  const std::vector<TextLog>& text_log() const { return text_log_; }
+
+ private:
+  std::vector<TextLog> text_log_;
+};
+
+// Given a buffer to test against, this can be used to test various areas of the
+// rectangular buffer against a specific color value.
+class TestRectangleBuffer {
+ public:
+  TestRectangleBuffer(const char* string,
+                      const SkColor* buffer,
+                      uint32_t stride,
+                      uint32_t row_count)
+      : string_(string),
+        buffer_(buffer),
+        stride_(stride),
+        row_count_(row_count) {}
+
+  TestRectangleBuffer(const TestRectangleBuffer&) = delete;
+  TestRectangleBuffer& operator=(const TestRectangleBuffer&) = delete;
+
+  // Test if any values in the rectangular area are anything other than |color|.
+  void EnsureSolidRect(SkColor color,
+                       int left,
+                       int top,
+                       int width,
+                       int height) const {
+    ASSERT_LT(top, row_count_) << string_;
+    ASSERT_LE(top + height, row_count_) << string_;
+    ASSERT_LT(left, stride_) << string_;
+    ASSERT_LE(left + width, stride_) << string_ << ", left " << left
+                                     << ", width " << width << ", stride_ "
+                                     << stride_;
+    for (int y = top; y < top + height; ++y) {
+      for (int x = left; x < left + width; ++x) {
+        SkColor buffer_color = buffer_[x + y * stride_];
+        EXPECT_EQ(color, buffer_color) << string_ << " at " << x << ", " << y;
+      }
+    }
+  }
+
+  // Test that the rect defined by |left|, |top|, |width| and |height| is filled
+  // with the same color.
+  void EnsureRectIsAllSameColor(int left,
+                                int top,
+                                int width,
+                                int height) const {
+    SkColor buffer_color = buffer_[left + top * stride_];
+    EnsureSolidRect(buffer_color, left, top, width, height);
+  }
+
+ private:
+  const char* string_;
+  const SkColor* buffer_;
+  int stride_;
+  int row_count_;
+};
+
+}  // namespace
+
+// Test fixture class used to run parameterized tests for all RenderText
+// implementations.
+class RenderTextTest : public testing::Test {
+ public:
+  RenderTextTest()
+      : task_environment_(
+            base::test::SingleThreadTaskEnvironment::MainThreadType::UI),
+        render_text_(std::make_unique<RenderTextHarfBuzz>()),
+        test_api_(new test::RenderTextTestApi(render_text_.get())),
+        renderer_(canvas()) {}
+
+  RenderTextTest(const RenderTextTest&) = delete;
+  RenderTextTest& operator=(const RenderTextTest&) = delete;
+
+ protected:
+  const cc::PaintFlags& GetRendererPaint() {
+    return test::RenderTextTestApi::GetRendererPaint(renderer());
+  }
+
+  const SkFont& GetRendererFont() {
+    return test::RenderTextTestApi::GetRendererFont(renderer());
+  }
+
+  void DrawVisualText(const std::vector<Range> selections = {}) {
+    test_api()->EnsureLayout();
+    test_api()->DrawVisualText(renderer(), selections);
+    renderer()->GetTextLogAndReset(&text_log_);
+  }
+
+  void Draw(bool select_all = false) {
+    constexpr int kCanvasWidth = 1200;
+    constexpr int kCanvasHeight = 400;
+
+    cc::PaintRecorder recorder;
+    Canvas canvas(recorder.beginRecording(kCanvasWidth, kCanvasHeight), 1.0f);
+    test_api_->Draw(&canvas, select_all);
+    sk_sp<cc::PaintRecord> record = recorder.finishRecordingAsPicture();
+
+    TestRenderTextCanvas test_canvas(kCanvasWidth, kCanvasHeight);
+    record->Playback(&test_canvas);
+
+    test_canvas.GetTextLogAndReset(&text_log_);
+  }
+
+  internal::TextRunList* GetHarfBuzzRunList() {
+    test_api()->EnsureLayout();
+    return test_api()->GetHarfBuzzRunList();
+  }
+
+  // For testing purposes, returns which fonts were chosen for which parts of
+  // the text by returning a vector of Font and Range pairs, where each range
+  // specifies the character range for which the corresponding font has been
+  // chosen.
+  std::vector<FontSpan> GetFontSpans() {
+    test_api()->EnsureLayout();
+
+    const internal::TextRunList* run_list = GetHarfBuzzRunList();
+    std::vector<FontSpan> spans;
+    std::transform(
+        run_list->runs().begin(), run_list->runs().end(),
+        std::back_inserter(spans), [this](const auto& run) {
+          return FontSpan(
+              run->font_params.font,
+              Range(test_api()->DisplayIndexToTextIndex(run->range.start()),
+                    test_api()->DisplayIndexToTextIndex(run->range.end())));
+        });
+
+    return spans;
+  }
+
+  // Converts the current run list into a human-readable string. Can be used in
+  // test assertions for a readable expectation and failure message.
+  //
+  // The string shows the runs in visual order. Each run is enclosed in square
+  // brackets, and shows the begin and end inclusive logical character position,
+  // with an arrow indicating the direction of the run. Single-character runs
+  // just show the character position.
+  //
+  // For example, the the logical bidirectional string "abc+\u05d0\u05d1\u05d2"
+  // (visual string: "abc+אבג") yields "[0->2][3][6<-4]".
+  std::string GetRunListStructureString() {
+    test_api()->EnsureLayout();
+
+    const internal::TextRunList* run_list = GetHarfBuzzRunList();
+    std::string result;
+    for (size_t i = 0; i < run_list->size(); ++i) {
+      size_t logical_index = run_list->visual_to_logical(i);
+      const internal::TextRunHarfBuzz& run = *run_list->runs()[logical_index];
+      if (run.range.length() == 1) {
+        result.append(base::StringPrintf("[%d]", run.range.start()));
+      } else if (run.font_params.is_rtl) {
+        result.append(base::StringPrintf("[%d<-%d]", run.range.end() - 1,
+                                         run.range.start()));
+      } else {
+        result.append(base::StringPrintf("[%d->%d]", run.range.start(),
+                                         run.range.end() - 1));
+      }
+    }
+    return result;
+  }
+
+  // Returns a vector of text fragments corresponding to the current list of
+  // text runs.
+  std::vector<std::u16string> GetRunListStrings() {
+    std::vector<std::u16string> runs_as_text;
+    for (const auto& span : GetFontSpans()) {
+      runs_as_text.push_back(render_text_->text().substr(span.second.GetMin(),
+                                                         span.second.length()));
+    }
+    return runs_as_text;
+  }
+
+  // Sets the text to |text|, then returns GetRunListStrings().
+  std::vector<std::u16string> RunsFor(const std::u16string& text) {
+    render_text_->SetText(text);
+    test_api()->EnsureLayout();
+    return GetRunListStrings();
+  }
+
+  void ResetRenderTextInstance() {
+    render_text_ = std::make_unique<RenderTextHarfBuzz>();
+    test_api_ = std::make_unique<test::RenderTextTestApi>(GetRenderText());
+  }
+
+  void ResetCursorX() { test_api()->reset_cached_cursor_x(); }
+
+  int GetLineContainingYCoord(float text_y) {
+    return test_api()->GetLineContainingYCoord(text_y);
+  }
+
+  RenderTextHarfBuzz* GetRenderText() { return render_text_.get(); }
+
+  Rect GetSubstringBoundsUnion(const Range& range) {
+    const std::vector<Rect> bounds = render_text_->GetSubstringBounds(range);
+    return std::accumulate(
+        bounds.begin(), bounds.end(), Rect(),
+        [](const Rect& a, const Rect& b) { return UnionRects(a, b); });
+  }
+
+  Rect GetSelectionBoundsUnion() {
+    return GetSubstringBoundsUnion(render_text_->selection());
+  }
+
+  // Checks left-to-right text, ensuring that the caret moves to the right as
+  // the cursor position increments through the logical text. Also ensures that
+  // each glyph is to the right of the prior glyph. RenderText automatically
+  // updates invalid cursor positions (eg. between a surrogate pair) to a valid
+  // neighbor, so the positions may be unchanged for some iterations. Invoking
+  // this in a test gives coverage of the sanity checks in functions such as
+  // TextRunHarfBuzz::GetGraphemeBounds() which rely on sensible glyph positions
+  // being provided by installed typefaces.
+  void CheckBoundsForCursorPositions() {
+    ASSERT_FALSE(render_text_->text().empty());
+
+    // Use a wide display rect to avoid scrolling.
+    render_text_->SetDisplayRect(gfx::Rect(0, 0, 1000, 50));
+    EXPECT_LT(render_text_->GetContentWidthF(),
+              render_text_->display_rect().width());
+
+    // Assume LTR for now.
+    int max_cursor_x = 0;
+    int max_glyph_x = 0, max_glyph_right = 0;
+
+    for (size_t i = 0; i <= render_text_->text().size(); ++i) {
+      render_text_->SetCursorPosition(i);
+
+      SCOPED_TRACE(testing::Message()
+                   << "Cursor position: " << i
+                   << " selection: " << render_text_->selection().ToString());
+
+      const gfx::Rect cursor_bounds = render_text_->GetUpdatedCursorBounds();
+
+      // The cursor should always be one pixel wide.
+      EXPECT_EQ(1, cursor_bounds.width());
+      EXPECT_LE(max_cursor_x, cursor_bounds.x());
+      max_cursor_x = cursor_bounds.x();
+
+      const gfx::Rect glyph_bounds =
+          render_text_->GetCursorBounds(render_text_->selection_model(), false);
+      EXPECT_LE(max_glyph_x, glyph_bounds.x());
+      EXPECT_LE(max_glyph_right, glyph_bounds.right());
+      max_glyph_x = glyph_bounds.x();
+      max_glyph_right = glyph_bounds.right();
+    }
+  }
+
+  void SetGlyphWidth(float test_width) {
+    test_api()->SetGlyphWidth(test_width);
+  }
+
+  void SetGlyphHeight(float test_height) {
+    test_api()->SetGlyphHeight(test_height);
+  }
+
+  bool ShapeRunWithFont(const std::u16string& text,
+                        const Font& font,
+                        const FontRenderParams& render_params,
+                        internal::TextRunHarfBuzz* run) {
+    internal::TextRunHarfBuzz::FontParams font_params = run->font_params;
+    font_params.ComputeRenderParamsFontSizeAndBaselineOffset();
+    font_params.SetRenderParamsRematchFont(font, render_params);
+    run->shape.missing_glyph_count = static_cast<size_t>(-1);
+    std::vector<internal::TextRunHarfBuzz*> runs = {run};
+    GetRenderText()->ShapeRunsWithFont(text, font_params, &runs);
+    return runs.empty();
+  }
+
+  int GetCursorYForTesting(int line_num = 0) {
+    return GetRenderText()->GetLineOffset(line_num).y() + 1;
+  }
+
+  size_t GetLineContainingCaret() {
+    return GetRenderText()->GetLineContainingCaret(
+        GetRenderText()->selection_model());
+  }
+
+  Canvas* canvas() { return &canvas_; }
+  TestSkiaTextRenderer* renderer() { return &renderer_; }
+  test::RenderTextTestApi* test_api() { return test_api_.get(); }
+  const test::RenderTextTestApi* test_api() const { return test_api_.get(); }
+  const std::vector<TextLog>& text_log() const { return text_log_; }
+
+  void ExpectTextLog(std::vector<GlyphCountAndColor> runs) {
+    EXPECT_EQ(runs.size(), text_log_.size());
+    const size_t min_size = std::min(runs.size(), text_log_.size());
+    for (size_t i = 0; i < min_size; ++i) {
+      SCOPED_TRACE(testing::Message()
+                   << "ExpectTextLog, run " << i << " of " << runs.size());
+      EXPECT_EQ(runs[i].color, text_log_[i].color());
+      EXPECT_EQ(runs[i].glyph_count, text_log_[i].glyphs().size());
+    }
+  }
+
+ private:
+  // Needed to bypass DCHECK in GetFallbackFont.
+  base::test::SingleThreadTaskEnvironment task_environment_;
+
+  std::unique_ptr<RenderTextHarfBuzz> render_text_;
+  std::unique_ptr<test::RenderTextTestApi> test_api_;
+  std::vector<TextLog> text_log_;
+  Canvas canvas_;
+  TestSkiaTextRenderer renderer_;
+};
+
+TEST_F(RenderTextTest, DefaultStyles) {
+  // Check the default styles applied to new instances and adjusted text.
+  RenderText* render_text = GetRenderText();
+  EXPECT_TRUE(render_text->text().empty());
+  const char16_t* const cases[] = {kWeak, kLtr, u"Hello", kRtl, u"", u""};
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    EXPECT_TRUE(test_api()->colors().EqualsValueForTesting(kPlaceholderColor));
+    EXPECT_TRUE(test_api()->baselines().EqualsValueForTesting(NORMAL_BASELINE));
+    EXPECT_TRUE(test_api()->font_size_overrides().EqualsValueForTesting(0));
+    for (size_t style = 0; style < static_cast<int>(TEXT_STYLE_COUNT); ++style)
+      EXPECT_TRUE(test_api()->styles()[style].EqualsValueForTesting(false));
+    render_text->SetText(cases[i]);
+  }
+}
+
+TEST_F(RenderTextTest, SetStyles) {
+  // Ensure custom default styles persist across setting and clearing text.
+  RenderText* render_text = GetRenderText();
+  const SkColor color = SK_ColorGREEN;
+  render_text->SetColor(color);
+  render_text->SetBaselineStyle(SUPERSCRIPT);
+  render_text->SetWeight(Font::Weight::BOLD);
+  render_text->SetStyle(TEXT_STYLE_UNDERLINE, false);
+  const char16_t* const cases[] = {kWeak, kLtr, u"Hello", kRtl, u"", u""};
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    EXPECT_TRUE(test_api()->colors().EqualsValueForTesting(color));
+    EXPECT_TRUE(test_api()->baselines().EqualsValueForTesting(SUPERSCRIPT));
+    EXPECT_TRUE(
+        test_api()->weights().EqualsValueForTesting(Font::Weight::BOLD));
+    EXPECT_TRUE(
+        test_api()->styles()[TEXT_STYLE_UNDERLINE].EqualsValueForTesting(
+            false));
+    render_text->SetText(cases[i]);
+
+    // Ensure custom default styles can be applied after text has been set.
+    if (i == 1)
+      render_text->SetStyle(TEXT_STYLE_STRIKE, true);
+    if (i >= 1)
+      EXPECT_TRUE(
+          test_api()->styles()[TEXT_STYLE_STRIKE].EqualsValueForTesting(true));
+  }
+}
+
+TEST_F(RenderTextTest, ApplyStyles) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"012345678");
+
+  constexpr int kTestFontSizeOverride = 20;
+
+  // Apply a ranged color and style and check the resulting breaks.
+  render_text->ApplyColor(SK_ColorGREEN, Range(1, 4));
+  render_text->ApplyBaselineStyle(SUPERIOR, Range(2, 4));
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(2, 5));
+  render_text->ApplyFontSizeOverride(kTestFontSizeOverride, Range(5, 7));
+
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting(
+      {{0, kPlaceholderColor}, {1, SK_ColorGREEN}, {4, kPlaceholderColor}}));
+
+  EXPECT_TRUE(test_api()->baselines().EqualsForTesting(
+      {{0, NORMAL_BASELINE}, {2, SUPERIOR}, {4, NORMAL_BASELINE}}));
+
+  EXPECT_TRUE(test_api()->font_size_overrides().EqualsForTesting(
+      {{0, 0}, {5, kTestFontSizeOverride}, {7, 0}}));
+
+  EXPECT_TRUE(
+      test_api()->weights().EqualsForTesting({{0, Font::Weight::NORMAL},
+                                              {2, Font::Weight::BOLD},
+                                              {5, Font::Weight::NORMAL}}));
+
+  // Ensure that setting a value overrides the ranged values.
+  render_text->SetColor(SK_ColorBLUE);
+  EXPECT_TRUE(test_api()->colors().EqualsValueForTesting(SK_ColorBLUE));
+  render_text->SetBaselineStyle(SUBSCRIPT);
+  EXPECT_TRUE(test_api()->baselines().EqualsValueForTesting(SUBSCRIPT));
+  render_text->SetWeight(Font::Weight::NORMAL);
+  EXPECT_TRUE(
+      test_api()->weights().EqualsValueForTesting(Font::Weight::NORMAL));
+
+  // Apply a value over the text end and check the resulting breaks (INT_MAX
+  // should be used instead of the text length for the range end)
+  const size_t text_length = render_text->text().length();
+  render_text->ApplyColor(SK_ColorGREEN, Range(0, text_length));
+  render_text->ApplyBaselineStyle(SUPERIOR, Range(0, text_length));
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(2, text_length));
+
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting({{0, SK_ColorGREEN}}));
+  EXPECT_TRUE(test_api()->baselines().EqualsForTesting({{0, SUPERIOR}}));
+  EXPECT_TRUE(test_api()->weights().EqualsForTesting(
+      {{0, Font::Weight::NORMAL}, {2, Font::Weight::BOLD}}));
+
+  // Ensure ranged values adjust to accommodate text length changes.
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(0, 2));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(3, 6));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(7, text_length));
+  std::vector<std::pair<size_t, bool>> expected_italic = {
+      {0, true}, {2, false}, {3, true}, {6, false}, {7, true}};
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_ITALIC].EqualsForTesting(
+      expected_italic));
+
+  // Changing the text should clear any breaks except for the first one.
+  render_text->SetText(u"0123456");
+  expected_italic.resize(1);
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_ITALIC].EqualsForTesting(
+      expected_italic));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, false, Range(2, 4));
+  render_text->SetText(u"012345678");
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_ITALIC].EqualsForTesting(
+      expected_italic));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, false, Range(0, 1));
+  render_text->SetText(u"0123456");
+  expected_italic.begin()->second = false;
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_ITALIC].EqualsForTesting(
+      expected_italic));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(2, 4));
+  render_text->SetText(u"012345678");
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_ITALIC].EqualsForTesting(
+      expected_italic));
+
+  // Styles mid-grapheme should work. Style of first character of the grapheme
+  // is used.
+  render_text->SetText(u"0\u0915\u093f1\u0915\u093f2");
+  render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, Range(2, 5));
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_UNDERLINE].EqualsForTesting(
+      {{0, false}, {2, true}, {5, false}}));
+}
+
+TEST_F(RenderTextTest, ApplyStyleSurrogatePair) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"x\U0001F601x");
+  // Apply the style in the middle of a surrogate pair. The style should be
+  // applied to the whole range of the codepoint.
+  gfx::Range range(2, 3);
+  render_text->ApplyWeight(gfx::Font::Weight::BOLD, range);
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, range);
+  render_text->ApplyColor(SK_ColorGREEN, range);
+  render_text->Draw(canvas());
+
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_ITALIC].EqualsForTesting(
+      {{0, false}, {2, true}, {3, false}}));
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting(
+      {{0, kPlaceholderColor}, {2, SK_ColorGREEN}, {3, kPlaceholderColor}}));
+  EXPECT_TRUE(
+      test_api()->weights().EqualsForTesting({{0, Font::Weight::NORMAL},
+                                              {2, Font::Weight::BOLD},
+                                              {3, Font::Weight::NORMAL}}));
+}
+
+TEST_F(RenderTextTest, ApplyStyleGrapheme) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"e\u0301");
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, gfx::Range(1, 2));
+  render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, gfx::Range(0, 1));
+  Draw();
+
+  // Ensures that the whole grapheme is drawn with the same style.
+  ExpectTextLog({{1}});
+}
+
+TEST_F(RenderTextTest, ApplyStyleMultipleGraphemes) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"xxe\u0301x");
+  // Apply the style in the middle of a grapheme.
+  gfx::Range range(1, 3);
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, range);
+  Draw();
+
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_ITALIC].EqualsForTesting(
+      {{0, false}, {1, true}, {3, false}}));
+
+  // Ensures that the style of the grapheme is the style at its first character.
+  ExpectTextLog({{1}, {2}, {1}});
+}
+
+TEST_F(RenderTextTest, ApplyColorSurrogatePair) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"x\U0001F601x");
+  render_text->ApplyColor(SK_ColorGREEN, Range(2, 3));
+  Draw();
+
+  // Ensures that the color is not applied since it is in the middle of a
+  // surrogate pair.
+  // There is three runs since the codepoints are not in the same script.
+  ExpectTextLog({{1}, {1}, {1}});
+
+  // Obscure the text should renders characters with the same colors.
+  render_text->SetObscured(true);
+  Draw();
+  ExpectTextLog({{3}});
+}
+
+TEST_F(RenderTextTest, ApplyColorLongEmoji) {
+  // A long emoji sequence.
+  static const char16_t kLongEmoji[] = u"\U0001F468\u200D\u2708\uFE0F";
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(kLongEmoji);
+  render_text->AppendText(kLongEmoji);
+  render_text->AppendText(kLongEmoji);
+
+  render_text->ApplyColor(SK_ColorGREEN, Range(0, 2));
+  render_text->ApplyColor(SK_ColorBLUE, Range(8, 13));
+  Draw();
+
+  // Ensures that the color of the emoji is the color at its first character.
+  ASSERT_EQ(3u, text_log().size());
+  EXPECT_EQ(SK_ColorGREEN, text_log()[0].color());
+  EXPECT_EQ(kPlaceholderColor, text_log()[1].color());
+  EXPECT_EQ(SK_ColorBLUE, text_log()[2].color());
+
+  // Reset the color.
+  render_text->SetColor(SK_ColorBLACK);
+  Draw();
+
+  // The amount of glyphs depend on the font. If the font supports the emoji,
+  // the amount of glyph is 1, otherwise it vary.
+  ASSERT_EQ(1u, text_log().size());
+  EXPECT_EQ(SK_ColorBLACK, text_log()[0].color());
+}
+
+TEST_F(RenderTextTest, ApplyColorObscuredEmoji) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"\U0001F628\U0001F628\U0001F628");
+  render_text->ApplyColor(SK_ColorGREEN, Range(0, 2));
+  render_text->ApplyColor(SK_ColorBLUE, Range(4, 5));
+
+  const std::vector<GlyphCountAndColor> kExpectedTextLog = {
+      {1, SK_ColorGREEN}, {1, kPlaceholderColor}, {1, SK_ColorBLUE}};
+
+  // Ensures that colors are applied.
+  Draw();
+  ExpectTextLog(kExpectedTextLog);
+
+  // Obscure the text.
+  render_text->SetObscured(true);
+
+  // The obscured text (layout text) no longer contains surrogate pairs.
+  EXPECT_EQ(render_text->text().size(), 2 * test_api()->GetLayoutText().size());
+
+  // Obscured text should give the same colors.
+  Draw();
+  ExpectTextLog(kExpectedTextLog);
+
+  for (size_t i = 0; i < render_text->text().size(); ++i) {
+    render_text->RenderText::SetObscuredRevealIndex(i);
+
+    // Revealed codepoints should give the same colors.
+    Draw();
+    ExpectTextLog(kExpectedTextLog);
+  }
+}
+
+TEST_F(RenderTextTest, ApplyColorArabicDiacritics) {
+  // Render an Arabic character with two diacritics. The color should be taken
+  // from the base character.
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"\u0628\u0651\u0650");
+  render_text->ApplyColor(SK_ColorGREEN, Range(0, 1));
+  render_text->ApplyColor(SK_ColorBLACK, Range(1, 2));
+  render_text->ApplyColor(SK_ColorBLUE, Range(2, 3));
+  Draw();
+  ASSERT_EQ(1u, text_log().size());
+  EXPECT_EQ(SK_ColorGREEN, text_log()[0].color());
+}
+
+TEST_F(RenderTextTest, ApplyColorArabicLigature) {
+  // In Arabic, letters of each word join together whenever possible. During
+  // the shaping pass of the font, characters will take their joining form:
+  // Isolated, Initial, Medial or Final.
+
+  // Render the isolated form of the first glyph.
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"ب");
+  Draw();
+  ASSERT_EQ(1u, text_log().size());
+  ASSERT_EQ(1u, text_log()[0].glyphs().size());
+  uint16_t isolated_first_glyph = text_log()[0].glyphs()[0];
+
+  // Render a pair of glyphs (initial form and final form).
+  render_text->SetText(u"بم");
+  Draw();
+  ASSERT_EQ(1u, text_log().size());
+  ASSERT_LE(2u, text_log()[0].glyphs().size());
+  uint16_t initial_first_glyph = text_log()[0].glyphs()[0];
+  uint16_t final_second_glyph = text_log()[0].glyphs()[1];
+
+  // A ligature is applied between glyphs and the two glyphs (isolated and
+  // initial form) are displayed differently.
+  EXPECT_NE(isolated_first_glyph, initial_first_glyph);
+
+  // Ensures that both characters didn't merge in a single glyph.
+  EXPECT_NE(initial_first_glyph, final_second_glyph);
+
+  // Applying color should not break the ligature.
+  // see: https://w3c.github.io/alreq/#h_styling_individual_letters
+  render_text->ApplyColor(SK_ColorGREEN, Range(0, 1));
+  render_text->ApplyColor(SK_ColorBLACK, Range(1, 2));
+  Draw();
+  ASSERT_EQ(2u, text_log().size());
+  ASSERT_LE(1u, text_log()[0].glyphs().size());
+  ASSERT_EQ(1u, text_log()[1].glyphs().size());
+  uint16_t colored_first_glyph = text_log()[1].glyphs()[0];
+  uint16_t colored_second_glyph = text_log()[0].glyphs()[0];
+
+  // Glyphs should be the same with and without color.
+  EXPECT_EQ(initial_first_glyph, colored_first_glyph);
+  EXPECT_EQ(final_second_glyph, colored_second_glyph);
+
+  // Colors should be applied.
+  EXPECT_EQ(SK_ColorGREEN, text_log()[0].color());
+  EXPECT_EQ(SK_ColorBLACK, text_log()[1].color());
+}
+
+TEST_F(RenderTextTest, AppendTextKeepsStyles) {
+  RenderText* render_text = GetRenderText();
+  // Setup basic functionality.
+  render_text->SetText(u"abcd");
+  render_text->ApplyColor(SK_ColorGREEN, Range(0, 1));
+  render_text->ApplyBaselineStyle(SUPERSCRIPT, Range(1, 2));
+  render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, Range(2, 3));
+  render_text->ApplyFontSizeOverride(20, Range(3, 4));
+  // Verify basic functionality.
+  const std::vector<std::pair<size_t, SkColor>> expected_color = {
+      {0, SK_ColorGREEN}, {1, kPlaceholderColor}};
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting(expected_color));
+  const std::vector<std::pair<size_t, BaselineStyle>> expected_baseline = {
+      {0, NORMAL_BASELINE}, {1, SUPERSCRIPT}, {2, NORMAL_BASELINE}};
+  EXPECT_TRUE(test_api()->baselines().EqualsForTesting(expected_baseline));
+  const std::vector<std::pair<size_t, bool>> expected_style = {
+      {0, false}, {2, true}, {3, false}};
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_UNDERLINE].EqualsForTesting(
+      expected_style));
+  const std::vector<std::pair<size_t, int>> expected_font_size = {{0, 0},
+                                                                  {3, 20}};
+  EXPECT_TRUE(
+      test_api()->font_size_overrides().EqualsForTesting(expected_font_size));
+
+  // Ensure AppendText maintains current text styles.
+  render_text->AppendText(u"efg");
+  EXPECT_EQ(render_text->GetDisplayText(), u"abcdefg");
+  EXPECT_TRUE(test_api()->colors().EqualsForTesting(expected_color));
+  EXPECT_TRUE(test_api()->baselines().EqualsForTesting(expected_baseline));
+  EXPECT_TRUE(test_api()->styles()[TEXT_STYLE_UNDERLINE].EqualsForTesting(
+      expected_style));
+  EXPECT_TRUE(
+      test_api()->font_size_overrides().EqualsForTesting(expected_font_size));
+}
+
+TEST_F(RenderTextTest, SetSelection) {
+  RenderText* render_text = GetRenderText();
+  render_text->set_selection_color(SK_ColorGREEN);
+  render_text->SetText(u"abcdef");
+  render_text->set_focused(true);
+
+  // Single selection
+  render_text->SetSelection(
+      {{{4, 100}}, LogicalCursorDirection::CURSOR_FORWARD});
+  Draw();
+  ExpectTextLog({{4}, {2, SK_ColorGREEN}});
+
+  // Multiple selections
+  render_text->SetSelection(
+      {{{0, 1}, {4, 100}}, LogicalCursorDirection::CURSOR_FORWARD});
+  Draw();
+  ExpectTextLog({{1, SK_ColorGREEN}, {3}, {2, SK_ColorGREEN}});
+
+  render_text->ClearSelection();
+  Draw();
+  ExpectTextLog({{6}});
+}
+
+TEST_F(RenderTextTest, SelectRangeColored) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdef");
+  render_text->SetColor(SK_ColorBLACK);
+  render_text->set_selection_color(SK_ColorGREEN);
+  render_text->set_focused(true);
+
+  render_text->SelectRange(Range(0, 1));
+  Draw();
+  ExpectTextLog({{1, SK_ColorGREEN}, {5, SK_ColorBLACK}});
+
+  render_text->SelectRange(Range(1, 3));
+  Draw();
+  ExpectTextLog({{1, SK_ColorBLACK}, {2, SK_ColorGREEN}, {3, SK_ColorBLACK}});
+
+  render_text->ClearSelection();
+  Draw();
+  ExpectTextLog({{6, SK_ColorBLACK}});
+}
+
+// Tests that when a selection is made and the selection background is
+// translucent, the selection renders properly. See crbug.com/1134440.
+TEST_F(RenderTextTest, SelectWithTranslucentBackground) {
+  constexpr float kGlyphWidth = 5.5f;
+  constexpr Size kCanvasSize(300, 50);
+  constexpr SkColor kTranslucentBlue = SkColorSetARGB(0x7F, 0x00, 0x00, 0xFF);
+  const char* const kTestString{"A B C D"};
+  const char16_t* const kTestString16{u"A B C D"};
+
+  SkBitmap bitmap;
+  bitmap.allocPixels(
+      SkImageInfo::MakeN32Premul(kCanvasSize.width(), kCanvasSize.height()));
+  cc::SkiaPaintCanvas paint_canvas(bitmap);
+  Canvas canvas(&paint_canvas, 1.0f);
+  paint_canvas.clear(SK_ColorWHITE);
+
+  SetGlyphWidth(kGlyphWidth);
+  RenderText* render_text = GetRenderText();
+  render_text->set_selection_background_focused_color(kTranslucentBlue);
+  render_text->set_focused(true);
+
+  render_text->SetText(kTestString16);
+  render_text->SelectRange(Range(0, 7));
+  const Rect text_rect = Rect(render_text->GetStringSize());
+  render_text->SetDisplayRect(text_rect);
+  render_text->Draw(&canvas);
+  const uint32_t* buffer = static_cast<const uint32_t*>(bitmap.getPixels());
+  ASSERT_NE(nullptr, buffer);
+  TestRectangleBuffer rect_buffer(kTestString, buffer, kCanvasSize.width(),
+                                  kCanvasSize.height());
+
+  // This whole slice should be the same color and opacity.
+  rect_buffer.EnsureRectIsAllSameColor(0, 0, text_rect.width() - 1, 1);
+}
+
+TEST_F(RenderTextTest, SelectRangeColoredGrapheme) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"xe\u0301y");
+  render_text->SetColor(SK_ColorBLACK);
+  render_text->set_selection_color(SK_ColorGREEN);
+  render_text->set_focused(true);
+
+  render_text->SelectRange(Range(0, 1));
+  Draw();
+  ExpectTextLog({{1, SK_ColorGREEN}, {2, SK_ColorBLACK}});
+
+  render_text->SelectRange(Range(1, 2));
+  Draw();
+  ExpectTextLog({{1, SK_ColorBLACK}, {1, SK_ColorGREEN}, {1, SK_ColorBLACK}});
+
+  render_text->SelectRange(Range(2, 3));
+  Draw();
+  ExpectTextLog({{1, SK_ColorBLACK}, {1, SK_ColorGREEN}, {1, SK_ColorBLACK}});
+
+  render_text->SelectRange(Range(2, 4));
+  Draw();
+  ExpectTextLog({{1, SK_ColorBLACK}, {2, SK_ColorGREEN}});
+}
+
+TEST_F(RenderTextTest, SelectRangeMultiple) {
+  RenderText* render_text = GetRenderText();
+  render_text->set_selection_color(SK_ColorGREEN);
+  render_text->SetText(u"abcdef");
+  render_text->set_focused(true);
+
+  // Multiple selections
+  render_text->SelectRange(Range(0, 1));
+  render_text->SelectRange(Range(4, 2), false);
+  Draw();
+  ExpectTextLog({{1, SK_ColorGREEN}, {1}, {2, SK_ColorGREEN}, {2}});
+
+  // Setting a primary selection should override secondary selections
+  render_text->SelectRange(Range(5, 6));
+  Draw();
+  ExpectTextLog({{5}, {1, SK_ColorGREEN}});
+
+  render_text->ClearSelection();
+  Draw();
+  ExpectTextLog({{6}});
+}
+
+TEST_F(RenderTextTest, SetCompositionRangeColored) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdef");
+
+  render_text->SetCompositionRange(Range(0, 1));
+  Draw();
+  ExpectTextLog({{1}, {5}});
+
+  render_text->SetCompositionRange(Range(1, 3));
+  Draw();
+  ExpectTextLog({{1}, {2}, {3}});
+
+  render_text->SetCompositionRange(Range::InvalidRange());
+  Draw();
+  ExpectTextLog({{6}});
+}
+
+TEST_F(RenderTextTest, SetCompositionRangeColoredGrapheme) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"xe\u0301y");
+
+  render_text->SetCompositionRange(Range(0, 1));
+  Draw();
+  ExpectTextLog({{1}, {2}});
+
+  render_text->SetCompositionRange(Range(2, 3));
+  Draw();
+  ExpectTextLog({{3}});
+
+  render_text->SetCompositionRange(Range(2, 4));
+  Draw();
+  ExpectTextLog({{2}, {1}});
+}
+
+void TestVisualCursorMotionInObscuredField(
+    RenderText* render_text,
+    const std::u16string& text,
+    SelectionBehavior selection_behavior) {
+  const bool select = selection_behavior != SELECTION_NONE;
+  ASSERT_TRUE(render_text->obscured());
+  render_text->SetText(text);
+  int len = text.length();
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, selection_behavior);
+  EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
+            render_text->selection_model());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, selection_behavior);
+  EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+  for (int j = 1; j <= len; ++j) {
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, selection_behavior);
+    EXPECT_EQ(SelectionModel(Range(select ? 0 : j, j), CURSOR_BACKWARD),
+              render_text->selection_model());
+  }
+  for (int j = len - 1; j >= 0; --j) {
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, selection_behavior);
+    EXPECT_EQ(SelectionModel(Range(select ? 0 : j, j), CURSOR_FORWARD),
+              render_text->selection_model());
+  }
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, selection_behavior);
+  EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
+            render_text->selection_model());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, selection_behavior);
+  EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+}
+
+TEST_F(RenderTextTest, ObscuredText) {
+  const std::u16string seuss = u"hop on pop";
+  const std::u16string no_seuss = GetObscuredString(seuss.length());
+  RenderText* render_text = GetRenderText();
+
+  // GetDisplayText() returns a string filled with
+  // RenderText::kPasswordReplacementChar when the obscured bit is set.
+  render_text->SetText(seuss);
+  render_text->SetObscured(true);
+  EXPECT_EQ(seuss, render_text->text());
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
+  render_text->SetObscured(false);
+  EXPECT_EQ(seuss, render_text->text());
+  EXPECT_EQ(seuss, render_text->GetDisplayText());
+
+  render_text->SetObscured(true);
+
+  // Surrogate pairs are counted as one code point.
+  const char16_t invalid_surrogates[] = {0xDC00, 0xD800, 0};
+  render_text->SetText(invalid_surrogates);
+  EXPECT_EQ(GetObscuredString(2), render_text->GetDisplayText());
+  const char16_t valid_surrogates[] = {0xD800, 0xDC00, 0};
+  render_text->SetText(valid_surrogates);
+  EXPECT_EQ(GetObscuredString(1), render_text->GetDisplayText());
+  EXPECT_EQ(0U, render_text->cursor_position());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(2U, render_text->cursor_position());
+
+  // Test index conversion and cursor validity with a valid surrogate pair.
+  // Text contains "u+D800 u+DC00" and display text contains "u+2022".
+  EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(0U));
+  EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(1U));
+  EXPECT_EQ(1U, test_api()->TextIndexToDisplayIndex(2U));
+  EXPECT_EQ(0U, test_api()->DisplayIndexToTextIndex(0U));
+  EXPECT_EQ(2U, test_api()->DisplayIndexToTextIndex(1U));
+  EXPECT_TRUE(render_text->IsValidCursorIndex(0U));
+  EXPECT_FALSE(render_text->IsValidCursorIndex(1U));
+  EXPECT_TRUE(render_text->IsValidCursorIndex(2U));
+
+  // FindCursorPosition() should not return positions between a surrogate pair.
+  render_text->SetDisplayRect(Rect(0, 0, 20, 20));
+  const int cursor_y = GetCursorYForTesting();
+  EXPECT_EQ(render_text->FindCursorPosition(Point(0, cursor_y)).caret_pos(),
+            0U);
+  EXPECT_EQ(render_text->FindCursorPosition(Point(20, cursor_y)).caret_pos(),
+            2U);
+  for (int x = -1; x <= 20; ++x) {
+    SelectionModel selection =
+        render_text->FindCursorPosition(Point(x, cursor_y));
+    EXPECT_TRUE(selection.caret_pos() == 0U || selection.caret_pos() == 2U);
+  }
+
+  // GetCursorSpan() should yield the entire string bounds for text index 0.
+  EXPECT_EQ(render_text->GetStringSize().width(),
+            std::ceil(render_text->GetCursorSpan({0, 2}).length()));
+
+  // Cursoring is independent of underlying characters when text is obscured.
+  const char16_t* const texts[] = {
+      kWeak,         kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl,
+      u"hop on pop",  // Check LTR word boundaries.
+      u"אב אג בג",    // Check RTL word boundaries.
+  };
+  for (size_t i = 0; i < base::size(texts); ++i) {
+    TestVisualCursorMotionInObscuredField(render_text, texts[i],
+                                          SELECTION_NONE);
+    TestVisualCursorMotionInObscuredField(render_text, texts[i],
+                                          SELECTION_RETAIN);
+  }
+}
+
+TEST_F(RenderTextTest, ObscuredTextMultiline) {
+  const std::u16string test = u"a\nbc\ndef";
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(test);
+  render_text->SetObscured(true);
+  render_text->SetMultiline(true);
+
+  // Newlines should be kept in multiline mode.
+  std::u16string display_text = render_text->GetDisplayText();
+  EXPECT_EQ(display_text[1], '\n');
+  EXPECT_EQ(display_text[4], '\n');
+}
+
+TEST_F(RenderTextTest, ObscuredTextMultilineNewline) {
+  const std::u16string test = u"\r\r\n";
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(test);
+  render_text->SetObscured(true);
+  render_text->SetMultiline(true);
+
+  // Newlines should be kept in multiline mode.
+  std::u16string display_text = render_text->GetDisplayText();
+  EXPECT_EQ(display_text[0], '\r');
+  EXPECT_EQ(display_text[1], '\r');
+  EXPECT_EQ(display_text[2], '\n');
+}
+
+TEST_F(RenderTextTest, RevealObscuredText) {
+  const std::u16string seuss = u"hop on pop";
+  const std::u16string no_seuss = GetObscuredString(seuss.length());
+  RenderText* render_text = GetRenderText();
+
+  render_text->SetText(seuss);
+  render_text->SetObscured(true);
+  EXPECT_EQ(seuss, render_text->text());
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
+
+  // Valid reveal index and new revealed index clears previous one.
+  render_text->RenderText::SetObscuredRevealIndex(0);
+  EXPECT_EQ(GetObscuredString(seuss.length(), 0, 'h'),
+            render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(1);
+  EXPECT_EQ(GetObscuredString(seuss.length(), 1, 'o'),
+            render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(2);
+  EXPECT_EQ(GetObscuredString(seuss.length(), 2, 'p'),
+            render_text->GetDisplayText());
+
+  // Invalid reveal index.
+  render_text->RenderText::SetObscuredRevealIndex(-1);
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(seuss.length() + 1);
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
+
+  // SetObscured clears the revealed index.
+  render_text->RenderText::SetObscuredRevealIndex(0);
+  EXPECT_EQ(GetObscuredString(seuss.length(), 0, 'h'),
+            render_text->GetDisplayText());
+  render_text->SetObscured(false);
+  EXPECT_EQ(seuss, render_text->GetDisplayText());
+  render_text->SetObscured(true);
+  EXPECT_EQ(no_seuss, render_text->GetDisplayText());
+
+  // SetText clears the revealed index.
+  render_text->SetText(u"new");
+  EXPECT_EQ(GetObscuredString(3), render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(2);
+  EXPECT_EQ(GetObscuredString(3, 2, 'w'), render_text->GetDisplayText());
+  render_text->SetText(u"new longer");
+  EXPECT_EQ(GetObscuredString(10), render_text->GetDisplayText());
+
+  // Text with invalid surrogates (surrogates low 0xDC00 and high 0xD800).
+  // Invalid surrogates are replaced by replacement character (e.g. 0xFFFD).
+  render_text->SetText(u"\xDC00\xD800hop");
+  EXPECT_EQ(GetObscuredString(5), render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(0);
+  EXPECT_EQ(GetObscuredString(5, 0, 0xFFFD), render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(1);
+  EXPECT_EQ(GetObscuredString(5, 1, 0xFFFD), render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(2);
+  EXPECT_EQ(GetObscuredString(5, 2, 'h'), render_text->GetDisplayText());
+
+  // Text with valid surrogates before and after the reveal index.
+  render_text->SetText(u"\xD800\xDC00hop\xD800\xDC00");
+  EXPECT_EQ(GetObscuredString(5), render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(0);
+  const char16_t valid_expect_0_and_1[] = {0xD800,
+                                           0xDC00,
+                                           RenderText::kPasswordReplacementChar,
+                                           RenderText::kPasswordReplacementChar,
+                                           RenderText::kPasswordReplacementChar,
+                                           RenderText::kPasswordReplacementChar,
+                                           0};
+  EXPECT_EQ(valid_expect_0_and_1, render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(1);
+  EXPECT_EQ(valid_expect_0_and_1, render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(2);
+  EXPECT_EQ(GetObscuredString(5, 1, 'h'), render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(5);
+  const char16_t valid_expect_5_and_6[] = {RenderText::kPasswordReplacementChar,
+                                           RenderText::kPasswordReplacementChar,
+                                           RenderText::kPasswordReplacementChar,
+                                           RenderText::kPasswordReplacementChar,
+                                           0xD800,
+                                           0xDC00,
+                                           0};
+  EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
+  render_text->RenderText::SetObscuredRevealIndex(6);
+  EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
+}
+
+TEST_F(RenderTextTest, ObscuredEmoji) {
+  // Ensures text itemization doesn't crash on obscured multi-char glyphs.
+  RenderText* render_text = GetRenderText();
+  render_text->SetObscured(true);
+  // Test U+1F601 😁 "Grinning face with smiling eyes", followed by 'y'.
+  render_text->SetText(u"😁y");
+  render_text->Draw(canvas());
+
+  // Emoji codepoints are replaced by bullets.
+  EXPECT_EQ(u"••", render_text->GetDisplayText());
+  EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(0U));
+  EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(1U));
+  EXPECT_EQ(1U, test_api()->TextIndexToDisplayIndex(2U));
+
+  EXPECT_EQ(0U, test_api()->DisplayIndexToTextIndex(0U));
+  EXPECT_EQ(2U, test_api()->DisplayIndexToTextIndex(1U));
+
+  // Out of bound accesses.
+  EXPECT_EQ(2U, test_api()->TextIndexToDisplayIndex(3U));
+  EXPECT_EQ(3U, test_api()->DisplayIndexToTextIndex(2U));
+
+  // Test two U+1F4F7 📷 "Camera" characters in a row.
+  render_text->SetText(u"📷📷");
+  render_text->Draw(canvas());
+
+  // Emoji codepoints are replaced by bullets.
+  EXPECT_EQ(u"••", render_text->GetDisplayText());
+  EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(0U));
+  EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(1U));
+  EXPECT_EQ(1U, test_api()->TextIndexToDisplayIndex(2U));
+  EXPECT_EQ(1U, test_api()->TextIndexToDisplayIndex(3U));
+
+  EXPECT_EQ(0U, test_api()->DisplayIndexToTextIndex(0U));
+  EXPECT_EQ(2U, test_api()->DisplayIndexToTextIndex(1U));
+
+  // Reveal the first emoji.
+  render_text->SetObscuredRevealIndex(0);
+  render_text->Draw(canvas());
+
+  EXPECT_EQ(u"📷•", render_text->GetDisplayText());
+  EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(0U));
+  EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(1U));
+  EXPECT_EQ(2U, test_api()->TextIndexToDisplayIndex(2U));
+  EXPECT_EQ(2U, test_api()->TextIndexToDisplayIndex(3U));
+
+  EXPECT_EQ(0U, test_api()->DisplayIndexToTextIndex(0U));
+  EXPECT_EQ(0U, test_api()->DisplayIndexToTextIndex(1U));
+  EXPECT_EQ(2U, test_api()->DisplayIndexToTextIndex(2U));
+}
+
+TEST_F(RenderTextTest, ObscuredEmojiRevealed) {
+  RenderText* render_text = GetRenderText();
+
+  std::u16string text = u"123📷📷x😁-";
+  for (size_t i = 0; i < text.length(); ++i) {
+    render_text->SetText(text);
+    render_text->SetObscured(true);
+    render_text->SetObscuredRevealIndex(i);
+    render_text->Draw(canvas());
+  }
+}
+
+struct TextIndexConversionCase {
+  const char* test_name;
+  const char16_t* text;
+};
+
+using TextIndexConversionParam =
+    std::tuple<TextIndexConversionCase, bool, size_t>;
+
+class RenderTextTestWithTextIndexConversionCase
+    : public RenderTextTest,
+      public ::testing::WithParamInterface<TextIndexConversionParam> {
+ public:
+  static std::string ParamInfoToString(
+      ::testing::TestParamInfo<TextIndexConversionParam> param_info) {
+    TextIndexConversionCase param = std::get<0>(param_info.param);
+    bool obscured = std::get<1>(param_info.param);
+    size_t reveal_index = std::get<2>(param_info.param);
+    return base::StringPrintf("%s%s%zu", param.test_name,
+                              (obscured ? "Obscured" : ""), reveal_index);
+  }
+};
+
+TEST_P(RenderTextTestWithTextIndexConversionCase, TextIndexConversion) {
+  TextIndexConversionCase param = std::get<0>(GetParam());
+  bool obscured = std::get<1>(GetParam());
+  size_t reveal_index = std::get<2>(GetParam());
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(param.text);
+  render_text->SetObscured(obscured);
+  render_text->SetObscuredRevealIndex(reveal_index);
+  render_text->Draw(canvas());
+
+  std::u16string text = render_text->text();
+  std::u16string display_text = render_text->GetDisplayText();
+
+  // Adjust reveal_index to point to the beginning of the surrogate pair, if
+  // needed.
+  U16_SET_CP_START(text.c_str(), 0, reveal_index);
+
+  // Validate that codepoints still match.
+  for (base::i18n::UTF16CharIterator iter(render_text->text()); !iter.end();
+       iter.Advance()) {
+    size_t text_index = iter.array_pos();
+    size_t display_index = test_api()->TextIndexToDisplayIndex(text_index);
+    EXPECT_EQ(text_index, test_api()->DisplayIndexToTextIndex(display_index));
+    if (obscured && reveal_index != text_index) {
+      EXPECT_EQ(display_text[display_index],
+                RenderText::kPasswordReplacementChar);
+    } else {
+      EXPECT_EQ(display_text[display_index], text[text_index]);
+    }
+  }
+}
+
+const TextIndexConversionCase kTextIndexConversionCases[] = {
+    {"simple", u"abc"},
+    {"simple_obscured1", u"abc"},
+    {"simple_obscured2", u"abc"},
+    {"emoji_asc", u"😨1234"},
+    {"emoji_asc_obscured0", u"😨1234"},
+    {"emoji_asc_obscured2", u"😨1234"},
+    {"picto_title", u"xx☛"},
+    {"simple_mixed", u"aaڭڭcc"},
+    {"simple_rtl", u"أسكي"},
+};
+
+// Validate that conversion text and between display text indexes are consistent
+// even when text obscured and reveal character features are used.
+INSTANTIATE_TEST_SUITE_P(
+    ItemizeTextToRunsConversion,
+    RenderTextTestWithTextIndexConversionCase,
+    ::testing::Combine(::testing::ValuesIn(kTextIndexConversionCases),
+                       testing::Values(false, true),
+                       testing::Values(0, 1, 3)),
+    RenderTextTestWithTextIndexConversionCase::ParamInfoToString);
+
+struct RunListCase {
+  const char* test_name;
+  const char16_t* text;
+  const char* expected;
+  const bool multiline = false;
+};
+
+class RenderTextTestWithRunListCase
+    : public RenderTextTest,
+      public ::testing::WithParamInterface<RunListCase> {
+ public:
+  static std::string ParamInfoToString(
+      ::testing::TestParamInfo<RunListCase> param_info) {
+    return param_info.param.test_name;
+  }
+};
+
+TEST_P(RenderTextTestWithRunListCase, ItemizeTextToRuns) {
+  RunListCase param = GetParam();
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetMultiline(param.multiline);
+  render_text->SetText(param.text);
+  EXPECT_EQ(param.expected, GetRunListStructureString());
+}
+
+const RunListCase kBasicsRunListCases[] = {
+    {"simpleLTR", u"abc", "[0->2]"},
+    {"simpleRTL", u"ښڛڜ", "[2<-0]"},
+    {"asc_arb", u"abcښڛڜdef", "[0->2][5<-3][6->8]"},
+    {"asc_dev_asc", u"abcऔकखdefڜ", "[0->2][3->5][6->8][9]"},
+    {"phone", u"1-(800)-xxx-xxxx", "[0][1][2][3->5][6][7][8->10][11][12->15]"},
+    {"dev_ZWS", u"क\u200Bख", "[0][1][2]"},
+    {"numeric", u"1 2 3 4", "[0][1][2][3][4][5][6]"},
+    {"joiners1", u"1\u200C2\u200C3\u200C4", "[0->6]"},
+    {"joiners2", u"؏\u200C؏", "[0->2]"},
+    {"combining_accents1", u"àé", "[0->3]"},
+    {"combining_accents2", u"ëё", "[0->1][2->3]"},
+    {"picto_title", u"☞☛test☚☜", "[0->1][2->5][6->7]"},
+    {"picto_LTR", u"☺☺☺!", "[0->2][3]"},
+    {"picto_RTL", u"☺☺☺ښ", "[3][2<-0]"},
+    {"paren_picto", u"(☾☹☽)", "[0][1][2][3][4]"},
+    {"emoji_asc", u"😨1234", "[0->1][2->5]"},  // http://crbug.com/530021
+    {"emoji_title", u"▶Feel goods",
+     "[0][1->4][5][6->10]"},  // http://crbug.com/278913
+    {"jap_paren1", u"ぬ「シ」ほ",
+     "[0][1][2][3][4]"},  // http://crbug.com/396776
+    {"jap_paren2", u"國哲(c)1",
+     "[0->1][2][3][4][5]"},  // http://crbug.com/125792
+    {"newline1", u"\n\n", "[0->1]"},
+    {"newline2", u"\r\n\r\n", "[0->3]"},
+    {"newline3", u"\r\r\n", "[0->2]"},
+    {"multiline_newline1", u"\n\n", "[0][1]", true},
+    {"multiline_newline2", u"\r\n\r\n", "[0->1][2->3]", true},
+    {"multiline_newline3", u"\r\r\n", "[0][1->2]", true},
+    {"multiline_newline4", u"x\r\r", "[0][1][2]", true},
+    {"multiline_newline5", u"x\n\r\r", "[0][1][2][3]", true},
+    {"multiline_newline6", u"x\ny\rz\r\n", "[0][1][2][3][4][5->6]", true},
+};
+
+INSTANTIATE_TEST_SUITE_P(ItemizeTextToRunsBasics,
+                         RenderTextTestWithRunListCase,
+                         ::testing::ValuesIn(kBasicsRunListCases),
+                         RenderTextTestWithRunListCase::ParamInfoToString);
+
+// see 'Unicode Bidirectional Algorithm': http://unicode.org/reports/tr9/
+const RunListCase kBidiRunListCases[] = {
+    {"simple_ltr", u"ascii", "[0->4]"},
+    {"simple_rtl", u"أسكي", "[3<-0]"},
+    {"simple_mixed", u"aaڭڭcc", "[0->1][3<-2][4->5]"},
+    {"simple_mixed_LRE", u"\u202Aaaڭڭcc\u202C", "[0][1->2][4<-3][5->6][7]"},
+    {"simple_mixed_RLE", u"\u202Baaڭڭcc\u202C", "[7][5->6][4<-3][0][1->2]"},
+    {"sequence_RLE", u"\u202Baa\u202C\u202Bbb\u202C",
+     "[7][0][1->2][3->4][5->6]"},
+    {"simple_mixed_LRI", u"\u2066aaڭڭcc\u2069", "[0][1->2][4<-3][5->6][7]"},
+    {"simple_mixed_RLI", u"\u2067aaڭڭcc\u2069", "[0][5->6][4<-3][1->2][7]"},
+    {"sequence_RLI", u"\u2067aa\u2069\u2067bb\u2069",
+     "[0][1->2][3->4][5->6][7]"},
+    {"override_ltr_RLO", u"\u202Eaaa\u202C", "[4][3<-1][0]"},
+    {"override_rtl_LRO", u"\u202Dڭڭڭ\u202C", "[0][1->3][4]"},
+    {"neutral_strong_ltr", u"a!!a", "[0][1->2][3]"},
+    {"neutral_strong_rtl", u"ڭ!!ڭ", "[3][2<-1][0]"},
+    {"neutral_strong_both", u"a a ڭ ڭ", "[0][1][2][3][6][5][4]"},
+    {"neutral_strong_both_RLE", u"\u202Ba a ڭ ڭ\u202C",
+     "[8][7][6][5][4][0][1][2][3]"},
+    {"weak_numbers", u"one ڭ222ڭ", "[0->2][3][8][5->7][4]"},
+    {"not_weak_letters", u"one ڭabcڭ", "[0->2][3][4][5->7][8]"},
+    {"weak_arabic_numbers", u"one ڭ١٢٣ڭ", "[0->2][3][8][5->7][4]"},
+    {"neutral_LRM_pre", u"\u200E……", "[0->2]"},
+    {"neutral_LRM_post", u"……\u200E", "[0->2]"},
+    {"neutral_RLM_pre", u"\u200F……", "[2<-0]"},
+    {"neutral_RLM_post", u"……\u200F", "[2<-0]"},
+    {"brackets_ltr", u"aa(ڭڭ)……", "[0->1][2][4<-3][5][6->7]"},
+    {"brackets_rtl", u"ڭڭ(aa)……", "[7<-6][5][3->4][2][1<-0]"},
+    {"mixed_with_punct", u"aa \"ڭڭ!\", aa",
+     "[0->1][2][3][5<-4][6->8][9][10->11]"},
+    {"mixed_with_punct_RLI", u"aa \"\u2067ڭڭ!\u2069\", aa",
+     "[0->1][2][3][4][7][6<-5][8][9->10][11][12->13]"},
+    {"mixed_with_punct_RLM", u"aa \"ڭڭ!\u200F\", aa",
+     "[0->1][2][3][7][6][5<-4][8->9][10][11->12]"},
+};
+
+INSTANTIATE_TEST_SUITE_P(ItemizeTextToRunsBidi,
+                         RenderTextTestWithRunListCase,
+                         ::testing::ValuesIn(kBidiRunListCases),
+                         RenderTextTestWithRunListCase::ParamInfoToString);
+
+const RunListCase kBracketsRunListCases[] = {
+    {"matched_parens", u"(a)", "[0][1][2]"},
+    {"double_matched_parens", u"((a))", "[0->1][2][3->4]"},
+    {"double_matched_parens2", u"((aaa))", "[0->1][2->4][5->6]"},
+    {"square_brackets", u"[...]x", "[0][1->3][4][5]"},
+    {"curly_brackets", u"{}x{}", "[0->1][2][3->4]"},
+    {"style_brackets", u"「...」x", "[0][1->3][4][5]"},
+    {"tibetan_brackets", u"༺༻༠༠༼༽", "[0->1][2->3][4->5]"},
+    {"angle_brackets", u"〈〇〇〉", "[0][1->2][3]"},
+    {"double_angle_brackets", u"《〇〇》", "[0][1->2][3]"},
+    {"corner_angle_brackets", u"「〇〇」", "[0][1->2][3]"},
+    {"fullwidth_parens", u"（！）", "[0][1][2]"},
+};
+
+INSTANTIATE_TEST_SUITE_P(ItemizeTextToRunsBrackets,
+                         RenderTextTestWithRunListCase,
+                         ::testing::ValuesIn(kBracketsRunListCases),
+                         RenderTextTestWithRunListCase::ParamInfoToString);
+
+// Test cases to ensure the extraction of script extensions are taken into
+// account while performing the text itemization.
+// See table 7 from http://www.unicode.org/reports/tr24/tr24-29.html
+const RunListCase kScriptExtensionRunListCases[] = {
+    {"implicit_com_inherited", u"a\u0301", "[0->1]"},
+    {"explicit_lat", u"\u0061d", "[0->1]"},
+    {"explicit_inherited_lat", u"x\u0363d", "[0->2]"},
+    {"explicit_inherited_dev", u"क\u1CD1क", "[0->2]"},
+    {"multi_explicit_hira", u"は\u30FCz", "[0->1][2]"},
+    {"multi_explicit_kana", u"ハ\u30FCz", "[0->1][2]"},
+    {"multi_explicit_lat", u"a\u30FCz", "[0][1][2]"},
+    {"multi_explicit_impl_dev", u"क\u1CD0z", "[0->1][2]"},
+    {"multi_explicit_expl_dev", u"क\u096Fz", "[0->1][2]"},
+};
+
+INSTANTIATE_TEST_SUITE_P(ItemizeTextToRunsScriptExtension,
+                         RenderTextTestWithRunListCase,
+                         ::testing::ValuesIn(kScriptExtensionRunListCases),
+                         RenderTextTestWithRunListCase::ParamInfoToString);
+
+// Test cases to ensure ItemizeTextToRuns is splitting text based on unicode
+// script (intersection of script extensions).
+// See ScriptExtensions.txt and Scripts.txt from
+// http://www.unicode.org/reports/tr24/tr24-29.html
+const RunListCase kScriptsRunListCases[] = {
+    {"lat", u"abc", "[0->2]"},
+    {"lat_diac", u"e\u0308f", "[0->2]"},
+    // Indic Fraction codepoints have large set of script extensions.
+    {"indic_fraction", u"\uA830\uA832\uA834\uA835", "[0->3]"},
+    // Devanagari Danda codepoints have large set of script extensions.
+    {"dev_danda", u"\u0964\u0965", "[0->1]"},
+    // Combining Diacritical Marks (inherited) should only merge with preceding.
+    {"diac_lat", u"\u0308fg", "[0][1->2]"},
+    {"diac_dev", u"क\u0308f", "[0->1][2]"},
+    // ZWJW has the inherited script.
+    {"lat_ZWNJ", u"ab\u200Ccd", "[0->4]"},
+    {"dev_ZWNJ", u"क\u200Cक", "[0->2]"},
+    {"lat_dev_ZWNJ", u"a\u200Cक", "[0->1][2]"},
+    // Invalid codepoints.
+    {"invalid_cp", u"\uFFFE", "[0]"},
+    {"invalid_cps", u"\uFFFE\uFFFF", "[0->1]"},
+    {"unknown", u"a\u243Fb", "[0][1][2]"},
+
+    // Codepoints from different code block should be in same run when part of
+    // the same script.
+    {"blocks_lat", u"aɒɠƉĚÑ", "[0->5]"},
+    {"blocks_lat_paren", u"([_!_])", "[0->1][2->4][5->6]"},
+    {"blocks_lat_sub", u"ₐₑaeꬱ", "[0->4]"},
+    {"blocks_lat_smallcap", u"ꟺＭ", "[0->1]"},
+    {"blocks_lat_small_letter", u"ᶓᶍᶓᴔᴟ", "[0->4]"},
+    {"blocks_lat_acc", u"eéěĕȩɇḕẻếⱻꞫ", "[0->10]"},
+    {"blocks_com", u"⟦ℳ¥¾⟾⁸⟧Ⓔ", "[0][1][2->3][4][5][6][7]"},
+
+    // Latin script.
+    {"latin_numbers", u"a1b2c3", "[0][1][2][3][4][5]"},
+    {"latin_puncts1", u"a,b,c.", "[0][1][2][3][4][5]"},
+    {"latin_puncts2", u"aa,bb,cc!!", "[0->1][2][3->4][5][6->7][8->9]"},
+    {"latin_diac_multi", u"a\u0300e\u0352i", "[0->4]"},
+
+    // Common script.
+    {"common_tm", u"•bug™", "[0][1->3][4]"},
+    {"common_copyright", u"chromium©", "[0->7][8]"},
+    {"common_math1", u"ℳ: ¬ƒ(x)=½×¾", "[0][1][2][3][4][5][6][7][8][9->11]"},
+    {"common_math2", u"𝟏×𝟑", "[0->1][2][3->4]"},
+    {"common_numbers", u"🄀𝟭𝟐⒓¹²", "[0->1][2->5][6][7->8]"},
+    {"common_puncts", u",.\u0083!", "[0->1][2][3]"},
+
+    // Arabic script.
+    {"arabic", u"\u0633\u069b\u0763\u077f\u08A2\uFB53", "[5<-0]"},
+    {"arabic_lat", u"\u0633\u069b\u0763\u077f\u08A2\uFB53abc", "[6->8][5<-0]"},
+    {"arabic_word_ligatures", u"\uFDFD\uFDF3", "[1<-0]"},
+    {"arabic_diac", u"\u069D\u0300", "[1<-0]"},
+    {"arabic_diac_lat", u"\u069D\u0300abc", "[2->4][1<-0]"},
+    {"arabic_diac_lat2", u"abc\u069D\u0300abc", "[0->2][4<-3][5->7]"},
+    {"arabic_lyd", u"\U00010935\U00010930\u06B0\u06B1", "[5<-4][3<-0]"},
+    {"arabic_numbers", u"12\u06D034", "[3->4][2][0->1]"},
+    {"arabic_letters", u"ab\u06D0cd", "[0->1][2][3->4]"},
+    {"arabic_mixed", u"a1\u06D02d", "[0][1][3][2][4]"},
+    {"arabic_coptic1", u"\u06D0\U000102E2\u2CB2", "[1->3][0]"},
+    {"arabic_coptic2", u"\u2CB2\U000102E2\u06D0", "[0->2][3]"},
+
+    // Devanagari script.
+    {"devanagari1", u"ञटठडढणतथ", "[0->7]"},
+    {"devanagari2", u"ढ꣸ꣴ", "[0->2]"},
+    {"devanagari_vowels", u"\u0915\u093F\u0915\u094C", "[0->3]"},
+    {"devanagari_consonants", u"\u0915\u094D\u0937", "[0->2]"},
+
+    // Ethiopic script.
+    {"ethiopic", u"መጩጪᎅⶹⶼꬣꬦ", "[0->7]"},
+    {"ethiopic_numbers", u"1ቨቤ2", "[0][1->2][3]"},
+    {"ethiopic_mixed1", u"abቨቤ12", "[0->1][2->3][4->5]"},
+    {"ethiopic_mixed2", u"a1ቨቤb2", "[0][1][2->3][4][5]"},
+
+    // Georgian script.
+    {"georgian1", u"ႼႽႾႿჀჁჂჳჴჵ", "[0->9]"},
+    {"georgian2", u"ლⴊⴅ", "[0->2]"},
+    {"georgian_numbers", u"1ლⴊⴅ2", "[0][1->3][4]"},
+    {"georgian_mixed", u"a1ლⴊⴅb2", "[0][1][2->4][5][6]"},
+
+    // Telugu script.
+    {"telugu_lat", u"aaఉయ!", "[0->1][2->3][4]"},
+    {"telugu_numbers", u"123౦౧౨456౩౪౫", "[0->2][3->5][6->8][9->11]"},
+    {"telugu_puncts", u"కురుచ, చిఱుత, చేరువ, చెఱువు!",
+     "[0->4][5][6][7->11][12][13][14->18][19][20][21->26][27]"},
+
+    // Control Pictures.
+    {"control_pictures", u"␑␒␓␔␕␖␗␘␙␚␛", "[0->10]"},
+    {"control_pictures_rewrite", u"␑\t␛", "[0->2]"},
+
+    // Unicode art.
+    {"unicode_emoticon1", u"(▀̿ĺ̯▀̿ ̿)", "[0][1->2][3->4][5->6][7->8][9]"},
+    {"unicode_emoticon2", u"▀̿̿Ĺ̯̿▀̿ ", "[0->2][3->5][6->7][8]"},
+    {"unicode_emoticon3", u"( ͡° ͜ʖ ͡°)", "[0][1->2][3][4->5][6][7->8][9][10]"},
+    {"unicode_emoticon4", u"✩·͙*̩̩͙˚̩̥̩̥( ͡ᵔ ͜ʖ ͡ᵔ )*̩̩͙✩·͙˚̩̥̩̥.",
+     "[0][1->2][3->6][7->11][12][13->14][15][16->17][18][19->20][21][22][23]["
+     "24->27][28][29->30][31->35][36]"},
+    {"unicode_emoticon5", u"ヽ(͡◕ ͜ʖ ͡◕)ﾉ",
+     "[0][1->2][3][4->5][6][7->8][9][10][11]"},
+    {"unicode_art1", u"꧁༒✧ Great ✧༒꧂", "[0][1][2][3][4->8][9][10][11][12]"},
+    {"unicode_art2", u"t͎e͎s͎t͎", "[0->7]"},
+
+    // Combining diacritical sequences.
+    {"unicode_diac1", u"\u2123\u0336", "[0->1]"},
+    {"unicode_diac2", u"\u273c\u0325", "[0->1]"},
+    {"unicode_diac3", u"\u2580\u033f", "[0->1]"},
+    {"unicode_diac4", u"\u2022\u0325\u0329", "[0->2]"},
+    {"unicode_diac5", u"\u2022\u0325", "[0->1]"},
+    {"unicode_diac6", u"\u00b7\u0359\u0325", "[0->2]"},
+    {"unicode_diac7", u"\u2027\u0329\u0325", "[0->2]"},
+    {"unicode_diac8", u"\u0332\u0305\u03c1", "[0->1][2]"},
+};
+
+INSTANTIATE_TEST_SUITE_P(ItemizeTextToRunsScripts,
+                         RenderTextTestWithRunListCase,
+                         ::testing::ValuesIn(kScriptsRunListCases),
+                         RenderTextTestWithRunListCase::ParamInfoToString);
+
+// Test cases to ensure ItemizeTextToRuns is splitting emoji correctly.
+// see: http://www.unicode.org/reports/tr51
+// see: http://www.unicode.org/emoji/charts/full-emoji-list.html
+const RunListCase kEmojiRunListCases[] = {
+    // Samples from
+    // https://www.unicode.org/Public/emoji/12.0/emoji-data.txt
+    {"number_sign", u"\u0023", "[0]"},
+    {"keyboard", u"\u2328", "[0]"},
+    {"aries", u"\u2648", "[0]"},
+    {"candle", u"\U0001F56F", "[0->1]"},
+    {"anchor", u"\u2693", "[0]"},
+    {"grinning_face", u"\U0001F600", "[0->1]"},
+    {"face_with_monocle", u"\U0001F9D0", "[0->1]"},
+    {"light_skin_tone", u"\U0001F3FB", "[0->1]"},
+    {"index_pointing_up", u"\u261D", "[0]"},
+    {"horse_racing", u"\U0001F3C7", "[0->1]"},
+    {"kiss", u"\U0001F48F", "[0->1]"},
+    {"couple_with_heart", u"\U0001F491", "[0->1]"},
+    {"people_wrestling", u"\U0001F93C", "[0->1]"},
+    {"eject_button", u"\u23CF", "[0]"},
+
+    // Samples from
+    // https://unicode.org/Public/emoji/12.0/emoji-sequences.txt
+    {"watch", u"\u231A", "[0]"},
+    {"cross_mark", u"\u274C", "[0]"},
+    {"copyright", u"\u00A9\uFE0F", "[0->1]"},
+    {"stop_button", u"\u23F9\uFE0F", "[0->1]"},
+    {"passenger_ship", u"\U0001F6F3\uFE0F", "[0->2]"},
+    {"keycap_star", u"\u002A\uFE0F\u20E3", "[0->2]"},
+    {"keycap_6", u"\u0036\uFE0F\u20E3", "[0->2]"},
+    {"flag_andorra", u"\U0001F1E6\U0001F1E9", "[0->3]"},
+    {"flag_egypt", u"\U0001F1EA\U0001F1EC", "[0->3]"},
+    {"flag_england",
+     u"\U0001F3F4\U000E0067\U000E0062\U000E0065\U000E006E\U000E0067\U000E007F",
+     "[0->13]"},
+    {"index_up_light", u"\u261D\U0001F3FB", "[0->2]"},
+    {"person_bouncing_ball_light", u"\u26F9\U0001F3FC", "[0->2]"},
+    {"victory_hand_med_light", u"\u270C\U0001F3FC", "[0->2]"},
+    {"horse_racing_med_dark", u"\U0001F3C7\U0001F3FE", "[0->3]"},
+    {"woman_man_hands_light", u"\U0001F46B\U0001F3FB", "[0->3]"},
+    {"person_haircut_med_light", u"\U0001F487\U0001F3FC", "[0->3]"},
+    {"pinching_hand_light", u"\U0001F90F\U0001F3FB", "[0->3]"},
+    {"love_you_light", u"\U0001F91F\U0001F3FB", "[0->3]"},
+    {"leg_dark", u"\U0001F9B5\U0001F3FF", "[0->3]"},
+
+    // Samples from
+    // https://unicode.org/Public/emoji/12.0/emoji-variation-sequences.txt
+    {"number_sign_text", u"\u0023\uFE0E", "[0->1]"},
+    {"number_sign_emoji", u"\u0023\uFE0F", "[0->1]"},
+    {"digit_eight_text", u"\u0038\uFE0E", "[0->1]"},
+    {"digit_eight_emoji", u"\u0038\uFE0F", "[0->1]"},
+    {"up_down_arrow_text", u"\u2195\uFE0E", "[0->1]"},
+    {"up_down_arrow_emoji", u"\u2195\uFE0F", "[0->1]"},
+    {"stopwatch_text", u"\u23F1\uFE0E", "[0->1]"},
+    {"stopwatch_emoji", u"\u23F1\uFE0F", "[0->1]"},
+    {"thermometer_text", u"\U0001F321\uFE0E", "[0->2]"},
+    {"thermometer_emoji", u"\U0001F321\uFE0F", "[0->2]"},
+    {"thumbs_up_text", u"\U0001F44D\uFE0E", "[0->2]"},
+    {"thumbs_up_emoji", u"\U0001F44D\uFE0F", "[0->2]"},
+    {"hole_text", u"\U0001F573\uFE0E", "[0->2]"},
+    {"hole_emoji", u"\U0001F573\uFE0F", "[0->2]"},
+
+    // Samples from
+    // https://unicode.org/Public/emoji/12.0/emoji-zwj-sequences.txt
+    {"couple_man_man", u"\U0001F468\u200D\u2764\uFE0F\u200D\U0001F468",
+     "[0->7]"},
+    {"kiss_man_man",
+     u"\U0001F468\u200D\u2764\uFE0F\u200D\U0001F48B\u200D\U0001F468",
+     "[0->10]"},
+    {"family_man_woman_girl_boy",
+     u"\U0001F468\u200D\U0001F469\u200D\U0001F467\u200D\U0001F466", "[0->10]"},
+    {"men_hands_dark_medium",
+     u"\U0001F468\U0001F3FF\u200D\U0001F91D\u200D\U0001F468\U0001F3FD",
+     "[0->11]"},
+    {"people_hands_dark",
+     u"\U0001F9D1\U0001F3FF\u200D\U0001F91D\u200D\U0001F9D1\U0001F3FF",
+     "[0->11]"},
+    {"man_pilot", u"\U0001F468\u200D\u2708\uFE0F", "[0->4]"},
+    {"man_scientist", u"\U0001F468\u200D\U0001F52C", "[0->4]"},
+    {"man_mechanic_light", u"\U0001F468\U0001F3FB\u200D\U0001F527", "[0->6]"},
+    {"man_judge_medium", u"\U0001F468\U0001F3FD\u200D\u2696\uFE0F", "[0->6]"},
+    {"woman_cane_dark", u"\U0001F469\U0001F3FF\u200D\U0001F9AF", "[0->6]"},
+    {"woman_ball_light", u"\u26F9\U0001F3FB\u200D\u2640\uFE0F", "[0->5]"},
+    {"woman_running", u"\U0001F3C3\u200D\u2640\uFE0F", "[0->4]"},
+    {"woman_running_dark", u"\U0001F3C3\U0001F3FF\u200D\u2640\uFE0F", "[0->6]"},
+    {"woman_turban", u"\U0001F473\u200D\u2640\uFE0F", "[0->4]"},
+    {"woman_detective", u"\U0001F575\uFE0F\u200D\u2640\uFE0F", "[0->5]"},
+    {"man_facepalming", u"\U0001F926\u200D\u2642\uFE0F", "[0->4]"},
+    {"man_red_hair", u"\U0001F468\u200D\U0001F9B0", "[0->4]"},
+    {"man_medium_curly", u"\U0001F468\U0001F3FD\u200D\U0001F9B1", "[0->6]"},
+    {"woman_dark_white_hair", u"\U0001F469\U0001F3FF\u200D\U0001F9B3",
+     "[0->6]"},
+    {"rainbow_flag", u"\U0001F3F3\uFE0F\u200D\U0001F308", "[0->5]"},
+    {"pirate_flag", u"\U0001F3F4\u200D\u2620\uFE0F", "[0->4]"},
+    {"service_dog", u"\U0001F415\u200D\U0001F9BA", "[0->4]"},
+    {"eye_bubble", u"\U0001F441\uFE0F\u200D\U0001F5E8\uFE0F", "[0->6]"},
+};
+
+INSTANTIATE_TEST_SUITE_P(ItemizeTextToRunsEmoji,
+                         RenderTextTestWithRunListCase,
+                         ::testing::ValuesIn(kEmojiRunListCases),
+                         RenderTextTestWithRunListCase::ParamInfoToString);
+
+struct ElideTextTestOptions {
+  const ElideBehavior elide_behavior;
+};
+
+const bool kForceNoWhitespaceElision = false;
+const bool kForceWhitespaceElision = true;
+
+struct ElideTextCase {
+  const char* test_name;
+  const char16_t* text;
+  const char16_t* display_text;
+  // The available width, specified as a number of fixed-width glyphs. If no
+  // value is specified, the width of the resulting |display_text| is used. This
+  // helps test available widths larger than the resulting test; e.g. "a  b"
+  // should yield "a…" even if 3 glyph widths are available, when
+  // whitespace elision is enabled.
+  const absl::optional<size_t> available_width_as_glyph_count = absl::nullopt;
+  const absl::optional<bool> whitespace_elision = absl::nullopt;
+};
+
+using ElideTextCaseParam = std::tuple<ElideTextTestOptions, ElideTextCase>;
+
+class RenderTextTestWithElideTextCase
+    : public RenderTextTest,
+      public ::testing::WithParamInterface<ElideTextCaseParam> {
+ public:
+  static std::string ParamInfoToString(
+      ::testing::TestParamInfo<ElideTextCaseParam> param_info) {
+    return std::get<1>(param_info.param).test_name;
+  }
+};
+
+TEST_P(RenderTextTestWithElideTextCase, ElideText) {
+  // This test requires glyphs to be the same width.
+  constexpr int kGlyphWidth = 10;
+  SetGlyphWidth(kGlyphWidth);
+
+  const ElideTextTestOptions options = std::get<0>(GetParam());
+  const ElideTextCase param = std::get<1>(GetParam());
+  const std::u16string text = param.text;
+  const std::u16string display_text = param.display_text;
+
+  // Retrieve the display_text width without eliding.
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetText(display_text);
+  const int expected_width = render_text->GetContentWidth();
+
+  // Set the text and the eliding behavior.
+  render_text->SetText(text);
+  render_text->SetElideBehavior(options.elide_behavior);
+
+  // If specified, set the whitespace elision. Otherwise, keep the eliding
+  // behavior default value.
+  if (param.whitespace_elision.has_value())
+    render_text->SetWhitespaceElision(param.whitespace_elision.value());
+
+  // Set the display width to trigger the eliding.
+  if (param.available_width_as_glyph_count.has_value()) {
+    render_text->SetDisplayRect(
+        Rect(0, 0,
+             param.available_width_as_glyph_count.value() * kGlyphWidth +
+                 kGlyphWidth / 2,
+             100));
+  } else {
+    render_text->SetDisplayRect(
+        Rect(0, 0, expected_width + kGlyphWidth / 2, 100));
+  }
+
+  const int elided_width = render_text->GetContentWidth();
+
+  EXPECT_EQ(text, render_text->text());
+  EXPECT_EQ(display_text, render_text->GetDisplayText());
+  EXPECT_EQ(elided_width, expected_width);
+}
+
+const ElideTextCase kElideHeadTextCases[] = {
+    {"empty", u"", u""},
+    {"letter_m_tail0", u"M", u""},
+    {"letter_m_tail1", u"M", u"M"},
+    {"no_eliding", u"012ab", u"012ab"},
+    {"ltr_3", u"abc", u"abc"},
+    {"ltr_2", u"abc", u"…c"},
+    {"ltr_1", u"abc", u"…"},
+    {"ltr_0", u"abc", u""},
+    {"rtl_3", u"אבג", u"אבג"},
+    {"rtl_2", u"אבג", u"…ג"},
+    {"rtl_1", u"אבג", u"…"},
+    {"rtl_0", u"אבג", u""},
+    {"ltr_rtl_5", u"abcאבג", u"…cאבג"},
+    {"ltr_rtl_4", u"abcאבג", u"…אבג"},
+    {"ltr_rtl_3", u"abcאבג", u"…בג"},
+    {"rtl_ltr_5", u"אבגabc", u"…גabc"},
+    {"rtl_ltr_4", u"אבגabc", u"…abc"},
+    {"rtl_ltr_3", u"אבגabc", u"…bc"},
+    {"bidi_1", u"aבbבc012", u"…bבc012"},
+    {"bidi_2", u"aבbבc012", u"…בc012"},
+    {"bidi_3", u"aבbבc012", u"…c012"},
+    // Test surrogate pairs. No surrogate pair should be partially elided.
+    {"surrogate1", u"abc\U0001D11E\U0001D122x", u"…\U0001D11E\U0001D122x"},
+    {"surrogate2", u"abc\U0001D11E\U0001D122x", u"…\U0001D122x"},
+    {"surrogate3", u"abc\U0001D11E\U0001D122x", u"…x"},
+    // Test combining character sequences. U+0915 U+093F forms a compound
+    // glyph, as does U+0915 U+0942. No combining sequence should be partially
+    // elided.
+    {"combining1", u"0123\u0915\u093f\u0915\u0942456", u"…\u0915\u0942456"},
+    {"combining2", u"0123\u0915\u093f\u0915\u0942456", u"…456"},
+    // 𝄞 (U+1D11E, MUSICAL SYMBOL G CLEF) should be fully elided.
+    {"emoji1", u"012\U0001D11Ex", u"…\U0001D11Ex"},
+    {"emoji2", u"012\U0001D11Ex", u"…x"},
+
+    // Whitespace elision tests.
+    {"empty_no_elision", u"", u"", 0, kForceNoWhitespaceElision},
+    {"empty_elision", u"", u"", 0, kForceWhitespaceElision},
+    {"xyz_no_elision", u"  x  xyz", u"… xyz", 5, kForceNoWhitespaceElision},
+    {"xyz_elision", u"  x  xyz", u"…xyz", 5, kForceWhitespaceElision},
+    {"ltr_rtl_elision3", u"x  ב  y    ג", u"…ג", 3, kForceWhitespaceElision},
+    {"ltr_rtl_elision6", u"x  ב  y    ג", u"…ג", 6, kForceWhitespaceElision},
+    {"ltr_rtl_elision7", u"x  ב  y    ג", u"…y    ג", 7,
+     kForceWhitespaceElision},
+    {"ltr_rtl_elision10", u"x  ב  y    ג", u"…ב  y    ג", 10,
+     kForceWhitespaceElision},
+    {"ltr_rtl_elision11", u"x  ב  y    ג", u"…ב  y    ג", 11,
+     kForceWhitespaceElision},
+    // Emoji U+1F601 and emoji U+1F321 U+FE0E are graphemes that result in
+    // one glyph each. Eliding a glyph must remove the whole grapheme. It is
+    // invalid to break a grapheme in pieces.
+    {"graphemes_elision3", u"  \U0001F601  \U0001F321\uFE0E  ", u"…", 3,
+     kForceWhitespaceElision},
+    {"graphemes_elision4", u"  \U0001F601  \U0001F321\uFE0E  ",
+     u"…\U0001F321\uFE0E  ", 4, kForceWhitespaceElision},
+    {"graphemes_elision6", u"  \U0001F601  \U0001F321\uFE0E  ",
+     u"…\U0001F321\uFE0E  ", 6, kForceWhitespaceElision},
+    {"graphemes_elision7", u"  \U0001F601  \U0001F321\uFE0E  ",
+     u"…\U0001F601  \U0001F321\uFE0E  ", 7, kForceWhitespaceElision},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    ElideHead,
+    RenderTextTestWithElideTextCase,
+    testing::Combine(testing::Values(ElideTextTestOptions{ELIDE_HEAD}),
+                     testing::ValuesIn(kElideHeadTextCases)),
+    RenderTextTestWithElideTextCase::ParamInfoToString);
+
+const ElideTextCase kElideTailTextCases[] = {
+    {"empty", u"", u""},
+    {"letter_m_tail0", u"M", u""},
+    {"letter_m_tail1", u"M", u"M"},
+    {"letter_weak_3", u" . ", u" . "},
+    {"letter_weak_2", u" . ", u"…"},
+    {"no_eliding", u"012ab", u"012ab"},
+    {"ltr_3", u"abc", u"abc"},
+    {"ltr_2", u"abc", u"a…"},
+    {"ltr_1", u"abc", u"…"},
+    {"ltr_0", u"abc", u""},
+    {"rtl_3", u"אבג", u"אבג"},
+    {"rtl_2", u"אבג", u"א…"},
+    {"rtl_1", u"אבג", u"…"},
+    {"rtl_0", u"אבג", u""},
+    {"ltr_rtl_5", u"abcאבג", u"abcא…\u200F"},
+    {"ltr_rtl_4", u"abcאבג", u"abc…"},
+    {"ltr_rtl_3", u"abcאבג", u"ab…"},
+    {"rtl_ltr_5", u"אבגabc", u"אבגa…\u200E"},
+    {"rtl_ltr_4", u"אבגabc", u"אבג…"},
+    {"rtl_ltr_3", u"אבגabc", u"אב…"},
+    {"bidi_1", u"012aבbבc", u"012a…"},
+    {"bidi_2", u"012aבbבc", u"012aב…\u200F"},
+    {"bidi_3", u"012aבbבc", u"012aבb…"},
+    // No RLM marker added as digits (012) have weak directionality.
+    {"no_rlm", u"01אבג", u"01א…"},
+    // RLM marker added as "ab" have strong LTR directionality.
+    {"with_rlm", u"abאבגcd", u"abאב…\u200f"},
+    // Test surrogate pairs. The first pair 𝄞 'MUSICAL SYMBOL G CLEF' U+1D11E
+    // should be kept, and the second pair 𝄢 'MUSICAL SYMBOL F CLEF' U+1D122
+    // should be removed. No surrogate pair should be partially elided.
+    {"surrogate", u"0123\U0001D11E\U0001D122x", u"0123\U0001D11E…"},
+    // Test combining character sequences. U+0915 U+093F forms a compound
+    // glyph, as does U+0915 U+0942. The first should be kept; the second
+    // removed. No combining sequence should be partially elided.
+    {"combining", u"0123\u0915\u093f\u0915\u0942456", u"0123\u0915\u093f…"},
+    // U+05E9 U+05BC U+05C1 U+05B8 forms a four-character compound glyph.
+    // It should be either fully elided, or not elided at all. If completely
+    // elided, an LTR Mark (U+200E) should be added.
+    {"grapheme1", u"0\u05e9\u05bc\u05c1\u05b8", u"0\u05e9\u05bc\u05c1\u05b8"},
+    {"grapheme2", u"0\u05e9\u05bc\u05c1\u05b8abc", u"0…\u200E"},
+    {"grapheme3", u"01\u05e9\u05bc\u05c1\u05b8abc", u"01…\u200E"},
+    {"grapheme4", u"012\u05e9\u05bc\u05c1\u05b8abc", u"012…\u200E"},
+    // 𝄞 (U+1D11E, MUSICAL SYMBOL G CLEF) should be fully elided.
+    {"emoji", u"012\U0001D11Ex", u"012…"},
+
+    // Whitespace elision tests.
+    {"empty_no_elision", u"", u"", 0, kForceNoWhitespaceElision},
+    {"empty_elision", u"", u"", 0, kForceWhitespaceElision},
+    {"letter_weak_2_no_elision", u" . ", u" …", 2, kForceNoWhitespaceElision},
+    {"xyz_no_elision", u"  x  xyz", u"  x …", 5, kForceNoWhitespaceElision},
+    {"xyz_elision", u"  x  xyz", u"  x…", 5, kForceWhitespaceElision},
+    {"ltr_rtl_elision4", u"x  ב  y    ג", u"x…", 4, kForceWhitespaceElision},
+    {"ltr_rtl_elision5", u"x  ב  y    ג", u"x  ב…\u200F", 5,
+     kForceWhitespaceElision},
+    {"ltr_rtl_elision9", u"x  ב  y    ג", u"x  ב  y…", 9,
+     kForceWhitespaceElision},
+    // Emoji U+1F601 and emoji U+1F321 U+FE0E are graphemes that result in
+    // one glyph each. Eliding a glyph must remove the whole grapheme. It is
+    // invalid to break a grapheme in pieces.
+    {"graphemes_elision3", u"  \U0001F601  \U0001F321\uFE0E  ", u"…", 3,
+     kForceWhitespaceElision},
+    {"graphemes_elision6", u"  \U0001F601  \U0001F321\uFE0E  ",
+     u"  \U0001F601…", 6, kForceWhitespaceElision},
+    {"graphemes_elision7", u"  \U0001F601  \U0001F321\uFE0E  ",
+     u"  \U0001F601  \U0001F321\uFE0E…", 7, kForceWhitespaceElision},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    ElideTail,
+    RenderTextTestWithElideTextCase,
+    testing::Combine(testing::Values(ElideTextTestOptions{ELIDE_TAIL}),
+                     testing::ValuesIn(kElideTailTextCases)),
+    RenderTextTestWithElideTextCase::ParamInfoToString);
+
+const ElideTextCase kElideTruncateTextCases[] = {
+    {"empty", u"", u""},
+    {"letter_m_tail0", u"M", u""},
+    {"letter_m_tail1", u"M", u"M"},
+    {"no_eliding", u"012ab", u"012ab"},
+    {"ltr_3", u"abc", u"abc"},
+    {"ltr_2", u"abc", u"ab"},
+    {"ltr_1", u"abc", u"a"},
+    {"ltr_0", u"abc", u""},
+    {"rtl_3", u"אבג", u"אבג"},
+    {"rtl_2", u"אבג", u"אב"},
+    {"rtl_1", u"אבג", u"א"},
+    {"rtl_0", u"אבג", u""},
+    {"ltr_rtl_5", u"abcאבג", u"abcאב"},
+    {"ltr_rtl_4", u"abcאבג", u"abcא"},
+    {"ltr_rtl_3", u"abcאבג", u"abc"},
+    {"ltr_rtl_2", u"abcאבג", u"ab"},
+    {"rtl_ltr_5", u"אבגabc", u"אבגab"},
+    {"rtl_ltr_4", u"אבגabc", u"אבגa"},
+    {"rtl_ltr_3", u"אבגabc", u"אבג"},
+    {"rtl_ltr_2", u"אבגabc", u"אב"},
+    {"bidi_1", u"012aבbבc", u"012aבbב"},
+    {"bidi_2", u"012aבbבc", u"012aבb"},
+    {"bidi_3", u"012aבbבc", u"012aב"},
+    {"bidi_4", u"012aבbבc", u"012aב"},
+    // Test surrogate pairs. The first pair 𝄞 'MUSICAL SYMBOL G CLEF' U+1D11E
+    // should be kept, and the second pair 𝄢 'MUSICAL SYMBOL F CLEF' U+1D122
+    // should be removed. No surrogate pair should be partially elided.
+    {"surrogate1", u"0123\U0001D11E\U0001D122x", u"0123\U0001D11E\U0001D122"},
+    {"surrogate2", u"0123\U0001D11E\U0001D122x", u"0123\U0001D11E"},
+    {"surrogate3", u"0123\U0001D11E\U0001D122x", u"0123"},
+    // Test combining character sequences. U+0915 U+093F forms a compound
+    // glyph, as does U+0915 U+0942. The first should be kept; the second
+    // removed. No combining sequence should be partially elided.
+    {"combining", u"0123\u0915\u093f\u0915\u0942456", u"0123\u0915\u093f"},
+    // 𝄞 (U+1D11E, MUSICAL SYMBOL G CLEF) should be fully elided.
+    {"emoji1", u"012\U0001D11Ex", u"012\U0001D11E"},
+    {"emoji2", u"012\U0001D11Ex", u"012"},
+
+    // Whitespace elision tests.
+    {"empty_no_elision", u"", u"", 0, kForceNoWhitespaceElision},
+    {"empty_elision", u"", u"", 0, kForceWhitespaceElision},
+    {"xyz_no_elision", u"  x  xyz", u"  x  ", 5, kForceNoWhitespaceElision},
+    {"xyz_elision", u"  x  xyz", u"  x", 5, kForceWhitespaceElision},
+    {"ltr_rtl_elision3", u"x  ב  y    ג", u"x", 3, kForceWhitespaceElision},
+    {"ltr_rtl_elision4", u"x  ב  y    ג", u"x  ב", 4, kForceWhitespaceElision},
+    {"ltr_rtl_elision5", u"x  ב  y    ג", u"x  ב", 5, kForceWhitespaceElision},
+    {"ltr_rtl_elision9", u"x  ב  y    ג", u"x  ב  y", 9,
+     kForceWhitespaceElision},
+    // Emoji U+1F601 and emoji U+1F321 U+FE0E are graphemes that result in
+    // one glyph each. Eliding a glyph must remove the whole grapheme. It is
+    // invalid to break a grapheme in pieces.
+    {"graphemes_elision2", u"  \U0001F601  \U0001F321\uFE0E  ", u"", 2,
+     kForceWhitespaceElision},
+    {"graphemes_elision3", u"  \U0001F601  \U0001F321\uFE0E  ", u"  \U0001F601",
+     3, kForceWhitespaceElision},
+    {"graphemes_elision5", u"  \U0001F601  \U0001F321\uFE0E  ", u"  \U0001F601",
+     5, kForceWhitespaceElision},
+    {"graphemes_elision6", u"  \U0001F601  \U0001F321\uFE0E  ",
+     u"  \U0001F601  \U0001F321\uFE0E", 6, kForceWhitespaceElision},
+    {"graphemes_elision7", u"  \U0001F601  \U0001F321\uFE0E  ",
+     u"  \U0001F601  \U0001F321\uFE0E", 7, kForceWhitespaceElision},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    ElideTruncate,
+    RenderTextTestWithElideTextCase,
+    testing::Combine(testing::Values(ElideTextTestOptions{TRUNCATE}),
+                     testing::ValuesIn(kElideTruncateTextCases)),
+    RenderTextTestWithElideTextCase::ParamInfoToString);
+
+const ElideTextCase kElideEmailTextCases[] = {
+    // Invalid email text.
+    {"empty", u"", u""},
+    {"invalid_char1", u"x", u""},
+    {"invalid_char3", u"xyz", u"x…"},
+    {"invalid_amp", u"@", u""},
+    {"invalid_no_prefix0", u"@y", u""},
+    {"invalid_no_prefix1", u"@y", u"…"},
+    {"invalid_no_prefix2", u"@xyz", u"@x…"},
+    {"invalid_no_suffix0", u"x@", u""},
+    {"invalid_no_suffix1", u"x@", u"…"},
+    {"invalid_no_suffix2", u"xyz@", u"x…@"},
+
+    {"at1", u"@", u"@"},
+    {"at2", u"@@", u"…", 1},
+    {"at3", u"@@@", u"…", 2},
+    {"at4", u"@@@@", u"@…@", 3},
+
+    {"small1", u"a@b", u"…", 1},
+    {"small2", u"a@b", u"…", 2},
+    {"small3", u"a@b", u"a@b", 3},
+    {"small_username3", u"xyz@b", u"…", 3},
+    {"small_username4", u"xyz@b", u"x…@b", 4},
+    {"small_username5", u"xyz@b", u"xyz@b", 5},
+    {"small_domain3", u"a@xyz", u"…", 3},
+    {"small_domain4", u"a@xyz", u"a@x…", 4},
+    {"small_domain5", u"a@xyz", u"a@xyz", 5},
+
+    // Valid email.
+    {"email_small", u"a@b.com", u"…"},
+    {"email_nobody3", u"nobody@gmail.com", u"…", 3},
+    {"email_nobody4", u"nobody@gmail.com", u"…", 4},
+    {"email_nobody5", u"nobody@gmail.com", u"n…@g…", 5},
+    {"email_nobody6", u"nobody@gmail.com", u"no…@g…", 6},
+    {"email_nobody7", u"nobody@gmail.com", u"no…@g…m", 7},
+    {"email_nobody8", u"nobody@gmail.com", u"nob…@g…m", 8},
+    {"email_nobody9", u"nobody@gmail.com", u"nob…@gm…m", 9},
+    {"email_nobody10", u"nobody@gmail.com", u"nobo…@gm…m", 10},
+    {"email_root", u"root@localhost", u"r…@l…", 5},
+    {"email_myself", u"myself@127.0.0.1", u"my…@1…", 6},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    ElideEmail,
+    RenderTextTestWithElideTextCase,
+    testing::Combine(testing::Values(ElideTextTestOptions{ELIDE_EMAIL}),
+                     testing::ValuesIn(kElideEmailTextCases)),
+    RenderTextTestWithElideTextCase::ParamInfoToString);
+
+TEST_F(RenderTextTest, ElidedText_NoTrimWhitespace) {
+  // This test requires glyphs to be the same width.
+  constexpr int kGlyphWidth = 10;
+  SetGlyphWidth(kGlyphWidth);
+
+  RenderText* render_text = GetRenderText();
+  gfx::test::RenderTextTestApi render_text_test_api(render_text);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetWhitespaceElision(false);
+
+  // Pick a sufficiently long string that's mostly whitespace.
+  // Tail-eliding this with whitespace elision turned off should look like:
+  // [       ...]
+  // and not like:
+  // [...       ]
+  constexpr char16_t kInputString[] = u"                     foo";
+  render_text->SetText(kInputString);
+
+  // Choose a width based on being able to display 12 characters (one of which
+  // will be the trailing ellipsis).
+  constexpr int kDesiredChars = 12;
+  constexpr int kRequiredWidth = (kDesiredChars + 0.5f) * kGlyphWidth;
+  render_text->SetDisplayRect(Rect(0, 0, kRequiredWidth, 100));
+
+  // Verify this doesn't change the full text.
+  EXPECT_EQ(kInputString, render_text->text());
+
+  // Verify that the string is truncated to |kDesiredChars| with the ellipsis.
+  const std::u16string result = render_text->GetDisplayText();
+  const std::u16string expected =
+      std::u16string(kInputString).substr(0, kDesiredChars - 1) +
+      kEllipsisUTF16[0];
+  EXPECT_EQ(expected, result);
+}
+
+TEST_F(RenderTextTest, SetElideBehavior) {
+  // This test requires glyphs to be the same width.
+  constexpr int kGlyphWidth = 10;
+  SetGlyphWidth(kGlyphWidth);
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdef");
+  render_text->SetCursorEnabled(false);
+  render_text->SetDisplayRect(Rect(0, 0, 3 * kGlyphWidth, 100));
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  EXPECT_EQ(u"ab…", render_text->GetDisplayText());
+
+  // Setting a different eliding behavior must trigger a relayout.
+  render_text->SetElideBehavior(ELIDE_HEAD);
+  EXPECT_EQ(u"…ef", render_text->GetDisplayText());
+}
+
+TEST_F(RenderTextTest, SetWhitespaceElision) {
+  // This test requires glyphs to be the same width.
+  constexpr int kGlyphWidth = 10;
+  SetGlyphWidth(kGlyphWidth);
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"a b c d");
+  render_text->SetCursorEnabled(false);
+  render_text->SetDisplayRect(Rect(0, 0, 3 * kGlyphWidth, 100));
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetWhitespaceElision(false);
+  EXPECT_EQ(u"a …", render_text->GetDisplayText());
+
+  // Setting a different whitespace elision must trigger a relayout.
+  render_text->SetWhitespaceElision(true);
+  EXPECT_EQ(u"a…", render_text->GetDisplayText());
+}
+
+TEST_F(RenderTextTest, ElidedObscuredText) {
+  auto expected_render_text = std::make_unique<RenderTextHarfBuzz>();
+  expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
+  const char16_t elided_obscured_text[] = {RenderText::kPasswordReplacementChar,
+                                           RenderText::kPasswordReplacementChar,
+                                           kEllipsisUTF16[0], 0};
+  expected_render_text->SetText(elided_obscured_text);
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetDisplayRect(
+      Rect(0, 0, expected_render_text->GetContentWidth(), 100));
+  render_text->SetObscured(true);
+  render_text->SetText(u"abcdef");
+  EXPECT_EQ(u"abcdef", render_text->text());
+  EXPECT_EQ(elided_obscured_text, render_text->GetDisplayText());
+}
+
+TEST_F(RenderTextTest, MultilineElide) {
+  RenderText* render_text = GetRenderText();
+  std::u16string input_text;
+  // Aim for 3 lines of text.
+  for (int i = 0; i < 20; ++i)
+    input_text.append(u"hello world ");
+  render_text->SetText(input_text);
+  // Apply a style that tweaks the layout to make sure elision is calculated
+  // with these styles. This can expose a behavior in layout where text is
+  // slightly different width. This must be done after |SetText()|.
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(1, 20));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(1, 20));
+  render_text->SetMultiline(true);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetMaxLines(3);
+  const Size size = render_text->GetStringSize();
+  // Fit in 3 lines. (If we knew the width of a word, we could
+  // anticipate word wrap better.)
+  render_text->SetDisplayRect(Rect((size.width() + 96) / 3, 0));
+  // Trigger rendering.
+  render_text->GetStringSize();
+  EXPECT_EQ(input_text, render_text->GetDisplayText());
+
+  std::u16string actual_text;
+  // Try widening the space gradually, one pixel at a time, trying
+  // to trigger a failure in layout. There was an issue where, right at
+  // the edge of a word getting truncated, the estimate would be wrong
+  // and it would wrap instead.
+  for (int i = (size.width() - 12) / 3; i < (size.width() + 30) / 3; ++i) {
+    render_text->SetDisplayRect(Rect(i, 0));
+    // Trigger rendering.
+    render_text->GetStringSize();
+    actual_text = render_text->GetDisplayText();
+    EXPECT_LT(actual_text.size(), input_text.size());
+    EXPECT_EQ(actual_text, input_text.substr(0, actual_text.size() - 1) +
+                               std::u16string(kEllipsisUTF16));
+    EXPECT_EQ(3U, render_text->GetNumLines());
+  }
+  // Now remove line restriction.
+  render_text->SetMaxLines(0);
+  render_text->GetStringSize();
+  EXPECT_EQ(input_text, render_text->GetDisplayText());
+
+  // And put it back.
+  render_text->SetMaxLines(3);
+  render_text->GetStringSize();
+  EXPECT_LT(actual_text.size(), input_text.size());
+  EXPECT_EQ(actual_text, input_text.substr(0, actual_text.size() - 1) +
+                             std::u16string(kEllipsisUTF16));
+}
+
+TEST_F(RenderTextTest, MultilineElideWrap) {
+  RenderText* render_text = GetRenderText();
+  std::u16string input_text;
+  for (int i = 0; i < 20; ++i)
+    input_text.append(u"hello world ");
+  render_text->SetText(input_text);
+  render_text->SetMultiline(true);
+  render_text->SetMaxLines(3);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetDisplayRect(Rect(30, 0));
+
+  // ELIDE_LONG_WORDS doesn't make sense in multiline, and triggers assertion
+  // failure.
+  const WordWrapBehavior wrap_behaviors[] = {
+      IGNORE_LONG_WORDS, TRUNCATE_LONG_WORDS, WRAP_LONG_WORDS};
+  for (auto wrap_behavior : wrap_behaviors) {
+    render_text->SetWordWrapBehavior(wrap_behavior);
+    render_text->GetStringSize();
+    std::u16string actual_text = render_text->GetDisplayText();
+    EXPECT_LE(actual_text.size(), input_text.size());
+    EXPECT_EQ(actual_text, input_text.substr(0, actual_text.size() - 1) +
+                               std::u16string(kEllipsisUTF16));
+    EXPECT_LE(render_text->GetNumLines(), 3U);
+  }
+}
+
+// TODO(crbug.com/866720): The current implementation of eliding is not aware
+// of text styles. The elide text algorithm doesn't take into account the style
+// properties when eliding the text. This lead to incorrect text size when the
+// styles are applied.
+TEST_F(RenderTextTest, DISABLED_MultilineElideWrapWithStyle) {
+  RenderText* render_text = GetRenderText();
+  std::u16string input_text;
+  for (int i = 0; i < 20; ++i)
+    input_text.append(u"hello world ");
+  render_text->SetText(input_text);
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(1, 20));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(1, 20));
+  render_text->SetMultiline(true);
+  render_text->SetMaxLines(3);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetDisplayRect(Rect(30, 0));
+
+  // ELIDE_LONG_WORDS doesn't make sense in multiline, and triggers assertion
+  // failure.
+  const WordWrapBehavior wrap_behaviors[] = {
+      IGNORE_LONG_WORDS, TRUNCATE_LONG_WORDS, WRAP_LONG_WORDS};
+  for (auto wrap_behavior : wrap_behaviors) {
+    render_text->SetWordWrapBehavior(wrap_behavior);
+    render_text->GetStringSize();
+    std::u16string actual_text = render_text->GetDisplayText();
+    EXPECT_LE(actual_text.size(), input_text.size());
+    EXPECT_EQ(actual_text, input_text.substr(0, actual_text.size() - 1) +
+                               std::u16string(kEllipsisUTF16));
+    EXPECT_LE(render_text->GetNumLines(), 3U);
+  }
+}
+
+TEST_F(RenderTextTest, MultilineElideWrapStress) {
+  RenderText* render_text = GetRenderText();
+  std::u16string input_text;
+  for (int i = 0; i < 20; ++i)
+    input_text.append(u"hello world ");
+  render_text->SetText(input_text);
+  render_text->SetMultiline(true);
+  render_text->SetMaxLines(3);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+
+  // ELIDE_LONG_WORDS doesn't make sense in multiline, and triggers assertion
+  // failure.
+  const WordWrapBehavior wrap_behaviors[] = {
+      IGNORE_LONG_WORDS, TRUNCATE_LONG_WORDS, WRAP_LONG_WORDS};
+  for (auto wrap_behavior : wrap_behaviors) {
+    for (int i = 1; i < 60; ++i) {
+      SCOPED_TRACE(base::StringPrintf(
+          "MultilineElideWrapStress wrap_behavior = %d, width = %d",
+          wrap_behavior, i));
+
+      render_text->SetDisplayRect(Rect(i, 0));
+      render_text->SetWordWrapBehavior(wrap_behavior);
+      render_text->GetStringSize();
+      std::u16string actual_text = render_text->GetDisplayText();
+      EXPECT_LE(actual_text.size(), input_text.size());
+      EXPECT_LE(render_text->GetNumLines(), 3U);
+    }
+  }
+}
+
+// TODO(crbug.com/866720): The current implementation of eliding is not aware
+// of text styles. The elide text algorithm doesn't take into account the style
+// properties when eliding the text. This lead to incorrect text size when the
+// styles are applied.
+TEST_F(RenderTextTest, DISABLED_MultilineElideWrapStressWithStyle) {
+  RenderText* render_text = GetRenderText();
+  std::u16string input_text;
+  for (int i = 0; i < 20; ++i)
+    input_text.append(u"hello world ");
+  render_text->SetText(input_text);
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(1, 20));
+  render_text->SetMultiline(true);
+  render_text->SetMaxLines(3);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+
+  // ELIDE_LONG_WORDS doesn't make sense in multiline, and triggers assertion
+  // failure.
+  const WordWrapBehavior wrap_behaviors[] = {
+      IGNORE_LONG_WORDS, TRUNCATE_LONG_WORDS, WRAP_LONG_WORDS};
+  for (auto wrap_behavior : wrap_behaviors) {
+    for (int i = 1; i < 60; ++i) {
+      SCOPED_TRACE(base::StringPrintf(
+          "MultilineElideWrapStress wrap_behavior = %d, width = %d",
+          wrap_behavior, i));
+
+      render_text->SetDisplayRect(Rect(i, 0));
+      render_text->SetWordWrapBehavior(wrap_behavior);
+      render_text->GetStringSize();
+      std::u16string actual_text = render_text->GetDisplayText();
+      EXPECT_LE(actual_text.size(), input_text.size());
+      EXPECT_LE(render_text->GetNumLines(), 3U);
+    }
+  }
+}
+
+TEST_F(RenderTextTest, MultilineElideRTL) {
+  RenderText* render_text = GetRenderText();
+  SetGlyphWidth(5);
+
+  std::u16string input_text(u"זהו המסר של ההודעה");
+  render_text->SetText(input_text);
+  render_text->SetCursorEnabled(false);
+  render_text->SetMultiline(true);
+  render_text->SetMaxLines(1);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetDisplayRect(Rect(45, 0));
+  render_text->GetStringSize();
+
+  EXPECT_EQ(render_text->GetDisplayText(),
+            input_text.substr(0, 8) + std::u16string(kEllipsisUTF16));
+  EXPECT_EQ(render_text->GetNumLines(), 1U);
+}
+
+TEST_F(RenderTextTest, MultilineElideBiDi) {
+  RenderText* render_text = GetRenderText();
+  SetGlyphWidth(5);
+
+  std::u16string input_text(u"אa\nbcdבגדהefg\nhו");
+  render_text->SetText(input_text);
+  render_text->SetCursorEnabled(false);
+  render_text->SetMultiline(true);
+  render_text->SetMaxLines(2);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetDisplayRect(Rect(30, 0));
+  test_api()->EnsureLayout();
+
+  EXPECT_EQ(render_text->GetDisplayText(),
+            u"אa\nbcdבג" + std::u16string(kEllipsisUTF16));
+  EXPECT_EQ(render_text->GetNumLines(), 2U);
+}
+
+TEST_F(RenderTextTest, MultilineElideLinebreak) {
+  RenderText* render_text = GetRenderText();
+  SetGlyphWidth(5);
+
+  std::u16string input_text(u"hello\nworld");
+  render_text->SetText(input_text);
+  render_text->SetCursorEnabled(false);
+  render_text->SetMultiline(true);
+  render_text->SetMaxLines(1);
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetDisplayRect(Rect(100, 0));
+  render_text->GetStringSize();
+
+  EXPECT_EQ(render_text->GetDisplayText(),
+            input_text.substr(0, 5) + std::u16string(kEllipsisUTF16));
+  EXPECT_EQ(render_text->GetNumLines(), 1U);
+}
+
+TEST_F(RenderTextTest, ElidedStyledTextRtl) {
+  static const char16_t* kInputTexts[] = {
+      u"http://ar.wikipedia.com/فحص",
+      u"testحص,",
+      u"حص,test",
+      u"…",
+      u"…test",
+      u"test…",
+      u"حص,test…",
+      u"ٱ",
+      u"\uFEFF",   // BOM: Byte Order Marker
+      u"…\u200F",  // Right to left marker.
+  };
+
+  for (const auto* raw_text : kInputTexts) {
+    std::u16string input_text(raw_text);
+    SCOPED_TRACE(u"ElidedStyledTextRtl text = " + input_text);
+
+    RenderText* render_text = GetRenderText();
+    render_text->SetText(input_text);
+    render_text->SetElideBehavior(ELIDE_TAIL);
+    render_text->SetStyle(TEXT_STYLE_STRIKE, true);
+    render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
+
+    constexpr int kMaxContentWidth = 2000;
+    for (int i = 0; i < kMaxContentWidth; ++i) {
+      SCOPED_TRACE(base::StringPrintf("ElidedStyledTextRtl width = %d", i));
+      render_text->SetDisplayRect(Rect(i, 20));
+      render_text->GetStringSize();
+      std::u16string display_text = render_text->GetDisplayText();
+      EXPECT_LE(display_text.size(), input_text.size());
+
+      // Every size of content width was tried.
+      if (display_text == input_text)
+        break;
+    }
+  }
+}
+
+TEST_F(RenderTextTest, ElidedEmail) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"test@example.com");
+  const Size size = render_text->GetStringSize();
+
+  const std::u16string long_email = u"longemailaddresstest@example.com";
+  render_text->SetText(long_email);
+  render_text->SetElideBehavior(ELIDE_EMAIL);
+  render_text->SetDisplayRect(Rect(size));
+  EXPECT_GE(size.width(), render_text->GetStringSize().width());
+  EXPECT_GT(long_email.size(), render_text->GetDisplayText().size());
+}
+
+TEST_F(RenderTextTest, TruncatedText) {
+  struct {
+    const char16_t* text;
+    const char16_t* display_text;
+  } cases[] = {
+      // Strings shorter than the truncation length should be laid out in full.
+      {u"", u""},
+      {u" . ", u" . "},  // a wide kWeak
+      {u"abc", u"abc"},  // a wide kLtr
+      {u"אבג", u"אבג"},  // a wide kRtl
+      {u"aאב", u"aאב"},  // a wide kLtrRtl
+      {u"aבb", u"aבb"},  // a wide kLtrRtlLtr
+      {u"אבa", u"אבa"},  // a wide kRtlLtr
+      {u"אaב", u"אaב"},  // a wide kRtlLtrRtl
+      {u"01234", u"01234"},
+      // Long strings should be truncated with an ellipsis appended at the end.
+      {u"012345", u"0123…"},
+      {u"012 . ", u"012 …"},
+      {u"012abc", u"012a…"},
+      {u"012aאב", u"012a…"},
+      {u"012aבb", u"012a…"},
+      {u"012אבג", u"012א…"},
+      {u"012אבa", u"012א…"},
+      {u"012אaב", u"012א…"},
+      // Surrogate pairs should be truncated reasonably enough.
+      {u"0123\u0915\u093f", u"0123…"},
+      {u"\u05e9\u05bc\u05c1\u05b8", u"\u05e9\u05bc\u05c1\u05b8"},
+      {u"0\u05e9\u05bc\u05c1\u05b8", u"0\u05e9\u05bc\u05c1\u05b8"},
+      {u"01\u05e9\u05bc\u05c1\u05b8", u"01…"},
+      {u"012\u05e9\u05bc\u05c1\u05b8", u"012…"},
+      // Codepoint U+0001D11E is using 2x 16-bit characters.
+      {u"0\U0001D11Eaaa", u"0\U0001D11Ea…"},
+      {u"01\U0001D11Eaaa", u"01\U0001D11E…"},
+      {u"012\U0001D11Eaaa", u"012…"},
+      {u"0123\U0001D11Eaaa", u"0123…"},
+      {u"01234\U0001D11Eaaa", u"0123…"},
+      // Combining codepoint should stay together.
+      // (Letter 'e' U+0065 and acute accent U+0301).
+      {u"0e\u0301aaa", u"0e\u0301a…"},
+      {u"01e\u0301aaa", u"01e\u0301…"},
+      {u"012e\u0301aaa", u"012…"},
+      // Emoji 'keycap letter 6'.
+      {u"\u0036\uFE0F\u20E3aaa", u"\u0036\uFE0F\u20E3a…"},
+      {u"0\u0036\uFE0F\u20E3aaa", u"0\u0036\uFE0F\u20E3…"},
+      {u"01\u0036\uFE0F\u20E3aaa", u"01…"},
+      // Emoji 'pilot'.
+      {u"\U0001F468\u200D\u2708\uFE0F", u"\U0001F468\u200D\u2708\uFE0F"},
+      {u"\U0001F468\u200D\u2708\uFE0F0", u"…"},
+      {u"0\U0001F468\u200D\u2708\uFE0F", u"0…"},
+  };
+
+  RenderText* render_text = GetRenderText();
+  render_text->set_truncate_length(5);
+  for (size_t i = 0; i < base::size(cases); i++) {
+    render_text->SetText(cases[i].text);
+    EXPECT_EQ(cases[i].text, render_text->text());
+    EXPECT_EQ(cases[i].display_text, render_text->GetDisplayText())
+        << "For case " << i << ": " << cases[i].text;
+  }
+}
+
+TEST_F(RenderTextTest, TruncatedObscuredText) {
+  RenderText* render_text = GetRenderText();
+  render_text->set_truncate_length(3);
+  render_text->SetObscured(true);
+  render_text->SetText(u"abcdef");
+  EXPECT_EQ(u"abcdef", render_text->text());
+  EXPECT_EQ(GetObscuredString(3, 2, kEllipsisUTF16[0]),
+            render_text->GetDisplayText());
+}
+
+TEST_F(RenderTextTest, TruncatedObscuredTextWithGraphemes) {
+  RenderText* render_text = GetRenderText();
+  render_text->set_truncate_length(3);
+  render_text->SetText(u"e\u0301\U0001F468\u200D\u2708\uFE0F\U0001D11E");
+  render_text->SetObscured(true);
+  EXPECT_EQ(GetObscuredString(3), render_text->GetDisplayText());
+
+  render_text->SetObscuredRevealIndex(0);
+  EXPECT_EQ(u"e\u0301…", render_text->GetDisplayText());
+
+  render_text->SetObscuredRevealIndex(2);
+  EXPECT_EQ(u"\u2022…", render_text->GetDisplayText());
+
+  render_text->SetObscuredRevealIndex(7);
+  EXPECT_EQ(u"\u2022\u2022…", render_text->GetDisplayText());
+}
+
+TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
+  RenderText* render_text = GetRenderText();
+  render_text->set_truncate_length(2);
+  render_text->SetText(u"abcd");
+
+  EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+
+  std::vector<SelectionModel> expected;
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  // The cursor hops over the ellipsis and elided text to the line end.
+  expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(4, CURSOR_FORWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_RIGHT);
+
+  expected.clear();
+  expected.push_back(SelectionModel(4, CURSOR_FORWARD));
+  // The cursor hops over the elided text to preceeding text.
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_LEFT);
+}
+
+TEST_F(RenderTextTest, TruncatedCursorMovementRTL) {
+  RenderText* render_text = GetRenderText();
+  render_text->set_truncate_length(2);
+  render_text->SetText(u"אבגד");
+
+  EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+
+  std::vector<SelectionModel> expected;
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  // The cursor hops over the ellipsis and elided text to the line end.
+  expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(4, CURSOR_FORWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_LEFT);
+
+  expected.clear();
+  expected.push_back(SelectionModel(4, CURSOR_FORWARD));
+  // The cursor hops over the elided text to preceeding text.
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_RIGHT);
+}
+
+TEST_F(RenderTextTest, MoveCursor_Character) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"123 456 789");
+  std::vector<Range> expected;
+
+  // SELECTION_NONE.
+  render_text->SelectRange(Range(6));
+
+  // Move right twice.
+  expected.push_back(Range(7));
+  expected.push_back(Range(8));
+  RunMoveCursorTestAndClearExpectations(
+      render_text, CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(7));
+  expected.push_back(Range(6));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_LEFT, SELECTION_NONE, &expected);
+
+  // SELECTION_CARET.
+  render_text->SelectRange(Range(6));
+  expected.push_back(Range(6, 7));
+
+  // Move right.
+  RunMoveCursorTestAndClearExpectations(
+      render_text, CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_CARET, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(6));
+  expected.push_back(Range(6, 5));
+  RunMoveCursorTestAndClearExpectations(
+      render_text, CHARACTER_BREAK, CURSOR_LEFT, SELECTION_CARET, &expected);
+
+  // SELECTION_RETAIN.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 7));
+  RunMoveCursorTestAndClearExpectations(
+      render_text, CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(6));
+  expected.push_back(Range(6, 5));
+  RunMoveCursorTestAndClearExpectations(
+      render_text, CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN, &expected);
+
+  // SELECTION_EXTEND.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 7));
+  RunMoveCursorTestAndClearExpectations(
+      render_text, CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_EXTEND, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(7, 6));
+  expected.push_back(Range(7, 5));
+  RunMoveCursorTestAndClearExpectations(
+      render_text, CHARACTER_BREAK, CURSOR_LEFT, SELECTION_EXTEND, &expected);
+}
+
+TEST_F(RenderTextTest, MoveCursor_Word) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"123 456 789");
+  std::vector<Range> expected;
+
+  // SELECTION_NONE.
+  render_text->SelectRange(Range(6));
+
+  // Move left twice.
+  expected.push_back(Range(4));
+  expected.push_back(Range(0));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_NONE, &expected);
+
+  // Move right twice.
+#if defined(OS_WIN)  // Move word right includes space/punctuation.
+  expected.push_back(Range(4));
+  expected.push_back(Range(8));
+#else  // Non-Windows: move word right does NOT include space/punctuation.
+  expected.push_back(Range(3));
+  expected.push_back(Range(7));
+#endif
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_NONE, &expected);
+
+  // SELECTION_CARET.
+  render_text->SelectRange(Range(6));
+
+  // Move left.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_CARET, &expected);
+
+  // Move right twice.
+  expected.push_back(Range(6));
+#if defined(OS_WIN)  // Select word right includes space/punctuation.
+  expected.push_back(Range(6, 8));
+#else  // Non-Windows: select word right does NOT include space/punctuation.
+  expected.push_back(Range(6, 7));
+#endif
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_CARET, &expected);
+
+  // Move left.
+  expected.push_back(Range(6));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_CARET, &expected);
+
+  // SELECTION_RETAIN.
+  render_text->SelectRange(Range(6));
+
+  // Move left.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_RETAIN, &expected);
+
+  // Move right twice.
+#if defined(OS_WIN)  // Select word right includes space/punctuation.
+  expected.push_back(Range(6, 8));
+#else  // Non-Windows: select word right does NOT include space/punctuation.
+  expected.push_back(Range(6, 7));
+#endif
+  expected.push_back(Range(6, 11));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_RETAIN, &expected);
+
+  // Move left.
+  expected.push_back(Range(6, 8));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_RETAIN, &expected);
+
+  // SELECTION_EXTEND.
+  render_text->SelectRange(Range(6));
+
+  // Move left.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_EXTEND, &expected);
+
+  // Move right twice.
+#if defined(OS_WIN)  // Select word right includes space/punctuation.
+  expected.push_back(Range(4, 8));
+#else  // Non-Windows: select word right does NOT include space/punctuation.
+  expected.push_back(Range(4, 7));
+#endif
+  expected.push_back(Range(4, 11));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_EXTEND, &expected);
+
+  // Move left.
+  expected.push_back(Range(4, 8));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_EXTEND, &expected);
+}
+
+TEST_F(RenderTextTest, MoveCursor_Word_RTL) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"אבג דהו זחט");
+  std::vector<Range> expected;
+
+  // SELECTION_NONE.
+  render_text->SelectRange(Range(6));
+
+  // Move right twice.
+  expected.push_back(Range(4));
+  expected.push_back(Range(0));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_NONE, &expected);
+
+  // Move left twice.
+#if defined(OS_WIN)  // Move word left includes space/punctuation.
+  expected.push_back(Range(4));
+  expected.push_back(Range(8));
+#else  // Non-Windows: move word left does NOT include space/punctuation.
+  expected.push_back(Range(3));
+  expected.push_back(Range(7));
+#endif
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_NONE, &expected);
+
+  // SELECTION_CARET.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_CARET, &expected);
+
+  // Move left twice.
+  expected.push_back(Range(6));
+#if defined(OS_WIN)  // Select word left includes space/punctuation.
+  expected.push_back(Range(6, 8));
+#else  // Non-Windows: select word left does NOT include space/punctuation.
+  expected.push_back(Range(6, 7));
+#endif
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_CARET, &expected);
+
+  // Move right.
+  expected.push_back(Range(6));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_CARET, &expected);
+
+  // SELECTION_RETAIN.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_RETAIN, &expected);
+
+  // Move left twice.
+#if defined(OS_WIN)  // Select word left includes space/punctuation.
+  expected.push_back(Range(6, 8));
+#else  // Non-Windows: select word left does NOT include space/punctuation.
+  expected.push_back(Range(6, 7));
+#endif
+  expected.push_back(Range(6, 11));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_RETAIN, &expected);
+
+  // Move right.
+  expected.push_back(Range(6, 8));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_RETAIN, &expected);
+
+  // SELECTION_EXTEND.
+  render_text->SelectRange(Range(6));
+
+  // Move right.
+  expected.push_back(Range(6, 4));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_EXTEND, &expected);
+
+  // Move left twice.
+#if defined(OS_WIN)  // Select word left includes space/punctuation.
+  expected.push_back(Range(4, 8));
+#else  // Non-Windows: select word left does NOT include space/punctuation.
+  expected.push_back(Range(4, 7));
+#endif
+  expected.push_back(Range(4, 11));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_LEFT,
+                                        SELECTION_EXTEND, &expected);
+
+  // Move right.
+  expected.push_back(Range(4, 8));
+  RunMoveCursorTestAndClearExpectations(render_text, WORD_BREAK, CURSOR_RIGHT,
+                                        SELECTION_EXTEND, &expected);
+}
+
+TEST_F(RenderTextTest, MoveCursor_Line) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"123 456 789");
+  std::vector<Range> expected;
+
+  for (auto break_type : {LINE_BREAK, FIELD_BREAK}) {
+    // SELECTION_NONE.
+    render_text->SelectRange(Range(6));
+
+    // Move right twice.
+    expected.push_back(Range(11));
+    expected.push_back(Range(11));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_RIGHT,
+                                          SELECTION_NONE, &expected);
+
+    // Move left twice.
+    expected.push_back(Range(0));
+    expected.push_back(Range(0));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_LEFT,
+                                          SELECTION_NONE, &expected);
+
+    // SELECTION_CARET.
+    render_text->SelectRange(Range(6));
+
+    // Move right.
+    expected.push_back(Range(6, 11));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_RIGHT,
+                                          SELECTION_CARET, &expected);
+
+    // Move left twice.
+    expected.push_back(Range(6));
+    expected.push_back(Range(6, 0));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_LEFT,
+                                          SELECTION_CARET, &expected);
+
+    // Move right.
+    expected.push_back(Range(6));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_RIGHT,
+                                          SELECTION_CARET, &expected);
+
+    // SELECTION_RETAIN.
+    render_text->SelectRange(Range(6));
+
+    // Move right.
+    expected.push_back(Range(6, 11));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_RIGHT,
+                                          SELECTION_RETAIN, &expected);
+
+    // Move left twice.
+    expected.push_back(Range(6, 0));
+    expected.push_back(Range(6, 0));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_LEFT,
+                                          SELECTION_RETAIN, &expected);
+
+    // Move right.
+    expected.push_back(Range(6, 11));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_RIGHT,
+                                          SELECTION_RETAIN, &expected);
+
+    // SELECTION_EXTEND.
+    render_text->SelectRange(Range(6));
+
+    // Move right.
+    expected.push_back(Range(6, 11));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_RIGHT,
+                                          SELECTION_EXTEND, &expected);
+
+    // Move left twice.
+    expected.push_back(Range(11, 0));
+    expected.push_back(Range(11, 0));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_LEFT,
+                                          SELECTION_EXTEND, &expected);
+
+    // Move right.
+    expected.push_back(Range(0, 11));
+    RunMoveCursorTestAndClearExpectations(render_text, break_type, CURSOR_RIGHT,
+                                          SELECTION_EXTEND, &expected);
+  }
+}
+
+TEST_F(RenderTextTest, MoveCursor_UpDown) {
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(45, 1000));
+  render_text->SetMultiline(true);
+
+  std::vector<size_t> expected_lines;
+  std::vector<Range> expected_range;
+  for (auto* text : {u"123 456 123 456 ", u"אבג דהו זחט זחט "}) {
+    render_text->SetText(text);
+    EXPECT_EQ(2U, render_text->GetNumLines());
+
+    // SELECTION_NONE.
+    render_text->SelectRange(Range(0));
+    ResetCursorX();
+
+    // Move down twice.
+    expected_lines.push_back(1);
+    expected_lines.push_back(1);
+    RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                          CURSOR_DOWN, SELECTION_NONE,
+                                          &expected_lines);
+
+    // Move up twice.
+    expected_lines.push_back(0);
+    expected_lines.push_back(0);
+    RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                          CURSOR_UP, SELECTION_NONE,
+                                          &expected_lines);
+
+    // SELECTION_CARET.
+    render_text->SelectRange(Range(0));
+    ResetCursorX();
+
+    // Move down twice.
+    expected_range.push_back(Range(0, 8));
+    expected_range.push_back(Range(0, 16));
+    RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                          CURSOR_DOWN, SELECTION_CARET,
+                                          &expected_range);
+
+    // Move up twice.
+    expected_range.push_back(Range(0, 8));
+    expected_range.push_back(Range(0));
+    RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                          CURSOR_UP, SELECTION_CARET,
+                                          &expected_range);
+  }
+}
+
+TEST_F(RenderTextTest, MoveCursor_UpDown_Newline) {
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"123 456\n123 456 ");
+  render_text->SetDisplayRect(Rect(100, 1000));
+  render_text->SetMultiline(true);
+  EXPECT_EQ(2U, render_text->GetNumLines());
+
+  std::vector<size_t> expected_lines;
+  std::vector<Range> expected_range;
+
+  // SELECTION_NONE.
+  render_text->SelectRange(Range(0));
+  ResetCursorX();
+
+  // Move down twice.
+  expected_lines.push_back(1);
+  expected_lines.push_back(1);
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_DOWN, SELECTION_NONE,
+                                        &expected_lines);
+
+  // Move up twice.
+  expected_lines.push_back(0);
+  expected_lines.push_back(0);
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK, CURSOR_UP,
+                                        SELECTION_NONE, &expected_lines);
+
+  // SELECTION_CARET.
+  render_text->SelectRange(Range(0));
+  ResetCursorX();
+
+  // Move down twice.
+  expected_range.push_back(Range(0, 8));
+  expected_range.push_back(Range(0, 16));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_DOWN, SELECTION_CARET,
+                                        &expected_range);
+
+  // Move up twice.
+  expected_range.push_back(Range(0, 7));
+  expected_range.push_back(Range(0));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK, CURSOR_UP,
+                                        SELECTION_CARET, &expected_range);
+}
+
+TEST_F(RenderTextTest, MoveCursor_UpDown_EmptyLines) {
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"one\n\ntwo three");
+  render_text->SetDisplayRect(Rect(45, 1000));
+  render_text->SetMultiline(true);
+  EXPECT_EQ(3U, render_text->GetNumLines());
+
+  std::vector<Range> expected_range;
+
+  // Test up/down cursor movement at the start of the line.
+  render_text->SelectRange(Range(0));
+  expected_range.push_back(Range(4));
+  expected_range.push_back(Range(5));
+  expected_range.push_back(Range(14));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_DOWN, SELECTION_NONE,
+                                        &expected_range);
+
+  render_text->SelectRange(Range(5));
+  expected_range.push_back(Range(4));
+  expected_range.push_back(Range(0));
+  expected_range.push_back(Range(0));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK, CURSOR_UP,
+                                        SELECTION_NONE, &expected_range);
+
+  // Test up/down movement at the end of the line.
+  render_text->SelectRange(Range(3));
+  expected_range.push_back(Range(4));
+  expected_range.push_back(Range(8));
+  expected_range.push_back(Range(14));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_DOWN, SELECTION_NONE,
+                                        &expected_range);
+
+  render_text->SelectRange(Range(14));
+  expected_range.push_back(Range(4));
+  expected_range.push_back(Range(3));
+  expected_range.push_back(Range(0));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK, CURSOR_UP,
+                                        SELECTION_NONE, &expected_range);
+
+  // Test up/down movement somewhere in the middle of the line.
+  render_text->SelectRange(Range(2));
+  expected_range.push_back(Range(4));
+  expected_range.push_back(Range(7));
+  expected_range.push_back(Range(14));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_DOWN, SELECTION_NONE,
+                                        &expected_range);
+
+  render_text->SelectRange(Range(7));
+  expected_range.push_back(Range(4));
+  expected_range.push_back(Range(2));
+  expected_range.push_back(Range(0));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK, CURSOR_UP,
+                                        SELECTION_NONE, &expected_range);
+}
+
+TEST_F(RenderTextTest, MoveCursor_UpDown_Cache) {
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"123 456\n\n123 456");
+  render_text->SetDisplayRect(Rect(45, 1000));
+  render_text->SetMultiline(true);
+  EXPECT_EQ(3U, render_text->GetNumLines());
+
+  std::vector<size_t> expected_lines;
+  std::vector<Range> expected_range;
+
+  // SELECTION_NONE.
+  render_text->SelectRange(Range(2));
+  ResetCursorX();
+
+  // Move down twice.
+  expected_range.push_back(Range(8));
+  expected_range.push_back(Range(11));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_DOWN, SELECTION_NONE,
+                                        &expected_range);
+
+  // Move up twice.
+  expected_range.push_back(Range(8));
+  expected_range.push_back(Range(2));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK, CURSOR_UP,
+                                        SELECTION_NONE, &expected_range);
+
+  // Move left.
+  expected_range.push_back(Range(1));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_LEFT, SELECTION_NONE,
+                                        &expected_range);
+
+  // Move down twice again.
+  expected_range.push_back(Range(8));
+  expected_range.push_back(Range(10));
+  RunMoveCursorTestAndClearExpectations(render_text, CHARACTER_BREAK,
+                                        CURSOR_DOWN, SELECTION_NONE,
+                                        &expected_range);
+}
+
+TEST_F(RenderTextTest, MoveCursorWithNewline) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"a\r\nb");
+  render_text->SetMultiline(false);
+  EXPECT_EQ(1U, render_text->GetNumLines());
+
+  EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(1, CURSOR_BACKWARD), render_text->selection_model());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(3, CURSOR_BACKWARD), render_text->selection_model());
+
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
+}
+
+TEST_F(RenderTextTest, GetTextDirectionInvalidation) {
+  RenderText* render_text = GetRenderText();
+  ASSERT_EQ(render_text->directionality_mode(), DIRECTIONALITY_FROM_TEXT);
+
+  const base::i18n::TextDirection original_text_direction =
+      render_text->GetTextDirection();
+
+  render_text->SetText(u"a");
+  EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetTextDirection());
+
+  render_text->SetText(u"א");
+  EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetTextDirection());
+
+  // The codepoints u+2026 (ellipsis) has no strong direction.
+  render_text->SetText(u"…");
+  EXPECT_EQ(original_text_direction, render_text->GetTextDirection());
+  render_text->AppendText(u"a");
+  EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetTextDirection());
+
+  render_text->SetText(u"…");
+  EXPECT_EQ(original_text_direction, render_text->GetTextDirection());
+  render_text->AppendText(u"א");
+  EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetTextDirection());
+}
+
+TEST_F(RenderTextTest, GetDisplayTextDirectionInvalidation) {
+  RenderText* render_text = GetRenderText();
+  ASSERT_EQ(render_text->directionality_mode(), DIRECTIONALITY_FROM_TEXT);
+
+  const base::i18n::TextDirection original_text_direction =
+      render_text->GetDisplayTextDirection();
+
+  render_text->SetText(u"a");
+  EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetDisplayTextDirection());
+
+  render_text->SetText(u"א");
+  EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetDisplayTextDirection());
+
+  // The codepoints u+2026 (ellipsis) has no strong direction.
+  render_text->SetText(u"…");
+  EXPECT_EQ(original_text_direction, render_text->GetDisplayTextDirection());
+  render_text->AppendText(u"a");
+  EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetDisplayTextDirection());
+
+  render_text->SetText(u"…");
+  EXPECT_EQ(original_text_direction, render_text->GetDisplayTextDirection());
+  render_text->AppendText(u"א");
+  EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetDisplayTextDirection());
+}
+
+TEST_F(RenderTextTest, GetTextDirectionWithDifferentDirection) {
+  SetGlyphWidth(10);
+  RenderText* render_text = GetRenderText();
+  ASSERT_EQ(render_text->directionality_mode(), DIRECTIONALITY_FROM_TEXT);
+  render_text->SetWhitespaceElision(false);
+  render_text->SetText(u"123\u0638xyz");
+  render_text->SetElideBehavior(ELIDE_HEAD);
+  render_text->SetDisplayRect(Rect(25, 100));
+
+  // The elided text is an ellipsis with neutral directionality, and a 'z' with
+  // a strong LTR directionality.
+  EXPECT_EQ(u"…z", render_text->GetDisplayText());
+  EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetTextDirection());
+  EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetDisplayTextDirection());
+}
+
+TEST_F(RenderTextTest, DirectionalityInvalidation) {
+  RenderText* render_text = GetRenderText();
+  ASSERT_EQ(render_text->directionality_mode(), DIRECTIONALITY_FROM_TEXT);
+
+  // The codepoints u+2026 (ellipsis) has weak directionality.
+  render_text->SetText(u"…");
+  const base::i18n::TextDirection original_text_direction =
+      render_text->GetTextDirection();
+
+  render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
+  EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetTextDirection());
+  EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetDisplayTextDirection());
+
+  render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
+  EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetTextDirection());
+  EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetDisplayTextDirection());
+
+  render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
+  EXPECT_EQ(original_text_direction, render_text->GetTextDirection());
+  EXPECT_EQ(original_text_direction, render_text->GetDisplayTextDirection());
+}
+
+TEST_F(RenderTextTest, MoveCursor_UpDown_Scroll) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(100, 30));
+  render_text->SetMultiline(true);
+  render_text->SetVerticalAlignment(ALIGN_TOP);
+
+  const size_t kLineSize = 50;
+  std::u16string text;
+  for (size_t i = 0; i < kLineSize - 1; ++i)
+    text += u"a\n";
+
+  render_text->SetText(text);
+  EXPECT_EQ(kLineSize, render_text->GetNumLines());
+
+  // Move cursor down with scroll.
+  render_text->SelectRange(Range(0));
+  // |line_height| is the distance from the top.
+  float line_height =
+      render_text->GetLineSizeF(render_text->selection_model()).height();
+  for (size_t i = 1; i < kLineSize; ++i) {
+    SCOPED_TRACE(base::StringPrintf("Testing line [%" PRIuS "]", i));
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_DOWN, SELECTION_NONE);
+    ASSERT_EQ(Range(i * 2), render_text->selection());
+    ASSERT_TRUE(render_text->display_rect().Contains(
+        render_text->GetUpdatedCursorBounds()));
+    line_height +=
+        render_text->GetLineSizeF(render_text->selection_model()).height();
+    ASSERT_FLOAT_EQ(test_api()->display_offset().y(),
+                    std::min(0.0f, 30.0f - line_height));
+  }
+
+  // Move cursor up with scroll.
+  // |line_height| is the distance from the bottom.
+  line_height =
+      render_text->GetLineSizeF(render_text->selection_model()).height();
+  int offset_y = test_api()->display_offset().y();
+  for (size_t i = kLineSize - 2; i != static_cast<size_t>(-1); --i) {
+    SCOPED_TRACE(base::StringPrintf("Testing line [%" PRIuS "]", i));
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_UP, SELECTION_NONE);
+    ASSERT_EQ(Range(i * 2), render_text->selection());
+    ASSERT_TRUE(render_text->display_rect().Contains(
+        render_text->GetUpdatedCursorBounds()));
+    line_height +=
+        render_text->GetLineSizeF(render_text->selection_model()).height();
+    ASSERT_FLOAT_EQ(test_api()->display_offset().y(),
+                    offset_y + std::max(0.0f, line_height - 30.0f));
+  }
+  EXPECT_EQ(0, test_api()->display_offset().y());
+}
+
+TEST_F(RenderTextTest, GetDisplayTextDirection) {
+  struct {
+    const char16_t* text;
+    const base::i18n::TextDirection text_direction;
+  } cases[] = {
+      // Blank strings and those with no/weak directionality default to LTR.
+      {u"", base::i18n::LEFT_TO_RIGHT},
+      {kWeak, base::i18n::LEFT_TO_RIGHT},
+      // Strings that begin with strong LTR characters.
+      {kLtr, base::i18n::LEFT_TO_RIGHT},
+      {kLtrRtl, base::i18n::LEFT_TO_RIGHT},
+      {kLtrRtlLtr, base::i18n::LEFT_TO_RIGHT},
+      // Strings that begin with strong RTL characters.
+      {kRtl, base::i18n::RIGHT_TO_LEFT},
+      {kRtlLtr, base::i18n::RIGHT_TO_LEFT},
+      {kRtlLtrRtl, base::i18n::RIGHT_TO_LEFT},
+  };
+
+  RenderText* render_text = GetRenderText();
+  const bool was_rtl = base::i18n::IsRTL();
+
+  for (size_t i = 0; i < 2; ++i) {
+    // Toggle the application default text direction (to try each direction).
+    SetRTL(!base::i18n::IsRTL());
+    const base::i18n::TextDirection ui_direction = base::i18n::IsRTL() ?
+        base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
+
+    // Ensure that directionality modes yield the correct text directions.
+    for (size_t j = 0; j < base::size(cases); j++) {
+      render_text->SetText(cases[j].text);
+      render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(),cases[j].text_direction);
+      render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_UI);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(), ui_direction);
+      render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(),
+                base::i18n::LEFT_TO_RIGHT);
+      render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(),
+                base::i18n::RIGHT_TO_LEFT);
+      render_text->SetDirectionalityMode(DIRECTIONALITY_AS_URL);
+      EXPECT_EQ(render_text->GetDisplayTextDirection(),
+                base::i18n::LEFT_TO_RIGHT);
+    }
+  }
+
+  EXPECT_EQ(was_rtl, base::i18n::IsRTL());
+
+  // Ensure that text changes update the direction for DIRECTIONALITY_FROM_TEXT.
+  render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
+  render_text->SetText(kLtr);
+  EXPECT_EQ(render_text->GetDisplayTextDirection(), base::i18n::LEFT_TO_RIGHT);
+  render_text->SetText(kRtl);
+  EXPECT_EQ(render_text->GetDisplayTextDirection(), base::i18n::RIGHT_TO_LEFT);
+}
+
+struct GetTextIndexOfLineCase {
+  const char* test_name;
+  const char16_t* const text;
+  const std::vector<size_t> line_breaks;
+  const bool set_word_wrap = false;
+  const bool set_obscured = false;
+};
+
+class RenderTextTestWithGetTextIndexOfLineCase
+    : public RenderTextTest,
+      public ::testing::WithParamInterface<GetTextIndexOfLineCase> {
+ public:
+  static std::string ParamInfoToString(
+      ::testing::TestParamInfo<GetTextIndexOfLineCase> param_info) {
+    return param_info.param.test_name;
+  }
+};
+
+TEST_P(RenderTextTestWithGetTextIndexOfLineCase, GetTextIndexOfLine) {
+  GetTextIndexOfLineCase param = GetParam();
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  SetGlyphWidth(10);
+  if (param.set_word_wrap) {
+    render_text->SetDisplayRect(Rect(1, 1000));
+    render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
+  }
+  render_text->SetObscured(param.set_obscured);
+  render_text->SetText(param.text);
+  for (size_t i = 0; i < param.line_breaks.size(); ++i) {
+    EXPECT_EQ(param.line_breaks[i], render_text->GetTextIndexOfLine(i));
+  }
+}
+
+const GetTextIndexOfLineCase kGetTextIndexOfLineCases[] = {
+    {"emptyString", u"", {0}},
+    // The following test strings are three character strings.
+    // The word wrap makes each character fall on a new line.
+    {"kWeak_minWidth", u" . ", {0, 1, 2}, kUseWordWrap},
+    {"kLtr_minWidth", u"abc", {0, 1, 2}, kUseWordWrap},
+    {"kLtrRtl_minWidth", u"aאב", {0, 1, 2}, kUseWordWrap},
+    {"kLtrRtlLtr_minWidth", u"aבb", {0, 1, 2}, kUseWordWrap},
+    {"kRtl_minWidth", u"אבג", {0, 1, 2}, kUseWordWrap},
+    {"kRtlLtr_minWidth", u"אבa", {0, 1, 2}, kUseWordWrap},
+    {"kRtlLtrRtl_minWidth", u"אaב", {0, 1, 2}, kUseWordWrap},
+    // The following test strings have 2 graphemes separated by a newline.
+    // The obscured text replace each grapheme by a single codepoint.
+    {"grapheme_unobscured",
+     u"\U0001F601\n\U0001F468\u200D\u2708\uFE0F\nx",
+     {0, 3, 9}},
+    {"grapheme_obscured",
+     u"\U0001F601\n\U0001F468\u200D\u2708\uFE0F\nx",
+     {0, 3, 9},
+     !kUseWordWrap,
+     kUseObscuredText},
+    // The following test strings have a new line character.
+    {"basic_newLine", u"abc\ndef", {0, 4}},
+    {"basic_newLineWindows", u"abc\r\ndef", {0, 5}},
+    {"spaces_newLine", u"a \n b ", {0, 3}},
+    {"spaces_newLineWindows", u"a \r\n b ", {0, 4}},
+    {"double_newLine", u"a\n\nb", {0, 2, 3}},
+    {"double_newLineWindows", u"a\r\n\r\nb", {0, 3, 5}},
+    {"start_newLine", u"\nab", {0, 1}},
+    {"start_newLineWindows", u"\r\nab", {0, 2}},
+    {"end_newLine", u"ab\n", {0}},
+    {"end_newLineWindows", u"ab\r\n", {0}},
+    {"isolated_newLine", u"\n", {0}},
+    {"isolated_newLineWindows", u"\r\n", {0}},
+    {"isolatedDouble_newLine", u"\n\n", {0, 1}},
+    {"isolatedDouble_newLineWindows", u"\r\n\r\n", {0, 2}},
+    // The following test strings have unicode characters.
+    {"playSymbol_unicode", u"x\n\u25B6\ny", {0, 2, 4}},
+    {"emoji_unicode", u"x\n\U0001F601\ny\n\u2728\nz", {0, 2, 5, 7, 9}},
+    {"flag_unicode", u"🇬🇧\n🇯🇵", {0, 5}, false, false},
+    // The following cases test that GetTextIndexOfLine returns the length of
+    // the text when passed a line index larger than the number of lines.
+    {"basic_outsideRange", u"abc", {0, 1, 2, 3, 3}, kUseWordWrap},
+    {"emptyString_outsideRange", u"", {0, 0, 0}},
+    {"newLine_outsideRange", u"\n", {0, 1, 1}},
+    {"newLineWindows_outsideRange", u"\r\n", {0, 2, 2, 2}},
+    {"doubleNewLine_outsideRange", u"\n\n", {0, 1, 2, 2}},
+    {"doubleNewLineWindows_outsideRange", u"\r\n\r\n", {0, 2, 4, 4}},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    GetTextIndexOfLine,
+    RenderTextTestWithGetTextIndexOfLineCase,
+    ::testing::ValuesIn(kGetTextIndexOfLineCases),
+    RenderTextTestWithGetTextIndexOfLineCase::ParamInfoToString);
+
+TEST_F(RenderTextTest, MoveCursorLeftRightInLtr) {
+  RenderText* render_text = GetRenderText();
+  // Pure LTR.
+  render_text->SetText(u"abc");
+  // |expected| saves the expected SelectionModel when moving cursor from left
+  // to right.
+  std::vector<SelectionModel> expected;
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_RIGHT);
+
+  expected.clear();
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_LEFT);
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtl) {
+  RenderText* render_text = GetRenderText();
+  // LTR-RTL
+  render_text->SetText(u"abcאבג");
+  // The last one is the expected END position.
+  std::vector<SelectionModel> expected;
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(5, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(4, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(6, CURSOR_FORWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_RIGHT);
+
+  expected.clear();
+  expected.push_back(SelectionModel(6, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_LEFT);
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtlLtr) {
+  RenderText* render_text = GetRenderText();
+  // LTR-RTL-LTR.
+  render_text->SetText(u"aבb");
+  std::vector<SelectionModel> expected;
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_RIGHT);
+
+  expected.clear();
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_LEFT);
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
+  RenderText* render_text = GetRenderText();
+  // Pure RTL.
+  render_text->SetText(u"אבג");
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  std::vector<SelectionModel> expected;
+
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_LEFT);
+
+  expected.clear();
+
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_RIGHT);
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
+  RenderText* render_text = GetRenderText();
+  // RTL-LTR
+  render_text->SetText(u"אבגabc");
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  std::vector<SelectionModel> expected;
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(5, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(4, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(6, CURSOR_FORWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_LEFT);
+
+  expected.clear();
+  expected.push_back(SelectionModel(6, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_RIGHT);
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtrRtl) {
+  RenderText* render_text = GetRenderText();
+  // RTL-LTR-RTL.
+  render_text->SetText(u"אaב");
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  std::vector<SelectionModel> expected;
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_LEFT);
+
+  expected.clear();
+  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
+  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
+  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
+  RunMoveCursorLeftRightTest(render_text, expected, CURSOR_RIGHT);
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRight_ComplexScript) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"\u0915\u093f\u0915\u094d\u0915");
+  EXPECT_EQ(0U, render_text->cursor_position());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(2U, render_text->cursor_position());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(5U, render_text->cursor_position());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(5U, render_text->cursor_position());
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(2U, render_text->cursor_position());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRight_MeiryoUILigatures) {
+  RenderText* render_text = GetRenderText();
+  // Meiryo UI uses single-glyph ligatures for 'ff' and 'ffi', but each letter
+  // (code point) has unique bounds, so mid-glyph cursoring should be possible.
+  render_text->SetFontList(FontList("Meiryo UI, 12px"));
+  render_text->SetText(u"ff ffi");
+  render_text->SetDisplayRect(gfx::Rect(100, 100));
+  EXPECT_EQ(0U, render_text->cursor_position());
+
+  gfx::Rect last_selection_bounds = GetSelectionBoundsUnion();
+  for (size_t i = 0; i < render_text->text().length(); ++i) {
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
+    EXPECT_EQ(i + 1, render_text->cursor_position());
+
+    // Verify the selection bounds also increase and that the correct bounds are
+    // returned even when the grapheme boundary lies within a glyph.
+    const gfx::Rect selection_bounds = GetSelectionBoundsUnion();
+    EXPECT_GT(selection_bounds.right(), last_selection_bounds.right());
+    EXPECT_EQ(selection_bounds.x(), last_selection_bounds.x());
+    last_selection_bounds = selection_bounds;
+  }
+  EXPECT_EQ(6U, render_text->cursor_position());
+}
+
+TEST_F(RenderTextTest, GraphemeIterator) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"a\u0065\u0301b");
+
+  internal::GraphemeIterator iterator =
+      render_text->GetGraphemeIteratorAtTextIndex(0);
+
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(0U, render_text->GetDisplayTextIndex(iterator));
+  ++iterator;
+  EXPECT_EQ(1U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(1U, render_text->GetDisplayTextIndex(iterator));
+  ++iterator;
+  EXPECT_EQ(3U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(3U, render_text->GetDisplayTextIndex(iterator));
+  ++iterator;
+  EXPECT_EQ(4U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(4U, render_text->GetDisplayTextIndex(iterator));
+
+  --iterator;
+  EXPECT_EQ(3U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(3U, render_text->GetDisplayTextIndex(iterator));
+  --iterator;
+  EXPECT_EQ(1U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(1U, render_text->GetDisplayTextIndex(iterator));
+  --iterator;
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(0U, render_text->GetDisplayTextIndex(iterator));
+
+  iterator = render_text->GetGraphemeIteratorAtTextIndex(0);
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtTextIndex(1);
+  EXPECT_EQ(1U, render_text->GetTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtTextIndex(2);
+  EXPECT_EQ(1U, render_text->GetTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtTextIndex(3);
+  EXPECT_EQ(3U, render_text->GetTextIndex(iterator));
+
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(0);
+  EXPECT_EQ(0U, render_text->GetDisplayTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(1);
+  EXPECT_EQ(1U, render_text->GetDisplayTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(2);
+  EXPECT_EQ(1U, render_text->GetDisplayTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(3);
+  EXPECT_EQ(3U, render_text->GetDisplayTextIndex(iterator));
+
+  render_text->SetText(u"e\u0301b");
+  render_text->SetObscured(true);
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(0);
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(1);
+  EXPECT_EQ(2U, render_text->GetTextIndex(iterator));
+  render_text->SetObscured(false);
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(0);
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(1);
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(2);
+  EXPECT_EQ(2U, render_text->GetTextIndex(iterator));
+
+  render_text->SetText(u"a\U0001F601b");
+  render_text->SetObscured(true);
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(0);
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(0U, render_text->GetDisplayTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(1);
+  EXPECT_EQ(1U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(1U, render_text->GetDisplayTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(2);
+  EXPECT_EQ(3U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(2U, render_text->GetDisplayTextIndex(iterator));
+
+  render_text->SetText(u"\U0001F468\u200D\u2708\uFE0Fx");
+  render_text->SetObscured(true);
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(0);
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(0U, render_text->GetDisplayTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(1);
+  EXPECT_EQ(5U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(1U, render_text->GetDisplayTextIndex(iterator));
+  render_text->SetObscured(false);
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(0);
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(0U, render_text->GetDisplayTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(1);
+  EXPECT_EQ(0U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(0U, render_text->GetDisplayTextIndex(iterator));
+  iterator = render_text->GetGraphemeIteratorAtDisplayTextIndex(5);
+  EXPECT_EQ(5U, render_text->GetTextIndex(iterator));
+  EXPECT_EQ(5U, render_text->GetDisplayTextIndex(iterator));
+}
+
+TEST_F(RenderTextTest, GraphemeBoundaries) {
+  static const char16_t text[] =
+      u"\u0065\u0301"        // Letter 'e' U+0065 and acute accent U+0301
+      u"\u0036\uFE0F\u20E3"  // Emoji 'keycap letter 6'
+      u"\U0001F468\u200D\u2708\uFE0F";  // Emoji 'pilot'.
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(text);
+
+  EXPECT_TRUE(render_text->IsGraphemeBoundary(0));
+  EXPECT_FALSE(render_text->IsGraphemeBoundary(1));
+  EXPECT_TRUE(render_text->IsGraphemeBoundary(2));
+  EXPECT_FALSE(render_text->IsGraphemeBoundary(3));
+  EXPECT_FALSE(render_text->IsGraphemeBoundary(4));
+  EXPECT_TRUE(render_text->IsGraphemeBoundary(5));
+  EXPECT_FALSE(render_text->IsGraphemeBoundary(6));
+  EXPECT_FALSE(render_text->IsGraphemeBoundary(7));
+  EXPECT_FALSE(render_text->IsGraphemeBoundary(8));
+  EXPECT_FALSE(render_text->IsGraphemeBoundary(9));
+  EXPECT_TRUE(render_text->IsGraphemeBoundary(10));
+
+  EXPECT_EQ(2U, render_text->IndexOfAdjacentGrapheme(0, CURSOR_FORWARD));
+  EXPECT_EQ(2U, render_text->IndexOfAdjacentGrapheme(1, CURSOR_FORWARD));
+  EXPECT_EQ(5U, render_text->IndexOfAdjacentGrapheme(2, CURSOR_FORWARD));
+  EXPECT_EQ(5U, render_text->IndexOfAdjacentGrapheme(3, CURSOR_FORWARD));
+  EXPECT_EQ(5U, render_text->IndexOfAdjacentGrapheme(4, CURSOR_FORWARD));
+  EXPECT_EQ(10U, render_text->IndexOfAdjacentGrapheme(5, CURSOR_FORWARD));
+  EXPECT_EQ(10U, render_text->IndexOfAdjacentGrapheme(6, CURSOR_FORWARD));
+  EXPECT_EQ(10U, render_text->IndexOfAdjacentGrapheme(7, CURSOR_FORWARD));
+  EXPECT_EQ(10U, render_text->IndexOfAdjacentGrapheme(8, CURSOR_FORWARD));
+  EXPECT_EQ(10U, render_text->IndexOfAdjacentGrapheme(9, CURSOR_FORWARD));
+  EXPECT_EQ(10U, render_text->IndexOfAdjacentGrapheme(10, CURSOR_FORWARD));
+
+  EXPECT_EQ(0U, render_text->IndexOfAdjacentGrapheme(0, CURSOR_BACKWARD));
+  EXPECT_EQ(0U, render_text->IndexOfAdjacentGrapheme(1, CURSOR_BACKWARD));
+  EXPECT_EQ(0U, render_text->IndexOfAdjacentGrapheme(2, CURSOR_BACKWARD));
+  EXPECT_EQ(2U, render_text->IndexOfAdjacentGrapheme(3, CURSOR_BACKWARD));
+  EXPECT_EQ(2U, render_text->IndexOfAdjacentGrapheme(4, CURSOR_BACKWARD));
+  EXPECT_EQ(2U, render_text->IndexOfAdjacentGrapheme(5, CURSOR_BACKWARD));
+  EXPECT_EQ(5U, render_text->IndexOfAdjacentGrapheme(6, CURSOR_BACKWARD));
+  EXPECT_EQ(5U, render_text->IndexOfAdjacentGrapheme(7, CURSOR_BACKWARD));
+  EXPECT_EQ(5U, render_text->IndexOfAdjacentGrapheme(8, CURSOR_BACKWARD));
+  EXPECT_EQ(5U, render_text->IndexOfAdjacentGrapheme(9, CURSOR_BACKWARD));
+  EXPECT_EQ(5U, render_text->IndexOfAdjacentGrapheme(10, CURSOR_BACKWARD));
+}
+
+TEST_F(RenderTextTest, GraphemePositions) {
+  // LTR कि (DEVANAGARI KA with VOWEL I) (2-char grapheme), LTR abc, and LTR कि.
+  const std::u16string kText1 = u"\u0915\u093fabc\u0915\u093f";
+
+  // LTR ab, LTR कि (DEVANAGARI KA with VOWEL I) (2-char grapheme), LTR cd.
+  const std::u16string kText2 = u"ab\u0915\u093fcd";
+
+  // LTR ab, 𝄞 'MUSICAL SYMBOL G CLEF' U+1D11E (surrogate pair), LTR cd.
+  // Windows requires wide strings for \Unnnnnnnn universal character names.
+  const std::u16string kText3 = u"ab\U0001D11Ecd";
+
+  struct {
+    std::u16string text;
+    size_t index;
+    size_t expected_previous;
+    size_t expected_next;
+  } cases[] = {
+      {std::u16string(), 0, 0, 0},
+      {std::u16string(), 1, 0, 0},
+      {std::u16string(), 50, 0, 0},
+      {kText1, 0, 0, 2},
+      {kText1, 1, 0, 2},
+      {kText1, 2, 0, 3},
+      {kText1, 3, 2, 4},
+      {kText1, 4, 3, 5},
+      {kText1, 5, 4, 7},
+      {kText1, 6, 5, 7},
+      {kText1, 7, 5, 7},
+      {kText1, 8, 7, 7},
+      {kText1, 50, 7, 7},
+      {kText2, 0, 0, 1},
+      {kText2, 1, 0, 2},
+      {kText2, 2, 1, 4},
+      {kText2, 3, 2, 4},
+      {kText2, 4, 2, 5},
+      {kText2, 5, 4, 6},
+      {kText2, 6, 5, 6},
+      {kText2, 7, 6, 6},
+      {kText2, 50, 6, 6},
+      {kText3, 0, 0, 1},
+      {kText3, 1, 0, 2},
+      {kText3, 2, 1, 4},
+      {kText3, 3, 2, 4},
+      {kText3, 4, 2, 5},
+      {kText3, 5, 4, 6},
+      {kText3, 6, 5, 6},
+      {kText3, 7, 6, 6},
+      {kText3, 50, 6, 6},
+  };
+
+  RenderText* render_text = GetRenderText();
+  for (size_t i = 0; i < base::size(cases); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
+    render_text->SetText(cases[i].text);
+
+    size_t next = render_text->IndexOfAdjacentGrapheme(cases[i].index,
+                                                       CURSOR_FORWARD);
+    EXPECT_EQ(cases[i].expected_next, next);
+    EXPECT_TRUE(render_text->IsValidCursorIndex(next));
+
+    size_t previous = render_text->IndexOfAdjacentGrapheme(cases[i].index,
+                                                           CURSOR_BACKWARD);
+    EXPECT_EQ(cases[i].expected_previous, previous);
+    EXPECT_TRUE(render_text->IsValidCursorIndex(previous));
+  }
+}
+
+TEST_F(RenderTextTest, MidGraphemeSelectionBounds) {
+  // Test that selection bounds may be set amid multi-character graphemes.
+  const std::u16string kHindi = u"\u0915\u093f";
+  const std::u16string kThai = u"\u0e08\u0e33";
+  const std::u16string cases[] = {kHindi, kThai};
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(100, 1000));
+  for (size_t i = 0; i < base::size(cases); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
+    render_text->SetText(cases[i]);
+    EXPECT_TRUE(render_text->IsValidLogicalIndex(1));
+    EXPECT_FALSE(render_text->IsValidCursorIndex(1));
+    EXPECT_TRUE(render_text->SelectRange(Range(2, 1)));
+    EXPECT_EQ(Range(2, 1), render_text->selection());
+    EXPECT_EQ(1U, render_text->cursor_position());
+
+    // Verify that the selection bounds extend over the entire grapheme, even if
+    // the selection is set amid the grapheme.
+    const gfx::Rect mid_grapheme_bounds = GetSelectionBoundsUnion();
+    render_text->SelectAll(false);
+    EXPECT_EQ(GetSelectionBoundsUnion(), mid_grapheme_bounds);
+
+    // Although selection bounds may be set within a multi-character grapheme,
+    // cursor movement (e.g. via arrow key) should avoid those indices.
+    EXPECT_TRUE(render_text->SelectRange(Range(2, 1)));
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+    EXPECT_EQ(0U, render_text->cursor_position());
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+    EXPECT_EQ(2U, render_text->cursor_position());
+  }
+}
+
+TEST_F(RenderTextTest, FindCursorPosition) {
+  const char16_t* kTestStrings[] = {kLtrRtl, kLtrRtlLtr, kRtlLtr, kRtlLtrRtl};
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(0, 0, 100, 20));
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("Testing case[%" PRIuS "]", i));
+    render_text->SetText(kTestStrings[i]);
+    for (size_t j = 0; j < render_text->text().length(); ++j) {
+      gfx::RangeF cursor_span = render_text->GetCursorSpan(Range(j, j + 1));
+      // Test a point just inside the leading edge of the glyph bounds.
+      float x = cursor_span.start() + (cursor_span.is_reversed() ? -1 : 1);
+      Point point = gfx::ToCeiledPoint(PointF(x, GetCursorYForTesting()));
+      EXPECT_EQ(j, render_text->FindCursorPosition(point).caret_pos());
+    }
+  }
+}
+
+TEST_F(RenderTextTest, GetCursorBoundsMultilineLTR) {
+  const int kGlyphWidth = 5;
+  const int kGlyphHeight = 6;
+  SetGlyphWidth(kGlyphWidth);
+  SetGlyphHeight(kGlyphHeight);
+  RenderText* render_text = GetRenderText();
+  render_text->SetCursorEnabled(true);
+  render_text->SetDisplayRect(Rect(45, 100));
+  render_text->SetMultiline(true);
+  render_text->SetText(u"one\n\ntwo three");
+
+  const auto& text = render_text->GetDisplayText();
+  int expected_x = 0;
+  int current_line = 0;
+  for (size_t i = 0; i < text.size(); ++i) {
+    EXPECT_EQ(
+        expected_x,
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), true)
+            .x());
+    EXPECT_EQ(
+        render_text->GetLineOffset(current_line).y(),
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), true)
+            .y());
+
+    EXPECT_EQ(
+        expected_x,
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_BACKWARD), true)
+            .x());
+    EXPECT_EQ(
+        render_text->GetLineOffset(current_line).y(),
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_BACKWARD), true)
+            .y());
+
+    if (text[i] == '\n') {
+      expected_x = 0;
+      ++current_line;
+    } else {
+      expected_x += kGlyphWidth;
+    }
+  }
+}
+
+TEST_F(RenderTextTest, GetCursorBoundsMultilineCarriageReturn) {
+  const int kGlyphWidth = 5;
+  const int kGlyphHeight = 6;
+  SetGlyphWidth(kGlyphWidth);
+  SetGlyphHeight(kGlyphHeight);
+  RenderText* render_text = GetRenderText();
+  render_text->SetCursorEnabled(true);
+  render_text->SetDisplayRect(Rect(45, 100));
+  render_text->SetMultiline(true);
+  render_text->SetText(u"abc\n\n\ndef\r\n\r\n");
+
+  const auto& text = render_text->GetDisplayText();
+  int expected_x = 0;
+  int current_line = 0;
+  for (size_t i = 0; i < text.size(); ++i) {
+    EXPECT_EQ(
+        expected_x,
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), true)
+            .x());
+    EXPECT_EQ(
+        render_text->GetLineOffset(current_line).y(),
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), true)
+            .y());
+
+    if (text[i] == '\n') {
+      expected_x = 0;
+      ++current_line;
+    } else if (text[i] != '\r') {
+      // \r isn't a valid cursor position, since \r\n is a single 0-width glyph,
+      // everything else 5px
+      expected_x += kGlyphWidth;
+    }
+  }
+}
+
+TEST_F(RenderTextTest, GetCursorBoundsMultilineRTL) {
+  const int kGlyphWidth = 5;
+  const int kGlyphHeight = 6;
+  SetGlyphWidth(kGlyphWidth);
+  SetGlyphHeight(kGlyphHeight);
+  RenderText* render_text = GetRenderText();
+  render_text->SetCursorEnabled(true);
+  render_text->SetDisplayRect(Rect(45, 100));
+  render_text->SetMultiline(true);
+  render_text->SetText(u"אבג\n\nאבג אבגא");
+
+  // Line 1 is 3 codepoints, 5px wide each. Line 2 has 0 codepoints, and Line 3
+  // has 8 codepoints, 5px wide each.
+  const int kExpectedFirstGlyphInLineX[] = {15, 0, 40};
+  const auto& text = render_text->GetDisplayText();
+  int expected_x_offset = 0;
+  int current_line = 0;
+  for (size_t i = 0; i < text.size(); ++i) {
+    EXPECT_EQ(
+        kExpectedFirstGlyphInLineX[current_line] - expected_x_offset,
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), true)
+            .x());
+    EXPECT_EQ(
+        render_text->GetLineOffset(current_line).y(),
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), true)
+            .y());
+
+    EXPECT_EQ(
+        kExpectedFirstGlyphInLineX[current_line] - expected_x_offset,
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_BACKWARD), true)
+            .x());
+    EXPECT_EQ(
+        render_text->GetLineOffset(current_line).y(),
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_BACKWARD), true)
+            .y());
+
+    if (text[i] == '\n') {
+      expected_x_offset = 0;
+      ++current_line;
+    } else {
+      expected_x_offset += kGlyphWidth;
+    }
+  }
+}
+
+// Tests that FindCursorPosition behaves correctly for multi-line text.
+TEST_F(RenderTextTest, FindCursorPositionMultiline) {
+  const char16_t* kTestStrings[] = {u"abc def", u"אבג דהו"};
+
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(25, 1000));
+  render_text->SetMultiline(true);
+
+  for (size_t i = 0; i < base::size(kTestStrings); i++) {
+    render_text->SetText(kTestStrings[i]);
+    EXPECT_EQ(2u, render_text->GetNumLines());
+
+    const bool is_ltr =
+        render_text->GetDisplayTextDirection() == base::i18n::LEFT_TO_RIGHT;
+    for (size_t j = 0; j < render_text->text().length(); ++j) {
+      SCOPED_TRACE(base::StringPrintf(
+          "Testing index %" PRIuS " for case %" PRIuS "", j, i));
+      render_text->SelectRange(Range(j, j + 1));
+
+      // Test a point inside the leading edge of the glyph bounds.
+      const Rect bounds = GetSelectionBoundsUnion();
+      const Point cursor_position(is_ltr ? bounds.x() + 1 : bounds.right() - 1,
+                                  bounds.y() + 1);
+
+      const SelectionModel model =
+          render_text->FindCursorPosition(cursor_position);
+      EXPECT_EQ(j, model.caret_pos());
+      EXPECT_EQ(CURSOR_FORWARD, model.caret_affinity());
+    }
+  }
+}
+
+// Ensure FindCursorPosition returns positions only at valid grapheme
+// boundaries.
+TEST_F(RenderTextTest, FindCursorPosition_GraphemeBoundaries) {
+  struct {
+    std::u16string text;
+    std::set<size_t> expected_cursor_positions;
+  } cases[] = {
+      // LTR कि (DEVANAGARI KA with VOWEL I) (2-char grapheme), LTR abc, LTR कि.
+      {u"\u0915\u093fabc\u0915\u093f", {0, 2, 3, 4, 5, 7}},
+      // LTR ab, LTR कि (DEVANAGARI KA with VOWEL I) (2-char grapheme), LTR cd.
+      {u"ab\u0915\u093fcd", {0, 1, 2, 4, 5, 6}},
+      // LTR ab, surrogate pair composed of two 16 bit characters, LTR cd.
+      // Windows requires wide strings for \Unnnnnnnn universal character names.
+      {u"ab\U0001D11Ecd", {0, 1, 2, 4, 5, 6}}};
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(gfx::Rect(100, 30));
+  for (size_t i = 0; i < base::size(cases); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing case %" PRIuS "", i));
+    render_text->SetText(cases[i].text);
+    std::set<size_t> obtained_cursor_positions;
+    size_t cursor_y = GetCursorYForTesting();
+    for (int x = -5; x < 105; x++)
+      obtained_cursor_positions.insert(
+          render_text->FindCursorPosition(gfx::Point(x, cursor_y)).caret_pos());
+    EXPECT_EQ(cases[i].expected_cursor_positions, obtained_cursor_positions);
+  }
+}
+
+TEST_F(RenderTextTest, EdgeSelectionModels) {
+  // Simple Latin text.
+  const std::u16string kLatin = u"abc";
+  // LTR कि (DEVANAGARI KA with VOWEL I).
+  const std::u16string kLTRGrapheme = u"\u0915\u093f";
+  // LTR कि (DEVANAGARI KA with VOWEL I), LTR a, LTR कि.
+  const std::u16string kHindiLatin = u"\u0915\u093fa\u0915\u093f";
+  // RTL נָ (Hebrew letter NUN and point QAMATS).
+  const std::u16string kRTLGrapheme = u"\u05e0\u05b8";
+  // RTL נָ (Hebrew letter NUN and point QAMATS), LTR a, RTL נָ.
+  const std::u16string kHebrewLatin = u"\u05e0\u05b8a\u05e0\u05b8";
+
+  struct {
+    std::u16string text;
+    base::i18n::TextDirection expected_text_direction;
+  } cases[] = {
+      {std::u16string(), base::i18n::LEFT_TO_RIGHT},
+      {kLatin, base::i18n::LEFT_TO_RIGHT},
+      {kLTRGrapheme, base::i18n::LEFT_TO_RIGHT},
+      {kHindiLatin, base::i18n::LEFT_TO_RIGHT},
+      {kRTLGrapheme, base::i18n::RIGHT_TO_LEFT},
+      {kHebrewLatin, base::i18n::RIGHT_TO_LEFT},
+  };
+
+  RenderText* render_text = GetRenderText();
+  for (size_t i = 0; i < base::size(cases); i++) {
+    render_text->SetText(cases[i].text);
+    bool ltr = (cases[i].expected_text_direction == base::i18n::LEFT_TO_RIGHT);
+
+    SelectionModel start_edge =
+        test_api()->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
+    EXPECT_EQ(start_edge, SelectionModel(0, CURSOR_BACKWARD));
+
+    SelectionModel end_edge =
+        test_api()->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
+    EXPECT_EQ(end_edge, SelectionModel(cases[i].text.length(), CURSOR_FORWARD));
+  }
+}
+
+TEST_F(RenderTextTest, SelectAll) {
+  const char16_t* const cases[] = {kWeak, kLtr,    kLtrRtl,   kLtrRtlLtr,
+                                   kRtl,  kRtlLtr, kRtlLtrRtl};
+
+  // Ensure that SelectAll respects the |reversed| argument regardless of
+  // application locale and text content directionality.
+  RenderText* render_text = GetRenderText();
+  const SelectionModel expected_reversed(Range(3, 0), CURSOR_FORWARD);
+  const SelectionModel expected_forwards(Range(0, 3), CURSOR_BACKWARD);
+  const bool was_rtl = base::i18n::IsRTL();
+
+  for (size_t i = 0; i < 2; ++i) {
+    SetRTL(!base::i18n::IsRTL());
+    // Test that an empty string produces an empty selection model.
+    render_text->SetText(std::u16string());
+    EXPECT_EQ(render_text->selection_model(), SelectionModel());
+
+    // Test the weak, LTR, RTL, and Bidi string cases.
+    for (size_t j = 0; j < base::size(cases); j++) {
+      render_text->SetText(cases[j]);
+      render_text->SelectAll(false);
+      EXPECT_EQ(render_text->selection_model(), expected_forwards);
+      render_text->SelectAll(true);
+      EXPECT_EQ(render_text->selection_model(), expected_reversed);
+    }
+  }
+
+  EXPECT_EQ(was_rtl, base::i18n::IsRTL());
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRightWithSelection) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcאבג");
+  // Left arrow on select ranging (6, 4).
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(6), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(4), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(5), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(6), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
+  EXPECT_EQ(Range(6, 5), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
+  EXPECT_EQ(Range(6, 4), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(6), render_text->selection());
+
+  // Right arrow on select ranging (4, 6).
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(0), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(1), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(2), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(3), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(5), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(4), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
+  EXPECT_EQ(Range(4, 5), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
+  EXPECT_EQ(Range(4, 6), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(4), render_text->selection());
+}
+
+TEST_F(RenderTextTest, MoveCursorLeftRightWithSelection_Multiline) {
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(20, 1000));
+  render_text->SetText(u"012 456\n\n90");
+  EXPECT_EQ(4U, render_text->GetNumLines());
+
+  // Move cursor right to the end of the text.
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(4), render_text->selection());
+  EXPECT_EQ(0U, GetLineContainingCaret());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(5), render_text->selection());
+  EXPECT_EQ(1U, GetLineContainingCaret());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(7), render_text->selection());
+  EXPECT_EQ(1U, GetLineContainingCaret());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(8), render_text->selection());
+  EXPECT_EQ(2U, GetLineContainingCaret());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(9), render_text->selection());
+  EXPECT_EQ(3U, GetLineContainingCaret());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(11), render_text->selection());
+  EXPECT_EQ(3U, GetLineContainingCaret());
+
+  // Move cursor left to the beginning of the text.
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(9), render_text->selection());
+  EXPECT_EQ(3U, GetLineContainingCaret());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(8), render_text->selection());
+  EXPECT_EQ(2U, GetLineContainingCaret());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(7), render_text->selection());
+  EXPECT_EQ(1U, GetLineContainingCaret());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(4), render_text->selection());
+  EXPECT_EQ(1U, GetLineContainingCaret());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(3), render_text->selection());
+  EXPECT_EQ(0U, GetLineContainingCaret());
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(0), render_text->selection());
+  EXPECT_EQ(0U, GetLineContainingCaret());
+
+  // Move cursor right with WORD_BREAK.
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+#if defined(OS_WIN)
+  EXPECT_EQ(Range(4), render_text->selection());
+#else
+  EXPECT_EQ(Range(3), render_text->selection());
+#endif
+  EXPECT_EQ(0U, GetLineContainingCaret());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+#if defined(OS_WIN)
+  EXPECT_EQ(Range(9), render_text->selection());
+  EXPECT_EQ(3U, GetLineContainingCaret());
+#else
+  EXPECT_EQ(Range(7), render_text->selection());
+  EXPECT_EQ(1U, GetLineContainingCaret());
+#endif
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(11), render_text->selection());
+  EXPECT_EQ(3U, GetLineContainingCaret());
+
+  // Move cursor left with WORD_BREAK.
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(9), render_text->selection());
+  EXPECT_EQ(3U, GetLineContainingCaret());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(4), render_text->selection());
+  EXPECT_EQ(1U, GetLineContainingCaret());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(0), render_text->selection());
+  EXPECT_EQ(0U, GetLineContainingCaret());
+
+  // Move cursor right with FIELD_BREAK.
+  render_text->MoveCursor(FIELD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(11), render_text->selection());
+  EXPECT_EQ(3U, GetLineContainingCaret());
+
+  // Move cursor left with FIELD_BREAK.
+  render_text->MoveCursor(FIELD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(0), render_text->selection());
+  EXPECT_EQ(0U, GetLineContainingCaret());
+}
+
+TEST_F(RenderTextTest, CenteredDisplayOffset) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdefghij");
+  render_text->SetHorizontalAlignment(ALIGN_CENTER);
+
+  const int kEnlargement = 10;
+  const int content_width = render_text->GetContentWidth();
+  Rect display_rect(0, 0, content_width / 2,
+                    render_text->font_list().GetHeight());
+  render_text->SetDisplayRect(display_rect);
+
+  // Move the cursor to the beginning of the text and, by checking the cursor
+  // bounds, make sure no empty space is to the left of the text.
+  render_text->SetCursorPosition(0);
+  EXPECT_EQ(display_rect.x(), render_text->GetUpdatedCursorBounds().x());
+
+  // Widen the display rect and, by checking the cursor bounds, make sure no
+  // empty space is introduced to the left of the text.
+  display_rect.Inset(0, 0, -kEnlargement, 0);
+  render_text->SetDisplayRect(display_rect);
+  EXPECT_EQ(display_rect.x(), render_text->GetUpdatedCursorBounds().x());
+
+  // Move the cursor to the end of the text and, by checking the cursor
+  // bounds, make sure no empty space is to the right of the text.
+  render_text->SetCursorPosition(render_text->text().length());
+  EXPECT_EQ(display_rect.right(),
+            render_text->GetUpdatedCursorBounds().right());
+
+  // Widen the display rect and, by checking the cursor bounds, make sure no
+  // empty space is introduced to the right of the text.
+  display_rect.Inset(0, 0, -kEnlargement, 0);
+  render_text->SetDisplayRect(display_rect);
+  EXPECT_EQ(display_rect.right(),
+            render_text->GetUpdatedCursorBounds().right());
+}
+
+void MoveLeftRightByWordVerifier(RenderText* render_text, const char16_t* str) {
+  SCOPED_TRACE(str);
+  const std::u16string str16(str);
+  render_text->SetText(str16);
+
+  // Test moving by word from left to right.
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  const size_t num_words = (str16.length() + 1) / 4;
+  for (size_t i = 0; i < num_words; ++i) {
+    // First, test moving by word from a word break position, such as from
+    // "|abc def" to "abc| def".
+    const SelectionModel start = render_text->selection_model();
+    render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+    const SelectionModel end = render_text->selection_model();
+
+    // For testing simplicity, each word is a 3-character word.
+#if defined(OS_WIN)
+    // Windows moves from "|abc def" to "abc |def" instead of "abc| def", so
+    // traverse 4 characters on all but the last word instead of all but the
+    // first.
+    const int num_character_moves = (i == num_words - 1) ? 3 : 4;
+#else
+    const int num_character_moves = (i == 0) ? 3 : 4;
+#endif
+    render_text->SetSelection(start);
+    for (int j = 0; j < num_character_moves; ++j)
+      render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+    EXPECT_EQ(end, render_text->selection_model());
+
+    // Then, test moving by word from positions inside the word, such as from
+    // "a|bc def" to "abc| def", and from "ab|c def" to "abc| def".
+    for (int j = 1; j < num_character_moves; ++j) {
+      render_text->SetSelection(start);
+      for (int k = 0; k < j; ++k)
+        render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+      render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+      EXPECT_EQ(end, render_text->selection_model());
+    }
+  }
+
+  // Test moving by word from right to left.
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  for (size_t i = 0; i < num_words; ++i) {
+    const SelectionModel start = render_text->selection_model();
+    render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+    const SelectionModel end = render_text->selection_model();
+
+    const int num_character_moves = (i == 0) ? 3 : 4;
+    render_text->SetSelection(start);
+    for (int j = 0; j < num_character_moves; ++j)
+      render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+    EXPECT_EQ(end, render_text->selection_model());
+
+    for (int j = 1; j < num_character_moves; ++j) {
+      render_text->SetSelection(start);
+      for (int k = 0; k < j; ++k)
+        render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+      render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+      EXPECT_EQ(end, render_text->selection_model());
+    }
+  }
+}
+
+#if defined(OS_WIN)
+// TODO(aleventhal): https://crbug.com/906308 Fix bugs, update verifier code
+// above, and enable for Windows.
+#define MAYBE_MoveLeftRightByWordInBidiText \
+  DISABLED_MoveLeftRightByWordInBidiText
+#else
+#define MAYBE_MoveLeftRightByWordInBidiText MoveLeftRightByWordInBidiText
+#endif
+TEST_F(RenderTextTest, MAYBE_MoveLeftRightByWordInBidiText) {
+  RenderText* render_text = GetRenderText();
+  // For testing simplicity, each word is a 3-character word.
+  std::vector<const char16_t*> test;
+  test.push_back(u"abc");
+  test.push_back(u"abc def");
+  test.push_back(u"\u05E1\u05E2\u05E3");
+  test.push_back(u"\u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6");
+  test.push_back(u"abc \u05E1\u05E2\u05E3");
+  test.push_back(u"abc def \u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6");
+  test.push_back(
+      u"abc def hij \u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6"
+      u" \u05E7\u05E8\u05E9");
+
+  test.push_back(u"abc \u05E1\u05E2\u05E3 hij");
+  test.push_back(u"abc def \u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6 hij opq");
+  test.push_back(
+      u"abc def hij \u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6"
+      u" \u05E7\u05E8\u05E9 opq rst uvw");
+
+  test.push_back(u"\u05E1\u05E2\u05E3 abc");
+  test.push_back(u"\u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6 abc def");
+  test.push_back(
+      u"\u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6 \u05E7\u05E8\u05E9"
+      u" abc def hij");
+
+  test.push_back(u"בגד abc \u05E1\u05E2\u05E3");
+  test.push_back(
+      u"בגד הוז abc def"
+      u" \u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6");
+  test.push_back(
+      u"בגד הוז חטי"
+      u" abc def hij \u05E1\u05E2\u05E3 \u05E4\u05E5\u05E6"
+      u" \u05E7\u05E8\u05E9");
+
+  for (size_t i = 0; i < test.size(); ++i)
+    MoveLeftRightByWordVerifier(render_text, test[i]);
+}
+
+TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText_TestEndOfText) {
+  RenderText* render_text = GetRenderText();
+
+  render_text->SetText(u"ab\u05E1");
+  // Moving the cursor by word from "abC|" to the left should return "|abC".
+  // But since end of text is always treated as a word break, it returns
+  // position "ab|C".
+  // TODO(xji): Need to make it work as expected.
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  // EXPECT_EQ(SelectionModel(), render_text->selection_model());
+
+  // Moving the cursor by word from "|abC" to the right returns "abC|".
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
+
+  render_text->SetText(u"\u05E1\u05E2a");
+  // For logical text "BCa", moving the cursor by word from "aCB|" to the left
+  // returns "|aCB".
+  render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
+
+  // Moving the cursor by word from "|aCB" to the right should return "aCB|".
+  // But since end of text is always treated as a word break, it returns
+  // position "a|CB".
+  // TODO(xji): Need to make it work as expected.
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  // EXPECT_EQ(SelectionModel(), render_text->selection_model());
+}
+
+TEST_F(RenderTextTest, MoveLeftRightByWordInTextWithMultiSpaces) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abc     def");
+  render_text->SetCursorPosition(5);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+#if defined(OS_WIN)
+  EXPECT_EQ(8U, render_text->cursor_position());
+#else
+  EXPECT_EQ(11U, render_text->cursor_position());
+#endif
+
+  render_text->SetCursorPosition(5);
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+}
+
+TEST_F(RenderTextTest, MoveLeftRightByWordInThaiText) {
+  RenderText* render_text = GetRenderText();
+  // เรียกดูรวดเร็ว is broken to เรียก|ดู|รวดเร็ว.
+  render_text->SetText(u"เรียกดูรวดเร็ว");
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(5U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(7U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(14U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(14U, render_text->cursor_position());
+
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(7U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(5U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+}
+
+// TODO(crbug.com/865527): Chinese and Japanese tokenization doesn't work on
+// mobile.
+#if !defined(OS_ANDROID)
+TEST_F(RenderTextTest, MoveLeftRightByWordInChineseText) {
+  RenderText* render_text = GetRenderText();
+  // zh-Hans-CN: 我们去公园玩, broken to 我们|去|公园|玩.
+  render_text->SetText(u"\u6211\u4EEC\u53BB\u516C\u56ED\u73A9");
+  render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(2U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(3U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(5U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(6U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(6U, render_text->cursor_position());
+
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(5U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(3U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(2U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+  render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(0U, render_text->cursor_position());
+}
+#endif
+
+// Test the correct behavior of undirected selections: selections where the
+// "end" of the selection that holds the cursor is only determined after the
+// first cursor movement.
+TEST_F(RenderTextTest, DirectedSelections) {
+  RenderText* render_text = GetRenderText();
+
+  auto ResultAfter = [&](VisualCursorDirection direction) -> std::u16string {
+    render_text->MoveCursor(CHARACTER_BREAK, direction, SELECTION_RETAIN);
+    return GetSelectedText(render_text);
+  };
+
+  render_text->SetText(u"01234");
+
+  // Test Right, then Left. LTR.
+  // Undirected, or forward when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({2, 4});
+  EXPECT_EQ(u"23", GetSelectedText(render_text));
+  EXPECT_EQ(u"234", ResultAfter(CURSOR_RIGHT));
+  EXPECT_EQ(u"23", ResultAfter(CURSOR_LEFT));
+
+  // Test collapsing the selection. This always ignores any existing direction.
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(2, 2), render_text->selection());  // Collapse left.
+
+  // Undirected, or backward when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({4, 2});
+  EXPECT_EQ(u"23", GetSelectedText(render_text));
+  if (RenderText::kSelectionIsAlwaysDirected)
+    EXPECT_EQ(u"3", ResultAfter(CURSOR_RIGHT));  // Keep left.
+  else
+    EXPECT_EQ(u"234", ResultAfter(CURSOR_RIGHT));  // Pick right.
+  EXPECT_EQ(u"23", ResultAfter(CURSOR_LEFT));
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(2, 2), render_text->selection());  // Collapse left.
+
+  // Test Left, then Right. LTR.
+  // Undirected, or forward when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({2, 4});
+  EXPECT_EQ(u"23", GetSelectedText(render_text));  // Sanity check,
+
+  if (RenderText::kSelectionIsAlwaysDirected)
+    EXPECT_EQ(u"2", ResultAfter(CURSOR_LEFT));  // Keep right.
+  else
+    EXPECT_EQ(u"123", ResultAfter(CURSOR_LEFT));  // Pick left.
+  EXPECT_EQ(u"23", ResultAfter(CURSOR_RIGHT));
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(4, 4), render_text->selection());  // Collapse right.
+
+  // Undirected, or backward when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({4, 2});
+  EXPECT_EQ(u"23", GetSelectedText(render_text));
+  EXPECT_EQ(u"123", ResultAfter(CURSOR_LEFT));
+  EXPECT_EQ(u"23", ResultAfter(CURSOR_RIGHT));
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(4, 4), render_text->selection());  // Collapse right.
+
+  auto ToHebrew = [](const char* digits) -> std::u16string {
+    const std::u16string hebrew = u"אבגדח";  // Roughly "abcde".
+    DCHECK_EQ(5u, hebrew.size());
+    std::u16string result;
+    for (const char* d = digits; *d; d++)
+      result += hebrew[*d - '0'];
+    return result;
+  };
+  render_text->SetText(ToHebrew("01234"));
+
+  // Test Left, then Right. RTL.
+  // Undirected, or forward (to the left) when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({2, 4});
+  EXPECT_EQ(ToHebrew("23"), GetSelectedText(render_text));
+  EXPECT_EQ(ToHebrew("234"), ResultAfter(CURSOR_LEFT));
+  EXPECT_EQ(ToHebrew("23"), ResultAfter(CURSOR_RIGHT));
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(4, 4), render_text->selection());  // Collapse left.
+
+  // Undirected, or backward (to the right) when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({4, 2});
+  EXPECT_EQ(ToHebrew("23"), GetSelectedText(render_text));
+  if (RenderText::kSelectionIsAlwaysDirected)
+    EXPECT_EQ(ToHebrew("3"), ResultAfter(CURSOR_LEFT));  // Keep right.
+  else
+    EXPECT_EQ(ToHebrew("234"), ResultAfter(CURSOR_LEFT));  // Pick left.
+  EXPECT_EQ(ToHebrew("23"), ResultAfter(CURSOR_RIGHT));
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(4, 4), render_text->selection());  // Collapse left.
+
+  // Test Right, then Left. RTL.
+  // Undirected, or forward (to the left) when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({2, 4});
+  EXPECT_EQ(ToHebrew("23"), GetSelectedText(render_text));
+  if (RenderText::kSelectionIsAlwaysDirected)
+    EXPECT_EQ(ToHebrew("2"), ResultAfter(CURSOR_RIGHT));  // Keep left.
+  else
+    EXPECT_EQ(ToHebrew("123"), ResultAfter(CURSOR_RIGHT));  // Pick right.
+  EXPECT_EQ(ToHebrew("23"), ResultAfter(CURSOR_LEFT));
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(2, 2), render_text->selection());  // Collapse right.
+
+  // Undirected, or backward (to the right) when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({4, 2});
+  EXPECT_EQ(ToHebrew("23"), GetSelectedText(render_text));
+  EXPECT_EQ(ToHebrew("123"), ResultAfter(CURSOR_RIGHT));
+  EXPECT_EQ(ToHebrew("23"), ResultAfter(CURSOR_LEFT));
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(2, 2), render_text->selection());  // Collapse right.
+}
+
+TEST_F(RenderTextTest, DirectedSelections_Multiline) {
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+
+  auto ResultAfter = [&](VisualCursorDirection direction) {
+    render_text->MoveCursor(CHARACTER_BREAK, direction, SELECTION_RETAIN);
+    return GetSelectedText(render_text);
+  };
+
+  render_text->SetText(u"01234\n56789\nabcde");
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(500, 500));
+  ResetCursorX();
+
+  // Test Down, then Up. LTR.
+  // Undirected, or forward when kSelectionIsAlwaysDirected.
+  render_text->SelectRange({2, 4});
+  EXPECT_EQ(u"23", GetSelectedText(render_text));
+  EXPECT_EQ(u"234\n5678", ResultAfter(CURSOR_DOWN));
+  EXPECT_EQ(u"23", ResultAfter(CURSOR_UP));
+
+  // Test collapsing the selection. This always ignores any existing direction.
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(2, 2), render_text->selection());  // Collapse left.
+
+  // Undirected, or backward when kSelectionIsAlwaysDirected.
+  ResetCursorX();  // Reset cached cursor x position.
+  render_text->SelectRange({4, 2});
+  EXPECT_EQ(u"23", GetSelectedText(render_text));
+  if (RenderText::kSelectionIsAlwaysDirected) {
+    EXPECT_EQ(u"4\n56", ResultAfter(CURSOR_DOWN));  // Keep left.
+  } else {
+    EXPECT_EQ(u"234\n5678",
+              ResultAfter(CURSOR_DOWN));  // Pick right.
+  }
+  EXPECT_EQ(u"23", ResultAfter(CURSOR_UP));
+
+  // Test with multi-line selection.
+  // Undirected, or forward when kSelectionIsAlwaysDirected.
+  ResetCursorX();
+  render_text->SelectRange({2, 7});  // Select multi-line.
+  EXPECT_EQ(u"234\n5", GetSelectedText(render_text));
+  EXPECT_EQ(u"234\n56789\na", ResultAfter(CURSOR_DOWN));
+  EXPECT_EQ(u"234\n5", ResultAfter(CURSOR_UP));
+
+  // Undirected, or backward when kSelectionIsAlwaysDirected.
+  ResetCursorX();
+  render_text->SelectRange({7, 2});  // Select multi-line.
+  EXPECT_EQ(u"234\n5", GetSelectedText(render_text));
+
+  if (RenderText::kSelectionIsAlwaysDirected) {
+    EXPECT_EQ(u"6", ResultAfter(CURSOR_DOWN));  // Keep left.
+  } else {
+    EXPECT_EQ(u"234\n56789\na",
+              ResultAfter(CURSOR_DOWN));  // Pick right.
+  }
+  EXPECT_EQ(u"234\n5", ResultAfter(CURSOR_UP));
+}
+
+TEST_F(RenderTextTest, StringSizeSanity) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"Hello World");
+  const Size string_size = render_text->GetStringSize();
+  EXPECT_GT(string_size.width(), 0);
+  EXPECT_GT(string_size.height(), 0);
+}
+
+TEST_F(RenderTextTest, StringSizeLongStrings) {
+  RenderText* render_text = GetRenderText();
+  // Remove the default 100000 characters limit.
+  render_text->set_truncate_length(0);
+  Size previous_string_size;
+  for (size_t length = 10; length < 1000000; length *= 10) {
+    render_text->SetText(std::u16string(length, 'a'));
+    const Size string_size = render_text->GetStringSize();
+    EXPECT_GT(string_size.width(), previous_string_size.width());
+    EXPECT_GT(string_size.height(), 0);
+    previous_string_size = string_size;
+  }
+}
+
+TEST_F(RenderTextTest, StringSizeEmptyString) {
+  // Ascent and descent of Arial and Symbol are different on most platforms.
+  const FontList font_list(
+      base::StringPrintf("Arial,%s, 16px", kSymbolFontName));
+  RenderText* render_text = GetRenderText();
+  render_text->SetFontList(font_list);
+  render_text->SetDisplayRect(Rect(0, 0, 0, font_list.GetHeight()));
+
+  // The empty string respects FontList metrics for non-zero height
+  // and baseline.
+  render_text->SetText(std::u16string());
+  EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
+  EXPECT_EQ(0, render_text->GetStringSize().width());
+  EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
+
+  render_text->SetText(u" ");
+  EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
+  EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
+}
+
+TEST_F(RenderTextTest, StringSizeRespectsFontListMetrics) {
+  // NOTE: On most platforms, kCJKFontName has different metrics than
+  // kTestFontName, but on Android it does not.
+  Font test_font(kTestFontName, 16);
+  ASSERT_EQ(base::ToLowerASCII(kTestFontName),
+            base::ToLowerASCII(test_font.GetActualFontName()));
+  Font cjk_font(kCJKFontName, 16);
+  ASSERT_EQ(base::ToLowerASCII(kCJKFontName),
+            base::ToLowerASCII(cjk_font.GetActualFontName()));
+  Font smaller_font = test_font;
+  Font larger_font = cjk_font;
+  // "a" should be rendered with the test font, not with the CJK font.
+  const char16_t* smaller_font_text = u"a";
+  // "円" (U+5168 Han character YEN) should render with the CJK font, not
+  // the test font.
+  const char16_t* larger_font_text = u"\u5168";
+  if (cjk_font.GetHeight() < test_font.GetHeight() &&
+      cjk_font.GetBaseline() < test_font.GetBaseline()) {
+    std::swap(smaller_font, larger_font);
+    std::swap(smaller_font_text, larger_font_text);
+  }
+  ASSERT_LE(smaller_font.GetHeight(), larger_font.GetHeight());
+  ASSERT_LE(smaller_font.GetBaseline(), larger_font.GetBaseline());
+
+  // Check |smaller_font_text| is rendered with the smaller font.
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(smaller_font_text);
+  render_text->SetFontList(FontList(smaller_font));
+  render_text->SetDisplayRect(Rect(0, 0, 0,
+                                   render_text->font_list().GetHeight()));
+  EXPECT_EQ(smaller_font.GetHeight(), render_text->GetStringSize().height());
+  EXPECT_EQ(smaller_font.GetBaseline(), render_text->GetBaseline());
+  EXPECT_EQ(GetFontSpans()[0].first.GetFontName(), smaller_font.GetFontName());
+
+  // Layout the same text with mixed fonts.  The text should be rendered with
+  // the smaller font, but the height and baseline are determined with the
+  // metrics of the font list, which is equal to the larger font.
+  std::vector<Font> fonts;
+  fonts.push_back(smaller_font);  // The primary font is the smaller font.
+  fonts.push_back(larger_font);
+  const FontList font_list(fonts);
+  render_text->SetFontList(font_list);
+  render_text->SetDisplayRect(Rect(0, 0, 0,
+                                   render_text->font_list().GetHeight()));
+  EXPECT_EQ(GetFontSpans()[0].first.GetFontName(), smaller_font.GetFontName());
+  EXPECT_LE(smaller_font.GetHeight(), render_text->GetStringSize().height());
+  EXPECT_LE(smaller_font.GetBaseline(), render_text->GetBaseline());
+  EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
+  EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
+}
+
+TEST_F(RenderTextTest, StringSizeMultiline) {
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"Hello\nWorld");
+  const Size string_size = render_text->GetStringSize();
+  EXPECT_EQ(55, string_size.width());
+
+  render_text->SetDisplayRect(Rect(30, 1000));
+  render_text->SetMultiline(true);
+  // The newline glyph has width 0.
+  EXPECT_EQ(50, render_text->TotalLineWidth());
+
+  // The newline glyph has width 0.
+  EXPECT_FLOAT_EQ(
+      25, render_text->GetLineSizeF(SelectionModel(0, CURSOR_FORWARD)).width());
+  EXPECT_FLOAT_EQ(
+      25, render_text->GetLineSizeF(SelectionModel(6, CURSOR_FORWARD)).width());
+  // |GetStringSize()| of multi-line text does not include newline character.
+  EXPECT_EQ(25, render_text->GetStringSize().width());
+  // Expect height to be 2 times the font height. This assumes simple strings
+  // that do not have special metrics.
+  int font_height = render_text->font_list().GetHeight();
+  EXPECT_EQ(font_height * 2, render_text->GetStringSize().height());
+}
+
+TEST_F(RenderTextTest, MinLineHeight) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"Hello!");
+  SizeF default_size = render_text->GetStringSizeF();
+  ASSERT_NE(0, default_size.height());
+  ASSERT_NE(0, default_size.width());
+
+  render_text->SetMinLineHeight(default_size.height() / 2);
+  EXPECT_EQ(default_size.ToString(), render_text->GetStringSizeF().ToString());
+
+  render_text->SetMinLineHeight(default_size.height() * 2);
+  SizeF taller_size = render_text->GetStringSizeF();
+  EXPECT_EQ(default_size.height() * 2, taller_size.height());
+  EXPECT_EQ(default_size.width(), taller_size.width());
+}
+
+// Check that, for Latin characters, typesetting text in the default fonts and
+// sizes does not discover any glyphs that would exceed the line spacing
+// recommended by gfx::Font.
+TEST_F(RenderTextTest, DefaultLineHeights) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"A quick brown fox jumped over the lazy dog!");
+
+#if defined(OS_APPLE)
+  const FontList body2_font = FontList().DeriveWithSizeDelta(-1);
+#else
+  const FontList body2_font;
+#endif
+
+  const FontList headline_font = body2_font.DeriveWithSizeDelta(8);
+  const FontList title_font = body2_font.DeriveWithSizeDelta(3);
+  const FontList body1_font = body2_font.DeriveWithSizeDelta(1);
+#if defined(OS_WIN)
+  const FontList button_font =
+      body2_font.DeriveWithWeight(gfx::Font::Weight::BOLD);
+#else
+  const FontList button_font =
+      body2_font.DeriveWithWeight(gfx::Font::Weight::MEDIUM);
+#endif
+
+  EXPECT_EQ(12, body2_font.GetFontSize());
+  EXPECT_EQ(20, headline_font.GetFontSize());
+  EXPECT_EQ(15, title_font.GetFontSize());
+  EXPECT_EQ(13, body1_font.GetFontSize());
+  EXPECT_EQ(12, button_font.GetFontSize());
+
+  for (const auto& font :
+       {headline_font, title_font, body1_font, body2_font, button_font}) {
+    render_text->SetFontList(font);
+    EXPECT_EQ(font.GetHeight(), render_text->GetStringSizeF().height());
+  }
+}
+
+TEST_F(RenderTextTest, TextSize) {
+  // Set a fractional glyph size to trigger floating rounding logic.
+  const float kGlyphWidth = 1.2;
+  const float kGlyphHeight = 9.2;
+  SetGlyphWidth(kGlyphWidth);
+  SetGlyphHeight(kGlyphHeight);
+
+  RenderText* render_text = GetRenderText();
+  for (size_t text_length = 0; text_length < 10; ++text_length) {
+    render_text->SetText(std::u16string(text_length, u'x'));
+
+    // Ensures that conversion from float to integer ceils the values.
+    const float expected_width = text_length * kGlyphWidth;
+    const float expected_height = kGlyphHeight;
+    const int expected_ceiled_width = std::ceil(expected_width);
+    const int expected_ceiled_height = std::ceil(expected_height);
+
+    EXPECT_FLOAT_EQ(expected_width, render_text->GetStringSizeF().width());
+    EXPECT_FLOAT_EQ(expected_height, render_text->GetStringSizeF().height());
+    EXPECT_EQ(expected_ceiled_width, render_text->GetStringSize().width());
+    EXPECT_EQ(expected_ceiled_height, render_text->GetStringSize().height());
+
+    EXPECT_FLOAT_EQ(expected_width, render_text->TotalLineWidth());
+
+    // With cursor disabled, the content width is the same as string width.
+    render_text->SetCursorEnabled(false);
+    EXPECT_FLOAT_EQ(expected_width, render_text->GetContentWidthF());
+    EXPECT_EQ(expected_ceiled_width, render_text->GetContentWidth());
+
+    render_text->SetCursorEnabled(true);
+    // The cursor is drawn one pixel beyond the int-enclosing text bounds.
+    EXPECT_FLOAT_EQ(expected_ceiled_width + 1, render_text->GetContentWidthF());
+    EXPECT_EQ(expected_ceiled_width + 1, render_text->GetContentWidth());
+  }
+}
+
+TEST_F(RenderTextTest, TextSizeMultiline) {
+  // Set a fractional glyph size to trigger floating rounding logic.
+  const float kGlyphWidth = 1.2;
+  const float kGlyphHeight = 9.2;
+  SetGlyphWidth(kGlyphWidth);
+  SetGlyphHeight(kGlyphHeight);
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+
+  for (size_t line = 0; line < 10; ++line) {
+    if (line != 0)
+      render_text->AppendText(u"\n");
+    const int text_length = line;
+    render_text->AppendText(std::u16string(text_length, u'x'));
+
+    // Ensures that conversion from float to integer ceils the values.
+    const float expected_width = text_length * kGlyphWidth;
+    const float expected_height = (line + 1) * kGlyphHeight;
+    const int expected_ceiled_width = std::ceil(expected_width);
+    const int expected_ceiled_height = std::ceil(expected_height);
+
+    EXPECT_FLOAT_EQ(expected_width, render_text->GetStringSizeF().width());
+    EXPECT_FLOAT_EQ(expected_height, render_text->GetStringSizeF().height());
+    EXPECT_EQ(expected_ceiled_width, render_text->GetStringSize().width());
+    EXPECT_EQ(expected_ceiled_height, render_text->GetStringSize().height());
+
+    const int total_glyphs = render_text->text().length();
+    // |total_glyphs| includes one \n glyph per line, which has width 0.
+    EXPECT_FLOAT_EQ((total_glyphs - line) * kGlyphWidth,
+                    render_text->TotalLineWidth());
+
+    // With cursor disabled, the content width is the same as string width.
+    render_text->SetCursorEnabled(false);
+    EXPECT_FLOAT_EQ(expected_width, render_text->GetContentWidthF());
+    EXPECT_EQ(expected_ceiled_width, render_text->GetContentWidth());
+
+    render_text->SetCursorEnabled(true);
+    // The cursor is drawn one pixel beyond the int-enclosing text bounds.
+    EXPECT_FLOAT_EQ(expected_ceiled_width + 1, render_text->GetContentWidthF());
+    EXPECT_EQ(expected_ceiled_width + 1, render_text->GetContentWidth());
+  }
+}
+
+TEST_F(RenderTextTest, LineSizeMultiline) {
+  // Set a fractional glyph size to trigger floating rounding logic.
+  const float kGlyphWidth = 1.2;
+  SetGlyphWidth(kGlyphWidth);
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetText(u"xx\nxxx\nxxxxx");
+
+  // \n doesn't have a width, so the expected sizes are only the visible
+  // characters
+  const float expected_line1_size = 2 * kGlyphWidth;
+  const float expected_line2_size = 3 * kGlyphWidth;
+  const float expected_line3_size = 5 * kGlyphWidth;
+
+  EXPECT_FLOAT_EQ(
+      expected_line1_size,
+      render_text->GetLineSizeF(SelectionModel(1, CURSOR_FORWARD)).width());
+  EXPECT_FLOAT_EQ(
+      expected_line2_size,
+      render_text->GetLineSizeF(SelectionModel(4, CURSOR_FORWARD)).width());
+  EXPECT_FLOAT_EQ(
+      expected_line3_size,
+      render_text->GetLineSizeF(SelectionModel(10, CURSOR_FORWARD)).width());
+}
+
+TEST_F(RenderTextTest, TextPosition) {
+  // Set a fractional glyph size to trigger floating rounding logic.
+  // This test sets a fixed fractional width and height for glyphs to ensure
+  // that computations are fixed (i.e. not font or system dependent).
+  const float kGlyphWidth = 5.4;
+  const float kGlyphHeight = 9.2;
+  SetGlyphWidth(kGlyphWidth);
+  SetGlyphHeight(kGlyphHeight);
+
+  const int kGlyphCount = 3;
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(std::u16string(kGlyphCount, u'x'));
+  render_text->SetDisplayRect(Rect(1, 1, 25, 12));
+  render_text->SetCursorEnabled(false);
+  render_text->SetVerticalAlignment(ALIGN_TOP);
+
+  // Content width is 16.2px. Extra space inside display rect is 8.8px
+  // (i.e. 25px - 16.2px) which is used for alignment.
+  const float expected_content_width = kGlyphCount * kGlyphWidth;
+  EXPECT_FLOAT_EQ(expected_content_width, render_text->GetContentWidthF());
+  EXPECT_FLOAT_EQ(expected_content_width, render_text->TotalLineWidth());
+
+  render_text->SetHorizontalAlignment(ALIGN_LEFT);
+  EXPECT_EQ(1, render_text->GetLineOffset(0).x());
+
+  EXPECT_EQ(Rect(1, 1, 6, 10), GetSubstringBoundsUnion(Range(0, 1)));
+  EXPECT_EQ(Rect(6, 1, 6, 10), GetSubstringBoundsUnion(Range(1, 2)));
+  EXPECT_EQ(Rect(11, 1, 7, 10), GetSubstringBoundsUnion(Range(2, 3)));
+
+  render_text->SetHorizontalAlignment(ALIGN_CENTER);
+  EXPECT_EQ(5, render_text->GetLineOffset(0).x());
+  EXPECT_EQ(Rect(5, 1, 6, 10), GetSubstringBoundsUnion(Range(0, 1)));
+  EXPECT_EQ(Rect(10, 1, 6, 10), GetSubstringBoundsUnion(Range(1, 2)));
+  EXPECT_EQ(Rect(15, 1, 7, 10), GetSubstringBoundsUnion(Range(2, 3)));
+
+  render_text->SetHorizontalAlignment(ALIGN_RIGHT);
+  EXPECT_EQ(9, render_text->GetLineOffset(0).x());
+  EXPECT_EQ(Rect(9, 1, 6, 10), GetSubstringBoundsUnion(Range(0, 1)));
+  EXPECT_EQ(Rect(14, 1, 6, 10), GetSubstringBoundsUnion(Range(1, 2)));
+  EXPECT_EQ(Rect(19, 1, 7, 10), GetSubstringBoundsUnion(Range(2, 3)));
+}
+
+TEST_F(RenderTextTest, SetFontList) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetFontList(
+      FontList(base::StringPrintf("Arial,%s, 13px", kSymbolFontName)));
+  const std::vector<Font>& fonts = render_text->font_list().GetFonts();
+  ASSERT_EQ(2U, fonts.size());
+  EXPECT_EQ("Arial", fonts[0].GetFontName());
+  EXPECT_EQ(kSymbolFontName, fonts[1].GetFontName());
+  EXPECT_EQ(13, render_text->font_list().GetFontSize());
+}
+
+TEST_F(RenderTextTest, StringSizeBoldWidth) {
+  // TODO(mboc): Add some unittests for other weights (currently not
+  // implemented because of test system font configuration).
+  RenderText* render_text = GetRenderText();
+
+#if defined(OS_FUCHSIA)
+  // Increase font size to ensure that bold and regular styles differ in width.
+  render_text->SetFontList(FontList("Arial, 20px"));
+#endif  // defined(OS_FUCHSIA)
+
+  render_text->SetText(u"Hello World");
+
+  const int plain_width = render_text->GetStringSize().width();
+  EXPECT_GT(plain_width, 0);
+
+  // Apply a bold style and check that the new width is greater.
+  render_text->SetWeight(Font::Weight::BOLD);
+  const int bold_width = render_text->GetStringSize().width();
+  EXPECT_GT(bold_width, plain_width);
+
+#if defined(OS_WIN)
+  render_text->SetWeight(Font::Weight::SEMIBOLD);
+  const int semibold_width = render_text->GetStringSize().width();
+  EXPECT_GT(bold_width, semibold_width);
+#endif
+
+  // Now, apply a plain style over the first word only.
+  render_text->ApplyWeight(Font::Weight::NORMAL, Range(0, 5));
+  const int plain_bold_width = render_text->GetStringSize().width();
+  EXPECT_GT(plain_bold_width, plain_width);
+  EXPECT_LT(plain_bold_width, bold_width);
+}
+
+TEST_F(RenderTextTest, StringSizeHeight) {
+  std::u16string cases[] = {
+      u"Hello World!",  // English
+      u"\u6328\u62f6",  // Japanese 挨拶 (characters press & near)
+      u"\u0915\u093f",  // Hindi कि (letter KA with vowel I)
+      u"\u05e0\u05b8",  // Hebrew נָ (letter NUN and point QAMATS)
+  };
+
+  const FontList default_font_list;
+  const FontList& larger_font_list = default_font_list.DeriveWithSizeDelta(24);
+  EXPECT_GT(larger_font_list.GetHeight(), default_font_list.GetHeight());
+
+  for (size_t i = 0; i < base::size(cases); i++) {
+    ResetRenderTextInstance();
+    RenderText* render_text = GetRenderText();
+    render_text->SetFontList(default_font_list);
+    render_text->SetText(cases[i]);
+
+    const int height1 = render_text->GetStringSize().height();
+    EXPECT_GT(height1, 0);
+
+    // Check that setting the larger font increases the height.
+    render_text->SetFontList(larger_font_list);
+    const int height2 = render_text->GetStringSize().height();
+    EXPECT_GT(height2, height1);
+  }
+}
+
+TEST_F(RenderTextTest, GetBaselineSanity) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"Hello World");
+  const int baseline = render_text->GetBaseline();
+  EXPECT_GT(baseline, 0);
+}
+
+TEST_F(RenderTextTest, GetCursorBoundsInReplacementMode) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdefg");
+  render_text->SetDisplayRect(Rect(100, 17));
+  SelectionModel sel_b(1, CURSOR_FORWARD);
+  SelectionModel sel_c(2, CURSOR_FORWARD);
+  Rect cursor_around_b = render_text->GetCursorBounds(sel_b, false);
+  Rect cursor_before_b = render_text->GetCursorBounds(sel_b, true);
+  Rect cursor_before_c = render_text->GetCursorBounds(sel_c, true);
+  EXPECT_EQ(cursor_around_b.x(), cursor_before_b.x());
+  EXPECT_EQ(cursor_around_b.right(), cursor_before_c.x());
+}
+
+TEST_F(RenderTextTest, GetCursorBoundsWithGraphemes) {
+  constexpr int kGlyphWidth = 10;
+  SetGlyphWidth(kGlyphWidth);
+  constexpr int kGlyphHeight = 12;
+  SetGlyphHeight(kGlyphHeight);
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"a\u0300e\u0301\U0001F601x\U0001F573\uFE0F");
+  render_text->SetDisplayRect(Rect(100, 20));
+  render_text->SetVerticalAlignment(ALIGN_TOP);
+
+  static const size_t kGraphemeBoundaries[] = {0, 2, 4, 6, 7};
+  for (size_t i = 0; i < base::size(kGraphemeBoundaries); ++i) {
+    const size_t text_offset = kGraphemeBoundaries[i];
+    EXPECT_EQ(render_text->GetCursorBounds(
+                  SelectionModel(text_offset, CURSOR_FORWARD), true),
+              Rect(i * kGlyphWidth, 0, 1, kGlyphHeight));
+    EXPECT_EQ(render_text->GetCursorBounds(
+                  SelectionModel(text_offset, CURSOR_FORWARD), false),
+              Rect(i * kGlyphWidth, 0, kGlyphWidth, kGlyphHeight));
+  }
+
+  // Check cursor bounds at end of text.
+  EXPECT_EQ(
+      render_text->GetCursorBounds(SelectionModel(10, CURSOR_FORWARD), true),
+      Rect(50, 0, 1, kGlyphHeight));
+  EXPECT_EQ(
+      render_text->GetCursorBounds(SelectionModel(10, CURSOR_FORWARD), false),
+      Rect(50, 0, 1, kGlyphHeight));
+}
+
+TEST_F(RenderTextTest, GetTextOffset) {
+  // The default horizontal text offset differs for LTR and RTL, and is only set
+  // when the RenderText object is created.  This test will check the default in
+  // LTR mode, and the next test will check the RTL default.
+  const bool was_rtl = base::i18n::IsRTL();
+  SetRTL(false);
+
+  // Reset the render text instance since the locale was changed.
+  ResetRenderTextInstance();
+  RenderText* render_text = GetRenderText();
+
+  render_text->SetText(u"abcdefg");
+  render_text->SetFontList(FontList("Arial, 13px"));
+
+  // Set display area's size equal to the font size.
+  const Size font_size(render_text->GetContentWidth(),
+                       render_text->font_list().GetHeight());
+  Rect display_rect(font_size);
+  render_text->SetDisplayRect(display_rect);
+
+  Vector2d offset = render_text->GetLineOffset(0);
+  EXPECT_TRUE(offset.IsZero());
+
+  const int kEnlargementX = 2;
+  display_rect.Inset(0, 0, -kEnlargementX, 0);
+  render_text->SetDisplayRect(display_rect);
+
+  // Check the default horizontal alignment.
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(0, offset.x());
+
+  // Check explicitly setting the horizontal alignment.
+  render_text->SetHorizontalAlignment(ALIGN_LEFT);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(0, offset.x());
+  render_text->SetHorizontalAlignment(ALIGN_CENTER);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(kEnlargementX / 2, offset.x());
+  render_text->SetHorizontalAlignment(ALIGN_RIGHT);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(kEnlargementX, offset.x());
+
+  // Check that text is vertically centered within taller display rects.
+  const int kEnlargementY = display_rect.height();
+  display_rect.Inset(0, 0, 0, -kEnlargementY);
+  render_text->SetDisplayRect(display_rect);
+  const Vector2d prev_offset = render_text->GetLineOffset(0);
+  display_rect.Inset(0, 0, 0, -2 * kEnlargementY);
+  render_text->SetDisplayRect(display_rect);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(prev_offset.y() + kEnlargementY, offset.y());
+
+  SetRTL(was_rtl);
+}
+
+TEST_F(RenderTextTest, GetTextOffsetHorizontalDefaultInRTL) {
+  // This only checks the default horizontal alignment in RTL mode; all other
+  // GetLineOffset(0) attributes are checked by the test above.
+  const bool was_rtl = base::i18n::IsRTL();
+  SetRTL(true);
+
+  // Reset the render text instance since the locale was changed.
+  ResetRenderTextInstance();
+  RenderText* render_text = GetRenderText();
+
+  render_text->SetText(u"abcdefg");
+  render_text->SetFontList(FontList("Arial, 13px"));
+  const int kEnlargement = 2;
+  const Size font_size(render_text->GetContentWidth() + kEnlargement,
+                       render_text->GetStringSize().height());
+  Rect display_rect(font_size);
+  render_text->SetDisplayRect(display_rect);
+  Vector2d offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(kEnlargement, offset.x());
+  SetRTL(was_rtl);
+}
+
+TEST_F(RenderTextTest, GetTextOffsetVerticalAlignment) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdefg");
+  render_text->SetFontList(FontList("Arial, 13px"));
+
+  // Set display area's size equal to the font size.
+  const Size font_size(render_text->GetContentWidth(),
+                       render_text->font_list().GetHeight());
+  Rect display_rect(font_size);
+  render_text->SetDisplayRect(display_rect);
+
+  Vector2d offset = render_text->GetLineOffset(0);
+  EXPECT_TRUE(offset.IsZero());
+
+  const int kEnlargementY = 10;
+  display_rect.Inset(0, 0, 0, -kEnlargementY);
+  render_text->SetDisplayRect(display_rect);
+
+  // Check the default vertical alignment (ALIGN_MIDDLE).
+  offset = render_text->GetLineOffset(0);
+  // Because the line height may be odd, and because of the way this calculation
+  // is done, we will accept a result within 1 DIP of half:
+  EXPECT_NEAR(kEnlargementY / 2, offset.y(), 1);
+
+  // Check explicitly setting the vertical alignment.
+  render_text->SetVerticalAlignment(ALIGN_TOP);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(0, offset.y());
+  render_text->SetVerticalAlignment(ALIGN_MIDDLE);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_NEAR(kEnlargementY / 2, offset.y(), 1);
+  render_text->SetVerticalAlignment(ALIGN_BOTTOM);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(kEnlargementY, offset.y());
+}
+
+TEST_F(RenderTextTest, GetTextOffsetVerticalAlignment_Multiline) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetMaxLines(2);
+  render_text->SetText(u"abcdefg hijklmn");
+  render_text->SetFontList(FontList("Arial, 13px"));
+
+  // Set display area's size equal to the font size.
+  const Size font_size(render_text->GetContentWidth(),
+                       render_text->font_list().GetHeight());
+
+  // Force text onto two lines.
+  Rect display_rect(Size(font_size.width() * 2 / 3, font_size.height() * 2));
+  render_text->SetDisplayRect(display_rect);
+
+  Vector2d offset = render_text->GetLineOffset(0);
+  EXPECT_TRUE(offset.IsZero());
+
+  const int kEnlargementY = 10;
+  display_rect.Inset(0, 0, 0, -kEnlargementY);
+  render_text->SetDisplayRect(display_rect);
+
+  // Check the default vertical alignment (ALIGN_MIDDLE).
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(kEnlargementY / 2, offset.y());
+
+  // Check explicitly setting the vertical alignment.
+  render_text->SetVerticalAlignment(ALIGN_TOP);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(0, offset.y());
+  render_text->SetVerticalAlignment(ALIGN_MIDDLE);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(kEnlargementY / 2, offset.y());
+  render_text->SetVerticalAlignment(ALIGN_BOTTOM);
+  offset = render_text->GetLineOffset(0);
+  EXPECT_EQ(kEnlargementY, offset.y());
+}
+
+TEST_F(RenderTextTest, SetDisplayOffset) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdefg");
+  render_text->SetFontList(FontList("Arial, 13px"));
+
+  const Size font_size(render_text->GetContentWidth(),
+                       render_text->font_list().GetHeight());
+  const int kEnlargement = 10;
+
+  // Set display width |kEnlargement| pixels greater than content width and test
+  // different possible situations. In this case the only possible display
+  // offset is zero.
+  Rect display_rect(font_size);
+  display_rect.Inset(0, 0, -kEnlargement, 0);
+  render_text->SetDisplayRect(display_rect);
+
+  struct {
+    HorizontalAlignment alignment;
+    int offset;
+  } small_content_cases[] = {
+    { ALIGN_LEFT, -kEnlargement },
+    { ALIGN_LEFT, 0 },
+    { ALIGN_LEFT, kEnlargement },
+    { ALIGN_RIGHT, -kEnlargement },
+    { ALIGN_RIGHT, 0 },
+    { ALIGN_RIGHT, kEnlargement },
+    { ALIGN_CENTER, -kEnlargement },
+    { ALIGN_CENTER, 0 },
+    { ALIGN_CENTER, kEnlargement },
+  };
+
+  for (size_t i = 0; i < base::size(small_content_cases); i++) {
+    render_text->SetHorizontalAlignment(small_content_cases[i].alignment);
+    render_text->SetDisplayOffset(small_content_cases[i].offset);
+    EXPECT_EQ(0, render_text->GetUpdatedDisplayOffset().x());
+  }
+
+  // Set display width |kEnlargement| pixels less than content width and test
+  // different possible situations.
+  display_rect = Rect(font_size);
+  display_rect.Inset(0, 0, kEnlargement, 0);
+  render_text->SetDisplayRect(display_rect);
+
+  struct {
+    HorizontalAlignment alignment;
+    int offset;
+    int expected_offset;
+  } large_content_cases[] = {
+    // When text is left-aligned, display offset can be in range
+    // [-kEnlargement, 0].
+    { ALIGN_LEFT, -2 * kEnlargement, -kEnlargement },
+    { ALIGN_LEFT, -kEnlargement / 2, -kEnlargement / 2 },
+    { ALIGN_LEFT, kEnlargement, 0 },
+    // When text is right-aligned, display offset can be in range
+    // [0, kEnlargement].
+    { ALIGN_RIGHT, -kEnlargement, 0 },
+    { ALIGN_RIGHT, kEnlargement / 2, kEnlargement / 2 },
+    { ALIGN_RIGHT, 2 * kEnlargement, kEnlargement },
+    // When text is center-aligned, display offset can be in range
+    // [-kEnlargement / 2 - 1, (kEnlargement - 1) / 2].
+    { ALIGN_CENTER, -kEnlargement, -kEnlargement / 2 - 1 },
+    { ALIGN_CENTER, -kEnlargement / 4, -kEnlargement / 4 },
+    { ALIGN_CENTER, kEnlargement / 4, kEnlargement / 4 },
+    { ALIGN_CENTER, kEnlargement, (kEnlargement - 1) / 2 },
+  };
+
+  for (size_t i = 0; i < base::size(large_content_cases); i++) {
+    render_text->SetHorizontalAlignment(large_content_cases[i].alignment);
+    render_text->SetDisplayOffset(large_content_cases[i].offset);
+    EXPECT_EQ(large_content_cases[i].expected_offset,
+              render_text->GetUpdatedDisplayOffset().x());
+  }
+}
+
+TEST_F(RenderTextTest, SameFontForParentheses) {
+  struct {
+    const char16_t left_char;
+    const char16_t right_char;
+  } punctuation_pairs[] = {
+    { '(', ')' },
+    { '{', '}' },
+    { '<', '>' },
+  };
+  struct {
+    std::u16string text;
+  } cases[] = {
+      // English(English)
+      {u"Hello World(a)"},
+      // English(English)English
+      {u"Hello World(a)Hello World"},
+
+      // Japanese(English)
+      {u"\u6328\u62f6(a)"},
+      // Japanese(English)Japanese
+      {u"\u6328\u62f6(a)\u6328\u62f6"},
+      // English(Japanese)English
+      {u"Hello World(\u6328\u62f6)Hello World"},
+
+      // Hindi(English)
+      {u"\u0915\u093f(a)"},
+      // Hindi(English)Hindi
+      {u"\u0915\u093f(a)\u0915\u093f"},
+      // English(Hindi)English
+      {u"Hello World(\u0915\u093f)Hello World"},
+
+      // Hebrew(English)
+      {u"\u05e0\u05b8(a)"},
+      // Hebrew(English)Hebrew
+      {u"\u05e0\u05b8(a)\u05e0\u05b8"},
+      // English(Hebrew)English
+      {u"Hello World(\u05e0\u05b8)Hello World"},
+  };
+
+  RenderText* render_text = GetRenderText();
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::u16string text = cases[i].text;
+    const size_t start_paren_char_index = text.find('(');
+    ASSERT_NE(std::u16string::npos, start_paren_char_index);
+    const size_t end_paren_char_index = text.find(')');
+    ASSERT_NE(std::u16string::npos, end_paren_char_index);
+
+    for (size_t j = 0; j < base::size(punctuation_pairs); ++j) {
+      text[start_paren_char_index] = punctuation_pairs[j].left_char;
+      text[end_paren_char_index] = punctuation_pairs[j].right_char;
+      render_text->SetText(text);
+
+      const std::vector<FontSpan> spans = GetFontSpans();
+
+      int start_paren_span_index = -1;
+      int end_paren_span_index = -1;
+      for (size_t k = 0; k < spans.size(); ++k) {
+        if (IndexInRange(spans[k].second, start_paren_char_index))
+          start_paren_span_index = k;
+        if (IndexInRange(spans[k].second, end_paren_char_index))
+          end_paren_span_index = k;
+      }
+      ASSERT_NE(-1, start_paren_span_index);
+      ASSERT_NE(-1, end_paren_span_index);
+
+      const Font& start_font = spans[start_paren_span_index].first;
+      const Font& end_font = spans[end_paren_span_index].first;
+      EXPECT_EQ(start_font.GetFontName(), end_font.GetFontName());
+      EXPECT_EQ(start_font.GetFontSize(), end_font.GetFontSize());
+      EXPECT_EQ(start_font.GetStyle(), end_font.GetStyle());
+    }
+  }
+}
+
+// Make sure the caret width is always >=1 so that the correct
+// caret is drawn at high DPI. crbug.com/164100.
+TEST_F(RenderTextTest, CaretWidth) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdefg");
+  EXPECT_GE(render_text->GetUpdatedCursorBounds().width(), 1);
+}
+
+TEST_F(RenderTextTest, SelectWord) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u" foo  a.bc.d bar");
+
+  struct {
+    size_t cursor;
+    size_t selection_start;
+    size_t selection_end;
+  } cases[] = {
+    { 0,   0,  1 },
+    { 1,   1,  4 },
+    { 2,   1,  4 },
+    { 3,   1,  4 },
+    { 4,   4,  6 },
+    { 5,   4,  6 },
+    { 6,   6,  7 },
+    { 7,   7,  8 },
+    { 8,   8, 10 },
+    { 9,   8, 10 },
+    { 10, 10, 11 },
+    { 11, 11, 12 },
+    { 12, 12, 13 },
+    { 13, 13, 16 },
+    { 14, 13, 16 },
+    { 15, 13, 16 },
+    { 16, 13, 16 },
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    render_text->SetCursorPosition(cases[i].cursor);
+    render_text->SelectWord();
+    EXPECT_EQ(Range(cases[i].selection_start, cases[i].selection_end),
+              render_text->selection());
+  }
+}
+
+// Make sure the last word is selected when the cursor is at text.length().
+TEST_F(RenderTextTest, LastWordSelected) {
+  const std::u16string kTestURL1 = u"http://www.google.com";
+  const std::u16string kTestURL2 = u"http://www.google.com/something/";
+
+  RenderText* render_text = GetRenderText();
+
+  render_text->SetText(kTestURL1);
+  render_text->SetCursorPosition(kTestURL1.length());
+  render_text->SelectWord();
+  EXPECT_EQ(u"com", GetSelectedText(render_text));
+  EXPECT_FALSE(render_text->selection().is_reversed());
+
+  render_text->SetText(kTestURL2);
+  render_text->SetCursorPosition(kTestURL2.length());
+  render_text->SelectWord();
+  EXPECT_EQ(u"/", GetSelectedText(render_text));
+  EXPECT_FALSE(render_text->selection().is_reversed());
+}
+
+// When given a non-empty selection, SelectWord should expand the selection to
+// nearest word boundaries.
+TEST_F(RenderTextTest, SelectMultipleWords) {
+  const std::u16string kTestURL = u"http://www.google.com";
+
+  RenderText* render_text = GetRenderText();
+
+  render_text->SetText(kTestURL);
+  render_text->SelectRange(Range(16, 20));
+  render_text->SelectWord();
+  EXPECT_EQ(u"google.com", GetSelectedText(render_text));
+  EXPECT_FALSE(render_text->selection().is_reversed());
+
+  // SelectWord should preserve the selection direction.
+  render_text->SelectRange(Range(20, 16));
+  render_text->SelectWord();
+  EXPECT_EQ(u"google.com", GetSelectedText(render_text));
+  EXPECT_TRUE(render_text->selection().is_reversed());
+}
+
+TEST_F(RenderTextTest, DisplayRectShowsCursorLTR) {
+  ASSERT_FALSE(base::i18n::IsRTL());
+  ASSERT_FALSE(base::i18n::ICUIsRTL());
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdefghijklmnopqrstuvwxzyabcdefg");
+  render_text->SetCursorPosition(render_text->text().length());
+  int width = render_text->GetStringSize().width();
+  ASSERT_GT(width, 10);
+
+  // Ensure that the cursor is placed at the width of its preceding text.
+  render_text->SetDisplayRect(Rect(width + 10, 1));
+  EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
+
+  // Ensure that shrinking the display rectangle keeps the cursor in view.
+  render_text->SetDisplayRect(Rect(width - 10, 1));
+  EXPECT_EQ(render_text->display_rect().width(),
+            render_text->GetUpdatedCursorBounds().right());
+
+  // Ensure that the text will pan to fill its expanding display rectangle.
+  render_text->SetDisplayRect(Rect(width - 5, 1));
+  EXPECT_EQ(render_text->display_rect().width(),
+            render_text->GetUpdatedCursorBounds().right());
+
+  // Ensure that a sufficiently large display rectangle shows all the text.
+  render_text->SetDisplayRect(Rect(width + 10, 1));
+  EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
+
+  // Repeat the test with RTL text.
+  render_text->SetText(u"אבגדהוזחטיךכלםמן");
+  render_text->SetCursorPosition(0);
+  width = render_text->GetStringSize().width();
+  ASSERT_GT(width, 10);
+
+  // Ensure that the cursor is placed at the width of its preceding text.
+  render_text->SetDisplayRect(Rect(width + 10, 1));
+  EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
+
+  // Ensure that shrinking the display rectangle keeps the cursor in view.
+  render_text->SetDisplayRect(Rect(width - 10, 1));
+  EXPECT_EQ(render_text->display_rect().width(),
+            render_text->GetUpdatedCursorBounds().right());
+
+  // Ensure that the text will pan to fill its expanding display rectangle.
+  render_text->SetDisplayRect(Rect(width - 5, 1));
+  EXPECT_EQ(render_text->display_rect().width(),
+            render_text->GetUpdatedCursorBounds().right());
+
+  // Ensure that a sufficiently large display rectangle shows all the text.
+  render_text->SetDisplayRect(Rect(width + 10, 1));
+  EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
+}
+
+TEST_F(RenderTextTest, DisplayRectShowsCursorRTL) {
+  // Set the application default text direction to RTL.
+  const bool was_rtl = base::i18n::IsRTL();
+  SetRTL(true);
+
+  // Reset the render text instance since the locale was changed.
+  ResetRenderTextInstance();
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abcdefghijklmnopqrstuvwxzyabcdefg");
+  render_text->SetCursorPosition(0);
+  int width = render_text->GetStringSize().width();
+  ASSERT_GT(width, 10);
+
+  // Ensure that the cursor is placed at the width of its preceding text.
+  render_text->SetDisplayRect(Rect(width + 10, 1));
+  EXPECT_EQ(render_text->display_rect().width() - width - 1,
+            render_text->GetUpdatedCursorBounds().x());
+
+  // Ensure that shrinking the display rectangle keeps the cursor in view.
+  render_text->SetDisplayRect(Rect(width - 10, 1));
+  EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+
+  // Ensure that the text will pan to fill its expanding display rectangle.
+  render_text->SetDisplayRect(Rect(width - 5, 1));
+  EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+
+  // Ensure that a sufficiently large display rectangle shows all the text.
+  render_text->SetDisplayRect(Rect(width + 10, 1));
+  EXPECT_EQ(render_text->display_rect().width() - width - 1,
+            render_text->GetUpdatedCursorBounds().x());
+
+  // Repeat the test with RTL text.
+  render_text->SetText(u"אבגדהוזחטיךכלםמן");
+  render_text->SetCursorPosition(render_text->text().length());
+  width = render_text->GetStringSize().width();
+  ASSERT_GT(width, 10);
+
+  // Ensure that the cursor is placed at the width of its preceding text.
+  render_text->SetDisplayRect(Rect(width + 10, 1));
+  EXPECT_EQ(render_text->display_rect().width() - width - 1,
+            render_text->GetUpdatedCursorBounds().x());
+
+  // Ensure that shrinking the display rectangle keeps the cursor in view.
+  render_text->SetDisplayRect(Rect(width - 10, 1));
+  EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+
+  // Ensure that the text will pan to fill its expanding display rectangle.
+  render_text->SetDisplayRect(Rect(width - 5, 1));
+  EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+
+  // Ensure that a sufficiently large display rectangle shows all the text.
+  render_text->SetDisplayRect(Rect(width + 10, 1));
+  EXPECT_EQ(render_text->display_rect().width() - width - 1,
+            render_text->GetUpdatedCursorBounds().x());
+
+  // Reset the application default text direction to LTR.
+  SetRTL(was_rtl);
+  EXPECT_EQ(was_rtl, base::i18n::IsRTL());
+}
+
+// Changing colors between or inside ligated glyphs should not break shaping.
+TEST_F(RenderTextTest, SelectionKeepsLigatures) {
+  const char16_t* const kTestStrings[] = {u"\u0644\u0623", u"\u0633\u0627"};
+  RenderText* render_text = GetRenderText();
+  render_text->set_selection_color(SK_ColorGREEN);
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    render_text->SetText(kTestStrings[i]);
+    const int expected_width = render_text->GetStringSize().width();
+    render_text->SelectRange({0, 1});
+    EXPECT_EQ(expected_width, render_text->GetStringSize().width());
+    // Drawing the text should not DCHECK or crash; see http://crbug.com/262119
+    render_text->Draw(canvas());
+    render_text->SetCursorPosition(0);
+  }
+}
+
+// Test that characters commonly used in the context of several scripts do not
+// cause text runs to break. For example the Japanese "long sound symbol" --
+// normally only used in a Katakana script, is also used on occasion when in
+// Hiragana scripts. It shouldn't cause a Hiragana text run break since that
+// could upset kerning.
+TEST_F(RenderTextTest, ScriptExtensionsDoNotBreak) {
+  // Apparently ramen restaurants prefer "らーめん" over "らあめん". The "dash"
+  // is the long sound symbol and usually just appears in Katakana writing.
+  const std::u16string ramen_hiragana = u"らーめん";
+  const std::u16string ramen_katakana = u"ラーメン";
+  const std::u16string ramen_mixed = u"らあメン";
+
+  EXPECT_EQ(std::vector<std::u16string>({ramen_hiragana}),
+            RunsFor(ramen_hiragana));
+  EXPECT_EQ(std::vector<std::u16string>({ramen_katakana}),
+            RunsFor(ramen_katakana));
+
+  EXPECT_EQ(std::vector<std::u16string>({u"らあ", u"メン"}),
+            RunsFor(ramen_mixed));
+}
+
+// Test that whitespace breaks runs of text. E.g. this can permit better fonts
+// to be chosen by the fallback mechanism when a font does not provide
+// whitespace glyphs for all scripts. See http://crbug.com/731563.
+TEST_F(RenderTextTest, WhitespaceDoesBreak) {
+  // Title of the Wikipedia page for "bit". ASCII spaces. In Hebrew and English.
+  // Note that the hyphens that Wikipedia uses are different. English uses
+  // ASCII (U+002D) "hyphen minus", Hebrew uses the U+2013 "EN Dash".
+  const std::u16string ascii_space_he = u"סיבית – ויקיפדיה";
+  const std::u16string ascii_space_en = u"Bit - Wikipedia";
+
+  // This says "thank you very much" with a full-width non-ascii space (U+3000).
+  const std::u16string full_width_space = u"ども　ありがと";
+
+  EXPECT_EQ(
+      std::vector<std::u16string>({u"סיבית", u" ", u"–", u" ", u"ויקיפדיה"}),
+      RunsFor(ascii_space_he));
+  EXPECT_EQ(
+      std::vector<std::u16string>({u"Bit", u" ", u"-", u" ", u"Wikipedia"}),
+      RunsFor(ascii_space_en));
+  EXPECT_EQ(std::vector<std::u16string>({u"ども", u"　", u"ありがと"}),
+            RunsFor(full_width_space));
+}
+
+// Ensure strings wrap onto multiple lines for a small available width.
+TEST_F(RenderTextTest, Multiline_MinWidth) {
+  const char16_t* kTestStrings[] = {kWeak, kLtr,    kLtrRtl,   kLtrRtlLtr,
+                                    kRtl,  kRtlLtr, kRtlLtrRtl};
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(1, 1000));
+  render_text->SetMultiline(true);
+  render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(kTestStrings[i]);
+    render_text->Draw(canvas());
+    EXPECT_GT(test_api()->lines().size(), 1U);
+  }
+}
+
+// Ensure strings wrap onto multiple lines for a normal available width.
+TEST_F(RenderTextTest, Multiline_NormalWidth) {
+  // Should RenderText suppress drawing whitespace at the end of a line?
+  // Currently it does not.
+  const struct {
+    const char16_t* const text;
+    const Range first_line_char_range;
+    const Range second_line_char_range;
+
+    // Lengths of each text run. Runs break at whitespace.
+    std::vector<size_t> run_lengths;
+
+    // The index of the text run that should start the second line.
+    int second_line_run_index;
+
+    bool is_ltr;
+  } kTestStrings[] = {
+      {u"abc defg hijkl", Range(0, 9), Range(9, 14), {3, 1, 4, 1, 5}, 4, true},
+      {u"qwertyzxcvbn", Range(0, 10), Range(10, 12), {10, 2}, 1, true},
+      // RTL: should render left-to-right as "<space>43210 \n cba9876".
+      // Note this used to say "Arabic language", in Arabic, but the last
+      // character in the string (\u0629) got fancy in an updated Mac font, so
+      // now the penultimate character repeats. (See "NOTE" below).
+      {u"اللغة العربيي",
+       Range(0, 6),
+       Range(6, 13),
+       {1 /* space first */, 5, 7},
+       2,
+       false},
+      // RTL: should render left-to-right as "<space>3210 \n cba98765".
+      {u"تفاح תפוזיךכם",
+       Range(0, 5),
+       Range(5, 13),
+       {1 /* space first */, 5, 8},
+       2,
+       false}};
+
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // Specify the fixed width for characters to suppress the possible variations
+  // of linebreak results.
+  SetGlyphWidth(5);
+  render_text->SetDisplayRect(Rect(50, 1000));
+  render_text->SetMultiline(true);
+  render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
+  render_text->SetHorizontalAlignment(ALIGN_TO_HEAD);
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(kTestStrings[i].text);
+    DrawVisualText();
+
+    ASSERT_EQ(2U, test_api()->lines().size());
+    EXPECT_EQ(kTestStrings[i].first_line_char_range,
+              LineCharRange(test_api()->lines()[0]));
+    EXPECT_EQ(kTestStrings[i].second_line_char_range,
+              LineCharRange(test_api()->lines()[1]));
+
+    ASSERT_EQ(kTestStrings[i].run_lengths.size(), text_log().size());
+
+    // NOTE: this expectation compares the character length and glyph counts,
+    // which isn't always equal. This is okay only because all the test
+    // strings are simple (like, no compound characters nor UTF16-surrogate
+    // pairs). Be careful in case more complicated test strings are added.
+    EXPECT_EQ(kTestStrings[i].run_lengths[0], text_log()[0].glyphs().size());
+    const int second_line_start = kTestStrings[i].second_line_run_index;
+    EXPECT_EQ(kTestStrings[i].run_lengths[second_line_start],
+              text_log()[second_line_start].glyphs().size());
+    EXPECT_LT(text_log()[0].origin().y(),
+              text_log()[second_line_start].origin().y());
+    if (kTestStrings[i].is_ltr) {
+      EXPECT_EQ(0, text_log()[0].origin().x());
+      EXPECT_EQ(0, text_log()[second_line_start].origin().x());
+    } else {
+      EXPECT_LT(0, text_log()[0].origin().x());
+      EXPECT_LT(0, text_log()[second_line_start].origin().x());
+    }
+  }
+}
+
+// Ensure strings don't wrap onto multiple lines for a sufficient available
+// width.
+TEST_F(RenderTextTest, Multiline_SufficientWidth) {
+  const char16_t* kTestStrings[] = {u"",
+                                    u" ",
+                                    u".",
+                                    u" . ",
+                                    u"abc",
+                                    u"a b c",
+                                    u"\u062E\u0628\u0632",
+                                    u"\u062E \u0628 \u0632"};
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(1000, 1000));
+  render_text->SetMultiline(true);
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(kTestStrings[i]);
+    render_text->Draw(canvas());
+    EXPECT_EQ(1U, test_api()->lines().size());
+  }
+}
+
+TEST_F(RenderTextTest, Multiline_Newline) {
+  const struct {
+    const char16_t* const text;
+    const size_t lines_count;
+    // Ranges of the characters on each line.
+    const Range line_char_ranges[3];
+  } kTestStrings[] = {
+      {u"abc\ndef", 2ul, {Range(0, 4), Range(4, 7), Range::InvalidRange()}},
+      {u"a \n b ", 2ul, {Range(0, 3), Range(3, 6), Range::InvalidRange()}},
+      {u"ab\n", 2ul, {Range(0, 3), Range(), Range::InvalidRange()}},
+      {u"a\n\nb", 3ul, {Range(0, 2), Range(2, 3), Range(3, 4)}},
+      {u"\nab", 2ul, {Range(0, 1), Range(1, 3), Range::InvalidRange()}},
+      {u"\n", 2ul, {Range(0, 1), Range(), Range::InvalidRange()}},
+  };
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(200, 1000));
+  render_text->SetMultiline(true);
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(kTestStrings[i].text);
+    render_text->Draw(canvas());
+    EXPECT_EQ(kTestStrings[i].lines_count, test_api()->lines().size());
+    if (kTestStrings[i].lines_count != test_api()->lines().size())
+      continue;
+
+    for (size_t j = 0; j < kTestStrings[i].lines_count; ++j) {
+      SCOPED_TRACE(base::StringPrintf("Line %" PRIuS "", j));
+      // There might be multiple segments in one line. Merge all the segments
+      // ranges in the same line.
+      const size_t segment_size = test_api()->lines()[j].segments.size();
+      Range line_range;
+      if (segment_size > 0)
+        line_range = Range(
+            test_api()->lines()[j].segments[0].char_range.start(),
+            test_api()->lines()[j].segments[segment_size - 1].char_range.end());
+      EXPECT_EQ(kTestStrings[i].line_char_ranges[j], line_range);
+    }
+  }
+}
+
+// Make sure that multiline mode ignores elide behavior.
+TEST_F(RenderTextTest, Multiline_IgnoreElide) {
+  const char16_t kTestString[] =
+      u"very very very long string xxxxxxxxxxxxxxxxxxxxxxxxxx";
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  render_text->SetDisplayRect(Rect(20, 1000));
+  render_text->SetText(kTestString);
+  EXPECT_NE(std::u16string::npos, render_text->GetDisplayText().find(u"…"));
+
+  render_text->SetMultiline(true);
+  EXPECT_EQ(std::u16string::npos, render_text->GetDisplayText().find(u"…"));
+}
+
+TEST_F(RenderTextTest, Multiline_NewlineCharacterReplacement) {
+  const char16_t* kTestStrings[] = {
+      u"abc\ndef", u"a \n b ", u"ab\n", u"a\n\nb", u"\nab", u"\n",
+  };
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    ResetRenderTextInstance();
+    RenderText* render_text = GetRenderText();
+    render_text->SetDisplayRect(Rect(200, 1000));
+    render_text->SetText(kTestStrings[i]);
+
+    std::u16string display_text = render_text->GetDisplayText();
+    // If RenderText is not multiline, the newline characters are replaced
+    // by symbols, therefore the character should be changed.
+    EXPECT_NE(kTestStrings[i], render_text->GetDisplayText());
+
+    // Setting multiline will fix this, the newline characters will be back
+    // to the original text.
+    render_text->SetMultiline(true);
+    EXPECT_EQ(kTestStrings[i], render_text->GetDisplayText());
+  }
+}
+
+// Ensure horizontal alignment works in multiline mode.
+TEST_F(RenderTextTest, Multiline_HorizontalAlignment) {
+  constexpr struct {
+    const char16_t* const text;
+    const HorizontalAlignment alignment;
+    const base::i18n::TextDirection display_text_direction;
+  } kTestStrings[] = {
+      {u"abcdefghi\nhijk", ALIGN_LEFT, base::i18n::LEFT_TO_RIGHT},
+      {u"nhij\nabcdefghi", ALIGN_LEFT, base::i18n::LEFT_TO_RIGHT},
+      // Hebrew, 2nd line shorter
+      {u"אבגדהוזח\n"
+       u"אבגד",
+       ALIGN_RIGHT, base::i18n::RIGHT_TO_LEFT},
+      // Hebrew, 2nd line longer
+      {u"אבגד\n"
+       u"אבגדהוזח",
+       ALIGN_RIGHT, base::i18n::RIGHT_TO_LEFT},
+      // Arabic, 2nd line shorter.
+      {u"\u0627\u0627\u0627\u0627\u0627\u0627\u0627\u0627\n"
+       u"\u0627\u0644\u0644\u063A",
+       ALIGN_RIGHT, base::i18n::RIGHT_TO_LEFT},
+      // Arabic, 2nd line longer.
+      {u"\u0627\u0644\u0644\u063A\n"
+       u"\u0627\u0627\u0627\u0627\u0627\u0627\u0627\u0627",
+       ALIGN_RIGHT, base::i18n::RIGHT_TO_LEFT},
+  };
+  const int kGlyphSize = 5;
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetHorizontalAlignment(ALIGN_TO_HEAD);
+  SetGlyphWidth(kGlyphSize);
+  render_text->SetDisplayRect(Rect(100, 1000));
+  render_text->SetMultiline(true);
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(testing::Message("kTestStrings[")
+                 << i << "] = " << kTestStrings[i].text);
+    render_text->SetText(kTestStrings[i].text);
+    EXPECT_EQ(kTestStrings[i].display_text_direction,
+              render_text->GetDisplayTextDirection());
+    render_text->Draw(canvas());
+    ASSERT_LE(2u, test_api()->lines().size());
+    if (kTestStrings[i].alignment == ALIGN_LEFT) {
+      EXPECT_EQ(0, test_api()->GetAlignmentOffset(0).x());
+      EXPECT_EQ(0, test_api()->GetAlignmentOffset(1).x());
+    } else {
+      std::vector<std::u16string> lines =
+          base::SplitString(kTestStrings[i].text, std::u16string(1, '\n'),
+                            base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+      ASSERT_EQ(2u, lines.size());
+
+      // Sanity check the input string lengths match the glyph lengths.
+      EXPECT_EQ(4u, std::min(lines[0].length(), lines[1].length()));
+      EXPECT_EQ(8u, std::max(lines[0].length(), lines[1].length()));
+      const internal::TextRunList* run_list = GetHarfBuzzRunList();
+      ASSERT_EQ(3U, run_list->runs().size());
+      EXPECT_EQ(lines[0].length(), run_list->runs()[0]->shape.glyph_count);
+      EXPECT_EQ(1u, run_list->runs()[1]->shape.glyph_count);  // \n.
+      EXPECT_EQ(lines[1].length(), run_list->runs()[2]->shape.glyph_count);
+
+      // The newline glyph itself has width 0.
+      int difference = (lines[0].length() - lines[1].length()) * kGlyphSize;
+      EXPECT_EQ(test_api()->GetAlignmentOffset(0).x() + difference,
+                test_api()->GetAlignmentOffset(1).x());
+    }
+  }
+}
+
+TEST_F(RenderTextTest, Multiline_WordWrapBehavior) {
+  const int kGlyphSize = 5;
+  const struct {
+    const WordWrapBehavior behavior;
+    const size_t num_lines;
+    const Range char_ranges[4];
+  } kTestScenarios[] = {
+    { IGNORE_LONG_WORDS, 3u,
+      { Range(0, 4), Range(4, 11), Range(11, 14), Range::InvalidRange() } },
+    { TRUNCATE_LONG_WORDS, 3u,
+      { Range(0, 4), Range(4, 8), Range(11, 14), Range::InvalidRange() } },
+    { WRAP_LONG_WORDS, 4u,
+      { Range(0, 4), Range(4, 8), Range(8, 11), Range(11, 14) } },
+    // TODO(mukai): implement ELIDE_LONG_WORDS. It's not used right now.
+  };
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetText(u"foo fooooo foo");
+  SetGlyphWidth(kGlyphSize);
+  render_text->SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
+
+  for (size_t i = 0; i < base::size(kTestScenarios); ++i) {
+    SCOPED_TRACE(base::StringPrintf(
+        "kTestScenarios[%" PRIuS "] %d", i, kTestScenarios[i].behavior));
+    render_text->SetWordWrapBehavior(kTestScenarios[i].behavior);
+    render_text->Draw(canvas());
+
+    ASSERT_EQ(kTestScenarios[i].num_lines, test_api()->lines().size());
+    for (size_t j = 0; j < test_api()->lines().size(); ++j) {
+      SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
+      EXPECT_EQ(kTestScenarios[i].char_ranges[j],
+                LineCharRange(test_api()->lines()[j]));
+      EXPECT_EQ(kTestScenarios[i].char_ranges[j].length() * kGlyphSize,
+                test_api()->lines()[j].size.width());
+    }
+  }
+}
+
+TEST_F(RenderTextTest, Multiline_LineBreakerBehavior) {
+  const int kGlyphSize = 5;
+  const struct {
+    const char16_t* const text;
+    const WordWrapBehavior behavior;
+    const Range char_ranges[3];
+  } kTestScenarios[] = {
+      {u"a single run",
+       IGNORE_LONG_WORDS,
+       {Range(0, 2), Range(2, 9), Range(9, 12)}},
+      // 3 words: "That's ", ""good". ", "aaa" and 7 runs: "That", "'", "s ",
+      // """, "good", "". ", "aaa". They all mixed together.
+      {u"That's \"good\". aaa",
+       IGNORE_LONG_WORDS,
+       {Range(0, 7), Range(7, 15), Range(15, 18)}},
+      // Test "\"" should be put into a new line correctly.
+      {u"a \"good\" one.",
+       IGNORE_LONG_WORDS,
+       {Range(0, 2), Range(2, 9), Range(9, 13)}},
+      // Test for full-width space.
+      {u"That's\u3000good.\u3000yyy",
+       IGNORE_LONG_WORDS,
+       {Range(0, 7), Range(7, 13), Range(13, 16)}},
+      {u"a single run",
+       TRUNCATE_LONG_WORDS,
+       {Range(0, 2), Range(2, 6), Range(9, 12)}},
+      {u"That's \"good\". aaa",
+       TRUNCATE_LONG_WORDS,
+       {Range(0, 4), Range(7, 11), Range(15, 18)}},
+      {u"That's good. aaa",
+       TRUNCATE_LONG_WORDS,
+       {Range(0, 4), Range(7, 11), Range(13, 16)}},
+      {u"a \"good\" one.",
+       TRUNCATE_LONG_WORDS,
+       {Range(0, 2), Range(2, 6), Range(9, 13)}},
+      {u"asingleword",
+       WRAP_LONG_WORDS,
+       {Range(0, 4), Range(4, 8), Range(8, 11)}},
+      {u"That's good",
+       WRAP_LONG_WORDS,
+       {Range(0, 4), Range(4, 7), Range(7, 11)}},
+      {u"That's \"g\".",
+       WRAP_LONG_WORDS,
+       {Range(0, 4), Range(4, 7), Range(7, 11)}},
+  };
+
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  SetGlyphWidth(kGlyphSize);
+  render_text->SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
+
+  for (size_t i = 0; i < base::size(kTestScenarios); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(kTestScenarios[i].text);
+    render_text->SetWordWrapBehavior(kTestScenarios[i].behavior);
+    render_text->Draw(canvas());
+
+    ASSERT_EQ(3u, test_api()->lines().size());
+    for (size_t j = 0; j < test_api()->lines().size(); ++j) {
+      SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
+      // Merge all the segments ranges in the same line.
+      size_t segment_size = test_api()->lines()[j].segments.size();
+      Range line_range;
+      if (segment_size > 0)
+        line_range = Range(
+            test_api()->lines()[j].segments[0].char_range.start(),
+            test_api()->lines()[j].segments[segment_size - 1].char_range.end());
+      EXPECT_EQ(kTestScenarios[i].char_ranges[j], line_range);
+      // Depending on kerning pairs in the font, a run's length is not strictly
+      // equal to number of glyphs * kGlyphsize. Size should match within a
+      // small margin.
+      const float kSizeMargin = 0.127;
+      EXPECT_LT(
+          std::abs(kTestScenarios[i].char_ranges[j].length() * kGlyphSize -
+                   test_api()->lines()[j].size.width()),
+          kSizeMargin);
+    }
+  }
+}
+
+// Test that Surrogate pairs or combining character sequences do not get
+// separated by line breaking.
+TEST_F(RenderTextTest, Multiline_SurrogatePairsOrCombiningChars) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
+
+  // Below is 'MUSICAL SYMBOL G CLEF' (U+1D11E), which is represented in UTF-16
+  // as two code units forming a surrogate pair: 0xD834 0xDD1E.
+  const char16_t kSurrogate[] = {0xD834, 0xDD1E, 0};
+  const std::u16string text_surrogate(kSurrogate);
+  const int kSurrogateWidth =
+      GetStringWidth(kSurrogate, render_text->font_list());
+
+  // Below is a Devanagari two-character combining sequence U+0921 U+093F. The
+  // sequence forms a single display character and should not be separated.
+  const char16_t kCombiningChars[] = {0x921, 0x93F, 0};
+  const std::u16string text_combining(kCombiningChars);
+  const int kCombiningCharsWidth =
+      GetStringWidth(kCombiningChars, render_text->font_list());
+
+  const struct {
+    const std::u16string text;
+    const int display_width;
+    const Range char_ranges[3];
+  } kTestScenarios[] = {
+      {text_surrogate + text_surrogate + text_surrogate,
+       kSurrogateWidth / 2 * 3,
+       {Range(0, 2), Range(2, 4), Range(4, 6)}},
+      {text_surrogate + u" " + kCombiningChars,
+       std::min(kSurrogateWidth, kCombiningCharsWidth) / 2,
+       {Range(0, 2), Range(2, 3), Range(3, 5)}},
+  };
+
+  for (size_t i = 0; i < base::size(kTestScenarios); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(kTestScenarios[i].text);
+    render_text->SetDisplayRect(Rect(0, 0, kTestScenarios[i].display_width, 0));
+    render_text->Draw(canvas());
+
+    ASSERT_EQ(3u, test_api()->lines().size());
+    for (size_t j = 0; j < test_api()->lines().size(); ++j) {
+      SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
+      // There is only one segment in each line.
+      EXPECT_EQ(kTestScenarios[i].char_ranges[j],
+                test_api()->lines()[j].segments[0].char_range);
+    }
+  }
+}
+
+// Test that Zero width characters have the correct line breaking behavior.
+TEST_F(RenderTextTest, Multiline_ZeroWidthChars) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  render_text->SetMultiline(true);
+  render_text->SetWordWrapBehavior(WRAP_LONG_WORDS);
+
+  // U+200B is Zero Width Space.
+  const std::u16string text = u"test\u200B\n\u200Btest.";
+  const int kTestWidth = GetStringWidth(u"test", render_text->font_list());
+  const Range char_ranges[3] = {Range(0, 6), Range(6, 11), Range(11, 12)};
+
+  render_text->SetText(text);
+  render_text->SetDisplayRect(Rect(0, 0, kTestWidth, 0));
+  render_text->Draw(canvas());
+
+  EXPECT_EQ(3u, test_api()->lines().size());
+  for (size_t j = 0;
+       j < std::min(base::size(char_ranges), test_api()->lines().size()); ++j) {
+    SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
+    int segment_size = test_api()->lines()[j].segments.size();
+    ASSERT_GT(segment_size, 0);
+    Range line_range(
+        test_api()->lines()[j].segments[0].char_range.start(),
+        test_api()->lines()[j].segments[segment_size - 1].char_range.end());
+    EXPECT_EQ(char_ranges[j], line_range);
+  }
+}
+
+TEST_F(RenderTextTest, Multiline_ZeroWidthNewline) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+
+  const std::u16string text(u"\n\n");
+  render_text->SetText(text);
+  EXPECT_EQ(3u, render_text->GetNumLines());
+  for (const auto& line : test_api()->lines()) {
+    EXPECT_EQ(0, line.size.width());
+    EXPECT_LT(0, line.size.height());
+  }
+
+  const internal::TextRunList* run_list = GetHarfBuzzRunList();
+  EXPECT_EQ(2U, run_list->size());
+  EXPECT_EQ(0, run_list->width());
+}
+
+TEST_F(RenderTextTest, Multiline_GetLineContainingCaret) {
+  struct {
+    const SelectionModel caret;
+    const size_t line_num;
+  } cases[] = {
+      {SelectionModel(8, CURSOR_FORWARD), 1},
+      {SelectionModel(9, CURSOR_BACKWARD), 1},
+      {SelectionModel(9, CURSOR_FORWARD), 2},
+      {SelectionModel(12, CURSOR_BACKWARD), 2},
+      {SelectionModel(12, CURSOR_FORWARD), 2},
+      {SelectionModel(13, CURSOR_BACKWARD), 3},
+      {SelectionModel(13, CURSOR_FORWARD), 3},
+      {SelectionModel(14, CURSOR_BACKWARD), 4},
+      {SelectionModel(14, CURSOR_FORWARD), 4},
+  };
+
+  // Set a non-integral width to cause rounding errors in calculating cursor
+  // bounds. GetCursorBounds calculates cursor position based on the horizontal
+  // span of the cursor, which is compared with the line widths to find out on
+  // which line the span stops. Rounding errors should be taken into
+  // consideration in comparing these two non-integral values.
+  SetGlyphWidth(5.3);
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(45, 1000));
+  render_text->SetMultiline(true);
+  render_text->SetVerticalAlignment(ALIGN_TOP);
+
+  for (const char16_t* text :
+       {u"\n123 456 789\n\n123", u"\nשנב גקכ עין\n\nחלך"}) {
+    for (const auto& sample : cases) {
+      SCOPED_TRACE(testing::Message()
+                   << "Testing " << (text[1] == '1' ? "LTR" : "RTL")
+                   << " Caret " << sample.caret << " line " << sample.line_num);
+      render_text->SetText(text);
+      EXPECT_EQ(5U, render_text->GetNumLines());
+      EXPECT_EQ(sample.line_num,
+                render_text->GetLineContainingCaret(sample.caret));
+
+      // GetCursorBounds should be in the same line as GetLineContainingCaret.
+      Rect bounds = render_text->GetCursorBounds(sample.caret, true);
+      EXPECT_EQ(static_cast<int>(sample.line_num),
+                GetLineContainingYCoord(bounds.origin().y() + 1));
+    }
+  }
+}
+
+TEST_F(RenderTextTest, NewlineWithoutMultilineFlag) {
+  const char16_t* kTestStrings[] = {
+      u"abc\ndef", u"a \n b ", u"ab\n", u"a\n\nb", u"\nab", u"\n",
+  };
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(200, 1000));
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(kTestStrings[i]);
+    render_text->Draw(canvas());
+
+    EXPECT_EQ(1U, test_api()->lines().size());
+  }
+}
+
+TEST_F(RenderTextTest, ControlCharacterReplacement) {
+  static const char16_t kTextWithControlCharacters[] = u"\b\r\a\t\n\v\f";
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(kTextWithControlCharacters);
+
+  // The control characters should have been replaced by their symbols.
+  EXPECT_EQ(u"␈␍␇␉␊␋␌", render_text->GetDisplayText());
+
+  // Setting multiline, the newline character will be back to the original text.
+  render_text->SetMultiline(true);
+  EXPECT_EQ(u"␈\r␇␉\n␋␌", render_text->GetDisplayText());
+
+  // The generic control characters should have been replaced by the replacement
+  // codepoints.
+  render_text->SetText(u"\u008f\u0080");
+  EXPECT_EQ(u"\ufffd\ufffd", render_text->GetDisplayText());
+}
+
+TEST_F(RenderTextTest, PrivateUseCharacterReplacement) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"xx\ue78d\ue78fa\U00100042z");
+
+  // The private use characters should have been replaced. If the code point is
+  // a surrogate pair, it needs to be replaced by two characters.
+  EXPECT_EQ(u"xx\ufffd\ufffda\ufffdz", render_text->GetDisplayText());
+
+  // The private use characters from Area-B must be replaced. The rewrite step
+  // replaced 2 characters by 1 character.
+  render_text->SetText(u"x\U00100000\U00100001\U00100002");
+  EXPECT_EQ(u"x\ufffd\ufffd\ufffd", render_text->GetDisplayText());
+}
+
+TEST_F(RenderTextTest, AppleSpecificPrivateUseCharacterReplacement) {
+  // see: http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/CORPCHAR.TXT
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"\uf8ff");
+#if defined(OS_APPLE)
+  EXPECT_EQ(u"\uf8ff", render_text->GetDisplayText());
+#else
+  EXPECT_EQ(u"\ufffd", render_text->GetDisplayText());
+#endif
+}
+
+TEST_F(RenderTextTest, MicrosoftSpecificPrivateUseCharacterReplacement) {
+  const char16_t* allowed_codepoints[] = {
+      u"\uF093", u"\uF094", u"\uF095", u"\uF096", u"\uF108",
+      u"\uF109", u"\uF10A", u"\uF10B", u"\uF10C", u"\uF10D",
+      u"\uF10E", u"\uEECA", u"\uEDE3"};
+  for (auto* codepoint : allowed_codepoints) {
+    RenderText* render_text = GetRenderText();
+    render_text->SetText(codepoint);
+#if defined(OS_WIN)
+    if (base::win::GetVersion() >= base::win::Version::WIN10) {
+      EXPECT_EQ(codepoint, render_text->GetDisplayText());
+    } else {
+      EXPECT_EQ(u"\uFFFD", render_text->GetDisplayText());
+    }
+#else
+    EXPECT_EQ(u"\uFFFD", render_text->GetDisplayText());
+#endif
+  }
+}
+
+TEST_F(RenderTextTest, InvalidSurrogateCharacterReplacement) {
+  // Text with invalid surrogates (surrogates low 0xDC00 and high 0xD800).
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"\xDC00\xD800");
+  EXPECT_EQ(u"\ufffd\ufffd", render_text->GetDisplayText());
+}
+
+// Make sure the horizontal positions of runs in a line (left-to-right for
+// LTR languages and right-to-left for RTL languages).
+TEST_F(RenderTextTest, HarfBuzz_HorizontalPositions) {
+  const struct {
+    const char16_t* const text;
+    const char* expected_runs;
+  } kTestStrings[] = {
+      {u"abc\u3042\u3044\u3046\u3048\u304A", "[0->2][3->7]"},
+      {u"\u062A\u0641\u0627\u062D\u05EA\u05E4וז", "[7<-4][3<-0]"},
+  };
+
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(kTestStrings[i].text);
+
+    EXPECT_EQ(kTestStrings[i].expected_runs, GetRunListStructureString());
+
+    DrawVisualText();
+
+    const internal::TextRunList* run_list = GetHarfBuzzRunList();
+    ASSERT_EQ(2U, run_list->size());
+    ASSERT_EQ(2U, text_log().size());
+
+    // Verifies the DrawText happens in the visual order and left-to-right.
+    // If the text is RTL, the logically first run should be drawn at last.
+    EXPECT_EQ(
+        run_list->runs()[run_list->logical_to_visual(0)]->shape.glyph_count,
+        text_log()[0].glyphs().size());
+    EXPECT_EQ(
+        run_list->runs()[run_list->logical_to_visual(1)]->shape.glyph_count,
+        text_log()[1].glyphs().size());
+    EXPECT_LT(text_log()[0].origin().x(), text_log()[1].origin().x());
+  }
+}
+
+// Test TextRunHarfBuzz's cluster finding logic.
+TEST_F(RenderTextTest, HarfBuzz_Clusters) {
+  struct {
+    uint32_t glyph_to_char[4];
+    Range chars[4];
+    Range glyphs[4];
+    bool is_rtl;
+  } cases[] = {
+    { // From string "A B C D" to glyphs "a b c d".
+      { 0, 1, 2, 3 },
+      { Range(0, 1), Range(1, 2), Range(2, 3), Range(3, 4) },
+      { Range(0, 1), Range(1, 2), Range(2, 3), Range(3, 4) },
+      false
+    },
+    { // From string "A B C D" to glyphs "d c b a".
+      { 3, 2, 1, 0 },
+      { Range(0, 1), Range(1, 2), Range(2, 3), Range(3, 4) },
+      { Range(3, 4), Range(2, 3), Range(1, 2), Range(0, 1) },
+      true
+    },
+    { // From string "A B C D" to glyphs "ab c c d".
+      { 0, 2, 2, 3 },
+      { Range(0, 2), Range(0, 2), Range(2, 3), Range(3, 4) },
+      { Range(0, 1), Range(0, 1), Range(1, 3), Range(3, 4) },
+      false
+    },
+    { // From string "A B C D" to glyphs "d c c ba".
+      { 3, 2, 2, 0 },
+      { Range(0, 2), Range(0, 2), Range(2, 3), Range(3, 4) },
+      { Range(3, 4), Range(3, 4), Range(1, 3), Range(0, 1) },
+      true
+    },
+  };
+
+  internal::TextRunHarfBuzz run((Font()));
+  run.range = Range(0, 4);
+  run.shape.glyph_count = 4;
+  run.shape.glyph_to_char.resize(4);
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::copy(cases[i].glyph_to_char, cases[i].glyph_to_char + 4,
+              run.shape.glyph_to_char.begin());
+    run.font_params.is_rtl = cases[i].is_rtl;
+
+    for (size_t j = 0; j < 4; ++j) {
+      SCOPED_TRACE(base::StringPrintf("Case %" PRIuS ", char %" PRIuS, i, j));
+      Range chars;
+      Range glyphs;
+      run.GetClusterAt(j, &chars, &glyphs);
+      EXPECT_EQ(cases[i].chars[j], chars);
+      EXPECT_EQ(cases[i].glyphs[j], glyphs);
+      EXPECT_EQ(cases[i].glyphs[j], run.CharRangeToGlyphRange(chars));
+    }
+  }
+}
+
+// Ensures GetClusterAt does not crash on invalid conditions. crbug.com/724880
+TEST_F(RenderTextTest, HarfBuzz_NoCrashOnTextRunGetClusterAt) {
+  internal::TextRunHarfBuzz run((Font()));
+  run.range = Range(0, 4);
+  run.shape.glyph_count = 4;
+  // Construct a |glyph_to_char| map where no glyph maps to the first character.
+  run.shape.glyph_to_char = {1u, 1u, 2u, 3u};
+
+  Range chars, glyphs;
+  // GetClusterAt should not crash asking for the cluster at position 0.
+  ASSERT_NO_FATAL_FAILURE(run.GetClusterAt(0, &chars, &glyphs));
+}
+
+// Ensure that graphemes with multiple code points do not get split.
+TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemeCases) {
+  const char16_t* cases[] = {
+      // Ä (A with combining umlaut), followed by a "B".
+      u"A\u0308B",
+      // कि (Devangari letter KA with vowel I), followed by an "a".
+      u"\u0915\u093f\u0905",
+      // จำ (Thai characters CHO CHAN and SARA AM, followed by Thai digit 0.
+      u"\u0e08\u0e33\u0E50",
+  };
+
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    SCOPED_TRACE(base::StringPrintf("Case %" PRIuS, i));
+
+    std::u16string text = cases[i];
+    render_text->SetText(text);
+    const internal::TextRunList* run_list = GetHarfBuzzRunList();
+    ASSERT_EQ(1U, run_list->size());
+    internal::TextRunHarfBuzz* run = run_list->runs()[0].get();
+
+    auto first_grapheme_bounds = run->GetGraphemeBounds(render_text, 0);
+    EXPECT_EQ(first_grapheme_bounds, run->GetGraphemeBounds(render_text, 1));
+    auto second_grapheme_bounds = run->GetGraphemeBounds(render_text, 2);
+    EXPECT_EQ(first_grapheme_bounds.end(), second_grapheme_bounds.start());
+  }
+}
+
+// Test the partition of a multi-grapheme cluster into grapheme ranges.
+TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemePartition) {
+  struct {
+    uint32_t glyph_to_char[2];
+    Range bounds[4];
+    bool is_rtl;
+  } cases[] = {
+    { // From string "A B C D" to glyphs "a bcd".
+      { 0, 1 },
+      { Range(0, 10), Range(10, 13), Range(13, 17), Range(17, 20) },
+      false
+    },
+    { // From string "A B C D" to glyphs "ab cd".
+      { 0, 2 },
+      { Range(0, 5), Range(5, 10), Range(10, 15), Range(15, 20) },
+      false
+    },
+    { // From string "A B C D" to glyphs "dcb a".
+      { 1, 0 },
+      { Range(10, 20), Range(7, 10), Range(3, 7), Range(0, 3) },
+      true
+    },
+    { // From string "A B C D" to glyphs "dc ba".
+      { 2, 0 },
+      { Range(15, 20), Range(10, 15), Range(5, 10), Range(0, 5) },
+      true
+    },
+  };
+
+  internal::TextRunHarfBuzz run((Font()));
+  run.range = Range(0, 4);
+  run.shape.glyph_count = 2;
+  run.shape.glyph_to_char.resize(2);
+  run.shape.positions.resize(4);
+  run.shape.width = 20;
+
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetText(u"abcd");
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::copy(cases[i].glyph_to_char, cases[i].glyph_to_char + 2,
+              run.shape.glyph_to_char.begin());
+    run.font_params.is_rtl = cases[i].is_rtl;
+    for (int j = 0; j < 2; ++j)
+      run.shape.positions[j].set(j * 10, 0);
+
+    for (size_t j = 0; j < 4; ++j) {
+      SCOPED_TRACE(base::StringPrintf("Case %" PRIuS ", char %" PRIuS, i, j));
+      RangeF bounds_f = run.GetGraphemeBounds(render_text, j);
+      Range bounds(std::round(bounds_f.start()), std::round(bounds_f.end()));
+      EXPECT_EQ(cases[i].bounds[j], bounds);
+    }
+  }
+}
+
+TEST_F(RenderTextTest, HarfBuzz_RunDirection) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  const std::u16string mixed = u"אב1234גדabc";
+  render_text->SetText(mixed);
+
+  // Get the run list for both display directions.
+  render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
+  EXPECT_EQ("[7<-6][2->5][1<-0][8->10]", GetRunListStructureString());
+
+  render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
+  EXPECT_EQ("[8->10][7<-6][2->5][1<-0]", GetRunListStructureString());
+}
+
+TEST_F(RenderTextTest, HarfBuzz_RunDirection_URLs) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  // This string, unescaped (logical order):
+  // ‭www.אב.גד/הוabc/def?זח=טי‬
+  const std::u16string mixed =
+      u"www.אב.גד/הו"
+      u"abc/def?זח=טי";
+  render_text->SetText(mixed);
+
+  // Normal LTR text should treat URL syntax as weak (as per the normal Bidi
+  // algorithm).
+  render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
+
+  // This is complex because a new run is created for each punctuation mark, but
+  // it simplifies down to: [0->3][11<-4][12->19][24<-20]
+  // Should render as: ‭www.וה/דג.באabc/def?יט=חז‬
+  const char kExpectedRunListNormalBidi[] =
+      "[0->2][3][11<-10][9][8<-7][6][5<-4][12->14][15][16->18][19][24<-23][22]"
+      "[21<-20]";
+  EXPECT_EQ(kExpectedRunListNormalBidi, GetRunListStructureString());
+
+  // DIRECTIONALITY_AS_URL should be exactly the same as
+  // DIRECTIONALITY_FORCE_LTR by default.
+  render_text->SetDirectionalityMode(DIRECTIONALITY_AS_URL);
+  EXPECT_EQ(kExpectedRunListNormalBidi, GetRunListStructureString());
+}
+
+TEST_F(RenderTextTest, HarfBuzz_BreakRunsByUnicodeBlocks) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // The ▶ (U+25B6) "play character" should break runs. http://crbug.com/278913
+  render_text->SetText(u"x\u25B6y");
+  EXPECT_EQ(std::vector<std::u16string>({u"x", u"▶", u"y"}),
+            GetRunListStrings());
+  EXPECT_EQ("[0][1][2]", GetRunListStructureString());
+
+  render_text->SetText(u"x \u25B6 y");
+  EXPECT_EQ(std::vector<std::u16string>({u"x", u" ", u"▶", u" ", u"y"}),
+            GetRunListStrings());
+  EXPECT_EQ("[0][1][2][3][4]", GetRunListStructureString());
+}
+
+TEST_F(RenderTextTest, HarfBuzz_BreakRunsByEmoji) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // 😁 (U+1F601, a smile emoji) and ✨ (U+2728, a sparkle icon) can both be
+  // drawn with color emoji fonts, so runs should be separated. crbug.com/448909
+  // Windows requires wide strings for \Unnnnnnnn universal character names.
+  render_text->SetText(u"x\U0001F601y\u2728");
+  EXPECT_EQ(std::vector<std::u16string>({u"x", u"😁", u"y", u"✨"}),
+            GetRunListStrings());
+  // U+1F601 is represented as a surrogate pair in UTF-16.
+  EXPECT_EQ("[0][1->2][3][4]", GetRunListStructureString());
+
+  // Ensure non-latin 「foo」 brackets around Emoji correctly break runs.
+  render_text->SetText(u"「🦋」「");
+  EXPECT_EQ(std::vector<std::u16string>({u"「", u"🦋", u"」「"}),
+            GetRunListStrings());
+  // Note 🦋 is a surrogate pair [1->2].
+  EXPECT_EQ("[0][1->2][3->4]", GetRunListStructureString());
+}
+
+TEST_F(RenderTextTest, HarfBuzz_BreakRunsByNewline) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetText(u"x\ny");
+  EXPECT_EQ(std::vector<std::u16string>({u"x", u"\n", u"y"}),
+            GetRunListStrings());
+  EXPECT_EQ("[0][1][2]", GetRunListStructureString());
+
+  // Validate that the character newline is an unknown glyph
+  // (see http://crbug/972090 and http://crbug/680430).
+  const internal::TextRunList* run_list = GetHarfBuzzRunList();
+  ASSERT_EQ(3U, run_list->size());
+  EXPECT_EQ(0U, run_list->runs()[0]->CountMissingGlyphs());
+  EXPECT_EQ(1U, run_list->runs()[1]->CountMissingGlyphs());
+  EXPECT_EQ(0U, run_list->runs()[2]->CountMissingGlyphs());
+
+  SkScalar x_width =
+      run_list->runs()[0]->GetGlyphWidthForCharRange(Range(0, 1));
+  EXPECT_GT(x_width, 0);
+
+  // Newline character must have a width of zero.
+  SkScalar newline_width =
+      run_list->runs()[1]->GetGlyphWidthForCharRange(Range(1, 2));
+  EXPECT_EQ(newline_width, 0);
+
+  SkScalar y_width =
+      run_list->runs()[2]->GetGlyphWidthForCharRange(Range(2, 3));
+  EXPECT_GT(y_width, 0);
+}
+
+TEST_F(RenderTextTest, HarfBuzz_BreakRunsByEmojiVariationSelectors) {
+  constexpr int kGlyphWidth = 30;
+  SetGlyphWidth(30);
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // ☎ (U+260E BLACK TELEPHONE) and U+FE0F (a variation selector) combine to
+  // form (on some platforms), ☎️, a red (or blue) telephone. The run can
+  // not break between the codepoints, or the incorrect glyph will be chosen.
+  render_text->SetText(u"z\u260E\uFE0Fy");
+  render_text->SetDisplayRect(Rect(1000, 50));
+  EXPECT_EQ(std::vector<std::u16string>({u"z", u"☎\uFE0F", u"y"}),
+            GetRunListStrings());
+  EXPECT_EQ("[0][1->2][3]", GetRunListStructureString());
+
+  // Also test moving the cursor across the telephone.
+  EXPECT_EQ(gfx::Range(0, 0), render_text->selection());
+  EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(gfx::Range(1, 1), render_text->selection());
+  EXPECT_EQ(1 * kGlyphWidth, render_text->GetUpdatedCursorBounds().x());
+
+#if defined(OS_APPLE)
+  // Early versions of macOS provide a tofu glyph for the variation selector.
+  // Bail out early except on 10.12 and above.
+  if (base::mac::IsAtMostOS10_11())
+    return;
+#endif
+
+  // TODO(865709): make this work on Android.
+#if !defined(OS_ANDROID)
+  // Jump over the telephone: two codepoints, but a single glyph.
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(gfx::Range(3, 3), render_text->selection());
+  EXPECT_EQ(2 * kGlyphWidth, render_text->GetUpdatedCursorBounds().x());
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(gfx::Range(4, 4), render_text->selection());
+  EXPECT_EQ(3 * kGlyphWidth, render_text->GetUpdatedCursorBounds().x());
+
+  // Nothing else.
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(gfx::Range(4, 4), render_text->selection());
+  EXPECT_EQ(3 * kGlyphWidth, render_text->GetUpdatedCursorBounds().x());
+#endif
+}
+
+TEST_F(RenderTextTest, HarfBuzz_OrphanedVariationSelector) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // It should never happen in normal usage, but a variation selector can appear
+  // by itself. In this case, it can form its own text run, with no glyphs.
+  render_text->SetText(u"\uFE0F");
+  EXPECT_EQ(std::vector<std::u16string>({u"\uFE0F"}), GetRunListStrings());
+  EXPECT_EQ("[0]", GetRunListStructureString());
+  CheckBoundsForCursorPositions();
+}
+
+TEST_F(RenderTextTest, HarfBuzz_AsciiVariationSelector) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+#if defined(OS_APPLE)
+  // Don't use a system font on macOS - asking for a variation selector on
+  // ASCII glyphs can tickle OS bugs. See http://crbug.com/785522.
+  render_text->SetFontList(FontList("Arial, 12px"));
+#endif
+  // A variation selector doesn't have to appear with Emoji. It will probably
+  // cause the typesetter to render tofu in this case, but it should not break
+  // a text run.
+  render_text->SetText(u"z\uFE0Fy");
+  EXPECT_EQ(std::vector<std::u16string>({u"z\uFE0Fy"}), GetRunListStrings());
+  EXPECT_EQ("[0->2]", GetRunListStructureString());
+  CheckBoundsForCursorPositions();
+}
+
+TEST_F(RenderTextTest, HarfBuzz_LeadingVariationSelector) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // When a variation selector appears either side of an emoji, ensure the one
+  // after is in the same run.
+  render_text->SetText(u"\uFE0F\u260E\uFE0Fy");
+  EXPECT_EQ(std::vector<std::u16string>({u"\uFE0F", u"☎\uFE0F", u"y"}),
+            GetRunListStrings());
+  EXPECT_EQ("[0][1->2][3]", GetRunListStructureString());
+  CheckBoundsForCursorPositions();
+}
+
+TEST_F(RenderTextTest, HarfBuzz_TrailingVariationSelector) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // If a redundant variation selector appears in an emoji run, it also gets
+  // merged into the emoji run. Usually there should be no effect. That's
+  // ultimately up to the typeface but, however it choses, cursor and glyph
+  // positions should behave.
+  render_text->SetText(u"z\u260E\uFE0F\uFE0Fy");
+  EXPECT_EQ(std::vector<std::u16string>({u"z", u"☎\uFE0F\uFE0F", u"y"}),
+            GetRunListStrings());
+  EXPECT_EQ("[0][1->3][4]", GetRunListStructureString());
+  CheckBoundsForCursorPositions();
+}
+
+TEST_F(RenderTextTest, HarfBuzz_MultipleVariationSelectorEmoji) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // Two emoji with variation selectors appearing in a correct sequence should
+  // be in the same run.
+  render_text->SetText(u"z\u260E\uFE0F\u260E\uFE0Fy");
+  EXPECT_EQ(std::vector<std::u16string>({u"z", u"☎\uFE0F☎\uFE0F", u"y"}),
+            GetRunListStrings());
+  EXPECT_EQ("[0][1->4][5]", GetRunListStructureString());
+  CheckBoundsForCursorPositions();
+}
+
+TEST_F(RenderTextTest, HarfBuzz_BreakRunsByAscii) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // ▶ (U+25B6, Geometric Shapes) and an ascii character should have
+  // different runs.
+  render_text->SetText(u"▶z");
+  EXPECT_EQ(std::vector<std::u16string>({u"▶", u"z"}), GetRunListStrings());
+  EXPECT_EQ("[0][1]", GetRunListStructureString());
+
+  // ★ (U+2605, Miscellaneous Symbols) and an ascii character should have
+  // different runs.
+  render_text->SetText(u"★1");
+  EXPECT_EQ(std::vector<std::u16string>({u"★", u"1"}), GetRunListStrings());
+  EXPECT_EQ("[0][1]", GetRunListStructureString());
+
+  // 🐱 (U+1F431, a cat face, Miscellaneous Symbols and Pictographs) and an
+  // ASCII period should have separate runs.
+  render_text->SetText(u"🐱.");
+  EXPECT_EQ(std::vector<std::u16string>({u"🐱", u"."}), GetRunListStrings());
+  // U+1F431 is represented as a surrogate pair in UTF-16.
+  EXPECT_EQ("[0->1][2]", GetRunListStructureString());
+
+  // 🥴 (U+1f974, Supplemental Symbols and Pictographs) and an ascii character
+  // should have different runs.
+  render_text->SetText(u"🥴$");
+  EXPECT_EQ(std::vector<std::u16string>({u"🥴", u"$"}), GetRunListStrings());
+  EXPECT_EQ("[0->1][2]", GetRunListStructureString());
+}
+
+// Test that, on Mac, font fallback mechanisms and Harfbuzz configuration cause
+// the correct glyphs to be chosen for unicode regional indicators.
+TEST_F(RenderTextTest, EmojiFlagGlyphCount) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(1000, 1000));
+  // Two flags: UK and Japan. Note macOS 10.9 only has flags for 10 countries.
+  std::u16string text(u"🇬🇧🇯🇵");
+  // Each flag is 4 UTF16 characters (2 surrogate pair code points).
+  EXPECT_EQ(8u, text.length());
+  render_text->SetText(text);
+
+  const internal::TextRunList* run_list = GetHarfBuzzRunList();
+  ASSERT_EQ(1U, run_list->runs().size());
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_APPLE)
+  // On Linux and macOS, the flags should be found, so two glyphs result.
+  EXPECT_EQ(2u, run_list->runs()[0]->shape.glyph_count);
+#elif defined(OS_ANDROID)
+  // It seems that some versions of android support the flags. Older versions
+  // don't support it.
+  EXPECT_TRUE(2u == run_list->runs()[0]->shape.glyph_count ||
+              4u == run_list->runs()[0]->shape.glyph_count);
+#else
+  // Elsewhere, the flags are not found, so each surrogate pair gets a
+  // placeholder glyph. Eventually, all platforms should have 2 glyphs.
+  EXPECT_EQ(4u, run_list->runs()[0]->shape.glyph_count);
+#endif
+}
+
+TEST_F(RenderTextTest, HarfBuzz_ShapeRunsWithMultipleFonts) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+
+  // The following text will be split in 3 runs:
+  //   1) u+1F3F3 u+FE0F u+FE0F  (Segoe UI Emoji)
+  //   2) u+0020                 (Segoe UI)
+  //   3) u+1F308 u+20E0 u+20E0  (Segoe UI Symbol)
+  // The three runs are shape in the same group but are mapped with three
+  // different fonts.
+  render_text->SetText(u"\U0001F3F3\U0000FE0F\U00000020\U0001F308\U000020E0");
+  std::vector<std::u16string> expected;
+  expected.push_back(u"\U0001F3F3\U0000FE0F");
+  expected.push_back(u" ");
+  expected.push_back(u"\U0001F308\U000020E0");
+  EXPECT_EQ(expected, GetRunListStrings());
+  EXPECT_EQ("[0->2][3][4->6]", GetRunListStructureString());
+
+#if defined(OS_WIN)
+  std::vector<std::string> expected_fonts;
+  if (base::win::GetVersion() < base::win::Version::WIN10)
+    expected_fonts = {"Segoe UI", "Segoe UI", "Segoe UI Symbol"};
+  else
+    expected_fonts = {"Segoe UI Emoji", "Segoe UI", "Segoe UI Symbol"};
+
+  std::vector<std::string> mapped_fonts;
+  for (const auto& font_span : GetFontSpans())
+    mapped_fonts.push_back(font_span.first.GetFontName());
+  EXPECT_EQ(expected_fonts, mapped_fonts);
+#endif
+}
+
+TEST_F(RenderTextTest, GlyphBounds) {
+  const char16_t* kTestStrings[] = {u"asdf 1234 qwer", u"\u0647\u0654",
+                                    u"\u0645\u0631\u062D\u0628\u0627"};
+  RenderText* render_text = GetRenderText();
+
+  for (size_t i = 0; i < base::size(kTestStrings); ++i) {
+    render_text->SetText(kTestStrings[i]);
+
+    for (size_t j = 0; j < render_text->text().length(); ++j)
+      EXPECT_FALSE(render_text->GetCursorSpan(Range(j, j + 1)).is_empty());
+  }
+}
+
+// Ensure that shaping with a non-existent font does not cause a crash.
+TEST_F(RenderTextTest, HarfBuzz_NonExistentFont) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetText(u"test");
+  const internal::TextRunList* run_list = GetHarfBuzzRunList();
+  ASSERT_EQ(1U, run_list->size());
+  internal::TextRunHarfBuzz* run = run_list->runs()[0].get();
+  ShapeRunWithFont(render_text->text(), Font("TheFontThatDoesntExist", 13),
+                   FontRenderParams(), run);
+}
+
+// Ensure an empty run returns sane values to queries.
+TEST_F(RenderTextTest, HarfBuzz_EmptyRun) {
+  internal::TextRunHarfBuzz run((Font()));
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetText(u"abcdefgh");
+
+  run.range = Range(3, 8);
+  run.shape.glyph_count = 0;
+  EXPECT_EQ(Range(), run.CharRangeToGlyphRange(Range(4, 5)));
+  EXPECT_EQ(RangeF(), run.GetGraphemeBounds(render_text, 4));
+  Range chars;
+  Range glyphs;
+  run.GetClusterAt(4, &chars, &glyphs);
+  EXPECT_EQ(Range(3, 8), chars);
+  EXPECT_EQ(Range(), glyphs);
+}
+
+// Ensure the line breaker doesn't compute the word's width bigger than the
+// actual size. See http://crbug.com/470073
+TEST_F(RenderTextTest, HarfBuzz_WordWidthWithDiacritics) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  const std::u16string kWord = u"\u0906\u092A\u0915\u0947 ";
+  render_text->SetText(kWord);
+  const SizeF text_size = render_text->GetStringSizeF();
+
+  render_text->SetText(kWord + kWord);
+  render_text->SetMultiline(true);
+  EXPECT_EQ(text_size.width() * 2, render_text->GetStringSizeF().width());
+  EXPECT_EQ(text_size.height(), render_text->GetStringSizeF().height());
+  render_text->SetDisplayRect(Rect(0, 0, std::ceil(text_size.width()), 0));
+  EXPECT_NEAR(text_size.width(), render_text->GetStringSizeF().width(), 1.0f);
+  EXPECT_EQ(text_size.height() * 2, render_text->GetStringSizeF().height());
+}
+
+// Ensure a string fits in a display rect with a width equal to the string's.
+TEST_F(RenderTextTest, StringFitsOwnWidth) {
+  RenderText* render_text = GetRenderText();
+  const std::u16string kString = u"www.example.com";
+
+  render_text->SetText(kString);
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(0, 3));
+  render_text->SetElideBehavior(ELIDE_TAIL);
+
+  render_text->SetDisplayRect(Rect(0, 0, 500, 100));
+  EXPECT_EQ(kString, render_text->GetDisplayText());
+  render_text->SetDisplayRect(Rect(0, 0, render_text->GetContentWidth(), 100));
+  EXPECT_EQ(kString, render_text->GetDisplayText());
+}
+
+// TODO(865715): Figure out why this fails on Android.
+#if !defined(OS_ANDROID)
+// Ensure that RenderText examines all of the fonts in its FontList before
+// falling back to other fonts.
+TEST_F(RenderTextTest, HarfBuzz_FontListFallback) {
+  // Double-check that the requested fonts are present.
+  std::string format = std::string(kTestFontName) + ", %s, 12px";
+  FontList font_list(base::StringPrintf(format.c_str(), kSymbolFontName));
+  const std::vector<Font>& fonts = font_list.GetFonts();
+  ASSERT_EQ(2u, fonts.size());
+  ASSERT_EQ(base::ToLowerASCII(kTestFontName),
+            base::ToLowerASCII(fonts[0].GetActualFontName()));
+  ASSERT_EQ(base::ToLowerASCII(kSymbolFontName),
+            base::ToLowerASCII(fonts[1].GetActualFontName()));
+
+  // "⊕" (U+2295, CIRCLED PLUS) should be rendered with Symbol rather than
+  // falling back to some other font that's present on the system.
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetFontList(font_list);
+  render_text->SetText(u"\u2295");
+  const std::vector<FontSpan> spans = GetFontSpans();
+  ASSERT_EQ(static_cast<size_t>(1), spans.size());
+  EXPECT_EQ(kSymbolFontName, spans[0].first.GetFontName());
+}
+#endif  // !defined(OS_ANDROID)
+
+// Ensure that the fallback fonts offered by GetFallbackFonts() are tried. Note
+// this test assumes the font "Arial" doesn't provide a unicode glyph for a
+// particular character, and that there is a system fallback font which does.
+// TODO(msw): Fallback doesn't find a glyph on Linux and Android.
+#if !defined(OS_LINUX) && !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
+TEST_F(RenderTextTest, HarfBuzz_UnicodeFallback) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetFontList(FontList("Arial, 12px"));
+
+  // An invalid Unicode character that somehow yields Korean character "han".
+  render_text->SetText(u"\ud55c");
+  const internal::TextRunList* run_list = GetHarfBuzzRunList();
+  ASSERT_EQ(1U, run_list->size());
+  EXPECT_EQ(0U, run_list->runs()[0]->CountMissingGlyphs());
+}
+#endif  // !defined(OS_LINUX) && !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
+
+// Ensure that the fallback fonts offered by GetFallbackFont() support glyphs
+// for different languages.
+TEST_F(RenderTextTest, HarfBuzz_FallbackFontsSupportGlyphs) {
+  // The word 'test' in different languages.
+  static const char16_t* kLanguageTests[] = {
+      u"test", u"اختبار", u"Δοκιμή", u"परीक्षा", u"تست", u"Փորձարկում",
+  };
+
+  for (const auto* text : kLanguageTests) {
+    RenderTextHarfBuzz* render_text = GetRenderText();
+    render_text->SetText(text);
+
+    const internal::TextRunList* run_list = GetHarfBuzzRunList();
+    ASSERT_EQ(1U, run_list->size());
+    int missing_glyphs = run_list->runs()[0]->CountMissingGlyphs();
+    if (missing_glyphs != 0) {
+      ADD_FAILURE() << "Text '" << text << "' is missing " << missing_glyphs
+                    << " glyphs.";
+    }
+  }
+}
+
+// Ensure that the fallback fonts offered by GetFallbackFont() support glyphs
+// for different languages.
+TEST_F(RenderTextTest, HarfBuzz_MultiRunsSupportGlyphs) {
+  static const char16_t* kLanguageTests[] = {
+      u"www.اختبار.com",
+      u"(اختبار)",
+      u"/ זה (מבחן) /",
+  };
+
+  for (const auto* text : kLanguageTests) {
+    RenderTextHarfBuzz* render_text = GetRenderText();
+    render_text->SetText(text);
+
+    int missing_glyphs = 0;
+    const internal::TextRunList* run_list = GetHarfBuzzRunList();
+    for (const auto& run : run_list->runs())
+      missing_glyphs += run->CountMissingGlyphs();
+
+    if (missing_glyphs != 0) {
+      ADD_FAILURE() << "Text '" << text << "' is missing " << missing_glyphs
+                    << " glyphs.";
+    }
+  }
+}
+
+struct FallbackFontCase {
+  const char* test_name;
+  const char16_t* text;
+};
+
+class RenderTextTestWithFallbackFontCase
+    : public RenderTextTest,
+      public ::testing::WithParamInterface<FallbackFontCase> {
+ public:
+  static std::string ParamInfoToString(
+      ::testing::TestParamInfo<FallbackFontCase> param_info) {
+    return param_info.param.test_name;
+  }
+};
+
+TEST_P(RenderTextTestWithFallbackFontCase, FallbackFont) {
+  FallbackFontCase param = GetParam();
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetText(param.text);
+
+  int missing_glyphs = 0;
+  const internal::TextRunList* run_list = GetHarfBuzzRunList();
+  for (const auto& run : run_list->runs())
+    missing_glyphs += run->CountMissingGlyphs();
+
+  EXPECT_EQ(missing_glyphs, 0);
+}
+
+const FallbackFontCase kUnicodeDecomposeCases[] = {
+    // Decompose to "\u0041\u0300".
+    {"letter_A_with_grave", u"\u00c0"},
+    // Decompose to "\u004f\u0328\u0304".
+    {"letter_O_with_ogonek_macron", u"\u01ec"},
+    // Decompose to "\u0041\u030a".
+    {"angstrom_sign", u"\u212b"},
+    // Decompose to "\u1100\u1164\u11b6".
+    {"hangul_syllable_gyaelh", u"\uac63"},
+    // Decompose to "\u1107\u1170\u11af".
+    {"hangul_syllable_bwel", u"\ubdc0"},
+    // Decompose to "\U00044039".
+    {"cjk_ideograph_fad4", u"\ufad4"},
+};
+
+INSTANTIATE_TEST_SUITE_P(FallbackFontUnicodeDecompose,
+                         RenderTextTestWithFallbackFontCase,
+                         ::testing::ValuesIn(kUnicodeDecomposeCases),
+                         RenderTextTestWithFallbackFontCase::ParamInfoToString);
+
+// Ensures that RenderText is finding an appropriate font and that every
+// codepoint can be rendered by the font. An error here can be by an incorrect
+// ItemizeText(...) leading to an invalid fallback font.
+const FallbackFontCase kComplexTextCases[] = {
+    {"simple1", u"test"},
+    {"simple2", u"اختبار"},
+    {"simple3", u"Δοκιμή"},
+    {"simple4", u"परीक्षा"},
+    {"simple5", u"تست"},
+    {"simple6", u"Փորձարկում"},
+    {"mixed1", u"www.اختبار.com"},
+    {"mixed2", u"(اختبار)"},
+    {"mixed3", u"/ זה (מבחן) /"},
+#if defined(OS_WIN)
+    {"asc_arb", u"abcښڛڜdef"},
+    {"devanagari", u"ञटठडढणतथ"},
+    {"ethiopic", u"መጩጪᎅⶹⶼ"},
+    {"greek", u"ξοπρς"},
+    {"kannada", u"ಠಡಢಣತಥ"},
+    {"lao", u"ປຝພຟມ"},
+    {"oriya", u"ଔକଖଗଘଙ"},
+    {"telugu_lat", u"aaఉయ!"},
+    {"common_math", u"ℳ: ¬ƒ(x)=½×¾"},
+    {"picto_title", u"☞☛test☚☜"},
+    {"common_numbers", u"𝟭𝟐⒓¹²"},
+    {"common_puncts", u",.!"},
+    {"common_space_math1", u" 𝓐"},
+    {"common_space_math2", u" 𝓉"},
+    {"common_split_spaces", u"♬  𝓐"},
+    {"common_mixed", u"\U0001d4c9\u24d4\U0001d42c"},
+    {"arrows", u"↰↱↲↳↴↵⇚⇛⇜⇝⇞⇟"},
+    {"arrows_space", u"↰ ↱ ↲ ↳ ↴ ↵ ⇚ ⇛ ⇜ ⇝ ⇞ ⇟"},
+    {"emoji_title", u"▶Feel goods"},
+    {"enclosed_alpha", u"ⒶⒷⒸⒹⒺⒻⒼ"},
+    {"shapes", u" ▶▷▸▹►▻◀◁◂◃◄◅"},
+    {"symbols", u"☂☎☏☝☫☬☭☮☯"},
+    {"symbols_space", u"☂ ☎ ☏ ☝ ☫ ☬ ☭ ☮ ☯"},
+    {"dingbats", u"✂✃✄✆✇✈"},
+    {"cjk_compatibility_ideographs", u"賈滑串句龜"},
+    {"lat_dev_ZWNJ", u"a\u200Cक"},
+    {"paren_picto", u"(☾☹☽)"},
+    {"emoji1", u"This is 💩!"},
+    {"emoji2", u"Look [🔝]"},
+    {"strange1", u"💔♬  𝓐 𝓉ⓔ𝐬т ＦỖ𝕣 ｃ卄尺𝕆ᵐ€  ♘👹"},
+    {"strange2", u"˜”*°•.˜”*°• A test for chrome •°*”˜.•°*”˜"},
+    {"strange3", u"𝐭єⓢт ｆσ𝐑 𝔠ʰ𝕣ό𝐌𝔢"},
+    {"strange4", u"тẸⓈ𝔱 𝔽𝕠ᖇ 𝕔𝐡ŕ𝔬ⓜẸ"},
+    {"url1", u"http://www.google.com"},
+    {"url2", u"http://www.nowhere.com/Lörick.html"},
+    {"url3", u"http://www.nowhere.com/تسجيل الدخول"},
+    {"url4", u"https://xyz.com:8080/تس(1)جيل الدخول"},
+    {"url5", u"http://www.script.com/test.php?abc=42&cde=12&f=%20%20"},
+    {"punct1", u"This‐is‑a‒test–for—punctuations"},
+    {"punct2", u"⁅All ‷magic‴ comes with a ‶price″⁆"},
+    {"punct3", u"⍟ Complete my sentence… †"},
+    {"parens", u"❝This❞ 「test」 has ((a)) 【lot】 [{of}] 〚parentheses〛"},
+    {"games", u"Let play: ♗♘⚀⚁♠♣"},
+    {"braille", u"⠞⠑⠎⠞ ⠋⠕⠗ ⠉⠓⠗⠕⠍⠑"},
+    {"emoticon1", u"¯\\_(ツ)_/¯"},
+    {"emoticon2", u"٩(⁎❛ᴗ❛⁎)۶"},
+    {"emoticon3", u"(͡° ͜ʖ ͡°)"},
+    {"emoticon4", u"[̲̅$̲̅(̲̅5̲̅)̲̅$̲̅]"},
+#endif
+};
+
+INSTANTIATE_TEST_SUITE_P(FallbackFontComplexTextCases,
+                         RenderTextTestWithFallbackFontCase,
+                         ::testing::ValuesIn(kComplexTextCases),
+                         RenderTextTestWithFallbackFontCase::ParamInfoToString);
+
+// Test cases to ensures the COMMON unicode script is split by unicode code
+// block. These tests work on Windows and Mac default fonts installation.
+// On other platforms, the fonts are mock (see test_fonts).
+const FallbackFontCase kCommonScriptCases[] = {
+#if defined(OS_WIN)
+    // The following tests are made to work on win7 and win10.
+    {"common00", u"\u237b\u2ac1\u24f5\u259f\u2a87\u23ea\u25d4\u2220"},
+    {"common01", u"\u2303\u2074\u2988\u32b6\u26a2\u24e5\u2a53\u2219"},
+    {"common02", u"\u29b2\u25fc\u2366\u24ae\u2647\u258e\u2654\u25fe"},
+    {"common03", u"\u21ea\u22b4\u29b0\u2a84\u0008\u2657\u2731\u2697"},
+    {"common04", u"\u2b3c\u2932\u21c8\u23cf\u20a1\u2aa2\u2344\u0011"},
+    {"common05", u"\u22c3\u2a56\u2340\u21b7\u26ba\u2798\u220f\u2404"},
+    {"common06", u"\u21f9\u25fd\u008e\u21e6\u2686\u21e4\u259f\u29ee"},
+    {"common07", u"\u231e\ufe39\u0008\u2349\u2262\u2270\uff09\u2b3b"},
+    {"common08", u"\u24a3\u236e\u29b2\u2259\u26ea\u2705\u00ae\u2a23"},
+    {"common09", u"\u33bd\u235e\u2018\u32ba\u2973\u02c1\u20b9\u25b4"},
+    {"common10", u"\u2245\u2a4d\uff19\u2042\u2aa9\u2658\u276e\uff40"},
+    {"common11", u"\u0007\u21b4\u23c9\u2593\u21ba\u00a0\u258f\u23b3"},
+    {"common12", u"\u2938\u250c\u2240\u2676\u2297\u2b07\u237e\u2a04"},
+    {"common13", u"\u2520\u233a\u20a5\u2744\u2445\u268a\u2716\ufe62"},
+    {"common14", u"\ufe4d\u25d5\u2ae1\u2a35\u2323\u273c\u26be\u2a3b"},
+    {"common15", u"\u2aa2\u0000\ufe65\u2962\u2573\u21f8\u2651\u02d2"},
+    {"common16", u"\u225c\u2283\u2960\u4de7\uff12\uffe1\u0016\u2905"},
+    {"common17", u"\uff07\u25aa\u2076\u259e\u226c\u2568\u0026\u2691"},
+    {"common18", u"\u2388\u21c2\u208d\u2a7f\u22d0\u2583\u2ad5\u240f"},
+    {"common19", u"\u230a\u27ac\u001e\u261e\u259d\u25c3\u33a5\u0011"},
+    {"common20", u"\ufe54\u29c7\u2477\u21ed\u2069\u4dfc\u2ae2\u21e8"},
+    {"common21", u"\u2131\u2ab7\u23b9\u2660\u2083\u24c7\u228d\u2a01"},
+    {"common22", u"\u2587\u2572\u21df\uff3c\u02cd\ufffd\u2404\u22b3"},
+    {"common23", u"\u4dc3\u02fe\uff09\u25a3\ufe14\u255c\u2128\u2698"},
+    {"common24", u"\u2b36\u3382\u02f6\u2752\uff16\u22cf\u00b0\u21d6"},
+    {"common25", u"\u2561\u23db\u2958\u2782\u22af\u2621\u24a3\u29ae"},
+    {"common26", u"\u2693\u22e2\u2988\u2987\u33ba\u2a94\u298e\u2328"},
+    {"common27", u"\u266c\u2aa5\u2405\uffeb\uff5c\u2902\u291e\u02e6"},
+    {"common28", u"\u2634\u32b2\u3385\u2032\u33be\u2366\u2ac7\u23cf"},
+    {"common29", u"\u2981\ua721\u25a9\u2320\u21cf\u295a\u2273\u2ac2"},
+    {"common30", u"\u22d9\u2465\u2347\u2a94\u4dca\u2389\u23b0\u208d"},
+    {"common31", u"\u21cc\u2af8\u2912\u23a4\u2271\u2303\u241e\u33a1"},
+#elif defined(OS_ANDROID)
+    {"common00", u"\u2497\uff04\u277c\u21b6\u2076\u21e4\u2068\u21b3"},
+    {"common01", u"\u2663\u2466\u338e\u226b\u2734\u21be\u3389\u00ab"},
+    {"common02", u"\u2062\u2197\u3392\u2681\u33be\u206d\ufe10\ufe34"},
+    {"common03", u"\u02db\u00b0\u02d3\u2745\u33d1\u21e4\u24e4\u33d6"},
+    {"common04", u"\u21da\u261f\u26a1\u2586\u27af\u2560\u21cd\u25c6"},
+    {"common05", u"\ufe51\uff17\u0027\u21fd\u24de\uff5e\u2606\u251f"},
+    {"common06", u"\u2493\u2466\u21fc\u226f\u202d\u21a9\u0040\u265d"},
+    {"common07", u"\u2103\u255a\u2153\u26be\u27ac\u222e\u2490\u21a4"},
+    {"common08", u"\u270b\u2486\u246b\u263c\u27b6\u21d9\u219d\u25a9"},
+    {"common09", u"\u002d\u2494\u25fd\u2321\u2111\u2511\u00d7\u2535"},
+    {"common10", u"\u2523\u203e\u25b2\ufe18\u2499\u2229\ufd3e\ufe16"},
+    {"common11", u"\u2133\u2716\u273f\u2064\u2248\u005c\u265f\u21e6"},
+    {"common12", u"\u2060\u246a\u231b\u2726\u25bd\ufe40\u002e\u25ca"},
+    {"common13", u"\ufe39\u24a2\ufe18\u254b\u249c\u3396\ua71f\u2466"},
+    {"common14", u"\u21b8\u2236\u251a\uff11\u2077\u0035\u27bd\u2013"},
+    {"common15", u"\u2668\u2551\u221a\u02bc\u2741\u2649\u2192\u00a1"},
+    {"common16", u"\u2211\u21ca\u24dc\u2536\u201b\u21c8\u2530\u25fb"},
+    {"common17", u"\u231a\u33d8\u2934\u27bb\u2109\u23ec\u20a9\u3000"},
+    {"common18", u"\u2069\u205f\u33d3\u2466\u24a1\u24dd\u21ac\u21e3"},
+    {"common19", u"\u2737\u219a\u21f1\u2285\u226a\u00b0\u27b2\u2746"},
+    {"common20", u"\u264f\u2539\u2202\u264e\u2548\u2530\u2111\u2007"},
+    {"common21", u"\u2799\u0035\u25e4\u265b\u24e2\u2044\u222b\u0021"},
+    {"common22", u"\u2728\u00a2\u2533\ufe43\u33c9\u27a2\u02f9\u005d"},
+    {"common23", u"\ufe68\u256c\u25b6\u276c\u2771\u33c4\u2712\u24b3"},
+    {"common24", u"\ufe5d\ufe31\ufe3d\u205e\u2512\u33b8\u272b\ufe4f"},
+    {"common25", u"\u24e7\u25fc\u2582\u2743\u2010\u2474\u2262\u251a"},
+    {"common26", u"\u2020\u211c\u24b4\u33c7\u2007\uff0f\u267f\u00b4"},
+    {"common27", u"\u266c\u3399\u2570\u33a4\u276e\u00a8\u2506\u24dc"},
+    {"common28", u"\u2202\ufe43\u2511\u2191\u339a\u33b0\u02d7\u2473"},
+    {"common29", u"\u2517\u2297\u2762\u2460\u25bd\u24a9\u21a7\ufe64"},
+    {"common30", u"\u2105\u2722\u275d\u249c\u21a2\u2590\u2260\uff5d"},
+    {"common31", u"\u33ba\u21c6\u2706\u02cb\ufe64\u02e6\u0374\u2493"},
+#elif defined(OS_APPLE)
+    {"common00", u"\u2153\u24e0\u2109\u02f0\u2a8f\u25ed\u02c5\u2716"},
+    {"common01", u"\u02f0\u208c\u2203\u2518\u2067\u2270\u21f1\ufe66"},
+    {"common02", u"\u2686\u2585\u2b15\u246f\u23e3\u21b4\u2394\ufe31"},
+    {"common03", u"\u23c1\u2a97\u201e\u2200\u3389\u25d3\u02c2\u259d"},
+#else
+    // The following tests are made for the mock fonts (see test_fonts).
+    {"common00", u"\u2153\u24e0\u2109\u02f0\u2a8f\u25ed\u02c5\u2716"},
+    {"common01", u"\u02f0\u208c\u2203\u2518\u2067\u2270\u21f1\ufe66"},
+    {"common02", u"\u2686\u2585\u2b15\u246f\u23e3\u21b4\u2394\ufe31"},
+    {"common03", u"\u23c1\u2a97\u201e\u2200\u3389\u25d3\u02c2\u259d"},
+    {"common04", u"\u2075\u4dec\u252a\uff15\u4df6\u2668\u27fa\ufe17"},
+    {"common05", u"\u260b\u2049\u3036\u2a85\u2b15\u23c7\u230a\u2374"},
+    {"common06", u"\u2771\u27fa\u255d\uff0b\u2213\u3396\u2a85\u2276"},
+    {"common07", u"\u211e\u2b06\u2255\u2727\u26c3\u33cf\u267d\u2ab2"},
+    {"common08", u"\u2373\u20b3\u22b8\u2a0f\u02fd\u2585\u3036\ufe48"},
+    {"common09", u"\u256d\u2940\u21d8\u4dde\u23a1\u226b\u3374\u2a99"},
+    {"common10", u"\u270f\u24e5\u26c1\u2131\u21f5\u25af\u230f\u27fe"},
+    {"common11", u"\u27aa\u23a2\u02ef\u2373\u2257\u2749\u2496\ufe31"},
+    {"common12", u"\u230a\u25fb\u2117\u3386\u32cc\u21c5\u24c4\u207e"},
+    {"common13", u"\u2467\u2791\u3393\u33bb\u02ca\u25de\ua788\u278f"},
+    {"common14", u"\ua719\u25ed\u20a8\u20a1\u4dd8\u2295\u24eb\u02c8"},
+    {"common15", u"\u22b6\u2520\u2036\uffee\u21df\u002d\u277a\u2b24"},
+    {"common16", u"\u21f8\u211b\u22a0\u25b6\u263e\u2704\u221a\u2758"},
+    {"common17", u"\ufe10\u2060\u24ac\u3385\u27a1\u2059\u2689\u2278"},
+    {"common18", u"\u269b\u211b\u33a4\ufe36\u239e\u267f\u2423\u24a2"},
+    {"common19", u"\u4ded\u262d\u225e\u248b\u21df\u279d\u2518\u21ba"},
+    {"common20", u"\u225a\uff16\u21d4\u21c6\u02ba\u2545\u23aa\u005e"},
+    {"common21", u"\u20a5\u265e\u3395\u2a6a\u2555\u22a4\u2086\u23aa"},
+    {"common22", u"\u203f\u3250\u2240\u24e9\u21cb\u258f\u24b1\u3259"},
+    {"common23", u"\u27bd\u263b\uff1f\u2199\u2547\u258d\u201f\u2507"},
+    {"common24", u"\u2482\u2548\u02dc\u231f\u24cd\u2198\u220e\u20ad"},
+    {"common25", u"\u2ff7\u2540\ufe48\u2197\u276b\u2574\u2062\u3398"},
+    {"common26", u"\u2663\u21cd\u263f\u23e5\u22d7\u2518\u21b9\u2628"},
+    {"common27", u"\u21fa\ufe66\u2739\u2051\u21f4\u3399\u2599\u25f7"},
+    {"common28", u"\u29d3\u25ec\u27a6\u24e0\u2735\u25b4\u2737\u25db"},
+    {"common29", u"\u2622\u22e8\u33d2\u21d3\u2502\u2153\u2669\u25f2"},
+    {"common30", u"\u2121\u21af\u2729\u203c\u337a\u2464\u2b08\u2e24"},
+    {"common31", u"\u33cd\u007b\u02d2\u22cc\u32be\u2ffa\u2787\u02e9"},
+#endif
+};
+
+INSTANTIATE_TEST_SUITE_P(FallbackFontCommonScript,
+                         RenderTextTestWithFallbackFontCase,
+                         ::testing::ValuesIn(kCommonScriptCases),
+                         RenderTextTestWithFallbackFontCase::ParamInfoToString);
+
+#if defined(OS_WIN)
+// Ensures that locale is used for fonts selection.
+TEST_F(RenderTextTest, CJKFontWithLocale) {
+  const char16_t kCJKTest[] = u"\u8AA4\u904E\u9AA8";
+  static const char* kLocaleTests[] = {"zh-CN", "ja-JP", "ko-KR"};
+
+  std::set<std::string> tested_font_names;
+  for (const auto* locale : kLocaleTests) {
+    base::i18n::SetICUDefaultLocale(locale);
+    ResetRenderTextInstance();
+
+    RenderTextHarfBuzz* render_text = GetRenderText();
+    render_text->SetText(kCJKTest);
+
+    const std::vector<FontSpan> font_spans = GetFontSpans();
+    ASSERT_EQ(font_spans.size(), 1U);
+
+    // Expect the font name to be different for each locale.
+    bool unique_font_name =
+        tested_font_names.insert(font_spans[0].first.GetFontName()).second;
+    EXPECT_TRUE(unique_font_name);
+  }
+}
+#endif  // defined(OS_WIN)
+
+TEST_F(RenderTextTest, SameFontAccrossIgnorableCodepoints) {
+  RenderText* render_text = GetRenderText();
+
+  render_text->SetText(u"\u060F");
+  const std::vector<FontSpan> spans1 = GetFontSpans();
+  ASSERT_EQ(1u, spans1.size());
+  Font font1 = spans1[0].first;
+
+  render_text->SetText(u"\u060F\u200C\u060F");
+  const std::vector<FontSpan> spans2 = GetFontSpans();
+  ASSERT_EQ(1u, spans2.size());
+  Font font2 = spans2[0].first;
+
+  // Ensures the same font is used with or without the joiners
+  // (see http://crbug.com/1036652).
+  EXPECT_EQ(font1.GetFontName(), font2.GetFontName());
+}
+
+TEST_F(RenderTextTest, ZeroWidthCharacters) {
+  static const char16_t* kEmptyText[] = {
+      u"\u200C",  // ZERO WIDTH NON-JOINER
+      u"\u200D",  // ZERO WIDTH JOINER
+      u"\u200B",  // ZERO WIDTH SPACE
+      u"\uFEFF",  // ZERO WIDTH NO-BREAK SPACE
+  };
+
+  for (const auto* text : kEmptyText) {
+    RenderTextHarfBuzz* render_text = GetRenderText();
+    render_text->SetText(text);
+
+    const internal::TextRunList* run_list = GetHarfBuzzRunList();
+    EXPECT_EQ(0, run_list->width());
+    ASSERT_EQ(run_list->runs().size(), 1U);
+    EXPECT_EQ(run_list->runs()[0]->CountMissingGlyphs(), 0U);
+  }
+}
+
+// Ensure that the width reported by RenderText is sufficient for drawing. Draws
+// to a canvas and checks if any pixel beyond the bounding rectangle is colored.
+TEST_F(RenderTextTest, DISABLED_TextDoesntClip) {
+  const char* kTestStrings[] = {
+      "            ",
+      // TODO(dschuyler): Underscores draw outside GetStringSize;
+      // crbug.com/459812.  This appears to be a preexisting issue that wasn't
+      // revealed by the prior unit tests.
+      // "TEST_______",
+      "TEST some stuff", "WWWWWWWWWW", "gAXAXAXAXAXAXA", "gÅXÅXÅXÅXÅXÅXÅ",
+      "هٔهٔهٔهٔمرحبا"};
+  const Size kCanvasSize(300, 50);
+  const int kTestSize = 10;
+
+  SkBitmap bitmap;
+  bitmap.allocPixels(
+      SkImageInfo::MakeN32Premul(kCanvasSize.width(), kCanvasSize.height()));
+  cc::SkiaPaintCanvas paint_canvas(bitmap);
+  Canvas canvas(&paint_canvas, 1.0f);
+  RenderText* render_text = GetRenderText();
+  render_text->SetHorizontalAlignment(ALIGN_LEFT);
+  render_text->SetColor(SK_ColorBLACK);
+
+  for (auto* string : kTestStrings) {
+    paint_canvas.clear(SK_ColorWHITE);
+    render_text->SetText(base::UTF8ToUTF16(string));
+    render_text->ApplyBaselineStyle(SUPERSCRIPT, Range(1, 2));
+    render_text->ApplyBaselineStyle(SUPERIOR, Range(3, 4));
+    render_text->ApplyBaselineStyle(INFERIOR, Range(5, 6));
+    render_text->ApplyBaselineStyle(SUBSCRIPT, Range(7, 8));
+    const Size string_size = render_text->GetStringSize();
+    render_text->SetWeight(Font::Weight::BOLD);
+    render_text->SetDisplayRect(
+        Rect(kTestSize, kTestSize, string_size.width(), string_size.height()));
+    // Allow the RenderText to paint outside of its display rect.
+    render_text->set_clip_to_display_rect(false);
+    ASSERT_LE(string_size.width() + kTestSize * 2, kCanvasSize.width());
+
+    render_text->Draw(&canvas);
+    ASSERT_LT(string_size.width() + kTestSize, kCanvasSize.width());
+    const uint32_t* buffer = static_cast<const uint32_t*>(bitmap.getPixels());
+    ASSERT_NE(nullptr, buffer);
+    TestRectangleBuffer rect_buffer(string, buffer, kCanvasSize.width(),
+                                    kCanvasSize.height());
+    {
+      SCOPED_TRACE("TextDoesntClip Top Side");
+      rect_buffer.EnsureSolidRect(SK_ColorWHITE, 0, 0, kCanvasSize.width(),
+                                  kTestSize);
+    }
+    {
+      SCOPED_TRACE("TextDoesntClip Bottom Side");
+      rect_buffer.EnsureSolidRect(SK_ColorWHITE, 0,
+                                  kTestSize + string_size.height(),
+                                  kCanvasSize.width(), kTestSize);
+    }
+    {
+      SCOPED_TRACE("TextDoesntClip Left Side");
+      // TODO(dschuyler): Smoothing draws to the left of text. This appears to
+      // be a preexisting issue that wasn't revealed by the prior unit tests.
+      // RenderText currently only uses origins and advances and ignores
+      // bounding boxes so cannot account for under- and over-hang.
+      rect_buffer.EnsureSolidRect(SK_ColorWHITE, 0, kTestSize, kTestSize - 1,
+                                  string_size.height());
+    }
+    {
+      SCOPED_TRACE("TextDoesntClip Right Side");
+      // TODO(dschuyler): Smoothing draws to the right of text. This appears to
+      // be a preexisting issue that wasn't revealed by the prior unit tests.
+      // RenderText currently only uses origins and advances and ignores
+      // bounding boxes so cannot account for under- and over-hang.
+      rect_buffer.EnsureSolidRect(SK_ColorWHITE,
+                                  kTestSize + string_size.width() + 1,
+                                  kTestSize, kTestSize - 1,
+                                  string_size.height());
+    }
+  }
+}
+
+// Ensure that the text will clip to the display rect. Draws to a canvas and
+// checks whether any pixel beyond the bounding rectangle is colored.
+TEST_F(RenderTextTest, DISABLED_TextDoesClip) {
+  const char* kTestStrings[] = {"TEST", "W", "WWWW", "gAXAXWWWW"};
+  const Size kCanvasSize(300, 50);
+  const int kTestSize = 10;
+
+  SkBitmap bitmap;
+  bitmap.allocPixels(
+      SkImageInfo::MakeN32Premul(kCanvasSize.width(), kCanvasSize.height()));
+  cc::SkiaPaintCanvas paint_canvas(bitmap);
+  Canvas canvas(&paint_canvas, 1.0f);
+  RenderText* render_text = GetRenderText();
+  render_text->SetHorizontalAlignment(ALIGN_LEFT);
+  render_text->SetColor(SK_ColorBLACK);
+
+  for (auto* string : kTestStrings) {
+    paint_canvas.clear(SK_ColorWHITE);
+    render_text->SetText(base::UTF8ToUTF16(string));
+    const Size string_size = render_text->GetStringSize();
+    int fake_width = string_size.width() / 2;
+    int fake_height = string_size.height() / 2;
+    render_text->SetDisplayRect(
+        Rect(kTestSize, kTestSize, fake_width, fake_height));
+    render_text->set_clip_to_display_rect(true);
+    render_text->Draw(&canvas);
+    ASSERT_LT(string_size.width() + kTestSize, kCanvasSize.width());
+    const uint32_t* buffer = static_cast<const uint32_t*>(bitmap.getPixels());
+    ASSERT_NE(nullptr, buffer);
+    TestRectangleBuffer rect_buffer(string, buffer, kCanvasSize.width(),
+                                    kCanvasSize.height());
+    {
+      SCOPED_TRACE("TextDoesClip Top Side");
+      rect_buffer.EnsureSolidRect(SK_ColorWHITE, 0, 0, kCanvasSize.width(),
+                                  kTestSize);
+    }
+
+    {
+      SCOPED_TRACE("TextDoesClip Bottom Side");
+      rect_buffer.EnsureSolidRect(SK_ColorWHITE, 0, kTestSize + fake_height,
+                                  kCanvasSize.width(), kTestSize);
+    }
+    {
+      SCOPED_TRACE("TextDoesClip Left Side");
+      rect_buffer.EnsureSolidRect(SK_ColorWHITE, 0, kTestSize, kTestSize,
+                                  fake_height);
+    }
+    {
+      SCOPED_TRACE("TextDoesClip Right Side");
+      rect_buffer.EnsureSolidRect(SK_ColorWHITE, kTestSize + fake_width,
+                                  kTestSize, kTestSize, fake_height);
+    }
+  }
+}
+
+// Ensure color changes are picked up by the RenderText implementation.
+TEST_F(RenderTextTest, ColorChange) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"x");
+  Draw();
+  ExpectTextLog({{1, kPlaceholderColor}});
+
+  render_text->SetColor(SK_ColorGREEN);
+  Draw();
+  ExpectTextLog({{1, SK_ColorGREEN}});
+}
+
+// Ensure style information propagates to the typeface on the text renderer.
+TEST_F(RenderTextTest, StylePropagated) {
+  RenderText* render_text = GetRenderText();
+  // Default-constructed fonts on Mac are system fonts. These can have all kinds
+  // of weird weights and style, which are preserved by PlatformFontMac, but do
+  // not map simply to a SkTypeface::Style (the full details in SkFontStyle is
+  // needed). They also vary depending on the OS version, so set a known font.
+  FontList font_list(Font("Arial", 10));
+
+  render_text->SetText(u"x");
+  render_text->SetFontList(font_list);
+
+  DrawVisualText();
+  EXPECT_EQ(SkFontStyle::Normal(),
+            GetRendererFont().getTypeface()->fontStyle());
+
+  render_text->SetWeight(Font::Weight::BOLD);
+  DrawVisualText();
+  EXPECT_EQ(SkFontStyle::Bold(), GetRendererFont().getTypeface()->fontStyle());
+
+  render_text->SetStyle(TEXT_STYLE_ITALIC, true);
+  DrawVisualText();
+  EXPECT_EQ(SkFontStyle::BoldItalic(),
+            GetRendererFont().getTypeface()->fontStyle());
+
+  render_text->SetWeight(Font::Weight::NORMAL);
+  DrawVisualText();
+  EXPECT_EQ(SkFontStyle::Italic(),
+            GetRendererFont().getTypeface()->fontStyle());
+}
+
+// Ensure the painter adheres to RenderText::subpixel_rendering_suppressed().
+TEST_F(RenderTextTest, SubpixelRenderingSuppressed) {
+  ASSERT_TRUE(IsFontsSmoothingEnabled())
+      << "The test requires that fonts smoothing (anti-aliasing) is activated. "
+         "If this assert is failing you need to manually activate the flag in "
+         "your system fonts settings.";
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"x");
+
+  DrawVisualText();
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_ANDROID) || \
+    defined(OS_FUCHSIA)
+  // On Linux, whether subpixel AA is supported is determined by the platform
+  // FontConfig. Force it into a particular style after computing runs. Other
+  // platforms use a known default FontRenderParams from a static local.
+  GetHarfBuzzRunList()
+      ->runs()[0]
+      ->font_params.render_params.subpixel_rendering =
+      FontRenderParams::SUBPIXEL_RENDERING_RGB;
+  DrawVisualText();
+#endif
+  EXPECT_EQ(GetRendererFont().getEdging(), SkFont::Edging::kSubpixelAntiAlias);
+
+  render_text->set_subpixel_rendering_suppressed(true);
+  DrawVisualText();
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_ANDROID) || \
+    defined(OS_FUCHSIA)
+  // For Linux, runs shouldn't be re-calculated, and the suppression of the
+  // SUBPIXEL_RENDERING_RGB set above should now take effect. But, after
+  // checking, apply the override anyway to be explicit that it is suppressed.
+  EXPECT_NE(GetRendererFont().getEdging(), SkFont::Edging::kSubpixelAntiAlias);
+  GetHarfBuzzRunList()
+      ->runs()[0]
+      ->font_params.render_params.subpixel_rendering =
+      FontRenderParams::SUBPIXEL_RENDERING_RGB;
+  DrawVisualText();
+#endif
+  EXPECT_NE(GetRendererFont().getEdging(), SkFont::Edging::kSubpixelAntiAlias);
+}
+
+// Ensure the SkFont Edging is computed accurately.
+TEST_F(RenderTextTest, SkFontEdging) {
+  const auto edging = [this]() { return GetRendererFont().getEdging(); };
+
+  FontRenderParams params;
+  EXPECT_TRUE(params.antialiasing);
+  EXPECT_EQ(params.subpixel_rendering,
+            FontRenderParams::SUBPIXEL_RENDERING_NONE);
+
+  // aa: true, subpixel: false, subpixel_suppressed: false -> kAntiAlias
+  renderer()->SetFontRenderParams(params,
+                                  false /*subpixel_rendering_suppressed*/);
+  EXPECT_EQ(edging(), SkFont::Edging::kAntiAlias);
+
+  // aa: false, subpixel: false, subpixel_suppressed: false -> kAlias
+  params.antialiasing = false;
+  renderer()->SetFontRenderParams(params,
+                                  false /*subpixel_rendering_suppressed*/);
+  EXPECT_EQ(edging(), SkFont::Edging::kAlias);
+
+  // aa: true, subpixel: true, subpixel_suppressed: false -> kSubpixelAntiAlias
+  params.antialiasing = true;
+  params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_RGB;
+  renderer()->SetFontRenderParams(params,
+                                  false /*subpixel_rendering_suppressed*/);
+  EXPECT_EQ(edging(), SkFont::Edging::kSubpixelAntiAlias);
+
+  // aa: true, subpixel: true, subpixel_suppressed: true -> kAntiAlias
+  renderer()->SetFontRenderParams(params,
+                                  true /*subpixel_rendering_suppressed*/);
+  EXPECT_EQ(edging(), SkFont::Edging::kAntiAlias);
+
+  // aa: false, subpixel: true, subpixel_suppressed: false -> kAlias
+  params.antialiasing = false;
+  renderer()->SetFontRenderParams(params,
+                                  false /*subpixel_rendering_suppressed*/);
+  EXPECT_EQ(edging(), SkFont::Edging::kAlias);
+}
+
+// Verify GetWordLookupDataAtPoint returns the correct baseline point and
+// decorated word for an LTR string.
+TEST_F(RenderTextTest, GetWordLookupDataAtPoint_LTR) {
+  // Set an integer glyph width; GetCursorBounds() and
+  // GetWordLookupDataAtPoint() use different rounding internally.
+  //
+  // TODO(crbug.com/1111044): this shouldn't be necessary once RenderText keeps
+  // float precision through GetCursorBounds().
+  SetGlyphWidth(5);
+  const std::u16string ltr = u"  ab  c ";
+  const int kWordOneStartIndex = 2;
+  const int kWordTwoStartIndex = 6;
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(100, 30));
+  render_text->SetText(ltr);
+  render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(0, 3));
+  render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, Range(1, 5));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(3, 8));
+  render_text->ApplyStyle(TEXT_STYLE_STRIKE, true, Range(1, 7));
+  const int cursor_y = GetCursorYForTesting();
+
+  const std::vector<FontSpan> font_spans = GetFontSpans();
+
+  // Create expected decorated text instances.
+  DecoratedText expected_word_1;
+  expected_word_1.text = u"ab";
+  // Attributes for the characters 'a' and 'b' at logical indices 2 and 3
+  // respectively.
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordOneStartIndex, Font::Weight::SEMIBOLD,
+      UNDERLINE_MASK | STRIKE_MASK));
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 1, kWordOneStartIndex + 1, Font::Weight::NORMAL,
+      UNDERLINE_MASK | ITALIC_MASK | STRIKE_MASK));
+  const Rect left_glyph_word_1 = render_text->GetCursorBounds(
+      SelectionModel(kWordOneStartIndex, CURSOR_FORWARD), false);
+
+  DecoratedText expected_word_2;
+  expected_word_2.text = u"c";
+  // Attributes for character 'c' at logical index |kWordTwoStartIndex|.
+  expected_word_2.attributes.push_back(
+      CreateRangedAttribute(font_spans, 0, kWordTwoStartIndex,
+                            Font::Weight::NORMAL, ITALIC_MASK | STRIKE_MASK));
+  const Rect left_glyph_word_2 = render_text->GetCursorBounds(
+      SelectionModel(kWordTwoStartIndex, CURSOR_FORWARD), false);
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the left of text bounds"));
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(
+        Point(-5, cursor_y), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+    EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+  }
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the right of text bounds"));
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(
+        Point(105, cursor_y), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+    EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+  }
+
+  for (size_t i = 0; i < render_text->text().length(); i++) {
+    SCOPED_TRACE(base::StringPrintf("Case[%" PRIuS "]", i));
+    // Query the decorated word using the origin of the i'th glyph's bounds.
+    const Point query =
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), false)
+            .origin();
+
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(query, &decorated_word,
+                                                      &baseline_point));
+
+    if (i < kWordTwoStartIndex) {
+      VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+      EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+    } else {
+      VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+      EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+    }
+  }
+}
+
+// Verify GetWordLookupDataAtPoint returns the correct baseline point and
+// decorated word for an RTL string.
+TEST_F(RenderTextTest, GetWordLookupDataAtPoint_RTL) {
+  // Set an integer glyph width; GetCursorBounds() and
+  // GetWordLookupDataAtPoint() use different rounding internally.
+  //
+  // TODO(crbug.com/1111044): this shouldn't be necessary once RenderText keeps
+  // float precision through GetCursorBounds().
+  SetGlyphWidth(5);
+  const std::u16string rtl = u" \u0634\u0632  \u0634";
+  const int kWordOneStartIndex = 1;
+  const int kWordTwoStartIndex = 5;
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(100, 30));
+  render_text->SetText(rtl);
+  render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(2, 3));
+  render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, Range(3, 6));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(0, 3));
+  render_text->ApplyStyle(TEXT_STYLE_STRIKE, true, Range(2, 5));
+  const int cursor_y = GetCursorYForTesting();
+
+  const std::vector<FontSpan> font_spans = GetFontSpans();
+
+  // Create expected decorated text instance.
+  DecoratedText expected_word_1;
+  expected_word_1.text = u"\u0634\u0632";
+  // Attributes for characters at logical indices 1 and 2.
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordOneStartIndex, Font::Weight::NORMAL, ITALIC_MASK));
+  expected_word_1.attributes.push_back(
+      CreateRangedAttribute(font_spans, 1, kWordOneStartIndex + 1,
+                            Font::Weight::SEMIBOLD, ITALIC_MASK | STRIKE_MASK));
+  // The leftmost glyph is the one at logical index 2.
+  const Rect left_glyph_word_1 = render_text->GetCursorBounds(
+      SelectionModel(kWordOneStartIndex + 1, CURSOR_FORWARD), false);
+
+  DecoratedText expected_word_2;
+  expected_word_2.text = u"\u0634";
+  // Attributes for character at logical index |kWordTwoStartIndex|.
+  expected_word_2.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordTwoStartIndex, Font::Weight::NORMAL, UNDERLINE_MASK));
+  const Rect left_glyph_word_2 = render_text->GetCursorBounds(
+      SelectionModel(kWordTwoStartIndex, CURSOR_FORWARD), false);
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the left of text bounds"));
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(
+        Point(-5, cursor_y), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+    EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+  }
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the right of text bounds"));
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(
+        Point(105, cursor_y), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+    EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+  }
+
+  for (size_t i = 0; i < render_text->text().length(); i++) {
+    SCOPED_TRACE(base::StringPrintf("Case[%" PRIuS "]", i));
+
+    // Query the decorated word using the top right point of the i'th glyph's
+    // bounds.
+    const Point query =
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), false)
+            .top_right();
+
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(query, &decorated_word,
+                                                      &baseline_point));
+    if (i < kWordTwoStartIndex) {
+      VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+      EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+    } else {
+      VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+      EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+    }
+  }
+}
+
+// Test that GetWordLookupDataAtPoint behaves correctly for multiline text.
+TEST_F(RenderTextTest, GetWordLookupDataAtPoint_Multiline) {
+  const std::u16string text = u"a b\n..\ncd.";
+  const size_t kWordOneIndex = 0;    // Index of character 'a'.
+  const size_t kWordTwoIndex = 2;    // Index of character 'b'.
+  const size_t kWordThreeIndex = 7;  // Index of character 'c'.
+
+  // Set up render text.
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(500, 500));
+  render_text->SetText(text);
+  render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(0, 3));
+  render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, Range(1, 7));
+  render_text->ApplyStyle(TEXT_STYLE_STRIKE, true, Range(1, 8));
+  render_text->ApplyStyle(TEXT_STYLE_ITALIC, true, Range(5, 9));
+
+  // Set up test expectations.
+  const std::vector<FontSpan> font_spans = GetFontSpans();
+
+  DecoratedText expected_word_1;
+  expected_word_1.text = u"a";
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordOneIndex, Font::Weight::SEMIBOLD, 0));
+  const Rect left_glyph_word_1 =
+      GetSubstringBoundsUnion(Range(kWordOneIndex, kWordOneIndex + 1));
+
+  DecoratedText expected_word_2;
+  expected_word_2.text = u"b";
+  expected_word_2.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordTwoIndex, Font::Weight::SEMIBOLD,
+      UNDERLINE_MASK | STRIKE_MASK));
+  const Rect left_glyph_word_2 =
+      GetSubstringBoundsUnion(Range(kWordTwoIndex, kWordTwoIndex + 1));
+
+  DecoratedText expected_word_3;
+  expected_word_3.text = u"cd";
+  expected_word_3.attributes.push_back(
+      CreateRangedAttribute(font_spans, 0, kWordThreeIndex,
+                            Font::Weight::NORMAL, STRIKE_MASK | ITALIC_MASK));
+  expected_word_3.attributes.push_back(CreateRangedAttribute(
+      font_spans, 1, kWordThreeIndex + 1, Font::Weight::NORMAL, ITALIC_MASK));
+
+  const Rect left_glyph_word_3 =
+      GetSubstringBoundsUnion(Range(kWordThreeIndex, kWordThreeIndex + 1));
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+  {
+    // Query to the left of the first line.
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(
+        Point(-5, GetCursorYForTesting(0)), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+    EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+  }
+  {
+    // Query on the second line.
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(
+        Point(5, GetCursorYForTesting(1)), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+    EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+  }
+  {
+    // Query at the center point of the character 'c'.
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(
+        left_glyph_word_3.CenterPoint(), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_3, decorated_word);
+    EXPECT_TRUE(left_glyph_word_3.Contains(baseline_point));
+  }
+  {
+    // Query to the right of the third line.
+    EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(
+        Point(505, GetCursorYForTesting(2)), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_3, decorated_word);
+    EXPECT_TRUE(left_glyph_word_3.Contains(baseline_point));
+  }
+}
+
+// Verify the boolean return value of GetWordLookupDataAtPoint.
+TEST_F(RenderTextTest, GetWordLookupDataAtPoint_Return) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"...");
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+
+  // False should be returned, when the text does not contain any word.
+  Point query =
+      render_text->GetCursorBounds(SelectionModel(0, CURSOR_FORWARD), false)
+          .origin();
+  EXPECT_FALSE(render_text->GetWordLookupDataAtPoint(query, &decorated_word,
+                                                     &baseline_point));
+
+  render_text->SetText(u"abc");
+  query = render_text->GetCursorBounds(SelectionModel(0, CURSOR_FORWARD), false)
+              .origin();
+  EXPECT_TRUE(render_text->GetWordLookupDataAtPoint(query, &decorated_word,
+                                                    &baseline_point));
+
+  // False should be returned for obscured text.
+  render_text->SetObscured(true);
+  query = render_text->GetCursorBounds(SelectionModel(0, CURSOR_FORWARD), false)
+              .origin();
+  EXPECT_FALSE(render_text->GetWordLookupDataAtPoint(query, &decorated_word,
+                                                     &baseline_point));
+}
+
+// Test that GetLookupDataAtPoint behaves correctly when the range spans lines.
+TEST_F(RenderTextTest, GetLookupDataAtRange_Multiline) {
+  const std::u16string text = u"a\nb";
+  constexpr Range kWordOneRange = Range(0, 1);  // Range of character 'a'.
+  constexpr Range kWordTwoRange = Range(2, 3);  // Range of character 'b'.
+  constexpr Range kTextRange = Range(0, 3);     // Range of the entire text.
+
+  // Set up render text. Apply style ranges so that each character index gets
+  // a corresponding font.
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(500, 500));
+  render_text->SetText(text);
+  render_text->ApplyWeight(Font::Weight::SEMIBOLD, kWordOneRange);
+  render_text->ApplyStyle(TEXT_STYLE_UNDERLINE, true, kWordTwoRange);
+
+  // Set up test expectations.
+  const std::vector<FontSpan> font_spans = GetFontSpans();
+
+  DecoratedText expected_word_1;
+  expected_word_1.text = u"a";
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordOneRange.start(), Font::Weight::SEMIBOLD, 0));
+  const Rect left_glyph_word_1 = GetSubstringBoundsUnion(kWordOneRange);
+
+  DecoratedText expected_word_2;
+  expected_word_2.text = u"b";
+  expected_word_2.attributes.push_back(
+      CreateRangedAttribute(font_spans, 0, kWordTwoRange.start(),
+                            Font::Weight::NORMAL, UNDERLINE_MASK));
+  const Rect left_glyph_word_2 = GetSubstringBoundsUnion(kWordTwoRange);
+
+  DecoratedText expected_entire_text;
+  expected_entire_text.text = u"a\nb";
+  expected_entire_text.attributes.push_back(
+      CreateRangedAttribute(font_spans, kWordOneRange.start(),
+                            kWordOneRange.start(), Font::Weight::SEMIBOLD, 0));
+  expected_entire_text.attributes.push_back(
+      CreateRangedAttribute(font_spans, 1, 1, Font::Weight::NORMAL, 0));
+  expected_entire_text.attributes.push_back(CreateRangedAttribute(
+      font_spans, kWordTwoRange.start(), kWordTwoRange.start(),
+      Font::Weight::NORMAL, UNDERLINE_MASK));
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+  {
+    // Query for the range of the first word.
+    EXPECT_TRUE(render_text->GetLookupDataForRange(
+        kWordOneRange, &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+    EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+  }
+  {
+    // Query for the range of the second word.
+    EXPECT_TRUE(render_text->GetLookupDataForRange(
+        kWordTwoRange, &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+    EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+  }
+  {
+    // Query the entire text range.
+    EXPECT_TRUE(render_text->GetLookupDataForRange(kTextRange, &decorated_word,
+                                                   &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_entire_text, decorated_word);
+    EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+  }
+}
+
+// Tests text selection made at end points of individual lines of multiline
+// text.
+TEST_F(RenderTextTest, LineEndSelections) {
+  const char16_t* const ltr = u"abc\n\ndef";
+  const char16_t* const rtl = u"שנב\n\nגקכ";
+  const char16_t* const ltr_single = u"abc def ghi";
+  const char16_t* const rtl_single = u"שנב גקכ עין";
+  const int left_x = -100;
+  const int right_x = 200;
+  struct {
+    const char16_t* const text;
+    const int line_num;
+    const int x;
+    const char16_t* const selected_text;
+  } cases[] = {
+      {ltr, 1, left_x, u"abc\n"},
+      {ltr, 1, right_x, u"abc\n"},
+      {ltr, 2, left_x, u"abc\n\n"},
+      {ltr, 2, right_x, ltr},
+
+      {rtl, 1, left_x, u"שנב\n"},
+      {rtl, 1, right_x, u"שנב\n"},
+      {rtl, 2, left_x, rtl},
+      {rtl, 2, right_x, u"שנב\n\n"},
+
+      {ltr_single, 1, left_x, u"abc "},
+      {ltr_single, 1, right_x, u"abc def "},
+      {ltr_single, 2, left_x, u"abc def "},
+      {ltr_single, 2, right_x, ltr_single},
+
+      {rtl_single, 1, left_x, u"שנב גקכ "},
+      {rtl_single, 1, right_x, u"שנב "},
+      {rtl_single, 2, left_x, rtl_single},
+      {rtl_single, 2, right_x, u"שנב גקכ "},
+  };
+
+  SetGlyphWidth(5);
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(20, 1000));
+
+  for (size_t i = 0; i < base::size(cases); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing case %" PRIuS "", i));
+    render_text->SetText(cases[i].text);
+
+    EXPECT_EQ(3u, render_text->GetNumLines());
+    // Position the cursor at the logical beginning of text.
+    render_text->SelectRange(Range(0));
+
+    render_text->MoveCursorToPoint(
+        Point(cases[i].x, GetCursorYForTesting(cases[i].line_num)), true);
+    EXPECT_EQ(cases[i].selected_text, GetSelectedText(render_text));
+  }
+}
+
+TEST_F(RenderTextTest, GetSubstringBounds) {
+  const float kGlyphWidth = 5;
+  SetGlyphWidth(kGlyphWidth);
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"abc");
+  render_text->SetCursorEnabled(false);
+  render_text->SetElideBehavior(NO_ELIDE);
+
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(0, 1)).width(), kGlyphWidth);
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(1, 2)).width(), kGlyphWidth);
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(1, 3)).width(), 2 * kGlyphWidth);
+
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(0, 0)).width(), 0);
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(3, 3)).width(), 0);
+
+  // Apply eliding so display text has 2 visible character.
+  render_text->SetDisplayRect(Rect(0, 0, 2 * kGlyphWidth, 100));
+  render_text->SetElideBehavior(TRUNCATE);
+
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(0, 1)).width(), kGlyphWidth);
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(1, 2)).width(), kGlyphWidth);
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(1, 3)).width(), kGlyphWidth);
+  // Check a fully elided range.
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(2, 3)).width(), 0);
+
+  // Empty ranges result in empty rect.
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(0, 0)).width(), 0);
+  EXPECT_EQ(GetSubstringBoundsUnion(Range(3, 3)).width(), 0);
+}
+
+// Tests that GetSubstringBounds rounds outward when glyphs have floating-point
+// widths.
+TEST_F(RenderTextTest, GetSubstringBoundsFloatingPoint) {
+  const float kGlyphWidth = 5.8;
+  SetGlyphWidth(kGlyphWidth);
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(200, 1000));
+  render_text->SetText(u"abcdef");
+  gfx::Rect bounds = GetSubstringBoundsUnion(Range(1, 2));
+  // The bounds should be rounded outwards so that the full substring is always
+  // contained in them.
+  EXPECT_EQ(base::ClampFloor(kGlyphWidth), bounds.x());
+  EXPECT_EQ(base::ClampCeil(2 * kGlyphWidth), bounds.right());
+}
+
+// Tests that GetSubstringBounds handles integer glypth widths correctly.
+TEST_F(RenderTextTest, GetSubstringBoundsInt) {
+  const float kGlyphWidth = 5;
+  SetGlyphWidth(kGlyphWidth);
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(200, 1000));
+  render_text->SetText(u"abcdef");
+  gfx::Rect bounds = GetSubstringBoundsUnion(Range(1, 2));
+  EXPECT_EQ(kGlyphWidth, bounds.x());
+  EXPECT_EQ(2 * kGlyphWidth, bounds.right());
+}
+
+// Tests that GetSubstringBounds returns the correct bounds for multiline text.
+TEST_F(RenderTextTest, GetSubstringBoundsMultiline) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(200, 1000));
+  render_text->SetText(u"abc\n\ndef");
+
+  const std::vector<Range> line_char_range = {Range(0, 4), Range(4, 5),
+                                              Range(5, 8)};
+
+  // Test bounds for individual lines.
+  EXPECT_EQ(3u, render_text->GetNumLines());
+  Rect expected_total_bounds;
+  for (size_t i = 0; i < test_api()->lines().size(); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing bounds for line %" PRIuS "", i));
+    const internal::Line& line = test_api()->lines()[i];
+    const Size line_size(std::ceil(line.size.width()),
+                         std::ceil(line.size.height()));
+    const Rect expected_line_bounds =
+        render_text->GetLineOffset(i) + Rect(line_size);
+    expected_total_bounds.Union(expected_line_bounds);
+
+    render_text->SelectRange(line_char_range[i]);
+    EXPECT_EQ(expected_line_bounds, GetSelectionBoundsUnion());
+  }
+
+  // Test complete bounds.
+  render_text->SelectAll(false);
+  EXPECT_EQ(expected_total_bounds, GetSelectionBoundsUnion());
+}
+
+// Tests that RenderText doesn't crash even if it's passed an invalid font. Test
+// for crbug.com/668058.
+TEST_F(RenderTextTest, InvalidFont) {
+  const std::string font_name = "invalid_font";
+  const int kFontSize = 13;
+  RenderText* render_text = GetRenderText();
+  render_text->SetFontList(FontList(Font(font_name, kFontSize)));
+  render_text->SetText(u"abc");
+
+  DrawVisualText();
+}
+
+TEST_F(RenderTextTest, ExpandToBeVerticallySymmetric) {
+  Rect test_display_rect(0, 0, 400, 100);
+
+  // Basic case.
+  EXPECT_EQ(Rect(20, 20, 400, 60),
+            test::RenderTextTestApi::ExpandToBeVerticallySymmetric(
+                Rect(20, 20, 400, 40), test_display_rect));
+
+  // Expand upwards.
+  EXPECT_EQ(Rect(20, 20, 400, 60),
+            test::RenderTextTestApi::ExpandToBeVerticallySymmetric(
+                Rect(20, 40, 400, 40), test_display_rect));
+
+  // Original rect is entirely above the center point.
+  EXPECT_EQ(Rect(10, 30, 200, 40),
+            test::RenderTextTestApi::ExpandToBeVerticallySymmetric(
+                Rect(10, 30, 200, 10), test_display_rect));
+
+  // Original rect is below the display rect entirely.
+  EXPECT_EQ(Rect(10, -10, 200, 120),
+            test::RenderTextTestApi::ExpandToBeVerticallySymmetric(
+                Rect(10, 100, 200, 10), test_display_rect));
+
+  // Sanity check that we can handle a display rect with a non-zero origin.
+  test_display_rect.Offset(10, 10);
+  EXPECT_EQ(Rect(20, 20, 400, 80),
+            test::RenderTextTestApi::ExpandToBeVerticallySymmetric(
+                Rect(20, 20, 400, 40), test_display_rect));
+}
+
+TEST_F(RenderTextTest, MergeIntersectingRects) {
+  // Basic case.
+  std::vector<Rect> test_rects{Rect(0, 0, 10, 10), Rect(5, 0, 10, 10),
+                               Rect(10, 0, 5, 10), Rect(12, 0, 5, 10)};
+  test::RenderTextTestApi::MergeIntersectingRects(test_rects);
+  ASSERT_EQ(1u, test_rects.size());
+  EXPECT_EQ(Rect(0, 0, 17, 10), test_rects[0]);
+
+  // Case where some rects intersect and some don't.
+  test_rects = std::vector<Rect>{Rect(0, 0, 10, 10), Rect(5, 0, 10, 10),
+                                 Rect(16, 0, 10, 10), Rect(25, 0, 10, 10),
+                                 Rect(40, 0, 10, 10)};
+  test::RenderTextTestApi::MergeIntersectingRects(test_rects);
+  ASSERT_EQ(3u, test_rects.size());
+  EXPECT_EQ(Rect(0, 0, 15, 10), test_rects[0]);
+  EXPECT_EQ(Rect(16, 0, 19, 10), test_rects[1]);
+  EXPECT_EQ(Rect(40, 0, 10, 10), test_rects[2]);
+
+  // Case where no rects intersect.
+  test_rects = std::vector<Rect>{Rect(0, 0, 10, 10), Rect(11, 0, 10, 10),
+                                 Rect(22, 0, 10, 10), Rect(33, 0, 10, 10)};
+  test::RenderTextTestApi::MergeIntersectingRects(test_rects);
+  ASSERT_EQ(4u, test_rects.size());
+  EXPECT_EQ(Rect(0, 0, 10, 10), test_rects[0]);
+  EXPECT_EQ(Rect(11, 0, 10, 10), test_rects[1]);
+  EXPECT_EQ(Rect(22, 0, 10, 10), test_rects[2]);
+  EXPECT_EQ(Rect(33, 0, 10, 10), test_rects[3]);
+
+  // Rects are out-of-order.
+  test_rects = std::vector<Rect>{Rect(10, 0, 5, 10), Rect(0, 0, 10, 10),
+                                 Rect(12, 0, 5, 10), Rect(5, 0, 10, 10)};
+  test::RenderTextTestApi::MergeIntersectingRects(test_rects);
+  ASSERT_EQ(1u, test_rects.size());
+  EXPECT_EQ(Rect(0, 0, 17, 10), test_rects[0]);
+
+  // The first 3 rects are adjacent horizontally. The 4th rect is adjacent to
+  // the 3rd rect vertically, but is not merged. The last rect is adjacent to
+  // the 4th rect.
+  test_rects = std::vector<Rect>{Rect(0, 0, 10, 10), Rect(10, 0, 10, 10),
+                                 Rect(20, 0, 10, 10), Rect(20, 10, 10, 10),
+                                 Rect(30, 10, 10, 10)};
+  test::RenderTextTestApi::MergeIntersectingRects(test_rects);
+  ASSERT_EQ(2u, test_rects.size());
+  EXPECT_EQ(Rect(0, 0, 30, 10), test_rects[0]);
+  EXPECT_EQ(Rect(20, 10, 20, 10), test_rects[1]);
+}
+
+// Ensures that text is centered vertically and consistently when either the
+// display rectangle height changes, or when the minimum line height changes.
+// The difference between the two is the selection rectangle, which should match
+// the line height.
+TEST_F(RenderTextTest, BaselineWithLineHeight) {
+  RenderText* render_text = GetRenderText();
+  const int font_height = render_text->font_list().GetHeight();
+  render_text->SetDisplayRect(Rect(500, font_height));
+  render_text->SetText(u"abc");
+
+  // Select everything so the test can use GetSelectionBoundsUnion().
+  render_text->SelectAll(false);
+
+  const int normal_baseline = test_api()->GetDisplayTextBaseline();
+  ASSERT_EQ(1u, test_api()->lines().size());
+  EXPECT_EQ(font_height, test_api()->lines()[0].size.height());
+
+  // With a matching display height, the baseline calculated using font metrics
+  // and the baseline from the layout engine should agree. This works because
+  // the text string is simple (exotic glyphs may use fonts with different
+  // metrics).
+  EXPECT_EQ(normal_baseline, render_text->GetBaseline());
+  EXPECT_EQ(0, render_text->GetLineOffset(0).y());
+
+  const gfx::Rect normal_selection_bounds = GetSelectionBoundsUnion();
+
+  // Sanity check: selection should start from (0,0).
+  EXPECT_EQ(gfx::Vector2d(), normal_selection_bounds.OffsetFromOrigin());
+
+  constexpr int kDelta = 16;
+
+  // Grow just the display rectangle.
+  render_text->SetDisplayRect(Rect(500, font_height + kDelta));
+
+  // The display text baseline does not move: GetLineOffset() moves it instead.
+  EXPECT_EQ(normal_baseline, test_api()->GetDisplayTextBaseline());
+
+  ASSERT_EQ(1u, test_api()->lines().size());
+  EXPECT_EQ(font_height, test_api()->lines()[0].size.height());
+
+  // Save the baseline calculated using the display rectangle before enabling
+  // multi-line or SetMinLineHeight().
+  const int reported_baseline = render_text->GetBaseline();
+  const int baseline_shift = reported_baseline - normal_baseline;
+
+  // When line height matches font height, this should match the line offset.
+  EXPECT_EQ(baseline_shift, render_text->GetLineOffset(0).y());
+
+  // The actual shift depends on font metrics, and the calculations done in
+  // RenderText::DetermineBaselineCenteringText(). Do a sanity check that the
+  // "centering" part is happening within some tolerance by ensuring the shift
+  // is within a pixel of (kDelta / 2). That is, 7, 8 or 9 pixels (for a delta
+  // of 16). An unusual font in future may need more leeway.
+  constexpr int kFuzz = 1;  // If the next EXPECT fails, try increasing this.
+  EXPECT_LE(abs(baseline_shift - kDelta / 2), kFuzz);
+
+  // Increasing display height (but not line height) should shift the selection
+  // bounds down by |baseline_shift|, but leave a matching size.
+  gfx::Rect current_selection_bounds = GetSelectionBoundsUnion();
+  EXPECT_EQ(baseline_shift, current_selection_bounds.y());
+  EXPECT_EQ(0, current_selection_bounds.x());
+  EXPECT_EQ(normal_selection_bounds.size(), current_selection_bounds.size());
+
+  // Now increase the line height, but remain single-line. Note the line height
+  // now matches the display rect.
+  render_text->SetMinLineHeight(font_height + kDelta);
+  int display_text_baseline = test_api()->GetDisplayTextBaseline();
+  ASSERT_EQ(1u, test_api()->lines().size());
+  EXPECT_EQ(font_height + kDelta, test_api()->lines()[0].size.height());
+
+  // The line offset should go back to zero, but now the display text baseline
+  // should shift down to compensate, and the shift amount should match.
+  EXPECT_EQ(0, render_text->GetLineOffset(0).y());
+  EXPECT_EQ(normal_baseline + baseline_shift, display_text_baseline);
+
+  // Now selection bounds should grow in height, but not shift its origin.
+  current_selection_bounds = GetSelectionBoundsUnion();
+  EXPECT_EQ(font_height + kDelta, current_selection_bounds.height());
+  EXPECT_EQ(normal_selection_bounds.width(), current_selection_bounds.width());
+  EXPECT_EQ(gfx::Vector2d(), current_selection_bounds.OffsetFromOrigin());
+
+  // Flipping the multiline flag should change nothing.
+  render_text->SetMultiline(true);
+  display_text_baseline = test_api()->GetDisplayTextBaseline();
+  ASSERT_EQ(1u, test_api()->lines().size());
+  EXPECT_EQ(font_height + kDelta, test_api()->lines()[0].size.height());
+  EXPECT_EQ(0, render_text->GetLineOffset(0).y());
+  EXPECT_EQ(normal_baseline + baseline_shift, display_text_baseline);
+  current_selection_bounds = GetSelectionBoundsUnion();
+  EXPECT_EQ(font_height + kDelta, current_selection_bounds.height());
+  EXPECT_EQ(normal_selection_bounds.width(), current_selection_bounds.width());
+  EXPECT_EQ(gfx::Vector2d(), current_selection_bounds.OffsetFromOrigin());
+}
+
+TEST_F(RenderTextTest, TeluguGraphemeBoundaries) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(50, 1000));
+  // This is first syllable of the Telugu word for "New" in Chrome. It's a
+  // string of 4 UTF-8 characters: [క,్,ర,ొ]. When typeset with a supporting
+  // font, the second and fourth characters become diacritical marks for the
+  // first and third characters to form two graphemes. Then, these graphemes
+  // combine into a ligature "cluster". But, unlike ligatures in English (e.g.
+  // the "ffl" in "waffle"), this Telugu ligature is laid out vertically, with
+  // both graphemes occupying the same horizontal space.
+  render_text->SetText(u"క్రొ");
+
+  const int whole_width = render_text->GetStringSize().width();
+  // Sanity check. A typical width is 8 pixels. Anything less than 6 could screw
+  // up the checks below with rounding.
+  EXPECT_LE(6, whole_width);
+
+  // Go to the end and perform Shift+Left. The selection should jump to a
+  // grapheme boundary.
+  // Before ICU 65, this was in the center of the glyph, but now it encompasses
+  // the entire glyph.
+  render_text->SetCursorPosition(4);
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
+  EXPECT_EQ(Range(4, 0), render_text->selection());
+
+  // The cursor is already at the boundary, so there should be no change.
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_RETAIN);
+  EXPECT_EQ(Range(4, 0), render_text->selection());
+
+  // The selection should cover the entire width.
+  Rect selection_bounds = GetSelectionBoundsUnion();
+  EXPECT_EQ(0, selection_bounds.x());
+  EXPECT_EQ(whole_width, selection_bounds.width());
+}
+
+// Test cursor bounds for Emoji flags (unicode regional indicators) when the
+// flag does not merge into a single glyph.
+TEST_F(RenderTextTest, MissingFlagEmoji) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(1000, 1000));
+
+  // Usually these pair into country codes, but for this test we do not want
+  // them to combine into a flag. Instead, the placeholder glyphs should be used
+  // but cursor navigation should still behave as though they are joined. To get
+  // placeholder glyphs, make up a non-existent country. The codes used are
+  // based on ISO 3166-1 alpha-2. Codes starting with X are user-assigned.
+  std::u16string text(u"🇽🇽🇽🇽");
+  // Each flag is 4 UTF16 characters (2 surrogate pair code points).
+  EXPECT_EQ(8u, text.length());
+
+  render_text->SetText(text);
+
+  const int whole_width = render_text->GetStringSize().width();
+  const int half_width = whole_width / 2;
+  EXPECT_LE(6, whole_width);  // Sanity check.
+
+  EXPECT_EQ("[0->7]", GetRunListStructureString());
+
+  // Move from the left to the right.
+  const Rect start_cursor = render_text->GetUpdatedCursorBounds();
+  EXPECT_EQ(0, start_cursor.x());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(4, 4), render_text->selection());
+  const Rect middle_cursor = render_text->GetUpdatedCursorBounds();
+
+  // Should move about half way. Cursor bounds round to the nearest integer, so
+  // account for that.
+  EXPECT_LE(half_width - 1, middle_cursor.x());
+  EXPECT_GE(half_width + 1, middle_cursor.x());
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
+  EXPECT_EQ(Range(8, 8), render_text->selection());
+  const Rect end_cursor = render_text->GetUpdatedCursorBounds();
+  EXPECT_LE(whole_width - 1, end_cursor.x());  // Should move most of the way.
+  EXPECT_GE(whole_width + 1, end_cursor.x());
+
+  // Move right to left.
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(4, 4), render_text->selection());
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, SELECTION_NONE);
+  EXPECT_EQ(Range(0, 0), render_text->selection());
+
+  // Select from the left to the right. The first "flag" should be selected.
+  // Note cursor bounds and selection bounds differ on integer rounding - see
+  // http://crbug.com/735346.
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
+  EXPECT_EQ(Range(0, 4), render_text->selection());
+  Rect selection_bounds = GetSelectionBoundsUnion();
+  EXPECT_EQ(0, selection_bounds.x());
+  EXPECT_LE(half_width - 1, selection_bounds.width());  // Allow for rounding.
+  EXPECT_GE(half_width + 1, selection_bounds.width());
+
+  render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_RETAIN);
+  EXPECT_EQ(Range(0, 8), render_text->selection());
+  selection_bounds = GetSelectionBoundsUnion();
+  EXPECT_EQ(0, selection_bounds.x());
+  EXPECT_EQ(whole_width, selection_bounds.width());
+}
+
+// Ensures that glyph spacing is correctly applied to obscured text.
+TEST_F(RenderTextTest, ObscuredGlyphSpacing) {
+  const std::u16string seuss = u"hop on pop";
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetText(seuss);
+  render_text->SetObscured(true);
+
+  // The default glyph spacing is zero.
+  const int width_without_glyph_spacing = render_text->GetStringSize().width();
+  EXPECT_EQ(0, render_text->obscured_glyph_spacing());
+
+  constexpr int kObscuredGlyphSpacing = 5;
+  render_text->SetObscuredGlyphSpacing(kObscuredGlyphSpacing);
+  const int width_with_glyph_spacing = render_text->GetStringSize().width();
+  EXPECT_EQ(kObscuredGlyphSpacing, render_text->obscured_glyph_spacing());
+
+  EXPECT_EQ(width_without_glyph_spacing +
+                static_cast<int>(seuss.length()) * kObscuredGlyphSpacing,
+            width_with_glyph_spacing);
+}
+
+// Ensures that glyph spacing is ignored for non-obscured text.
+TEST_F(RenderTextTest, ObscuredGlyphSpacingOnNonObscuredText) {
+  const std::u16string seuss = u"hop on pop";
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  render_text->SetText(seuss);
+  render_text->SetObscured(false);
+  const int width_without_glyph_spacing = render_text->GetStringSize().width();
+
+  constexpr int kObscuredGlyphSpacing = 5;
+  render_text->SetObscuredGlyphSpacing(kObscuredGlyphSpacing);
+  const int width_with_glyph_spacing = render_text->GetStringSize().width();
+  EXPECT_EQ(width_without_glyph_spacing, width_with_glyph_spacing);
+}
+
+// Ensure font size overrides propagate through to text runs.
+TEST_F(RenderTextTest, FontSizeOverride) {
+  RenderTextHarfBuzz* render_text = GetRenderText();
+  const int default_font_size = render_text->font_list().GetFontSize();
+  const int test_font_size_override = default_font_size + 5;
+  render_text->SetText(u"0123456789");
+  render_text->ApplyFontSizeOverride(test_font_size_override, gfx::Range(3, 7));
+  EXPECT_EQ(std::vector<std::u16string>({u"012", u"3456", u"789"}),
+            GetRunListStrings());
+
+  const internal::TextRunList* run_list = GetHarfBuzzRunList();
+  ASSERT_EQ(3U, run_list->size());
+
+  EXPECT_EQ(default_font_size,
+            run_list->runs()[0].get()->font_params.font_size);
+  EXPECT_EQ(test_font_size_override,
+            run_list->runs()[1].get()->font_params.font_size);
+  EXPECT_EQ(default_font_size,
+            run_list->runs()[2].get()->font_params.font_size);
+}
+
+TEST_F(RenderTextTest, DrawVisualText_WithSelection) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"TheRedElephantIsEatingMyPumpkin");
+  // Ensure selected text is drawn differently than unselected text.
+  render_text->set_selection_color(SK_ColorGREEN);
+  DrawVisualText({{3, 14}});
+  ExpectTextLog(
+      {{3, kPlaceholderColor}, {11, SK_ColorGREEN}, {17, kPlaceholderColor}});
+}
+
+TEST_F(RenderTextTest, DrawVisualText_WithSelectionOnObcuredEmoji) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"\U0001F628\U0001F628\U0001F628");
+  render_text->SetObscured(true);
+  render_text->set_selection_color(SK_ColorGREEN);
+  DrawVisualText({{4, 6}});
+  ExpectTextLog({{2, kPlaceholderColor}, {1, SK_ColorGREEN}});
+}
+
+TEST_F(RenderTextTest, DrawSelectAll) {
+  const std::vector<GlyphCountAndColor> kUnselected = {
+      {4, SK_ColorBLACK}};
+  const std::vector<GlyphCountAndColor> kSelected = {{4, SK_ColorGREEN}};
+  const std::vector<GlyphCountAndColor> kFocused = {
+      {1, SK_ColorBLACK}, {2, SK_ColorGREEN}, {1, SK_ColorBLACK}};
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"Test");
+  render_text->SetColor(SK_ColorBLACK);
+  render_text->set_selection_color(SK_ColorGREEN);
+  render_text->SelectRange(Range(1, 3));
+
+  Draw(false);
+  ExpectTextLog(kUnselected);
+  Draw(true);
+  ExpectTextLog(kSelected);
+  Draw(false);
+  ExpectTextLog(kUnselected);
+
+  render_text->set_focused(true);
+  Draw(false);
+  ExpectTextLog(kFocused);
+  Draw(true);
+  ExpectTextLog(kSelected);
+
+  render_text->set_focused(false);
+  Draw(true);
+  ExpectTextLog(kSelected);
+  Draw(false);
+  ExpectTextLog(kUnselected);
+}
+
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+TEST_F(RenderTextTest, StringSizeUpdatedWhenDeviceScaleFactorChanges) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(u"Test - 1");
+  const gfx::SizeF initial_size = render_text->GetStringSizeF();
+
+  // Non-integer device scale factor enables subpixel positioning on Linux and
+  // Chrome OS, which should update text size.
+  SetFontRenderParamsDeviceScaleFactor(1.5);
+
+  const gfx::SizeF scaled_size = render_text->GetStringSizeF();
+
+  // Create render text with scale factor set from the beginning, and use is as
+  // a baseline to which compare the original render text string size.
+  ResetRenderTextInstance();
+  RenderText* scaled_render_text = GetRenderText();
+  scaled_render_text->SetText(u"Test - 1");
+
+  // Verify that original render text string size got updated after device scale
+  // factor changed.
+  EXPECT_NE(initial_size.width(), scaled_size.width());
+  EXPECT_EQ(scaled_render_text->GetStringSizeF(), scaled_size);
+}
+#endif
+
+TEST_F(RenderTextTest, Clusterfuzz_Issue_1287804) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetMaxLines(1);
+  render_text->SetText(u">\r\r");
+  render_text->SetMultiline(true);
+  render_text->SetDisplayRect(Rect(0, 0, 100, 24));
+  render_text->SetElideBehavior(ELIDE_TAIL);
+  EXPECT_EQ(RangeF(0, 0), render_text->GetCursorSpan(Range(0, 0)));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/rendering_pipeline.cc b/ui/gfx/rendering_pipeline.cc
new file mode 100644
index 0000000..174b10b
--- /dev/null
+++ b/ui/gfx/rendering_pipeline.cc
@@ -0,0 +1,298 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/rendering_pipeline.h"
+
+#include "base/containers/flat_map.h"
+#include "base/task/current_thread.h"
+#include "base/task/sequence_manager/task_time_observer.h"
+#include "base/thread_annotations.h"
+#include "base/threading/thread_checker.h"
+#include "ui/gfx/rendering_stage_scheduler.h"
+
+namespace gfx {
+namespace {
+
+class ThreadSafeTimeObserver : public base::sequence_manager::TaskTimeObserver {
+ public:
+  explicit ThreadSafeTimeObserver(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : task_runner_(std::move(task_runner)) {}
+  ~ThreadSafeTimeObserver() override {
+    // If the observer is being used on the target thread, unregister now. If it
+    // was being used on a different thread, then the target thread should have
+    // been torn down already.
+    SetEnabled(false);
+  }
+
+  ThreadSafeTimeObserver(const ThreadSafeTimeObserver&) = delete;
+  ThreadSafeTimeObserver& operator=(const ThreadSafeTimeObserver&) = delete;
+
+  void SetEnabled(bool enabled) {
+    {
+      base::AutoLock hold(time_lock_);
+      if (enabled_ == enabled)
+        return;
+      enabled_ = enabled;
+    }
+
+    if (!task_runner_)
+      return;
+
+    if (task_runner_->BelongsToCurrentThread()) {
+      UpdateOnTargetThread(enabled);
+      return;
+    }
+
+    task_runner_->PostTask(
+        FROM_HERE, base::BindOnce(&ThreadSafeTimeObserver::UpdateOnTargetThread,
+                                  base::Unretained(this), enabled));
+  }
+
+  base::TimeDelta GetAndResetTimeSinceLastFrame() {
+    base::AutoLock hold(time_lock_);
+
+    if (!start_time_active_task_.is_null()) {
+      auto now = base::TimeTicks::Now();
+      time_since_last_frame_ += now - start_time_active_task_;
+      start_time_active_task_ = now;
+    }
+
+    auto result = time_since_last_frame_;
+    time_since_last_frame_ = base::TimeDelta();
+    return result;
+  }
+
+  // TaskTimeObserver impl.
+  void WillProcessTask(base::TimeTicks start_time) override {
+    base::AutoLock hold(time_lock_);
+    if (!enabled_)
+      return;
+
+    DCHECK(start_time_active_task_.is_null());
+    start_time_active_task_ = start_time;
+  }
+
+  void DidProcessTask(base::TimeTicks start_time,
+                      base::TimeTicks end_time) override {
+    base::AutoLock hold(time_lock_);
+    if (!enabled_) {
+      start_time_active_task_ = base::TimeTicks();
+      return;
+    }
+
+    // This should be null for the task which adds this object to the observer
+    // list.
+    if (start_time_active_task_.is_null())
+      return;
+
+    if (start_time_active_task_ <= end_time) {
+      time_since_last_frame_ += (end_time - start_time_active_task_);
+    } else {
+      // This could happen if |GetAndResetTimeSinceLastFrame| is called on a
+      // different thread and the observed thread had to wait to acquire the
+      // lock to call DidProcessTask. Assume the time for this task is already
+      // recorded in |GetAndResetTimeSinceLastFrame|.
+      DCHECK_NE(start_time_active_task_, start_time);
+    }
+
+    start_time_active_task_ = base::TimeTicks();
+  }
+
+ private:
+  void UpdateOnTargetThread(bool enabled) {
+    if (enabled) {
+      base::CurrentThread::Get().AddTaskTimeObserver(this);
+
+      base::AutoLock hold(time_lock_);
+      start_time_active_task_ = base::TimeTicks();
+      time_since_last_frame_ = base::TimeDelta();
+    } else {
+      base::CurrentThread::Get().RemoveTaskTimeObserver(this);
+    }
+  }
+
+  // Accessed only on the calling thread. The caller ensures no concurrent
+  // access.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
+  // Accessed on calling and target thread.
+  base::Lock time_lock_;
+  bool enabled_ GUARDED_BY(time_lock_) = false;
+  base::TimeTicks start_time_active_task_ GUARDED_BY(time_lock_);
+  base::TimeDelta time_since_last_frame_ GUARDED_BY(time_lock_);
+};
+
+}  // namespace
+
+class RenderingPipelineImpl final : public RenderingPipeline {
+ public:
+  explicit RenderingPipelineImpl(const char* pipeline_type)
+      : pipeline_type_(pipeline_type) {
+    DETACH_FROM_THREAD(bound_thread_);
+  }
+  ~RenderingPipelineImpl() override { TearDown(); }
+
+  RenderingPipelineImpl(const RenderingPipelineImpl&) = delete;
+  RenderingPipelineImpl& operator=(const RenderingPipelineImpl&) = delete;
+
+  void SetTargetDuration(base::TimeDelta target_duration) override {
+    DCHECK_CALLED_ON_VALID_THREAD(bound_thread_);
+    DCHECK(!target_duration.is_zero());
+
+    if (target_duration_ == target_duration)
+      return;
+
+    target_duration_ = target_duration;
+    if (should_use_scheduler())
+      SetUp();
+  }
+
+  void AddSequenceManagerThread(
+      base::PlatformThreadId thread_id,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) override {
+    base::AutoLock lock(lock_);
+    DCHECK(time_observers_.find(thread_id) == time_observers_.end());
+    time_observers_[thread_id] =
+        std::make_unique<ThreadSafeTimeObserver>(task_runner);
+    if (scheduler_)
+      CreateSchedulerAndEnableWithLockAcquired();
+  }
+
+  base::sequence_manager::TaskTimeObserver* AddSimpleThread(
+      base::PlatformThreadId thread_id) override {
+    base::AutoLock lock(lock_);
+    DCHECK(time_observers_.find(thread_id) == time_observers_.end());
+    time_observers_[thread_id] =
+        std::make_unique<ThreadSafeTimeObserver>(nullptr);
+
+    if (scheduler_)
+      CreateSchedulerAndEnableWithLockAcquired();
+    return time_observers_[thread_id].get();
+  }
+
+  void NotifyFrameFinished() override {
+    DCHECK_CALLED_ON_VALID_THREAD(bound_thread_);
+
+    base::AutoLock lock(lock_);
+    if (!scheduler_)
+      return;
+
+    // TODO(crbug.com/1157620): This can be optimized to exclude tasks which can
+    // be paused during rendering. The best use-case is idle tasks on the
+    // renderer main thread. If all non-optional work is close to the frame
+    // budget then the scheduler dynamically adjusts to pause work like idle
+    // tasks.
+    base::TimeDelta total_time;
+    for (auto& it : time_observers_) {
+      total_time += it.second->GetAndResetTimeSinceLastFrame();
+    }
+    scheduler_->ReportCpuCompletionTime(total_time + gpu_latency_);
+  }
+
+  void SetGpuLatency(base::TimeDelta gpu_latency) override {
+    DCHECK_CALLED_ON_VALID_THREAD(bound_thread_);
+    gpu_latency_ = gpu_latency;
+  }
+
+  void UpdateActiveCount(bool active) override {
+    DCHECK_CALLED_ON_VALID_THREAD(bound_thread_);
+
+    if (active) {
+      active_count_++;
+    } else {
+      DCHECK_GT(active_count_, 0);
+      active_count_--;
+    }
+
+    if (should_use_scheduler()) {
+      SetUp();
+    } else {
+      TearDown();
+    }
+  }
+
+ private:
+  bool should_use_scheduler() const {
+    // TODO(crbug.com/1157620) : Figure out what we should be doing if multiple
+    // independent pipelines of a type are running simultaneously. The common
+    // use-case for this in practice would be multi-window. The tabs could be
+    // hosted in the same renderer process and each window is composited
+    // independently by the GPU process.
+    return active_count_ == 1 && !target_duration_.is_zero();
+  }
+
+  void SetUp() {
+    base::AutoLock lock(lock_);
+    CreateSchedulerAndEnableWithLockAcquired();
+  }
+
+  void CreateSchedulerAndEnableWithLockAcquired() {
+    lock_.AssertAcquired();
+    scheduler_.reset();
+
+    std::vector<base::PlatformThreadId> platform_threads;
+    for (auto& it : time_observers_) {
+      platform_threads.push_back(it.first);
+      it.second->SetEnabled(true);
+    }
+
+    scheduler_ = RenderingStageScheduler::CreateAdpf(
+        pipeline_type_, std::move(platform_threads), target_duration_);
+  }
+
+  void TearDown() {
+    base::AutoLock lock(lock_);
+    for (auto& it : time_observers_)
+      it.second->SetEnabled(false);
+    scheduler_.reset();
+  }
+
+  THREAD_CHECKER(bound_thread_);
+
+  base::Lock lock_;
+  base::flat_map<base::PlatformThreadId,
+                 std::unique_ptr<ThreadSafeTimeObserver>>
+      time_observers_ GUARDED_BY(lock_);
+  std::unique_ptr<RenderingStageScheduler> scheduler_ GUARDED_BY(lock_);
+
+  // Pipeline name, for tracing and metrics.
+  const char* pipeline_type_;
+
+  // The number of currently active pipelines of this type.
+  int active_count_ = 0;
+
+  // The target time for this rendering stage for a frame.
+  base::TimeDelta target_duration_;
+
+  base::TimeDelta gpu_latency_;
+};
+
+RenderingPipeline::ScopedPipelineActive::ScopedPipelineActive(
+    RenderingPipeline* pipeline)
+    : pipeline_(pipeline) {
+  pipeline_->UpdateActiveCount(true);
+}
+
+RenderingPipeline::ScopedPipelineActive::~ScopedPipelineActive() {
+  pipeline_->UpdateActiveCount(false);
+}
+
+std::unique_ptr<RenderingPipeline> RenderingPipeline::CreateRendererMain() {
+  static constexpr char kRendererMain[] = "RendererMain";
+  return std::make_unique<RenderingPipelineImpl>(kRendererMain);
+}
+
+std::unique_ptr<RenderingPipeline>
+RenderingPipeline::CreateRendererCompositor() {
+  static constexpr char kRendererCompositor[] = "RendererCompositor";
+  return std::make_unique<RenderingPipelineImpl>(kRendererCompositor);
+}
+
+std::unique_ptr<RenderingPipeline> RenderingPipeline::CreateGpu() {
+  static constexpr char kGpu[] = "Gpu";
+  return std::make_unique<RenderingPipelineImpl>(kGpu);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/rendering_pipeline.h b/ui/gfx/rendering_pipeline.h
new file mode 100644
index 0000000..0ad6729
--- /dev/null
+++ b/ui/gfx/rendering_pipeline.h
@@ -0,0 +1,82 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RENDERING_PIPELINE_H_
+#define UI_GFX_RENDERING_PIPELINE_H_
+
+#include "base/memory/singleton.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/platform_thread.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace base {
+namespace sequence_manager {
+class TaskTimeObserver;
+}
+}  // namespace base
+
+namespace gfx {
+
+// Tracks the desired and actual execution time of rendering threads to
+// optimally schedule them on the CPU. Instances of this class should be shared
+// between all compositors of the same rendering stage.
+//
+// This class can be created on any thread but becomes bound to the thread it's
+// subsequently used on. The class may be destroyed on any thread but the caller
+// is responsible for ensuring all other threads in the rendering stage, other
+// than the thread the object is destroyed on, are torn down before destroying
+// an instance of this class.
+class GFX_EXPORT RenderingPipeline {
+ public:
+  // Notifies when this pipeline is active. Multiple pipelines of the same type
+  // can be concurrently active at a time. The pipeline is assumed active for
+  // the lifetime of this object.
+  class GFX_EXPORT ScopedPipelineActive {
+   public:
+    explicit ScopedPipelineActive(RenderingPipeline* pipeline);
+    ~ScopedPipelineActive();
+
+   private:
+    RenderingPipeline* const pipeline_;
+  };
+
+  static std::unique_ptr<RenderingPipeline> CreateRendererMain();
+  static std::unique_ptr<RenderingPipeline> CreateRendererCompositor();
+  static std::unique_ptr<RenderingPipeline> CreateGpu();
+
+  virtual ~RenderingPipeline() = default;
+
+  // Add to this pipeline a thread backed by base sequence manager, where
+  // |base::CurrentThread| works. Most threads in chromium should fall into
+  // this category.
+  // This method is thread safe and can be called on any thread.
+  virtual void AddSequenceManagerThread(
+      base::PlatformThreadId thread_id,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) = 0;
+
+  // Add a simple thread to this pipeline. The caller is responsible for
+  // updating the returned observer for tasks executed on the thread.
+  // The returned observer is owned by this pipeline object.
+  // This method is thread safe and can be called on any thread.
+  virtual base::sequence_manager::TaskTimeObserver* AddSimpleThread(
+      base::PlatformThreadId thread_id) = 0;
+
+  // Notifies when this pipeline stage has finished rendering to compute the
+  // execution time per frame for the associated threads.
+  virtual void NotifyFrameFinished() = 0;
+
+  // Sets the desired duration for this pipeline.
+  virtual void SetTargetDuration(base::TimeDelta target_duration) = 0;
+
+  // Sets the latency from composition for a display buffer finishing on the
+  // Gpu thread to when execution finished on the Gpu.
+  virtual void SetGpuLatency(base::TimeDelta delta) = 0;
+
+ protected:
+  virtual void UpdateActiveCount(bool active) = 0;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_RENDERING_PIPELINE_H_
diff --git a/ui/gfx/rendering_stage_scheduler.cc b/ui/gfx/rendering_stage_scheduler.cc
new file mode 100644
index 0000000..0bfa2e0
--- /dev/null
+++ b/ui/gfx/rendering_stage_scheduler.cc
@@ -0,0 +1,78 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/rendering_stage_scheduler.h"
+
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
+
+#if defined(OS_ANDROID)
+#include "base/android/jni_array.h"
+#include "base/android/scoped_java_ref.h"
+#include "ui/gfx/gfx_jni_headers/AdpfRenderingStageScheduler_jni.h"
+#endif  // OS_ANDROID
+
+namespace gfx {
+namespace {
+#if defined(OS_ANDROID)
+
+class RenderingStageSchedulerAdpf : public RenderingStageScheduler {
+ public:
+  RenderingStageSchedulerAdpf(const char* pipeline_type,
+                              std::vector<base::PlatformThreadId> threads,
+                              base::TimeDelta desired_duration)
+      : pipeline_type_(pipeline_type), desired_duration_(desired_duration) {
+    static_assert(sizeof(base::PlatformThreadId) == sizeof(jint),
+                  "thread id types incompatible");
+    JNIEnv* env = base::android::AttachCurrentThread();
+    j_object_ = Java_AdpfRenderingStageScheduler_create(
+        env, base::android::ToJavaIntArray(env, threads),
+        desired_duration_.InNanoseconds());
+  }
+
+  ~RenderingStageSchedulerAdpf() override {
+    if (!j_object_)
+      return;
+    JNIEnv* env = base::android::AttachCurrentThread();
+    Java_AdpfRenderingStageScheduler_destroy(env, j_object_);
+  }
+
+  void ReportCpuCompletionTime(base::TimeDelta actual_duration) override {
+    TRACE_EVENT_INSTANT2(
+        "benchmark", "RenderingStageSchedulerAdpf::ReportCpuCompletionTime",
+        TRACE_EVENT_SCOPE_THREAD, "pipeline_type", pipeline_type_,
+        "utilization_percentage",
+        static_cast<int>(actual_duration * 100 / desired_duration_));
+    if (!j_object_)
+      return;
+    JNIEnv* env = base::android::AttachCurrentThread();
+    Java_AdpfRenderingStageScheduler_reportCpuCompletionTime(
+        env, j_object_, actual_duration.InNanoseconds());
+  }
+
+ private:
+  const char* pipeline_type_;
+  const base::TimeDelta desired_duration_;
+  base::android::ScopedJavaGlobalRef<jobject> j_object_;
+};
+
+#endif  // OS_ANDROID
+
+}  // namespace
+
+std::unique_ptr<RenderingStageScheduler> RenderingStageScheduler::CreateAdpf(
+    const char* pipeline_type,
+    std::vector<base::PlatformThreadId> threads,
+    base::TimeDelta desired_duration) {
+#if defined(OS_ANDROID)
+  return std::make_unique<RenderingStageSchedulerAdpf>(
+      pipeline_type, std::move(threads), desired_duration);
+#else
+  return nullptr;
+#endif
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/rendering_stage_scheduler.h b/ui/gfx/rendering_stage_scheduler.h
new file mode 100644
index 0000000..3c00f17
--- /dev/null
+++ b/ui/gfx/rendering_stage_scheduler.h
@@ -0,0 +1,35 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_RENDERING_STAGE_SCHEDULER_H_
+#define UI_GFX_RENDERING_STAGE_SCHEDULER_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/threading/platform_thread.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class GFX_EXPORT RenderingStageScheduler {
+ public:
+  // Creating instances of this class requires loading native libraries which
+  // require synchronous file access. This method ensures the synchronous work
+  // is finished.
+  static void EnsureInitialized();
+
+  static std::unique_ptr<RenderingStageScheduler> CreateAdpf(
+      const char* pipeline_type,
+      std::vector<base::PlatformThreadId> threads,
+      base::TimeDelta desired_duration);
+
+  virtual ~RenderingStageScheduler() = default;
+
+  virtual void ReportCpuCompletionTime(base::TimeDelta actual_duration) = 0;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_RENDERING_STAGE_SCHEDULER_H_
diff --git a/ui/gfx/scoped_canvas.cc b/ui/gfx/scoped_canvas.cc
new file mode 100644
index 0000000..fe45fcd
--- /dev/null
+++ b/ui/gfx/scoped_canvas.cc
@@ -0,0 +1,29 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/scoped_canvas.h"
+
+#include "base/i18n/rtl.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace gfx {
+
+ScopedCanvas::ScopedCanvas(gfx::Canvas* canvas) : canvas_(canvas) {
+  if (canvas_)
+    canvas_->Save();
+}
+
+ScopedCanvas::~ScopedCanvas() {
+  if (canvas_)
+    canvas_->Restore();
+}
+
+void ScopedCanvas::FlipIfRTL(int width) {
+  if (base::i18n::IsRTL()) {
+    canvas_->Translate(gfx::Vector2d(width, 0));
+    canvas_->Scale(-1, 1);
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/scoped_canvas.h b/ui/gfx/scoped_canvas.h
new file mode 100644
index 0000000..d2fee56
--- /dev/null
+++ b/ui/gfx/scoped_canvas.h
@@ -0,0 +1,32 @@
+// 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.
+
+#ifndef UI_GFX_SCOPED_CANVAS_H_
+#define UI_GFX_SCOPED_CANVAS_H_
+
+#include "base/macros.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Saves the drawing state, and restores the state when going out of scope.
+class GFX_EXPORT ScopedCanvas {
+ public:
+  explicit ScopedCanvas(gfx::Canvas* canvas);
+  ScopedCanvas(const ScopedCanvas&) = delete;
+  ScopedCanvas& operator=(const ScopedCanvas&) = delete;
+  virtual ~ScopedCanvas();
+
+  // If the UI is in RTL layout, applies a transform such that anything drawn
+  // inside the supplied width will be flipped horizontally.
+  void FlipIfRTL(int width);
+
+ private:
+  gfx::Canvas* canvas_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SCOPED_CANVAS_H_
diff --git a/ui/gfx/scoped_cg_context_save_gstate_mac.h b/ui/gfx/scoped_cg_context_save_gstate_mac.h
new file mode 100644
index 0000000..c829906
--- /dev/null
+++ b/ui/gfx/scoped_cg_context_save_gstate_mac.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SCOPED_CG_CONTEXT_SAVE_GSTATE_MAC_H_
+#define UI_GFX_SCOPED_CG_CONTEXT_SAVE_GSTATE_MAC_H_
+
+#import <QuartzCore/QuartzCore.h>
+
+#include "base/macros.h"
+
+namespace gfx {
+
+class ScopedCGContextSaveGState {
+ public:
+  explicit ScopedCGContextSaveGState(CGContextRef context) : context_(context) {
+    CGContextSaveGState(context_);
+  }
+
+  ScopedCGContextSaveGState(const ScopedCGContextSaveGState&) = delete;
+  ScopedCGContextSaveGState& operator=(const ScopedCGContextSaveGState&) =
+      delete;
+
+  ~ScopedCGContextSaveGState() {
+    CGContextRestoreGState(context_);
+  }
+
+ private:
+  CGContextRef context_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SCOPED_CG_CONTEXT_SAVE_GSTATE_MAC_H_
diff --git a/ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h b/ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h
new file mode 100644
index 0000000..b0e7553
--- /dev/null
+++ b/ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SCOPED_NS_GRAPHICS_CONTEXT_SAVE_GSTATE_MAC_H_
+#define UI_GFX_SCOPED_NS_GRAPHICS_CONTEXT_SAVE_GSTATE_MAC_H_
+
+#include "base/macros.h"
+#include "ui/gfx/gfx_export.h"
+
+#if defined(__OBJC__)
+@class NSGraphicsContext;
+#else
+class NSGraphicsContext;
+#endif
+
+namespace gfx {
+
+// A class to save/restore the state of the current context.
+class GFX_EXPORT ScopedNSGraphicsContextSaveGState {
+ public:
+  ScopedNSGraphicsContextSaveGState();
+
+  ScopedNSGraphicsContextSaveGState(const ScopedNSGraphicsContextSaveGState&) =
+      delete;
+  ScopedNSGraphicsContextSaveGState& operator=(
+      const ScopedNSGraphicsContextSaveGState&) = delete;
+
+  ~ScopedNSGraphicsContextSaveGState();
+
+ private:
+  NSGraphicsContext* context_;  // weak
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SCOPED_NS_GRAPHICS_CONTEXT_SAVE_GSTATE_MAC_H_
diff --git a/ui/gfx/scoped_ns_graphics_context_save_gstate_mac.mm b/ui/gfx/scoped_ns_graphics_context_save_gstate_mac.mm
new file mode 100644
index 0000000..658f4c6
--- /dev/null
+++ b/ui/gfx/scoped_ns_graphics_context_save_gstate_mac.mm
@@ -0,0 +1,23 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
+
+#import <AppKit/AppKit.h>
+
+#include "base/check_op.h"
+
+namespace gfx {
+
+ScopedNSGraphicsContextSaveGState::ScopedNSGraphicsContextSaveGState()
+    : context_([NSGraphicsContext currentContext]) {
+  [NSGraphicsContext saveGraphicsState];
+}
+
+ScopedNSGraphicsContextSaveGState::~ScopedNSGraphicsContextSaveGState() {
+  [NSGraphicsContext restoreGraphicsState];
+  DCHECK_EQ(context_, [NSGraphicsContext currentContext]);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/scoped_ui_graphics_push_context_ios.h b/ui/gfx/scoped_ui_graphics_push_context_ios.h
new file mode 100644
index 0000000..682da30
--- /dev/null
+++ b/ui/gfx/scoped_ui_graphics_push_context_ios.h
@@ -0,0 +1,30 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SCOPED_UI_GRAPHICS_PUSH_CONTEXT_IOS_H_
+#define UI_GFX_SCOPED_UI_GRAPHICS_PUSH_CONTEXT_IOS_H_
+
+#import <QuartzCore/QuartzCore.h>
+
+#include "base/macros.h"
+
+namespace gfx {
+
+class ScopedUIGraphicsPushContext {
+ public:
+  explicit ScopedUIGraphicsPushContext(CGContextRef context);
+
+  ScopedUIGraphicsPushContext(const ScopedUIGraphicsPushContext&) = delete;
+  ScopedUIGraphicsPushContext& operator=(const ScopedUIGraphicsPushContext&) =
+      delete;
+
+  ~ScopedUIGraphicsPushContext();
+
+ private:
+  CGContextRef context_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SCOPED_UI_GRAPHICS_PUSH_CONTEXT_IOS_H_
diff --git a/ui/gfx/scoped_ui_graphics_push_context_ios.mm b/ui/gfx/scoped_ui_graphics_push_context_ios.mm
new file mode 100644
index 0000000..a5b9b95
--- /dev/null
+++ b/ui/gfx/scoped_ui_graphics_push_context_ios.mm
@@ -0,0 +1,23 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/scoped_ui_graphics_push_context_ios.h"
+
+#import <UIKit/UIKit.h>
+
+#include "base/check_op.h"
+
+namespace gfx {
+
+ScopedUIGraphicsPushContext::ScopedUIGraphicsPushContext(CGContextRef context)
+    : context_(context) {
+  UIGraphicsPushContext(context_);
+}
+
+ScopedUIGraphicsPushContext::~ScopedUIGraphicsPushContext() {
+  DCHECK_EQ(context_, UIGraphicsGetCurrentContext());
+  UIGraphicsPopContext();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/scrollbar_size.cc b/ui/gfx/scrollbar_size.cc
new file mode 100644
index 0000000..040adec
--- /dev/null
+++ b/ui/gfx/scrollbar_size.cc
@@ -0,0 +1,24 @@
+// Copyright (c) 2009 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.
+
+#include "ui/gfx/scrollbar_size.h"
+
+#include "base/compiler_specific.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
+namespace gfx {
+
+int scrollbar_size() {
+#if defined(OS_WIN)
+  return GetSystemMetrics(SM_CXVSCROLL);
+#else
+  return 15;
+#endif
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/scrollbar_size.h b/ui/gfx/scrollbar_size.h
new file mode 100644
index 0000000..bfea069
--- /dev/null
+++ b/ui/gfx/scrollbar_size.h
@@ -0,0 +1,19 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SCROLLBAR_SIZE_H_
+#define UI_GFX_SCROLLBAR_SIZE_H_
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// This should return the thickness, in pixels, of a scrollbar in web content.
+// This needs to match the values in WebCore's
+// ScrollbarThemeChromiumXXX.cpp::scrollbarThickness().
+GFX_EXPORT int scrollbar_size();
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SCROLLBAR_SIZE_H_
diff --git a/ui/gfx/selection_bound.cc b/ui/gfx/selection_bound.cc
new file mode 100644
index 0000000..4e34107
--- /dev/null
+++ b/ui/gfx/selection_bound.cc
@@ -0,0 +1,125 @@
+// Copyright 2014 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.
+
+#include <algorithm>
+
+#include "base/macros.h"
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/selection_bound.h"
+
+namespace gfx {
+
+SelectionBound::SelectionBound() : type_(EMPTY), visible_(false) {}
+
+SelectionBound::SelectionBound(const SelectionBound& other) = default;
+
+SelectionBound::~SelectionBound() {}
+
+void SelectionBound::SetEdgeStart(const gfx::PointF& value) {
+  edge_start_ = value;
+  edge_start_rounded_ = gfx::ToRoundedPoint(value);
+}
+
+void SelectionBound::SetVisibleEdgeStart(const gfx::PointF& value) {
+  visible_edge_start_ = value;
+}
+
+void SelectionBound::SetEdgeEnd(const gfx::PointF& value) {
+  edge_end_ = value;
+  edge_end_rounded_ = gfx::ToRoundedPoint(value);
+}
+
+void SelectionBound::SetVisibleEdgeEnd(const gfx::PointF& value) {
+  visible_edge_end_ = value;
+}
+
+void SelectionBound::SetEdge(const gfx::PointF& start, const gfx::PointF& end) {
+  SetEdgeStart(start);
+  SetEdgeEnd(end);
+}
+
+void SelectionBound::SetVisibleEdge(const gfx::PointF& start,
+                                    const gfx::PointF& end) {
+  SetVisibleEdgeStart(start);
+  SetVisibleEdgeEnd(end);
+}
+
+int SelectionBound::GetHeight() const {
+  return edge_end_rounded_.y() - edge_start_rounded_.y();
+}
+
+std::string SelectionBound::ToString() const {
+  return base::StringPrintf(
+      "SelectionBound(%s, %s, %s, %s, %d)", edge_start_.ToString().c_str(),
+      edge_end_.ToString().c_str(), edge_start_rounded_.ToString().c_str(),
+      edge_end_rounded_.ToString().c_str(), visible_);
+}
+
+bool operator==(const SelectionBound& lhs, const SelectionBound& rhs) {
+  return lhs.type() == rhs.type() && lhs.visible() == rhs.visible() &&
+         lhs.edge_start() == rhs.edge_start() &&
+         lhs.edge_end() == rhs.edge_end() &&
+         lhs.visible_edge_start() == rhs.visible_edge_start() &&
+         lhs.visible_edge_end() == rhs.visible_edge_end();
+}
+
+bool operator!=(const SelectionBound& lhs, const SelectionBound& rhs) {
+  return !(lhs == rhs);
+}
+
+gfx::Rect RectBetweenSelectionBounds(const SelectionBound& b1,
+                                     const SelectionBound& b2) {
+  gfx::Point top_left(b1.edge_start_rounded());
+  top_left.SetToMin(b1.edge_end_rounded());
+  top_left.SetToMin(b2.edge_start_rounded());
+  top_left.SetToMin(b2.edge_end_rounded());
+
+  gfx::Point bottom_right(b1.edge_start_rounded());
+  bottom_right.SetToMax(b1.edge_end_rounded());
+  bottom_right.SetToMax(b2.edge_start_rounded());
+  bottom_right.SetToMax(b2.edge_end_rounded());
+
+  gfx::Vector2d diff = bottom_right - top_left;
+  return gfx::Rect(top_left, gfx::Size(diff.x(), diff.y()));
+}
+
+gfx::RectF RectFBetweenSelectionBounds(const SelectionBound& b1,
+                                       const SelectionBound& b2) {
+  gfx::PointF top_left(b1.edge_start());
+  top_left.SetToMin(b1.edge_end());
+  top_left.SetToMin(b2.edge_start());
+  top_left.SetToMin(b2.edge_end());
+
+  gfx::PointF bottom_right(b1.edge_start());
+  bottom_right.SetToMax(b1.edge_end());
+  bottom_right.SetToMax(b2.edge_start());
+  bottom_right.SetToMax(b2.edge_end());
+
+  gfx::Vector2dF diff = bottom_right - top_left;
+  return gfx::RectF(top_left, gfx::SizeF(diff.x(), diff.y()));
+}
+
+gfx::RectF RectFBetweenVisibleSelectionBounds(const SelectionBound& b1,
+                                              const SelectionBound& b2) {
+  // The selection bound is determined by the |start| and |end| points. For the
+  // writing-mode is vertical-*, the bounds are horizontal, the |end| might
+  // be on the left side of the |start|.
+  gfx::PointF top_left(b1.visible_edge_start());
+  top_left.SetToMin(b1.visible_edge_end());
+  top_left.SetToMin(b2.visible_edge_start());
+  top_left.SetToMin(b2.visible_edge_end());
+
+  gfx::PointF bottom_right(b1.visible_edge_start());
+  bottom_right.SetToMax(b1.visible_edge_end());
+  bottom_right.SetToMax(b2.visible_edge_start());
+  bottom_right.SetToMax(b2.visible_edge_end());
+
+  gfx::Vector2dF diff = bottom_right - top_left;
+  return gfx::RectF(top_left, gfx::SizeF(diff.x(), diff.y()));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/selection_bound.h b/ui/gfx/selection_bound.h
new file mode 100644
index 0000000..150b3a0
--- /dev/null
+++ b/ui/gfx/selection_bound.h
@@ -0,0 +1,83 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SELECTION_BOUND_H_
+#define UI_GFX_SELECTION_BOUND_H_
+
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class Rect;
+class RectF;
+
+// Bound of a selection end-point.
+class GFX_EXPORT SelectionBound {
+ public:
+  enum Type { LEFT, RIGHT, CENTER, EMPTY, LAST = EMPTY };
+
+  SelectionBound();
+  SelectionBound(const SelectionBound& other);
+  ~SelectionBound();
+
+  Type type() const { return type_; }
+  void set_type(Type value) { type_ = value; }
+
+  const gfx::PointF& edge_start() const { return edge_start_; }
+  const gfx::PointF& visible_edge_start() const { return visible_edge_start_; }
+  const gfx::Point& edge_start_rounded() const { return edge_start_rounded_; }
+  void SetEdgeStart(const gfx::PointF& value);
+  void SetVisibleEdgeStart(const gfx::PointF& value);
+
+  const gfx::PointF& edge_end() const { return edge_end_; }
+  const gfx::PointF& visible_edge_end() const { return visible_edge_end_; }
+  const gfx::Point& edge_end_rounded() const { return edge_end_rounded_; }
+  void SetEdgeEnd(const gfx::PointF& value);
+  void SetVisibleEdgeEnd(const gfx::PointF& value);
+
+  void SetEdge(const gfx::PointF& start, const gfx::PointF& end);
+  void SetVisibleEdge(const gfx::PointF& start, const gfx::PointF& end);
+
+  bool visible() const { return visible_; }
+  void set_visible(bool value) { visible_ = value; }
+
+  // Returns the vertical difference between rounded start and end.
+  int GetHeight() const;
+
+  std::string ToString() const;
+
+ private:
+  Type type_;
+  // The actual bounds of a selection end-point mgiht be invisible for
+  // occlusion.
+  gfx::PointF edge_start_;
+  gfx::PointF edge_end_;
+  // The visible bounds of a selection, which are equal to the above, when there
+  // is no occlusion.
+  gfx::PointF visible_edge_start_;
+  gfx::PointF visible_edge_end_;
+  gfx::Point edge_start_rounded_;
+  gfx::Point edge_end_rounded_;
+  bool visible_;
+};
+
+GFX_EXPORT bool operator==(const SelectionBound& lhs,
+                           const SelectionBound& rhs);
+GFX_EXPORT bool operator!=(const SelectionBound& lhs,
+                           const SelectionBound& rhs);
+
+GFX_EXPORT gfx::Rect RectBetweenSelectionBounds(const SelectionBound& b1,
+                                                const SelectionBound& b2);
+
+GFX_EXPORT gfx::RectF RectFBetweenSelectionBounds(const SelectionBound& b1,
+                                                  const SelectionBound& b2);
+
+GFX_EXPORT gfx::RectF RectFBetweenVisibleSelectionBounds(
+    const SelectionBound& b1,
+    const SelectionBound& b2);
+}  // namespace ui
+
+#endif  // UI_GFX_SELECTION_BOUND_H_
diff --git a/ui/gfx/selection_bound_unittest.cc b/ui/gfx/selection_bound_unittest.cc
new file mode 100644
index 0000000..224ebe3
--- /dev/null
+++ b/ui/gfx/selection_bound_unittest.cc
@@ -0,0 +1,103 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/selection_bound.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace gfx {
+
+TEST(SelectionBoundTest, RectBetweenSelectionBounds) {
+  SelectionBound b1, b2;
+  // Simple case of aligned vertical bounds of equal height
+  b1.SetEdge(gfx::PointF(0.f, 20.f), gfx::PointF(0.f, 25.f));
+  b2.SetEdge(gfx::PointF(110.f, 20.f), gfx::PointF(110.f, 25.f));
+  gfx::Rect expected_rect(
+      b1.edge_start_rounded().x(), b1.edge_start_rounded().y(),
+      b2.edge_start_rounded().x() - b1.edge_start_rounded().x(),
+      b2.edge_end_rounded().y() - b2.edge_start_rounded().y());
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b2, b1));
+
+  // Both bounds are invisible.
+  b1.SetVisibleEdge(gfx::PointF(10.f, 20.f), gfx::PointF(10.f, 25.f));
+  b2.SetVisibleEdge(gfx::PointF(100.f, 20.f), gfx::PointF(100.f, 25.f));
+  gfx::RectF expected_visible_rect(
+      b1.visible_edge_start().x(), b1.visible_edge_start().y(),
+      b2.visible_edge_start().x() - b1.visible_edge_start().x(),
+      b2.visible_edge_end().y() - b2.visible_edge_start().y());
+  EXPECT_EQ(expected_visible_rect, RectFBetweenVisibleSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_visible_rect, RectFBetweenVisibleSelectionBounds(b2, b1));
+
+  // One of the bounds is invisible.
+  b1.SetVisibleEdge(gfx::PointF(0.f, 20.f), gfx::PointF(0.f, 25.f));
+  b2.SetVisibleEdge(gfx::PointF(100.f, 20.f), gfx::PointF(100.f, 25.f));
+  expected_visible_rect =
+      gfx::RectF(b1.visible_edge_start().x(), b1.visible_edge_start().y(),
+                 b2.visible_edge_start().x() - b1.visible_edge_start().x(),
+                 b2.visible_edge_end().y() - b2.visible_edge_start().y());
+  EXPECT_EQ(expected_visible_rect, RectFBetweenVisibleSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_visible_rect, RectFBetweenVisibleSelectionBounds(b2, b1));
+
+  // Parallel vertical bounds of different heights
+  b1.SetEdge(gfx::PointF(10.f, 20.f), gfx::PointF(10.f, 25.f));
+  b2.SetEdge(gfx::PointF(110.f, 0.f), gfx::PointF(110.f, 35.f));
+  expected_rect =
+      gfx::Rect(b1.edge_start_rounded().x(), b2.edge_start_rounded().y(),
+                b2.edge_start_rounded().x() - b1.edge_start_rounded().x(),
+                b2.edge_end_rounded().y() - b2.edge_start_rounded().y());
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b2, b1));
+
+  b1.SetEdge(gfx::PointF(10.f, 20.f), gfx::PointF(10.f, 30.f));
+  b2.SetEdge(gfx::PointF(110.f, 25.f), gfx::PointF(110.f, 45.f));
+  expected_rect =
+      gfx::Rect(b1.edge_start_rounded().x(), b1.edge_start_rounded().y(),
+                b2.edge_start_rounded().x() - b1.edge_start_rounded().x(),
+                b2.edge_end_rounded().y() - b1.edge_start_rounded().y());
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b2, b1));
+
+  b1.SetEdge(gfx::PointF(10.f, 20.f), gfx::PointF(10.f, 30.f));
+  b2.SetEdge(gfx::PointF(110.f, 40.f), gfx::PointF(110.f, 60.f));
+  expected_rect =
+      gfx::Rect(b1.edge_start_rounded().x(), b1.edge_start_rounded().y(),
+                b2.edge_start_rounded().x() - b1.edge_start_rounded().x(),
+                b2.edge_end_rounded().y() - b1.edge_start_rounded().y());
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b2, b1));
+
+  // Overlapping vertical bounds
+  b1.SetEdge(gfx::PointF(10.f, 20.f), gfx::PointF(10.f, 30.f));
+  b2.SetEdge(gfx::PointF(10.f, 25.f), gfx::PointF(10.f, 40.f));
+  expected_rect =
+      gfx::Rect(b1.edge_start_rounded().x(), b1.edge_start_rounded().y(), 0,
+                b2.edge_end_rounded().y() - b1.edge_start_rounded().y());
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b2, b1));
+
+  // Non-vertical bounds: "\ \"
+  b1.SetEdge(gfx::PointF(10.f, 20.f), gfx::PointF(20.f, 30.f));
+  b2.SetEdge(gfx::PointF(110.f, 40.f), gfx::PointF(120.f, 60.f));
+  expected_rect =
+      gfx::Rect(b1.edge_start_rounded().x(), b1.edge_start_rounded().y(),
+                b2.edge_end_rounded().x() - b1.edge_start_rounded().x(),
+                b2.edge_end_rounded().y() - b1.edge_start_rounded().y());
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b2, b1));
+
+  // Non-vertical bounds: "/ \"
+  b1.SetEdge(gfx::PointF(20.f, 30.f), gfx::PointF(0.f, 40.f));
+  b2.SetEdge(gfx::PointF(110.f, 30.f), gfx::PointF(120.f, 40.f));
+  expected_rect =
+      gfx::Rect(b1.edge_end_rounded().x(), b1.edge_start_rounded().y(),
+                b2.edge_end_rounded().x() - b1.edge_end_rounded().x(),
+                b2.edge_end_rounded().y() - b2.edge_start_rounded().y());
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b1, b2));
+  EXPECT_EQ(expected_rect, RectBetweenSelectionBounds(b2, b1));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/selection_model.cc b/ui/gfx/selection_model.cc
new file mode 100644
index 0000000..a792731
--- /dev/null
+++ b/ui/gfx/selection_model.cc
@@ -0,0 +1,81 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/selection_model.h"
+
+#include <ostream>
+
+#include "base/check.h"
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
+
+namespace gfx {
+
+SelectionModel::SelectionModel()
+    : selection_(0),
+      caret_affinity_(CURSOR_BACKWARD) {}
+
+SelectionModel::SelectionModel(size_t position, LogicalCursorDirection affinity)
+    : selection_(position),
+      caret_affinity_(affinity) {}
+
+SelectionModel::SelectionModel(const Range& selection,
+                               LogicalCursorDirection affinity)
+    : selection_(selection),
+      caret_affinity_(affinity) {}
+
+SelectionModel::SelectionModel(const std::vector<Range>& selections,
+                               LogicalCursorDirection affinity)
+    : selection_(selections[0]), caret_affinity_(affinity) {
+  for (size_t i = 1; i < selections.size(); ++i)
+    AddSecondarySelection(selections[i]);
+}
+
+SelectionModel::SelectionModel(const SelectionModel& selection_model) = default;
+
+SelectionModel::~SelectionModel() = default;
+
+void SelectionModel::AddSecondarySelection(const Range& selection) {
+  for (auto s : GetAllSelections())
+    DCHECK(!selection.Intersects(s));
+  secondary_selections_.push_back(selection);
+}
+
+std::vector<Range> SelectionModel::GetAllSelections() const {
+  std::vector<Range> selections = {selection()};
+  selections.insert(selections.end(), secondary_selections_.begin(),
+                    secondary_selections_.end());
+  return selections;
+}
+
+bool SelectionModel::operator==(const SelectionModel& sel) const {
+  return selection() == sel.selection() &&
+         caret_affinity() == sel.caret_affinity() &&
+         secondary_selections() == sel.secondary_selections();
+}
+
+std::string SelectionModel::ToString() const {
+  std::string str = "{";
+  if (selection().is_empty())
+    base::StringAppendF(&str, "%" PRIuS, caret_pos());
+  else
+    str += selection().ToString();
+  const bool backward = caret_affinity() == CURSOR_BACKWARD;
+  str += (backward ? ",BACKWARD" : ",FORWARD");
+  for (auto selection : secondary_selections()) {
+    str += ",";
+    if (selection.is_empty())
+      base::StringAppendF(&str, "%" PRIu32, selection.end());
+    else
+      str += selection.ToString();
+  }
+  return str + "}";
+}
+
+std::ostream& operator<<(std::ostream& out, const SelectionModel& model) {
+  out << model.ToString();
+  return out;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/selection_model.h b/ui/gfx/selection_model.h
new file mode 100644
index 0000000..150b38c
--- /dev/null
+++ b/ui/gfx/selection_model.h
@@ -0,0 +1,136 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SELECTION_MODEL_H_
+#define UI_GFX_SELECTION_MODEL_H_
+
+#include <stddef.h>
+#include <vector>
+
+#include <iosfwd>
+#include <string>
+
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/range/range.h"
+
+namespace gfx {
+
+// VisualCursorDirection and LogicalCursorDirection represent directions of
+// motion of the cursor in BiDi text. The combinations that make sense are:
+//
+//  base::i18n::TextDirection  VisualCursorDirection  LogicalCursorDirection
+//       LEFT_TO_RIGHT             CURSOR_LEFT           CURSOR_BACKWARD
+//       LEFT_TO_RIGHT             CURSOR_RIGHT          CURSOR_FORWARD
+//       RIGHT_TO_LEFT             CURSOR_RIGHT          CURSOR_BACKWARD
+//       RIGHT_TO_LEFT             CURSOR_LEFT           CURSOR_FORWARD
+enum VisualCursorDirection {
+  CURSOR_LEFT,
+  CURSOR_RIGHT,
+  CURSOR_UP,
+  CURSOR_DOWN
+};
+enum LogicalCursorDirection {
+  CURSOR_BACKWARD,
+  CURSOR_FORWARD
+};
+
+// TODO(xji): publish bidi-editing guide line and replace the place holder.
+// SelectionModel is used to represent the logical selection and visual
+// position of cursor.
+//
+// For bi-directional text, the mapping between visual position and logical
+// position is not one-to-one. For example, logical text "abcDEF" where capital
+// letters stand for Hebrew, the visual display is "abcFED". According to the
+// bidi editing guide (http://bidi-editing-guideline):
+// 1. If pointing to the right half of the cell of a LTR character, the current
+// position must be set after this character and the caret must be displayed
+// after this character.
+// 2. If pointing to the right half of the cell of a RTL character, the current
+// position must be set before this character and the caret must be displayed
+// before this character.
+//
+// Pointing to the right half of 'c' and pointing to the right half of 'D' both
+// set the logical cursor position to 3. But the cursor displayed visually at
+// different places:
+// Pointing to the right half of 'c' displays the cursor right of 'c' as
+// "abc|FED".
+// Pointing to the right half of 'D' displays the cursor right of 'D' as
+// "abcFED|".
+// So, besides the logical selection start point and end point, we need extra
+// information to specify to which character the visual cursor is bound. This
+// is given by a "caret affinity" which is either CURSOR_BACKWARD (indicating
+// the trailing half of the 'c' in this case) or CURSOR_FORWARD (indicating
+// the leading half of the 'D').
+class GFX_EXPORT SelectionModel {
+ public:
+  // Create a default SelectionModel to be overwritten later.
+  SelectionModel();
+  // Create a SelectionModel representing a caret |position| without a
+  // selection. The |affinity| is meaningful only when the caret is positioned
+  // between bidi runs that are not visually contiguous: in that case, it
+  // indicates the run to which the caret is attached for display purposes.
+  SelectionModel(size_t position, LogicalCursorDirection affinity);
+  // Create a SelectionModel representing a selection (which may be empty).
+  // The caret position is the end of the range.
+  SelectionModel(const Range& selection, LogicalCursorDirection affinity);
+  // Create a SelectionModel representing multiple selections (which may be
+  // empty but not overlapping). The end of the first range determines the caret
+  // position.
+  SelectionModel(const std::vector<Range>& selections,
+                 LogicalCursorDirection affinity);
+  SelectionModel(const SelectionModel& selection_model);
+  ~SelectionModel();
+
+  // |selection| should overlap with neither |selection_| nor
+  // |secondary_selections_|.
+  void AddSecondarySelection(const Range& selection);
+
+  const Range& selection() const { return selection_; }
+  size_t caret_pos() const { return selection_.end(); }
+  LogicalCursorDirection caret_affinity() const { return caret_affinity_; }
+  const std::vector<Range>& secondary_selections() const {
+    return secondary_selections_;
+  }
+  std::vector<Range> GetAllSelections() const;
+
+  // WARNING: Generally the selection start should not be changed without
+  // considering the effect on the caret affinity.
+  void set_selection_start(uint32_t pos) { selection_.set_start(pos); }
+
+  bool operator==(const SelectionModel& sel) const;
+  bool operator!=(const SelectionModel& sel) const { return !(*this == sel); }
+
+  std::string ToString() const;
+
+ private:
+  // Logical selection. The logical caret position is the end of the selection.
+  Range selection_;
+  // Secondary selections not associated with the cursor. Do not overlap.
+  std::vector<Range> secondary_selections_;
+
+  // The logical direction from the caret position (selection_.end()) to the
+  // character it is attached to for display purposes. This matters only when
+  // the surrounding characters are not visually contiguous, which happens only
+  // in bidi text (and only at bidi run boundaries). The text is treated as
+  // though it was surrounded on both sides by runs in the dominant text
+  // direction. For example, supposing the dominant direction is LTR and the
+  // logical text is "abcDEF", where DEF is right-to-left text, the visual
+  // cursor will display as follows:
+  //    caret position    CURSOR_BACKWARD affinity    CURSOR_FORWARD affinity
+  //          0                  |abcFED                     |abcFED
+  //          1                  a|bcFED                     a|bcFED
+  //          2                  ab|cFED                     ab|cFED
+  //          3                  abc|FED                     abcFED|
+  //          4                  abcFE|D                     abcFE|D
+  //          5                  abcF|ED                     abcF|ED
+  //          6                  abc|FED                     abcFED|
+  LogicalCursorDirection caret_affinity_;
+};
+
+GFX_EXPORT std::ostream& operator<<(std::ostream& out,
+                                    const SelectionModel& model);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SELECTION_MODEL_H_
diff --git a/ui/gfx/selection_model_unittest.cc b/ui/gfx/selection_model_unittest.cc
new file mode 100644
index 0000000..2147b2d
--- /dev/null
+++ b/ui/gfx/selection_model_unittest.cc
@@ -0,0 +1,90 @@
+// Copyright (c) 2020 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.
+
+#include <vector>
+
+#include "ui/gfx/selection_model.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/range/range.h"
+
+namespace gfx {
+
+TEST(SelectionModelTest, Construction) {
+  {
+    SelectionModel selection_model;
+    EXPECT_EQ(selection_model.selection(), Range(0));
+    EXPECT_EQ(selection_model.caret_pos(), 0u);
+    EXPECT_EQ(selection_model.secondary_selections(), std::vector<Range>());
+  }
+  {
+    SelectionModel selection_model{5, CURSOR_FORWARD};
+    EXPECT_EQ(selection_model.selection(), Range(5));
+    EXPECT_EQ(selection_model.caret_pos(), 5u);
+    EXPECT_EQ(selection_model.secondary_selections(), std::vector<Range>());
+  }
+  {
+    SelectionModel selection_model{{3, 2}, CURSOR_BACKWARD};
+    EXPECT_EQ(selection_model.selection(), Range(3, 2));
+    EXPECT_EQ(selection_model.caret_pos(), 2u);
+    EXPECT_EQ(selection_model.secondary_selections(), std::vector<Range>());
+  }
+  {
+    SelectionModel selection_model{{{2, 3}, {5, 5}, {1, 0}}, CURSOR_BACKWARD};
+    EXPECT_EQ(selection_model.selection(), Range(2, 3));
+    EXPECT_EQ(selection_model.caret_pos(), 3u);
+    EXPECT_EQ(selection_model.secondary_selections(),
+              std::vector<Range>({{5, 5}, {1, 0}}));
+  }
+}
+
+TEST(SelectionModelTest, AddSecondarySelection) {
+  SelectionModel selection_model;
+  selection_model.AddSecondarySelection({5, 6});
+  selection_model.AddSecondarySelection({7, 6});
+  selection_model.AddSecondarySelection({8, 8});
+  EXPECT_EQ(selection_model.selection(), Range(0));
+  EXPECT_EQ(selection_model.caret_pos(), 0u);
+  EXPECT_EQ(selection_model.secondary_selections(),
+            std::vector<Range>({{5, 6}, {7, 6}, {8, 8}}));
+}
+
+TEST(SelectionModelTest, GetAllSelections) {
+  SelectionModel selection_model{{3, 2}, CURSOR_BACKWARD};
+  selection_model.AddSecondarySelection({5, 6});
+  selection_model.AddSecondarySelection({7, 6});
+  selection_model.AddSecondarySelection({8, 8});
+  EXPECT_EQ(selection_model.GetAllSelections(),
+            std::vector<Range>({{3, 2}, {5, 6}, {7, 6}, {8, 8}}));
+}
+
+TEST(SelectionModelTest, EqualityOperators) {
+  SelectionModel selection_model{{3, 2}, CURSOR_BACKWARD};
+  selection_model.AddSecondarySelection({5, 6});
+  selection_model.AddSecondarySelection({7, 6});
+  selection_model.AddSecondarySelection({8, 8});
+
+  // Equal
+  EXPECT_EQ(selection_model,
+            SelectionModel({{3, 2}, {5, 6}, {7, 6}, {8, 8}}, CURSOR_BACKWARD));
+  // Unequal selection
+  EXPECT_NE(selection_model,
+            SelectionModel({{3, 3}, {5, 6}, {7, 6}, {8, 8}}, CURSOR_BACKWARD));
+  // Unequal secondary selections
+  EXPECT_NE(selection_model,
+            SelectionModel({{3, 2}, {5, 6}, {7, 6}, {9, 8}}, CURSOR_BACKWARD));
+  // Unequal cursor affinity
+  EXPECT_NE(selection_model,
+            SelectionModel({{3, 2}, {5, 6}, {7, 6}, {8, 8}}, CURSOR_FORWARD));
+}
+
+TEST(SelectionModelTest, ToString) {
+  SelectionModel selection_model{{3, 2}, CURSOR_BACKWARD};
+  selection_model.AddSecondarySelection({5, 6});
+  selection_model.AddSecondarySelection({7, 6});
+  selection_model.AddSecondarySelection({8, 8});
+  EXPECT_EQ(selection_model.ToString(), "{{3,2},BACKWARD,{5,6},{7,6},8}");
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/sequential_id_generator.cc b/ui/gfx/sequential_id_generator.cc
new file mode 100644
index 0000000..d8e7efb
--- /dev/null
+++ b/ui/gfx/sequential_id_generator.cc
@@ -0,0 +1,89 @@
+// Copyright (c) 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.
+
+#include "ui/gfx/sequential_id_generator.h"
+
+#include "base/check_op.h"
+
+namespace {
+
+// Removes |key| from |first|, and |first[key]| from |second|.
+template <typename T>
+void Remove(uint32_t key, T* first, T* second) {
+  auto iter = first->find(key);
+  if (iter == first->end())
+    return;
+
+  uint32_t second_key = iter->second;
+  first->erase(iter);
+
+  iter = second->find(second_key);
+  DCHECK(iter != second->end());
+  second->erase(iter);
+}
+
+}  // namespace
+
+namespace ui {
+
+SequentialIDGenerator::SequentialIDGenerator(uint32_t min_id)
+    : min_id_(min_id), min_available_id_(min_id) {}
+
+SequentialIDGenerator::~SequentialIDGenerator() {
+}
+
+uint32_t SequentialIDGenerator::GetGeneratedID(uint32_t number) {
+  auto find = number_to_id_.find(number);
+  if (find != number_to_id_.end())
+    return find->second;
+
+  int id = GetNextAvailableID();
+  number_to_id_.emplace(number, id);
+  id_to_number_.emplace(id, number);
+  return id;
+}
+
+bool SequentialIDGenerator::HasGeneratedIDFor(uint32_t number) const {
+  return number_to_id_.find(number) != number_to_id_.end();
+}
+
+void SequentialIDGenerator::ReleaseNumber(uint32_t number) {
+  if (number_to_id_.count(number) > 0U) {
+    UpdateNextAvailableIDAfterRelease(number_to_id_[number]);
+    Remove(number, &number_to_id_, &id_to_number_);
+  }
+}
+
+void SequentialIDGenerator::ReleaseID(uint32_t id) {
+  if (id_to_number_.count(id) > 0U) {
+    UpdateNextAvailableIDAfterRelease(id);
+    Remove(id_to_number_[id], &number_to_id_, &id_to_number_);
+  }
+}
+
+void SequentialIDGenerator::ResetForTest() {
+  number_to_id_.clear();
+  id_to_number_.clear();
+  min_available_id_ = min_id_;
+}
+
+uint32_t SequentialIDGenerator::GetNextAvailableID() {
+  const uint32_t kMaxID = 128;
+  while (id_to_number_.count(min_available_id_) > 0 &&
+         min_available_id_ < kMaxID) {
+    ++min_available_id_;
+  }
+  if (min_available_id_ >= kMaxID)
+    min_available_id_ = min_id_;
+  return min_available_id_;
+}
+
+void SequentialIDGenerator::UpdateNextAvailableIDAfterRelease(uint32_t id) {
+  if (id < min_available_id_) {
+    min_available_id_ = id;
+    DCHECK_GE(min_available_id_, min_id_);
+  }
+}
+
+}  // namespace ui
diff --git a/ui/gfx/sequential_id_generator.h b/ui/gfx/sequential_id_generator.h
new file mode 100644
index 0000000..bc24e2c
--- /dev/null
+++ b/ui/gfx/sequential_id_generator.h
@@ -0,0 +1,65 @@
+// Copyright (c) 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.
+
+#ifndef UI_GFX_SEQUENTIAL_ID_GENERATOR_H_
+#define UI_GFX_SEQUENTIAL_ID_GENERATOR_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <unordered_map>
+
+#include "base/macros.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace ui {
+
+// This is used to generate a series of sequential ID numbers in a way that a
+// new ID is always the lowest possible ID in the sequence.
+class GFX_EXPORT SequentialIDGenerator {
+ public:
+   // Creates a new generator with the specified lower bound for the IDs.
+  explicit SequentialIDGenerator(uint32_t min_id);
+
+  SequentialIDGenerator(const SequentialIDGenerator&) = delete;
+  SequentialIDGenerator& operator=(const SequentialIDGenerator&) = delete;
+
+  ~SequentialIDGenerator();
+
+  // Generates a unique ID to represent |number|. The generated ID is the
+  // smallest available ID greater than or equal to the |min_id| specified
+  // during creation of the generator.
+  uint32_t GetGeneratedID(uint32_t number);
+
+  // Checks to see if the generator currently has a unique ID generated for
+  // |number|.
+  bool HasGeneratedIDFor(uint32_t number) const;
+
+  // Removes the ID previously generated for |number| by calling
+  // |GetGeneratedID()| - does nothing if the number is not mapped.
+  void ReleaseNumber(uint32_t number);
+
+  // Releases ID previously generated by calling |GetGeneratedID()|. Does
+  // nothing if the ID is not mapped.
+  void ReleaseID(uint32_t id);
+
+  void ResetForTest();
+
+ private:
+  typedef std::unordered_map<uint32_t, uint32_t> IDMap;
+
+  uint32_t GetNextAvailableID();
+
+  void UpdateNextAvailableIDAfterRelease(uint32_t id);
+
+  IDMap number_to_id_;
+  IDMap id_to_number_;
+
+  const uint32_t min_id_;
+  uint32_t min_available_id_;
+};
+
+}  // namespace ui
+
+#endif  // UI_GFX_SEQUENTIAL_ID_GENERATOR_H_
diff --git a/ui/gfx/sequential_id_generator_unittest.cc b/ui/gfx/sequential_id_generator_unittest.cc
new file mode 100644
index 0000000..f36aa98
--- /dev/null
+++ b/ui/gfx/sequential_id_generator_unittest.cc
@@ -0,0 +1,47 @@
+// Copyright (c) 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.
+
+#include "ui/gfx/sequential_id_generator.h"
+
+#include <stdint.h>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace ui {
+
+typedef testing::Test SequentialIDGeneratorTest;
+
+TEST(SequentialIDGeneratorTest, RemoveMultipleNumbers) {
+  const uint32_t kMinID = 4;
+  SequentialIDGenerator generator(kMinID);
+
+  EXPECT_EQ(4U, generator.GetGeneratedID(45));
+  EXPECT_EQ(5U, generator.GetGeneratedID(55));
+  EXPECT_EQ(6U, generator.GetGeneratedID(15));
+
+  generator.ReleaseNumber(45);
+  EXPECT_FALSE(generator.HasGeneratedIDFor(45));
+  generator.ReleaseNumber(15);
+  EXPECT_FALSE(generator.HasGeneratedIDFor(15));
+
+  EXPECT_EQ(5U, generator.GetGeneratedID(55));
+  EXPECT_EQ(4U, generator.GetGeneratedID(12));
+
+  generator.ReleaseNumber(12);
+  generator.ReleaseNumber(55);
+  EXPECT_EQ(4U, generator.GetGeneratedID(0));
+}
+
+TEST(SequentialIDGeneratorTest, MaybeRemoveNumbers) {
+  const uint32_t kMinID = 0;
+  SequentialIDGenerator generator(kMinID);
+
+  EXPECT_EQ(0U, generator.GetGeneratedID(42));
+
+  generator.ReleaseNumber(42);
+  EXPECT_FALSE(generator.HasGeneratedIDFor(42));
+  generator.ReleaseNumber(42);
+}
+
+}  // namespace ui
diff --git a/ui/gfx/shadow_util.cc b/ui/gfx/shadow_util.cc
new file mode 100644
index 0000000..04b7762
--- /dev/null
+++ b/ui/gfx/shadow_util.cc
@@ -0,0 +1,105 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/shadow_util.h"
+
+#include <map>
+#include <vector>
+
+#include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
+#include "third_party/skia/include/core/SkDrawLooper.h"
+#include "third_party/skia/include/core/SkRRect.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/image/canvas_image_source.h"
+#include "ui/gfx/shadow_value.h"
+#include "ui/gfx/skia_paint_util.h"
+
+namespace gfx {
+namespace {
+
+// Creates an image with the given shadows painted around a round rect with
+// the given corner radius. The image will be just large enough to paint the
+// shadows appropriately with a 1px square region reserved for "content".
+class ShadowNineboxSource : public CanvasImageSource {
+ public:
+  ShadowNineboxSource(const std::vector<ShadowValue>& shadows,
+                      float corner_radius)
+      : CanvasImageSource(CalculateSize(shadows, corner_radius)),
+        shadows_(shadows),
+        corner_radius_(corner_radius) {
+    DCHECK(!shadows.empty());
+  }
+
+  ShadowNineboxSource(const ShadowNineboxSource&) = delete;
+  ShadowNineboxSource& operator=(const ShadowNineboxSource&) = delete;
+
+  ~ShadowNineboxSource() override {}
+
+  // CanvasImageSource overrides:
+  void Draw(Canvas* canvas) override {
+    cc::PaintFlags flags;
+    flags.setLooper(CreateShadowDrawLooper(shadows_));
+    Insets insets = -ShadowValue::GetMargin(shadows_);
+    gfx::Rect bounds(size());
+    bounds.Inset(insets);
+    SkRRect r_rect = SkRRect::MakeRectXY(gfx::RectToSkRect(bounds),
+                                         corner_radius_, corner_radius_);
+
+    // Clip out the center so it's not painted with the shadow.
+    canvas->sk_canvas()->clipRRect(r_rect, SkClipOp::kDifference, true);
+    // Clipping alone is not enough --- due to anti aliasing there will still be
+    // some of the fill color in the rounded corners. We must make the fill
+    // color transparent.
+    flags.setColor(SK_ColorTRANSPARENT);
+    canvas->sk_canvas()->drawRRect(r_rect, flags);
+  }
+
+ private:
+  static Size CalculateSize(const std::vector<ShadowValue>& shadows,
+                            float corner_radius) {
+    // The "content" area (the middle tile in the 3x3 grid) is a single pixel.
+    gfx::Rect bounds(0, 0, 1, 1);
+    // We need enough space to render the full range of blur.
+    bounds.Inset(-ShadowValue::GetBlurRegion(shadows));
+    // We also need space for the full roundrect corner rounding.
+    bounds.Inset(-gfx::Insets(corner_radius));
+    return bounds.size();
+  }
+
+  const std::vector<ShadowValue> shadows_;
+
+  const float corner_radius_;
+};
+
+// Map from elevation/corner radius pair to a cached shadow.
+using ShadowDetailsMap = std::map<std::pair<int, int>, ShadowDetails>;
+base::LazyInstance<ShadowDetailsMap>::DestructorAtExit g_shadow_cache =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+ShadowDetails::ShadowDetails() {}
+ShadowDetails::ShadowDetails(const ShadowDetails& other) = default;
+ShadowDetails::~ShadowDetails() {}
+
+const ShadowDetails& ShadowDetails::Get(int elevation, int corner_radius) {
+  auto iter =
+      g_shadow_cache.Get().find(std::make_pair(elevation, corner_radius));
+  if (iter != g_shadow_cache.Get().end())
+    return iter->second;
+
+  auto insertion = g_shadow_cache.Get().emplace(
+      std::make_pair(elevation, corner_radius), ShadowDetails());
+  DCHECK(insertion.second);
+  ShadowDetails* shadow = &insertion.first->second;
+  shadow->values = ShadowValue::MakeMdShadowValues(elevation);
+  auto* source = new ShadowNineboxSource(shadow->values, corner_radius);
+  shadow->ninebox_image = ImageSkia(base::WrapUnique(source), source->size());
+  return *shadow;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/shadow_util.h b/ui/gfx/shadow_util.h
new file mode 100644
index 0000000..8f8759d
--- /dev/null
+++ b/ui/gfx/shadow_util.h
@@ -0,0 +1,33 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SHADOW_UTIL_H_
+#define UI_GFX_SHADOW_UTIL_H_
+
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/shadow_value.h"
+
+namespace gfx {
+
+// A struct that describes a vector of shadows and their depiction as an image
+// suitable for ninebox tiling.
+struct GFX_EXPORT ShadowDetails {
+  ShadowDetails();
+  ShadowDetails(const ShadowDetails& other);
+  ~ShadowDetails();
+
+  // Returns a cached ShadowDetails for the given elevation (which controls
+  // style) and corner radius. Creates the ShadowDetails first if necessary.
+  static const ShadowDetails& Get(int elevation, int radius);
+
+  // Description of the shadows.
+  gfx::ShadowValues values;
+  // Cached ninebox image based on |values|.
+  gfx::ImageSkia ninebox_image;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SHADOW_UTIL_H_
diff --git a/ui/gfx/shadow_value.cc b/ui/gfx/shadow_value.cc
new file mode 100644
index 0000000..d71ecfd
--- /dev/null
+++ b/ui/gfx/shadow_value.cc
@@ -0,0 +1,128 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/shadow_value.h"
+
+#include <stddef.h>
+
+#include <algorithm>
+
+#include "base/check_op.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/vector2d_conversions.h"
+
+namespace gfx {
+
+namespace {
+
+Insets GetInsets(const ShadowValues& shadows, bool include_inner_blur) {
+  int left = 0;
+  int top = 0;
+  int right = 0;
+  int bottom = 0;
+
+  for (size_t i = 0; i < shadows.size(); ++i) {
+    const ShadowValue& shadow = shadows[i];
+
+    double blur = shadow.blur();
+    if (!include_inner_blur)
+      blur /= 2;
+    int blur_length = base::ClampRound(blur);
+
+    left = std::max(left, blur_length - shadow.x());
+    top = std::max(top, blur_length - shadow.y());
+    right = std::max(right, blur_length + shadow.x());
+    bottom = std::max(bottom, blur_length + shadow.y());
+  }
+
+  return Insets(top, left, bottom, right);
+}
+
+}  // namespace
+
+ShadowValue ShadowValue::Scale(float scale) const {
+  Vector2d scaled_offset = ToFlooredVector2d(ScaleVector2d(offset_, scale));
+  return ShadowValue(scaled_offset, blur_ * scale, color_);
+}
+
+std::string ShadowValue::ToString() const {
+  return base::StringPrintf(
+      "(%d,%d),%.2f,rgba(%d,%d,%d,%d)",
+      offset_.x(), offset_.y(),
+      blur_,
+      SkColorGetR(color_),
+      SkColorGetG(color_),
+      SkColorGetB(color_),
+      SkColorGetA(color_));
+}
+
+// static
+Insets ShadowValue::GetMargin(const ShadowValues& shadows) {
+  Insets margins = GetInsets(shadows, false);
+  return -margins;
+}
+
+// static
+Insets ShadowValue::GetBlurRegion(const ShadowValues& shadows) {
+  return GetInsets(shadows, true);
+}
+
+// static
+ShadowValues ShadowValue::MakeShadowValues(int elevation,
+                                           SkColor key_shadow_color,
+                                           SkColor ambient_shadow_color) {
+  // Refresh uses hand-tweaked shadows corresponding to a small set of
+  // elevations. Use the Refresh spec and designer input to add missing shadow
+  // values.
+
+  // To match the CSS notion of blur (spread outside the bounding box) to the
+  // Skia notion of blur (spread outside and inside the bounding box), we have
+  // to double the designer-provided blur values.
+  const int kBlurCorrection = 2;
+
+  switch (elevation) {
+    case 3: {
+      ShadowValue key = {Vector2d(0, 1), 12, key_shadow_color};
+      ShadowValue ambient = {Vector2d(0, 4), 64, ambient_shadow_color};
+      return {key, ambient};
+    }
+    case 16: {
+      ShadowValue key = {Vector2d(0, 0), kBlurCorrection * 16,
+                         key_shadow_color};
+      ShadowValue ambient = {Vector2d(0, 12), kBlurCorrection * 16,
+                             ambient_shadow_color};
+      return {key, ambient};
+    }
+    default:
+      // This surface has not been updated for Refresh. Fall back to the
+      // deprecated style.
+      DCHECK_EQ(key_shadow_color, ambient_shadow_color);
+      return MakeMdShadowValues(elevation, key_shadow_color);
+  }
+}
+
+// static
+ShadowValues ShadowValue::MakeMdShadowValues(int elevation, SkColor color) {
+  ShadowValues shadow_values;
+  // To match the CSS notion of blur (spread outside the bounding box) to the
+  // Skia notion of blur (spread outside and inside the bounding box), we have
+  // to double the designer-provided blur values.
+  const int kBlurCorrection = 2;
+  // "Key shadow": y offset is elevation and blur is twice the elevation.
+  shadow_values.emplace_back(Vector2d(0, elevation),
+                             kBlurCorrection * elevation * 2,
+                             SkColorSetA(color, 0x3d));
+  // "Ambient shadow": no offset and blur matches the elevation.
+  shadow_values.emplace_back(Vector2d(), kBlurCorrection * elevation,
+                             SkColorSetA(color, 0x1f));
+  // To see what this looks like for elevation 24, try this CSS:
+  //   box-shadow: 0 24px 48px rgba(0, 0, 0, .24),
+  //               0 0 24px rgba(0, 0, 0, .12);
+  return shadow_values;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/shadow_value.h b/ui/gfx/shadow_value.h
new file mode 100644
index 0000000..fdb8175
--- /dev/null
+++ b/ui/gfx/shadow_value.h
@@ -0,0 +1,88 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SHADOW_VALUE_H_
+#define UI_GFX_SHADOW_VALUE_H_
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class Insets;
+
+class ShadowValue;
+typedef std::vector<ShadowValue> ShadowValues;
+
+// ShadowValue encapsulates parameters needed to define a shadow, including the
+// shadow's offset, blur amount and color.
+class GFX_EXPORT ShadowValue {
+ public:
+  constexpr ShadowValue() = default;
+  constexpr ShadowValue(const gfx::Vector2d& offset, double blur, SkColor color)
+      : offset_(offset), blur_(blur), color_(color) {}
+
+  constexpr int x() const { return offset_.x(); }
+  constexpr int y() const { return offset_.y(); }
+  constexpr const gfx::Vector2d& offset() const { return offset_; }
+  constexpr double blur() const { return blur_; }
+  constexpr SkColor color() const { return color_; }
+
+  constexpr bool operator==(const ShadowValue& other) const {
+    return offset_ == other.offset_ && blur_ == other.blur_ &&
+           color_ == other.color_;
+  }
+
+  ShadowValue Scale(float scale) const;
+
+  std::string ToString() const;
+
+  // Gets margin space needed for shadows. Note that values in returned Insets
+  // are negative because shadow margins are outside a boundary.
+  static Insets GetMargin(const ShadowValues& shadows);
+
+  // Gets the area inside a rectangle that would be affected by shadow blur.
+  // This is similar to the margin except it's positive (the blur region is
+  // inside a hypothetical rectangle) and it accounts for the blur both inside
+  // and outside the bounding box. The region inside the "blur region" would be
+  // a uniform color.
+  static Insets GetBlurRegion(const ShadowValues& shadows);
+
+  // Makes ShadowValues for the given elevation and color. Calls to
+  // MakeShadowValues that expect to fallback to MakeMdShadowValues should pass
+  // in the same base color for |key_shadow_color| and |ambient_shadow_color|
+  // until MakeMdShadowValues is refactored to remove SkColorSetA calls and also
+  // take in its own |key_shadow_color| and |ambient_shadow_color|.
+  // TODO(elainechien): crbug.com/1056950.
+  static ShadowValues MakeShadowValues(int elevation,
+                                       SkColor key_shadow_color,
+                                       SkColor ambient_shadow_color);
+  // Makes ShadowValues for MD shadows. This style is deprecated.
+  static ShadowValues MakeMdShadowValues(int elevation,
+                                         SkColor color = SK_ColorBLACK);
+
+ private:
+  gfx::Vector2d offset_;
+
+  // Blur amount of the shadow in pixels. If underlying implementation supports
+  // (e.g. Skia), it can have fraction part such as 0.5 pixel. The value
+  // defines a range from full shadow color at the start point inside the
+  // shadow to fully transparent at the end point outside it. The range is
+  // perpendicular to and centered on the shadow edge. For example, a blur
+  // amount of 4.0 means to have a blurry shadow edge of 4 pixels that
+  // transitions from full shadow color to fully transparent and with 2 pixels
+  // inside the shadow and 2 pixels goes beyond the edge.
+  double blur_ = 0.;
+
+  SkColor color_ = SK_ColorTRANSPARENT;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SHADOW_VALUE_H_
diff --git a/ui/gfx/shadow_value_unittest.cc b/ui/gfx/shadow_value_unittest.cc
new file mode 100644
index 0000000..713b473
--- /dev/null
+++ b/ui/gfx/shadow_value_unittest.cc
@@ -0,0 +1,70 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+
+#include "base/cxx17_backports.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/shadow_value.h"
+
+namespace gfx {
+
+TEST(ShadowValueTest, GetMargin) {
+  constexpr struct TestCase {
+    Insets expected_margin;
+    size_t shadow_count;
+    ShadowValue shadows[2];
+  } kTestCases[] = {
+      {
+          Insets(), 0, {},
+      },
+      {
+          Insets(-2, -2, -2, -2),
+          1,
+          {
+              {gfx::Vector2d(0, 0), 4, 0},
+          },
+      },
+      {
+          Insets(0, -1, -4, -3),
+          1,
+          {
+              {gfx::Vector2d(1, 2), 4, 0},
+          },
+      },
+      {
+          Insets(-4, -3, 0, -1),
+          1,
+          {
+              {gfx::Vector2d(-1, -2), 4, 0},
+          },
+      },
+      {
+          Insets(0, -1, -5, -4),
+          2,
+          {
+              {gfx::Vector2d(1, 2), 4, 0}, {gfx::Vector2d(2, 3), 4, 0},
+          },
+      },
+      {
+          Insets(-4, -3, -5, -4),
+          2,
+          {
+              {gfx::Vector2d(-1, -2), 4, 0}, {gfx::Vector2d(2, 3), 4, 0},
+          },
+      },
+  };
+
+  for (size_t i = 0; i < base::size(kTestCases); ++i) {
+    Insets margin = ShadowValue::GetMargin(
+        ShadowValues(kTestCases[i].shadows,
+                     kTestCases[i].shadows + kTestCases[i].shadow_count));
+
+    EXPECT_EQ(kTestCases[i].expected_margin, margin) << " i=" << i;
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/skbitmap_operations.cc b/ui/gfx/skbitmap_operations.cc
new file mode 100644
index 0000000..9bcbd2e
--- /dev/null
+++ b/ui/gfx/skbitmap_operations.cc
@@ -0,0 +1,781 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/skbitmap_operations.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <algorithm>
+
+#include "base/check_op.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColorFilter.h"
+#include "third_party/skia/include/core/SkColorPriv.h"
+#include "third_party/skia/include/core/SkUnPreMultiply.h"
+#include "third_party/skia/include/effects/SkImageFilters.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/size.h"
+
+static bool IsUninitializedBitmap(const SkBitmap& bitmap) {
+  return bitmap.isNull() && bitmap.colorType() == kUnknown_SkColorType &&
+         bitmap.alphaType() == kUnknown_SkAlphaType;
+}
+
+// static
+SkBitmap SkBitmapOperations::CreateInvertedBitmap(const SkBitmap& image) {
+  if (IsUninitializedBitmap(image))
+    return image;
+  CHECK_EQ(image.colorType(), kN32_SkColorType);
+
+  SkBitmap inverted;
+  inverted.allocN32Pixels(image.width(), image.height());
+
+  for (int y = 0; y < image.height(); ++y) {
+    uint32_t* image_row = image.getAddr32(0, y);
+    uint32_t* dst_row = inverted.getAddr32(0, y);
+
+    for (int x = 0; x < image.width(); ++x) {
+      uint32_t image_pixel = image_row[x];
+      dst_row[x] = (image_pixel & 0xFF000000) |
+                   (0x00FFFFFF - (image_pixel & 0x00FFFFFF));
+    }
+  }
+
+  return inverted;
+}
+
+// static
+SkBitmap SkBitmapOperations::CreateBlendedBitmap(const SkBitmap& first,
+                                                 const SkBitmap& second,
+                                                 double alpha) {
+  DCHECK((alpha >= 0) && (alpha <= 1));
+  CHECK_EQ(first.width(), second.width());
+  CHECK_EQ(first.height(), second.height());
+  CHECK_EQ(first.colorType(), kN32_SkColorType);
+  CHECK_EQ(second.colorType(), kN32_SkColorType);
+
+  // Optimize for case where we won't need to blend anything.
+  static const double alpha_min = 1.0 / 255;
+  static const double alpha_max = 254.0 / 255;
+  if (alpha < alpha_min)
+    return first;
+  else if (alpha > alpha_max)
+    return second;
+
+  SkBitmap blended;
+  blended.allocN32Pixels(first.width(), first.height());
+
+  double first_alpha = 1 - alpha;
+
+  for (int y = 0; y < first.height(); ++y) {
+    uint32_t* first_row = first.getAddr32(0, y);
+    uint32_t* second_row = second.getAddr32(0, y);
+    uint32_t* dst_row = blended.getAddr32(0, y);
+
+    for (int x = 0; x < first.width(); ++x) {
+      uint32_t first_pixel = first_row[x];
+      uint32_t second_pixel = second_row[x];
+
+      int a = static_cast<int>((SkColorGetA(first_pixel) * first_alpha) +
+                               (SkColorGetA(second_pixel) * alpha));
+      int r = static_cast<int>((SkColorGetR(first_pixel) * first_alpha) +
+                               (SkColorGetR(second_pixel) * alpha));
+      int g = static_cast<int>((SkColorGetG(first_pixel) * first_alpha) +
+                               (SkColorGetG(second_pixel) * alpha));
+      int b = static_cast<int>((SkColorGetB(first_pixel) * first_alpha) +
+                               (SkColorGetB(second_pixel) * alpha));
+
+      dst_row[x] = SkColorSetARGB(a, r, g, b);
+    }
+  }
+
+  return blended;
+}
+
+// static
+SkBitmap SkBitmapOperations::CreateMaskedBitmap(const SkBitmap& rgb,
+                                                const SkBitmap& alpha) {
+  CHECK_EQ(rgb.width(), alpha.width());
+  CHECK_EQ(rgb.height(), alpha.height());
+  CHECK_EQ(rgb.colorType(), kN32_SkColorType);
+  CHECK_EQ(alpha.colorType(), kN32_SkColorType);
+
+  SkBitmap masked;
+  masked.allocN32Pixels(rgb.width(), rgb.height());
+
+  for (int y = 0; y < masked.height(); ++y) {
+    uint32_t* rgb_row = rgb.getAddr32(0, y);
+    uint32_t* alpha_row = alpha.getAddr32(0, y);
+    uint32_t* dst_row = masked.getAddr32(0, y);
+
+    for (int x = 0; x < masked.width(); ++x) {
+      unsigned alpha32 = SkGetPackedA32(alpha_row[x]);
+      unsigned scale = SkAlpha255To256(alpha32);
+      dst_row[x] = SkAlphaMulQ(rgb_row[x], scale);
+    }
+  }
+
+  return masked;
+}
+
+// static
+SkBitmap SkBitmapOperations::CreateButtonBackground(SkColor color,
+                                                    const SkBitmap& image,
+                                                    const SkBitmap& mask) {
+  CHECK_EQ(image.colorType(), kN32_SkColorType);
+  CHECK_EQ(mask.colorType(), kN32_SkColorType);
+
+  SkBitmap background;
+  background.allocN32Pixels(mask.width(), mask.height());
+
+  double bg_a = SkColorGetA(color);
+  double bg_r = SkColorGetR(color) * (bg_a / 255.0);
+  double bg_g = SkColorGetG(color) * (bg_a / 255.0);
+  double bg_b = SkColorGetB(color) * (bg_a / 255.0);
+
+  for (int y = 0; y < mask.height(); ++y) {
+    uint32_t* dst_row = background.getAddr32(0, y);
+    uint32_t* image_row = image.getAddr32(0, y % image.height());
+    uint32_t* mask_row = mask.getAddr32(0, y);
+
+    for (int x = 0; x < mask.width(); ++x) {
+      uint32_t image_pixel = image_row[x % image.width()];
+
+      double img_a = SkColorGetA(image_pixel);
+      double img_r = SkColorGetR(image_pixel);
+      double img_g = SkColorGetG(image_pixel);
+      double img_b = SkColorGetB(image_pixel);
+
+      double img_alpha = img_a / 255.0;
+      double img_inv = 1 - img_alpha;
+
+      double mask_a = static_cast<double>(SkColorGetA(mask_row[x])) / 255.0;
+
+      dst_row[x] = SkColorSetARGB(
+          // This is pretty weird; why not the usual SrcOver alpha?
+          static_cast<int>(std::min(255.0, bg_a + img_a) * mask_a),
+          static_cast<int>(((bg_r * img_inv) + (img_r * img_alpha)) * mask_a),
+          static_cast<int>(((bg_g * img_inv) + (img_g * img_alpha)) * mask_a),
+          static_cast<int>(((bg_b * img_inv) + (img_b * img_alpha)) * mask_a));
+    }
+  }
+
+  return background;
+}
+
+namespace {
+namespace HSLShift {
+
+// TODO(viettrungluu): Some things have yet to be optimized at all.
+
+// Notes on and conventions used in the following code
+//
+// Conventions:
+//  - R, G, B, A = obvious; as variables: |r|, |g|, |b|, |a| (see also below)
+//  - H, S, L = obvious; as variables: |h|, |s|, |l| (see also below)
+//  - variables derived from S, L shift parameters: |sdec| and |sinc| for S
+//    increase and decrease factors, |ldec| and |linc| for L (see also below)
+//
+// To try to optimize HSL shifts, we do several things:
+//  - Avoid unpremultiplying (then processing) then premultiplying. This means
+//    that R, G, B values (and also L, but not H and S) should be treated as
+//    having a range of 0..A (where A is alpha).
+//  - Do things in integer/fixed-point. This avoids costly conversions between
+//    floating-point and integer, though I should study the tradeoff more
+//    carefully (presumably, at some point of processing complexity, converting
+//    and processing using simpler floating-point code will begin to win in
+//    performance). Also to be studied is the speed/type of floating point
+//    conversions; see, e.g., <http://www.stereopsis.com/sree/fpu2006.html>.
+//
+// Conventions for fixed-point arithmetic
+//  - Each function has a constant denominator (called |den|, which should be a
+//    power of 2), appropriate for the computations done in that function.
+//  - A value |x| is then typically represented by a numerator, named |x_num|,
+//    so that its actual value is |x_num / den| (casting to floating-point
+//    before division).
+//  - To obtain |x_num| from |x|, simply multiply by |den|, i.e., |x_num = x *
+//    den| (casting appropriately).
+//  - When necessary, a value |x| may also be represented as a numerator over
+//    the denominator squared (set |den2 = den * den|). In such a case, the
+//    corresponding variable is called |x_num2| (so that its actual value is
+//    |x_num^2 / den2|.
+//  - The representation of the product of |x| and |y| is be called |x_y_num| if
+//    |x * y == x_y_num / den|, and |xy_num2| if |x * y == x_y_num2 / den2|. In
+//    the latter case, notice that one can calculate |x_y_num2 = x_num * y_num|.
+
+// Routine used to process a line; typically specialized for specific kinds of
+// HSL shifts (to optimize).
+typedef void (*LineProcessor)(const color_utils::HSL&,
+                              const SkPMColor*,
+                              SkPMColor*,
+                              int width);
+
+enum OperationOnH { kOpHNone = 0, kOpHShift, kNumHOps };
+enum OperationOnS { kOpSNone = 0, kOpSDec, kOpSInc, kNumSOps };
+enum OperationOnL { kOpLNone = 0, kOpLDec, kOpLInc, kNumLOps };
+
+// Epsilon used to judge when shift values are close enough to various critical
+// values (typically 0.5, which yields a no-op for S and L shifts. 1/256 should
+// be small enough, but let's play it safe>
+const double epsilon = 0.0005;
+
+// Line processor: default/universal (i.e., old-school).
+void LineProcDefault(const color_utils::HSL& hsl_shift,
+                     const SkPMColor* in,
+                     SkPMColor* out,
+                     int width) {
+  for (int x = 0; x < width; x++) {
+    out[x] = SkPreMultiplyColor(color_utils::HSLShift(
+        SkUnPreMultiply::PMColorToColor(in[x]), hsl_shift));
+  }
+}
+
+// Line processor: no-op (i.e., copy).
+void LineProcCopy(const color_utils::HSL& hsl_shift,
+                  const SkPMColor* in,
+                  SkPMColor* out,
+                  int width) {
+  DCHECK(hsl_shift.h < 0);
+  DCHECK(hsl_shift.s < 0 || fabs(hsl_shift.s - 0.5) < HSLShift::epsilon);
+  DCHECK(hsl_shift.l < 0 || fabs(hsl_shift.l - 0.5) < HSLShift::epsilon);
+  memcpy(out, in, static_cast<size_t>(width) * sizeof(out[0]));
+}
+
+// Line processor: H no-op, S no-op, L decrease.
+void LineProcHnopSnopLdec(const color_utils::HSL& hsl_shift,
+                          const SkPMColor* in,
+                          SkPMColor* out,
+                          int width) {
+  const uint32_t den = 65536;
+
+  DCHECK(hsl_shift.h < 0);
+  DCHECK(hsl_shift.s < 0 || fabs(hsl_shift.s - 0.5) < HSLShift::epsilon);
+  DCHECK(hsl_shift.l <= 0.5 - HSLShift::epsilon && hsl_shift.l >= 0);
+
+  uint32_t ldec_num = static_cast<uint32_t>(hsl_shift.l * 2 * den);
+  for (int x = 0; x < width; x++) {
+    uint32_t a = SkGetPackedA32(in[x]);
+    uint32_t r = SkGetPackedR32(in[x]);
+    uint32_t g = SkGetPackedG32(in[x]);
+    uint32_t b = SkGetPackedB32(in[x]);
+    r = r * ldec_num / den;
+    g = g * ldec_num / den;
+    b = b * ldec_num / den;
+    out[x] = SkPackARGB32(a, r, g, b);
+  }
+}
+
+// Line processor: H no-op, S no-op, L increase.
+void LineProcHnopSnopLinc(const color_utils::HSL& hsl_shift,
+                          const SkPMColor* in,
+                          SkPMColor* out,
+                          int width) {
+  const uint32_t den = 65536;
+
+  DCHECK(hsl_shift.h < 0);
+  DCHECK(hsl_shift.s < 0 || fabs(hsl_shift.s - 0.5) < HSLShift::epsilon);
+  DCHECK(hsl_shift.l >= 0.5 + HSLShift::epsilon && hsl_shift.l <= 1);
+
+  uint32_t linc_num = static_cast<uint32_t>((hsl_shift.l - 0.5) * 2 * den);
+  for (int x = 0; x < width; x++) {
+    uint32_t a = SkGetPackedA32(in[x]);
+    uint32_t r = SkGetPackedR32(in[x]);
+    uint32_t g = SkGetPackedG32(in[x]);
+    uint32_t b = SkGetPackedB32(in[x]);
+    r += (a - r) * linc_num / den;
+    g += (a - g) * linc_num / den;
+    b += (a - b) * linc_num / den;
+    out[x] = SkPackARGB32(a, r, g, b);
+  }
+}
+
+// Saturation changes modifications in RGB
+//
+// (Note that as a further complication, the values we deal in are
+// premultiplied, so R/G/B values must be in the range 0..A. For mathematical
+// purposes, one may as well use r=R/A, g=G/A, b=B/A. Without loss of
+// generality, assume that R/G/B values are in the range 0..1.)
+//
+// Let Max = max(R,G,B), Min = min(R,G,B), and Med be the median value. Then L =
+// (Max+Min)/2. If L is to remain constant, Max+Min must also remain constant.
+//
+// For H to remain constant, first, the (numerical) order of R/G/B (from
+// smallest to largest) must remain the same. Second, all the ratios
+// (R-G)/(Max-Min), (R-B)/(Max-Min), (G-B)/(Max-Min) must remain constant (of
+// course, if Max = Min, then S = 0 and no saturation change is well-defined,
+// since H is not well-defined).
+//
+// Let C_max be a colour with value Max, C_min be one with value Min, and C_med
+// the remaining colour. Increasing saturation (to the maximum) is accomplished
+// by increasing the value of C_max while simultaneously decreasing C_min and
+// changing C_med so that the ratios are maintained; for the latter, it suffices
+// to keep (C_med-C_min)/(C_max-C_min) constant (and equal to
+// (Med-Min)/(Max-Min)).
+
+// Line processor: H no-op, S decrease, L no-op.
+void LineProcHnopSdecLnop(const color_utils::HSL& hsl_shift,
+                          const SkPMColor* in,
+                          SkPMColor* out,
+                          int width) {
+  DCHECK(hsl_shift.h < 0);
+  DCHECK(hsl_shift.s >= 0 && hsl_shift.s <= 0.5 - HSLShift::epsilon);
+  DCHECK(hsl_shift.l < 0 || fabs(hsl_shift.l - 0.5) < HSLShift::epsilon);
+
+  const int32_t denom = 65536;
+  int32_t s_numer = static_cast<int32_t>(hsl_shift.s * 2 * denom);
+  for (int x = 0; x < width; x++) {
+    int32_t a = static_cast<int32_t>(SkGetPackedA32(in[x]));
+    int32_t r = static_cast<int32_t>(SkGetPackedR32(in[x]));
+    int32_t g = static_cast<int32_t>(SkGetPackedG32(in[x]));
+    int32_t b = static_cast<int32_t>(SkGetPackedB32(in[x]));
+
+    int32_t vmax, vmin;
+    if (r > g) {  // This uses 3 compares rather than 4.
+      vmax = std::max(r, b);
+      vmin = std::min(g, b);
+    } else {
+      vmax = std::max(g, b);
+      vmin = std::min(r, b);
+    }
+
+    // Use denom * L to avoid rounding.
+    int32_t denom_l = (vmax + vmin) * (denom / 2);
+    int32_t s_numer_l = (vmax + vmin) * s_numer / 2;
+
+    r = (denom_l + r * s_numer - s_numer_l) / denom;
+    g = (denom_l + g * s_numer - s_numer_l) / denom;
+    b = (denom_l + b * s_numer - s_numer_l) / denom;
+    out[x] = SkPackARGB32(a, r, g, b);
+  }
+}
+
+// Line processor: H no-op, S decrease, L decrease.
+void LineProcHnopSdecLdec(const color_utils::HSL& hsl_shift,
+                          const SkPMColor* in,
+                          SkPMColor* out,
+                          int width) {
+  DCHECK(hsl_shift.h < 0);
+  DCHECK(hsl_shift.s >= 0 && hsl_shift.s <= 0.5 - HSLShift::epsilon);
+  DCHECK(hsl_shift.l >= 0 && hsl_shift.l <= 0.5 - HSLShift::epsilon);
+
+  // Can't be too big since we need room for denom*denom and a bit for sign.
+  const int32_t denom = 1024;
+  int32_t l_numer = static_cast<int32_t>(hsl_shift.l * 2 * denom);
+  int32_t s_numer = static_cast<int32_t>(hsl_shift.s * 2 * denom);
+  for (int x = 0; x < width; x++) {
+    int32_t a = static_cast<int32_t>(SkGetPackedA32(in[x]));
+    int32_t r = static_cast<int32_t>(SkGetPackedR32(in[x]));
+    int32_t g = static_cast<int32_t>(SkGetPackedG32(in[x]));
+    int32_t b = static_cast<int32_t>(SkGetPackedB32(in[x]));
+
+    int32_t vmax, vmin;
+    if (r > g) {  // This uses 3 compares rather than 4.
+      vmax = std::max(r, b);
+      vmin = std::min(g, b);
+    } else {
+      vmax = std::max(g, b);
+      vmin = std::min(r, b);
+    }
+
+    // Use denom * L to avoid rounding.
+    int32_t denom_l = (vmax + vmin) * (denom / 2);
+    int32_t s_numer_l = (vmax + vmin) * s_numer / 2;
+
+    r = (denom_l + r * s_numer - s_numer_l) * l_numer / (denom * denom);
+    g = (denom_l + g * s_numer - s_numer_l) * l_numer / (denom * denom);
+    b = (denom_l + b * s_numer - s_numer_l) * l_numer / (denom * denom);
+    out[x] = SkPackARGB32(a, r, g, b);
+  }
+}
+
+// Line processor: H no-op, S decrease, L increase.
+void LineProcHnopSdecLinc(const color_utils::HSL& hsl_shift,
+                          const SkPMColor* in,
+                          SkPMColor* out,
+                          int width) {
+  DCHECK(hsl_shift.h < 0);
+  DCHECK(hsl_shift.s >= 0 && hsl_shift.s <= 0.5 - HSLShift::epsilon);
+  DCHECK(hsl_shift.l >= 0.5 + HSLShift::epsilon && hsl_shift.l <= 1);
+
+  // Can't be too big since we need room for denom*denom and a bit for sign.
+  const int32_t denom = 1024;
+  int32_t l_numer = static_cast<int32_t>((hsl_shift.l - 0.5) * 2 * denom);
+  int32_t s_numer = static_cast<int32_t>(hsl_shift.s * 2 * denom);
+  for (int x = 0; x < width; x++) {
+    int32_t a = static_cast<int32_t>(SkGetPackedA32(in[x]));
+    int32_t r = static_cast<int32_t>(SkGetPackedR32(in[x]));
+    int32_t g = static_cast<int32_t>(SkGetPackedG32(in[x]));
+    int32_t b = static_cast<int32_t>(SkGetPackedB32(in[x]));
+
+    int32_t vmax, vmin;
+    if (r > g) {  // This uses 3 compares rather than 4.
+      vmax = std::max(r, b);
+      vmin = std::min(g, b);
+    } else {
+      vmax = std::max(g, b);
+      vmin = std::min(r, b);
+    }
+
+    // Use denom * L to avoid rounding.
+    int32_t denom_l = (vmax + vmin) * (denom / 2);
+    int32_t s_numer_l = (vmax + vmin) * s_numer / 2;
+
+    r = denom_l + r * s_numer - s_numer_l;
+    g = denom_l + g * s_numer - s_numer_l;
+    b = denom_l + b * s_numer - s_numer_l;
+
+    r = (r * denom + (a * denom - r) * l_numer) / (denom * denom);
+    g = (g * denom + (a * denom - g) * l_numer) / (denom * denom);
+    b = (b * denom + (a * denom - b) * l_numer) / (denom * denom);
+    out[x] = SkPackARGB32(a, r, g, b);
+  }
+}
+
+const LineProcessor kLineProcessors[kNumHOps][kNumSOps][kNumLOps] = {
+  { // H: kOpHNone
+    { // S: kOpSNone
+      LineProcCopy,         // L: kOpLNone
+      LineProcHnopSnopLdec, // L: kOpLDec
+      LineProcHnopSnopLinc  // L: kOpLInc
+    },
+    { // S: kOpSDec
+      LineProcHnopSdecLnop, // L: kOpLNone
+      LineProcHnopSdecLdec, // L: kOpLDec
+      LineProcHnopSdecLinc  // L: kOpLInc
+    },
+    { // S: kOpSInc
+      LineProcDefault, // L: kOpLNone
+      LineProcDefault, // L: kOpLDec
+      LineProcDefault  // L: kOpLInc
+    }
+  },
+  { // H: kOpHShift
+    { // S: kOpSNone
+      LineProcDefault, // L: kOpLNone
+      LineProcDefault, // L: kOpLDec
+      LineProcDefault  // L: kOpLInc
+    },
+    { // S: kOpSDec
+      LineProcDefault, // L: kOpLNone
+      LineProcDefault, // L: kOpLDec
+      LineProcDefault  // L: kOpLInc
+    },
+    { // S: kOpSInc
+      LineProcDefault, // L: kOpLNone
+      LineProcDefault, // L: kOpLDec
+      LineProcDefault  // L: kOpLInc
+    }
+  }
+};
+
+}  // namespace HSLShift
+}  // namespace
+
+// static
+SkBitmap SkBitmapOperations::CreateHSLShiftedBitmap(
+    const SkBitmap& bitmap,
+    const color_utils::HSL& hsl_shift) {
+  if (IsUninitializedBitmap(bitmap))
+    return bitmap;
+  CHECK_EQ(bitmap.colorType(), kN32_SkColorType);
+
+  // Default to NOPs.
+  HSLShift::OperationOnH H_op = HSLShift::kOpHNone;
+  HSLShift::OperationOnS S_op = HSLShift::kOpSNone;
+  HSLShift::OperationOnL L_op = HSLShift::kOpLNone;
+
+  if (hsl_shift.h >= 0 && hsl_shift.h <= 1)
+    H_op = HSLShift::kOpHShift;
+
+  // Saturation shift: 0 -> fully desaturate, 0.5 -> NOP, 1 -> fully saturate.
+  if (hsl_shift.s >= 0 && hsl_shift.s <= (0.5 - HSLShift::epsilon))
+    S_op = HSLShift::kOpSDec;
+  else if (hsl_shift.s >= (0.5 + HSLShift::epsilon))
+    S_op = HSLShift::kOpSInc;
+
+  // Lightness shift: 0 -> black, 0.5 -> NOP, 1 -> white.
+  if (hsl_shift.l >= 0 && hsl_shift.l <= (0.5 - HSLShift::epsilon))
+    L_op = HSLShift::kOpLDec;
+  else if (hsl_shift.l >= (0.5 + HSLShift::epsilon))
+    L_op = HSLShift::kOpLInc;
+
+  HSLShift::LineProcessor line_proc =
+      HSLShift::kLineProcessors[H_op][S_op][L_op];
+
+  DCHECK(bitmap.empty() == false);
+  DCHECK(bitmap.colorType() == kN32_SkColorType);
+
+  SkBitmap shifted;
+  shifted.allocN32Pixels(bitmap.width(), bitmap.height());
+
+  // Loop through the pixels of the original bitmap.
+  for (int y = 0; y < bitmap.height(); ++y) {
+    SkPMColor* pixels = bitmap.getAddr32(0, y);
+    SkPMColor* tinted_pixels = shifted.getAddr32(0, y);
+
+    (*line_proc)(hsl_shift, pixels, tinted_pixels, bitmap.width());
+  }
+
+  return shifted;
+}
+
+// static
+SkBitmap SkBitmapOperations::CreateTiledBitmap(const SkBitmap& source,
+                                               int src_x, int src_y,
+                                               int dst_w, int dst_h) {
+  CHECK_EQ(source.colorType(), kN32_SkColorType);
+
+  SkBitmap cropped;
+  cropped.allocN32Pixels(dst_w, dst_h);
+
+  // Loop through the pixels of the original bitmap.
+  for (int y = 0; y < dst_h; ++y) {
+    int y_pix = (src_y + y) % source.height();
+    while (y_pix < 0)
+      y_pix += source.height();
+
+    uint32_t* source_row = source.getAddr32(0, y_pix);
+    uint32_t* dst_row = cropped.getAddr32(0, y);
+
+    for (int x = 0; x < dst_w; ++x) {
+      int x_pix = (src_x + x) % source.width();
+      while (x_pix < 0)
+        x_pix += source.width();
+
+      dst_row[x] = source_row[x_pix];
+    }
+  }
+
+  return cropped;
+}
+
+// static
+SkBitmap SkBitmapOperations::DownsampleByTwoUntilSize(const SkBitmap& bitmap,
+                                                      int min_w, int min_h) {
+  if ((bitmap.width() <= min_w) || (bitmap.height() <= min_h) ||
+      (min_w < 0) || (min_h < 0))
+    return bitmap;
+
+  // Since bitmaps are refcounted, this copy will be fast.
+  SkBitmap current = bitmap;
+  while ((current.width() >= min_w * 2) && (current.height() >= min_h * 2) &&
+         (current.width() > 1) && (current.height() > 1))
+    current = DownsampleByTwo(current);
+  return current;
+}
+
+// static
+SkBitmap SkBitmapOperations::DownsampleByTwo(const SkBitmap& bitmap) {
+  if (IsUninitializedBitmap(bitmap))
+    return bitmap;
+  CHECK_EQ(bitmap.colorType(), kN32_SkColorType);
+
+  // Handle the nop case.
+  if ((bitmap.width() <= 1) || (bitmap.height() <= 1))
+    return bitmap;
+
+  SkBitmap result;
+  result.allocN32Pixels((bitmap.width() + 1) / 2, (bitmap.height() + 1) / 2);
+
+  const int resultLastX = result.width() - 1;
+  const int srcLastX = bitmap.width() - 1;
+
+  for (int dest_y = 0; dest_y < result.height(); ++dest_y) {
+    const int src_y = dest_y << 1;
+    const SkPMColor* SK_RESTRICT cur_src0 = bitmap.getAddr32(0, src_y);
+    const SkPMColor* SK_RESTRICT cur_src1 = cur_src0;
+    if (src_y + 1 < bitmap.height())
+      cur_src1 = bitmap.getAddr32(0, src_y + 1);
+
+    SkPMColor* SK_RESTRICT cur_dst = result.getAddr32(0, dest_y);
+
+    for (int dest_x = 0; dest_x <= resultLastX; ++dest_x) {
+      // This code is based on downsampleby2_proc32 in SkBitmap.cpp. It is very
+      // clever in that it does two channels at once: alpha and green ("ag")
+      // and red and blue ("rb"). Each channel gets averaged across 4 pixels
+      // to get the result.
+      int bump_x = (dest_x << 1) < srcLastX;
+      SkPMColor tmp, ag, rb;
+
+      // Top left pixel of the 2x2 block.
+      tmp = cur_src0[0];
+      ag = (tmp >> 8) & 0xFF00FF;
+      rb = tmp & 0xFF00FF;
+
+      // Top right pixel of the 2x2 block.
+      tmp = cur_src0[bump_x];
+      ag += (tmp >> 8) & 0xFF00FF;
+      rb += tmp & 0xFF00FF;
+
+      // Bottom left pixel of the 2x2 block.
+      tmp = cur_src1[0];
+      ag += (tmp >> 8) & 0xFF00FF;
+      rb += tmp & 0xFF00FF;
+
+      // Bottom right pixel of the 2x2 block.
+      tmp = cur_src1[bump_x];
+      ag += (tmp >> 8) & 0xFF00FF;
+      rb += tmp & 0xFF00FF;
+
+      // Put the channels back together, dividing each by 4 to get the average.
+      // |ag| has the alpha and green channels shifted right by 8 bits from
+      // there they should end up, so shifting left by 6 gives them in the
+      // correct position divided by 4.
+      *cur_dst++ = ((rb >> 2) & 0xFF00FF) | ((ag << 6) & 0xFF00FF00);
+
+      cur_src0 += 2;
+      cur_src1 += 2;
+    }
+  }
+
+  return result;
+}
+
+// static
+SkBitmap SkBitmapOperations::UnPreMultiply(const SkBitmap& bitmap) {
+  if (IsUninitializedBitmap(bitmap))
+    return bitmap;
+  CHECK_EQ(bitmap.colorType(), kN32_SkColorType);
+
+  if (bitmap.alphaType() != kPremul_SkAlphaType)
+    return bitmap;
+
+  const SkImageInfo& opaque_info =
+      bitmap.info().makeAlphaType(kUnpremul_SkAlphaType);
+  SkBitmap opaque_bitmap;
+  opaque_bitmap.allocPixels(opaque_info);
+
+  for (int y = 0; y < opaque_bitmap.height(); y++) {
+    for (int x = 0; x < opaque_bitmap.width(); x++) {
+      uint32_t src_pixel = *bitmap.getAddr32(x, y);
+      uint32_t* dst_pixel = opaque_bitmap.getAddr32(x, y);
+      SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(src_pixel);
+      *dst_pixel = unmultiplied;
+    }
+  }
+
+  return opaque_bitmap;
+}
+
+// static
+SkBitmap SkBitmapOperations::CreateTransposedBitmap(const SkBitmap& image) {
+  if (IsUninitializedBitmap(image))
+    return image;
+  CHECK_EQ(image.colorType(), kN32_SkColorType);
+
+  SkBitmap transposed;
+  transposed.allocN32Pixels(image.height(), image.width());
+
+  for (int y = 0; y < image.height(); ++y) {
+    uint32_t* image_row = image.getAddr32(0, y);
+    for (int x = 0; x < image.width(); ++x) {
+      uint32_t* dst = transposed.getAddr32(y, x);
+      *dst = image_row[x];
+    }
+  }
+
+  return transposed;
+}
+
+// static
+SkBitmap SkBitmapOperations::CreateColorMask(const SkBitmap& bitmap,
+                                             SkColor c) {
+  CHECK_EQ(bitmap.colorType(), kN32_SkColorType);
+
+  SkBitmap color_mask;
+  color_mask.allocN32Pixels(bitmap.width(), bitmap.height());
+  color_mask.eraseARGB(0, 0, 0, 0);
+
+  SkCanvas canvas(color_mask, SkSurfaceProps{});
+
+  SkPaint paint;
+  paint.setColorFilter(SkColorFilters::Blend(c, SkBlendMode::kSrcIn));
+  canvas.drawImage(bitmap.asImage(), 0, 0, SkSamplingOptions(), &paint);
+  return color_mask;
+}
+
+// static
+SkBitmap SkBitmapOperations::CreateDropShadow(
+    const SkBitmap& bitmap,
+    const gfx::ShadowValues& shadows) {
+  CHECK_EQ(bitmap.colorType(), kN32_SkColorType);
+
+  // Shadow margin insets are negative values because they grow outside.
+  // Negate them here as grow direction is not important and only pixel value
+  // is of interest here.
+  gfx::Insets shadow_margin = -gfx::ShadowValue::GetMargin(shadows);
+
+  SkBitmap image_with_shadow;
+  image_with_shadow.allocN32Pixels(bitmap.width() + shadow_margin.width(),
+                                   bitmap.height() + shadow_margin.height());
+  image_with_shadow.eraseARGB(0, 0, 0, 0);
+
+  SkCanvas canvas(image_with_shadow, SkSurfaceProps{});
+  canvas.translate(SkIntToScalar(shadow_margin.left()),
+                   SkIntToScalar(shadow_margin.top()));
+
+  SkPaint paint;
+  for (size_t i = 0; i < shadows.size(); ++i) {
+    const gfx::ShadowValue& shadow = shadows[i];
+    SkBitmap shadow_image = SkBitmapOperations::CreateColorMask(bitmap,
+                                                                shadow.color());
+
+    // The blur is halved to produce a shadow that correctly fits within the
+    // |shadow_margin|.
+    SkScalar sigma = SkDoubleToScalar(shadow.blur() / 2);
+    paint.setImageFilter(SkImageFilters::Blur(sigma, sigma, nullptr));
+
+    canvas.saveLayer(0, &paint);
+    canvas.drawImage(shadow_image.asImage(), SkIntToScalar(shadow.x()),
+                     SkIntToScalar(shadow.y()));
+    canvas.restore();
+  }
+
+  canvas.drawImage(bitmap.asImage(), 0, 0);
+  return image_with_shadow;
+}
+
+// static
+SkBitmap SkBitmapOperations::Rotate(const SkBitmap& source,
+                                    RotationAmount rotation) {
+  if (IsUninitializedBitmap(source))
+    return source;
+  CHECK_EQ(source.colorType(), kN32_SkColorType);
+  // SkCanvas::drawBitmap() fails silently with unpremultiplied SkBitmap.
+  DCHECK_NE(source.info().alphaType(), kUnpremul_SkAlphaType);
+
+  SkBitmap result;
+  SkScalar angle = SkFloatToScalar(0.0f);
+
+  switch (rotation) {
+   case ROTATION_90_CW:
+     angle = SkFloatToScalar(90.0f);
+     result.allocN32Pixels(source.height(), source.width());
+     break;
+   case ROTATION_180_CW:
+     angle = SkFloatToScalar(180.0f);
+     result.allocN32Pixels(source.width(), source.height());
+     break;
+   case ROTATION_270_CW:
+     angle = SkFloatToScalar(270.0f);
+     result.allocN32Pixels(source.height(), source.width());
+     break;
+  }
+
+  SkCanvas canvas(result, SkSurfaceProps{});
+  canvas.clear(SkColorSetARGB(0, 0, 0, 0));
+
+  canvas.translate(SkFloatToScalar(result.width() * 0.5f),
+                   SkFloatToScalar(result.height() * 0.5f));
+  canvas.rotate(angle);
+  canvas.translate(-SkFloatToScalar(source.width() * 0.5f),
+                   -SkFloatToScalar(source.height() * 0.5f));
+  canvas.drawImage(source.asImage(), 0, 0);
+  canvas.flush();
+
+  return result;
+}
diff --git a/ui/gfx/skbitmap_operations.h b/ui/gfx/skbitmap_operations.h
new file mode 100644
index 0000000..4e7e641
--- /dev/null
+++ b/ui/gfx/skbitmap_operations.h
@@ -0,0 +1,119 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SKBITMAP_OPERATIONS_H_
+#define UI_GFX_SKBITMAP_OPERATIONS_H_
+
+#include "base/gtest_prod_util.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/shadow_value.h"
+
+class SkBitmap;
+
+class GFX_EXPORT SkBitmapOperations {
+ public:
+  // Enum for use in rotating images (must be in 90 degree increments),
+  // see: Rotate.
+  enum RotationAmount {
+    ROTATION_90_CW,
+    ROTATION_180_CW,
+    ROTATION_270_CW,
+  };
+
+  // Create a bitmap that is an inverted image of the passed in image.
+  // Each color becomes its inverse in the color wheel. So (255, 15, 0) becomes
+  // (0, 240, 255). The alpha value is not inverted.
+  static SkBitmap CreateInvertedBitmap(const SkBitmap& image);
+
+  // Create a bitmap that is a blend of two others. The alpha argument
+  // specifies the opacity of the second bitmap. The provided bitmaps must
+  // use have the kARGB_8888_Config config and be of equal dimensions.
+  static SkBitmap CreateBlendedBitmap(const SkBitmap& first,
+                                      const SkBitmap& second,
+                                      double alpha);
+
+  // Create a bitmap that is the original bitmap masked out by the mask defined
+  // in the alpha bitmap. The images must use the kARGB_8888_Config config and
+  // be of equal dimensions.
+  static SkBitmap CreateMaskedBitmap(const SkBitmap& first,
+                                     const SkBitmap& alpha);
+
+  // We create a button background image by compositing the color and image
+  // together, then applying the mask. This is a highly specialized composite
+  // operation that is the equivalent of drawing a background in |color|,
+  // tiling |image| over the top, and then masking the result out with |mask|.
+  // The images must use kARGB_8888_Config config.
+  static SkBitmap CreateButtonBackground(SkColor color,
+                                         const SkBitmap& image,
+                                         const SkBitmap& mask);
+
+  // Shift a bitmap's HSL values. The shift values are in the range of 0-1,
+  // with the option to specify -1 for 'no change'. The shift values are
+  // defined as:
+  // hsl_shift[0] (hue): The absolute hue value for the image - 0 and 1 map
+  //    to 0 and 360 on the hue color wheel (red).
+  // hsl_shift[1] (saturation): A saturation shift for the image, with the
+  //    following key values:
+  //    0 = remove all color.
+  //    0.5 = leave unchanged.
+  //    1 = fully saturate the image.
+  // hsl_shift[2] (lightness): A lightness shift for the image, with the
+  //    following key values:
+  //    0 = remove all lightness (make all pixels black).
+  //    0.5 = leave unchanged.
+  //    1 = full lightness (make all pixels white).
+  static SkBitmap CreateHSLShiftedBitmap(const SkBitmap& bitmap,
+                                         const color_utils::HSL& hsl_shift);
+
+  // Create a bitmap that is cropped from another bitmap. This is special
+  // because it tiles the original bitmap, so your coordinates can extend
+  // outside the bounds of the original image.
+  static SkBitmap CreateTiledBitmap(const SkBitmap& bitmap,
+                                    int src_x, int src_y,
+                                    int dst_w, int dst_h);
+
+  // Iteratively downsamples by 2 until the bitmap is no smaller than the
+  // input size. The normal use of this is to downsample the bitmap "close" to
+  // the final size, and then use traditional resampling on the result.
+  // Because the bitmap will be closer to the final size, it will be faster,
+  // and linear interpolation will generally work well as a second step.
+  static SkBitmap DownsampleByTwoUntilSize(const SkBitmap& bitmap,
+                                           int min_w, int min_h);
+
+  // Makes a bitmap half has large in each direction by averaging groups of
+  // 4 pixels. This is one step in generating a mipmap.
+  static SkBitmap DownsampleByTwo(const SkBitmap& bitmap);
+
+  // Unpremultiplies all pixels in |bitmap|. You almost never want to call
+  // this, as |SkBitmap|s are always premultiplied by conversion. Call this
+  // only if you will pass the bitmap's data into a system function that
+  // doesn't expect premultiplied colors.
+  static SkBitmap UnPreMultiply(const SkBitmap& bitmap);
+
+  // Transpose the pixels in |bitmap| by swapping x and y.
+  static SkBitmap CreateTransposedBitmap(const SkBitmap& bitmap);
+
+  // Create a bitmap by combining alpha channel of |bitmap| and color |c|.
+  // The image must use the kARGB_8888_Config config.
+  static SkBitmap CreateColorMask(const SkBitmap& bitmap, SkColor c);
+
+  // Create a bitmap with drop shadow added to |bitmap|. |shadows| defines
+  // the shadows to add. The created bitmap would be padded to have enough space
+  // for shadows and have original bitmap in the center. The image must use the
+  // kARGB_8888_Config config.
+  static SkBitmap CreateDropShadow(const SkBitmap& bitmap,
+                                   const gfx::ShadowValues& shadows);
+
+  // Rotates the given source bitmap clockwise by the requested amount.
+  static SkBitmap Rotate(const SkBitmap& source, RotationAmount rotation);
+
+ private:
+  SkBitmapOperations();  // Class for scoping only.
+
+  FRIEND_TEST_ALL_PREFIXES(SkBitmapOperationsTest, DownsampleByTwo);
+  FRIEND_TEST_ALL_PREFIXES(SkBitmapOperationsTest, DownsampleByTwoSmall);
+};
+
+#endif  // UI_GFX_SKBITMAP_OPERATIONS_H_
diff --git a/ui/gfx/skbitmap_operations_unittest.cc b/ui/gfx/skbitmap_operations_unittest.cc
new file mode 100644
index 0000000..a0be6ed
--- /dev/null
+++ b/ui/gfx/skbitmap_operations_unittest.cc
@@ -0,0 +1,561 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/skbitmap_operations.h"
+
+#include <stdint.h>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColorPriv.h"
+#include "third_party/skia/include/core/SkRect.h"
+#include "third_party/skia/include/core/SkRegion.h"
+#include "third_party/skia/include/core/SkUnPreMultiply.h"
+
+namespace {
+
+// Returns true if each channel of the given two colors are "close." This is
+// used for comparing colors where rounding errors may cause off-by-one.
+inline bool ColorsClose(uint32_t a, uint32_t b) {
+  return abs(static_cast<int>(SkColorGetB(a) - SkColorGetB(b))) <= 2 &&
+         abs(static_cast<int>(SkColorGetG(a) - SkColorGetG(b))) <= 2 &&
+         abs(static_cast<int>(SkColorGetR(a) - SkColorGetR(b))) <= 2 &&
+         abs(static_cast<int>(SkColorGetA(a) - SkColorGetA(b))) <= 2;
+}
+
+inline bool MultipliedColorsClose(uint32_t a, uint32_t b) {
+  return ColorsClose(SkUnPreMultiply::PMColorToColor(a),
+                     SkUnPreMultiply::PMColorToColor(b));
+}
+
+bool BitmapsClose(const SkBitmap& a, const SkBitmap& b) {
+  for (int y = 0; y < a.height(); y++) {
+    for (int x = 0; x < a.width(); x++) {
+      SkColor a_pixel = *a.getAddr32(x, y);
+      SkColor b_pixel = *b.getAddr32(x, y);
+      if (!ColorsClose(a_pixel, b_pixel))
+        return false;
+    }
+  }
+  return true;
+}
+
+void FillDataToBitmap(int w, int h, SkBitmap* bmp) {
+  bmp->allocN32Pixels(w, h);
+
+  unsigned char* src_data =
+      reinterpret_cast<unsigned char*>(bmp->getAddr32(0, 0));
+  for (int i = 0; i < w * h; i++) {
+    const int alpha = i % 256;
+    src_data[i * 4 + 0] = static_cast<unsigned char>(alpha);
+    src_data[i * 4 + 1] = static_cast<unsigned char>((i + 16) % (alpha + 1));
+    src_data[i * 4 + 2] = static_cast<unsigned char>((i + 32) % (alpha + 1));
+    src_data[i * 4 + 3] = static_cast<unsigned char>((i + 64) % (alpha + 1));
+  }
+}
+
+// The reference (i.e., old) implementation of |CreateHSLShiftedBitmap()|.
+SkBitmap ReferenceCreateHSLShiftedBitmap(
+    const SkBitmap& bitmap,
+    color_utils::HSL hsl_shift) {
+  SkBitmap shifted;
+  shifted.allocN32Pixels(bitmap.width(), bitmap.height());
+  shifted.eraseARGB(0, 0, 0, 0);
+
+  // Loop through the pixels of the original bitmap.
+  for (int y = 0; y < bitmap.height(); ++y) {
+    SkPMColor* pixels = bitmap.getAddr32(0, y);
+    SkPMColor* tinted_pixels = shifted.getAddr32(0, y);
+
+    for (int x = 0; x < bitmap.width(); ++x) {
+      tinted_pixels[x] = SkPreMultiplyColor(color_utils::HSLShift(
+          SkUnPreMultiply::PMColorToColor(pixels[x]), hsl_shift));
+    }
+  }
+
+  return shifted;
+}
+
+}  // namespace
+
+// Invert bitmap and verify the each pixel is inverted and the alpha value is
+// not changed.
+TEST(SkBitmapOperationsTest, CreateInvertedBitmap) {
+  int src_w = 16, src_h = 16;
+  SkBitmap src;
+  src.allocN32Pixels(src_w, src_h);
+
+  for (int y = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      int i = y * src_w + x;
+      *src.getAddr32(x, y) =
+          SkColorSetARGB((255 - i) % 255, i % 255, i * 4 % 255, 0);
+    }
+  }
+
+  SkBitmap inverted = SkBitmapOperations::CreateInvertedBitmap(src);
+
+  for (int y = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      int i = y * src_w + x;
+      EXPECT_EQ(static_cast<unsigned int>((255 - i) % 255),
+                SkColorGetA(*inverted.getAddr32(x, y)));
+      EXPECT_EQ(static_cast<unsigned int>(255 - (i % 255)),
+                SkColorGetR(*inverted.getAddr32(x, y)));
+      EXPECT_EQ(static_cast<unsigned int>(255 - (i * 4 % 255)),
+                SkColorGetG(*inverted.getAddr32(x, y)));
+      EXPECT_EQ(static_cast<unsigned int>(255),
+                SkColorGetB(*inverted.getAddr32(x, y)));
+    }
+  }
+}
+
+// Blend two bitmaps together at 50% alpha and verify that the result
+// is the middle-blend of the two.
+TEST(SkBitmapOperationsTest, CreateBlendedBitmap) {
+  int src_w = 16, src_h = 16;
+  SkBitmap src_a;
+  src_a.allocN32Pixels(src_w, src_h);
+
+  SkBitmap src_b;
+  src_b.allocN32Pixels(src_w, src_h);
+
+  for (int y = 0, i = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      *src_a.getAddr32(x, y) = SkColorSetARGB(255, 0, i * 2 % 255, i % 255);
+      *src_b.getAddr32(x, y) =
+          SkColorSetARGB((255 - i) % 255, i % 255, i * 4 % 255, 0);
+      i++;
+    }
+  }
+
+  // Shift to red.
+  SkBitmap blended = SkBitmapOperations::CreateBlendedBitmap(
+    src_a, src_b, 0.5);
+
+  for (int y = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      int i = y * src_w + x;
+      EXPECT_EQ(static_cast<unsigned int>((255 + ((255 - i) % 255)) / 2),
+                SkColorGetA(*blended.getAddr32(x, y)));
+      EXPECT_EQ(static_cast<unsigned int>(i % 255 / 2),
+                SkColorGetR(*blended.getAddr32(x, y)));
+      EXPECT_EQ((static_cast<unsigned int>((i * 2) % 255 + (i * 4) % 255) / 2),
+                SkColorGetG(*blended.getAddr32(x, y)));
+      EXPECT_EQ(static_cast<unsigned int>(i % 255 / 2),
+                SkColorGetB(*blended.getAddr32(x, y)));
+    }
+  }
+}
+
+// Test our masking functions.
+TEST(SkBitmapOperationsTest, CreateMaskedBitmap) {
+  const int src_w = 16, src_h = 16;
+
+  SkBitmap src;
+  FillDataToBitmap(src_w, src_h, &src);
+
+  SkBitmap alpha;
+  alpha.allocN32Pixels(src_w, src_h);
+  for (int y = 0, i = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      *alpha.getAddr32(x, y) = SkPackARGB32(i % 256, 0, 0, 0);
+      i++;
+    }
+  }
+
+  SkBitmap masked = SkBitmapOperations::CreateMaskedBitmap(src, alpha);
+
+  for (int y = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      int alpha_pixel = *alpha.getAddr32(x, y);
+      int src_pixel = *src.getAddr32(x, y);
+      int masked_pixel = *masked.getAddr32(x, y);
+
+      int scale = SkAlpha255To256(SkGetPackedA32(alpha_pixel));
+
+      int src_a = (src_pixel >> SK_A32_SHIFT) & 0xFF;
+      int src_r = (src_pixel >> SK_R32_SHIFT) & 0xFF;
+      int src_g = (src_pixel >> SK_G32_SHIFT) & 0xFF;
+      int src_b = (src_pixel >> SK_B32_SHIFT) & 0xFF;
+
+      int masked_a = (masked_pixel >> SK_A32_SHIFT) & 0xFF;
+      int masked_r = (masked_pixel >> SK_R32_SHIFT) & 0xFF;
+      int masked_g = (masked_pixel >> SK_G32_SHIFT) & 0xFF;
+      int masked_b = (masked_pixel >> SK_B32_SHIFT) & 0xFF;
+
+      EXPECT_EQ((src_a * scale) >> 8, masked_a);
+      EXPECT_EQ((src_r * scale) >> 8, masked_r);
+      EXPECT_EQ((src_g * scale) >> 8, masked_g);
+      EXPECT_EQ((src_b * scale) >> 8, masked_b);
+    }
+  }
+}
+
+// Make sure that when shifting a bitmap without any shift parameters,
+// the end result is close enough to the original (rounding errors
+// notwithstanding).
+TEST(SkBitmapOperationsTest, CreateHSLShiftedBitmapToSame) {
+  int src_w = 16, src_h = 16;
+  SkBitmap src;
+  src.allocN32Pixels(src_w, src_h);
+
+  for (int y = 0, i = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      *src.getAddr32(x, y) = SkPreMultiplyColor(SkColorSetARGB((i + 128) % 255,
+          (i + 128) % 255, (i + 64) % 255, (i + 0) % 255));
+      i++;
+    }
+  }
+
+  color_utils::HSL hsl = { -1, -1, -1 };
+  SkBitmap shifted = ReferenceCreateHSLShiftedBitmap(src, hsl);
+
+  for (int y = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      SkColor src_pixel = *src.getAddr32(x, y);
+      SkColor shifted_pixel = *shifted.getAddr32(x, y);
+      EXPECT_TRUE(MultipliedColorsClose(src_pixel, shifted_pixel)) <<
+          "source: (a,r,g,b) = (" << SkColorGetA(src_pixel) << "," <<
+                                     SkColorGetR(src_pixel) << "," <<
+                                     SkColorGetG(src_pixel) << "," <<
+                                     SkColorGetB(src_pixel) << "); " <<
+          "shifted: (a,r,g,b) = (" << SkColorGetA(shifted_pixel) << "," <<
+                                     SkColorGetR(shifted_pixel) << "," <<
+                                     SkColorGetG(shifted_pixel) << "," <<
+                                     SkColorGetB(shifted_pixel) << ")";
+    }
+  }
+}
+
+// Shift a blue bitmap to red.
+TEST(SkBitmapOperationsTest, CreateHSLShiftedBitmapHueOnly) {
+  int src_w = 16, src_h = 16;
+  SkBitmap src;
+  src.allocN32Pixels(src_w, src_h);
+
+  for (int y = 0, i = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      *src.getAddr32(x, y) = SkColorSetARGB(255, 0, 0, i % 255);
+      i++;
+    }
+  }
+
+  // Shift to red.
+  color_utils::HSL hsl = { 0, -1, -1 };
+
+  SkBitmap shifted = SkBitmapOperations::CreateHSLShiftedBitmap(src, hsl);
+
+  for (int y = 0, i = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      EXPECT_TRUE(ColorsClose(shifted.getColor(x, y),
+                              SkColorSetARGB(255, i % 255, 0, 0)));
+      i++;
+    }
+  }
+}
+
+// Validate HSL shift.
+TEST(SkBitmapOperationsTest, ValidateHSLShift) {
+  // Note: 255/51 = 5 (exactly) => 6 including 0!
+  const int inc = 51;
+  const int dim = 255 / inc + 1;
+  SkBitmap src;
+  src.allocN32Pixels(dim*dim, dim*dim);
+
+  for (int a = 0, y = 0; a <= 255; a += inc) {
+    for (int r = 0; r <= 255; r += inc, y++) {
+      for (int g = 0, x = 0; g <= 255; g += inc) {
+        for (int b = 0; b <= 255; b+= inc, x++) {
+          *src.getAddr32(x, y) =
+              SkPreMultiplyColor(SkColorSetARGB(a, r, g, b));
+        }
+      }
+    }
+  }
+
+  // Shhhh. The spec says I should set things to -1 for "no change", but
+  // actually -0.1 will do. Don't tell anyone I did this.
+  for (double h = -0.1; h <= 1.0001; h += 0.1) {
+    for (double s = -0.1; s <= 1.0001; s += 0.1) {
+      for (double l = -0.1; l <= 1.0001; l += 0.1) {
+        color_utils::HSL hsl = { h, s, l };
+        SkBitmap ref_shifted = ReferenceCreateHSLShiftedBitmap(src, hsl);
+        SkBitmap shifted = SkBitmapOperations::CreateHSLShiftedBitmap(src, hsl);
+        EXPECT_TRUE(BitmapsClose(ref_shifted, shifted))
+            << "h = " << h << ", s = " << s << ", l = " << l;
+      }
+    }
+  }
+}
+
+// Test our cropping.
+TEST(SkBitmapOperationsTest, CreateCroppedBitmap) {
+  int src_w = 16, src_h = 16;
+  SkBitmap src;
+  FillDataToBitmap(src_w, src_h, &src);
+
+  SkBitmap cropped = SkBitmapOperations::CreateTiledBitmap(src, 4, 4,
+                                                              8, 8);
+  ASSERT_EQ(8, cropped.width());
+  ASSERT_EQ(8, cropped.height());
+
+  for (int y = 4; y < 12; y++) {
+    for (int x = 4; x < 12; x++) {
+      EXPECT_EQ(*src.getAddr32(x, y),
+                *cropped.getAddr32(x - 4, y - 4));
+    }
+  }
+}
+
+// Test whether our cropping correctly wraps across image boundaries.
+TEST(SkBitmapOperationsTest, CreateCroppedBitmapWrapping) {
+  int src_w = 16, src_h = 16;
+  SkBitmap src;
+  FillDataToBitmap(src_w, src_h, &src);
+
+  SkBitmap cropped = SkBitmapOperations::CreateTiledBitmap(
+      src, src_w / 2, src_h / 2, src_w, src_h);
+  ASSERT_EQ(src_w, cropped.width());
+  ASSERT_EQ(src_h, cropped.height());
+
+  for (int y = 0; y < src_h; y++) {
+    for (int x = 0; x < src_w; x++) {
+      EXPECT_EQ(*src.getAddr32(x, y),
+                *cropped.getAddr32((x + src_w / 2) % src_w,
+                                   (y + src_h / 2) % src_h));
+    }
+  }
+}
+
+TEST(SkBitmapOperationsTest, DownsampleByTwo) {
+  // Use an odd-sized bitmap to make sure the edge cases where there isn't a
+  // 2x2 block of pixels is handled correctly.
+  // Here's the ARGB example
+  //
+  //    50% transparent green             opaque 50% blue           white
+  //        80008000                         FF000080              FFFFFFFF
+  //
+  //    50% transparent red               opaque 50% gray           black
+  //        80800000                         80808080              FF000000
+  //
+  //         black                            white                50% gray
+  //        FF000000                         FFFFFFFF              FF808080
+  //
+  // The result of this computation should be:
+  //        A0404040  FF808080
+  //        FF808080  FF808080
+  SkBitmap input;
+  input.allocN32Pixels(3, 3);
+
+  // The color order may be different, but we don't care (the channels are
+  // trated the same).
+  *input.getAddr32(0, 0) = 0x80008000;
+  *input.getAddr32(1, 0) = 0xFF000080;
+  *input.getAddr32(2, 0) = 0xFFFFFFFF;
+  *input.getAddr32(0, 1) = 0x80800000;
+  *input.getAddr32(1, 1) = 0x80808080;
+  *input.getAddr32(2, 1) = 0xFF000000;
+  *input.getAddr32(0, 2) = 0xFF000000;
+  *input.getAddr32(1, 2) = 0xFFFFFFFF;
+  *input.getAddr32(2, 2) = 0xFF808080;
+
+  SkBitmap result = SkBitmapOperations::DownsampleByTwo(input);
+  EXPECT_EQ(2, result.width());
+  EXPECT_EQ(2, result.height());
+
+  // Some of the values are off-by-one due to rounding.
+  EXPECT_EQ(0x9f404040, *result.getAddr32(0, 0));
+  EXPECT_EQ(0xFF7f7f7f, *result.getAddr32(1, 0));
+  EXPECT_EQ(0xFF7f7f7f, *result.getAddr32(0, 1));
+  EXPECT_EQ(0xFF808080, *result.getAddr32(1, 1));
+}
+
+// Test edge cases for DownsampleByTwo.
+TEST(SkBitmapOperationsTest, DownsampleByTwoSmall) {
+  SkPMColor reference = 0xFF4080FF;
+
+  // Test a 1x1 bitmap.
+  SkBitmap one_by_one;
+  one_by_one.allocN32Pixels(1, 1);
+  *one_by_one.getAddr32(0, 0) = reference;
+  SkBitmap result = SkBitmapOperations::DownsampleByTwo(one_by_one);
+  EXPECT_EQ(1, result.width());
+  EXPECT_EQ(1, result.height());
+  EXPECT_EQ(reference, *result.getAddr32(0, 0));
+
+  // Test an n by 1 bitmap.
+  SkBitmap one_by_n;
+  one_by_n.allocN32Pixels(300, 1);
+  result = SkBitmapOperations::DownsampleByTwo(one_by_n);
+  EXPECT_EQ(300, result.width());
+  EXPECT_EQ(1, result.height());
+
+  // Test a 1 by n bitmap.
+  SkBitmap n_by_one;
+  n_by_one.allocN32Pixels(1, 300);
+  result = SkBitmapOperations::DownsampleByTwo(n_by_one);
+  EXPECT_EQ(1, result.width());
+  EXPECT_EQ(300, result.height());
+
+  // Test an empty bitmap
+  SkBitmap empty;
+  result = SkBitmapOperations::DownsampleByTwo(empty);
+  EXPECT_TRUE(result.isNull());
+  EXPECT_EQ(0, result.width());
+  EXPECT_EQ(0, result.height());
+}
+
+// Here we assume DownsampleByTwo works correctly (it's tested above) and
+// just make sure that the wrapper function does the right thing.
+TEST(SkBitmapOperationsTest, DownsampleByTwoUntilSize) {
+  // First make sure a "too small" bitmap doesn't get modified at all.
+  SkBitmap too_small;
+  too_small.allocN32Pixels(10, 10);
+  SkBitmap result = SkBitmapOperations::DownsampleByTwoUntilSize(
+      too_small, 16, 16);
+  EXPECT_EQ(10, result.width());
+  EXPECT_EQ(10, result.height());
+
+  // Now make sure giving it a 0x0 target returns something reasonable.
+  result = SkBitmapOperations::DownsampleByTwoUntilSize(too_small, 0, 0);
+  EXPECT_EQ(1, result.width());
+  EXPECT_EQ(1, result.height());
+
+  // Test multiple steps of downsampling.
+  SkBitmap large;
+  large.allocN32Pixels(100, 43);
+  result = SkBitmapOperations::DownsampleByTwoUntilSize(large, 6, 6);
+
+  // The result should be divided in half 100x43 -> 50x22 -> 25x11
+  EXPECT_EQ(25, result.width());
+  EXPECT_EQ(11, result.height());
+}
+
+TEST(SkBitmapOperationsTest, UnPreMultiply) {
+  SkBitmap input;
+  input.allocN32Pixels(2, 2);
+  EXPECT_EQ(input.alphaType(), kPremul_SkAlphaType);
+
+  // Set PMColors into the bitmap
+  *input.getAddr32(0, 0) = SkPackARGB32NoCheck(0x80, 0x00, 0x00, 0x00);
+  *input.getAddr32(1, 0) = SkPackARGB32NoCheck(0x80, 0x80, 0x80, 0x80);
+  *input.getAddr32(0, 1) = SkPackARGB32NoCheck(0xFF, 0x00, 0xCC, 0x88);
+  *input.getAddr32(1, 1) = SkPackARGB32NoCheck(0x00, 0x00, 0xCC, 0x88);
+
+  SkBitmap result = SkBitmapOperations::UnPreMultiply(input);
+  EXPECT_EQ(result.alphaType(), kUnpremul_SkAlphaType);
+  EXPECT_EQ(2, result.width());
+  EXPECT_EQ(2, result.height());
+  EXPECT_NE(result.getPixels(), input.getPixels());
+
+  EXPECT_EQ(0x80000000, *result.getAddr32(0, 0));
+  EXPECT_EQ(0x80FFFFFF, *result.getAddr32(1, 0));
+  EXPECT_EQ(0xFF00CC88, *result.getAddr32(0, 1));
+  EXPECT_EQ(0x00000000u, *result.getAddr32(1, 1));  // "Division by zero".
+}
+
+TEST(SkBitmapOperationsTest, UnPreMultiplyOpaque) {
+  SkBitmap input;
+  input.allocN32Pixels(2, 2, true);
+  EXPECT_EQ(input.alphaType(), kOpaque_SkAlphaType);
+
+  SkBitmap result = SkBitmapOperations::UnPreMultiply(input);
+  EXPECT_EQ(result.alphaType(), kOpaque_SkAlphaType);
+  EXPECT_EQ(result.getPixels(), input.getPixels());
+}
+
+TEST(SkBitmapOperationsTest, UnPreMultiplyAlreadyUnPreMultiplied) {
+  SkBitmap input;
+  input.allocN32Pixels(2, 2);
+  input.setAlphaType(kUnpremul_SkAlphaType);
+  EXPECT_EQ(input.alphaType(), kUnpremul_SkAlphaType);
+
+  SkBitmap result = SkBitmapOperations::UnPreMultiply(input);
+  EXPECT_EQ(result.alphaType(), kUnpremul_SkAlphaType);
+  EXPECT_EQ(result.getPixels(), input.getPixels());
+}
+
+TEST(SkBitmapOperationsTest, CreateTransposedBitmap) {
+  SkBitmap input;
+  input.allocN32Pixels(2, 3);
+
+  for (int x = 0; x < input.width(); ++x) {
+    for (int y = 0; y < input.height(); ++y) {
+      *input.getAddr32(x, y) = x * input.width() + y;
+    }
+  }
+
+  SkBitmap result = SkBitmapOperations::CreateTransposedBitmap(input);
+  EXPECT_EQ(3, result.width());
+  EXPECT_EQ(2, result.height());
+
+  for (int x = 0; x < input.width(); ++x) {
+    for (int y = 0; y < input.height(); ++y) {
+      EXPECT_EQ(*input.getAddr32(x, y), *result.getAddr32(y, x));
+    }
+  }
+}
+
+void DrawRectWithColor(SkCanvas* canvas,
+                       int left,
+                       int top,
+                       int right,
+                       int bottom,
+                       SkColor color) {
+  SkPaint paint;
+  paint.setColor(color);
+  paint.setBlendMode(SkBlendMode::kSrc);
+  canvas->drawRect(
+      SkRect::MakeLTRB(SkIntToScalar(left), SkIntToScalar(top),
+                       SkIntToScalar(right), SkIntToScalar(bottom)),
+      paint);
+}
+
+// Check that Rotate provides the desired results
+TEST(SkBitmapOperationsTest, RotateImage) {
+  const int src_w = 6, src_h = 4;
+  SkBitmap src;
+  // Create a simple 4 color bitmap:
+  // RRRBBB
+  // RRRBBB
+  // GGGYYY
+  // GGGYYY
+  src.allocN32Pixels(src_w, src_h);
+
+  SkCanvas canvas(src, SkSurfaceProps{});
+  src.eraseARGB(0, 0, 0, 0);
+
+  // This region is a semi-transparent red to test non-opaque pixels.
+  DrawRectWithColor(&canvas, 0, 0, src_w / 2, src_h / 2, 0x1FFF0000);
+  DrawRectWithColor(&canvas, src_w / 2, 0, src_w, src_h / 2, SK_ColorBLUE);
+  DrawRectWithColor(&canvas, 0, src_h / 2, src_w / 2, src_h, SK_ColorGREEN);
+  DrawRectWithColor(&canvas, src_w / 2, src_h / 2, src_w, src_h,
+                    SK_ColorYELLOW);
+
+  SkBitmap rotate90, rotate180, rotate270;
+  rotate90 = SkBitmapOperations::Rotate(src,
+                                        SkBitmapOperations::ROTATION_90_CW);
+  rotate180 = SkBitmapOperations::Rotate(src,
+                                         SkBitmapOperations::ROTATION_180_CW);
+  rotate270 = SkBitmapOperations::Rotate(src,
+                                         SkBitmapOperations::ROTATION_270_CW);
+
+  ASSERT_EQ(rotate90.width(), src.height());
+  ASSERT_EQ(rotate90.height(), src.width());
+  ASSERT_EQ(rotate180.width(), src.width());
+  ASSERT_EQ(rotate180.height(), src.height());
+  ASSERT_EQ(rotate270.width(), src.height());
+  ASSERT_EQ(rotate270.height(), src.width());
+
+  for (int x=0; x < src_w; ++x) {
+    for (int y=0; y < src_h; ++y) {
+      ASSERT_EQ(*src.getAddr32(x,y), *rotate90.getAddr32(src_h - (y+1),x));
+      ASSERT_EQ(*src.getAddr32(x,y), *rotate270.getAddr32(y, src_w - (x+1)));
+      ASSERT_EQ(*src.getAddr32(x,y),
+                *rotate180.getAddr32(src_w - (x+1), src_h - (y+1)));
+    }
+  }
+}
diff --git a/ui/gfx/skia_color_space_util.cc b/ui/gfx/skia_color_space_util.cc
new file mode 100644
index 0000000..87d372d
--- /dev/null
+++ b/ui/gfx/skia_color_space_util.cc
@@ -0,0 +1,96 @@
+// Copyright 2017 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.
+
+#include "ui/gfx/skia_color_space_util.h"
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+#include "base/cxx17_backports.h"
+
+namespace gfx {
+
+float SkTransferFnEvalUnclamped(const skcms_TransferFunction& fn, float x) {
+  if (x < fn.d)
+    return fn.c * x + fn.f;
+  return std::pow(fn.a * x + fn.b, fn.g) + fn.e;
+}
+
+float SkTransferFnEval(const skcms_TransferFunction& fn, float x) {
+  float fn_at_x_unclamped = SkTransferFnEvalUnclamped(fn, x);
+  return base::clamp(fn_at_x_unclamped, 0.0f, 1.0f);
+}
+
+skcms_TransferFunction SkTransferFnInverse(const skcms_TransferFunction& fn) {
+  skcms_TransferFunction fn_inv = {0};
+  if (fn.a > 0 && fn.g > 0) {
+    double a_to_the_g = std::pow(fn.a, fn.g);
+    fn_inv.a = 1.f / a_to_the_g;
+    fn_inv.b = -fn.e / a_to_the_g;
+    fn_inv.g = 1.f / fn.g;
+  }
+  fn_inv.d = fn.c * fn.d + fn.f;
+  fn_inv.e = -fn.b / fn.a;
+  if (fn.c != 0) {
+    fn_inv.c = 1.f / fn.c;
+    fn_inv.f = -fn.f / fn.c;
+  }
+  return fn_inv;
+}
+
+skcms_TransferFunction SkTransferFnScaled(const skcms_TransferFunction& fn,
+                                          float scale) {
+  if (scale == 1.f)
+    return fn;
+  float scale_to_g_inv = std::pow(scale, 1.f / fn.g);
+  skcms_TransferFunction fn_scaled = {0};
+  fn_scaled.a = fn.a * scale_to_g_inv;
+  fn_scaled.b = fn.b * scale_to_g_inv;
+  fn_scaled.c = fn.c * scale;
+  fn_scaled.d = fn.d;
+  fn_scaled.e = fn.e * scale;
+  fn_scaled.f = fn.f * scale;
+  fn_scaled.g = fn.g;
+  return fn_scaled;
+}
+
+bool SkTransferFnsApproximatelyCancel(const skcms_TransferFunction& a,
+                                      const skcms_TransferFunction& b) {
+  const float kStep = 1.f / 8.f;
+  const float kEpsilon = 2.5f / 256.f;
+  for (float x = 0; x <= 1.f; x += kStep) {
+    float a_of_x = SkTransferFnEval(a, x);
+    float b_of_a_of_x = SkTransferFnEval(b, a_of_x);
+    if (std::abs(b_of_a_of_x - x) > kEpsilon)
+      return false;
+  }
+  return true;
+}
+
+bool SkTransferFnIsApproximatelyIdentity(const skcms_TransferFunction& a) {
+  const float kStep = 1.f / 8.f;
+  const float kEpsilon = 2.5f / 256.f;
+  for (float x = 0; x <= 1.f; x += kStep) {
+    float a_of_x = SkTransferFnEval(a, x);
+    if (std::abs(a_of_x - x) > kEpsilon)
+      return false;
+  }
+  return true;
+}
+
+bool SkMatrixIsApproximatelyIdentity(const skia::Matrix44& m) {
+  const float kEpsilon = 1.f / 256.f;
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      float identity_value = i == j ? 1 : 0;
+      float value = m.get(i, j);
+      if (std::abs(identity_value - value) > kEpsilon)
+        return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/skia_color_space_util.h b/ui/gfx/skia_color_space_util.h
new file mode 100644
index 0000000..0048eba
--- /dev/null
+++ b/ui/gfx/skia_color_space_util.h
@@ -0,0 +1,43 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SKIA_COLOR_SPACE_UTIL_H_
+#define UI_GFX_SKIA_COLOR_SPACE_UTIL_H_
+
+#include "skia/ext/skia_matrix_44.h"
+#include "third_party/skia/include/core/SkColorSpace.h"
+#include "third_party/skia/include/core/SkICC.h"
+#include "ui/gfx/color_space_export.h"
+
+namespace gfx {
+
+// Return the parameterized function in |fn|, evaluated at |x|. Note that this
+// will clamp output values to the range [0, 1].
+float COLOR_SPACE_EXPORT SkTransferFnEval(const skcms_TransferFunction& fn,
+                                          float x);
+
+// Return the parameterized function in |fn|, evaluated at |x|. This will not
+// clamp output values.
+float COLOR_SPACE_EXPORT
+SkTransferFnEvalUnclamped(const skcms_TransferFunction& fn, float x);
+
+skcms_TransferFunction COLOR_SPACE_EXPORT
+SkTransferFnInverse(const skcms_TransferFunction& fn);
+
+skcms_TransferFunction COLOR_SPACE_EXPORT
+SkTransferFnScaled(const skcms_TransferFunction& fn, float scale);
+
+bool COLOR_SPACE_EXPORT
+SkTransferFnsApproximatelyCancel(const skcms_TransferFunction& a,
+                                 const skcms_TransferFunction& b);
+
+bool COLOR_SPACE_EXPORT
+SkTransferFnIsApproximatelyIdentity(const skcms_TransferFunction& fn);
+
+bool COLOR_SPACE_EXPORT
+SkMatrixIsApproximatelyIdentity(const skia::Matrix44& m);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SKIA_COLOR_SPACE_UTIL_H_
diff --git a/ui/gfx/skia_font_delegate.cc b/ui/gfx/skia_font_delegate.cc
new file mode 100644
index 0000000..f7c24c5
--- /dev/null
+++ b/ui/gfx/skia_font_delegate.cc
@@ -0,0 +1,23 @@
+// 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.
+
+#include "ui/gfx/skia_font_delegate.h"
+
+namespace {
+
+gfx::SkiaFontDelegate* g_skia_font_delegate = 0;
+
+}  // namespace
+
+namespace gfx {
+
+void SkiaFontDelegate::SetInstance(SkiaFontDelegate* instance) {
+  g_skia_font_delegate = instance;
+}
+
+const SkiaFontDelegate* SkiaFontDelegate::instance() {
+  return g_skia_font_delegate;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/skia_font_delegate.h b/ui/gfx/skia_font_delegate.h
new file mode 100644
index 0000000..05636e9
--- /dev/null
+++ b/ui/gfx/skia_font_delegate.h
@@ -0,0 +1,48 @@
+// 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.
+
+#ifndef UI_GFX_SKIA_FONT_DELEGATE_H_
+#define UI_GFX_SKIA_FONT_DELEGATE_H_
+
+#include <memory>
+#include <string>
+
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Allows a Linux platform-specific overriding of font preferences.
+class GFX_EXPORT SkiaFontDelegate {
+ public:
+  virtual ~SkiaFontDelegate() {}
+
+  // Sets the dynamically loaded singleton that provides font preferences.
+  // This pointer is not owned, and if this method is called a second time,
+  // the first instance is not deleted.
+  static void SetInstance(SkiaFontDelegate* instance);
+
+  // Returns a SkiaFontDelegate instance for the toolkit used in
+  // the user's desktop environment.
+  //
+  // Can return NULL, in case no toolkit has been set. (For example, if we're
+  // running with the "--ash" flag.)
+  static const SkiaFontDelegate* instance();
+
+  // Returns the default font rendering settings.
+  virtual FontRenderParams GetDefaultFontRenderParams() const = 0;
+
+  // Returns details about the default UI font. |style_out| holds a bitfield of
+  // gfx::Font::Style values.
+  virtual void GetDefaultFontDescription(
+      std::string* family_out,
+      int* size_pixels_out,
+      int* style_out,
+      Font::Weight* weight_out,
+      FontRenderParams* params_out) const = 0;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SKIA_FONT_DELEGATE_H_
diff --git a/ui/gfx/skia_paint_util.cc b/ui/gfx/skia_paint_util.cc
new file mode 100644
index 0000000..7bc2d44
--- /dev/null
+++ b/ui/gfx/skia_paint_util.cc
@@ -0,0 +1,110 @@
+// Copyright (c) 2017 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.
+
+#include "ui/gfx/skia_paint_util.h"
+
+#include "cc/paint/paint_image_builder.h"
+#include "third_party/skia/include/core/SkColorFilter.h"
+#include "third_party/skia/include/core/SkMaskFilter.h"
+#include "third_party/skia/include/effects/SkGradientShader.h"
+#include "third_party/skia/include/effects/SkLayerDrawLooper.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+#include "ui/gfx/image/image_skia_rep.h"
+#include "ui/gfx/switches.h"
+
+namespace gfx {
+
+sk_sp<cc::PaintShader> CreateImageRepShader(const gfx::ImageSkiaRep& image_rep,
+                                            SkTileMode tile_mode_x,
+                                            SkTileMode tile_mode_y,
+                                            const SkMatrix& local_matrix) {
+  return CreateImageRepShaderForScale(image_rep, tile_mode_x, tile_mode_y,
+                                      local_matrix, image_rep.scale());
+}
+
+sk_sp<cc::PaintShader> CreateImageRepShaderForScale(
+    const gfx::ImageSkiaRep& image_rep,
+    SkTileMode tile_mode_x,
+    SkTileMode tile_mode_y,
+    const SkMatrix& local_matrix,
+    SkScalar scale) {
+  // Unscale matrix by |scale| such that the bitmap is drawn at the
+  // correct density.
+  // Convert skew and translation to pixel coordinates.
+  // Thus, for |bitmap_scale| = 2:
+  //   x scale = 2, x translation = 1 DIP,
+  // should be converted to
+  //   x scale = 1, x translation = 2 pixels.
+  SkMatrix shader_scale = local_matrix;
+  shader_scale.preScale(scale, scale);
+  shader_scale.setScaleX(local_matrix.getScaleX() / scale);
+  shader_scale.setScaleY(local_matrix.getScaleY() / scale);
+
+  // TODO(malaykeshav): The check for has_paint_image was only added here to
+  // prevent generating a paint record in tests. Tests need an instance of
+  // base::DiscardableMemoryAllocator to generate the PaintRecord. However most
+  // test suites don't have this set.
+  // https://crbug.com/891469
+  if (!image_rep.has_paint_image()) {
+    return cc::PaintShader::MakePaintRecord(
+        image_rep.GetPaintRecord(),
+        SkRect::MakeIWH(image_rep.pixel_width(), image_rep.pixel_height()),
+        tile_mode_x, tile_mode_y, &shader_scale);
+  } else {
+    return cc::PaintShader::MakeImage(image_rep.paint_image(), tile_mode_x,
+                                      tile_mode_y, &shader_scale);
+  }
+}
+
+sk_sp<cc::PaintShader> CreateGradientShader(const gfx::Point& start_point,
+                                            const gfx::Point& end_point,
+                                            SkColor start_color,
+                                            SkColor end_color) {
+  SkColor grad_colors[2] = {start_color, end_color};
+  SkPoint grad_points[2] = {gfx::PointToSkPoint(start_point),
+                            gfx::PointToSkPoint(end_point)};
+
+  return cc::PaintShader::MakeLinearGradient(grad_points, grad_colors, nullptr,
+                                             2, SkTileMode::kClamp);
+}
+
+// This is copied from
+// third_party/WebKit/Source/platform/graphics/skia/SkiaUtils.h
+static SkScalar RadiusToSigma(double radius) {
+  return radius > 0 ? SkDoubleToScalar(0.288675f * radius + 0.5f) : 0;
+}
+
+sk_sp<SkDrawLooper> CreateShadowDrawLooper(
+    const std::vector<ShadowValue>& shadows) {
+  if (shadows.empty())
+    return nullptr;
+
+  SkLayerDrawLooper::Builder looper_builder;
+
+  looper_builder.addLayer();  // top layer of the original.
+
+  SkLayerDrawLooper::LayerInfo layer_info;
+  layer_info.fPaintBits |= SkLayerDrawLooper::kMaskFilter_Bit;
+  layer_info.fPaintBits |= SkLayerDrawLooper::kColorFilter_Bit;
+  layer_info.fColorMode = SkBlendMode::kSrc;
+
+  for (size_t i = 0; i < shadows.size(); ++i) {
+    const ShadowValue& shadow = shadows[i];
+
+    layer_info.fOffset.set(SkIntToScalar(shadow.x()),
+                           SkIntToScalar(shadow.y()));
+
+    SkPaint* paint = looper_builder.addLayer(layer_info);
+    // Skia's blur radius defines the range to extend the blur from
+    // original mask, which is half of blur amount as defined in ShadowValue.
+    paint->setMaskFilter(SkMaskFilter::MakeBlur(
+        kNormal_SkBlurStyle, RadiusToSigma(shadow.blur() / 2)));
+    paint->setColorFilter(
+        SkColorFilters::Blend(shadow.color(), SkBlendMode::kSrcIn));
+  }
+
+  return looper_builder.detach();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/skia_paint_util.h b/ui/gfx/skia_paint_util.h
new file mode 100644
index 0000000..7a00067
--- /dev/null
+++ b/ui/gfx/skia_paint_util.h
@@ -0,0 +1,58 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SKIA_PAINT_UTIL_H_
+#define UI_GFX_SKIA_PAINT_UTIL_H_
+
+#include <memory>
+#include <vector>
+
+#include "cc/paint/paint_shader.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/shadow_value.h"
+
+class SkDrawLooper;
+class SkMatrix;
+
+namespace gfx {
+
+class ImageSkiaRep;
+
+// Creates a bitmap shader for the image rep with the image rep's scale factor.
+// Sets the created shader's local matrix such that it displays the image rep at
+// the correct scale factor.
+// The shader's local matrix should not be changed after the shader is created.
+// TODO(pkotwicz): Allow shader's local matrix to be changed after the shader
+// is created.
+//
+GFX_EXPORT sk_sp<cc::PaintShader> CreateImageRepShader(
+    const gfx::ImageSkiaRep& image_rep,
+    SkTileMode tile_mode_x,
+    SkTileMode tile_mode_y,
+    const SkMatrix& local_matrix);
+
+// Creates a bitmap shader for the image rep with the passed in scale factor.
+GFX_EXPORT sk_sp<cc::PaintShader> CreateImageRepShaderForScale(
+    const gfx::ImageSkiaRep& image_rep,
+    SkTileMode tile_mode_x,
+    SkTileMode tile_mode_y,
+    const SkMatrix& local_matrix,
+    SkScalar scale);
+
+// Creates a gradient shader. The caller owns the shader.
+GFX_EXPORT sk_sp<cc::PaintShader> CreateGradientShader(
+    const gfx::Point& start_point,
+    const gfx::Point& end_point,
+    SkColor start_color,
+    SkColor end_color);
+
+// Creates a draw looper to generate |shadows|. The caller owns the draw looper.
+// NULL is returned if |shadows| is empty since no draw looper is needed in
+// this case.
+GFX_EXPORT sk_sp<SkDrawLooper> CreateShadowDrawLooper(
+    const std::vector<ShadowValue>& shadows);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SKIA_PAINT_UTIL_H_
diff --git a/ui/gfx/skia_util.cc b/ui/gfx/skia_util.cc
new file mode 100644
index 0000000..9df544a
--- /dev/null
+++ b/ui/gfx/skia_util.cc
@@ -0,0 +1,52 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/skia_util.h"
+
+#include "base/check.h"
+#include "base/numerics/safe_conversions.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+
+namespace gfx {
+
+bool BitmapsAreEqual(const SkBitmap& bitmap1, const SkBitmap& bitmap2) {
+  if (bitmap1.isNull() != bitmap2.isNull() ||
+      bitmap1.dimensions() != bitmap2.dimensions())
+    return false;
+
+  if (bitmap1.getGenerationID() == bitmap2.getGenerationID() ||
+      (bitmap1.empty() && bitmap2.empty()))
+    return true;
+
+  // Calling getAddr32() on null or empty bitmaps will assert. The conditions
+  // above should return early if either bitmap is empty or null.
+  DCHECK(!bitmap1.isNull() && !bitmap2.isNull());
+  DCHECK(!bitmap1.empty() && !bitmap2.empty());
+
+  void* addr1 = bitmap1.getAddr32(0, 0);
+  void* addr2 = bitmap2.getAddr32(0, 0);
+  size_t size1 = bitmap1.computeByteSize();
+  size_t size2 = bitmap2.computeByteSize();
+
+  return (size1 == size2) && (0 == memcmp(addr1, addr2, size1));
+}
+
+// We treat HarfBuzz ints as 16.16 fixed-point.
+static const int kHbUnit1 = 1 << 16;
+
+int SkiaScalarToHarfBuzzUnits(SkScalar value) {
+  return base::saturated_cast<int>(value * kHbUnit1);
+}
+
+SkScalar HarfBuzzUnitsToSkiaScalar(int value) {
+  static const SkScalar kSkToHbRatio = SK_Scalar1 / kHbUnit1;
+  return kSkToHbRatio * value;
+}
+
+float HarfBuzzUnitsToFloat(int value) {
+  static const float kFloatToHbRatio = 1.0f / kHbUnit1;
+  return kFloatToHbRatio * value;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/skia_util.h b/ui/gfx/skia_util.h
new file mode 100644
index 0000000..fb5f20d
--- /dev/null
+++ b/ui/gfx/skia_util.h
@@ -0,0 +1,30 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SKIA_UTIL_H_
+#define UI_GFX_SKIA_UTIL_H_
+
+#include "third_party/skia/include/core/SkScalar.h"
+#include "ui/gfx/gfx_skia_export.h"
+
+class SkBitmap;
+
+namespace gfx {
+
+// Returns true if the two bitmaps contain the same pixels.
+GFX_SKIA_EXPORT bool BitmapsAreEqual(const SkBitmap& bitmap1,
+                                     const SkBitmap& bitmap2);
+
+// Converts a Skia floating-point value to an int appropriate for hb_position_t.
+GFX_SKIA_EXPORT int SkiaScalarToHarfBuzzUnits(SkScalar value);
+
+// Converts an hb_position_t to a Skia floating-point value.
+GFX_SKIA_EXPORT SkScalar HarfBuzzUnitsToSkiaScalar(int value);
+
+// Converts an hb_position_t to a float.
+GFX_SKIA_EXPORT float HarfBuzzUnitsToFloat(int value);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SKIA_UTIL_H_
diff --git a/ui/gfx/skia_util_unittest.cc b/ui/gfx/skia_util_unittest.cc
new file mode 100644
index 0000000..34ce126
--- /dev/null
+++ b/ui/gfx/skia_util_unittest.cc
@@ -0,0 +1,47 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/skia_util.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+
+namespace gfx {
+
+TEST(SkiaUtilTest, BitmapsAreEqual) {
+  SkBitmap a, b;
+  EXPECT_TRUE(gfx::BitmapsAreEqual(a, b));  // Both bitmaps are null.
+
+  a.allocN32Pixels(0, 0);
+  EXPECT_FALSE(gfx::BitmapsAreEqual(a, b));  // isNull() differs.
+  b.allocN32Pixels(10, 0);
+  EXPECT_FALSE(gfx::BitmapsAreEqual(a, b));  // Dimensions differ.
+  a.allocN32Pixels(0, 10);
+  EXPECT_FALSE(gfx::BitmapsAreEqual(a, b));  // Dimensions still differ.
+  b.allocN32Pixels(0, 10);
+  EXPECT_TRUE(gfx::BitmapsAreEqual(a, b));  // Dimensions equal (but empty).
+  a.allocN32Pixels(10, 10);
+  EXPECT_FALSE(gfx::BitmapsAreEqual(a, b));  // Dimensions differ.
+  b.allocN32Pixels(10, 10);
+  EXPECT_TRUE(gfx::BitmapsAreEqual(a, b));  // Dimensions equal (non-empty).
+
+  a.eraseColor(SK_ColorRED);
+  EXPECT_FALSE(gfx::BitmapsAreEqual(a, b));  // Contents differ.
+  b.eraseColor(SK_ColorGREEN);
+  EXPECT_FALSE(gfx::BitmapsAreEqual(a, b));  // Contents still differ.
+  b.eraseColor(SK_ColorRED);
+  EXPECT_TRUE(gfx::BitmapsAreEqual(a, b));  // Contents equal.
+
+  a.eraseColor(SK_ColorBLUE);
+  EXPECT_FALSE(gfx::BitmapsAreEqual(a, b));  // Contents differ.
+  b = a;
+  EXPECT_TRUE(gfx::BitmapsAreEqual(a, b));  // Generation ids equal.
+
+  a.reset();
+  EXPECT_FALSE(gfx::BitmapsAreEqual(a, b));  // isNull() differs.
+  b.reset();
+  EXPECT_TRUE(gfx::BitmapsAreEqual(a, b));  // Both bitmaps are null.
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/skrect_conversion_unittest.cc b/ui/gfx/skrect_conversion_unittest.cc
new file mode 100644
index 0000000..2725e04
--- /dev/null
+++ b/ui/gfx/skrect_conversion_unittest.cc
@@ -0,0 +1,47 @@
+// Copyright (c) 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.
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/skia_conversions.h"
+
+namespace gfx {
+
+TEST(RectTest, SkiaRectConversions) {
+  Rect isrc(10, 20, 30, 40);
+  RectF fsrc(10.5f, 20.5f, 30.5f, 40.5f);
+
+  SkIRect skirect = RectToSkIRect(isrc);
+  EXPECT_EQ(isrc.ToString(), SkIRectToRect(skirect).ToString());
+
+  SkRect skrect = RectToSkRect(isrc);
+  EXPECT_EQ(gfx::RectF(isrc).ToString(), SkRectToRectF(skrect).ToString());
+
+  skrect = RectFToSkRect(fsrc);
+  EXPECT_EQ(fsrc.ToString(), SkRectToRectF(skrect).ToString());
+}
+
+TEST(RectTest, SkIRectToRectClamping) {
+  // This clamping only makes sense if SkIRect and gfx::Rect have the same size.
+  // Otherwise, either other overflows can occur that we don't handle, or no
+  // overflows can ocur.
+  if (sizeof(int) != sizeof(int32_t))
+    return;
+  using Limits = std::numeric_limits<int>;
+
+  // right-left and bottom-top would overflow.
+  // These should be mapped to max width/height, which is as close as gfx::Rect
+  // can represent.
+  Rect result = SkIRectToRect(SkIRect::MakeLTRB(Limits::min(), Limits::min(),
+                                                Limits::max(), Limits::max()));
+  EXPECT_EQ(gfx::Size(Limits::max(), Limits::max()), result.size());
+
+  // right-left and bottom-top would underflow.
+  // These should be mapped to zero, like all negative values.
+  result = SkIRectToRect(SkIRect::MakeLTRB(Limits::max(), Limits::max(),
+                                           Limits::min(), Limits::min()));
+  EXPECT_EQ(gfx::Rect(Limits::max(), Limits::max(), 0, 0), result);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/surface_origin.h b/ui/gfx/surface_origin.h
new file mode 100644
index 0000000..0f51513
--- /dev/null
+++ b/ui/gfx/surface_origin.h
@@ -0,0 +1,19 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SURFACE_ORIGIN_H_
+#define UI_GFX_SURFACE_ORIGIN_H_
+
+namespace gfx {
+
+// Describes where (0,0) coordinate is in a surface. Conventionally this value
+// is kBottomLeft for OpenGL.
+enum class SurfaceOrigin {
+  kTopLeft,
+  kBottomLeft,
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SURFACE_ORIGIN_H_
diff --git a/ui/gfx/swap_result.cc b/ui/gfx/swap_result.cc
new file mode 100644
index 0000000..9d600c7
--- /dev/null
+++ b/ui/gfx/swap_result.cc
@@ -0,0 +1,28 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/swap_result.h"
+
+#include "ui/gfx/ca_layer_params.h"
+#include "ui/gfx/gpu_fence.h"
+
+namespace gfx {
+
+SwapCompletionResult::SwapCompletionResult(gfx::SwapResult swap_result)
+    : swap_result(swap_result) {}
+
+SwapCompletionResult::SwapCompletionResult(gfx::SwapResult swap_result,
+                                           gfx::GpuFenceHandle release_fence)
+    : swap_result(swap_result), release_fence(std::move(release_fence)) {}
+
+SwapCompletionResult::SwapCompletionResult(
+    gfx::SwapResult swap_result,
+    std::unique_ptr<gfx::CALayerParams> ca_layer_params)
+    : swap_result(swap_result), ca_layer_params(std::move(ca_layer_params)) {}
+
+SwapCompletionResult::SwapCompletionResult(SwapCompletionResult&& other) =
+    default;
+SwapCompletionResult::~SwapCompletionResult() = default;
+
+}  // namespace gfx
diff --git a/ui/gfx/swap_result.h b/ui/gfx/swap_result.h
new file mode 100644
index 0000000..39a62d5
--- /dev/null
+++ b/ui/gfx/swap_result.h
@@ -0,0 +1,98 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SWAP_RESULT_H_
+#define UI_GFX_SWAP_RESULT_H_
+
+#include <memory>
+
+#include "base/time/time.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/gpu_fence_handle.h"
+
+namespace gfx {
+
+struct CALayerParams;
+
+enum class SwapResult {
+  SWAP_ACK,
+  SWAP_FAILED,
+  // Typically, the Viz thread should decide whether to skip a swap based off
+  // the damage. In rare cases, however, the GPU main thread might skip the
+  // swap after the Viz thread requests it (e.g. the Viz thread might not know
+  // that the buffers are not fully initialized yet). For the purposes of
+  // metrics bookkeeping, we label this scenario as SWAP_SKIPPED and treat it
+  // much like we do a SWAP_FAILED (e.g. failed PresentationFeedback).
+  // TODO(https://crbug.com/1226090): Consider more explicit handling of
+  // SWAP_SKIPPED.
+  SWAP_SKIPPED,
+  SWAP_NAK_RECREATE_BUFFERS,
+  SWAP_RESULT_LAST = SWAP_NAK_RECREATE_BUFFERS,
+};
+
+struct SwapTimings {
+  // When the GPU service first started processing the SwapBuffers request.
+  base::TimeTicks swap_start;
+
+  // On most platforms, this is when the GPU service finished processing the
+  // SwapBuffers request. On ChromeOS, this corresponds to the present time.
+  // TODO(brianderson): Differentiate the concepts without introducing
+  // dicontinuities in associated UMA data.
+  base::TimeTicks swap_end;
+
+  // When Display Compositor thread scheduled work to GPU Thread. For GLRenderer
+  // it's when InProcessCommandBuffer::Flush() happens, for SkiaRenderer it's
+  // PostTask time for FinishPaintRenderPass or SwapBuffers whichever comes
+  // first.
+  base::TimeTicks viz_scheduled_draw;
+
+  // When GPU thread started draw submitted by Display Compositor thread. For
+  // GLRenderer it's InProcessCommandBuffer::FlushOnGpuThread, for SkiaRenderer
+  // it's FinishPaintRenderPass/SwapBuffers.
+  base::TimeTicks gpu_started_draw;
+
+  // When GPU scheduler removed the last required dependency.
+  base::TimeTicks gpu_task_ready;
+
+  bool is_null() const { return swap_start.is_null() && swap_end.is_null(); }
+};
+
+// Sent by ImageTransportSurfaces to their clients in response to a SwapBuffers.
+struct SwapResponse {
+  // The swap's sequence id which helps clients determine which SwapBuffers
+  // this corresponds to. We may receive responses out of order on platforms
+  // that allow multiple swaps pending if a failed swap returns immediately
+  // while a successful swap is still outstanding.
+  uint64_t swap_id;
+
+  // Indicates whether the swap succeeded or not.
+  // TODO(https://crbug.com/894929): It may be more reasonable to add
+  // a full SwapCompletionResult as a member.
+  SwapResult result;
+
+  // Timing information about the given swap.
+  SwapTimings timings;
+};
+
+// Sent by GLImages to their GLImage::SwapCompletionCallbacks.
+struct GFX_EXPORT SwapCompletionResult {
+  explicit SwapCompletionResult(gfx::SwapResult swap_result);
+  SwapCompletionResult(gfx::SwapResult swap_result,
+                       gfx::GpuFenceHandle release_fence);
+  SwapCompletionResult(gfx::SwapResult swap_result,
+                       std::unique_ptr<gfx::CALayerParams> ca_layer_params);
+  SwapCompletionResult(SwapCompletionResult&& other);
+  ~SwapCompletionResult();
+
+  SwapCompletionResult(const SwapCompletionResult& other) = delete;
+  SwapCompletionResult& operator=(const SwapCompletionResult other) = delete;
+
+  gfx::SwapResult swap_result = SwapResult::SWAP_FAILED;
+  gfx::GpuFenceHandle release_fence;
+  std::unique_ptr<CALayerParams> ca_layer_params;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_SWAP_RESULT_H_
diff --git a/ui/gfx/switches.cc b/ui/gfx/switches.cc
new file mode 100644
index 0000000..6733cbe
--- /dev/null
+++ b/ui/gfx/switches.cc
@@ -0,0 +1,42 @@
+// Copyright 2012 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.
+
+#include "build/build_config.h"
+#include "ui/gfx/switches.h"
+
+namespace switches {
+
+// Scale factor to apply to every animation duration. Must be >= 0.0. This will
+// only apply to LinearAnimation and its subclasses.
+const char kAnimationDurationScale[] = "animation-duration-scale";
+
+// Force disables font subpixel positioning. This affects the character glyph
+// sharpness, kerning, hinting and layout.
+const char kDisableFontSubpixelPositioning[] =
+    "disable-font-subpixel-positioning";
+
+// Enable native CPU-mappable GPU memory buffer support on Linux.
+const char kEnableNativeGpuMemoryBuffers[] = "enable-native-gpu-memory-buffers";
+
+// Forces whether the user desires reduced motion, regardless of system
+// settings.
+const char kForcePrefersReducedMotion[] = "force-prefers-reduced-motion";
+
+// Run in headless mode, i.e., without a UI or display server dependencies.
+const char kHeadless[] = "headless";
+
+}  // namespace switches
+
+namespace features {
+
+const base::Feature kOddHeightMultiPlanarBuffers {
+  "OddHeightMultiPlanarBuffers",
+#if defined(OS_MAC)
+      base::FEATURE_ENABLED_BY_DEFAULT
+#else
+      base::FEATURE_DISABLED_BY_DEFAULT
+#endif
+};
+
+}  // namespace features
diff --git a/ui/gfx/switches.h b/ui/gfx/switches.h
new file mode 100644
index 0000000..afb36f3
--- /dev/null
+++ b/ui/gfx/switches.h
@@ -0,0 +1,25 @@
+// Copyright 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SWITCHES_H_
+#define UI_GFX_SWITCHES_H_
+
+#include "base/feature_list.h"
+#include "build/build_config.h"
+#include "ui/gfx/switches_export.h"
+
+namespace switches {
+
+GFX_SWITCHES_EXPORT extern const char kAnimationDurationScale[];
+GFX_SWITCHES_EXPORT extern const char kDisableFontSubpixelPositioning[];
+GFX_SWITCHES_EXPORT extern const char kEnableNativeGpuMemoryBuffers[];
+GFX_SWITCHES_EXPORT extern const char kForcePrefersReducedMotion[];
+GFX_SWITCHES_EXPORT extern const char kHeadless[];
+}  // namespace switches
+
+namespace features {
+GFX_SWITCHES_EXPORT extern const base::Feature kOddHeightMultiPlanarBuffers;
+}  // namespace features
+
+#endif  // UI_GFX_SWITCHES_H_
diff --git a/ui/gfx/switches_export.h b/ui/gfx/switches_export.h
new file mode 100644
index 0000000..34418ae
--- /dev/null
+++ b/ui/gfx/switches_export.h
@@ -0,0 +1,29 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SWITCHES_EXPORT_H_
+#define UI_GFX_SWITCHES_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(GFX_SWITCHES_IMPLEMENTATION)
+#define GFX_SWITCHES_EXPORT __declspec(dllexport)
+#else
+#define GFX_SWITCHES_EXPORT __declspec(dllimport)
+#endif  // defined(GFX_SWITCHES_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(GFX_SWITCHES_IMPLEMENTATION)
+#define GFX_SWITCHES_EXPORT __attribute__((visibility("default")))
+#else
+#define GFX_SWITCHES_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define GFX_SWITCHES_EXPORT
+#endif
+
+#endif  // UI_GFX_SWITCHES_EXPORT_H_
diff --git a/ui/gfx/sys_color_change_listener.cc b/ui/gfx/sys_color_change_listener.cc
new file mode 100644
index 0000000..72dae9f
--- /dev/null
+++ b/ui/gfx/sys_color_change_listener.cc
@@ -0,0 +1,79 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/sys_color_change_listener.h"
+
+#include <windows.h>
+
+#include <memory>
+
+#include "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/memory/singleton.h"
+#include "base/observer_list.h"
+#include "ui/gfx/win/singleton_hwnd_observer.h"
+
+namespace gfx {
+
+class SysColorChangeObserver {
+ public:
+  static SysColorChangeObserver* GetInstance();
+
+  void AddListener(SysColorChangeListener* listener);
+  void RemoveListener(SysColorChangeListener* listener);
+
+ private:
+  friend struct base::DefaultSingletonTraits<SysColorChangeObserver>;
+
+  SysColorChangeObserver();
+  virtual ~SysColorChangeObserver();
+
+  void OnWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+
+  base::ObserverList<SysColorChangeListener>::Unchecked listeners_;
+  std::unique_ptr<gfx::SingletonHwndObserver> singleton_hwnd_observer_;
+};
+
+// static
+SysColorChangeObserver* SysColorChangeObserver::GetInstance() {
+  return base::Singleton<SysColorChangeObserver>::get();
+}
+
+SysColorChangeObserver::SysColorChangeObserver()
+    : singleton_hwnd_observer_(new SingletonHwndObserver(
+          base::BindRepeating(&SysColorChangeObserver::OnWndProc,
+                              base::Unretained(this)))) {}
+
+SysColorChangeObserver::~SysColorChangeObserver() {}
+
+void SysColorChangeObserver::AddListener(SysColorChangeListener* listener) {
+  listeners_.AddObserver(listener);
+}
+
+void SysColorChangeObserver::RemoveListener(SysColorChangeListener* listener) {
+  listeners_.RemoveObserver(listener);
+}
+
+void SysColorChangeObserver::OnWndProc(HWND hwnd,
+                                       UINT message,
+                                       WPARAM wparam,
+                                       LPARAM lparam) {
+  if (message == WM_SYSCOLORCHANGE ||
+      (message == WM_SETTINGCHANGE && wparam == SPI_SETHIGHCONTRAST)) {
+    for (SysColorChangeListener& observer : listeners_)
+      observer.OnSysColorChange();
+  }
+}
+
+ScopedSysColorChangeListener::ScopedSysColorChangeListener(
+    SysColorChangeListener* listener)
+    : listener_(listener) {
+  SysColorChangeObserver::GetInstance()->AddListener(listener_);
+}
+
+ScopedSysColorChangeListener::~ScopedSysColorChangeListener() {
+  SysColorChangeObserver::GetInstance()->RemoveListener(listener_);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/sys_color_change_listener.h b/ui/gfx/sys_color_change_listener.h
new file mode 100644
index 0000000..4dbbe9d
--- /dev/null
+++ b/ui/gfx/sys_color_change_listener.h
@@ -0,0 +1,40 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SYS_COLOR_CHANGE_LISTENER_H_
+#define UI_GFX_SYS_COLOR_CHANGE_LISTENER_H_
+
+#include "base/macros.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Interface for classes that want to listen to system color changes.
+class GFX_EXPORT SysColorChangeListener {
+ public:
+  virtual void OnSysColorChange() = 0;
+
+ protected:
+  virtual ~SysColorChangeListener() {}
+};
+
+// Create an instance of this class in any object that wants to listen
+// for system color changes.
+class GFX_EXPORT ScopedSysColorChangeListener {
+ public:
+  explicit ScopedSysColorChangeListener(SysColorChangeListener* listener);
+
+  ScopedSysColorChangeListener(const ScopedSysColorChangeListener&) = delete;
+  ScopedSysColorChangeListener& operator=(const ScopedSysColorChangeListener&) =
+      delete;
+
+  ~ScopedSysColorChangeListener();
+
+ private:
+  SysColorChangeListener* listener_;
+};
+
+}  // namespace gfx;
+
+#endif  // UI_GFX_SYS_COLOR_CHANGE_LISTENER_H_
diff --git a/ui/gfx/system_fonts_win.cc b/ui/gfx/system_fonts_win.cc
new file mode 100644
index 0000000..0ed4445
--- /dev/null
+++ b/ui/gfx/system_fonts_win.cc
@@ -0,0 +1,306 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/system_fonts_win.h"
+
+#include <windows.h>
+
+#include "base/containers/flat_map.h"
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/trace_event/trace_event.h"
+#include "base/win/scoped_gdi_object.h"
+#include "base/win/scoped_hdc.h"
+#include "base/win/scoped_select_object.h"
+#include "ui/gfx/platform_font.h"
+
+namespace gfx {
+namespace win {
+
+namespace {
+
+class SystemFonts {
+ public:
+  const gfx::Font& GetFont(SystemFont system_font) {
+    if (!IsInitialized())
+      Initialize();
+
+    auto it = system_fonts_.find(system_font);
+    DCHECK(it != system_fonts_.end())
+        << "System font #" << static_cast<int>(system_font) << " not found!";
+    return it->second;
+  }
+
+  static SystemFonts* Instance() {
+    static base::NoDestructor<SystemFonts> instance;
+    return instance.get();
+  }
+
+  SystemFonts(const SystemFonts&) = delete;
+  SystemFonts& operator=(const SystemFonts&) = delete;
+
+  void ResetForTesting() {
+    SystemFonts::is_initialized_ = false;
+    SystemFonts::adjust_font_callback_ = nullptr;
+    SystemFonts::get_minimum_font_size_callback_ = nullptr;
+    system_fonts_.clear();
+  }
+
+  static int AdjustFontSize(int lf_height, int size_delta) {
+    // Extract out the sign of |lf_height| - we'll add it back later.
+    const int lf_sign = lf_height < 0 ? -1 : 1;
+    lf_height = std::abs(lf_height);
+
+    // Apply the size adjustment.
+    lf_height += size_delta;
+
+    // Make sure |lf_height| is not smaller than allowed min allowed font size.
+    int min_font_size = 0;
+    if (get_minimum_font_size_callback_) {
+      min_font_size = get_minimum_font_size_callback_();
+      DCHECK_GE(min_font_size, 0);
+    }
+    lf_height = std::max(min_font_size, lf_height);
+
+    // Add back the sign.
+    return lf_sign * lf_height;
+  }
+
+  static void AdjustLOGFONT(const FontAdjustment& font_adjustment,
+                            LOGFONT* logfont) {
+    DCHECK_GT(font_adjustment.font_scale, 0.0);
+    LONG new_height =
+        base::ClampRound<LONG>(logfont->lfHeight * font_adjustment.font_scale);
+    if (logfont->lfHeight && !new_height)
+      new_height = logfont->lfHeight > 0 ? 1 : -1;
+    logfont->lfHeight = new_height;
+    if (!font_adjustment.font_family_override.empty()) {
+      auto result = wcscpy_s(logfont->lfFaceName,
+                             font_adjustment.font_family_override.c_str());
+      DCHECK_EQ(0, result) << "Font name "
+                           << font_adjustment.font_family_override
+                           << " cannot be copied into LOGFONT structure.";
+    }
+  }
+
+  static Font GetFontFromLOGFONT(const LOGFONT& logfont) {
+    // Finds a matching font by triggering font mapping. The font mapper finds
+    // the closest physical font for a given logical font.
+    base::win::ScopedHFONT font(::CreateFontIndirect(&logfont));
+    base::win::ScopedGetDC screen_dc(NULL);
+    base::win::ScopedSelectObject scoped_font(screen_dc, font.get());
+
+    DCHECK(font.get()) << "Font for '"
+                       << base::SysWideToUTF8(logfont.lfFaceName)
+                       << "' has an invalid handle.";
+
+    // Retrieve the name and height of the mapped font (physical font).
+    LOGFONT mapped_font_info;
+    GetObject(font.get(), sizeof(mapped_font_info), &mapped_font_info);
+    std::string font_name = base::SysWideToUTF8(mapped_font_info.lfFaceName);
+
+    TEXTMETRIC mapped_font_metrics;
+    GetTextMetrics(screen_dc, &mapped_font_metrics);
+    const int font_size =
+        std::max<int>(1, mapped_font_metrics.tmHeight -
+                             mapped_font_metrics.tmInternalLeading);
+
+    Font system_font =
+        Font(PlatformFont::CreateFromNameAndSize(font_name, font_size));
+
+    // System fonts may have different styles when they are manually changed by
+    // the users (see crbug.com/989476).
+    Font::FontStyle style = logfont.lfItalic == 0 ? Font::FontStyle::NORMAL
+                                                  : Font::FontStyle::ITALIC;
+    Font::Weight weight = logfont.lfWeight == 0
+                              ? Font::Weight::NORMAL
+                              : static_cast<Font::Weight>(logfont.lfWeight);
+    if (style != Font::FontStyle::NORMAL || weight != Font::Weight::NORMAL)
+      system_font = system_font.Derive(0, style, weight);
+
+    return system_font;
+  }
+
+  static void SetGetMinimumFontSizeCallback(
+      GetMinimumFontSizeCallback callback) {
+    DCHECK(!SystemFonts::IsInitialized());
+    get_minimum_font_size_callback_ = callback;
+  }
+
+  static void SetAdjustFontCallback(AdjustFontCallback callback) {
+    DCHECK(!SystemFonts::IsInitialized());
+    adjust_font_callback_ = callback;
+  }
+
+ private:
+  friend base::NoDestructor<SystemFonts>;
+
+  SystemFonts() {}
+
+  void Initialize() {
+    TRACE_EVENT0("fonts", "gfx::SystemFonts::Initialize");
+
+    NONCLIENTMETRICS metrics = {};
+    metrics.cbSize = sizeof(metrics);
+    const bool success = !!SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
+                                                metrics.cbSize, &metrics, 0);
+    DCHECK(success);
+
+    // NOTE(dfried): When rendering Chrome, we do all of our own font scaling
+    // based on a number of factors, but what Windows reports to us has some
+    // (but not all) of these factors baked in, and not in a way that is
+    // display-consistent.
+    //
+    // For example, if your system DPI is 192 (200%) but you connect a monitor
+    // with a standard DPI (100%) then even if Chrome starts on the second
+    // monitor, we will be told the system font is 24pt instead of 12pt.
+    // Conversely, if the system DPI is set to 96 (100%) but all of our monitors
+    // are currently at 150%, Windows will still report 12pt fonts.
+    //
+    // The same is true with Text Zoom (a new accessibility feature). If zoom is
+    // set to 150%, then Windows will report a font size of 18pt. But again, we
+    // already take Text Zoom into account when rendering, so we want to account
+    // for that.
+    //
+    // Our system fonts are in DIPs, so we must always take what Windows gives
+    // us, figure out which adjustments it's making (and undo them), make our
+    // own adjustments for localization (for example, we always render Hindi 25%
+    // larger for readability), and only then can we store (and report) the
+    // system fonts.
+
+    // Factor in/out scale adjustment that fall outside what we can access here.
+    // This includes l10n adjustments and those we have to ask UWP or other COM
+    // interfaces for (since we don't have dependencies on that code from this
+    // module, and don't want to implicitly invoke COM for testing purposes if
+    // we don't have to).
+    FontAdjustment font_adjustment;
+    if (adjust_font_callback_) {
+      adjust_font_callback_(&font_adjustment);
+    }
+
+    // Factor out system DPI scale that Windows will include in reported font
+    // sizes. Note that these are (sadly) system-wide and do not reflect
+    // specific displays' DPI.
+    double system_scale = GetSystemScale();
+    font_adjustment.font_scale /= system_scale;
+
+    // Grab each of the fonts from the NONCLIENTMETRICS block, adjust it
+    // appropriately, and store it in the font table.
+    AddFont(SystemFont::kCaption, font_adjustment, &metrics.lfCaptionFont);
+    AddFont(SystemFont::kSmallCaption, font_adjustment,
+            &metrics.lfSmCaptionFont);
+    AddFont(SystemFont::kMenu, font_adjustment, &metrics.lfMenuFont);
+    AddFont(SystemFont::kMessage, font_adjustment, &metrics.lfMessageFont);
+    AddFont(SystemFont::kStatus, font_adjustment, &metrics.lfStatusFont);
+
+    is_initialized_ = true;
+  }
+
+  static bool IsInitialized() { return is_initialized_; }
+
+  void AddFont(SystemFont system_font,
+               const FontAdjustment& font_adjustment,
+               LOGFONT* logfont) {
+    TRACE_EVENT0("fonts", "gfx::SystemFonts::AddFont");
+
+    // Make adjustments to the font as necessary.
+    AdjustLOGFONT(font_adjustment, logfont);
+
+    // Cap at minimum font size.
+    logfont->lfHeight = AdjustFontSize(logfont->lfHeight, 0);
+
+    system_fonts_.emplace(system_font, GetFontFromLOGFONT(*logfont));
+  }
+
+  // Returns the system DPI scale (standard DPI being 1.0).
+  // TODO(dfried): move dpi.[h|cc] somewhere in base/win so we can share this
+  // logic. However, note that the similar function in dpi.h is used many places
+  // it ought not to be.
+  static double GetSystemScale() {
+    constexpr double kDefaultDPI = 96.0;
+    base::win::ScopedGetDC screen_dc(nullptr);
+    return ::GetDeviceCaps(screen_dc, LOGPIXELSY) / kDefaultDPI;
+  }
+
+  // Use a flat map for faster lookups.
+  base::flat_map<SystemFont, gfx::Font> system_fonts_;
+
+  static bool is_initialized_;
+
+  // Font adjustment callback.
+  static AdjustFontCallback adjust_font_callback_;
+
+  // Minimum size callback.
+  static GetMinimumFontSizeCallback get_minimum_font_size_callback_;
+};
+
+// static
+bool SystemFonts::is_initialized_ = false;
+
+// static
+AdjustFontCallback SystemFonts::adjust_font_callback_ = nullptr;
+
+// static
+GetMinimumFontSizeCallback SystemFonts::get_minimum_font_size_callback_ =
+    nullptr;
+
+}  // namespace
+
+void SetGetMinimumFontSizeCallback(GetMinimumFontSizeCallback callback) {
+  SystemFonts::SetGetMinimumFontSizeCallback(callback);
+}
+
+void SetAdjustFontCallback(AdjustFontCallback callback) {
+  SystemFonts::SetAdjustFontCallback(callback);
+}
+
+const Font& GetDefaultSystemFont() {
+  // The message font is the closest font for a default system font from the
+  // structure NONCLIENTMETRICS. The lfMessageFont field contains information
+  // about the logical font used to display text in message boxes.
+  return GetSystemFont(SystemFont::kMessage);
+}
+
+const Font& GetSystemFont(SystemFont system_font) {
+  return SystemFonts::Instance()->GetFont(system_font);
+}
+
+NativeFont AdjustExistingSystemFont(NativeFont existing_font,
+                                    const FontAdjustment& font_adjustment) {
+  LOGFONT logfont;
+  auto result = GetObject(existing_font, sizeof(logfont), &logfont);
+  DCHECK(result);
+
+  // Make the necessary adjustments.
+  SystemFonts::AdjustLOGFONT(font_adjustment, &logfont);
+
+  // Cap at minimum font size.
+  logfont.lfHeight = SystemFonts::AdjustFontSize(logfont.lfHeight, 0);
+
+  // Create the Font object.
+  return ::CreateFontIndirect(&logfont);
+}
+
+int AdjustFontSize(int lf_height, int size_delta) {
+  return SystemFonts::AdjustFontSize(lf_height, size_delta);
+}
+
+void AdjustLOGFONTForTesting(const FontAdjustment& font_adjustment,
+                             LOGFONT* logfont) {
+  SystemFonts::AdjustLOGFONT(font_adjustment, logfont);
+}
+
+// Retrieve a FONT from a LOGFONT structure.
+Font GetFontFromLOGFONTForTesting(const LOGFONT& logfont) {
+  return SystemFonts::GetFontFromLOGFONT(logfont);
+}
+
+void ResetSystemFontsForTesting() {
+  SystemFonts::Instance()->ResetForTesting();
+}
+
+}  // namespace win
+}  // namespace gfx
diff --git a/ui/gfx/system_fonts_win.h b/ui/gfx/system_fonts_win.h
new file mode 100644
index 0000000..acf63cd
--- /dev/null
+++ b/ui/gfx/system_fonts_win.h
@@ -0,0 +1,72 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_SYSTEM_FONTS_WIN_H_
+#define UI_GFX_SYSTEM_FONTS_WIN_H_
+
+#include "ui/gfx/font.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+namespace win {
+
+// Represents an optional override of system font and scale.
+struct FontAdjustment {
+  std::wstring font_family_override;
+  double font_scale = 1.0;
+};
+
+// Identifiers for Windows-specific fonts described in the NONCLIENTMETRICS
+// struct.
+enum class SystemFont { kCaption = 0, kSmallCaption, kMenu, kStatus, kMessage };
+
+// Callback that returns the minimum height that should be used for
+// gfx::Fonts. Optional. If not specified, the minimum font size is 0.
+typedef int (*GetMinimumFontSizeCallback)();
+GFX_EXPORT void SetGetMinimumFontSizeCallback(
+    GetMinimumFontSizeCallback callback);
+
+// Callback that adjusts a FontAdjustment to meet suitability requirements
+// of the embedding application. Optional. If not specified, no adjustments
+// are performed other than clamping to a minimum font size if
+// |get_minimum_font_size_callback| is specified.
+typedef void (*AdjustFontCallback)(FontAdjustment* font_adjustment);
+GFX_EXPORT void SetAdjustFontCallback(AdjustFontCallback callback);
+
+// Returns the specified Windows default system font. By default, this is the
+// font used for message boxes (see struct NONCLIENTMETRICS).
+GFX_EXPORT const Font& GetDefaultSystemFont();
+
+// Returns the specified Windows system font, suitable for drawing on screen
+// elements.
+GFX_EXPORT const Font& GetSystemFont(SystemFont system_font);
+
+// Applies a font adjustment to an existing native font.
+GFX_EXPORT NativeFont
+AdjustExistingSystemFont(NativeFont existing_font,
+                         const FontAdjustment& font_adjustment);
+
+// Computes and returns the adjusted size of a font, subject to the global
+// minimum size. |lf_height| is the height as reported by the LOGFONT structure,
+// and may be positive or negative (but is typically negative, indicating
+// character size rather than cell size). The absolute value of |lf_size| will
+// be adjusted by |size_delta| and then returned with the original sign.
+GFX_EXPORT int AdjustFontSize(int lf_height, int size_delta);
+
+// Adjusts a LOGFONT structure for optional size scale and face override.
+GFX_EXPORT void AdjustLOGFONTForTesting(const FontAdjustment& font_adjustment,
+                                        LOGFONT* logfont);
+
+// Retrieves a FONT from a LOGFONT structure.
+GFX_EXPORT Font GetFontFromLOGFONTForTesting(const LOGFONT& logfont);
+
+// Clears the system fonts cache. SystemFonts is keeping a global state that
+// must be reset in unittests when using |GetMinimumFontSizeCallback| or
+// |SetAdjustFontCallback|.
+GFX_EXPORT void ResetSystemFontsForTesting();
+
+}  // namespace win
+}  // namespace gfx
+
+#endif  // UI_GFX_SYSTEM_FONTS_WIN_H_
diff --git a/ui/gfx/system_fonts_win_unittest.cc b/ui/gfx/system_fonts_win_unittest.cc
new file mode 100644
index 0000000..9e736b9
--- /dev/null
+++ b/ui/gfx/system_fonts_win_unittest.cc
@@ -0,0 +1,172 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/system_fonts_win.h"
+
+#include <windows.h>
+
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+namespace win {
+
+namespace {
+
+class SystemFontsWinTest : public testing::Test {
+ public:
+  SystemFontsWinTest() = default;
+
+  SystemFontsWinTest(const SystemFontsWinTest&) = delete;
+  SystemFontsWinTest& operator=(const SystemFontsWinTest&) = delete;
+
+ protected:
+  void SetUp() override {
+#if defined(OS_WIN)
+    // System fonts is keeping a cache of loaded system fonts. These fonts are
+    // scaled based on global callbacks configured on startup. The tests in this
+    // file are testing these callbacks and need to be sure we cleared the
+    // global state to avoid flaky tests.
+    win::ResetSystemFontsForTesting();
+#endif
+  }
+};
+
+LOGFONT CreateLOGFONT(const wchar_t* name, LONG height) {
+  LOGFONT logfont = {};
+  logfont.lfHeight = height;
+  auto result = wcscpy_s(logfont.lfFaceName, name);
+  DCHECK_EQ(0, result);
+  return logfont;
+}
+
+const wchar_t kSegoeUI[] = L"Segoe UI";
+const wchar_t kArial[] = L"Arial";
+
+}  // namespace
+
+TEST_F(SystemFontsWinTest, AdjustFontSize) {
+  EXPECT_EQ(10, gfx::win::AdjustFontSize(10, 0));
+  EXPECT_EQ(-10, gfx::win::AdjustFontSize(-10, 0));
+  EXPECT_EQ(8, gfx::win::AdjustFontSize(10, -2));
+  EXPECT_EQ(-8, gfx::win::AdjustFontSize(-10, -2));
+  EXPECT_EQ(13, gfx::win::AdjustFontSize(10, 3));
+  EXPECT_EQ(-13, gfx::win::AdjustFontSize(-10, 3));
+  EXPECT_EQ(1, gfx::win::AdjustFontSize(10, -9));
+  EXPECT_EQ(-1, gfx::win::AdjustFontSize(-10, -9));
+  EXPECT_EQ(0, gfx::win::AdjustFontSize(10, -12));
+  EXPECT_EQ(0, gfx::win::AdjustFontSize(-10, -12));
+}
+
+TEST_F(SystemFontsWinTest, AdjustFontSize_MinimumSizeSpecified) {
+  gfx::win::SetGetMinimumFontSizeCallback([] { return 1; });
+  EXPECT_EQ(10, gfx::win::AdjustFontSize(10, 0));
+  EXPECT_EQ(-10, gfx::win::AdjustFontSize(-10, 0));
+  EXPECT_EQ(8, gfx::win::AdjustFontSize(10, -2));
+  EXPECT_EQ(-8, gfx::win::AdjustFontSize(-10, -2));
+  EXPECT_EQ(13, gfx::win::AdjustFontSize(10, 3));
+  EXPECT_EQ(-13, gfx::win::AdjustFontSize(-10, 3));
+  EXPECT_EQ(1, gfx::win::AdjustFontSize(10, -9));
+  EXPECT_EQ(-1, gfx::win::AdjustFontSize(-10, -9));
+  EXPECT_EQ(1, gfx::win::AdjustFontSize(10, -12));
+  EXPECT_EQ(-1, gfx::win::AdjustFontSize(-10, -12));
+}
+
+TEST_F(SystemFontsWinTest, AdjustLOGFONT_NoAdjustment) {
+  LOGFONT logfont = CreateLOGFONT(kSegoeUI, -12);
+  FontAdjustment adjustment;
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(-12, logfont.lfHeight);
+  EXPECT_STREQ(kSegoeUI, logfont.lfFaceName);
+}
+
+TEST_F(SystemFontsWinTest, AdjustLOGFONT_ChangeFace) {
+  LOGFONT logfont = CreateLOGFONT(kSegoeUI, -12);
+  FontAdjustment adjustment{kArial, 1.0};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(-12, logfont.lfHeight);
+  EXPECT_STREQ(kArial, logfont.lfFaceName);
+}
+
+TEST_F(SystemFontsWinTest, AdjustLOGFONT_ScaleDown) {
+  LOGFONT logfont = CreateLOGFONT(kSegoeUI, -12);
+  FontAdjustment adjustment{L"", 0.5};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(-6, logfont.lfHeight);
+  EXPECT_STREQ(kSegoeUI, logfont.lfFaceName);
+
+  logfont = CreateLOGFONT(kSegoeUI, 12);
+  adjustment = {L"", 0.5};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(6, logfont.lfHeight);
+  EXPECT_STREQ(kSegoeUI, logfont.lfFaceName);
+}
+
+TEST_F(SystemFontsWinTest, AdjustLOGFONT_ScaleDownWithRounding) {
+  LOGFONT logfont = CreateLOGFONT(kSegoeUI, -10);
+  FontAdjustment adjustment{L"", 0.85};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(-9, logfont.lfHeight);
+  EXPECT_STREQ(kSegoeUI, logfont.lfFaceName);
+
+  logfont = CreateLOGFONT(kSegoeUI, 10);
+  adjustment = {L"", 0.85};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(9, logfont.lfHeight);
+  EXPECT_STREQ(kSegoeUI, logfont.lfFaceName);
+}
+
+TEST_F(SystemFontsWinTest, AdjustLOGFONT_ScaleUpWithFaceChange) {
+  LOGFONT logfont = CreateLOGFONT(kSegoeUI, -12);
+  FontAdjustment adjustment{kArial, 1.5};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(-18, logfont.lfHeight);
+  EXPECT_STREQ(kArial, logfont.lfFaceName);
+
+  logfont = CreateLOGFONT(kSegoeUI, 12);
+  adjustment = {kArial, 1.5};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(18, logfont.lfHeight);
+  EXPECT_STREQ(kArial, logfont.lfFaceName);
+}
+
+TEST_F(SystemFontsWinTest, AdjustLOGFONT_ScaleUpWithRounding) {
+  LOGFONT logfont = CreateLOGFONT(kSegoeUI, -10);
+  FontAdjustment adjustment{L"", 1.111};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(-11, logfont.lfHeight);
+  EXPECT_STREQ(kSegoeUI, logfont.lfFaceName);
+
+  logfont = CreateLOGFONT(kSegoeUI, 10);
+  adjustment = {L"", 1.11};
+  AdjustLOGFONTForTesting(adjustment, &logfont);
+  EXPECT_EQ(11, logfont.lfHeight);
+  EXPECT_STREQ(kSegoeUI, logfont.lfFaceName);
+}
+
+TEST_F(SystemFontsWinTest, GetFontFromLOGFONT) {
+  LOGFONT logfont = CreateLOGFONT(kSegoeUI, -10);
+  Font font = GetFontFromLOGFONTForTesting(logfont);
+  EXPECT_EQ(font.GetStyle(), Font::FontStyle::NORMAL);
+  EXPECT_EQ(font.GetWeight(), Font::Weight::NORMAL);
+}
+
+TEST_F(SystemFontsWinTest, GetFontFromLOGFONT_WithStyle) {
+  LOGFONT logfont = CreateLOGFONT(kSegoeUI, -10);
+  logfont.lfItalic = 1;
+  logfont.lfWeight = 700;
+
+  Font font = GetFontFromLOGFONTForTesting(logfont);
+  EXPECT_EQ(font.GetStyle(), Font::FontStyle::ITALIC);
+  EXPECT_EQ(font.GetWeight(), Font::Weight::BOLD);
+}
+
+TEST_F(SystemFontsWinTest, GetDefaultSystemFont) {
+  Font system_font = GetDefaultSystemFont();
+  EXPECT_EQ(base::WideToUTF8(kSegoeUI), system_font.GetFontName());
+}
+
+}  // namespace win
+}  // namespace gfx
diff --git a/ui/gfx/test/DEPS b/ui/gfx/test/DEPS
new file mode 100644
index 0000000..960c0d1
--- /dev/null
+++ b/ui/gfx/test/DEPS
@@ -0,0 +1,7 @@
+specific_include_rules = {
+  "run_all_unittests\.cc": [
+    "+mojo/core/embedder/embedder.h",
+    "+ui/base/resource/resource_bundle.h",
+    "+ui/base/ui_base_paths.h",
+  ],
+}
diff --git a/ui/gfx/test/OWNERS b/ui/gfx/test/OWNERS
new file mode 100644
index 0000000..8b2fc78
--- /dev/null
+++ b/ui/gfx/test/OWNERS
@@ -0,0 +1,3 @@
+# Fonts and fallback fonts.
+per-file font*=etienneb@chromium.org
+per-file font*=robliao@chromium.org
diff --git a/ui/gfx/test/data/compositor/BackgroundBlur1.png b/ui/gfx/test/data/compositor/BackgroundBlur1.png
new file mode 100644
index 0000000..13adbe6
--- /dev/null
+++ b/ui/gfx/test/data/compositor/BackgroundBlur1.png
Binary files differ
diff --git a/ui/gfx/test/data/compositor/BackgroundBlur1_zoom.png b/ui/gfx/test/data/compositor/BackgroundBlur1_zoom.png
new file mode 100644
index 0000000..48987ed
--- /dev/null
+++ b/ui/gfx/test/data/compositor/BackgroundBlur1_zoom.png
Binary files differ
diff --git a/ui/gfx/test/data/compositor/BackgroundBlur2.png b/ui/gfx/test/data/compositor/BackgroundBlur2.png
new file mode 100644
index 0000000..b110b06
--- /dev/null
+++ b/ui/gfx/test/data/compositor/BackgroundBlur2.png
Binary files differ
diff --git a/ui/gfx/test/data/compositor/ModifyHierarchy1.png b/ui/gfx/test/data/compositor/ModifyHierarchy1.png
new file mode 100644
index 0000000..465c24e
--- /dev/null
+++ b/ui/gfx/test/data/compositor/ModifyHierarchy1.png
Binary files differ
diff --git a/ui/gfx/test/data/compositor/ModifyHierarchy2.png b/ui/gfx/test/data/compositor/ModifyHierarchy2.png
new file mode 100644
index 0000000..f4ac5db
--- /dev/null
+++ b/ui/gfx/test/data/compositor/ModifyHierarchy2.png
Binary files differ
diff --git a/ui/gfx/test/data/compositor/Opacity.png b/ui/gfx/test/data/compositor/Opacity.png
new file mode 100644
index 0000000..83e1199
--- /dev/null
+++ b/ui/gfx/test/data/compositor/Opacity.png
Binary files differ
diff --git a/ui/gfx/test/data/icon_util/128_X_128_icon.ico b/ui/gfx/test/data/icon_util/128_X_128_icon.ico
new file mode 100644
index 0000000..a5d72fe
--- /dev/null
+++ b/ui/gfx/test/data/icon_util/128_X_128_icon.ico
Binary files differ
diff --git a/ui/gfx/test/data/icon_util/16_X_16_icon.ico b/ui/gfx/test/data/icon_util/16_X_16_icon.ico
new file mode 100644
index 0000000..0e524f1
--- /dev/null
+++ b/ui/gfx/test/data/icon_util/16_X_16_icon.ico
Binary files differ
diff --git a/ui/gfx/test/data/render_text/OWNERS b/ui/gfx/test/data/render_text/OWNERS
new file mode 100644
index 0000000..bd3a84d
--- /dev/null
+++ b/ui/gfx/test/data/render_text/OWNERS
@@ -0,0 +1,3 @@
+# RenderText and related classes.
+per-file render_text*=etienneb@chromium.org
+per-file render_text*=msw@chromium.org
diff --git a/ui/gfx/test/data/render_text/unicode_text_fuzzer.dict b/ui/gfx/test/data/render_text/unicode_text_fuzzer.dict
new file mode 100644
index 0000000..59f7bd6
--- /dev/null
+++ b/ui/gfx/test/data/render_text/unicode_text_fuzzer.dict
@@ -0,0 +1,351 @@
+# Copyright 2019 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Fuzzer dictionary targetting RenderText.
+
+# Control codes
+"\x00"
+"\x0a"
+"\x0d"
+
+# Basic Latin
+" "
+"!"
+"123"
+"@"
+"ABC"
+"~"
+
+# Latin-1 Supplement
+"\xA0"
+"\xc2\xa5"
+"\xc3\x86"
+"\xc3\x98"
+"\xc3\xa9"
+"\xc3\xb7"
+
+# Latin Extended-A
+"\xc4\x80"
+"\xc4\x89"
+"\xc4\x9e"
+"\xc4\xb6"
+"\xc5\x85"
+"\xc5\x92"
+
+# Latin Extended-B
+"\xc6\x82"
+"\xc6\x86"
+"\xc6\x90"
+"\xc6\xba"
+"\xc9\x83"
+
+# Latin Extended-C
+"\xe2\xb1\xa3"
+"\xe2\xb1\xab"
+
+# Latin Extended-D
+"\xea\x9c\xb6"
+"\xea\x9e\xb0"
+"\xea\x9f\xbf"
+
+# Latin Extended-E
+"\xea\xad\x82"
+"\xea\xac\xba"
+
+# IPA Extensions
+"\xca\x92"
+"\xc9\x99"
+
+# Spacing modifier letters
+"\xca\xb0"
+"\xcb\x87"
+"\xcb\xa8"
+
+# Phonetic Extensions
+"\xe1\xb4\x94"
+"\xe1\xb5\xab"
+"\xe1\xb5\xba"
+
+# Phonetic Extensions Supplement
+"\xe1\xb6\x95"
+"\xe1\xb6\x8e"
+"\xe1\xb6\xb3"
+
+# Combining Marks
+"\xe2\x97\x8c\xcc\x85"
+"\xe2\x97\x8c\xcc\x9a"
+"\xe2\x97\x8c\xcc\xb8"
+"\xe2\x97\x8c\xcd\xa5"
+"\xe2\x97\x8c\xe2\x83\x95"
+"\xe2\x97\x8c\xe2\x83\x92"
+
+# Greek and Coptic
+"\xcd\xb2"
+"\xcd\xb6"
+"\xce\x86"
+"\xcf\x96"
+
+# Greek Extended
+"\xe1\xbc\xaa"
+"\xe1\xbe\x8c"
+"\xe1\xbe\xa5"
+
+# Cyrillic
+"\xd0\x82"
+"\xd0\x89"
+"\xd0\x94"
+"\xd0\xa1"
+
+# Cyrillic Supplement
+"\xd4\x94"
+"\xd4\x99"
+"\xd4\xaa"
+
+# Cyrillic Extended-A
+"\xe2\xb7\xa8"
+"\xe2\xb7\xbc"
+
+# Cyrillic Extended-B
+"\xea\x99\x9a"
+"\xea\x99\xb2"
+"\xea\x99\xac"
+"\xea\x99\xae"
+
+# Cyrillic Extended-C
+"\xe1\xb2\x80"
+"\xe1\xb2\x82"
+"\xe1\xb2\x83"
+"\xe1\xb2\x85"
+
+# Armenian
+"\xd5\x83"
+"\xd4\xb9"
+"\xd5\x8d"
+"\xd6\x83"
+
+# Arabic
+"\xef\xba\x90"
+"\xef\xba\x9e"
+"\xef\xba\xac"
+"\xef\xba\xb6"
+"\xe0\xa2\xa9"
+"\xef\xad\xb3"
+"\xef\xba\xb6"
+
+# Arabic Word ligatures
+"\xef\xb7\xb0"
+"\xef\xb7\xb2"
+"\xef\xb7\xb6"
+
+# Hebrew
+"\xd7\x90"
+"\xd7\x9d"
+"\xd7\xa3"
+"\xef\xac\xa4"
+
+# Mandaic
+"\xe0\xa1\x81"
+"\xe0\xa1\x82"
+"\xe0\xa1\x85"
+
+# Samaritan
+"\xe0\xa0\x81"
+"\xe0\xa0\x84"
+"\xe0\xa0\x85"
+"\xe0\xa0\x86"
+
+# Syriac
+"\xdc\x93"
+"\xdc\x9c"
+"\xdc\xae"
+"\xdd\x8e"
+
+# Thaana
+"\xde\x84"
+"\xde\x8c"
+"\xde\x9d"
+
+# Devanagari
+"\xe0\xa4\x96"
+"\xe0\xa4\x99"
+"\xe0\xa5\x9a"
+"\xe0\xa5\xbe"
+
+# Bengali
+"\xe0\xa6\x86"
+"\xe0\xa6\x8b"
+"\xe0\xa6\x9d"
+"\xe0\xa6\xb6"
+
+# Gurmukhi
+"\xe0\xa8\x86"
+"\xe0\xa8\x98"
+"\xe0\xa8\x9b"
+"\xe0\xa8\xb2"
+
+# Gujarati
+"\xe0\xaa\x86"
+"\xe0\xaa\x8a"
+"\xe0\xaa\x8d"
+"\xe0\xaa\xb6"
+"\xe0\xab\x84"
+"\xe0\xab\x81"
+"\xe0\xab\x80"
+"\xe0\xab\xb1"
+
+# Oriya
+"\xe0\xac\x81"
+"\xe0\xac\x86"
+"\xe0\xac\xaa"
+"\xe0\xac\x9e"
+"\xe0\xad\x8b"
+"\xe0\xad\x9c"
+
+# Tamil
+"\xe0\xae\x85"
+"\xe0\xae\x87"
+"\xe0\xae\x99"
+"\xe0\xae\x9c"
+"\xe0\xaf\xb5"
+
+# Telugu
+"\xe0\xb0\x94"
+"\xe0\xb0\x8b"
+"\xe0\xb0\x9d"
+"\xe0\xb0\xae"
+"\xe0\xb1\xa0"
+"\xe0\xb1\x98"
+"\xe0\xb1\x96"
+
+# Kannada
+"\xe0\xb2\x85"
+"\xe0\xb2\x88"
+"\xe0\xb2\x8a"
+"\xe0\xb2\x9d"
+"\xe0\xb3\x88"
+"\xe0\xb3\x8b"
+
+# Malayalam
+"\xe0\xb4\x83"
+"\xe0\xb4\x86"
+"\xe0\xb4\x98"
+"\xe0\xb4\xb8"
+"\xe0\xb5\xba"
+
+# Sinhala
+"\xe0\xb6\x86"
+"\xe0\xb6\x89"
+"\xe0\xb6\x8c"
+"\xe0\xb6\x9d"
+"\xe0\xb7\x96"
+"\xe0\xb7\xb4"
+
+# Thai
+"\xe0\xb8\x97"
+"\xe0\xb8\xa9"
+"\xe0\xb9\x97"
+
+# Georgian
+"\xe1\x82\xb3"
+"\xe1\x82\xb4"
+"\xe1\x83\x9a"
+
+# Unicode symbols
+"\xe2\x80\x95"
+"\xe2\x80\xa0"
+"\xe2\x80\xbc"
+
+# General Punctuation
+"\xe2\x80\x96"
+"\xe2\x80\xbb"
+"\xe2\x80\x8b"
+"\xe2\x80\x8c"
+"\xe2\x80\x8d"
+"\xe2\x80\x8e"
+"\xe2\x80\x8f"
+"\xe2\x81\xa0"
+
+# Superscripts and Subscripts
+"\xe2\x82\x88"
+"\xe2\x82\x98"
+
+# Currency Symbols
+"\xe2\x82\xa9"
+"\xe2\x82\xad"
+
+# Letterlike Symbols
+"\xe2\x84\x96"
+"\xe2\x84\xac"
+"\xe2\x84\xa2"
+
+# Number Forms
+"\xe2\x85\x97"
+"\xe2\x85\xa8"
+
+# Arrows
+"\xe2\x86\x88"
+"\xe2\x87\x86"
+"\xe2\x87\x98"
+"\xe2\x87\xbc"
+
+# Mathematical symbols
+"\xe2\x88\xad"
+"\xe2\x89\x99"
+"\xe2\x8a\x98"
+
+# Miscellaneous Technical
+"\xe2\x8c\x9b"
+"\xe2\x8d\x89"
+"\xe2\x8e\x9b"
+
+# Enclosed Alphanumerics
+"\xe2\x91\xa5"
+"\xe2\x93\x8b"
+"\xe2\x93\xb4"
+
+# Box Drawing
+"\xe2\x94\xa3"
+"\xe2\x95\xa9"
+
+# Block Elements
+"\xe2\x96\x84"
+"\xe2\x96\x8a"
+
+# Geometric Shapes
+"\xe2\x96\xa4"
+"\xe2\x96\xb0"
+"\xe2\x97\xb7"
+
+# Miscellaneous Symbols
+"\xe2\x98\xb9"
+"\xe2\x9a\xbd"
+"\xe2\x9b\xb5"
+
+# Dingbat
+"\xe2\x9c\xbb"
+"\xe2\x9d\x89"
+
+# Braille
+"\xe2\xa0\x9b"
+"\xe2\xa1\xbb"
+"\xe2\xa2\xb7"
+"\xe2\xa3\xb8"
+
+# Music
+"\xf0\x9d\x84\x87"
+"\xf0\x9d\x84\xb5"
+"\xf0\x9d\x87\x9a"
+
+# Alchemical Symbols
+"\xf0\x9f\x9c\x97"
+"\xf0\x9f\x9d\x9c"
+"\xf0\x9f\x9d\xa9"
+
+# Emoji
+"\x32\x36\x39\x33"
+"\x36\xef\xb8\x8f\xe2\x83\xa3"
+"\xc2\xa9\xef\xb8\x8f"
+"\xf0\x9f\x8f\x87\xf0\x9f\x8f\xbe"
+"\x23\xef\xb8\x8e"
+"\xf0\x9f\x91\xa8\xf0\x9f\x8f\xbf\xe2\x80\x8d\xf0\x9f\xa4\x9d\xe2\x80\x8d\xf0\x9f\x91\xa8\xf0\x9f\x8f\xbd"
diff --git a/ui/gfx/test/font_fallback_test_data.cc b/ui/gfx/test/font_fallback_test_data.cc
new file mode 100644
index 0000000..a95fafe
--- /dev/null
+++ b/ui/gfx/test/font_fallback_test_data.cc
@@ -0,0 +1,280 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/test/font_fallback_test_data.h"
+
+#include <string>
+
+#include "build/build_config.h"
+
+namespace gfx {
+
+#if defined(OS_WIN)
+constexpr bool kWin10Only = true;
+#endif
+
+FallbackFontTestCase::FallbackFontTestCase() = default;
+FallbackFontTestCase::FallbackFontTestCase(const FallbackFontTestCase& other) =
+    default;
+
+FallbackFontTestCase::FallbackFontTestCase(
+    UScriptCode script_arg,
+    std::string language_tag_arg,
+    std::u16string text_arg,
+    std::vector<std::string> fallback_fonts_arg,
+    bool is_win10_arg)
+    : script(script_arg),
+      language_tag(language_tag_arg),
+      text(text_arg),
+      fallback_fonts(fallback_fonts_arg),
+      is_win10(is_win10_arg) {}
+
+FallbackFontTestCase::~FallbackFontTestCase() = default;
+
+#if defined(OS_WIN)
+// A list of script and the fallback font on a default windows installation.
+// This list may need to be updated if fonts or operating systems are
+// upgraded.
+// TODO(drott): Some of the test cases lack a valid language tag as it's unclear
+// which language in particular would be expressed with the respective ancient
+// script. Ideally we'd find a meaningful language tag for those.
+std::vector<FallbackFontTestCase> kGetFontFallbackTests = {
+    {USCRIPT_ARABIC,
+     "ar",
+     u"\u062A\u062D",
+     {"Segoe UI", "Tahoma", "Times New Roman"}},
+    {USCRIPT_ARMENIAN,
+     "hy-am",
+     u"\u0540\u0541",
+     {"Segoe UI", "Tahoma", "Sylfaen", "Times New Roman"}},
+    {USCRIPT_BENGALI, "bn", u"\u09B8\u09AE", {"Nirmala UI", "Vrinda"}},
+    {USCRIPT_BRAILLE, "en-us-brai", u"\u2870\u2871", {"Segoe UI Symbol"}},
+    {USCRIPT_BUGINESE, "bug", u"\u1A00\u1A01", {"Leelawadee UI"}, kWin10Only},
+    {USCRIPT_CANADIAN_ABORIGINAL,
+     "cans",
+     u"\u1410\u1411",
+     {"Gadugi", "Euphemia"}},
+
+    {USCRIPT_CARIAN,
+     "xcr",
+     u"\U000102A0\U000102A1",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_CHEROKEE,
+     "chr",
+     u"\u13A1\u13A2",
+     {"Gadugi", "Plantagenet Cherokee"}},
+
+    {USCRIPT_COPTIC,
+     "copt",
+     u"\u2C81\u2C82",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_CUNEIFORM,
+     "akk",
+     u"\U00012000\U0001200C",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_CYPRIOT,
+     "ecy",
+     u"\U00010800\U00010801",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_CYRILLIC, "ru", u"\u0410\u0411\u0412", {"Times New Roman"}},
+
+    {USCRIPT_DESERET,
+     "en",
+     u"\U00010400\U00010401",
+     {"Segoe UI Symbol"},
+     kWin10Only},
+
+    {USCRIPT_ETHIOPIC, "am", u"\u1201\u1202", {"Ebrima", "Nyala"}},
+    {USCRIPT_GEORGIAN,
+     "ka",
+     u"\u10A0\u10A1",
+     {"Sylfaen", "Segoe UI"},
+     kWin10Only},
+    {USCRIPT_GREEK, "el", u"\u0391\u0392", {"Times New Roman"}},
+    {USCRIPT_GURMUKHI, "pa", u"\u0A21\u0A22", {"Raavi", "Nirmala UI"}},
+    {USCRIPT_HAN,
+     "zh-CN",
+     u"\u6211",
+     {"Microsoft YaHei", "Microsoft YaHei UI"}},
+    {USCRIPT_HAN,
+     "zh-HK",
+     u"\u6211",
+     {"Microsoft JhengHei", "Microsoft JhengHei UI"}},
+    {USCRIPT_HAN,
+     "zh-Hans",
+     u"\u6211",
+     {"Microsoft YaHei", "Microsoft YaHei UI"}},
+    {USCRIPT_HAN,
+     "zh-Hant",
+     u"\u6211",
+     {"Microsoft JhengHei", "Microsoft JhengHei UI"}},
+    {USCRIPT_HAN, "ja", u"\u6211", {"Meiryo UI", "Yu Gothic UI", "Yu Gothic"}},
+    {USCRIPT_HANGUL,
+     "ko",
+     u"\u1100\u1101",
+     {"Malgun Gothic", "Gulim"},
+     kWin10Only},
+    {USCRIPT_HEBREW,
+     "he",
+     u"\u05D1\u05D2",
+     {"Segoe UI", "Tahoma", "Times New Roman"}},
+    {USCRIPT_KHMER,
+     "km",
+     u"\u1780\u1781",
+     {"Leelawadee UI", "Khmer UI", "Khmer OS", "MoolBoran", "DaunPenh"}},
+
+    {USCRIPT_IMPERIAL_ARAMAIC,
+     "arc",
+     u"\U00010841\U00010842",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_INSCRIPTIONAL_PAHLAVI,
+     "pal",
+     u"\U00010B61\U00010B62",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_INSCRIPTIONAL_PARTHIAN,
+     "xpr",
+     u"\U00010B41\U00010B42",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_JAVANESE, "jv", u"\uA991\uA992", {"Javanese Text"}, kWin10Only},
+    {USCRIPT_KANNADA, "kn", u"\u0CA1\u0CA2", {"Nirmala UI", "Tunga"}},
+
+    {USCRIPT_KHAROSHTHI,
+     "sa",
+     u"\U00010A10\U00010A11",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_LAO,
+     "lo",
+     u"\u0ED0\u0ED1",
+     {"Lao UI", "Leelawadee UI", "Segoe UI"}},
+    {USCRIPT_LISU, "lis", u"\uA4D0\uA4D1", {"Segoe UI"}, kWin10Only},
+
+    {USCRIPT_LYCIAN,
+     "xlc",
+     u"\U00010281\U00010282",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_LYDIAN,
+     "xld",
+     u"\U00010921\U00010922",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_MALAYALAM, "ml", u"\u0D21\u0D22", {"Kartika", "Nirmala UI"}},
+
+    {USCRIPT_MEROITIC_CURSIVE,
+     "",
+     u"\U000109A1\U000109A2",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_MYANMAR, "my", u"\u1000\u1001", {"Myanmar Text"}, kWin10Only},
+    {USCRIPT_NEW_TAI_LUE, "", u"\u1981\u1982", {"Microsoft New Tai Lue"}},
+    {USCRIPT_NKO, "nko", u"\u07C1\u07C2", {"Ebrima", "Segoe UI"}},
+
+    {USCRIPT_OGHAM,
+     "",
+     u"\u1680\u1681",
+     {"Segoe UI Symbol", "Segoe UI Historic"}},
+
+    {USCRIPT_OL_CHIKI, "", u"\u1C51\u1C52", {"Nirmala UI"}, kWin10Only},
+
+    {USCRIPT_OLD_ITALIC,
+     "",
+     u"\U00010301\U00010302",
+     {"Segoe UI Historic", "Segoe UI Symbol"}},
+
+    {USCRIPT_OLD_PERSIAN,
+     "peo",
+     u"\U000103A1\U000103A2",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_OLD_SOUTH_ARABIAN,
+     "",
+     u"\U00010A61\U00010A62",
+     {"Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_ORIYA, "or", u"\u0B21\u0B22", {"Kalinga", "Nirmala UI"}},
+    {USCRIPT_PHAGS_PA, "", u"\uA841\uA842", {"Microsoft PhagsPa"}},
+
+    {USCRIPT_RUNIC,
+     "",
+     u"\u16A0\u16A1",
+     {"Segoe UI Symbol", "Segoe UI Historic"}},
+
+    {USCRIPT_SHAVIAN,
+     "",
+     u"\U00010451\U00010452",
+     {"Segoe UI", "Segoe UI Historic"},
+     kWin10Only},
+
+    {USCRIPT_SINHALA, "si", u"\u0D91\u0D92", {"Iskoola Pota", "Nirmala UI"}},
+
+    {USCRIPT_SORA_SOMPENG,
+     "",
+     u"\U000110D1\U000110D2",
+     {"Nirmala UI"},
+     kWin10Only},
+
+    {USCRIPT_SYRIAC,
+     "syr",
+     u"\u0711\u0712",
+     {"Estrangelo Edessa", "Segoe UI Historic"}},
+
+    {USCRIPT_TAI_LE, "", u"\u1951\u1952", {"Microsoft Tai Le"}},
+    {USCRIPT_TAMIL, "ta", u"\u0BB1\u0BB2", {"Latha", "Nirmala UI"}},
+    {USCRIPT_TELUGU, "te", u"\u0C21\u0C22", {"Gautami", "Nirmala UI"}},
+    {USCRIPT_THAANA, "", u"\u0781\u0782", {"Mv Boli", "MV Boli"}},
+    {USCRIPT_THAI,
+     "th",
+     u"\u0e01\u0e02",
+     {"Tahoma", "Leelawadee UI", "Leelawadee"},
+     kWin10Only},
+    {USCRIPT_TIBETAN, "bo", u"\u0F01\u0F02", {"Microsoft Himalaya"}},
+    {USCRIPT_TIFINAGH, "", u"\u2D31\u2D32", {"Ebrima"}},
+    {USCRIPT_VAI, "vai", u"\uA501\uA502", {"Ebrima"}},
+    {USCRIPT_YI, "yi", u"\uA000\uA001", {"Microsoft Yi Baiti"}}};
+
+#elif defined(OS_LINUX) || defined(OS_CHROMEOS)
+
+// A list of script and the fallback font on the linux test environment.
+// On linux, font-config configuration and fonts are mock. The config
+// can be found in '${build}/etc/fonts/fonts.conf' and the test fonts
+// can be found in '${build}/test_fonts/*'.
+std::vector<FallbackFontTestCase> kGetFontFallbackTests = {
+    {USCRIPT_BENGALI, "bn", u"\u09B8\u09AE", {"Mukti Narrow"}},
+    {USCRIPT_DEVANAGARI, "hi", u"\u0905\u0906", {"Lohit Devanagari"}},
+    {USCRIPT_GURMUKHI, "pa", u"\u0A21\u0A22", {"Lohit Gurmukhi"}},
+    {USCRIPT_HAN, "zh-CN", u"\u6211", {"Noto Sans CJK JP"}},
+    {USCRIPT_KHMER, "km", u"\u1780\u1781", {"Noto Sans Khmer"}},
+    {USCRIPT_TAMIL, "ta", u"\u0BB1\u0BB2", {"Lohit Tamil"}},
+    {USCRIPT_THAI, "th", u"\u0e01\u0e02", {"Garuda"}},
+};
+
+#else
+
+// No fallback font tests are defined on that platform.
+std::vector<FallbackFontTestCase> kGetFontFallbackTests = {};
+
+#endif
+
+}  // namespace gfx
diff --git a/ui/gfx/test/font_fallback_test_data.h b/ui/gfx/test/font_fallback_test_data.h
new file mode 100644
index 0000000..cfc89e3
--- /dev/null
+++ b/ui/gfx/test/font_fallback_test_data.h
@@ -0,0 +1,36 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_TEST_FONT_FALLBACK_TEST_DATA_H_
+#define UI_GFX_TEST_FONT_FALLBACK_TEST_DATA_H_
+
+#include <string>
+#include <vector>
+
+#include "third_party/icu/source/common/unicode/uscript.h"
+
+namespace gfx {
+
+// A font test case for the parameterized unittests.
+struct FallbackFontTestCase {
+  FallbackFontTestCase();
+  FallbackFontTestCase(UScriptCode script_arg,
+                       std::string language_tag_arg,
+                       std::u16string text_arg,
+                       std::vector<std::string> fallback_fonts_arg,
+                       bool is_win10_arg = false);
+  FallbackFontTestCase(const FallbackFontTestCase& other);
+  ~FallbackFontTestCase();
+  UScriptCode script;
+  std::string language_tag;
+  std::u16string text;
+  std::vector<std::string> fallback_fonts;
+  bool is_win10 = false;
+};
+
+extern std::vector<FallbackFontTestCase> kGetFontFallbackTests;
+
+}  // namespace gfx
+
+#endif  // UI_GFX_TEST_FONT_FALLBACK_TEST_DATA_H_
diff --git a/ui/gfx/test/gfx_util.cc b/ui/gfx/test/gfx_util.cc
new file mode 100644
index 0000000..8037ee1
--- /dev/null
+++ b/ui/gfx/test/gfx_util.cc
@@ -0,0 +1,202 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/test/gfx_util.h"
+
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+#include "ui/gfx/geometry/axis_transform2d.h"
+#include "ui/gfx/geometry/box_f.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point3_f.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/geometry/quad_f.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "ui/gfx/geometry/transform.h"
+#include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/geometry/vector2d_f.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+
+namespace gfx {
+
+namespace {
+
+std::string ColorAsString(SkColor color) {
+  std::ostringstream stream;
+  stream << std::hex << std::uppercase << "#" << std::setfill('0')
+         << std::setw(2) << SkColorGetA(color)
+         << std::setw(2) << SkColorGetR(color)
+         << std::setw(2) << SkColorGetG(color)
+         << std::setw(2) << SkColorGetB(color);
+  return stream.str();
+}
+
+bool FloatAlmostEqual(float a, float b) {
+  // FloatLE is the gtest predicate for less than or almost equal to.
+  return ::testing::FloatLE("a", "b", a, b) &&
+         ::testing::FloatLE("b", "a", b, a);
+}
+
+}  // namespace
+
+::testing::AssertionResult AssertAxisTransform2dFloatEqual(
+    const char* lhs_expr,
+    const char* rhs_expr,
+    const AxisTransform2d& lhs,
+    const AxisTransform2d& rhs) {
+  if (FloatAlmostEqual(lhs.scale().x(), rhs.scale().x()) &&
+      FloatAlmostEqual(lhs.scale().y(), rhs.scale().y()) &&
+      FloatAlmostEqual(lhs.translation().x(), rhs.translation().x()) &&
+      FloatAlmostEqual(lhs.translation().y(), rhs.translation().y())) {
+    return ::testing::AssertionSuccess();
+  }
+  return ::testing::AssertionFailure()
+         << "Value of: " << rhs_expr << "\n  Actual: " << rhs.ToString()
+         << "\nExpected: " << lhs_expr << "\nWhich is: " << lhs.ToString();
+}
+
+::testing::AssertionResult AssertBoxFloatEqual(const char* lhs_expr,
+                                               const char* rhs_expr,
+                                               const BoxF& lhs,
+                                               const BoxF& rhs) {
+  if (FloatAlmostEqual(lhs.x(), rhs.x()) &&
+      FloatAlmostEqual(lhs.y(), rhs.y()) &&
+      FloatAlmostEqual(lhs.z(), rhs.z()) &&
+      FloatAlmostEqual(lhs.width(), rhs.width()) &&
+      FloatAlmostEqual(lhs.height(), rhs.height()) &&
+      FloatAlmostEqual(lhs.depth(), rhs.depth())) {
+    return ::testing::AssertionSuccess();
+  }
+  return ::testing::AssertionFailure() << "Value of: " << rhs_expr
+                                       << "\n  Actual: " << rhs.ToString()
+                                       << "\nExpected: " << lhs_expr
+                                       << "\nWhich is: " << lhs.ToString();
+}
+
+::testing::AssertionResult AssertPointFloatEqual(const char* lhs_expr,
+                                                 const char* rhs_expr,
+                                                 const PointF& lhs,
+                                                 const PointF& rhs) {
+  if (FloatAlmostEqual(lhs.x(), rhs.x()) &&
+      FloatAlmostEqual(lhs.y(), rhs.y())) {
+    return ::testing::AssertionSuccess();
+  }
+  return ::testing::AssertionFailure()
+         << "Value of: " << rhs_expr << "\n  Actual: " << rhs.ToString()
+         << "\nExpected: " << lhs_expr << "\nWhich is: " << lhs.ToString();
+}
+
+::testing::AssertionResult AssertRectFloatEqual(const char* lhs_expr,
+                                                const char* rhs_expr,
+                                                const RectF& lhs,
+                                                const RectF& rhs) {
+  if (FloatAlmostEqual(lhs.x(), rhs.x()) &&
+      FloatAlmostEqual(lhs.y(), rhs.y()) &&
+      FloatAlmostEqual(lhs.width(), rhs.width()) &&
+      FloatAlmostEqual(lhs.height(), rhs.height())) {
+    return ::testing::AssertionSuccess();
+  }
+  return ::testing::AssertionFailure()
+         << "Value of: " << rhs_expr << "\n  Actual: " << rhs.ToString()
+         << "\nExpected: " << lhs_expr << "\nWhich is: " << lhs.ToString();
+}
+
+::testing::AssertionResult AssertSkColorsEqual(const char* lhs_expr,
+                                               const char* rhs_expr,
+                                               SkColor lhs,
+                                               SkColor rhs) {
+  if (lhs == rhs) {
+    return ::testing::AssertionSuccess();
+  }
+  return ::testing::AssertionFailure() << "Value of: " << rhs_expr
+                                       << "\n  Actual: " << ColorAsString(rhs)
+                                       << "\nExpected: " << lhs_expr
+                                       << "\nWhich is: " << ColorAsString(lhs);
+}
+
+::testing::AssertionResult AssertSizeFFloatEqual(const char* lhs_expr,
+                                                 const char* rhs_expr,
+                                                 const SizeF& lhs,
+                                                 const SizeF& rhs) {
+  if (FloatAlmostEqual(lhs.width(), rhs.width()) &&
+      FloatAlmostEqual(lhs.height(), rhs.height())) {
+    return ::testing::AssertionSuccess();
+  }
+  return ::testing::AssertionFailure()
+         << "Value of: " << rhs_expr << "\n  Actual: " << rhs.ToString()
+         << "\nExpected: " << lhs_expr << "\nWhich is: " << lhs.ToString();
+}
+
+void PrintTo(const AxisTransform2d& transform, ::std::ostream* os) {
+  *os << transform.ToString();
+}
+
+void PrintTo(const BoxF& box, ::std::ostream* os) {
+  *os << box.ToString();
+}
+
+void PrintTo(const Point& point, ::std::ostream* os) {
+  *os << point.ToString();
+}
+
+void PrintTo(const Point3F& point, ::std::ostream* os) {
+  *os << point.ToString();
+}
+
+void PrintTo(const PointF& point, ::std::ostream* os) {
+  *os << point.ToString();
+}
+
+void PrintTo(const Insets& insets, ::std::ostream* os) {
+  *os << insets.ToString();
+}
+
+void PrintTo(const InsetsF& insets, ::std::ostream* os) {
+  *os << insets.ToString();
+}
+
+void PrintTo(const QuadF& quad, ::std::ostream* os) {
+  *os << quad.ToString();
+}
+
+void PrintTo(const Rect& rect, ::std::ostream* os) {
+  *os << rect.ToString();
+}
+
+void PrintTo(const RectF& rect, ::std::ostream* os) {
+  *os << rect.ToString();
+}
+
+void PrintTo(const Size& size, ::std::ostream* os) {
+  *os << size.ToString();
+}
+
+void PrintTo(const SizeF& size, ::std::ostream* os) {
+  *os << size.ToString();
+}
+
+void PrintTo(const Transform& transform, ::std::ostream* os) {
+  *os << transform.ToString();
+}
+
+void PrintTo(const Vector2d& vector, ::std::ostream* os) {
+  *os << vector.ToString();
+}
+
+void PrintTo(const Vector2dF& vector, ::std::ostream* os) {
+  *os << vector.ToString();
+}
+
+void PrintTo(const Vector3dF& vector, ::std::ostream* os) {
+  *os << vector.ToString();
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/test/gfx_util.h b/ui/gfx/test/gfx_util.h
new file mode 100644
index 0000000..cb59626
--- /dev/null
+++ b/ui/gfx/test/gfx_util.h
@@ -0,0 +1,82 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_TEST_GFX_UTIL_H_
+#define UI_GFX_TEST_GFX_UTIL_H_
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/font_list.h"
+
+namespace gfx {
+
+class AxisTransform2d;
+class BoxF;
+class PointF;
+class RectF;
+class SizeF;
+
+// Tests should use this scoped setter, instead of calling
+// SetDefaultFontDescription directly.
+class ScopedDefaultFontDescription {
+ public:
+  explicit ScopedDefaultFontDescription(const std::string& font_description) {
+    FontList::SetDefaultFontDescription(font_description);
+  }
+  ~ScopedDefaultFontDescription() {
+    FontList::SetDefaultFontDescription(std::string());
+  }
+};
+
+#define EXPECT_AXIS_TRANSFORM2D_EQ(a, b) \
+  EXPECT_PRED_FORMAT2(::gfx::AssertAxisTransform2dFloatEqual, a, b)
+
+::testing::AssertionResult AssertAxisTransform2dFloatEqual(
+    const char* lhs_expr,
+    const char* rhs_expr,
+    const AxisTransform2d& lhs,
+    const AxisTransform2d& rhs);
+
+#define EXPECT_BOXF_EQ(a, b) \
+  EXPECT_PRED_FORMAT2(::gfx::AssertBoxFloatEqual, a, b)
+
+::testing::AssertionResult AssertBoxFloatEqual(const char* lhs_expr,
+                                               const char* rhs_expr,
+                                               const BoxF& lhs,
+                                               const BoxF& rhs);
+
+#define EXPECT_POINTF_EQ(a, b) \
+  EXPECT_PRED_FORMAT2(::gfx::AssertPointFloatEqual, a, b)
+
+::testing::AssertionResult AssertPointFloatEqual(const char* lhs_expr,
+                                                 const char* rhs_expr,
+                                                 const PointF& lhs,
+                                                 const PointF& rhs);
+
+#define EXPECT_RECTF_EQ(a, b) \
+  EXPECT_PRED_FORMAT2(::gfx::AssertRectFloatEqual, a, b)
+
+::testing::AssertionResult AssertRectFloatEqual(const char* lhs_expr,
+                                                const char* rhs_expr,
+                                                const RectF& lhs,
+                                                const RectF& rhs);
+
+#define EXPECT_SKCOLOR_EQ(a, b) \
+  EXPECT_PRED_FORMAT2(::gfx::AssertSkColorsEqual, a, b)
+
+::testing::AssertionResult AssertSkColorsEqual(const char* lhs_expr,
+                                               const char* rhs_expr,
+                                               SkColor lhs,
+                                               SkColor rhs);
+
+#define EXPECT_SIZEF_EQ(a, b) \
+  EXPECT_PRED_FORMAT2(::gfx::AssertSizeFFloatEqual, a, b)
+
+::testing::AssertionResult AssertSizeFFloatEqual(const char* lhs_expr,
+                                                 const char* rhs_expr,
+                                                 const SizeF& lhs,
+                                                 const SizeF& rhs);
+}  // namespace gfx
+
+#endif  // UI_GFX_TEST_GFX_UTIL_H_
diff --git a/ui/gfx/test/icc_profiles.cc b/ui/gfx/test/icc_profiles.cc
new file mode 100644
index 0000000..4ec059f
--- /dev/null
+++ b/ui/gfx/test/icc_profiles.cc
@@ -0,0 +1,1938 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/test/icc_profiles.h"
+
+#include "base/cxx17_backports.h"
+
+namespace gfx {
+
+namespace {
+
+const unsigned char generic_rgb_profile_data[] = {
+    0x00, 0x00, 0x07, 0xd8, 0x61, 0x70, 0x70, 0x6c, 0x02, 0x20, 0x00, 0x00,
+    0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x07, 0xd9, 0x00, 0x02, 0x00, 0x19, 0x00, 0x0b, 0x00, 0x1a, 0x00, 0x0b,
+    0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4c, 0x00, 0x00, 0x00, 0x00,
+    0x61, 0x70, 0x70, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x61, 0x70, 0x70, 0x6c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x6f,
+    0x64, 0x73, 0x63, 0x6d, 0x00, 0x00, 0x01, 0x78, 0x00, 0x00, 0x05, 0x9c,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x07, 0x14, 0x00, 0x00, 0x00, 0x38,
+    0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x07, 0x4c, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x07, 0x60, 0x00, 0x00, 0x00, 0x14,
+    0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x07, 0x74, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x07, 0x88, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x07, 0x9c, 0x00, 0x00, 0x00, 0x0e,
+    0x63, 0x68, 0x61, 0x64, 0x00, 0x00, 0x07, 0xac, 0x00, 0x00, 0x00, 0x2c,
+    0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x07, 0x9c, 0x00, 0x00, 0x00, 0x0e,
+    0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x07, 0x9c, 0x00, 0x00, 0x00, 0x0e,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14,
+    0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x52, 0x47, 0x42, 0x20,
+    0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x47, 0x65, 0x6e, 0x65, 0x72,
+    0x69, 0x63, 0x20, 0x52, 0x47, 0x42, 0x20, 0x50, 0x72, 0x6f, 0x66, 0x69,
+    0x6c, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x6d, 0x6c, 0x75, 0x63, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x0c, 0x73, 0x6b, 0x53, 0x4b,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x01, 0x84, 0x64, 0x61, 0x44, 0x4b,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x01, 0xac, 0x63, 0x61, 0x45, 0x53,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x01, 0xda, 0x76, 0x69, 0x56, 0x4e,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x01, 0xfe, 0x70, 0x74, 0x42, 0x52,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x02, 0x22, 0x75, 0x6b, 0x55, 0x41,
+    0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x02, 0x48, 0x66, 0x72, 0x46, 0x55,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x02, 0x72, 0x68, 0x75, 0x48, 0x55,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x02, 0x9a, 0x7a, 0x68, 0x54, 0x57,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x02, 0xc2, 0x6e, 0x62, 0x4e, 0x4f,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x02, 0xd8, 0x63, 0x73, 0x43, 0x5a,
+    0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x02, 0xfe, 0x68, 0x65, 0x49, 0x4c,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x03, 0x20, 0x69, 0x74, 0x49, 0x54,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x03, 0x3e, 0x72, 0x6f, 0x52, 0x4f,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x03, 0x66, 0x64, 0x65, 0x44, 0x45,
+    0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x03, 0x8a, 0x6b, 0x6f, 0x4b, 0x52,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x03, 0xb6, 0x73, 0x76, 0x53, 0x45,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x02, 0xd8, 0x7a, 0x68, 0x43, 0x4e,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x03, 0xcc, 0x6a, 0x61, 0x4a, 0x50,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x03, 0xe2, 0x65, 0x6c, 0x47, 0x52,
+    0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x03, 0xfc, 0x70, 0x74, 0x50, 0x4f,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x04, 0x1e, 0x6e, 0x6c, 0x4e, 0x4c,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x04, 0x44, 0x65, 0x73, 0x45, 0x53,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x04, 0x1e, 0x74, 0x68, 0x54, 0x48,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x04, 0x6c, 0x74, 0x72, 0x54, 0x52,
+    0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x04, 0x90, 0x66, 0x69, 0x46, 0x49,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x04, 0xb2, 0x68, 0x72, 0x48, 0x52,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x04, 0xda, 0x70, 0x6c, 0x50, 0x4c,
+    0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x05, 0x02, 0x72, 0x75, 0x52, 0x55,
+    0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x05, 0x2e, 0x61, 0x72, 0x45, 0x47,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x05, 0x50, 0x65, 0x6e, 0x55, 0x53,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x05, 0x76, 0x00, 0x56, 0x01, 0x61,
+    0x00, 0x65, 0x00, 0x6f, 0x00, 0x62, 0x00, 0x65, 0x00, 0x63, 0x00, 0x6e,
+    0x00, 0xfd, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20,
+    0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c,
+    0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x65,
+    0x00, 0x6c, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x2d,
+    0x00, 0x62, 0x00, 0x65, 0x00, 0x73, 0x00, 0x6b, 0x00, 0x72, 0x00, 0x69,
+    0x00, 0x76, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x73, 0x00, 0x65, 0x00, 0x50,
+    0x00, 0x65, 0x00, 0x72, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x20,
+    0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x67, 0x00, 0x65,
+    0x00, 0x6e, 0x00, 0xe8, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x43,
+    0x1e, 0xa5, 0x00, 0x75, 0x00, 0x20, 0x00, 0x68, 0x00, 0xec, 0x00, 0x6e,
+    0x00, 0x68, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20,
+    0x00, 0x43, 0x00, 0x68, 0x00, 0x75, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x50,
+    0x00, 0x65, 0x00, 0x72, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x20,
+    0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x47, 0x00, 0x65,
+    0x00, 0x6e, 0x00, 0xe9, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x6f,
+    0x04, 0x17, 0x04, 0x30, 0x04, 0x33, 0x04, 0x30, 0x04, 0x3b, 0x04, 0x4c,
+    0x04, 0x3d, 0x04, 0x38, 0x04, 0x39, 0x00, 0x20, 0x04, 0x3f, 0x04, 0x40,
+    0x04, 0x3e, 0x04, 0x44, 0x04, 0x30, 0x04, 0x39, 0x04, 0x3b, 0x00, 0x20,
+    0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f,
+    0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x67, 0x00, 0xe9,
+    0x00, 0x6e, 0x00, 0xe9, 0x00, 0x72, 0x00, 0x69, 0x00, 0x71, 0x00, 0x75,
+    0x00, 0x65, 0x00, 0x20, 0x00, 0x52, 0x00, 0x56, 0x00, 0x42, 0x00, 0xc1,
+    0x00, 0x6c, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6c, 0x00, 0xe1, 0x00, 0x6e,
+    0x00, 0x6f, 0x00, 0x73, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42,
+    0x00, 0x20, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69,
+    0x00, 0x6c, 0x90, 0x1a, 0x75, 0x28, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47,
+    0x00, 0x42, 0x00, 0x20, 0x82, 0x72, 0x5f, 0x69, 0x63, 0xcf, 0x8f, 0xf0,
+    0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69,
+    0x00, 0x73, 0x00, 0x6b, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42,
+    0x00, 0x2d, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69,
+    0x00, 0x6c, 0x00, 0x4f, 0x00, 0x62, 0x00, 0x65, 0x00, 0x63, 0x00, 0x6e,
+    0x00, 0xfd, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20,
+    0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c,
+    0x05, 0xe4, 0x05, 0xe8, 0x05, 0xd5, 0x05, 0xe4, 0x05, 0xd9, 0x05, 0xdc,
+    0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x05, 0xdb,
+    0x05, 0xdc, 0x05, 0xdc, 0x05, 0xd9, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f,
+    0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x20, 0x00, 0x52,
+    0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6e,
+    0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x50,
+    0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x20,
+    0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x67, 0x00, 0x65,
+    0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x41,
+    0x00, 0x6c, 0x00, 0x6c, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6d, 0x00, 0x65,
+    0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x52,
+    0x00, 0x47, 0x00, 0x42, 0x00, 0x2d, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f,
+    0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0xc7, 0x7c, 0xbc, 0x18, 0x00, 0x20,
+    0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0xd5, 0x04, 0xb8, 0x5c,
+    0xd3, 0x0c, 0xc7, 0x7c, 0x66, 0x6e, 0x90, 0x1a, 0x00, 0x20, 0x00, 0x52,
+    0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x63, 0xcf, 0x8f, 0xf0, 0x65, 0x87,
+    0x4e, 0xf6, 0x4e, 0x00, 0x82, 0x2c, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47,
+    0x00, 0x42, 0x00, 0x20, 0x30, 0xd7, 0x30, 0xed, 0x30, 0xd5, 0x30, 0xa1,
+    0x30, 0xa4, 0x30, 0xeb, 0x03, 0x93, 0x03, 0xb5, 0x03, 0xbd, 0x03, 0xb9,
+    0x03, 0xba, 0x03, 0xcc, 0x00, 0x20, 0x03, 0xc0, 0x03, 0xc1, 0x03, 0xbf,
+    0x03, 0xc6, 0x03, 0xaf, 0x03, 0xbb, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47,
+    0x00, 0x42, 0x00, 0x50, 0x00, 0x65, 0x00, 0x72, 0x00, 0x66, 0x00, 0x69,
+    0x00, 0x6c, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20,
+    0x00, 0x67, 0x00, 0x65, 0x00, 0x6e, 0x00, 0xe9, 0x00, 0x72, 0x00, 0x69,
+    0x00, 0x63, 0x00, 0x6f, 0x00, 0x41, 0x00, 0x6c, 0x00, 0x67, 0x00, 0x65,
+    0x00, 0x6d, 0x00, 0x65, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x52,
+    0x00, 0x47, 0x00, 0x42, 0x00, 0x2d, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f,
+    0x00, 0x66, 0x00, 0x69, 0x00, 0x65, 0x00, 0x6c, 0x0e, 0x42, 0x0e, 0x1b,
+    0x0e, 0x23, 0x0e, 0x44, 0x0e, 0x1f, 0x0e, 0x25, 0x0e, 0x4c, 0x00, 0x20,
+    0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x0e, 0x17, 0x0e, 0x31,
+    0x0e, 0x48, 0x0e, 0x27, 0x0e, 0x44, 0x0e, 0x1b, 0x00, 0x47, 0x00, 0x65,
+    0x00, 0x6e, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47,
+    0x00, 0x42, 0x00, 0x20, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66,
+    0x00, 0x69, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x59, 0x00, 0x6c, 0x00, 0x65,
+    0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x52,
+    0x00, 0x47, 0x00, 0x42, 0x00, 0x2d, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f,
+    0x00, 0x66, 0x00, 0x69, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x47,
+    0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x01, 0x0d,
+    0x00, 0x6b, 0x00, 0x69, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42,
+    0x00, 0x20, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69,
+    0x00, 0x6c, 0x00, 0x55, 0x00, 0x6e, 0x00, 0x69, 0x00, 0x77, 0x00, 0x65,
+    0x00, 0x72, 0x00, 0x73, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x6e, 0x00, 0x79,
+    0x00, 0x20, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69,
+    0x00, 0x6c, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x04, 0x1e,
+    0x04, 0x31, 0x04, 0x49, 0x04, 0x38, 0x04, 0x39, 0x00, 0x20, 0x04, 0x3f,
+    0x04, 0x40, 0x04, 0x3e, 0x04, 0x44, 0x04, 0x38, 0x04, 0x3b, 0x04, 0x4c,
+    0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x06, 0x45, 0x06, 0x44,
+    0x06, 0x41, 0x00, 0x20, 0x06, 0x2a, 0x06, 0x39, 0x06, 0x31, 0x06, 0x4a,
+    0x06, 0x41, 0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20,
+    0x06, 0x27, 0x06, 0x44, 0x06, 0x39, 0x06, 0x27, 0x06, 0x45, 0x00, 0x47,
+    0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63,
+    0x00, 0x20, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x50,
+    0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x65,
+    0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
+    0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x32, 0x30, 0x30, 0x37, 0x20, 0x41,
+    0x70, 0x70, 0x6c, 0x65, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x2c, 0x20, 0x61,
+    0x6c, 0x6c, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x20, 0x72, 0x65,
+    0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x2e, 0x00, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3, 0x52, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x16, 0xcf, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x74, 0x4d, 0x00, 0x00, 0x3d, 0xee, 0x00, 0x00, 0x03, 0xd0,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x75,
+    0x00, 0x00, 0xac, 0x73, 0x00, 0x00, 0x17, 0x34, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x1a, 0x00, 0x00, 0x15, 0x9f,
+    0x00, 0x00, 0xb8, 0x36, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x01, 0xcd, 0x00, 0x00, 0x73, 0x66, 0x33, 0x32,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0c, 0x42, 0x00, 0x00, 0x05, 0xde,
+    0xff, 0xff, 0xf3, 0x26, 0x00, 0x00, 0x07, 0x92, 0x00, 0x00, 0xfd, 0x91,
+    0xff, 0xff, 0xfb, 0xa2, 0xff, 0xff, 0xfd, 0xa3, 0x00, 0x00, 0x03, 0xdc,
+    0x00, 0x00, 0xc0, 0x6c};
+
+const unsigned char srgb_profile_data[] = {
+    0x00, 0x00, 0x0c, 0x48, 0x4c, 0x69, 0x6e, 0x6f, 0x02, 0x10, 0x00, 0x00,
+    0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00,
+    0x61, 0x63, 0x73, 0x70, 0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
+    0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x48, 0x50, 0x20, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84, 0x00, 0x00, 0x00, 0x6c,
+    0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14,
+    0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14,
+    0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54, 0x00, 0x00, 0x00, 0x70,
+    0x64, 0x6d, 0x64, 0x64, 0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88,
+    0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c, 0x00, 0x00, 0x00, 0x86,
+    0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24,
+    0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8, 0x00, 0x00, 0x00, 0x14,
+    0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24,
+    0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30, 0x00, 0x00, 0x00, 0x0c,
+    0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+    0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+    0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+    0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
+    0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39,
+    0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65, 0x74, 0x74, 0x2d, 0x50,
+    0x61, 0x63, 0x6b, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61,
+    0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43,
+    0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47,
+    0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32,
+    0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xcc,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5,
+    0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x62, 0x99, 0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0xa0,
+    0x00, 0x00, 0x0f, 0x84, 0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20,
+    0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
+    0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74,
+    0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x65, 0x63, 0x2e,
+    0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
+    0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e,
+    0x31, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47,
+    0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61,
+    0x63, 0x65, 0x20, 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x49, 0x45, 0x43,
+    0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44,
+    0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47, 0x42, 0x20, 0x63,
+    0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
+    0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2c, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+    0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f,
+    0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49,
+    0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52,
+    0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x56, 0x69, 0x65,
+    0x77, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
+    0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39,
+    0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe, 0x00, 0x14, 0x5f, 0x2e,
+    0x00, 0x10, 0xcf, 0x14, 0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b,
+    0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00,
+    0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x8f,
+    0x00, 0x00, 0x00, 0x02, 0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f,
+    0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23, 0x00, 0x28, 0x00, 0x2d,
+    0x00, 0x32, 0x00, 0x37, 0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a,
+    0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e, 0x00, 0x63, 0x00, 0x68,
+    0x00, 0x6d, 0x00, 0x72, 0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86,
+    0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a, 0x00, 0x9f, 0x00, 0xa4,
+    0x00, 0xa9, 0x00, 0xae, 0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1,
+    0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5, 0x00, 0xdb, 0x00, 0xe0,
+    0x00, 0xe5, 0x00, 0xeb, 0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01,
+    0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19, 0x01, 0x1f, 0x01, 0x25,
+    0x01, 0x2b, 0x01, 0x32, 0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c,
+    0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67, 0x01, 0x6e, 0x01, 0x75,
+    0x01, 0x7c, 0x01, 0x83, 0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1,
+    0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1, 0x01, 0xc9, 0x01, 0xd1,
+    0x01, 0xd9, 0x01, 0xe1, 0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03,
+    0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26, 0x02, 0x2f, 0x02, 0x38,
+    0x02, 0x41, 0x02, 0x4b, 0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71,
+    0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98, 0x02, 0xa2, 0x02, 0xac,
+    0x02, 0xb6, 0x02, 0xc1, 0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb,
+    0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16, 0x03, 0x21, 0x03, 0x2d,
+    0x03, 0x38, 0x03, 0x43, 0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72,
+    0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2, 0x03, 0xae, 0x03, 0xba,
+    0x03, 0xc7, 0x03, 0xd3, 0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06,
+    0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b, 0x04, 0x48, 0x04, 0x55,
+    0x04, 0x63, 0x04, 0x71, 0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8,
+    0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1, 0x04, 0xf0, 0x04, 0xfe,
+    0x05, 0x0d, 0x05, 0x1c, 0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58,
+    0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96, 0x05, 0xa6, 0x05, 0xb5,
+    0x05, 0xc5, 0x05, 0xd5, 0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16,
+    0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59, 0x06, 0x6a, 0x06, 0x7b,
+    0x06, 0x8c, 0x06, 0x9d, 0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3,
+    0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b, 0x07, 0x3d, 0x07, 0x4f,
+    0x07, 0x61, 0x07, 0x74, 0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf,
+    0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b, 0x08, 0x1f, 0x08, 0x32,
+    0x08, 0x46, 0x08, 0x5a, 0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa,
+    0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb, 0x09, 0x10, 0x09, 0x25,
+    0x09, 0x3a, 0x09, 0x4f, 0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4,
+    0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb, 0x0a, 0x11, 0x0a, 0x27,
+    0x0a, 0x3d, 0x0a, 0x54, 0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae,
+    0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b, 0x0b, 0x22, 0x0b, 0x39,
+    0x0b, 0x51, 0x0b, 0x69, 0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8,
+    0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a, 0x0c, 0x43, 0x0c, 0x5c,
+    0x0c, 0x75, 0x0c, 0x8e, 0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3,
+    0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a, 0x0d, 0x74, 0x0d, 0x8e,
+    0x0d, 0xa9, 0x0d, 0xc3, 0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e,
+    0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b, 0x0e, 0xb6, 0x0e, 0xd2,
+    0x0e, 0xee, 0x0f, 0x09, 0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a,
+    0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec, 0x10, 0x09, 0x10, 0x26,
+    0x10, 0x43, 0x10, 0x61, 0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7,
+    0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f, 0x11, 0x6d, 0x11, 0x8c,
+    0x11, 0xaa, 0x11, 0xc9, 0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45,
+    0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3, 0x12, 0xe3, 0x13, 0x03,
+    0x13, 0x23, 0x13, 0x43, 0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5,
+    0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49, 0x14, 0x6a, 0x14, 0x8b,
+    0x14, 0xad, 0x14, 0xce, 0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56,
+    0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0, 0x16, 0x03, 0x16, 0x26,
+    0x16, 0x49, 0x16, 0x6c, 0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa,
+    0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89, 0x17, 0xae, 0x17, 0xd2,
+    0x17, 0xf7, 0x18, 0x1b, 0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf,
+    0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45, 0x19, 0x6b, 0x19, 0x91,
+    0x19, 0xb7, 0x19, 0xdd, 0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77,
+    0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14, 0x1b, 0x3b, 0x1b, 0x63,
+    0x1b, 0x8a, 0x1b, 0xb2, 0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52,
+    0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5, 0x1d, 0x1e, 0x1d, 0x47,
+    0x1d, 0x70, 0x1d, 0x99, 0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40,
+    0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9, 0x1f, 0x13, 0x1f, 0x3e,
+    0x1f, 0x69, 0x1f, 0x94, 0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41,
+    0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0, 0x21, 0x1c, 0x21, 0x48,
+    0x21, 0x75, 0x21, 0xa1, 0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55,
+    0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a, 0x23, 0x38, 0x23, 0x66,
+    0x23, 0x94, 0x23, 0xc2, 0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c,
+    0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38, 0x25, 0x68, 0x25, 0x97,
+    0x25, 0xc7, 0x25, 0xf7, 0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7,
+    0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a, 0x27, 0xab, 0x27, 0xdc,
+    0x28, 0x0d, 0x28, 0x3f, 0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06,
+    0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0, 0x2a, 0x02, 0x2a, 0x35,
+    0x2a, 0x68, 0x2a, 0x9b, 0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69,
+    0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39, 0x2c, 0x6e, 0x2c, 0xa2,
+    0x2c, 0xd7, 0x2d, 0x0c, 0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1,
+    0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7, 0x2e, 0xee, 0x2f, 0x24,
+    0x2f, 0x5a, 0x2f, 0x91, 0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c,
+    0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a, 0x31, 0x82, 0x31, 0xba,
+    0x31, 0xf2, 0x32, 0x2a, 0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d,
+    0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1, 0x34, 0x2b, 0x34, 0x65,
+    0x34, 0x9e, 0x34, 0xd8, 0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2,
+    0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae, 0x36, 0xe9, 0x37, 0x24,
+    0x37, 0x60, 0x37, 0x9c, 0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c,
+    0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f, 0x39, 0xbc, 0x39, 0xf9,
+    0x3a, 0x36, 0x3a, 0x74, 0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b,
+    0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65, 0x3c, 0xa4, 0x3c, 0xe3,
+    0x3d, 0x22, 0x3d, 0x61, 0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60,
+    0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61, 0x3f, 0xa2, 0x3f, 0xe2,
+    0x40, 0x23, 0x40, 0x64, 0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a,
+    0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72, 0x42, 0xb5, 0x42, 0xf7,
+    0x43, 0x3a, 0x43, 0x7d, 0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a,
+    0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a, 0x45, 0xde, 0x46, 0x22,
+    0x46, 0x67, 0x46, 0xab, 0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0,
+    0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7, 0x49, 0x1d, 0x49, 0x63,
+    0x49, 0xa9, 0x49, 0xf0, 0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c,
+    0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a, 0x4c, 0x72, 0x4c, 0xba,
+    0x4d, 0x02, 0x4d, 0x4a, 0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e,
+    0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93, 0x4f, 0xdd, 0x50, 0x27,
+    0x50, 0x71, 0x50, 0xbb, 0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6,
+    0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13, 0x53, 0x5f, 0x53, 0xaa,
+    0x53, 0xf6, 0x54, 0x42, 0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75,
+    0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9, 0x56, 0xf7, 0x57, 0x44,
+    0x57, 0x92, 0x57, 0xe0, 0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a,
+    0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56, 0x5a, 0xa6, 0x5a, 0xf5,
+    0x5b, 0x45, 0x5b, 0x95, 0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6,
+    0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a, 0x5e, 0x6c, 0x5e, 0xbd,
+    0x5f, 0x0f, 0x5f, 0x61, 0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa,
+    0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5, 0x62, 0x49, 0x62, 0x9c,
+    0x62, 0xf0, 0x63, 0x43, 0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94,
+    0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7, 0x66, 0x3d, 0x66, 0x92,
+    0x66, 0xe8, 0x67, 0x3d, 0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96,
+    0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1, 0x6a, 0x48, 0x6a, 0x9f,
+    0x6a, 0xf7, 0x6b, 0x4f, 0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf,
+    0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12, 0x6e, 0x6b, 0x6e, 0xc4,
+    0x6f, 0x1e, 0x6f, 0x78, 0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0,
+    0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b, 0x72, 0xa6, 0x73, 0x01,
+    0x73, 0x5d, 0x73, 0xb8, 0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28,
+    0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b, 0x76, 0xf8, 0x77, 0x56,
+    0x77, 0xb3, 0x78, 0x11, 0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89,
+    0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04, 0x7b, 0x63, 0x7b, 0xc2,
+    0x7c, 0x21, 0x7c, 0x81, 0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01,
+    0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84, 0x7f, 0xe5, 0x80, 0x47,
+    0x80, 0xa8, 0x81, 0x0a, 0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92,
+    0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d, 0x84, 0x80, 0x84, 0xe3,
+    0x85, 0x47, 0x85, 0xab, 0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b,
+    0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce, 0x89, 0x33, 0x89, 0x99,
+    0x89, 0xfe, 0x8a, 0x64, 0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc,
+    0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98, 0x8d, 0xff, 0x8e, 0x66,
+    0x8e, 0xce, 0x8f, 0x36, 0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6,
+    0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a, 0x92, 0xe3, 0x93, 0x4d,
+    0x93, 0xb6, 0x94, 0x20, 0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9,
+    0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75, 0x97, 0xe0, 0x98, 0x4c,
+    0x98, 0xb8, 0x99, 0x24, 0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5,
+    0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89, 0x9c, 0xf7, 0x9d, 0x64,
+    0x9d, 0xd2, 0x9e, 0x40, 0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa,
+    0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6, 0xa2, 0x26, 0xa2, 0x96,
+    0xa3, 0x06, 0xa3, 0x76, 0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38,
+    0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd, 0xa7, 0x6e, 0xa7, 0xe0,
+    0xa8, 0x52, 0xa8, 0xc4, 0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f,
+    0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c, 0xac, 0xd0, 0xad, 0x44,
+    0xad, 0xb8, 0xae, 0x2d, 0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00,
+    0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6, 0xb2, 0x4b, 0xb2, 0xc2,
+    0xb3, 0x38, 0xb3, 0xae, 0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a,
+    0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68, 0xb7, 0xe0, 0xb8, 0x59,
+    0xb8, 0xd1, 0xb9, 0x4a, 0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e,
+    0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15, 0xbd, 0x8f, 0xbe, 0x0a,
+    0xbe, 0x84, 0xbe, 0xff, 0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec,
+    0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb, 0xc3, 0x58, 0xc3, 0xd4,
+    0xc4, 0x51, 0xc4, 0xce, 0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3,
+    0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc, 0xc9, 0x3a, 0xc9, 0xb9,
+    0xca, 0x38, 0xca, 0xb7, 0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5,
+    0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6, 0xcf, 0x37, 0xcf, 0xb8,
+    0xd0, 0x39, 0xd0, 0xba, 0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1,
+    0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb, 0xd5, 0x4e, 0xd5, 0xd1,
+    0xd6, 0x55, 0xd6, 0xd8, 0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8,
+    0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb, 0xdb, 0x80, 0xdc, 0x05,
+    0xdc, 0x8a, 0xdd, 0x10, 0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29,
+    0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44, 0xe1, 0xcc, 0xe2, 0x53,
+    0xe2, 0xdb, 0xe3, 0x63, 0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84,
+    0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9, 0xe8, 0x32, 0xe8, 0xbc,
+    0xe9, 0x46, 0xe9, 0xd0, 0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb,
+    0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28, 0xee, 0xb4, 0xef, 0x40,
+    0xef, 0xcc, 0xf0, 0x58, 0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c,
+    0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2, 0xf5, 0x50, 0xf5, 0xde,
+    0xf6, 0x6d, 0xf6, 0xfb, 0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38,
+    0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77, 0xfc, 0x07, 0xfc, 0x98,
+    0xfd, 0x29, 0xfd, 0xba, 0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff};
+
+const unsigned char colorspin_profile_data[] = {
+    0x00, 0x00, 0x01, 0xea, 0x54, 0x45, 0x53, 0x54, 0x00, 0x00, 0x00, 0x00,
+    0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x61, 0x63, 0x73, 0x70, 0x74, 0x65, 0x73, 0x74, 0x00, 0x00, 0x00, 0x00,
+    0x74, 0x65, 0x73, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x74, 0x65, 0x73, 0x74,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x0d,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x8c,
+    0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x8c, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x01, 0xa0, 0x00, 0x00, 0x00, 0x14,
+    0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x01, 0xb4, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x01, 0xc8, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xdc, 0x00, 0x00, 0x00, 0x0e,
+    0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xdc, 0x00, 0x00, 0x00, 0x0e,
+    0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xdc, 0x00, 0x00, 0x00, 0x0e,
+    0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x77, 0x68, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x2e,
+    0x69, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3, 0x52,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x8d, 0x00, 0x00, 0xa0, 0x2c,
+    0x00, 0x00, 0x0f, 0x95, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x26, 0x31, 0x00, 0x00, 0x10, 0x2f, 0x00, 0x00, 0xbe, 0x9b,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0x18,
+    0x00, 0x00, 0x4f, 0xa5, 0x00, 0x00, 0x04, 0xfc, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x33};
+
+const unsigned char adobe_rgb_profile_data[] = {
+    0x00, 0x00, 0x02, 0x30, 0x41, 0x44, 0x42, 0x45, 0x02, 0x10, 0x00, 0x00,
+    0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x07, 0xd0, 0x00, 0x08, 0x00, 0x0b, 0x00, 0x13, 0x00, 0x33, 0x00, 0x3b,
+    0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4c, 0x00, 0x00, 0x00, 0x00,
+    0x6e, 0x6f, 0x6e, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x41, 0x44, 0x42, 0x45,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x32,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x6b,
+    0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x9c, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x01, 0xb0, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xc4, 0x00, 0x00, 0x00, 0x0e,
+    0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xd4, 0x00, 0x00, 0x00, 0x0e,
+    0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 0x00, 0x0e,
+    0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x01, 0xf4, 0x00, 0x00, 0x00, 0x14,
+    0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x1c, 0x00, 0x00, 0x00, 0x14,
+    0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
+    0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x32, 0x30, 0x30, 0x30, 0x20, 0x41,
+    0x64, 0x6f, 0x62, 0x65, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73,
+    0x20, 0x49, 0x6e, 0x63, 0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x65,
+    0x64, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x11, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x20, 0x52, 0x47,
+    0x42, 0x20, 0x28, 0x31, 0x39, 0x39, 0x38, 0x29, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xcc,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x33, 0x00, 0x00,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x02, 0x33, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x02, 0x33, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0x18, 0x00, 0x00, 0x4f, 0xa5,
+    0x00, 0x00, 0x04, 0xfc, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x34, 0x8d, 0x00, 0x00, 0xa0, 0x2c, 0x00, 0x00, 0x0f, 0x95,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x31,
+    0x00, 0x00, 0x10, 0x2f, 0x00, 0x00, 0xbe, 0x9c};
+}
+
+unsigned char no_analytic_tr_fn_profile_data[] = {
+    0x00, 0x00, 0x07, 0xd4, 0x00, 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00,
+    0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x61, 0x63, 0x73, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x34,
+    0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x01, 0x24, 0x00, 0x00, 0x00, 0x14,
+    0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x01, 0x38, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x01, 0x4c, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x02, 0x0c,
+    0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x03, 0x6c, 0x00, 0x00, 0x02, 0x0c,
+    0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x05, 0x78, 0x00, 0x00, 0x02, 0x0c,
+    0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x07, 0x84, 0x00, 0x00, 0x00, 0x14,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x07, 0x98, 0x00, 0x00, 0x00, 0x3c,
+    0x6d, 0x6c, 0x75, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0c, 0x65, 0x6e, 0x55, 0x53, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x47, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x67,
+    0x00, 0x6c, 0x00, 0x65, 0x00, 0x20, 0x00, 0x53, 0x00, 0x6b, 0x00, 0x69,
+    0x00, 0x61, 0x00, 0x20, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x73, 0x04, 0x00, 0x00, 0x39, 0x77, 0x00, 0x00, 0x00, 0x4a,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0xf1,
+    0x00, 0x00, 0xb8, 0xec, 0x00, 0x00, 0x0d, 0xb6, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0xe1, 0x00, 0x00, 0x0d, 0x9d,
+    0x00, 0x00, 0xc5, 0x2d, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x06, 0x00, 0x09,
+    0x00, 0x0c, 0x00, 0x0f, 0x00, 0x12, 0x00, 0x15, 0x00, 0x18, 0x00, 0x1b,
+    0x00, 0x1f, 0x00, 0x24, 0x00, 0x2b, 0x00, 0x34, 0x00, 0x3e, 0x00, 0x4a,
+    0x00, 0x58, 0x00, 0x68, 0x00, 0x79, 0x00, 0x8c, 0x00, 0xa1, 0x00, 0xb8,
+    0x00, 0xd1, 0x00, 0xeb, 0x01, 0x08, 0x01, 0x27, 0x01, 0x47, 0x01, 0x69,
+    0x01, 0x8e, 0x01, 0xb4, 0x01, 0xdd, 0x02, 0x07, 0x02, 0x33, 0x02, 0x62,
+    0x02, 0x92, 0x02, 0xc4, 0x02, 0xf9, 0x03, 0x2f, 0x03, 0x68, 0x03, 0xa2,
+    0x03, 0xdf, 0x04, 0x1d, 0x04, 0x5e, 0x04, 0xa0, 0x04, 0xe5, 0x05, 0x2c,
+    0x05, 0x75, 0x05, 0xbf, 0x06, 0x0c, 0x06, 0x5a, 0x06, 0xab, 0x06, 0xfd,
+    0x07, 0x51, 0x07, 0xa8, 0x08, 0x00, 0x08, 0x5a, 0x08, 0xb6, 0x09, 0x14,
+    0x09, 0x74, 0x09, 0xd5, 0x0a, 0x39, 0x0a, 0x9e, 0x0b, 0x05, 0x0b, 0x6e,
+    0x0b, 0xd9, 0x0c, 0x46, 0x0c, 0xb4, 0x0d, 0x24, 0x0d, 0x96, 0x0e, 0x0a,
+    0x0e, 0x7f, 0x0e, 0xf7, 0x0f, 0x6f, 0x0f, 0xea, 0x10, 0x65, 0x10, 0xe3,
+    0x11, 0x62, 0x11, 0xe2, 0x12, 0x65, 0x12, 0xe8, 0x13, 0x6d, 0x13, 0xf4,
+    0x14, 0x7c, 0x15, 0x05, 0x15, 0x90, 0x16, 0x1c, 0x16, 0xaa, 0x17, 0x39,
+    0x17, 0xca, 0x18, 0x5c, 0x18, 0xf1, 0x19, 0x86, 0x1a, 0x1d, 0x1a, 0xb7,
+    0x1b, 0x52, 0x1b, 0xf0, 0x1c, 0x8f, 0x1d, 0x31, 0x1d, 0xd6, 0x1e, 0x7d,
+    0x1f, 0x26, 0x1f, 0xd2, 0x20, 0x80, 0x21, 0x31, 0x21, 0xe4, 0x22, 0x9a,
+    0x23, 0x52, 0x24, 0x0d, 0x24, 0xca, 0x25, 0x8b, 0x26, 0x4e, 0x27, 0x14,
+    0x27, 0xde, 0x28, 0xaa, 0x29, 0x7a, 0x2a, 0x4c, 0x2b, 0x22, 0x2b, 0xfc,
+    0x2c, 0xd9, 0x2d, 0xb8, 0x2e, 0x9b, 0x2f, 0x81, 0x30, 0x69, 0x31, 0x54,
+    0x32, 0x42, 0x33, 0x32, 0x34, 0x25, 0x35, 0x1a, 0x36, 0x12, 0x37, 0x0d,
+    0x38, 0x09, 0x39, 0x07, 0x3a, 0x07, 0x3b, 0x09, 0x3c, 0x0d, 0x3d, 0x12,
+    0x3e, 0x19, 0x3f, 0x22, 0x40, 0x2e, 0x41, 0x3a, 0x42, 0x47, 0x43, 0x56,
+    0x44, 0x67, 0x45, 0x79, 0x46, 0x8d, 0x47, 0xa3, 0x48, 0xbb, 0x49, 0xd7,
+    0x4a, 0xf5, 0x4c, 0x13, 0x4d, 0x34, 0x4e, 0x58, 0x4f, 0x80, 0x50, 0xab,
+    0x51, 0xda, 0x53, 0x0c, 0x54, 0x44, 0x55, 0x7f, 0x56, 0xbe, 0x58, 0x02,
+    0x59, 0x4b, 0x5a, 0x99, 0x5b, 0xec, 0x5d, 0x45, 0x5e, 0xa2, 0x60, 0x03,
+    0x61, 0x67, 0x62, 0xcf, 0x64, 0x3b, 0x65, 0xab, 0x67, 0x1e, 0x68, 0x93,
+    0x6a, 0x05, 0x6b, 0x77, 0x6c, 0xe7, 0x6e, 0x57, 0x6f, 0xc7, 0x71, 0x38,
+    0x72, 0xaa, 0x74, 0x1b, 0x75, 0x8c, 0x76, 0xfe, 0x78, 0x71, 0x79, 0xe6,
+    0x7b, 0x5d, 0x7c, 0xd4, 0x7e, 0x4c, 0x7f, 0xc6, 0x81, 0x42, 0x82, 0xc2,
+    0x84, 0x48, 0x85, 0xd2, 0x87, 0x61, 0x88, 0xf4, 0x8a, 0x8c, 0x8c, 0x28,
+    0x8d, 0xc8, 0x8f, 0x6c, 0x91, 0x12, 0x92, 0xbd, 0x94, 0x6a, 0x96, 0x19,
+    0x97, 0xcb, 0x99, 0x80, 0x9b, 0x36, 0x9c, 0xee, 0x9e, 0xa7, 0xa0, 0x61,
+    0xa2, 0x1c, 0xa3, 0xda, 0xa5, 0x9a, 0xa7, 0x5f, 0xa9, 0x28, 0xaa, 0xf5,
+    0xac, 0xc5, 0xae, 0x95, 0xb0, 0x66, 0xb2, 0x38, 0xb4, 0x0c, 0xb5, 0xe5,
+    0xb7, 0xc5, 0xb9, 0xac, 0xbb, 0x9b, 0xbd, 0x90, 0xbf, 0x8a, 0xc1, 0x8a,
+    0xc3, 0x8f, 0xc5, 0x98, 0xc7, 0xa8, 0xc9, 0xbe, 0xcb, 0xdd, 0xce, 0x01,
+    0xd0, 0x23, 0xd2, 0x42, 0xd4, 0x63, 0xd6, 0x84, 0xd8, 0xa5, 0xda, 0xc7,
+    0xdc, 0xe9, 0xdf, 0x09, 0xe1, 0x26, 0xe3, 0x40, 0xe5, 0x58, 0xe7, 0x6c,
+    0xe9, 0x81, 0xeb, 0x94, 0xed, 0xa5, 0xef, 0xb5, 0xf1, 0xc4, 0xf3, 0xd1,
+    0xf5, 0xdd, 0xf7, 0xe6, 0xf9, 0xef, 0xfb, 0xf6, 0xfd, 0xfb, 0xff, 0xff,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x05, 0x00, 0x07, 0x00, 0x09, 0x00, 0x0c,
+    0x00, 0x0f, 0x00, 0x13, 0x00, 0x18, 0x00, 0x1f, 0x00, 0x26, 0x00, 0x30,
+    0x00, 0x3a, 0x00, 0x46, 0x00, 0x54, 0x00, 0x63, 0x00, 0x73, 0x00, 0x85,
+    0x00, 0x99, 0x00, 0xae, 0x00, 0xc5, 0x00, 0xdd, 0x00, 0xf7, 0x01, 0x12,
+    0x01, 0x30, 0x01, 0x4e, 0x01, 0x6f, 0x01, 0x91, 0x01, 0xb5, 0x01, 0xdb,
+    0x02, 0x02, 0x02, 0x2b, 0x02, 0x56, 0x02, 0x83, 0x02, 0xb2, 0x02, 0xe2,
+    0x03, 0x14, 0x03, 0x48, 0x03, 0x7e, 0x03, 0xb6, 0x03, 0xef, 0x04, 0x2a,
+    0x04, 0x68, 0x04, 0xa7, 0x04, 0xe8, 0x05, 0x2b, 0x05, 0x70, 0x05, 0xb7,
+    0x06, 0x00, 0x06, 0x4b, 0x06, 0x98, 0x06, 0xe6, 0x07, 0x37, 0x07, 0x8a,
+    0x07, 0xdf, 0x08, 0x36, 0x08, 0x90, 0x08, 0xeb, 0x09, 0x48, 0x09, 0xa7,
+    0x0a, 0x08, 0x0a, 0x6c, 0x0a, 0xd1, 0x0b, 0x39, 0x0b, 0xa3, 0x0c, 0x0e,
+    0x0c, 0x7c, 0x0c, 0xed, 0x0d, 0x5f, 0x0d, 0xd4, 0x0e, 0x4a, 0x0e, 0xc3,
+    0x0f, 0x3e, 0x0f, 0xbc, 0x10, 0x3c, 0x10, 0xbd, 0x11, 0x42, 0x11, 0xc8,
+    0x12, 0x51, 0x12, 0xdc, 0x13, 0x69, 0x13, 0xf9, 0x14, 0x8b, 0x15, 0x20,
+    0x15, 0xb6, 0x16, 0x50, 0x16, 0xeb, 0x17, 0x88, 0x18, 0x28, 0x18, 0xca,
+    0x19, 0x6e, 0x1a, 0x16, 0x1a, 0xbe, 0x1b, 0x69, 0x1c, 0x16, 0x1c, 0xc6,
+    0x1d, 0x77, 0x1e, 0x2a, 0x1e, 0xdf, 0x1f, 0x96, 0x20, 0x4e, 0x21, 0x08,
+    0x21, 0xc4, 0x22, 0x81, 0x23, 0x3f, 0x23, 0xff, 0x24, 0xc0, 0x25, 0x82,
+    0x26, 0x47, 0x27, 0x0e, 0x27, 0xd6, 0x28, 0xa1, 0x29, 0x6d, 0x2a, 0x3b,
+    0x2b, 0x0d, 0x2b, 0xdf, 0x2c, 0xb2, 0x2d, 0x87, 0x2e, 0x5e, 0x2f, 0x37,
+    0x30, 0x11, 0x30, 0xed, 0x31, 0xcb, 0x32, 0xaa, 0x33, 0x8c, 0x34, 0x6f,
+    0x35, 0x56, 0x36, 0x3f, 0x37, 0x2a, 0x38, 0x18, 0x39, 0x09, 0x39, 0xfd,
+    0x3a, 0xf4, 0x3b, 0xf0, 0x3c, 0xef, 0x3d, 0xf1, 0x3e, 0xf7, 0x40, 0x00,
+    0x41, 0x0d, 0x42, 0x1d, 0x43, 0x31, 0x44, 0x49, 0x45, 0x64, 0x46, 0x82,
+    0x47, 0xa4, 0x48, 0xc9, 0x49, 0xf1, 0x4b, 0x1a, 0x4c, 0x46, 0x4d, 0x75,
+    0x4e, 0xa4, 0x4f, 0xd6, 0x51, 0x0a, 0x52, 0x40, 0x53, 0x78, 0x54, 0xb2,
+    0x55, 0xee, 0x57, 0x2d, 0x58, 0x6f, 0x59, 0xb3, 0x5a, 0xfa, 0x5c, 0x44,
+    0x5d, 0x91, 0x5e, 0xe2, 0x60, 0x35, 0x61, 0x8b, 0x62, 0xe4, 0x64, 0x3e,
+    0x65, 0x9c, 0x66, 0xfb, 0x68, 0x5b, 0x69, 0xbb, 0x6b, 0x1b, 0x6c, 0x7b,
+    0x6d, 0xda, 0x6f, 0x3a, 0x70, 0x9b, 0x71, 0xfd, 0x73, 0x61, 0x74, 0xc8,
+    0x76, 0x32, 0x77, 0x9f, 0x79, 0x0e, 0x7a, 0x7f, 0x7b, 0xf3, 0x7d, 0x6a,
+    0x7e, 0xe3, 0x80, 0x5f, 0x81, 0xdd, 0x83, 0x61, 0x84, 0xe9, 0x86, 0x75,
+    0x88, 0x06, 0x89, 0x9d, 0x8b, 0x37, 0x8c, 0xd8, 0x8e, 0x7d, 0x90, 0x28,
+    0x91, 0xd6, 0x93, 0x87, 0x95, 0x38, 0x96, 0xe9, 0x98, 0x9a, 0x9a, 0x4b,
+    0x9b, 0xfd, 0x9d, 0xb2, 0x9f, 0x69, 0xa1, 0x22, 0xa2, 0xde, 0xa4, 0x98,
+    0xa6, 0x53, 0xa8, 0x0d, 0xa9, 0xc7, 0xab, 0x80, 0xad, 0x3d, 0xae, 0xfe,
+    0xb0, 0xc3, 0xb2, 0x8d, 0xb4, 0x5d, 0xb6, 0x30, 0xb8, 0x0a, 0xb9, 0xec,
+    0xbb, 0xd8, 0xbd, 0xce, 0xbf, 0xcf, 0xc1, 0xd9, 0xc3, 0xed, 0xc6, 0x0d,
+    0xc8, 0x36, 0xca, 0x66, 0xcc, 0x9c, 0xce, 0xd6, 0xd1, 0x11, 0xd3, 0x4d,
+    0xd5, 0x89, 0xd7, 0xc2, 0xd9, 0xf9, 0xdc, 0x2d, 0xde, 0x5b, 0xe0, 0x83,
+    0xe2, 0xa1, 0xe4, 0xb6, 0xe6, 0xc7, 0xe8, 0xd1, 0xea, 0xd8, 0xec, 0xda,
+    0xee, 0xd8, 0xf0, 0xd1, 0xf2, 0xc6, 0xf4, 0xb6, 0xf6, 0xa2, 0xf8, 0x8b,
+    0xfa, 0x6e, 0xfc, 0x4e, 0xfe, 0x28, 0xff, 0xff, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x03, 0x00, 0x05, 0x00, 0x07, 0x00, 0x0a, 0x00, 0x0e, 0x00, 0x13,
+    0x00, 0x19, 0x00, 0x20, 0x00, 0x28, 0x00, 0x31, 0x00, 0x3c, 0x00, 0x47,
+    0x00, 0x54, 0x00, 0x63, 0x00, 0x72, 0x00, 0x83, 0x00, 0x95, 0x00, 0xa9,
+    0x00, 0xbe, 0x00, 0xd4, 0x00, 0xec, 0x01, 0x06, 0x01, 0x21, 0x01, 0x3d,
+    0x01, 0x5b, 0x01, 0x7a, 0x01, 0x9b, 0x01, 0xbe, 0x01, 0xe2, 0x02, 0x08,
+    0x02, 0x2f, 0x02, 0x58, 0x02, 0x83, 0x02, 0xb0, 0x02, 0xde, 0x03, 0x0e,
+    0x03, 0x3f, 0x03, 0x72, 0x03, 0xa8, 0x03, 0xde, 0x04, 0x17, 0x04, 0x52,
+    0x04, 0x8e, 0x04, 0xcc, 0x05, 0x0c, 0x05, 0x4e, 0x05, 0x92, 0x05, 0xd8,
+    0x06, 0x1f, 0x06, 0x69, 0x06, 0xb5, 0x07, 0x02, 0x07, 0x52, 0x07, 0xa3,
+    0x07, 0xf7, 0x08, 0x4d, 0x08, 0xa5, 0x08, 0xff, 0x09, 0x5b, 0x09, 0xb9,
+    0x0a, 0x19, 0x0a, 0x7c, 0x0a, 0xe0, 0x0b, 0x47, 0x0b, 0xb0, 0x0c, 0x1c,
+    0x0c, 0x8a, 0x0c, 0xfa, 0x0d, 0x6c, 0x0d, 0xe1, 0x0e, 0x58, 0x0e, 0xd1,
+    0x0f, 0x4d, 0x0f, 0xcb, 0x10, 0x4c, 0x10, 0xcf, 0x11, 0x55, 0x11, 0xdd,
+    0x12, 0x68, 0x12, 0xf5, 0x13, 0x85, 0x14, 0x17, 0x14, 0xac, 0x15, 0x44,
+    0x15, 0xe0, 0x16, 0x7c, 0x17, 0x1a, 0x17, 0xba, 0x18, 0x5c, 0x19, 0x00,
+    0x19, 0xa6, 0x1a, 0x4d, 0x1a, 0xf7, 0x1b, 0xa2, 0x1c, 0x50, 0x1d, 0x00,
+    0x1d, 0xb1, 0x1e, 0x65, 0x1f, 0x1a, 0x1f, 0xd1, 0x20, 0x89, 0x21, 0x43,
+    0x21, 0xfe, 0x22, 0xba, 0x23, 0x78, 0x24, 0x37, 0x24, 0xf6, 0x25, 0xb7,
+    0x26, 0x7a, 0x27, 0x3d, 0x28, 0x02, 0x28, 0xc8, 0x29, 0x8f, 0x2a, 0x58,
+    0x2b, 0x22, 0x2b, 0xee, 0x2c, 0xbc, 0x2d, 0x8e, 0x2e, 0x62, 0x2f, 0x38,
+    0x30, 0x12, 0x30, 0xee, 0x31, 0xce, 0x32, 0xb0, 0x33, 0x95, 0x34, 0x7d,
+    0x35, 0x67, 0x36, 0x54, 0x37, 0x44, 0x38, 0x37, 0x39, 0x2c, 0x3a, 0x25,
+    0x3b, 0x21, 0x3c, 0x20, 0x3d, 0x23, 0x3e, 0x2a, 0x3f, 0x34, 0x40, 0x42,
+    0x41, 0x52, 0x42, 0x64, 0x43, 0x78, 0x44, 0x8e, 0x45, 0xa6, 0x46, 0xc0,
+    0x47, 0xdb, 0x48, 0xf9, 0x4a, 0x17, 0x4b, 0x37, 0x4c, 0x58, 0x4d, 0x7b,
+    0x4e, 0x9f, 0x4f, 0xc5, 0x50, 0xee, 0x52, 0x18, 0x53, 0x45, 0x54, 0x74,
+    0x55, 0xa4, 0x56, 0xd9, 0x58, 0x12, 0x59, 0x50, 0x5a, 0x93, 0x5b, 0xdb,
+    0x5d, 0x28, 0x5e, 0x7b, 0x5f, 0xd3, 0x61, 0x31, 0x62, 0x93, 0x63, 0xf9,
+    0x65, 0x64, 0x66, 0xd3, 0x68, 0x46, 0x69, 0xbb, 0x6b, 0x34, 0x6c, 0xab,
+    0x6e, 0x21, 0x6f, 0x95, 0x71, 0x08, 0x72, 0x7a, 0x73, 0xeb, 0x75, 0x5d,
+    0x76, 0xce, 0x78, 0x3e, 0x79, 0xae, 0x7b, 0x1e, 0x7c, 0x8c, 0x7d, 0xfa,
+    0x7f, 0x67, 0x80, 0xd5, 0x82, 0x4a, 0x83, 0xc6, 0x85, 0x4a, 0x86, 0xd6,
+    0x88, 0x6a, 0x8a, 0x07, 0x8b, 0xac, 0x8d, 0x5c, 0x8f, 0x14, 0x90, 0xd6,
+    0x92, 0xa0, 0x94, 0x73, 0x96, 0x4e, 0x98, 0x2b, 0x9a, 0x09, 0x9b, 0xe7,
+    0x9d, 0xc6, 0x9f, 0xa4, 0xa1, 0x82, 0xa3, 0x5e, 0xa5, 0x35, 0xa7, 0x09,
+    0xa8, 0xd9, 0xaa, 0xa5, 0xac, 0x71, 0xae, 0x40, 0xb0, 0x12, 0xb1, 0xe8,
+    0xb3, 0xc1, 0xb5, 0x9f, 0xb7, 0x83, 0xb9, 0x6f, 0xbb, 0x61, 0xbd, 0x5c,
+    0xbf, 0x60, 0xc1, 0x6c, 0xc3, 0x7b, 0xc5, 0x8c, 0xc7, 0xa1, 0xc9, 0xb7,
+    0xcb, 0xcd, 0xcd, 0xe4, 0xcf, 0xf7, 0xd2, 0x07, 0xd4, 0x12, 0xd6, 0x18,
+    0xd8, 0x21, 0xda, 0x2f, 0xdc, 0x41, 0xde, 0x57, 0xe0, 0x6f, 0xe2, 0x88,
+    0xe4, 0xa1, 0xe6, 0xbd, 0xe8, 0xdc, 0xeb, 0x03, 0xed, 0x29, 0xef, 0x4c,
+    0xf1, 0x6c, 0xf3, 0x89, 0xf5, 0xa4, 0xf7, 0xbc, 0xf9, 0xd1, 0xfb, 0xe3,
+    0xfd, 0xf2, 0xff, 0xff, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
+    0x6d, 0x6c, 0x75, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0c, 0x65, 0x6e, 0x55, 0x53, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x47, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x67,
+    0x00, 0x6c, 0x00, 0x65, 0x00, 0x20, 0x00, 0x49, 0x00, 0x6e, 0x00, 0x63,
+    0x00, 0x2e, 0x00, 0x20, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31, 0x00, 0x36};
+
+const unsigned char a2b_only_profile_data[] = {
+    0x00, 0x00, 0x0f, 0xd8, 0x41, 0x44, 0x42, 0x45, 0x04, 0x00, 0x00, 0x00,
+    0x73, 0x63, 0x6e, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x07, 0xd2, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4c, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x41, 0x44, 0x42, 0x45,
+    0x90, 0x51, 0xe0, 0x2b, 0x81, 0x28, 0xa4, 0x4d, 0x54, 0xfa, 0xae, 0x96,
+    0xfb, 0x1a, 0x46, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x6e,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x54, 0x00, 0x00, 0x00, 0x30,
+    0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x84, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x01, 0x98, 0x00, 0x00, 0x00, 0x14,
+    0x63, 0x68, 0x61, 0x64, 0x00, 0x00, 0x01, 0xac, 0x00, 0x00, 0x00, 0x2c,
+    0x41, 0x32, 0x42, 0x30, 0x00, 0x00, 0x01, 0xd8, 0x00, 0x00, 0x07, 0x00,
+    0x41, 0x32, 0x42, 0x32, 0x00, 0x00, 0x01, 0xd8, 0x00, 0x00, 0x07, 0x00,
+    0x41, 0x32, 0x42, 0x31, 0x00, 0x00, 0x08, 0xd8, 0x00, 0x00, 0x07, 0x00,
+    0x6d, 0x6c, 0x75, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0c, 0x65, 0x6e, 0x55, 0x53, 0x00, 0x00, 0x00, 0x52,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x79,
+    0x00, 0x72, 0x00, 0x69, 0x00, 0x67, 0x00, 0x68, 0x00, 0x74, 0x00, 0x20,
+    0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x32, 0x00, 0x20, 0x00, 0x41,
+    0x00, 0x64, 0x00, 0x6f, 0x00, 0x62, 0x00, 0x65, 0x00, 0x20, 0x00, 0x53,
+    0x00, 0x79, 0x00, 0x73, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6d, 0x00, 0x73,
+    0x00, 0x20, 0x00, 0x49, 0x00, 0x6e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x72,
+    0x00, 0x70, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65,
+    0x00, 0x64, 0x00, 0x00, 0x6d, 0x6c, 0x75, 0x63, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x65, 0x6e, 0x55, 0x53,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x73, 0x00, 0x59,
+    0x00, 0x43, 0x00, 0x43, 0x00, 0x20, 0x00, 0x38, 0x00, 0x2d, 0x00, 0x62,
+    0x00, 0x69, 0x00, 0x74, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x16,
+    0x00, 0x00, 0x03, 0x33, 0x00, 0x00, 0x02, 0xa4, 0x73, 0x66, 0x33, 0x32,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0c, 0x3f, 0x00, 0x00, 0x05, 0xdc,
+    0xff, 0xff, 0xf3, 0x26, 0x00, 0x00, 0x07, 0x90, 0x00, 0x00, 0xfd, 0x92,
+    0xff, 0xff, 0xfb, 0xa1, 0xff, 0xff, 0xfd, 0xa2, 0x00, 0x00, 0x03, 0xdc,
+    0x00, 0x00, 0xc0, 0x71, 0x6d, 0x41, 0x42, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x44,
+    0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x06, 0x98, 0x00, 0x00, 0x06, 0xdc,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x19, 0xde, 0x00, 0x00, 0xf8, 0xf2, 0x00, 0x00, 0x5c, 0x7d,
+    0x00, 0x00, 0x8f, 0xcc, 0x00, 0x01, 0xcf, 0x78, 0x00, 0x00, 0x27, 0x30,
+    0x00, 0x00, 0x08, 0xfc, 0x00, 0x00, 0x3e, 0xc1, 0x00, 0x01, 0xcd, 0x84,
+    0xff, 0xff, 0xa2, 0x21, 0xff, 0xff, 0x9e, 0xa4, 0xff, 0xff, 0xaf, 0xb0,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x10, 0x02, 0x1b, 0x03, 0x22, 0x04, 0x24, 0x05, 0x23,
+    0x06, 0x1d, 0x07, 0x12, 0x08, 0x04, 0x08, 0xf1, 0x09, 0xda, 0x0a, 0xbe,
+    0x0b, 0x9f, 0x0c, 0x7b, 0x0d, 0x53, 0x0e, 0x28, 0x0e, 0xf8, 0x0f, 0xc3,
+    0x10, 0x8b, 0x11, 0x4f, 0x12, 0x0f, 0x12, 0xcb, 0x13, 0x83, 0x14, 0x37,
+    0x14, 0xe7, 0x15, 0x93, 0x16, 0x3c, 0x16, 0xe0, 0x17, 0x81, 0x18, 0x1e,
+    0x18, 0xb7, 0x19, 0x4d, 0x19, 0xdf, 0x1a, 0x6d, 0x1a, 0xf7, 0x1b, 0x7e,
+    0x1c, 0x01, 0x1c, 0x81, 0x1c, 0xfd, 0x1d, 0x76, 0x1d, 0xeb, 0x1e, 0x5d,
+    0x1e, 0xcb, 0x1f, 0x36, 0x1f, 0x9e, 0x20, 0x02, 0x20, 0x63, 0x20, 0xc1,
+    0x21, 0x1b, 0x21, 0x73, 0x21, 0xc7, 0x22, 0x18, 0x22, 0x66, 0x22, 0xb0,
+    0x22, 0xf8, 0x23, 0x3d, 0x23, 0x7f, 0x23, 0xbe, 0x23, 0xfa, 0x24, 0x33,
+    0x24, 0x69, 0x24, 0x9d, 0x24, 0xce, 0x24, 0xfc, 0x25, 0x28, 0x25, 0x51,
+    0x25, 0x77, 0x25, 0x9b, 0x25, 0xbd, 0x25, 0xdc, 0x25, 0xf9, 0x26, 0x13,
+    0x26, 0x2b, 0x26, 0x41, 0x26, 0x55, 0x26, 0x67, 0x26, 0x77, 0x26, 0x85,
+    0x26, 0x91, 0x26, 0x9c, 0x26, 0xa7, 0x26, 0xb2, 0x26, 0xbd, 0x26, 0xc8,
+    0x26, 0xd3, 0x26, 0xde, 0x26, 0xe9, 0x26, 0xf6, 0x27, 0x04, 0x27, 0x15,
+    0x27, 0x27, 0x27, 0x3c, 0x27, 0x53, 0x27, 0x6c, 0x27, 0x87, 0x27, 0xa5,
+    0x27, 0xc5, 0x27, 0xe7, 0x28, 0x0c, 0x28, 0x34, 0x28, 0x5d, 0x28, 0x8a,
+    0x28, 0xb9, 0x28, 0xeb, 0x29, 0x20, 0x29, 0x57, 0x29, 0x91, 0x29, 0xce,
+    0x2a, 0x0e, 0x2a, 0x51, 0x2a, 0x97, 0x2a, 0xe0, 0x2b, 0x2c, 0x2b, 0x7b,
+    0x2b, 0xcd, 0x2c, 0x22, 0x2c, 0x7a, 0x2c, 0xd6, 0x2d, 0x35, 0x2d, 0x97,
+    0x2d, 0xfc, 0x2e, 0x65, 0x2e, 0xd1, 0x2f, 0x41, 0x2f, 0xb4, 0x30, 0x2a,
+    0x30, 0xa4, 0x31, 0x21, 0x31, 0xa2, 0x32, 0x27, 0x32, 0xaf, 0x33, 0x3b,
+    0x33, 0xca, 0x34, 0x5d, 0x34, 0xf4, 0x35, 0x8f, 0x36, 0x2d, 0x36, 0xcf,
+    0x37, 0x75, 0x38, 0x1f, 0x38, 0xcc, 0x39, 0x7e, 0x3a, 0x33, 0x3a, 0xed,
+    0x3b, 0xaa, 0x3c, 0x6b, 0x3d, 0x31, 0x3d, 0xfa, 0x3e, 0xc7, 0x3f, 0x99,
+    0x40, 0x6e, 0x41, 0x48, 0x42, 0x26, 0x43, 0x08, 0x43, 0xee, 0x44, 0xd8,
+    0x45, 0xc7, 0x46, 0xba, 0x47, 0xb1, 0x48, 0xac, 0x49, 0xac, 0x4a, 0xb0,
+    0x4b, 0xb9, 0x4c, 0xc6, 0x4d, 0xd7, 0x4e, 0xec, 0x50, 0x06, 0x51, 0x25,
+    0x52, 0x48, 0x53, 0x70, 0x54, 0x9c, 0x55, 0xcc, 0x57, 0x01, 0x58, 0x3b,
+    0x59, 0x79, 0x5a, 0xbc, 0x5c, 0x04, 0x5d, 0x50, 0x5e, 0xa1, 0x5f, 0xf7,
+    0x61, 0x51, 0x62, 0xb0, 0x64, 0x14, 0x65, 0x7c, 0x66, 0xea, 0x68, 0x5c,
+    0x69, 0xd3, 0x6b, 0x4f, 0x6c, 0xcf, 0x6e, 0x55, 0x6f, 0xdf, 0x71, 0x6f,
+    0x73, 0x03, 0x74, 0x9c, 0x76, 0x3a, 0x77, 0xdd, 0x79, 0x85, 0x7b, 0x32,
+    0x7c, 0xe5, 0x7e, 0x9c, 0x80, 0x58, 0x82, 0x19, 0x83, 0xe0, 0x85, 0xab,
+    0x87, 0x7c, 0x89, 0x52, 0x8b, 0x2d, 0x8d, 0x0d, 0x8e, 0xf2, 0x90, 0xdc,
+    0x92, 0xcc, 0x94, 0xc1, 0x96, 0xbb, 0x98, 0xbb, 0x9a, 0xc0, 0x9c, 0xca,
+    0x9e, 0xd9, 0xa0, 0xee, 0xa3, 0x08, 0xa5, 0x27, 0xa7, 0x4c, 0xa9, 0x76,
+    0xab, 0xa6, 0xad, 0xdb, 0xb0, 0x15, 0xb2, 0x55, 0xb4, 0x9a, 0xb6, 0xe5,
+    0xb9, 0x36, 0xbb, 0x8b, 0xbd, 0xe7, 0xc0, 0x48, 0xc2, 0xae, 0xc5, 0x1a,
+    0xc7, 0x8c, 0xca, 0x03, 0xcc, 0x80, 0xcf, 0x02, 0xd1, 0x8a, 0xd4, 0x18,
+    0xd6, 0xab, 0xd9, 0x44, 0xdb, 0xe3, 0xde, 0x87, 0xe1, 0x32, 0xe3, 0xe2,
+    0xe6, 0x97, 0xe9, 0x53, 0xec, 0x14, 0xee, 0xdb, 0xf1, 0xa8, 0xf4, 0x7a,
+    0xf7, 0x53, 0xfa, 0x31, 0xfd, 0x15, 0xff, 0xff, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x10,
+    0x02, 0x1b, 0x03, 0x22, 0x04, 0x24, 0x05, 0x23, 0x06, 0x1d, 0x07, 0x12,
+    0x08, 0x04, 0x08, 0xf1, 0x09, 0xda, 0x0a, 0xbe, 0x0b, 0x9f, 0x0c, 0x7b,
+    0x0d, 0x53, 0x0e, 0x28, 0x0e, 0xf8, 0x0f, 0xc3, 0x10, 0x8b, 0x11, 0x4f,
+    0x12, 0x0f, 0x12, 0xcb, 0x13, 0x83, 0x14, 0x37, 0x14, 0xe7, 0x15, 0x93,
+    0x16, 0x3c, 0x16, 0xe0, 0x17, 0x81, 0x18, 0x1e, 0x18, 0xb7, 0x19, 0x4d,
+    0x19, 0xdf, 0x1a, 0x6d, 0x1a, 0xf7, 0x1b, 0x7e, 0x1c, 0x01, 0x1c, 0x81,
+    0x1c, 0xfd, 0x1d, 0x76, 0x1d, 0xeb, 0x1e, 0x5d, 0x1e, 0xcb, 0x1f, 0x36,
+    0x1f, 0x9e, 0x20, 0x02, 0x20, 0x63, 0x20, 0xc1, 0x21, 0x1b, 0x21, 0x73,
+    0x21, 0xc7, 0x22, 0x18, 0x22, 0x66, 0x22, 0xb0, 0x22, 0xf8, 0x23, 0x3d,
+    0x23, 0x7f, 0x23, 0xbe, 0x23, 0xfa, 0x24, 0x33, 0x24, 0x69, 0x24, 0x9d,
+    0x24, 0xce, 0x24, 0xfc, 0x25, 0x28, 0x25, 0x51, 0x25, 0x77, 0x25, 0x9b,
+    0x25, 0xbd, 0x25, 0xdc, 0x25, 0xf9, 0x26, 0x13, 0x26, 0x2b, 0x26, 0x41,
+    0x26, 0x55, 0x26, 0x67, 0x26, 0x77, 0x26, 0x85, 0x26, 0x91, 0x26, 0x9c,
+    0x26, 0xa7, 0x26, 0xb2, 0x26, 0xbd, 0x26, 0xc8, 0x26, 0xd3, 0x26, 0xde,
+    0x26, 0xe9, 0x26, 0xf6, 0x27, 0x04, 0x27, 0x15, 0x27, 0x27, 0x27, 0x3c,
+    0x27, 0x53, 0x27, 0x6c, 0x27, 0x87, 0x27, 0xa5, 0x27, 0xc5, 0x27, 0xe7,
+    0x28, 0x0c, 0x28, 0x34, 0x28, 0x5d, 0x28, 0x8a, 0x28, 0xb9, 0x28, 0xeb,
+    0x29, 0x20, 0x29, 0x57, 0x29, 0x91, 0x29, 0xce, 0x2a, 0x0e, 0x2a, 0x51,
+    0x2a, 0x97, 0x2a, 0xe0, 0x2b, 0x2c, 0x2b, 0x7b, 0x2b, 0xcd, 0x2c, 0x22,
+    0x2c, 0x7a, 0x2c, 0xd6, 0x2d, 0x35, 0x2d, 0x97, 0x2d, 0xfc, 0x2e, 0x65,
+    0x2e, 0xd1, 0x2f, 0x41, 0x2f, 0xb4, 0x30, 0x2a, 0x30, 0xa4, 0x31, 0x21,
+    0x31, 0xa2, 0x32, 0x27, 0x32, 0xaf, 0x33, 0x3b, 0x33, 0xca, 0x34, 0x5d,
+    0x34, 0xf4, 0x35, 0x8f, 0x36, 0x2d, 0x36, 0xcf, 0x37, 0x75, 0x38, 0x1f,
+    0x38, 0xcc, 0x39, 0x7e, 0x3a, 0x33, 0x3a, 0xed, 0x3b, 0xaa, 0x3c, 0x6b,
+    0x3d, 0x31, 0x3d, 0xfa, 0x3e, 0xc7, 0x3f, 0x99, 0x40, 0x6e, 0x41, 0x48,
+    0x42, 0x26, 0x43, 0x08, 0x43, 0xee, 0x44, 0xd8, 0x45, 0xc7, 0x46, 0xba,
+    0x47, 0xb1, 0x48, 0xac, 0x49, 0xac, 0x4a, 0xb0, 0x4b, 0xb9, 0x4c, 0xc6,
+    0x4d, 0xd7, 0x4e, 0xec, 0x50, 0x06, 0x51, 0x25, 0x52, 0x48, 0x53, 0x70,
+    0x54, 0x9c, 0x55, 0xcc, 0x57, 0x01, 0x58, 0x3b, 0x59, 0x79, 0x5a, 0xbc,
+    0x5c, 0x04, 0x5d, 0x50, 0x5e, 0xa1, 0x5f, 0xf7, 0x61, 0x51, 0x62, 0xb0,
+    0x64, 0x14, 0x65, 0x7c, 0x66, 0xea, 0x68, 0x5c, 0x69, 0xd3, 0x6b, 0x4f,
+    0x6c, 0xcf, 0x6e, 0x55, 0x6f, 0xdf, 0x71, 0x6f, 0x73, 0x03, 0x74, 0x9c,
+    0x76, 0x3a, 0x77, 0xdd, 0x79, 0x85, 0x7b, 0x32, 0x7c, 0xe5, 0x7e, 0x9c,
+    0x80, 0x58, 0x82, 0x19, 0x83, 0xe0, 0x85, 0xab, 0x87, 0x7c, 0x89, 0x52,
+    0x8b, 0x2d, 0x8d, 0x0d, 0x8e, 0xf2, 0x90, 0xdc, 0x92, 0xcc, 0x94, 0xc1,
+    0x96, 0xbb, 0x98, 0xbb, 0x9a, 0xc0, 0x9c, 0xca, 0x9e, 0xd9, 0xa0, 0xee,
+    0xa3, 0x08, 0xa5, 0x27, 0xa7, 0x4c, 0xa9, 0x76, 0xab, 0xa6, 0xad, 0xdb,
+    0xb0, 0x15, 0xb2, 0x55, 0xb4, 0x9a, 0xb6, 0xe5, 0xb9, 0x36, 0xbb, 0x8b,
+    0xbd, 0xe7, 0xc0, 0x48, 0xc2, 0xae, 0xc5, 0x1a, 0xc7, 0x8c, 0xca, 0x03,
+    0xcc, 0x80, 0xcf, 0x02, 0xd1, 0x8a, 0xd4, 0x18, 0xd6, 0xab, 0xd9, 0x44,
+    0xdb, 0xe3, 0xde, 0x87, 0xe1, 0x32, 0xe3, 0xe2, 0xe6, 0x97, 0xe9, 0x53,
+    0xec, 0x14, 0xee, 0xdb, 0xf1, 0xa8, 0xf4, 0x7a, 0xf7, 0x53, 0xfa, 0x31,
+    0xfd, 0x15, 0xff, 0xff, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x10, 0x02, 0x1b, 0x03, 0x22,
+    0x04, 0x24, 0x05, 0x23, 0x06, 0x1d, 0x07, 0x12, 0x08, 0x04, 0x08, 0xf1,
+    0x09, 0xda, 0x0a, 0xbe, 0x0b, 0x9f, 0x0c, 0x7b, 0x0d, 0x53, 0x0e, 0x28,
+    0x0e, 0xf8, 0x0f, 0xc3, 0x10, 0x8b, 0x11, 0x4f, 0x12, 0x0f, 0x12, 0xcb,
+    0x13, 0x83, 0x14, 0x37, 0x14, 0xe7, 0x15, 0x93, 0x16, 0x3c, 0x16, 0xe0,
+    0x17, 0x81, 0x18, 0x1e, 0x18, 0xb7, 0x19, 0x4d, 0x19, 0xdf, 0x1a, 0x6d,
+    0x1a, 0xf7, 0x1b, 0x7e, 0x1c, 0x01, 0x1c, 0x81, 0x1c, 0xfd, 0x1d, 0x76,
+    0x1d, 0xeb, 0x1e, 0x5d, 0x1e, 0xcb, 0x1f, 0x36, 0x1f, 0x9e, 0x20, 0x02,
+    0x20, 0x63, 0x20, 0xc1, 0x21, 0x1b, 0x21, 0x73, 0x21, 0xc7, 0x22, 0x18,
+    0x22, 0x66, 0x22, 0xb0, 0x22, 0xf8, 0x23, 0x3d, 0x23, 0x7f, 0x23, 0xbe,
+    0x23, 0xfa, 0x24, 0x33, 0x24, 0x69, 0x24, 0x9d, 0x24, 0xce, 0x24, 0xfc,
+    0x25, 0x28, 0x25, 0x51, 0x25, 0x77, 0x25, 0x9b, 0x25, 0xbd, 0x25, 0xdc,
+    0x25, 0xf9, 0x26, 0x13, 0x26, 0x2b, 0x26, 0x41, 0x26, 0x55, 0x26, 0x67,
+    0x26, 0x77, 0x26, 0x85, 0x26, 0x91, 0x26, 0x9c, 0x26, 0xa7, 0x26, 0xb2,
+    0x26, 0xbd, 0x26, 0xc8, 0x26, 0xd3, 0x26, 0xde, 0x26, 0xe9, 0x26, 0xf6,
+    0x27, 0x04, 0x27, 0x15, 0x27, 0x27, 0x27, 0x3c, 0x27, 0x53, 0x27, 0x6c,
+    0x27, 0x87, 0x27, 0xa5, 0x27, 0xc5, 0x27, 0xe7, 0x28, 0x0c, 0x28, 0x34,
+    0x28, 0x5d, 0x28, 0x8a, 0x28, 0xb9, 0x28, 0xeb, 0x29, 0x20, 0x29, 0x57,
+    0x29, 0x91, 0x29, 0xce, 0x2a, 0x0e, 0x2a, 0x51, 0x2a, 0x97, 0x2a, 0xe0,
+    0x2b, 0x2c, 0x2b, 0x7b, 0x2b, 0xcd, 0x2c, 0x22, 0x2c, 0x7a, 0x2c, 0xd6,
+    0x2d, 0x35, 0x2d, 0x97, 0x2d, 0xfc, 0x2e, 0x65, 0x2e, 0xd1, 0x2f, 0x41,
+    0x2f, 0xb4, 0x30, 0x2a, 0x30, 0xa4, 0x31, 0x21, 0x31, 0xa2, 0x32, 0x27,
+    0x32, 0xaf, 0x33, 0x3b, 0x33, 0xca, 0x34, 0x5d, 0x34, 0xf4, 0x35, 0x8f,
+    0x36, 0x2d, 0x36, 0xcf, 0x37, 0x75, 0x38, 0x1f, 0x38, 0xcc, 0x39, 0x7e,
+    0x3a, 0x33, 0x3a, 0xed, 0x3b, 0xaa, 0x3c, 0x6b, 0x3d, 0x31, 0x3d, 0xfa,
+    0x3e, 0xc7, 0x3f, 0x99, 0x40, 0x6e, 0x41, 0x48, 0x42, 0x26, 0x43, 0x08,
+    0x43, 0xee, 0x44, 0xd8, 0x45, 0xc7, 0x46, 0xba, 0x47, 0xb1, 0x48, 0xac,
+    0x49, 0xac, 0x4a, 0xb0, 0x4b, 0xb9, 0x4c, 0xc6, 0x4d, 0xd7, 0x4e, 0xec,
+    0x50, 0x06, 0x51, 0x25, 0x52, 0x48, 0x53, 0x70, 0x54, 0x9c, 0x55, 0xcc,
+    0x57, 0x01, 0x58, 0x3b, 0x59, 0x79, 0x5a, 0xbc, 0x5c, 0x04, 0x5d, 0x50,
+    0x5e, 0xa1, 0x5f, 0xf7, 0x61, 0x51, 0x62, 0xb0, 0x64, 0x14, 0x65, 0x7c,
+    0x66, 0xea, 0x68, 0x5c, 0x69, 0xd3, 0x6b, 0x4f, 0x6c, 0xcf, 0x6e, 0x55,
+    0x6f, 0xdf, 0x71, 0x6f, 0x73, 0x03, 0x74, 0x9c, 0x76, 0x3a, 0x77, 0xdd,
+    0x79, 0x85, 0x7b, 0x32, 0x7c, 0xe5, 0x7e, 0x9c, 0x80, 0x58, 0x82, 0x19,
+    0x83, 0xe0, 0x85, 0xab, 0x87, 0x7c, 0x89, 0x52, 0x8b, 0x2d, 0x8d, 0x0d,
+    0x8e, 0xf2, 0x90, 0xdc, 0x92, 0xcc, 0x94, 0xc1, 0x96, 0xbb, 0x98, 0xbb,
+    0x9a, 0xc0, 0x9c, 0xca, 0x9e, 0xd9, 0xa0, 0xee, 0xa3, 0x08, 0xa5, 0x27,
+    0xa7, 0x4c, 0xa9, 0x76, 0xab, 0xa6, 0xad, 0xdb, 0xb0, 0x15, 0xb2, 0x55,
+    0xb4, 0x9a, 0xb6, 0xe5, 0xb9, 0x36, 0xbb, 0x8b, 0xbd, 0xe7, 0xc0, 0x48,
+    0xc2, 0xae, 0xc5, 0x1a, 0xc7, 0x8c, 0xca, 0x03, 0xcc, 0x80, 0xcf, 0x02,
+    0xd1, 0x8a, 0xd4, 0x18, 0xd6, 0xab, 0xd9, 0x44, 0xdb, 0xe3, 0xde, 0x87,
+    0xe1, 0x32, 0xe3, 0xe2, 0xe6, 0x97, 0xe9, 0x53, 0xec, 0x14, 0xee, 0xdb,
+    0xf1, 0xa8, 0xf4, 0x7a, 0xf7, 0x53, 0xfa, 0x31, 0xfd, 0x15, 0xff, 0xff,
+    0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x11, 0x27, 0x83, 0x33,
+    0x00, 0x00, 0x92, 0xa1, 0x41, 0x40, 0x00, 0x00, 0x11, 0x27, 0x63, 0x6c,
+    0xa3, 0xa5, 0x92, 0xa1, 0x21, 0x79, 0xa3, 0xa5, 0x6d, 0x81, 0xdf, 0x8c,
+    0x5c, 0x5a, 0xee, 0xfa, 0x9d, 0x9a, 0x5c, 0x5a, 0x6d, 0x81, 0xbf, 0xc5,
+    0xff, 0xff, 0xee, 0xfa, 0x7d, 0xd3, 0xff, 0xff, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x41, 0x42, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x06, 0x98,
+    0x00, 0x00, 0x06, 0xdc, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x17, 0x51, 0x00, 0x00, 0xf6, 0xb1,
+    0x00, 0x00, 0x5b, 0xa7, 0x00, 0x00, 0x8e, 0x7e, 0x00, 0x01, 0xcb, 0x45,
+    0x00, 0x00, 0x26, 0xd5, 0x00, 0x00, 0x08, 0xe7, 0x00, 0x00, 0x3e, 0x30,
+    0x00, 0x01, 0xc9, 0x57, 0xff, 0xff, 0xa4, 0x18, 0xff, 0xff, 0xa0, 0xaf,
+    0xff, 0xff, 0xb1, 0x5f, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x10, 0x02, 0x1b, 0x03, 0x22,
+    0x04, 0x24, 0x05, 0x23, 0x06, 0x1d, 0x07, 0x12, 0x08, 0x04, 0x08, 0xf1,
+    0x09, 0xda, 0x0a, 0xbe, 0x0b, 0x9f, 0x0c, 0x7b, 0x0d, 0x53, 0x0e, 0x28,
+    0x0e, 0xf8, 0x0f, 0xc3, 0x10, 0x8b, 0x11, 0x4f, 0x12, 0x0f, 0x12, 0xcb,
+    0x13, 0x83, 0x14, 0x37, 0x14, 0xe7, 0x15, 0x93, 0x16, 0x3c, 0x16, 0xe0,
+    0x17, 0x81, 0x18, 0x1e, 0x18, 0xb7, 0x19, 0x4d, 0x19, 0xdf, 0x1a, 0x6d,
+    0x1a, 0xf7, 0x1b, 0x7e, 0x1c, 0x01, 0x1c, 0x81, 0x1c, 0xfd, 0x1d, 0x76,
+    0x1d, 0xeb, 0x1e, 0x5d, 0x1e, 0xcb, 0x1f, 0x36, 0x1f, 0x9e, 0x20, 0x02,
+    0x20, 0x63, 0x20, 0xc1, 0x21, 0x1b, 0x21, 0x73, 0x21, 0xc7, 0x22, 0x18,
+    0x22, 0x66, 0x22, 0xb0, 0x22, 0xf8, 0x23, 0x3d, 0x23, 0x7f, 0x23, 0xbe,
+    0x23, 0xfa, 0x24, 0x33, 0x24, 0x69, 0x24, 0x9d, 0x24, 0xce, 0x24, 0xfc,
+    0x25, 0x28, 0x25, 0x51, 0x25, 0x77, 0x25, 0x9b, 0x25, 0xbd, 0x25, 0xdc,
+    0x25, 0xf9, 0x26, 0x13, 0x26, 0x2b, 0x26, 0x41, 0x26, 0x55, 0x26, 0x67,
+    0x26, 0x77, 0x26, 0x85, 0x26, 0x91, 0x26, 0x9c, 0x26, 0xa7, 0x26, 0xb2,
+    0x26, 0xbd, 0x26, 0xc8, 0x26, 0xd3, 0x26, 0xde, 0x26, 0xe9, 0x26, 0xf6,
+    0x27, 0x04, 0x27, 0x15, 0x27, 0x27, 0x27, 0x3c, 0x27, 0x53, 0x27, 0x6c,
+    0x27, 0x87, 0x27, 0xa5, 0x27, 0xc5, 0x27, 0xe7, 0x28, 0x0c, 0x28, 0x34,
+    0x28, 0x5d, 0x28, 0x8a, 0x28, 0xb9, 0x28, 0xeb, 0x29, 0x20, 0x29, 0x57,
+    0x29, 0x91, 0x29, 0xce, 0x2a, 0x0e, 0x2a, 0x51, 0x2a, 0x97, 0x2a, 0xe0,
+    0x2b, 0x2c, 0x2b, 0x7b, 0x2b, 0xcd, 0x2c, 0x22, 0x2c, 0x7a, 0x2c, 0xd6,
+    0x2d, 0x35, 0x2d, 0x97, 0x2d, 0xfc, 0x2e, 0x65, 0x2e, 0xd1, 0x2f, 0x41,
+    0x2f, 0xb4, 0x30, 0x2a, 0x30, 0xa4, 0x31, 0x21, 0x31, 0xa2, 0x32, 0x27,
+    0x32, 0xaf, 0x33, 0x3b, 0x33, 0xca, 0x34, 0x5d, 0x34, 0xf4, 0x35, 0x8f,
+    0x36, 0x2d, 0x36, 0xcf, 0x37, 0x75, 0x38, 0x1f, 0x38, 0xcc, 0x39, 0x7e,
+    0x3a, 0x33, 0x3a, 0xed, 0x3b, 0xaa, 0x3c, 0x6b, 0x3d, 0x31, 0x3d, 0xfa,
+    0x3e, 0xc7, 0x3f, 0x99, 0x40, 0x6e, 0x41, 0x48, 0x42, 0x26, 0x43, 0x08,
+    0x43, 0xee, 0x44, 0xd8, 0x45, 0xc7, 0x46, 0xba, 0x47, 0xb1, 0x48, 0xac,
+    0x49, 0xac, 0x4a, 0xb0, 0x4b, 0xb9, 0x4c, 0xc6, 0x4d, 0xd7, 0x4e, 0xec,
+    0x50, 0x06, 0x51, 0x25, 0x52, 0x48, 0x53, 0x70, 0x54, 0x9c, 0x55, 0xcc,
+    0x57, 0x01, 0x58, 0x3b, 0x59, 0x79, 0x5a, 0xbc, 0x5c, 0x04, 0x5d, 0x50,
+    0x5e, 0xa1, 0x5f, 0xf7, 0x61, 0x51, 0x62, 0xb0, 0x64, 0x14, 0x65, 0x7c,
+    0x66, 0xea, 0x68, 0x5c, 0x69, 0xd3, 0x6b, 0x4f, 0x6c, 0xcf, 0x6e, 0x55,
+    0x6f, 0xdf, 0x71, 0x6f, 0x73, 0x03, 0x74, 0x9c, 0x76, 0x3a, 0x77, 0xdd,
+    0x79, 0x85, 0x7b, 0x32, 0x7c, 0xe5, 0x7e, 0x9c, 0x80, 0x58, 0x82, 0x19,
+    0x83, 0xe0, 0x85, 0xab, 0x87, 0x7c, 0x89, 0x52, 0x8b, 0x2d, 0x8d, 0x0d,
+    0x8e, 0xf2, 0x90, 0xdc, 0x92, 0xcc, 0x94, 0xc1, 0x96, 0xbb, 0x98, 0xbb,
+    0x9a, 0xc0, 0x9c, 0xca, 0x9e, 0xd9, 0xa0, 0xee, 0xa3, 0x08, 0xa5, 0x27,
+    0xa7, 0x4c, 0xa9, 0x76, 0xab, 0xa6, 0xad, 0xdb, 0xb0, 0x15, 0xb2, 0x55,
+    0xb4, 0x9a, 0xb6, 0xe5, 0xb9, 0x36, 0xbb, 0x8b, 0xbd, 0xe7, 0xc0, 0x48,
+    0xc2, 0xae, 0xc5, 0x1a, 0xc7, 0x8c, 0xca, 0x03, 0xcc, 0x80, 0xcf, 0x02,
+    0xd1, 0x8a, 0xd4, 0x18, 0xd6, 0xab, 0xd9, 0x44, 0xdb, 0xe3, 0xde, 0x87,
+    0xe1, 0x32, 0xe3, 0xe2, 0xe6, 0x97, 0xe9, 0x53, 0xec, 0x14, 0xee, 0xdb,
+    0xf1, 0xa8, 0xf4, 0x7a, 0xf7, 0x53, 0xfa, 0x31, 0xfd, 0x15, 0xff, 0xff,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x10, 0x02, 0x1b, 0x03, 0x22, 0x04, 0x24, 0x05, 0x23,
+    0x06, 0x1d, 0x07, 0x12, 0x08, 0x04, 0x08, 0xf1, 0x09, 0xda, 0x0a, 0xbe,
+    0x0b, 0x9f, 0x0c, 0x7b, 0x0d, 0x53, 0x0e, 0x28, 0x0e, 0xf8, 0x0f, 0xc3,
+    0x10, 0x8b, 0x11, 0x4f, 0x12, 0x0f, 0x12, 0xcb, 0x13, 0x83, 0x14, 0x37,
+    0x14, 0xe7, 0x15, 0x93, 0x16, 0x3c, 0x16, 0xe0, 0x17, 0x81, 0x18, 0x1e,
+    0x18, 0xb7, 0x19, 0x4d, 0x19, 0xdf, 0x1a, 0x6d, 0x1a, 0xf7, 0x1b, 0x7e,
+    0x1c, 0x01, 0x1c, 0x81, 0x1c, 0xfd, 0x1d, 0x76, 0x1d, 0xeb, 0x1e, 0x5d,
+    0x1e, 0xcb, 0x1f, 0x36, 0x1f, 0x9e, 0x20, 0x02, 0x20, 0x63, 0x20, 0xc1,
+    0x21, 0x1b, 0x21, 0x73, 0x21, 0xc7, 0x22, 0x18, 0x22, 0x66, 0x22, 0xb0,
+    0x22, 0xf8, 0x23, 0x3d, 0x23, 0x7f, 0x23, 0xbe, 0x23, 0xfa, 0x24, 0x33,
+    0x24, 0x69, 0x24, 0x9d, 0x24, 0xce, 0x24, 0xfc, 0x25, 0x28, 0x25, 0x51,
+    0x25, 0x77, 0x25, 0x9b, 0x25, 0xbd, 0x25, 0xdc, 0x25, 0xf9, 0x26, 0x13,
+    0x26, 0x2b, 0x26, 0x41, 0x26, 0x55, 0x26, 0x67, 0x26, 0x77, 0x26, 0x85,
+    0x26, 0x91, 0x26, 0x9c, 0x26, 0xa7, 0x26, 0xb2, 0x26, 0xbd, 0x26, 0xc8,
+    0x26, 0xd3, 0x26, 0xde, 0x26, 0xe9, 0x26, 0xf6, 0x27, 0x04, 0x27, 0x15,
+    0x27, 0x27, 0x27, 0x3c, 0x27, 0x53, 0x27, 0x6c, 0x27, 0x87, 0x27, 0xa5,
+    0x27, 0xc5, 0x27, 0xe7, 0x28, 0x0c, 0x28, 0x34, 0x28, 0x5d, 0x28, 0x8a,
+    0x28, 0xb9, 0x28, 0xeb, 0x29, 0x20, 0x29, 0x57, 0x29, 0x91, 0x29, 0xce,
+    0x2a, 0x0e, 0x2a, 0x51, 0x2a, 0x97, 0x2a, 0xe0, 0x2b, 0x2c, 0x2b, 0x7b,
+    0x2b, 0xcd, 0x2c, 0x22, 0x2c, 0x7a, 0x2c, 0xd6, 0x2d, 0x35, 0x2d, 0x97,
+    0x2d, 0xfc, 0x2e, 0x65, 0x2e, 0xd1, 0x2f, 0x41, 0x2f, 0xb4, 0x30, 0x2a,
+    0x30, 0xa4, 0x31, 0x21, 0x31, 0xa2, 0x32, 0x27, 0x32, 0xaf, 0x33, 0x3b,
+    0x33, 0xca, 0x34, 0x5d, 0x34, 0xf4, 0x35, 0x8f, 0x36, 0x2d, 0x36, 0xcf,
+    0x37, 0x75, 0x38, 0x1f, 0x38, 0xcc, 0x39, 0x7e, 0x3a, 0x33, 0x3a, 0xed,
+    0x3b, 0xaa, 0x3c, 0x6b, 0x3d, 0x31, 0x3d, 0xfa, 0x3e, 0xc7, 0x3f, 0x99,
+    0x40, 0x6e, 0x41, 0x48, 0x42, 0x26, 0x43, 0x08, 0x43, 0xee, 0x44, 0xd8,
+    0x45, 0xc7, 0x46, 0xba, 0x47, 0xb1, 0x48, 0xac, 0x49, 0xac, 0x4a, 0xb0,
+    0x4b, 0xb9, 0x4c, 0xc6, 0x4d, 0xd7, 0x4e, 0xec, 0x50, 0x06, 0x51, 0x25,
+    0x52, 0x48, 0x53, 0x70, 0x54, 0x9c, 0x55, 0xcc, 0x57, 0x01, 0x58, 0x3b,
+    0x59, 0x79, 0x5a, 0xbc, 0x5c, 0x04, 0x5d, 0x50, 0x5e, 0xa1, 0x5f, 0xf7,
+    0x61, 0x51, 0x62, 0xb0, 0x64, 0x14, 0x65, 0x7c, 0x66, 0xea, 0x68, 0x5c,
+    0x69, 0xd3, 0x6b, 0x4f, 0x6c, 0xcf, 0x6e, 0x55, 0x6f, 0xdf, 0x71, 0x6f,
+    0x73, 0x03, 0x74, 0x9c, 0x76, 0x3a, 0x77, 0xdd, 0x79, 0x85, 0x7b, 0x32,
+    0x7c, 0xe5, 0x7e, 0x9c, 0x80, 0x58, 0x82, 0x19, 0x83, 0xe0, 0x85, 0xab,
+    0x87, 0x7c, 0x89, 0x52, 0x8b, 0x2d, 0x8d, 0x0d, 0x8e, 0xf2, 0x90, 0xdc,
+    0x92, 0xcc, 0x94, 0xc1, 0x96, 0xbb, 0x98, 0xbb, 0x9a, 0xc0, 0x9c, 0xca,
+    0x9e, 0xd9, 0xa0, 0xee, 0xa3, 0x08, 0xa5, 0x27, 0xa7, 0x4c, 0xa9, 0x76,
+    0xab, 0xa6, 0xad, 0xdb, 0xb0, 0x15, 0xb2, 0x55, 0xb4, 0x9a, 0xb6, 0xe5,
+    0xb9, 0x36, 0xbb, 0x8b, 0xbd, 0xe7, 0xc0, 0x48, 0xc2, 0xae, 0xc5, 0x1a,
+    0xc7, 0x8c, 0xca, 0x03, 0xcc, 0x80, 0xcf, 0x02, 0xd1, 0x8a, 0xd4, 0x18,
+    0xd6, 0xab, 0xd9, 0x44, 0xdb, 0xe3, 0xde, 0x87, 0xe1, 0x32, 0xe3, 0xe2,
+    0xe6, 0x97, 0xe9, 0x53, 0xec, 0x14, 0xee, 0xdb, 0xf1, 0xa8, 0xf4, 0x7a,
+    0xf7, 0x53, 0xfa, 0x31, 0xfd, 0x15, 0xff, 0xff, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x10,
+    0x02, 0x1b, 0x03, 0x22, 0x04, 0x24, 0x05, 0x23, 0x06, 0x1d, 0x07, 0x12,
+    0x08, 0x04, 0x08, 0xf1, 0x09, 0xda, 0x0a, 0xbe, 0x0b, 0x9f, 0x0c, 0x7b,
+    0x0d, 0x53, 0x0e, 0x28, 0x0e, 0xf8, 0x0f, 0xc3, 0x10, 0x8b, 0x11, 0x4f,
+    0x12, 0x0f, 0x12, 0xcb, 0x13, 0x83, 0x14, 0x37, 0x14, 0xe7, 0x15, 0x93,
+    0x16, 0x3c, 0x16, 0xe0, 0x17, 0x81, 0x18, 0x1e, 0x18, 0xb7, 0x19, 0x4d,
+    0x19, 0xdf, 0x1a, 0x6d, 0x1a, 0xf7, 0x1b, 0x7e, 0x1c, 0x01, 0x1c, 0x81,
+    0x1c, 0xfd, 0x1d, 0x76, 0x1d, 0xeb, 0x1e, 0x5d, 0x1e, 0xcb, 0x1f, 0x36,
+    0x1f, 0x9e, 0x20, 0x02, 0x20, 0x63, 0x20, 0xc1, 0x21, 0x1b, 0x21, 0x73,
+    0x21, 0xc7, 0x22, 0x18, 0x22, 0x66, 0x22, 0xb0, 0x22, 0xf8, 0x23, 0x3d,
+    0x23, 0x7f, 0x23, 0xbe, 0x23, 0xfa, 0x24, 0x33, 0x24, 0x69, 0x24, 0x9d,
+    0x24, 0xce, 0x24, 0xfc, 0x25, 0x28, 0x25, 0x51, 0x25, 0x77, 0x25, 0x9b,
+    0x25, 0xbd, 0x25, 0xdc, 0x25, 0xf9, 0x26, 0x13, 0x26, 0x2b, 0x26, 0x41,
+    0x26, 0x55, 0x26, 0x67, 0x26, 0x77, 0x26, 0x85, 0x26, 0x91, 0x26, 0x9c,
+    0x26, 0xa7, 0x26, 0xb2, 0x26, 0xbd, 0x26, 0xc8, 0x26, 0xd3, 0x26, 0xde,
+    0x26, 0xe9, 0x26, 0xf6, 0x27, 0x04, 0x27, 0x15, 0x27, 0x27, 0x27, 0x3c,
+    0x27, 0x53, 0x27, 0x6c, 0x27, 0x87, 0x27, 0xa5, 0x27, 0xc5, 0x27, 0xe7,
+    0x28, 0x0c, 0x28, 0x34, 0x28, 0x5d, 0x28, 0x8a, 0x28, 0xb9, 0x28, 0xeb,
+    0x29, 0x20, 0x29, 0x57, 0x29, 0x91, 0x29, 0xce, 0x2a, 0x0e, 0x2a, 0x51,
+    0x2a, 0x97, 0x2a, 0xe0, 0x2b, 0x2c, 0x2b, 0x7b, 0x2b, 0xcd, 0x2c, 0x22,
+    0x2c, 0x7a, 0x2c, 0xd6, 0x2d, 0x35, 0x2d, 0x97, 0x2d, 0xfc, 0x2e, 0x65,
+    0x2e, 0xd1, 0x2f, 0x41, 0x2f, 0xb4, 0x30, 0x2a, 0x30, 0xa4, 0x31, 0x21,
+    0x31, 0xa2, 0x32, 0x27, 0x32, 0xaf, 0x33, 0x3b, 0x33, 0xca, 0x34, 0x5d,
+    0x34, 0xf4, 0x35, 0x8f, 0x36, 0x2d, 0x36, 0xcf, 0x37, 0x75, 0x38, 0x1f,
+    0x38, 0xcc, 0x39, 0x7e, 0x3a, 0x33, 0x3a, 0xed, 0x3b, 0xaa, 0x3c, 0x6b,
+    0x3d, 0x31, 0x3d, 0xfa, 0x3e, 0xc7, 0x3f, 0x99, 0x40, 0x6e, 0x41, 0x48,
+    0x42, 0x26, 0x43, 0x08, 0x43, 0xee, 0x44, 0xd8, 0x45, 0xc7, 0x46, 0xba,
+    0x47, 0xb1, 0x48, 0xac, 0x49, 0xac, 0x4a, 0xb0, 0x4b, 0xb9, 0x4c, 0xc6,
+    0x4d, 0xd7, 0x4e, 0xec, 0x50, 0x06, 0x51, 0x25, 0x52, 0x48, 0x53, 0x70,
+    0x54, 0x9c, 0x55, 0xcc, 0x57, 0x01, 0x58, 0x3b, 0x59, 0x79, 0x5a, 0xbc,
+    0x5c, 0x04, 0x5d, 0x50, 0x5e, 0xa1, 0x5f, 0xf7, 0x61, 0x51, 0x62, 0xb0,
+    0x64, 0x14, 0x65, 0x7c, 0x66, 0xea, 0x68, 0x5c, 0x69, 0xd3, 0x6b, 0x4f,
+    0x6c, 0xcf, 0x6e, 0x55, 0x6f, 0xdf, 0x71, 0x6f, 0x73, 0x03, 0x74, 0x9c,
+    0x76, 0x3a, 0x77, 0xdd, 0x79, 0x85, 0x7b, 0x32, 0x7c, 0xe5, 0x7e, 0x9c,
+    0x80, 0x58, 0x82, 0x19, 0x83, 0xe0, 0x85, 0xab, 0x87, 0x7c, 0x89, 0x52,
+    0x8b, 0x2d, 0x8d, 0x0d, 0x8e, 0xf2, 0x90, 0xdc, 0x92, 0xcc, 0x94, 0xc1,
+    0x96, 0xbb, 0x98, 0xbb, 0x9a, 0xc0, 0x9c, 0xca, 0x9e, 0xd9, 0xa0, 0xee,
+    0xa3, 0x08, 0xa5, 0x27, 0xa7, 0x4c, 0xa9, 0x76, 0xab, 0xa6, 0xad, 0xdb,
+    0xb0, 0x15, 0xb2, 0x55, 0xb4, 0x9a, 0xb6, 0xe5, 0xb9, 0x36, 0xbb, 0x8b,
+    0xbd, 0xe7, 0xc0, 0x48, 0xc2, 0xae, 0xc5, 0x1a, 0xc7, 0x8c, 0xca, 0x03,
+    0xcc, 0x80, 0xcf, 0x02, 0xd1, 0x8a, 0xd4, 0x18, 0xd6, 0xab, 0xd9, 0x44,
+    0xdb, 0xe3, 0xde, 0x87, 0xe1, 0x32, 0xe3, 0xe2, 0xe6, 0x97, 0xe9, 0x53,
+    0xec, 0x14, 0xee, 0xdb, 0xf1, 0xa8, 0xf4, 0x7a, 0xf7, 0x53, 0xfa, 0x31,
+    0xfd, 0x15, 0xff, 0xff, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x11, 0x27, 0x83, 0x33, 0x00, 0x00, 0x92, 0xa1, 0x41, 0x40, 0x00, 0x00,
+    0x11, 0x27, 0x63, 0x6c, 0xa3, 0xa5, 0x92, 0xa1, 0x21, 0x79, 0xa3, 0xa5,
+    0x6d, 0x81, 0xdf, 0x8c, 0x5c, 0x5a, 0xee, 0xfa, 0x9d, 0x9a, 0x5c, 0x5a,
+    0x6d, 0x81, 0xbf, 0xc5, 0xff, 0xff, 0xee, 0xfa, 0x7d, 0xd3, 0xff, 0xff,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+unsigned char overshoot_profile_data[] = {
+    0x00, 0x00, 0x27, 0xa4, 0x6c, 0x69, 0x6e, 0x6f, 0x02, 0x20, 0x00, 0x00,
+    0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+    0x07, 0xe0, 0x00, 0x08, 0x00, 0x1a, 0x00, 0x03, 0x00, 0x3b, 0x00, 0x20,
+    0x61, 0x63, 0x73, 0x70, 0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x4d, 0x53, 0x46, 0x54,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x01, 0x60,
+    0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x02, 0x5c, 0x00, 0x00, 0x00, 0x31,
+    0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x02, 0x90, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0xa4, 0x00, 0x00, 0x00, 0x14,
+    0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0xb8, 0x00, 0x00, 0x00, 0x14,
+    0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0xcc, 0x00, 0x00, 0x00, 0x14,
+    0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x02, 0xe0, 0x00, 0x00, 0x02, 0x0c,
+    0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0xec, 0x00, 0x00, 0x02, 0x0c,
+    0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x06, 0xf8, 0x00, 0x00, 0x02, 0x0c,
+    0x4d, 0x53, 0x30, 0x30, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x1e, 0x9e,
+    0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58,
+    0x73, 0x52, 0x47, 0x42, 0x20, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79,
+    0x20, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x74,
+    0x68, 0x20, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x20, 0x68, 0x61,
+    0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69,
+    0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x61, 0x74,
+    0x61, 0x20, 0x64, 0x65, 0x72, 0x69, 0x76, 0x65, 0x64, 0x20, 0x66, 0x72,
+    0x6f, 0x6d, 0x20, 0x63, 0x61, 0x6c, 0x69, 0x62, 0x72, 0x61, 0x74, 0x69,
+    0x6f, 0x6e, 0x00, 0x00, 0x65, 0x6e, 0x55, 0x53, 0x00, 0x00, 0x00, 0x57,
+    0x00, 0x73, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x64,
+    0x00, 0x69, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x79,
+    0x00, 0x20, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69,
+    0x00, 0x6c, 0x00, 0x65, 0x00, 0x20, 0x00, 0x77, 0x00, 0x69, 0x00, 0x74,
+    0x00, 0x68, 0x00, 0x20, 0x00, 0x64, 0x00, 0x69, 0x00, 0x73, 0x00, 0x70,
+    0x00, 0x6c, 0x00, 0x61, 0x00, 0x79, 0x00, 0x20, 0x00, 0x68, 0x00, 0x61,
+    0x00, 0x72, 0x00, 0x64, 0x00, 0x77, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65,
+    0x00, 0x20, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x66, 0x00, 0x69,
+    0x00, 0x67, 0x00, 0x75, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69,
+    0x00, 0x6f, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x64, 0x00, 0x61, 0x00, 0x74,
+    0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69,
+    0x00, 0x76, 0x00, 0x65, 0x00, 0x64, 0x00, 0x20, 0x00, 0x66, 0x00, 0x72,
+    0x00, 0x6f, 0x00, 0x6d, 0x00, 0x20, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6c,
+    0x00, 0x69, 0x00, 0x62, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69,
+    0x00, 0x6f, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
+    0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63,
+    0x29, 0x20, 0x32, 0x30, 0x30, 0x34, 0x20, 0x4d, 0x69, 0x63, 0x72, 0x6f,
+    0x73, 0x6f, 0x66, 0x74, 0x20, 0x43, 0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3, 0x54, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x16, 0xc9, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x6f, 0x7b, 0x00, 0x00, 0x38, 0xc3, 0x00, 0x00, 0x03, 0x74,
+    0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x78,
+    0x00, 0x00, 0xb8, 0xd3, 0x00, 0x00, 0x16, 0x82, 0x58, 0x59, 0x5a, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0xe4, 0x00, 0x00, 0x0e, 0x6a,
+    0x00, 0x00, 0xb9, 0x36, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x28, 0x00, 0x3c,
+    0x00, 0x50, 0x00, 0x63, 0x00, 0x77, 0x00, 0x8b, 0x00, 0x9f, 0x00, 0xb3,
+    0x00, 0xc7, 0x00, 0xec, 0x01, 0x02, 0x01, 0x1a, 0x01, 0x33, 0x01, 0x4d,
+    0x01, 0x69, 0x01, 0x86, 0x01, 0xa4, 0x01, 0xc3, 0x01, 0xe4, 0x02, 0x06,
+    0x02, 0x29, 0x02, 0x4e, 0x02, 0x74, 0x02, 0x9c, 0x02, 0xc5, 0x02, 0xef,
+    0x03, 0x1b, 0x03, 0x48, 0x03, 0x77, 0x03, 0xa7, 0x03, 0xd9, 0x04, 0x0c,
+    0x04, 0x41, 0x04, 0x78, 0x04, 0xaf, 0x04, 0xe9, 0x05, 0x24, 0x05, 0x61,
+    0x05, 0x9f, 0x05, 0xdf, 0x06, 0x20, 0x06, 0x63, 0x06, 0xa8, 0x06, 0xee,
+    0x07, 0x36, 0x07, 0x80, 0x07, 0xcb, 0x08, 0x18, 0x08, 0x67, 0x08, 0xb8,
+    0x09, 0x0a, 0x09, 0x5e, 0x09, 0xb4, 0x0a, 0x0b, 0x0a, 0x65, 0x0a, 0xc0,
+    0x0b, 0x1d, 0x0b, 0x7b, 0x0b, 0xdc, 0x0c, 0x3e, 0x0c, 0xa2, 0x0d, 0x08,
+    0x0d, 0x70, 0x0d, 0xda, 0x0e, 0x46, 0x0e, 0xb3, 0x0f, 0x22, 0x0f, 0x94,
+    0x10, 0x07, 0x10, 0x7c, 0x10, 0xf3, 0x11, 0x6c, 0x11, 0xe7, 0x12, 0x64,
+    0x12, 0xe2, 0x13, 0x63, 0x13, 0xe6, 0x14, 0x6b, 0x14, 0xf1, 0x15, 0x7a,
+    0x16, 0x05, 0x16, 0x92, 0x17, 0x20, 0x17, 0xb1, 0x18, 0x44, 0x18, 0xd9,
+    0x19, 0x70, 0x1a, 0x09, 0x1a, 0xa4, 0x1b, 0x42, 0x1b, 0xe1, 0x1c, 0x82,
+    0x1d, 0x26, 0x1d, 0xcb, 0x1e, 0x73, 0x1f, 0x1d, 0x1f, 0xc9, 0x20, 0x77,
+    0x21, 0x28, 0x21, 0xda, 0x22, 0x8f, 0x23, 0x46, 0x23, 0xff, 0x24, 0xba,
+    0x25, 0x78, 0x26, 0x37, 0x26, 0xf9, 0x27, 0xbd, 0x28, 0x84, 0x29, 0x4c,
+    0x2a, 0x17, 0x2a, 0xe4, 0x2b, 0xb4, 0x2c, 0x85, 0x2d, 0x59, 0x2e, 0x2f,
+    0x2f, 0x08, 0x2f, 0xe2, 0x30, 0xc0, 0x31, 0x9f, 0x32, 0x81, 0x33, 0x65,
+    0x34, 0x4b, 0x35, 0x33, 0x36, 0x1e, 0x37, 0x0c, 0x37, 0xfc, 0x38, 0xee,
+    0x39, 0xe2, 0x3a, 0xd9, 0x3b, 0xd2, 0x3c, 0xce, 0x3d, 0xcb, 0x3e, 0xcc,
+    0x3f, 0xcf, 0x40, 0xd4, 0x41, 0xdb, 0x42, 0xe5, 0x43, 0xf2, 0x45, 0x01,
+    0x46, 0x12, 0x47, 0x26, 0x48, 0x3c, 0x49, 0x55, 0x4a, 0x70, 0x4b, 0x8e,
+    0x4c, 0xae, 0x4d, 0xd1, 0x4e, 0xf6, 0x50, 0x1d, 0x51, 0x47, 0x52, 0x74,
+    0x53, 0xa3, 0x54, 0xd5, 0x56, 0x09, 0x57, 0x40, 0x58, 0x79, 0x59, 0xb5,
+    0x5a, 0xf4, 0x5c, 0x34, 0x5d, 0x78, 0x5e, 0xbe, 0x60, 0x07, 0x61, 0x52,
+    0x62, 0xa0, 0x63, 0xf0, 0x65, 0x43, 0x66, 0x99, 0x67, 0xf1, 0x69, 0x4c,
+    0x6a, 0xaa, 0x6c, 0x0a, 0x6d, 0x6d, 0x6e, 0xd2, 0x70, 0x3a, 0x71, 0xa5,
+    0x73, 0x12, 0x74, 0x82, 0x75, 0xf5, 0x77, 0x6a, 0x78, 0xe3, 0x7a, 0x5d,
+    0x7b, 0xdb, 0x7d, 0x5b, 0x7e, 0xde, 0x80, 0x63, 0x81, 0xeb, 0x83, 0x76,
+    0x85, 0x04, 0x86, 0x95, 0x88, 0x28, 0x89, 0xbe, 0x8b, 0x56, 0x8c, 0xf2,
+    0x8e, 0x90, 0x90, 0x31, 0x91, 0xd4, 0x93, 0x7b, 0x95, 0x24, 0x96, 0xd0,
+    0x98, 0x7f, 0x9a, 0x30, 0x9b, 0xe5, 0x9d, 0x9c, 0x9f, 0x56, 0xa1, 0x13,
+    0xa2, 0xd2, 0xa4, 0x95, 0xa6, 0x5a, 0xa8, 0x22, 0xa9, 0xed, 0xab, 0xbb,
+    0xad, 0x8b, 0xaf, 0x5f, 0xb1, 0x35, 0xb3, 0x0e, 0xb4, 0xea, 0xb6, 0xc9,
+    0xb8, 0xab, 0xba, 0x90, 0xbc, 0x77, 0xbe, 0x62, 0xc0, 0x4f, 0xc2, 0x3f,
+    0xc4, 0x32, 0xc6, 0x28, 0xc8, 0x21, 0xca, 0x1d, 0xcc, 0x1c, 0xce, 0x1e,
+    0xd0, 0x22, 0xd2, 0x2a, 0xd4, 0x35, 0xd6, 0x42, 0xd8, 0x53, 0xda, 0x66,
+    0xdc, 0x7c, 0xde, 0x96, 0xe0, 0xb2, 0xe2, 0xd1, 0xe4, 0xf4, 0xe7, 0x19,
+    0xe9, 0x41, 0xeb, 0x6c, 0xed, 0x9b, 0xef, 0xcc, 0xf2, 0x00, 0xf4, 0x38,
+    0xf6, 0x72, 0xf8, 0xaf, 0xfa, 0xf0, 0xfd, 0x33, 0xff, 0x79, 0xff, 0xff,
+    0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x28, 0x00, 0x3c, 0x00, 0x50, 0x00, 0x63,
+    0x00, 0x77, 0x00, 0x8b, 0x00, 0x9f, 0x00, 0xb3, 0x00, 0xc7, 0x00, 0xec,
+    0x01, 0x02, 0x01, 0x1a, 0x01, 0x33, 0x01, 0x4d, 0x01, 0x69, 0x01, 0x86,
+    0x01, 0xa4, 0x01, 0xc3, 0x01, 0xe4, 0x02, 0x06, 0x02, 0x29, 0x02, 0x4e,
+    0x02, 0x74, 0x02, 0x9c, 0x02, 0xc5, 0x02, 0xef, 0x03, 0x1b, 0x03, 0x48,
+    0x03, 0x77, 0x03, 0xa7, 0x03, 0xd9, 0x04, 0x0c, 0x04, 0x41, 0x04, 0x78,
+    0x04, 0xaf, 0x04, 0xe9, 0x05, 0x24, 0x05, 0x61, 0x05, 0x9f, 0x05, 0xdf,
+    0x06, 0x20, 0x06, 0x63, 0x06, 0xa8, 0x06, 0xee, 0x07, 0x36, 0x07, 0x80,
+    0x07, 0xcb, 0x08, 0x18, 0x08, 0x67, 0x08, 0xb8, 0x09, 0x0a, 0x09, 0x5e,
+    0x09, 0xb4, 0x0a, 0x0b, 0x0a, 0x65, 0x0a, 0xc0, 0x0b, 0x1d, 0x0b, 0x7b,
+    0x0b, 0xdc, 0x0c, 0x3e, 0x0c, 0xa2, 0x0d, 0x08, 0x0d, 0x70, 0x0d, 0xda,
+    0x0e, 0x46, 0x0e, 0xb3, 0x0f, 0x22, 0x0f, 0x94, 0x10, 0x07, 0x10, 0x7c,
+    0x10, 0xf3, 0x11, 0x6c, 0x11, 0xe7, 0x12, 0x64, 0x12, 0xe2, 0x13, 0x63,
+    0x13, 0xe6, 0x14, 0x6b, 0x14, 0xf1, 0x15, 0x7a, 0x16, 0x05, 0x16, 0x92,
+    0x17, 0x20, 0x17, 0xb1, 0x18, 0x44, 0x18, 0xd9, 0x19, 0x70, 0x1a, 0x09,
+    0x1a, 0xa4, 0x1b, 0x42, 0x1b, 0xe1, 0x1c, 0x82, 0x1d, 0x26, 0x1d, 0xcb,
+    0x1e, 0x73, 0x1f, 0x1d, 0x1f, 0xc9, 0x20, 0x77, 0x21, 0x28, 0x21, 0xda,
+    0x22, 0x8f, 0x23, 0x46, 0x23, 0xff, 0x24, 0xba, 0x25, 0x78, 0x26, 0x37,
+    0x26, 0xf9, 0x27, 0xbd, 0x28, 0x84, 0x29, 0x4c, 0x2a, 0x17, 0x2a, 0xe4,
+    0x2b, 0xb4, 0x2c, 0x85, 0x2d, 0x59, 0x2e, 0x2f, 0x2f, 0x08, 0x2f, 0xe2,
+    0x30, 0xc0, 0x31, 0x9f, 0x32, 0x81, 0x33, 0x65, 0x34, 0x4b, 0x35, 0x33,
+    0x36, 0x1e, 0x37, 0x0c, 0x37, 0xfc, 0x38, 0xee, 0x39, 0xe2, 0x3a, 0xd9,
+    0x3b, 0xd2, 0x3c, 0xce, 0x3d, 0xcb, 0x3e, 0xcc, 0x3f, 0xcf, 0x40, 0xd4,
+    0x41, 0xdb, 0x42, 0xe5, 0x43, 0xf2, 0x45, 0x01, 0x46, 0x12, 0x47, 0x26,
+    0x48, 0x3c, 0x49, 0x55, 0x4a, 0x70, 0x4b, 0x8e, 0x4c, 0xae, 0x4d, 0xd1,
+    0x4e, 0xf6, 0x50, 0x1d, 0x51, 0x47, 0x52, 0x74, 0x53, 0xa3, 0x54, 0xd5,
+    0x56, 0x09, 0x57, 0x40, 0x58, 0x79, 0x59, 0xb5, 0x5a, 0xf4, 0x5c, 0x34,
+    0x5d, 0x78, 0x5e, 0xbe, 0x60, 0x07, 0x61, 0x52, 0x62, 0xa0, 0x63, 0xf0,
+    0x65, 0x43, 0x66, 0x99, 0x67, 0xf1, 0x69, 0x4c, 0x6a, 0xaa, 0x6c, 0x0a,
+    0x6d, 0x6d, 0x6e, 0xd2, 0x70, 0x3a, 0x71, 0xa5, 0x73, 0x12, 0x74, 0x82,
+    0x75, 0xf5, 0x77, 0x6a, 0x78, 0xe3, 0x7a, 0x5d, 0x7b, 0xdb, 0x7d, 0x5b,
+    0x7e, 0xde, 0x80, 0x63, 0x81, 0xeb, 0x83, 0x76, 0x85, 0x04, 0x86, 0x95,
+    0x88, 0x28, 0x89, 0xbe, 0x8b, 0x56, 0x8c, 0xf2, 0x8e, 0x90, 0x90, 0x31,
+    0x91, 0xd4, 0x93, 0x7b, 0x95, 0x24, 0x96, 0xd0, 0x98, 0x7f, 0x9a, 0x30,
+    0x9b, 0xe5, 0x9d, 0x9c, 0x9f, 0x56, 0xa1, 0x13, 0xa2, 0xd2, 0xa4, 0x95,
+    0xa6, 0x5a, 0xa8, 0x22, 0xa9, 0xed, 0xab, 0xbb, 0xad, 0x8b, 0xaf, 0x5f,
+    0xb1, 0x35, 0xb3, 0x0e, 0xb4, 0xea, 0xb6, 0xc9, 0xb8, 0xab, 0xba, 0x90,
+    0xbc, 0x77, 0xbe, 0x62, 0xc0, 0x4f, 0xc2, 0x3f, 0xc4, 0x32, 0xc6, 0x28,
+    0xc8, 0x21, 0xca, 0x1d, 0xcc, 0x1c, 0xce, 0x1e, 0xd0, 0x22, 0xd2, 0x2a,
+    0xd4, 0x35, 0xd6, 0x42, 0xd8, 0x53, 0xda, 0x66, 0xdc, 0x7c, 0xde, 0x96,
+    0xe0, 0xb2, 0xe2, 0xd1, 0xe4, 0xf4, 0xe7, 0x19, 0xe9, 0x41, 0xeb, 0x6c,
+    0xed, 0x9b, 0xef, 0xcc, 0xf2, 0x00, 0xf4, 0x38, 0xf6, 0x72, 0xf8, 0xaf,
+    0xfa, 0xf0, 0xfd, 0x33, 0xff, 0x79, 0xff, 0xff, 0x63, 0x75, 0x72, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x28, 0x00, 0x3c, 0x00, 0x50, 0x00, 0x63, 0x00, 0x77, 0x00, 0x8b,
+    0x00, 0x9f, 0x00, 0xb3, 0x00, 0xc7, 0x00, 0xec, 0x01, 0x02, 0x01, 0x1a,
+    0x01, 0x33, 0x01, 0x4d, 0x01, 0x69, 0x01, 0x86, 0x01, 0xa4, 0x01, 0xc3,
+    0x01, 0xe4, 0x02, 0x06, 0x02, 0x29, 0x02, 0x4e, 0x02, 0x74, 0x02, 0x9c,
+    0x02, 0xc5, 0x02, 0xef, 0x03, 0x1b, 0x03, 0x48, 0x03, 0x77, 0x03, 0xa7,
+    0x03, 0xd9, 0x04, 0x0c, 0x04, 0x41, 0x04, 0x78, 0x04, 0xaf, 0x04, 0xe9,
+    0x05, 0x24, 0x05, 0x61, 0x05, 0x9f, 0x05, 0xdf, 0x06, 0x20, 0x06, 0x63,
+    0x06, 0xa8, 0x06, 0xee, 0x07, 0x36, 0x07, 0x80, 0x07, 0xcb, 0x08, 0x18,
+    0x08, 0x67, 0x08, 0xb8, 0x09, 0x0a, 0x09, 0x5e, 0x09, 0xb4, 0x0a, 0x0b,
+    0x0a, 0x65, 0x0a, 0xc0, 0x0b, 0x1d, 0x0b, 0x7b, 0x0b, 0xdc, 0x0c, 0x3e,
+    0x0c, 0xa2, 0x0d, 0x08, 0x0d, 0x70, 0x0d, 0xda, 0x0e, 0x46, 0x0e, 0xb3,
+    0x0f, 0x22, 0x0f, 0x94, 0x10, 0x07, 0x10, 0x7c, 0x10, 0xf3, 0x11, 0x6c,
+    0x11, 0xe7, 0x12, 0x64, 0x12, 0xe2, 0x13, 0x63, 0x13, 0xe6, 0x14, 0x6b,
+    0x14, 0xf1, 0x15, 0x7a, 0x16, 0x05, 0x16, 0x92, 0x17, 0x20, 0x17, 0xb1,
+    0x18, 0x44, 0x18, 0xd9, 0x19, 0x70, 0x1a, 0x09, 0x1a, 0xa4, 0x1b, 0x42,
+    0x1b, 0xe1, 0x1c, 0x82, 0x1d, 0x26, 0x1d, 0xcb, 0x1e, 0x73, 0x1f, 0x1d,
+    0x1f, 0xc9, 0x20, 0x77, 0x21, 0x28, 0x21, 0xda, 0x22, 0x8f, 0x23, 0x46,
+    0x23, 0xff, 0x24, 0xba, 0x25, 0x78, 0x26, 0x37, 0x26, 0xf9, 0x27, 0xbd,
+    0x28, 0x84, 0x29, 0x4c, 0x2a, 0x17, 0x2a, 0xe4, 0x2b, 0xb4, 0x2c, 0x85,
+    0x2d, 0x59, 0x2e, 0x2f, 0x2f, 0x08, 0x2f, 0xe2, 0x30, 0xc0, 0x31, 0x9f,
+    0x32, 0x81, 0x33, 0x65, 0x34, 0x4b, 0x35, 0x33, 0x36, 0x1e, 0x37, 0x0c,
+    0x37, 0xfc, 0x38, 0xee, 0x39, 0xe2, 0x3a, 0xd9, 0x3b, 0xd2, 0x3c, 0xce,
+    0x3d, 0xcb, 0x3e, 0xcc, 0x3f, 0xcf, 0x40, 0xd4, 0x41, 0xdb, 0x42, 0xe5,
+    0x43, 0xf2, 0x45, 0x01, 0x46, 0x12, 0x47, 0x26, 0x48, 0x3c, 0x49, 0x55,
+    0x4a, 0x70, 0x4b, 0x8e, 0x4c, 0xae, 0x4d, 0xd1, 0x4e, 0xf6, 0x50, 0x1d,
+    0x51, 0x47, 0x52, 0x74, 0x53, 0xa3, 0x54, 0xd5, 0x56, 0x09, 0x57, 0x40,
+    0x58, 0x79, 0x59, 0xb5, 0x5a, 0xf4, 0x5c, 0x34, 0x5d, 0x78, 0x5e, 0xbe,
+    0x60, 0x07, 0x61, 0x52, 0x62, 0xa0, 0x63, 0xf0, 0x65, 0x43, 0x66, 0x99,
+    0x67, 0xf1, 0x69, 0x4c, 0x6a, 0xaa, 0x6c, 0x0a, 0x6d, 0x6d, 0x6e, 0xd2,
+    0x70, 0x3a, 0x71, 0xa5, 0x73, 0x12, 0x74, 0x82, 0x75, 0xf5, 0x77, 0x6a,
+    0x78, 0xe3, 0x7a, 0x5d, 0x7b, 0xdb, 0x7d, 0x5b, 0x7e, 0xde, 0x80, 0x63,
+    0x81, 0xeb, 0x83, 0x76, 0x85, 0x04, 0x86, 0x95, 0x88, 0x28, 0x89, 0xbe,
+    0x8b, 0x56, 0x8c, 0xf2, 0x8e, 0x90, 0x90, 0x31, 0x91, 0xd4, 0x93, 0x7b,
+    0x95, 0x24, 0x96, 0xd0, 0x98, 0x7f, 0x9a, 0x30, 0x9b, 0xe5, 0x9d, 0x9c,
+    0x9f, 0x56, 0xa1, 0x13, 0xa2, 0xd2, 0xa4, 0x95, 0xa6, 0x5a, 0xa8, 0x22,
+    0xa9, 0xed, 0xab, 0xbb, 0xad, 0x8b, 0xaf, 0x5f, 0xb1, 0x35, 0xb3, 0x0e,
+    0xb4, 0xea, 0xb6, 0xc9, 0xb8, 0xab, 0xba, 0x90, 0xbc, 0x77, 0xbe, 0x62,
+    0xc0, 0x4f, 0xc2, 0x3f, 0xc4, 0x32, 0xc6, 0x28, 0xc8, 0x21, 0xca, 0x1d,
+    0xcc, 0x1c, 0xce, 0x1e, 0xd0, 0x22, 0xd2, 0x2a, 0xd4, 0x35, 0xd6, 0x42,
+    0xd8, 0x53, 0xda, 0x66, 0xdc, 0x7c, 0xde, 0x96, 0xe0, 0xb2, 0xe2, 0xd1,
+    0xe4, 0xf4, 0xe7, 0x19, 0xe9, 0x41, 0xeb, 0x6c, 0xed, 0x9b, 0xef, 0xcc,
+    0xf2, 0x00, 0xf4, 0x38, 0xf6, 0x72, 0xf8, 0xaf, 0xfa, 0xf0, 0xfd, 0x33,
+    0xff, 0x79, 0xff, 0xff, 0x4d, 0x53, 0x31, 0x30, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x10, 0x0e, 0x00, 0x00, 0x10, 0x2e,
+    0x00, 0x00, 0x08, 0x28, 0x00, 0x00, 0x18, 0x56, 0x00, 0x00, 0x06, 0x48,
+    0x3c, 0x00, 0x3f, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x20, 0x00,
+    0x76, 0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00,
+    0x6e, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x30, 0x00,
+    0x22, 0x00, 0x20, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x63, 0x00, 0x6f, 0x00,
+    0x64, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x75, 0x00, 0x74, 0x00, 0x66, 0x00, 0x2d, 0x00, 0x31, 0x00, 0x36, 0x00,
+    0x22, 0x00, 0x3f, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x3c, 0x00,
+    0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x43, 0x00, 0x6f, 0x00,
+    0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x44, 0x00, 0x65, 0x00, 0x76, 0x00,
+    0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x64, 0x00,
+    0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00,
+    0x6e, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00,
+    0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00,
+    0x65, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x6d, 0x00,
+    0x69, 0x00, 0x63, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00,
+    0x66, 0x00, 0x74, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00,
+    0x2f, 0x00, 0x77, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x6f, 0x00,
+    0x77, 0x00, 0x73, 0x00, 0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x35, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x32, 0x00, 0x2f, 0x00, 0x63, 0x00,
+    0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x2f, 0x00, 0x43, 0x00,
+    0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x44, 0x00, 0x65, 0x00,
+    0x76, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x4d, 0x00, 0x6f, 0x00,
+    0x64, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x22, 0x00, 0x20, 0x00, 0x78, 0x00,
+    0x6d, 0x00, 0x6c, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x63, 0x00,
+    0x61, 0x00, 0x6c, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x68, 0x00, 0x74, 0x00,
+    0x74, 0x00, 0x70, 0x00, 0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, 0x73, 0x00,
+    0x63, 0x00, 0x68, 0x00, 0x65, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x73, 0x00,
+    0x2e, 0x00, 0x6d, 0x00, 0x69, 0x00, 0x63, 0x00, 0x72, 0x00, 0x6f, 0x00,
+    0x73, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x74, 0x00, 0x2e, 0x00, 0x63, 0x00,
+    0x6f, 0x00, 0x6d, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x69, 0x00, 0x6e, 0x00,
+    0x64, 0x00, 0x6f, 0x00, 0x77, 0x00, 0x73, 0x00, 0x2f, 0x00, 0x32, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x37, 0x00, 0x2f, 0x00, 0x31, 0x00, 0x31, 0x00,
+    0x2f, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x2f, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x62, 0x00,
+    0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00,
+    0x22, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x6e, 0x00,
+    0x73, 0x00, 0x3a, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00,
+    0x2f, 0x00, 0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00,
+    0x6d, 0x00, 0x61, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x6d, 0x00, 0x69, 0x00,
+    0x63, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x66, 0x00,
+    0x74, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x2f, 0x00,
+    0x77, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x6f, 0x00, 0x77, 0x00,
+    0x73, 0x00, 0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x35, 0x00,
+    0x2f, 0x00, 0x30, 0x00, 0x32, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x6f, 0x00,
+    0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x2f, 0x00, 0x57, 0x00, 0x63, 0x00,
+    0x73, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x6f, 0x00,
+    0x6e, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00,
+    0x6c, 0x00, 0x65, 0x00, 0x54, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00,
+    0x73, 0x00, 0x22, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00,
+    0x6e, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x6d, 0x00, 0x63, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00,
+    0x2f, 0x00, 0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00,
+    0x6d, 0x00, 0x61, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x6f, 0x00, 0x70, 0x00,
+    0x65, 0x00, 0x6e, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x66, 0x00,
+    0x6f, 0x00, 0x72, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x74, 0x00, 0x73, 0x00,
+    0x2e, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x67, 0x00, 0x2f, 0x00, 0x6d, 0x00,
+    0x61, 0x00, 0x72, 0x00, 0x6b, 0x00, 0x75, 0x00, 0x70, 0x00, 0x2d, 0x00,
+    0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x70, 0x00, 0x61, 0x00, 0x74, 0x00,
+    0x69, 0x00, 0x62, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x74, 0x00,
+    0x79, 0x00, 0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x36, 0x00,
+    0x22, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x50, 0x00, 0x72, 0x00,
+    0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x4e, 0x00,
+    0x61, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00,
+    0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00, 0x20, 0x00,
+    0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x3a, 0x00, 0x6c, 0x00, 0x61, 0x00,
+    0x6e, 0x00, 0x67, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x65, 0x00, 0x6e, 0x00,
+    0x2d, 0x00, 0x55, 0x00, 0x53, 0x00, 0x22, 0x00, 0x3e, 0x00, 0x43, 0x00,
+    0x61, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x62, 0x00, 0x72, 0x00, 0x61, 0x00,
+    0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x69, 0x00,
+    0x73, 0x00, 0x70, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x79, 0x00, 0x20, 0x00,
+    0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00,
+    0x65, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00,
+    0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00,
+    0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f, 0x00,
+    0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x4e, 0x00, 0x61, 0x00,
+    0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x44, 0x00,
+    0x65, 0x00, 0x73, 0x00, 0x63, 0x00, 0x72, 0x00, 0x69, 0x00, 0x70, 0x00,
+    0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x77, 0x00, 0x63, 0x00,
+    0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00,
+    0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x3a, 0x00, 0x6c, 0x00,
+    0x61, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x65, 0x00,
+    0x6e, 0x00, 0x2d, 0x00, 0x55, 0x00, 0x53, 0x00, 0x22, 0x00, 0x3e, 0x00,
+    0x73, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x64, 0x00,
+    0x69, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x79, 0x00,
+    0x20, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00,
+    0x6c, 0x00, 0x65, 0x00, 0x20, 0x00, 0x77, 0x00, 0x69, 0x00, 0x74, 0x00,
+    0x68, 0x00, 0x20, 0x00, 0x64, 0x00, 0x69, 0x00, 0x73, 0x00, 0x70, 0x00,
+    0x6c, 0x00, 0x61, 0x00, 0x79, 0x00, 0x20, 0x00, 0x68, 0x00, 0x61, 0x00,
+    0x72, 0x00, 0x64, 0x00, 0x77, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65, 0x00,
+    0x20, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x66, 0x00, 0x69, 0x00,
+    0x67, 0x00, 0x75, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x64, 0x00, 0x61, 0x00, 0x74, 0x00,
+    0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00,
+    0x76, 0x00, 0x65, 0x00, 0x64, 0x00, 0x20, 0x00, 0x66, 0x00, 0x72, 0x00,
+    0x6f, 0x00, 0x6d, 0x00, 0x20, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6c, 0x00,
+    0x69, 0x00, 0x62, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x63, 0x00,
+    0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x44, 0x00, 0x65, 0x00,
+    0x73, 0x00, 0x63, 0x00, 0x72, 0x00, 0x69, 0x00, 0x70, 0x00, 0x74, 0x00,
+    0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x41, 0x00, 0x75, 0x00, 0x74, 0x00, 0x68, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00,
+    0x78, 0x00, 0x74, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00,
+    0x3a, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2d, 0x00, 0x55, 0x00, 0x53, 0x00,
+    0x22, 0x00, 0x3e, 0x00, 0x4d, 0x00, 0x69, 0x00, 0x63, 0x00, 0x72, 0x00,
+    0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x74, 0x00, 0x20, 0x00,
+    0x44, 0x00, 0x69, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6c, 0x00, 0x61, 0x00,
+    0x79, 0x00, 0x20, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00,
+    0x72, 0x00, 0x20, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x69, 0x00,
+    0x62, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00,
+    0x6e, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00,
+    0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00,
+    0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x41, 0x00, 0x75, 0x00, 0x74, 0x00,
+    0x68, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x4d, 0x00, 0x65, 0x00, 0x61, 0x00, 0x73, 0x00, 0x75, 0x00, 0x72, 0x00,
+    0x65, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x43, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x53, 0x00, 0x70, 0x00, 0x61, 0x00, 0x63, 0x00, 0x65, 0x00, 0x3e, 0x00,
+    0x43, 0x00, 0x49, 0x00, 0x45, 0x00, 0x58, 0x00, 0x59, 0x00, 0x5a, 0x00,
+    0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x53, 0x00,
+    0x70, 0x00, 0x61, 0x00, 0x63, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x57, 0x00, 0x68, 0x00, 0x69, 0x00, 0x74, 0x00,
+    0x65, 0x00, 0x50, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x74, 0x00,
+    0x4e, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x44, 0x00,
+    0x36, 0x00, 0x35, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x57, 0x00, 0x68, 0x00, 0x69, 0x00, 0x74, 0x00,
+    0x65, 0x00, 0x50, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x74, 0x00,
+    0x4e, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x4d, 0x00, 0x65, 0x00, 0x61, 0x00, 0x73, 0x00,
+    0x75, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x6e, 0x00,
+    0x74, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x69, 0x00,
+    0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x53, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x66, 0x00,
+    0x4c, 0x00, 0x75, 0x00, 0x6d, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x6f, 0x00,
+    0x75, 0x00, 0x73, 0x00, 0x3e, 0x00, 0x74, 0x00, 0x72, 0x00, 0x75, 0x00,
+    0x65, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x53, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x66, 0x00, 0x4c, 0x00,
+    0x75, 0x00, 0x6d, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x6f, 0x00, 0x75, 0x00,
+    0x73, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x4d, 0x00, 0x61, 0x00,
+    0x78, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x61, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x3e, 0x00, 0x31, 0x00, 0x2e, 0x00,
+    0x30, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x4d, 0x00, 0x61, 0x00, 0x78, 0x00, 0x43, 0x00, 0x6f, 0x00,
+    0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x74, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00,
+    0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x4d, 0x00, 0x69, 0x00, 0x6e, 0x00,
+    0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x61, 0x00,
+    0x6e, 0x00, 0x74, 0x00, 0x3e, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x30, 0x00,
+    0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x4d, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00,
+    0x6f, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x56, 0x00,
+    0x69, 0x00, 0x72, 0x00, 0x74, 0x00, 0x75, 0x00, 0x61, 0x00, 0x6c, 0x00,
+    0x44, 0x00, 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x4d, 0x00, 0x65, 0x00,
+    0x61, 0x00, 0x73, 0x00, 0x75, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6d, 0x00,
+    0x65, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00,
+    0x61, 0x00, 0x20, 0x00, 0x54, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x65, 0x00,
+    0x53, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x70, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2d, 0x00,
+    0x30, 0x00, 0x38, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x36, 0x00, 0x54, 0x00,
+    0x30, 0x00, 0x33, 0x00, 0x3a, 0x00, 0x35, 0x00, 0x39, 0x00, 0x3a, 0x00,
+    0x33, 0x00, 0x32, 0x00, 0x22, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x4d, 0x00, 0x61, 0x00, 0x78, 0x00, 0x43, 0x00,
+    0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6e, 0x00,
+    0x74, 0x00, 0x55, 0x00, 0x73, 0x00, 0x65, 0x00, 0x64, 0x00, 0x3e, 0x00,
+    0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00,
+    0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x4d, 0x00, 0x61, 0x00, 0x78, 0x00,
+    0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x61, 0x00,
+    0x6e, 0x00, 0x74, 0x00, 0x55, 0x00, 0x73, 0x00, 0x65, 0x00, 0x64, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x4d, 0x00,
+    0x69, 0x00, 0x6e, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00,
+    0x72, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x55, 0x00, 0x73, 0x00,
+    0x65, 0x00, 0x64, 0x00, 0x3e, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x30, 0x00,
+    0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x4d, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00,
+    0x6f, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x55, 0x00,
+    0x73, 0x00, 0x65, 0x00, 0x64, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x57, 0x00, 0x68, 0x00, 0x69, 0x00, 0x74, 0x00,
+    0x65, 0x00, 0x50, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x61, 0x00,
+    0x72, 0x00, 0x79, 0x00, 0x20, 0x00, 0x58, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x39, 0x00, 0x35, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x35, 0x00, 0x22, 0x00,
+    0x20, 0x00, 0x59, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x30, 0x00,
+    0x30, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x30, 0x00, 0x22, 0x00, 0x20, 0x00,
+    0x5a, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x30, 0x00, 0x38, 0x00,
+    0x2e, 0x00, 0x39, 0x00, 0x30, 0x00, 0x22, 0x00, 0x2f, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x52, 0x00, 0x65, 0x00,
+    0x64, 0x00, 0x50, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x61, 0x00,
+    0x72, 0x00, 0x79, 0x00, 0x20, 0x00, 0x58, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x34, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x32, 0x00, 0x34, 0x00, 0x22, 0x00,
+    0x20, 0x00, 0x59, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x32, 0x00, 0x31, 0x00,
+    0x2e, 0x00, 0x32, 0x00, 0x36, 0x00, 0x22, 0x00, 0x20, 0x00, 0x5a, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x22, 0x00, 0x2f, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x47, 0x00, 0x72, 0x00, 0x65, 0x00, 0x65, 0x00, 0x6e, 0x00,
+    0x50, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x72, 0x00,
+    0x79, 0x00, 0x20, 0x00, 0x58, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x33, 0x00,
+    0x35, 0x00, 0x2e, 0x00, 0x37, 0x00, 0x36, 0x00, 0x22, 0x00, 0x20, 0x00,
+    0x59, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x37, 0x00, 0x31, 0x00, 0x2e, 0x00,
+    0x35, 0x00, 0x32, 0x00, 0x22, 0x00, 0x20, 0x00, 0x5a, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x31, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x39, 0x00, 0x32, 0x00,
+    0x22, 0x00, 0x2f, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x42, 0x00, 0x6c, 0x00, 0x75, 0x00, 0x65, 0x00, 0x50, 0x00,
+    0x72, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x72, 0x00, 0x79, 0x00,
+    0x20, 0x00, 0x58, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x38, 0x00,
+    0x2e, 0x00, 0x30, 0x00, 0x35, 0x00, 0x22, 0x00, 0x20, 0x00, 0x59, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x37, 0x00, 0x2e, 0x00, 0x32, 0x00, 0x32, 0x00,
+    0x22, 0x00, 0x20, 0x00, 0x5a, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x39, 0x00,
+    0x35, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x35, 0x00, 0x22, 0x00, 0x2f, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x42, 0x00,
+    0x6c, 0x00, 0x61, 0x00, 0x63, 0x00, 0x6b, 0x00, 0x50, 0x00, 0x72, 0x00,
+    0x69, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x72, 0x00, 0x79, 0x00, 0x20, 0x00,
+    0x58, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x30, 0x00, 0x22, 0x00, 0x20, 0x00,
+    0x59, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x30, 0x00, 0x22, 0x00, 0x20, 0x00,
+    0x5a, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x30, 0x00, 0x22, 0x00, 0x2f, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x47, 0x00,
+    0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x4f, 0x00, 0x66, 0x00,
+    0x66, 0x00, 0x73, 0x00, 0x65, 0x00, 0x74, 0x00, 0x47, 0x00, 0x61, 0x00,
+    0x69, 0x00, 0x6e, 0x00, 0x4c, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00,
+    0x61, 0x00, 0x72, 0x00, 0x47, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6e, 0x00,
+    0x20, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x34, 0x00, 0x22, 0x00,
+    0x20, 0x00, 0x4f, 0x00, 0x66, 0x00, 0x66, 0x00, 0x73, 0x00, 0x65, 0x00,
+    0x74, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x30, 0x00,
+    0x35, 0x00, 0x35, 0x00, 0x22, 0x00, 0x20, 0x00, 0x47, 0x00, 0x61, 0x00,
+    0x69, 0x00, 0x6e, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x30, 0x00, 0x2e, 0x00,
+    0x39, 0x00, 0x34, 0x00, 0x37, 0x00, 0x38, 0x00, 0x36, 0x00, 0x37, 0x00,
+    0x22, 0x00, 0x20, 0x00, 0x4c, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00,
+    0x61, 0x00, 0x72, 0x00, 0x47, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6e, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x39, 0x00,
+    0x32, 0x00, 0x22, 0x00, 0x20, 0x00, 0x54, 0x00, 0x72, 0x00, 0x61, 0x00,
+    0x6e, 0x00, 0x73, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00,
+    0x6e, 0x00, 0x50, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x74, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x34, 0x00,
+    0x30, 0x00, 0x34, 0x00, 0x35, 0x00, 0x22, 0x00, 0x2f, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x4d, 0x00, 0x65, 0x00,
+    0x61, 0x00, 0x73, 0x00, 0x75, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6d, 0x00,
+    0x65, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00,
+    0x61, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x2f, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x52, 0x00,
+    0x47, 0x00, 0x42, 0x00, 0x56, 0x00, 0x69, 0x00, 0x72, 0x00, 0x74, 0x00,
+    0x75, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x44, 0x00, 0x65, 0x00, 0x76, 0x00,
+    0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x43, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x62, 0x00, 0x72, 0x00,
+    0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00,
+    0x61, 0x00, 0x6c, 0x00, 0x3a, 0x00, 0x41, 0x00, 0x64, 0x00, 0x61, 0x00,
+    0x70, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x47, 0x00, 0x61, 0x00,
+    0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6e, 0x00,
+    0x66, 0x00, 0x69, 0x00, 0x67, 0x00, 0x75, 0x00, 0x72, 0x00, 0x61, 0x00,
+    0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00,
+    0x61, 0x00, 0x6c, 0x00, 0x3a, 0x00, 0x50, 0x00, 0x61, 0x00, 0x72, 0x00,
+    0x61, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00,
+    0x69, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x64, 0x00, 0x43, 0x00, 0x75, 0x00,
+    0x72, 0x00, 0x76, 0x00, 0x65, 0x00, 0x73, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x52, 0x00, 0x65, 0x00,
+    0x64, 0x00, 0x54, 0x00, 0x52, 0x00, 0x43, 0x00, 0x20, 0x00, 0x47, 0x00,
+    0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x22, 0x00, 0x20, 0x00, 0x47, 0x00, 0x61, 0x00,
+    0x69, 0x00, 0x6e, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x2e, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x22, 0x00, 0x20, 0x00, 0x4f, 0x00, 0x66, 0x00, 0x66, 0x00, 0x73, 0x00,
+    0x65, 0x00, 0x74, 0x00, 0x31, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x30, 0x00,
+    0x2e, 0x00, 0x30, 0x00, 0x22, 0x00, 0x2f, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x47, 0x00, 0x72, 0x00,
+    0x65, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x54, 0x00, 0x52, 0x00, 0x43, 0x00,
+    0x20, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x22, 0x00, 0x20, 0x00,
+    0x47, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x22, 0x00, 0x20, 0x00, 0x4f, 0x00, 0x66, 0x00,
+    0x66, 0x00, 0x73, 0x00, 0x65, 0x00, 0x74, 0x00, 0x31, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x22, 0x00, 0x2f, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00,
+    0x42, 0x00, 0x6c, 0x00, 0x75, 0x00, 0x65, 0x00, 0x54, 0x00, 0x52, 0x00,
+    0x43, 0x00, 0x20, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00,
+    0x61, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x30, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x22, 0x00,
+    0x20, 0x00, 0x47, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x22, 0x00, 0x20, 0x00, 0x4f, 0x00,
+    0x66, 0x00, 0x66, 0x00, 0x73, 0x00, 0x65, 0x00, 0x74, 0x00, 0x31, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x22, 0x00,
+    0x2f, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6c, 0x00,
+    0x3a, 0x00, 0x50, 0x00, 0x61, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6d, 0x00,
+    0x65, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x7a, 0x00,
+    0x65, 0x00, 0x64, 0x00, 0x43, 0x00, 0x75, 0x00, 0x72, 0x00, 0x76, 0x00,
+    0x65, 0x00, 0x73, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6c, 0x00,
+    0x3a, 0x00, 0x41, 0x00, 0x64, 0x00, 0x61, 0x00, 0x70, 0x00, 0x74, 0x00,
+    0x65, 0x00, 0x72, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00,
+    0x61, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x66, 0x00, 0x69, 0x00,
+    0x67, 0x00, 0x75, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x43, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x62, 0x00, 0x72, 0x00,
+    0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x64, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00,
+    0x72, 0x00, 0x44, 0x00, 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x63, 0x00,
+    0x65, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6c, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x3c, 0x00, 0x3f, 0x00, 0x78, 0x00,
+    0x6d, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x76, 0x00, 0x65, 0x00, 0x72, 0x00,
+    0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x22, 0x00, 0x3f, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x41, 0x00, 0x70, 0x00, 0x70, 0x00, 0x65, 0x00, 0x61, 0x00, 0x72, 0x00,
+    0x61, 0x00, 0x6e, 0x00, 0x63, 0x00, 0x65, 0x00, 0x4d, 0x00, 0x6f, 0x00,
+    0x64, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x49, 0x00, 0x44, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00,
+    0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00,
+    0x65, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x6d, 0x00,
+    0x69, 0x00, 0x63, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00,
+    0x66, 0x00, 0x74, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00,
+    0x2f, 0x00, 0x77, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x6f, 0x00,
+    0x77, 0x00, 0x73, 0x00, 0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x35, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x32, 0x00, 0x2f, 0x00, 0x63, 0x00,
+    0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x2f, 0x00, 0x44, 0x00,
+    0x36, 0x00, 0x35, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00,
+    0x70, 0x00, 0x22, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00,
+    0x6e, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00,
+    0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00,
+    0x65, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x6d, 0x00,
+    0x69, 0x00, 0x63, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00,
+    0x66, 0x00, 0x74, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00,
+    0x2f, 0x00, 0x77, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x6f, 0x00,
+    0x77, 0x00, 0x73, 0x00, 0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x35, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x32, 0x00, 0x2f, 0x00, 0x63, 0x00,
+    0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x2f, 0x00, 0x43, 0x00,
+    0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x41, 0x00, 0x70, 0x00,
+    0x70, 0x00, 0x65, 0x00, 0x61, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6e, 0x00,
+    0x63, 0x00, 0x65, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x64, 0x00, 0x65, 0x00,
+    0x6c, 0x00, 0x22, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00,
+    0x6e, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00,
+    0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00,
+    0x65, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x6d, 0x00,
+    0x69, 0x00, 0x63, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00,
+    0x66, 0x00, 0x74, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00,
+    0x2f, 0x00, 0x77, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x6f, 0x00,
+    0x77, 0x00, 0x73, 0x00, 0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x35, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x32, 0x00, 0x2f, 0x00, 0x63, 0x00,
+    0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x2f, 0x00, 0x57, 0x00,
+    0x63, 0x00, 0x73, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x6d, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00,
+    0x69, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x54, 0x00, 0x79, 0x00, 0x70, 0x00,
+    0x65, 0x00, 0x73, 0x00, 0x22, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00,
+    0x6c, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x78, 0x00, 0x73, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00,
+    0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x77, 0x00, 0x77, 0x00,
+    0x2e, 0x00, 0x77, 0x00, 0x33, 0x00, 0x2e, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x67, 0x00, 0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x31, 0x00,
+    0x2f, 0x00, 0x58, 0x00, 0x4d, 0x00, 0x4c, 0x00, 0x53, 0x00, 0x63, 0x00,
+    0x68, 0x00, 0x65, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x2d, 0x00, 0x69, 0x00,
+    0x6e, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x63, 0x00,
+    0x65, 0x00, 0x22, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x50, 0x00,
+    0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x65, 0x00,
+    0x4e, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x77, 0x00, 0x63, 0x00,
+    0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00,
+    0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x3a, 0x00, 0x6c, 0x00,
+    0x61, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x65, 0x00,
+    0x6e, 0x00, 0x2d, 0x00, 0x55, 0x00, 0x53, 0x00, 0x22, 0x00, 0x3e, 0x00,
+    0x57, 0x00, 0x43, 0x00, 0x53, 0x00, 0x20, 0x00, 0x70, 0x00, 0x72, 0x00,
+    0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x20, 0x00,
+    0x66, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x20, 0x00, 0x73, 0x00, 0x52, 0x00,
+    0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x76, 0x00, 0x69, 0x00, 0x65, 0x00,
+    0x77, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x20, 0x00, 0x63, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x77, 0x00,
+    0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00,
+    0x74, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x2f, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x50, 0x00,
+    0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x65, 0x00,
+    0x4e, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x44, 0x00, 0x65, 0x00, 0x73, 0x00, 0x63, 0x00, 0x72, 0x00,
+    0x69, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00,
+    0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00,
+    0x78, 0x00, 0x74, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00,
+    0x3a, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2d, 0x00, 0x55, 0x00, 0x53, 0x00,
+    0x22, 0x00, 0x3e, 0x00, 0x44, 0x00, 0x65, 0x00, 0x66, 0x00, 0x61, 0x00,
+    0x75, 0x00, 0x6c, 0x00, 0x74, 0x00, 0x20, 0x00, 0x70, 0x00, 0x72, 0x00,
+    0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x20, 0x00,
+    0x66, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x20, 0x00, 0x61, 0x00, 0x20, 0x00,
+    0x73, 0x00, 0x52, 0x00, 0x47, 0x00, 0x42, 0x00, 0x20, 0x00, 0x6d, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x69, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x20, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x73, 0x00, 0x74, 0x00,
+    0x61, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00,
+    0x20, 0x00, 0x76, 0x00, 0x69, 0x00, 0x65, 0x00, 0x77, 0x00, 0x69, 0x00,
+    0x6e, 0x00, 0x67, 0x00, 0x20, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6e, 0x00,
+    0x64, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00,
+    0x73, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00,
+    0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00,
+    0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x44, 0x00, 0x65, 0x00, 0x73, 0x00,
+    0x63, 0x00, 0x72, 0x00, 0x69, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x41, 0x00,
+    0x75, 0x00, 0x74, 0x00, 0x68, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x77, 0x00,
+    0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00,
+    0x74, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x3a, 0x00,
+    0x6c, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x65, 0x00, 0x6e, 0x00, 0x2d, 0x00, 0x55, 0x00, 0x53, 0x00, 0x22, 0x00,
+    0x3e, 0x00, 0x4d, 0x00, 0x69, 0x00, 0x63, 0x00, 0x72, 0x00, 0x6f, 0x00,
+    0x73, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x74, 0x00, 0x20, 0x00, 0x43, 0x00,
+    0x6f, 0x00, 0x72, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x61, 0x00,
+    0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00,
+    0x78, 0x00, 0x74, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x41, 0x00, 0x75, 0x00, 0x74, 0x00, 0x68, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00,
+    0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x56, 0x00, 0x69, 0x00, 0x65, 0x00,
+    0x77, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x43, 0x00, 0x6f, 0x00,
+    0x6e, 0x00, 0x64, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00,
+    0x6e, 0x00, 0x73, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x57, 0x00, 0x68, 0x00, 0x69, 0x00, 0x74, 0x00, 0x65, 0x00, 0x50, 0x00,
+    0x6f, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x4e, 0x00, 0x61, 0x00,
+    0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x44, 0x00, 0x36, 0x00, 0x35, 0x00,
+    0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x57, 0x00, 0x68, 0x00, 0x69, 0x00, 0x74, 0x00, 0x65, 0x00, 0x50, 0x00,
+    0x6f, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x4e, 0x00, 0x61, 0x00,
+    0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x42, 0x00, 0x61, 0x00, 0x63, 0x00, 0x6b, 0x00, 0x67, 0x00, 0x72, 0x00,
+    0x6f, 0x00, 0x75, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x20, 0x00, 0x58, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x31, 0x00, 0x39, 0x00, 0x2e, 0x00, 0x30, 0x00,
+    0x22, 0x00, 0x20, 0x00, 0x59, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x32, 0x00,
+    0x30, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x22, 0x00, 0x20, 0x00, 0x5a, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x32, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x37, 0x00,
+    0x38, 0x00, 0x22, 0x00, 0x2f, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x53, 0x00, 0x75, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6f, 0x00,
+    0x75, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x3e, 0x00, 0x41, 0x00, 0x76, 0x00,
+    0x65, 0x00, 0x72, 0x00, 0x61, 0x00, 0x67, 0x00, 0x65, 0x00, 0x3c, 0x00,
+    0x2f, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x53, 0x00,
+    0x75, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x75, 0x00, 0x6e, 0x00,
+    0x64, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x4c, 0x00,
+    0x75, 0x00, 0x6d, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x61, 0x00, 0x6e, 0x00,
+    0x63, 0x00, 0x65, 0x00, 0x4f, 0x00, 0x66, 0x00, 0x41, 0x00, 0x64, 0x00,
+    0x61, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00,
+    0x46, 0x00, 0x69, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x64, 0x00, 0x3e, 0x00,
+    0x31, 0x00, 0x36, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x4c, 0x00, 0x75, 0x00,
+    0x6d, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x63, 0x00,
+    0x65, 0x00, 0x4f, 0x00, 0x66, 0x00, 0x41, 0x00, 0x64, 0x00, 0x61, 0x00,
+    0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x46, 0x00,
+    0x69, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x64, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x63, 0x00, 0x61, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x44, 0x00, 0x65, 0x00, 0x67, 0x00, 0x72, 0x00,
+    0x65, 0x00, 0x65, 0x00, 0x4f, 0x00, 0x66, 0x00, 0x41, 0x00, 0x64, 0x00,
+    0x61, 0x00, 0x70, 0x00, 0x74, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00, 0x31, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x44, 0x00, 0x65, 0x00,
+    0x67, 0x00, 0x72, 0x00, 0x65, 0x00, 0x65, 0x00, 0x4f, 0x00, 0x66, 0x00,
+    0x41, 0x00, 0x64, 0x00, 0x61, 0x00, 0x70, 0x00, 0x74, 0x00, 0x61, 0x00,
+    0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x61, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x56, 0x00, 0x69, 0x00, 0x65, 0x00, 0x77, 0x00,
+    0x69, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x6e, 0x00,
+    0x64, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00,
+    0x73, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x63, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x43, 0x00, 0x6f, 0x00,
+    0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x41, 0x00, 0x70, 0x00, 0x70, 0x00,
+    0x65, 0x00, 0x61, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x63, 0x00,
+    0x65, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6c, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x3c, 0x00, 0x3f, 0x00, 0x78, 0x00,
+    0x6d, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x76, 0x00, 0x65, 0x00, 0x72, 0x00,
+    0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x22, 0x00, 0x3f, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x3c, 0x00, 0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x75, 0x00, 0x74, 0x00,
+    0x4d, 0x00, 0x61, 0x00, 0x70, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x64, 0x00,
+    0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x49, 0x00, 0x44, 0x00, 0x3d, 0x00,
+    0x22, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00,
+    0x2f, 0x00, 0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00,
+    0x6d, 0x00, 0x61, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x6d, 0x00, 0x69, 0x00,
+    0x63, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x66, 0x00,
+    0x74, 0x00, 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x2f, 0x00,
+    0x77, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x6f, 0x00, 0x77, 0x00,
+    0x73, 0x00, 0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x35, 0x00,
+    0x2f, 0x00, 0x30, 0x00, 0x32, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x6f, 0x00,
+    0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x2f, 0x00, 0x4d, 0x00, 0x65, 0x00,
+    0x64, 0x00, 0x69, 0x00, 0x61, 0x00, 0x53, 0x00, 0x69, 0x00, 0x6d, 0x00,
+    0x2e, 0x00, 0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x70, 0x00, 0x22, 0x00,
+    0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x6e, 0x00, 0x73, 0x00,
+    0x3a, 0x00, 0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x3d, 0x00, 0x22, 0x00,
+    0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00, 0x2f, 0x00,
+    0x2f, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00, 0x6d, 0x00,
+    0x61, 0x00, 0x73, 0x00, 0x2e, 0x00, 0x6d, 0x00, 0x69, 0x00, 0x63, 0x00,
+    0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x74, 0x00,
+    0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x2f, 0x00, 0x77, 0x00,
+    0x69, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x6f, 0x00, 0x77, 0x00, 0x73, 0x00,
+    0x2f, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x35, 0x00, 0x2f, 0x00,
+    0x30, 0x00, 0x32, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6c, 0x00,
+    0x6f, 0x00, 0x72, 0x00, 0x2f, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00,
+    0x75, 0x00, 0x74, 0x00, 0x4d, 0x00, 0x61, 0x00, 0x70, 0x00, 0x4d, 0x00,
+    0x6f, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x22, 0x00, 0x20, 0x00,
+    0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x3a, 0x00,
+    0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x68, 0x00,
+    0x74, 0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00,
+    0x73, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00, 0x6d, 0x00, 0x61, 0x00,
+    0x73, 0x00, 0x2e, 0x00, 0x6d, 0x00, 0x69, 0x00, 0x63, 0x00, 0x72, 0x00,
+    0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x74, 0x00, 0x2e, 0x00,
+    0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x69, 0x00,
+    0x6e, 0x00, 0x64, 0x00, 0x6f, 0x00, 0x77, 0x00, 0x73, 0x00, 0x2f, 0x00,
+    0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x35, 0x00, 0x2f, 0x00, 0x30, 0x00,
+    0x32, 0x00, 0x2f, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00,
+    0x72, 0x00, 0x2f, 0x00, 0x57, 0x00, 0x63, 0x00, 0x73, 0x00, 0x43, 0x00,
+    0x6f, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x50, 0x00,
+    0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x65, 0x00,
+    0x54, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x73, 0x00, 0x22, 0x00,
+    0x20, 0x00, 0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x6e, 0x00, 0x73, 0x00,
+    0x3a, 0x00, 0x78, 0x00, 0x73, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x68, 0x00,
+    0x74, 0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00,
+    0x77, 0x00, 0x77, 0x00, 0x77, 0x00, 0x2e, 0x00, 0x77, 0x00, 0x33, 0x00,
+    0x2e, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x67, 0x00, 0x2f, 0x00, 0x32, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x31, 0x00, 0x2f, 0x00, 0x58, 0x00, 0x4d, 0x00,
+    0x4c, 0x00, 0x53, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00, 0x6d, 0x00,
+    0x61, 0x00, 0x2d, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x74, 0x00,
+    0x61, 0x00, 0x6e, 0x00, 0x63, 0x00, 0x65, 0x00, 0x22, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x67, 0x00, 0x6d, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00,
+    0x69, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x4e, 0x00, 0x61, 0x00, 0x6d, 0x00,
+    0x65, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00,
+    0x65, 0x00, 0x78, 0x00, 0x74, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00,
+    0x6c, 0x00, 0x3a, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x67, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2d, 0x00, 0x55, 0x00,
+    0x53, 0x00, 0x22, 0x00, 0x3e, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f, 0x00,
+    0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00, 0x20, 0x00,
+    0x2d, 0x00, 0x20, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x75, 0x00,
+    0x6c, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x20, 0x00, 0x70, 0x00,
+    0x61, 0x00, 0x70, 0x00, 0x65, 0x00, 0x72, 0x00, 0x2f, 0x00, 0x6d, 0x00,
+    0x65, 0x00, 0x64, 0x00, 0x69, 0x00, 0x61, 0x00, 0x20, 0x00, 0x63, 0x00,
+    0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00,
+    0x78, 0x00, 0x74, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x2f, 0x00, 0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x3a, 0x00,
+    0x50, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00,
+    0x65, 0x00, 0x4e, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x3e, 0x00,
+    0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x67, 0x00, 0x6d, 0x00,
+    0x6d, 0x00, 0x3a, 0x00, 0x44, 0x00, 0x65, 0x00, 0x73, 0x00, 0x63, 0x00,
+    0x72, 0x00, 0x69, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00,
+    0x6e, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x3c, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00,
+    0x65, 0x00, 0x78, 0x00, 0x74, 0x00, 0x20, 0x00, 0x78, 0x00, 0x6d, 0x00,
+    0x6c, 0x00, 0x3a, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x67, 0x00,
+    0x3d, 0x00, 0x22, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2d, 0x00, 0x55, 0x00,
+    0x53, 0x00, 0x22, 0x00, 0x3e, 0x00, 0x41, 0x00, 0x70, 0x00, 0x70, 0x00,
+    0x72, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x72, 0x00, 0x69, 0x00, 0x61, 0x00,
+    0x74, 0x00, 0x65, 0x00, 0x20, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x20, 0x00, 0x49, 0x00, 0x43, 0x00, 0x43, 0x00, 0x20, 0x00, 0x61, 0x00,
+    0x62, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x75, 0x00, 0x74, 0x00,
+    0x65, 0x00, 0x20, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x6f, 0x00,
+    0x72, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x74, 0x00, 0x72, 0x00,
+    0x69, 0x00, 0x63, 0x00, 0x20, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6e, 0x00,
+    0x64, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00,
+    0x20, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6e, 0x00,
+    0x74, 0x00, 0x20, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x6b, 0x00,
+    0x66, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x77, 0x00, 0x73, 0x00, 0x3c, 0x00,
+    0x2f, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00, 0x3a, 0x00, 0x54, 0x00,
+    0x65, 0x00, 0x78, 0x00, 0x74, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x44, 0x00, 0x65, 0x00, 0x73, 0x00, 0x63, 0x00, 0x72, 0x00,
+    0x69, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x67, 0x00,
+    0x6d, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x41, 0x00, 0x75, 0x00, 0x74, 0x00,
+    0x68, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00,
+    0x09, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x77, 0x00, 0x63, 0x00, 0x73, 0x00,
+    0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00, 0x20, 0x00,
+    0x78, 0x00, 0x6d, 0x00, 0x6c, 0x00, 0x3a, 0x00, 0x6c, 0x00, 0x61, 0x00,
+    0x6e, 0x00, 0x67, 0x00, 0x3d, 0x00, 0x22, 0x00, 0x65, 0x00, 0x6e, 0x00,
+    0x2d, 0x00, 0x55, 0x00, 0x53, 0x00, 0x22, 0x00, 0x3e, 0x00, 0x4d, 0x00,
+    0x69, 0x00, 0x63, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x6f, 0x00,
+    0x66, 0x00, 0x74, 0x00, 0x20, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x72, 0x00,
+    0x70, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00,
+    0x6f, 0x00, 0x6e, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0x77, 0x00, 0x63, 0x00,
+    0x73, 0x00, 0x3a, 0x00, 0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x41, 0x00, 0x75, 0x00,
+    0x74, 0x00, 0x68, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x3e, 0x00, 0x0d, 0x00,
+    0x0a, 0x00, 0x09, 0x00, 0x3c, 0x00, 0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00,
+    0x3a, 0x00, 0x44, 0x00, 0x65, 0x00, 0x66, 0x00, 0x61, 0x00, 0x75, 0x00,
+    0x6c, 0x00, 0x74, 0x00, 0x42, 0x00, 0x61, 0x00, 0x73, 0x00, 0x65, 0x00,
+    0x6c, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x47, 0x00, 0x61, 0x00,
+    0x6d, 0x00, 0x75, 0x00, 0x74, 0x00, 0x4d, 0x00, 0x61, 0x00, 0x70, 0x00,
+    0x4d, 0x00, 0x6f, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x3e, 0x00,
+    0x48, 0x00, 0x50, 0x00, 0x4d, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x43, 0x00,
+    0x44, 0x00, 0x5f, 0x00, 0x41, 0x00, 0x62, 0x00, 0x73, 0x00, 0x6f, 0x00,
+    0x6c, 0x00, 0x75, 0x00, 0x74, 0x00, 0x65, 0x00, 0x3c, 0x00, 0x2f, 0x00,
+    0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x44, 0x00, 0x65, 0x00,
+    0x66, 0x00, 0x61, 0x00, 0x75, 0x00, 0x6c, 0x00, 0x74, 0x00, 0x42, 0x00,
+    0x61, 0x00, 0x73, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x6e, 0x00,
+    0x65, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x75, 0x00, 0x74, 0x00,
+    0x4d, 0x00, 0x61, 0x00, 0x70, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x64, 0x00,
+    0x65, 0x00, 0x6c, 0x00, 0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x3c, 0x00,
+    0x2f, 0x00, 0x67, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x3a, 0x00, 0x47, 0x00,
+    0x61, 0x00, 0x6d, 0x00, 0x75, 0x00, 0x74, 0x00, 0x4d, 0x00, 0x61, 0x00,
+    0x70, 0x00, 0x4d, 0x00, 0x6f, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6c, 0x00,
+    0x3e, 0x00, 0x0d, 0x00, 0x0a, 0x00, 0x00, 0x00};
+
+ICCProfile ICCProfileForTestingAdobeRGB() {
+  return ICCProfile::FromData(
+      reinterpret_cast<const char*>(adobe_rgb_profile_data),
+      base::size(adobe_rgb_profile_data));
+}
+
+ICCProfile ICCProfileForTestingGenericRGB() {
+  return ICCProfile::FromData(
+      reinterpret_cast<const char*>(generic_rgb_profile_data),
+      base::size(generic_rgb_profile_data));
+}
+
+ICCProfile ICCProfileForTestingSRGB() {
+  return ICCProfile::FromData(reinterpret_cast<const char*>(srgb_profile_data),
+                              base::size(srgb_profile_data));
+}
+
+ICCProfile ICCProfileForTestingColorSpin() {
+  return ICCProfile::FromData(
+      reinterpret_cast<const char*>(colorspin_profile_data),
+      base::size(colorspin_profile_data));
+}
+
+ICCProfile ICCProfileForTestingNoAnalyticTrFn() {
+  return ICCProfile::FromData(
+      reinterpret_cast<const char*>(no_analytic_tr_fn_profile_data),
+      base::size(no_analytic_tr_fn_profile_data));
+}
+
+ICCProfile ICCProfileForTestingA2BOnly() {
+  return ICCProfile::FromData(
+      reinterpret_cast<const char*>(a2b_only_profile_data),
+      base::size(a2b_only_profile_data));
+}
+
+ICCProfile ICCProfileForTestingOvershoot() {
+  return ICCProfile::FromData(
+      reinterpret_cast<const char*>(overshoot_profile_data),
+      base::size(overshoot_profile_data));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/test/icc_profiles.h b/ui/gfx/test/icc_profiles.h
new file mode 100644
index 0000000..8b13d4a
--- /dev/null
+++ b/ui/gfx/test/icc_profiles.h
@@ -0,0 +1,28 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_TEST_ICC_PROFILES_H_
+#define UI_GFX_TEST_ICC_PROFILES_H_
+
+#include "ui/gfx/icc_profile.h"
+
+namespace gfx {
+
+ICCProfile ICCProfileForTestingAdobeRGB();
+ICCProfile ICCProfileForTestingColorSpin();
+ICCProfile ICCProfileForTestingGenericRGB();
+ICCProfile ICCProfileForTestingSRGB();
+
+// A profile that does not have an analytic transfer function.
+ICCProfile ICCProfileForTestingNoAnalyticTrFn();
+
+// A profile that is A2B only.
+ICCProfile ICCProfileForTestingA2BOnly();
+
+// A profile that with an approxmation that shoots above 1.
+ICCProfile ICCProfileForTestingOvershoot();
+
+}  // namespace gfx
+
+#endif  // UI_GFX_TEST_ICC_PROFILES_H_
\ No newline at end of file
diff --git a/ui/gfx/test/run_all_unittests.cc b/ui/gfx/test/run_all_unittests.cc
new file mode 100644
index 0000000..e0b546d
--- /dev/null
+++ b/ui/gfx/test/run_all_unittests.cc
@@ -0,0 +1,88 @@
+// Copyright 2014 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.
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/path_service.h"
+#include "base/test/launcher/unit_test_launcher.h"
+#include "base/test/test_discardable_memory_allocator.h"
+#include "base/test/test_suite.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "ui/base/ui_base_paths.h"
+#include "ui/gfx/font_util.h"
+
+#if defined(OS_MAC)
+#include "base/test/mock_chrome_application_mac.h"
+#endif
+
+#if !defined(OS_IOS)
+#include "mojo/core/embedder/embedder.h"  // nogncheck
+#endif
+
+#if defined(OS_FUCHSIA)
+#include "skia/ext/test_fonts.h"  // nogncheck
+#endif
+
+namespace {
+
+class GfxTestSuite : public base::TestSuite {
+ public:
+  GfxTestSuite(int argc, char** argv) : base::TestSuite(argc, argv) {
+  }
+
+  GfxTestSuite(const GfxTestSuite&) = delete;
+  GfxTestSuite& operator=(const GfxTestSuite&) = delete;
+
+ protected:
+  void Initialize() override {
+    base::TestSuite::Initialize();
+
+#if defined(OS_MAC)
+    mock_cr_app::RegisterMockCrApp();
+#endif
+
+    ui::RegisterPathProvider();
+
+    base::FilePath ui_test_pak_path;
+    ASSERT_TRUE(base::PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
+    ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
+
+#if defined(OS_ANDROID)
+    // Android needs a discardable memory allocator when loading fallback fonts.
+    base::DiscardableMemoryAllocator::SetInstance(
+        &discardable_memory_allocator);
+#endif
+
+#if defined(OS_FUCHSIA)
+    skia::ConfigureTestFont();
+#endif
+
+    gfx::InitializeFonts();
+  }
+
+  void Shutdown() override {
+    ui::ResourceBundle::CleanupSharedInstance();
+    base::TestSuite::Shutdown();
+  }
+
+ private:
+  base::TestDiscardableMemoryAllocator discardable_memory_allocator;
+};
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  GfxTestSuite test_suite(argc, argv);
+
+#if !defined(OS_IOS)
+  mojo::core::Init();
+#endif
+
+  return base::LaunchUnitTests(
+      argc, argv,
+      base::BindOnce(&GfxTestSuite::Run, base::Unretained(&test_suite)));
+}
diff --git a/ui/gfx/text_constants.h b/ui/gfx/text_constants.h
new file mode 100644
index 0000000..f22a5d2
--- /dev/null
+++ b/ui/gfx/text_constants.h
@@ -0,0 +1,129 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_TEXT_CONSTANTS_H_
+#define UI_GFX_TEXT_CONSTANTS_H_
+
+namespace gfx {
+
+// TODO(msw): Distinguish between logical character stops and glyph stops?
+// TODO(msw): Merge with base::i18n::BreakIterator::BreakType.
+enum BreakType {
+  CHARACTER_BREAK = 0,  // Stop cursor movement on neighboring characters.
+  WORD_BREAK,           // Stop cursor movement on nearest word boundaries.
+  LINE_BREAK,           // Stop cursor movement on line ends as shown on screen.
+  FIELD_BREAK,          // Stop cursor movement on text ends.
+};
+
+// Specifies the selection behavior for a move/move-and-select command. For
+// example consider the state "ab|cd|e", i.e. cd is selected. Assume the
+// selection direction is from left to right. If we move to the beginning of the
+// line (LINE_BREAK, CURSOR_LEFT), the resultant state is:
+// "|ab|cde" for SELECTION_RETAIN, selection direction from right to left.
+// "|abcd|e" for SELECTION_EXTEND, selection direction from right to left.
+// "ab|cde" for SELECTION_CARET.
+// "|abcde" for SELECTION_NONE.
+enum SelectionBehavior {
+  // Default behavior for a move-and-select command. The selection start point
+  // remains the same. For example, this is the behavior of textfields on Mac
+  // for the command moveUpAndModifySelection (Shift + Up).
+  SELECTION_RETAIN,
+
+  // Use for move-and-select commands that want the existing selection to be
+  // extended in the opposite direction, when the selection direction is
+  // reversed. For example, this is the behavior for textfields on Mac for the
+  // command moveToLeftEndOfLineAndModifySelection (Command + Shift + Left).
+  SELECTION_EXTEND,
+
+  // Use for move-and-select commands that want the existing selection to reduce
+  // to a caret, when the selection direction is reversed. For example, this is
+  // the behavior for textfields on Mac for the command
+  // moveWordLeftAndModifySelection (Alt + Shift + Left).
+  SELECTION_CARET,
+
+  // No selection. To be used for move commands that don't want to cause a
+  // selection, and that want to collapse any pre-existing selection.
+  SELECTION_NONE,
+};
+
+// Specifies the word wrapping behavior when a word would exceed the available
+// display width. All words that are too wide will be put on a new line, and
+// then:
+enum WordWrapBehavior {
+  IGNORE_LONG_WORDS,   // Overflowing word text is left on that line.
+  TRUNCATE_LONG_WORDS, // Overflowing word text is truncated.
+  ELIDE_LONG_WORDS,    // Overflowing word text is elided at the ellipsis.
+  WRAP_LONG_WORDS,     // Overflowing word text is wrapped over multiple lines.
+};
+
+// Horizontal text alignment modes.
+enum HorizontalAlignment {
+  ALIGN_LEFT = 0, // Align the text's left edge with that of its display area.
+  ALIGN_CENTER,   // Align the text's center with that of its display area.
+  ALIGN_RIGHT,    // Align the text's right edge with that of its display area.
+  ALIGN_TO_HEAD,  // Align the text to its first strong character's direction.
+};
+
+// Vertical text alignment modes for multiline text.
+enum VerticalAlignment {
+  ALIGN_TOP = 0,  // Align the text's top edge with that of its display area.
+  ALIGN_MIDDLE,   // Align the text's center with that of its display area.
+  ALIGN_BOTTOM,   // Align the text's bottom edge with that of its display area.
+};
+
+// The directionality modes used to determine the base text direction.
+enum DirectionalityMode {
+  DIRECTIONALITY_FROM_TEXT = 0,  // Use the first strong character's direction.
+  DIRECTIONALITY_FROM_UI,        // Use the UI locale's text reading direction.
+  DIRECTIONALITY_FORCE_LTR,      // Use LTR regardless of content or UI locale.
+  DIRECTIONALITY_FORCE_RTL,      // Use RTL regardless of content or UI locale.
+  // Note: Unless the experimental feature LeftToRightUrls is enabled,
+  // DIRECTIONALITY_AS_URL is the same as DIRECTIONALITY_FORCE_LTR.
+  DIRECTIONALITY_AS_URL,  // FORCE_LTR with additional rules for URLs.
+};
+
+// Text styles and adornments.
+// TODO(msw): Merge with gfx::Font::FontStyle.
+enum TextStyle {
+  TEXT_STYLE_ITALIC = 0,
+  TEXT_STYLE_STRIKE,
+  TEXT_STYLE_UNDERLINE,
+  TEXT_STYLE_HEAVY_UNDERLINE,
+
+  TEXT_STYLE_COUNT,
+};
+
+// Text baseline offset types.
+// Figure of font metrics:
+//   +--------+--------+------------------------+-------------+
+//   |        |        | internal leading       | SUPERSCRIPT |
+//   |        |        +------------+-----------|             |
+//   |        | ascent |            | SUPERIOR  |-------------+
+//   | height |        | cap height |-----------|
+//   |        |        |            | INFERIOR  |-------------+
+//   |        |--------+------------+-----------|             |
+//   |        | descent                         | SUBSCRIPT   |
+//   +--------+---------------------------------+-------------+
+enum BaselineStyle {
+  NORMAL_BASELINE = 0,
+  SUPERSCRIPT,  // e.g. a mathematical exponent would be superscript.
+  SUPERIOR,     // e.g. 8th, the "th" would be superior script.
+  INFERIOR,     // e.g. 1/2, the "2" would be inferior ("1" is superior).
+  SUBSCRIPT,    // e.g. H2O, the "2" would be subscript.
+};
+
+// Elision behaviors of text that exceeds constrained dimensions.
+enum ElideBehavior {
+  NO_ELIDE = 0, // Do not modify the text, it may overflow its available bounds.
+  TRUNCATE,     // Do not elide or fade, just truncate at the end of the string.
+  ELIDE_HEAD,   // Add an ellipsis at the start of the string.
+  ELIDE_MIDDLE, // Add an ellipsis in the middle of the string.
+  ELIDE_TAIL,   // Add an ellipsis at the end of the string.
+  ELIDE_EMAIL,  // Add ellipses to username and domain substrings.
+  FADE_TAIL,    // Fade the string's end opposite of its horizontal alignment.
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_TEXT_CONSTANTS_H_
diff --git a/ui/gfx/text_elider.cc b/ui/gfx/text_elider.cc
new file mode 100644
index 0000000..211da2e
--- /dev/null
+++ b/ui/gfx/text_elider.cc
@@ -0,0 +1,846 @@
+// Copyright (c) 2012 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.
+//
+// This file implements utility functions for eliding and formatting UI text.
+//
+// Note that several of the functions declared in text_elider.h are implemented
+// in this file using helper classes in an unnamed namespace.
+
+#include "ui/gfx/text_elider.h"
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/check_op.h"
+#include "base/files/file_path.h"
+#include "base/i18n/break_iterator.h"
+#include "base/i18n/char_iterator.h"
+#include "base/i18n/rtl.h"
+#include "base/macros.h"
+#include "base/notreached.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "third_party/icu/source/common/unicode/rbbi.h"
+#include "third_party/icu/source/common/unicode/uloc.h"
+#include "third_party/icu/source/common/unicode/umachine.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/render_text.h"
+#include "ui/gfx/text_utils.h"
+
+using base::ASCIIToUTF16;
+using base::UTF8ToUTF16;
+using base::WideToUTF16;
+
+namespace gfx {
+
+namespace {
+
+#if defined(OS_IOS)
+// The returned string will have at least one character besides the ellipsis
+// on either side of '@'; if that's impossible, a single ellipsis is returned.
+// If possible, only the username is elided. Otherwise, the domain is elided
+// in the middle, splitting available width equally with the elided username.
+// If the username is short enough that it doesn't need half the available
+// width, the elided domain will occupy that extra width.
+std::u16string ElideEmail(const std::u16string& email,
+                          const FontList& font_list,
+                          float available_pixel_width) {
+  if (GetStringWidthF(email, font_list) <= available_pixel_width)
+    return email;
+
+  // Split the email into its local-part (username) and domain-part. The email
+  // spec allows for @ symbols in the username under some special requirements,
+  // but not in the domain part, so splitting at the last @ symbol is safe.
+  const size_t split_index = email.find_last_of('@');
+  DCHECK_NE(split_index, std::u16string::npos);
+  std::u16string username = email.substr(0, split_index);
+  std::u16string domain = email.substr(split_index + 1);
+  DCHECK(!username.empty());
+  DCHECK(!domain.empty());
+
+  // Subtract the @ symbol from the available width as it is mandatory.
+  const std::u16string kAtSignUTF16 = u"@";
+  available_pixel_width -= GetStringWidthF(kAtSignUTF16, font_list);
+
+  // Check whether eliding the domain is necessary: if eliding the username
+  // is sufficient, the domain will not be elided.
+  const float full_username_width = GetStringWidthF(username, font_list);
+  const float available_domain_width =
+      available_pixel_width -
+      std::min(full_username_width,
+               GetStringWidthF(username.substr(0, 1) + kEllipsisUTF16,
+                               font_list));
+  if (GetStringWidthF(domain, font_list) > available_domain_width) {
+    // Elide the domain so that it only takes half of the available width.
+    // Should the username not need all the width available in its half, the
+    // domain will occupy the leftover width.
+    // If |desired_domain_width| is greater than |available_domain_width|: the
+    // minimal username elision allowed by the specifications will not fit; thus
+    // |desired_domain_width| must be <= |available_domain_width| at all cost.
+    const float desired_domain_width =
+        std::min(available_domain_width,
+                 std::max(available_pixel_width - full_username_width,
+                          available_pixel_width / 2));
+    domain = ElideText(domain, font_list, desired_domain_width, ELIDE_MIDDLE);
+    // Failing to elide the domain such that at least one character remains
+    // (other than the ellipsis itself) remains: return a single ellipsis.
+    if (domain.length() <= 1U)
+      return std::u16string(kEllipsisUTF16);
+  }
+
+  // Fit the username in the remaining width (at this point the elided username
+  // is guaranteed to fit with at least one character remaining given all the
+  // precautions taken earlier).
+  available_pixel_width -= GetStringWidthF(domain, font_list);
+  username = ElideText(username, font_list, available_pixel_width, ELIDE_TAIL);
+  return username + kAtSignUTF16 + domain;
+}
+#endif
+
+bool GetDefaultWhitespaceElision(bool elide_in_middle,
+                                 bool elide_at_beginning) {
+  return elide_at_beginning || !elide_in_middle;
+}
+
+}  // namespace
+
+// U+2026 in utf8
+const char kEllipsis[] = "\xE2\x80\xA6";
+const char16_t kEllipsisUTF16[] = {0x2026, 0};
+const char16_t kForwardSlash = '/';
+
+StringSlicer::StringSlicer(const std::u16string& text,
+                           const std::u16string& ellipsis,
+                           bool elide_in_middle,
+                           bool elide_at_beginning,
+                           absl::optional<bool> elide_whitespace)
+    : text_(text),
+      ellipsis_(ellipsis),
+      elide_in_middle_(elide_in_middle),
+      elide_at_beginning_(elide_at_beginning),
+      elide_whitespace_(elide_whitespace
+                            ? *elide_whitespace
+                            : GetDefaultWhitespaceElision(elide_in_middle,
+                                                          elide_at_beginning)) {
+}
+
+std::u16string StringSlicer::CutString(size_t length,
+                                       bool insert_ellipsis) const {
+  const std::u16string ellipsis_text =
+      insert_ellipsis ? ellipsis_ : std::u16string();
+
+  // For visual consistency, when eliding at either end of the string, excess
+  // space should be trimmed from the text to return "Foo bar..." instead of
+  // "Foo bar ...".
+
+  if (elide_at_beginning_) {
+    return ellipsis_text +
+           text_.substr(FindValidBoundaryAfter(text_, text_.length() - length,
+                                               elide_whitespace_));
+  }
+
+  if (!elide_in_middle_) {
+    return text_.substr(
+               0, FindValidBoundaryBefore(text_, length, elide_whitespace_)) +
+           ellipsis_text;
+  }
+
+  // Put the extra character, if any, before the cut.
+  // Extra space around the ellipses will *not* be trimmed for |elide_in_middle|
+  // mode (we can change this later). The reason is that when laying out a
+  // column of middle-trimmed lines of text (such as a list of paths), the
+  // desired appearance is to be fully justified and the elipses should more or
+  // less line up; eliminating space would make the text look more ragged.
+  const size_t half_length = length / 2;
+  const size_t prefix_length =
+      FindValidBoundaryBefore(text_, length - half_length, elide_whitespace_);
+  const size_t suffix_start = FindValidBoundaryAfter(
+      text_, text_.length() - half_length, elide_whitespace_);
+  return text_.substr(0, prefix_length) + ellipsis_text +
+         text_.substr(suffix_start);
+}
+
+std::u16string ElideFilename(const base::FilePath& filename,
+                             const FontList& font_list,
+                             float available_pixel_width) {
+#if defined(OS_WIN)
+  std::u16string filename_utf16 = WideToUTF16(filename.value());
+  std::u16string extension = WideToUTF16(filename.Extension());
+  std::u16string rootname =
+      WideToUTF16(filename.BaseName().RemoveExtension().value());
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  std::u16string filename_utf16 =
+      WideToUTF16(base::SysNativeMBToWide(filename.value()));
+  std::u16string extension =
+      WideToUTF16(base::SysNativeMBToWide(filename.Extension()));
+  std::u16string rootname = WideToUTF16(
+      base::SysNativeMBToWide(filename.BaseName().RemoveExtension().value()));
+#endif
+
+  const float full_width = GetStringWidthF(filename_utf16, font_list);
+  if (full_width <= available_pixel_width)
+    return base::i18n::GetDisplayStringInLTRDirectionality(filename_utf16);
+
+  if (rootname.empty() || extension.empty()) {
+    const std::u16string elided_name =
+        ElideText(filename_utf16, font_list, available_pixel_width, ELIDE_TAIL);
+    return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
+  }
+
+  const float ext_width = GetStringWidthF(extension, font_list);
+  const float root_width = GetStringWidthF(rootname, font_list);
+
+  // We may have trimmed the path.
+  if (root_width + ext_width <= available_pixel_width) {
+    const std::u16string elided_name = rootname + extension;
+    return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
+  }
+
+  if (ext_width >= available_pixel_width) {
+    const std::u16string elided_name = ElideText(
+        rootname + extension, font_list, available_pixel_width, ELIDE_MIDDLE);
+    return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
+  }
+
+  float available_root_width = available_pixel_width - ext_width;
+  std::u16string elided_name =
+      ElideText(rootname, font_list, available_root_width, ELIDE_TAIL);
+  elided_name += extension;
+  return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
+}
+
+std::u16string ElideText(const std::u16string& text,
+                         const FontList& font_list,
+                         float available_pixel_width,
+                         ElideBehavior behavior) {
+#if !defined(OS_IOS)
+  DCHECK_NE(behavior, FADE_TAIL);
+  std::unique_ptr<RenderText> render_text = RenderText::CreateRenderText();
+  render_text->SetCursorEnabled(false);
+  render_text->SetFontList(font_list);
+  available_pixel_width = std::ceil(available_pixel_width);
+  render_text->SetDisplayRect(
+      gfx::ToEnclosingRect(gfx::RectF(gfx::SizeF(available_pixel_width, 1))));
+  render_text->SetElideBehavior(behavior);
+  render_text->SetText(text);
+  return render_text->GetDisplayText();
+#else
+  DCHECK_NE(behavior, FADE_TAIL);
+  if (text.empty() || behavior == FADE_TAIL || behavior == NO_ELIDE ||
+      GetStringWidthF(text, font_list) <= available_pixel_width) {
+    return text;
+  }
+  if (behavior == ELIDE_EMAIL)
+    return ElideEmail(text, font_list, available_pixel_width);
+
+  const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
+  const bool elide_at_beginning = (behavior == ELIDE_HEAD);
+  const bool insert_ellipsis = (behavior != TRUNCATE);
+  const std::u16string ellipsis = std::u16string(kEllipsisUTF16);
+  StringSlicer slicer(text, ellipsis, elide_in_middle, elide_at_beginning);
+
+  if (insert_ellipsis &&
+      GetStringWidthF(ellipsis, font_list) > available_pixel_width)
+    return std::u16string();
+
+  // Use binary search to compute the elided text.
+  size_t lo = 0;
+  size_t hi = text.length() - 1;
+  size_t guess;
+  std::u16string cut;
+  for (guess = (lo + hi) / 2; lo <= hi; guess = (lo + hi) / 2) {
+    // We check the width of the whole desired string at once to ensure we
+    // handle kerning/ligatures/etc. correctly.
+    // TODO(skanuj) : Handle directionality of ellipsis based on adjacent
+    // characters.  See crbug.com/327963.
+    cut = slicer.CutString(guess, insert_ellipsis);
+    const float guess_width = GetStringWidthF(cut, font_list);
+    if (guess_width == available_pixel_width)
+      break;
+    if (guess_width > available_pixel_width) {
+      hi = guess - 1;
+      // Move back on the loop terminating condition when the guess is too wide.
+      if (hi < lo)
+        lo = hi;
+    } else {
+      lo = guess + 1;
+    }
+  }
+
+  return cut;
+#endif
+}
+
+bool ElideString(const std::u16string& input,
+                 size_t max_len,
+                 std::u16string* output) {
+  if (input.length() <= max_len) {
+    output->assign(input);
+    return false;
+  }
+
+  switch (max_len) {
+    case 0:
+      output->clear();
+      break;
+    case 1:
+      output->assign(input.substr(0, 1));
+      break;
+    case 2:
+      output->assign(input.substr(0, 2));
+      break;
+    case 3:
+      output->assign(input.substr(0, 1) + u"." +
+                     input.substr(input.length() - 1));
+      break;
+    case 4:
+      output->assign(input.substr(0, 1) + u".." +
+                     input.substr(input.length() - 1));
+      break;
+    default: {
+      size_t rstr_len = (max_len - 3) / 2;
+      size_t lstr_len = rstr_len + ((max_len - 3) % 2);
+      output->assign(input.substr(0, lstr_len) + u"..." +
+                     input.substr(input.length() - rstr_len));
+      break;
+    }
+  }
+
+  return true;
+}
+
+namespace {
+
+// Internal class used to track progress of a rectangular string elide
+// operation.  Exists so the top-level ElideRectangleString() function
+// can be broken into smaller methods sharing this state.
+class RectangleString {
+ public:
+  RectangleString(size_t max_rows,
+                  size_t max_cols,
+                  bool strict,
+                  std::u16string* output)
+      : max_rows_(max_rows),
+        max_cols_(max_cols),
+        current_row_(0),
+        current_col_(0),
+        strict_(strict),
+        suppressed_(false),
+        output_(output) {}
+
+  RectangleString(const RectangleString&) = delete;
+  RectangleString& operator=(const RectangleString&) = delete;
+
+  // Perform deferred initializations following creation.  Must be called
+  // before any input can be added via AddString().
+  void Init() { output_->clear(); }
+
+  // Add an input string, reformatting to fit the desired dimensions.
+  // AddString() may be called multiple times to concatenate together
+  // multiple strings into the region (the current caller doesn't do
+  // this, however).
+  void AddString(const std::u16string& input);
+
+  // Perform any deferred output processing.  Must be called after the
+  // last AddString() call has occurred.
+  bool Finalize();
+
+ private:
+  // Add a line to the rectangular region at the current position,
+  // either by itself or by breaking it into words.
+  void AddLine(const std::u16string& line);
+
+  // Add a word to the rectangular region at the current position,
+  // either by itself or by breaking it into characters.
+  void AddWord(const std::u16string& word);
+
+  // Add text to the output string if the rectangular boundaries
+  // have not been exceeded, advancing the current position.
+  void Append(const std::u16string& string);
+
+  // Set the current position to the beginning of the next line.  If
+  // |output| is true, add a newline to the output string if the rectangular
+  // boundaries have not been exceeded.  If |output| is false, we assume
+  // some other mechanism will (likely) do similar breaking after the fact.
+  void NewLine(bool output);
+
+  // Maximum number of rows allowed in the output string.
+  size_t max_rows_;
+
+  // Maximum number of characters allowed in the output string.
+  size_t max_cols_;
+
+  // Current row position, always incremented and may exceed max_rows_
+  // when the input can not fit in the region.  We stop appending to
+  // the output string, however, when this condition occurs.  In the
+  // future, we may want to expose this value to allow the caller to
+  // determine how many rows would actually be required to hold the
+  // formatted string.
+  size_t current_row_;
+
+  // Current character position, should never exceed max_cols_.
+  size_t current_col_;
+
+  // True when we do whitespace to newline conversions ourselves.
+  bool strict_;
+
+  // True when some of the input has been truncated.
+  bool suppressed_;
+
+  // String onto which the output is accumulated.
+  std::u16string* output_;
+};
+
+void RectangleString::AddString(const std::u16string& input) {
+  base::i18n::BreakIterator lines(input,
+                                  base::i18n::BreakIterator::BREAK_NEWLINE);
+  if (lines.Init()) {
+    while (lines.Advance())
+      AddLine(lines.GetString());
+  } else {
+    NOTREACHED() << "BreakIterator (lines) init failed";
+  }
+}
+
+bool RectangleString::Finalize() {
+  if (suppressed_) {
+    output_->append(u"...");
+    return true;
+  }
+  return false;
+}
+
+void RectangleString::AddLine(const std::u16string& line) {
+  if (line.length() < max_cols_) {
+    Append(line);
+  } else {
+    base::i18n::BreakIterator words(line,
+                                    base::i18n::BreakIterator::BREAK_SPACE);
+    if (words.Init()) {
+      while (words.Advance())
+        AddWord(words.GetString());
+    } else {
+      NOTREACHED() << "BreakIterator (words) init failed";
+    }
+  }
+  // Account for naturally-occuring newlines.
+  ++current_row_;
+  current_col_ = 0;
+}
+
+void RectangleString::AddWord(const std::u16string& word) {
+  if (word.length() < max_cols_) {
+    // Word can be made to fit, no need to fragment it.
+    if (current_col_ + word.length() >= max_cols_)
+      NewLine(strict_);
+    Append(word);
+  } else {
+    // Word is so big that it must be fragmented.
+    size_t array_start = 0;
+    int char_start = 0;
+    base::i18n::UTF16CharIterator chars(word);
+    for (; !chars.end(); chars.Advance()) {
+      // When boundary is hit, add as much as will fit on this line.
+      if (current_col_ + (chars.char_offset() - char_start) >= max_cols_) {
+        Append(word.substr(array_start, chars.array_pos() - array_start));
+        NewLine(true);
+        array_start = chars.array_pos();
+        char_start = chars.char_offset();
+      }
+    }
+    // Add the last remaining fragment, if any.
+    if (array_start != chars.array_pos())
+      Append(word.substr(array_start, chars.array_pos() - array_start));
+  }
+}
+
+void RectangleString::Append(const std::u16string& string) {
+  if (current_row_ < max_rows_)
+    output_->append(string);
+  else
+    suppressed_ = true;
+  current_col_ += string.length();
+}
+
+void RectangleString::NewLine(bool output) {
+  if (current_row_ < max_rows_) {
+    if (output)
+      output_->append(u"\n");
+  } else {
+    suppressed_ = true;
+  }
+  ++current_row_;
+  current_col_ = 0;
+}
+
+// Internal class used to track progress of a rectangular text elide
+// operation.  Exists so the top-level ElideRectangleText() function
+// can be broken into smaller methods sharing this state.
+class RectangleText {
+ public:
+  RectangleText(const FontList& font_list,
+                float available_pixel_width,
+                int available_pixel_height,
+                WordWrapBehavior wrap_behavior,
+                std::vector<std::u16string>* lines)
+      : font_list_(font_list),
+        line_height_(font_list.GetHeight()),
+        available_pixel_width_(available_pixel_width),
+        available_pixel_height_(available_pixel_height),
+        wrap_behavior_(wrap_behavior),
+        lines_(lines) {}
+
+  RectangleText(const RectangleText&) = delete;
+  RectangleText& operator=(const RectangleText&) = delete;
+
+  // Perform deferred initializations following creation.  Must be called
+  // before any input can be added via AddString().
+  void Init() { lines_->clear(); }
+
+  // Add an input string, reformatting to fit the desired dimensions.
+  // AddString() may be called multiple times to concatenate together
+  // multiple strings into the region (the current caller doesn't do
+  // this, however).
+  void AddString(const std::u16string& input);
+
+  // Perform any deferred output processing.  Must be called after the last
+  // AddString() call has occurred. Returns a combination of
+  // |ReformattingResultFlags| indicating whether the given width or height was
+  // insufficient, leading to elision or truncation.
+  int Finalize();
+
+ private:
+  // Add a line to the rectangular region at the current position,
+  // either by itself or by breaking it into words.
+  void AddLine(const std::u16string& line);
+
+  // Wrap the specified word across multiple lines.
+  int WrapWord(const std::u16string& word);
+
+  // Add a long word - wrapping, eliding or truncating per the wrap behavior.
+  int AddWordOverflow(const std::u16string& word);
+
+  // Add a word to the rectangular region at the current position.
+  int AddWord(const std::u16string& word);
+
+  // Append the specified |text| to the current output line, incrementing the
+  // running width by the specified amount. This is an optimization over
+  // |AddToCurrentLine()| when |text_width| is already known.
+  void AddToCurrentLineWithWidth(const std::u16string& text, float text_width);
+
+  // Append the specified |text| to the current output line.
+  void AddToCurrentLine(const std::u16string& text);
+
+  // Set the current position to the beginning of the next line.
+  bool NewLine();
+
+  // The font list used for measuring text width.
+  const FontList& font_list_;
+
+  // The height of each line of text.
+  const int line_height_;
+
+  // The number of pixels of available width in the rectangle.
+  const float available_pixel_width_;
+
+  // The number of pixels of available height in the rectangle.
+  const int available_pixel_height_;
+
+  // The wrap behavior for words that are too long to fit on a single line.
+  const WordWrapBehavior wrap_behavior_;
+
+  // The current running width.
+  float current_width_ = 0;
+
+  // The current running height.
+  int current_height_ = 0;
+
+  // The current line of text.
+  std::u16string current_line_;
+
+  // Indicates whether the last line ended with \n.
+  bool last_line_ended_in_lf_ = false;
+
+  // The output vector of lines.
+  std::vector<std::u16string>* lines_;
+
+  // Indicates whether a word was so long that it had to be truncated or elided
+  // to fit the available width.
+  bool insufficient_width_ = false;
+
+  // Indicates whether there were too many lines for the available height.
+  bool insufficient_height_ = false;
+
+  // Indicates whether the very first word was truncated.
+  bool first_word_truncated_ = false;
+};
+
+void RectangleText::AddString(const std::u16string& input) {
+  base::i18n::BreakIterator lines(input,
+                                  base::i18n::BreakIterator::BREAK_NEWLINE);
+  if (lines.Init()) {
+    while (!insufficient_height_ && lines.Advance()) {
+      std::u16string line = lines.GetString();
+      // The BREAK_NEWLINE iterator will keep the trailing newline character,
+      // except in the case of the last line, which may not have one.  Remove
+      // the newline character, if it exists.
+      last_line_ended_in_lf_ = !line.empty() && line.back() == '\n';
+      if (last_line_ended_in_lf_)
+        line.resize(line.length() - 1);
+      AddLine(line);
+    }
+  } else {
+    NOTREACHED() << "BreakIterator (lines) init failed";
+  }
+}
+
+int RectangleText::Finalize() {
+  // Remove trailing whitespace from the last line or remove the last line
+  // completely, if it's just whitespace.
+  if (!insufficient_height_ && !lines_->empty()) {
+    base::TrimWhitespace(lines_->back(), base::TRIM_TRAILING, &lines_->back());
+    if (lines_->back().empty() && !last_line_ended_in_lf_)
+      lines_->pop_back();
+  }
+  if (last_line_ended_in_lf_)
+    lines_->push_back(std::u16string());
+  return (insufficient_width_ ? INSUFFICIENT_SPACE_HORIZONTAL : 0) |
+         (insufficient_height_ ? INSUFFICIENT_SPACE_VERTICAL : 0) |
+         (first_word_truncated_ ? INSUFFICIENT_SPACE_FOR_FIRST_WORD : 0);
+}
+
+void RectangleText::AddLine(const std::u16string& line) {
+  const float line_width = GetStringWidthF(line, font_list_);
+  if (line_width <= available_pixel_width_) {
+    AddToCurrentLineWithWidth(line, line_width);
+  } else {
+    // Iterate over positions that are valid to break the line at. In general,
+    // these are word boundaries but after any punctuation following the word.
+    base::i18n::BreakIterator words(line,
+                                    base::i18n::BreakIterator::BREAK_LINE);
+    if (words.Init()) {
+      while (words.Advance()) {
+        const bool truncate = !current_line_.empty();
+        const std::u16string& word = words.GetString();
+        const int lines_added = AddWord(word);
+        if (lines_added) {
+          if (truncate) {
+            // Trim trailing whitespace from the line that was added.
+            const size_t new_line = lines_->size() - lines_added;
+            base::TrimWhitespace(lines_->at(new_line), base::TRIM_TRAILING,
+                                 &lines_->at(new_line));
+          }
+          if (base::ContainsOnlyChars(word, base::kWhitespaceUTF16)) {
+            // Skip the first space if the previous line was carried over.
+            current_width_ = 0;
+            current_line_.clear();
+          }
+        }
+      }
+    } else {
+      NOTREACHED() << "BreakIterator (words) init failed";
+    }
+  }
+  // Account for naturally-occuring newlines.
+  NewLine();
+}
+
+int RectangleText::WrapWord(const std::u16string& word) {
+  // Word is so wide that it must be fragmented.
+  std::u16string text = word;
+  int lines_added = 0;
+  bool first_fragment = true;
+  while (!insufficient_height_ && !text.empty()) {
+    std::u16string fragment =
+        ElideText(text, font_list_, available_pixel_width_, TRUNCATE);
+    // At least one character has to be added at every line, even if the
+    // available space is too small.
+    if (fragment.empty())
+      fragment = text.substr(0, 1);
+    if (!first_fragment && NewLine())
+      lines_added++;
+    AddToCurrentLine(fragment);
+    text = text.substr(fragment.length());
+    first_fragment = false;
+  }
+  return lines_added;
+}
+
+int RectangleText::AddWordOverflow(const std::u16string& word) {
+  int lines_added = 0;
+
+  // Unless this is the very first word, put it on a new line.
+  if (!current_line_.empty()) {
+    if (!NewLine())
+      return 0;
+    lines_added++;
+  } else if (lines_->empty()) {
+    first_word_truncated_ = true;
+  }
+
+  if (wrap_behavior_ == IGNORE_LONG_WORDS) {
+    current_line_ = word;
+    current_width_ = available_pixel_width_;
+  } else if (wrap_behavior_ == WRAP_LONG_WORDS) {
+    lines_added += WrapWord(word);
+  } else {
+    const ElideBehavior elide_behavior =
+        (wrap_behavior_ == ELIDE_LONG_WORDS ? ELIDE_TAIL : TRUNCATE);
+    const std::u16string elided_word =
+        ElideText(word, font_list_, available_pixel_width_, elide_behavior);
+    AddToCurrentLine(elided_word);
+    insufficient_width_ = true;
+  }
+
+  return lines_added;
+}
+
+int RectangleText::AddWord(const std::u16string& word) {
+  int lines_added = 0;
+  std::u16string trimmed;
+  base::TrimWhitespace(word, base::TRIM_TRAILING, &trimmed);
+  const float trimmed_width = GetStringWidthF(trimmed, font_list_);
+  if (trimmed_width <= available_pixel_width_) {
+    // Word can be made to fit, no need to fragment it.
+    if ((current_width_ + trimmed_width > available_pixel_width_) && NewLine())
+      lines_added++;
+    // Append the non-trimmed word, in case more words are added after.
+    AddToCurrentLine(word);
+  } else {
+    lines_added = AddWordOverflow(wrap_behavior_ == IGNORE_LONG_WORDS ?
+                                  trimmed : word);
+  }
+  return lines_added;
+}
+
+void RectangleText::AddToCurrentLine(const std::u16string& text) {
+  AddToCurrentLineWithWidth(text, GetStringWidthF(text, font_list_));
+}
+
+void RectangleText::AddToCurrentLineWithWidth(const std::u16string& text,
+                                              float text_width) {
+  if (current_height_ >= available_pixel_height_) {
+    insufficient_height_ = true;
+    return;
+  }
+  current_line_.append(text);
+  current_width_ += text_width;
+}
+
+bool RectangleText::NewLine() {
+  bool line_added = false;
+  if (current_height_ < available_pixel_height_) {
+    lines_->push_back(current_line_);
+    current_line_.clear();
+    line_added = true;
+  } else {
+    insufficient_height_ = true;
+  }
+  current_height_ += line_height_;
+  current_width_ = 0;
+  return line_added;
+}
+
+}  // namespace
+
+bool ElideRectangleString(const std::u16string& input,
+                          size_t max_rows,
+                          size_t max_cols,
+                          bool strict,
+                          std::u16string* output) {
+  RectangleString rect(max_rows, max_cols, strict, output);
+  rect.Init();
+  rect.AddString(input);
+  return rect.Finalize();
+}
+
+int ElideRectangleText(const std::u16string& input,
+                       const FontList& font_list,
+                       float available_pixel_width,
+                       int available_pixel_height,
+                       WordWrapBehavior wrap_behavior,
+                       std::vector<std::u16string>* lines) {
+  RectangleText rect(font_list, available_pixel_width, available_pixel_height,
+                     wrap_behavior, lines);
+  rect.Init();
+  rect.AddString(input);
+  return rect.Finalize();
+}
+
+std::u16string TruncateString(const std::u16string& string,
+                              size_t length,
+                              BreakType break_type) {
+  const bool word_break = break_type == WORD_BREAK;
+  DCHECK(word_break || (break_type == CHARACTER_BREAK));
+
+  if (string.size() <= length)
+    return string;  // No need to elide.
+
+  if (length == 0)
+    return std::u16string();  // No room for anything, even an ellipsis.
+
+  // Added to the end of strings that are too big.
+  static const char16_t kElideString[] = {0x2026, 0};
+
+  if (length == 1)
+    return kElideString;  // Only room for an ellipsis.
+
+  int32_t index = static_cast<int32_t>(length - 1);
+  if (word_break) {
+    // Use a word iterator to find the first boundary.
+    UErrorCode status = U_ZERO_ERROR;
+    std::unique_ptr<icu::BreakIterator> bi(
+        icu::RuleBasedBreakIterator::createWordInstance(
+            icu::Locale::getDefault(), status));
+    if (U_FAILURE(status))
+      return string.substr(0, length - 1) + kElideString;
+    icu::UnicodeString bi_text(string.c_str());
+    bi->setText(bi_text);
+    index = bi->preceding(static_cast<int32_t>(length));
+    if (index == icu::BreakIterator::DONE || index == 0) {
+      // We either found no valid word break at all, or one right at the
+      // beginning of the string. Go back to the end; we'll have to break in the
+      // middle of a word.
+      index = static_cast<int32_t>(length - 1);
+    }
+  }
+
+  // By this point, |index| should point at the character that's a candidate for
+  // replacing with an ellipsis.  Use a character iterator to check previous
+  // characters and stop as soon as we find a previous non-whitespace character.
+  icu::StringCharacterIterator char_iterator(string.c_str());
+  char_iterator.setIndex(index);
+  while (char_iterator.hasPrevious()) {
+    char_iterator.previous();
+    if (!(u_isspace(char_iterator.current()) ||
+          u_charType(char_iterator.current()) == U_CONTROL_CHAR ||
+          u_charType(char_iterator.current()) == U_NON_SPACING_MARK)) {
+      // Not a whitespace character.  Truncate to everything up to and including
+      // this character, and append an ellipsis.
+      char_iterator.next();
+      return string.substr(0, char_iterator.getIndex()) + kElideString;
+    }
+  }
+
+  // Couldn't find a previous non-whitespace character.  If we were originally
+  // word-breaking, and index != length - 1, then the string is |index|
+  // whitespace characters followed by a word we're trying to break in the midst
+  // of, and we can fit at least one character of the word in the elided string.
+  // Do that rather than just returning an ellipsis.
+  if (word_break && (index != static_cast<int32_t>(length - 1)))
+    return string.substr(0, length - 1) + kElideString;
+
+  // Trying to break after only whitespace, elide all of it.
+  return kElideString;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/text_elider.h b/ui/gfx/text_elider.h
new file mode 100644
index 0000000..200ad04
--- /dev/null
+++ b/ui/gfx/text_elider.h
@@ -0,0 +1,162 @@
+// Copyright (c) 2012 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.
+//
+// This file defines utility functions for eliding and formatting UI text.
+
+#ifndef UI_GFX_TEXT_ELIDER_H_
+#define UI_GFX_TEXT_ELIDER_H_
+
+#include <stddef.h>
+
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "build/build_config.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/text_constants.h"
+
+namespace base {
+class FilePath;
+}
+
+namespace gfx {
+class FontList;
+
+GFX_EXPORT extern const char kEllipsis[];
+GFX_EXPORT extern const char16_t kEllipsisUTF16[];
+GFX_EXPORT extern const char16_t kForwardSlash;
+
+// Helper class to split + elide text, while respecting UTF-16 surrogate pairs
+// and combining character sequences.
+class GFX_EXPORT StringSlicer {
+ public:
+  // Warning: Retains a reference to |text| and |ellipsis|. They must have a
+  // longer lifetime than the StringSlicer.
+  //
+  // Note: if |elide_whitespace| is absl::nullopt, the default whitespace
+  // elision strategy for the type of elision being done will be chosen.
+  // Defaults are to trim for beginning and end elision; no trimming for middle
+  // elision.
+  StringSlicer(const std::u16string& text,
+               const std::u16string& ellipsis,
+               bool elide_in_middle,
+               bool elide_at_beginning,
+               absl::optional<bool> elide_whitespace = absl::nullopt);
+
+  StringSlicer(const StringSlicer&) = delete;
+  StringSlicer& operator=(const StringSlicer&) = delete;
+
+  // Cuts |text_| to be at most |length| UTF-16 code units long. If
+  // |elide_in_middle_| is true, the middle of the string is removed to leave
+  // equal-length pieces from the beginning and end of the string; otherwise,
+  // the end of the string is removed and only the beginning remains. If
+  // |insert_ellipsis| is true, then an ellipsis character will be inserted at
+  // the cut point (note that the ellipsis will does not count towards the
+  // |length| limit).
+  // Note: Characters may still be omitted even if |length| is the full string
+  // length, if surrogate pairs fall on the split boundary.
+  std::u16string CutString(size_t length, bool insert_ellipsis) const;
+
+ private:
+  // The text to be sliced.
+  const std::u16string& text_;
+
+  // Ellipsis string to use.
+  const std::u16string& ellipsis_;
+
+  // If true, the middle of the string will be elided.
+  const bool elide_in_middle_;
+
+  // If true, the beginning of the string will be elided.
+  const bool elide_at_beginning_;
+
+  // How whitespace around an elision point is handled.
+  const bool elide_whitespace_;
+};
+
+// Elides |text| to fit the |available_pixel_width| with the specified behavior.
+GFX_EXPORT std::u16string ElideText(const std::u16string& text,
+                                    const gfx::FontList& font_list,
+                                    float available_pixel_width,
+                                    ElideBehavior elide_behavior);
+
+// Elide a filename to fit a given pixel width, with an emphasis on not hiding
+// the extension unless we have to. If filename contains a path, the path will
+// be removed if filename doesn't fit into available_pixel_width. The elided
+// filename is forced to have LTR directionality, which means that in RTL UI
+// the elided filename is wrapped with LRE (Left-To-Right Embedding) mark and
+// PDF (Pop Directional Formatting) mark.
+GFX_EXPORT std::u16string ElideFilename(const base::FilePath& filename,
+                                        const gfx::FontList& font_list,
+                                        float available_pixel_width);
+
+// Functions to elide strings when the font information is unknown. As opposed
+// to the above functions, ElideString() and ElideRectangleString() operate in
+// terms of character units, not pixels.
+
+// If the size of |input| is more than |max_len|, this function returns
+// true and |input| is shortened into |output| by removing chars in the
+// middle (they are replaced with up to 3 dots, as size permits).
+// Ex: ElideString(u"Hello", 10, &str) puts Hello in str and
+// returns false.  ElideString(u"Hello my name is Tom", 10, &str)
+// puts "Hell...Tom" in str and returns true.
+// TODO(tsepez): Doesn't handle UTF-16 surrogate pairs properly.
+// TODO(tsepez): Doesn't handle bidi properly.
+GFX_EXPORT bool ElideString(const std::u16string& input,
+                            size_t max_len,
+                            std::u16string* output);
+
+// Reformat |input| into |output| so that it fits into a |max_rows| by
+// |max_cols| rectangle of characters.  Input newlines are respected, but
+// lines that are too long are broken into pieces.  If |strict| is true,
+// we break first at naturally occurring whitespace boundaries, otherwise
+// we assume some other mechanism will do this in approximately the same
+// spot after the fact.  If the word itself is too long, we always break
+// intra-word (respecting UTF-16 surrogate pairs) as necessary. Truncation
+// (indicated by an added 3 dots) occurs if the result is still too long.
+//  Returns true if the input had to be truncated (and not just reformatted).
+GFX_EXPORT bool ElideRectangleString(const std::u16string& input,
+                                     size_t max_rows,
+                                     size_t max_cols,
+                                     bool strict,
+                                     std::u16string* output);
+
+// Indicates whether the |available_pixel_width| by |available_pixel_height|
+// rectangle passed to |ElideRectangleText()| had insufficient space to
+// accommodate the given |text|, leading to elision or truncation.
+enum ReformattingResultFlags {
+  INSUFFICIENT_SPACE_HORIZONTAL = 1 << 0,
+  INSUFFICIENT_SPACE_VERTICAL = 1 << 1,
+  INSUFFICIENT_SPACE_FOR_FIRST_WORD = 1 << 2,
+};
+
+// Reformats |text| into output vector |lines| so that the resulting text fits
+// into an |available_pixel_width| by |available_pixel_height| rectangle with
+// the specified |font_list|. Input newlines are respected, but lines that are
+// too long are broken into pieces. For words that are too wide to fit on a
+// single line, the wrapping behavior can be specified with the |wrap_behavior|
+// param. Returns a combination of |ReformattingResultFlags| that indicate
+// whether the given rectangle had insufficient space to accommodate |text|,
+// leading to elision or truncation (and not just reformatting).
+GFX_EXPORT int ElideRectangleText(const std::u16string& text,
+                                  const gfx::FontList& font_list,
+                                  float available_pixel_width,
+                                  int available_pixel_height,
+                                  WordWrapBehavior wrap_behavior,
+                                  std::vector<std::u16string>* lines);
+
+// Truncates |string| to |length| characters. This breaks the string according
+// to the specified |break_type|, which must be either WORD_BREAK or
+// CHARACTER_BREAK, and adds the horizontal ellipsis character (unicode
+// character 0x2026) to render "...". The supplied string is returned if the
+// string has |length| characters or less.
+GFX_EXPORT std::u16string TruncateString(const std::u16string& string,
+                                         size_t length,
+                                         BreakType break_type);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_TEXT_ELIDER_H_
diff --git a/ui/gfx/text_elider_unittest.cc b/ui/gfx/text_elider_unittest.cc
new file mode 100644
index 0000000..579f73b
--- /dev/null
+++ b/ui/gfx/text_elider_unittest.cc
@@ -0,0 +1,1158 @@
+// Copyright (c) 2012 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.
+//
+// Unit tests for eliding and formatting utility functions.
+
+#include "ui/gfx/text_elider.h"
+
+#include <stddef.h>
+
+#include <memory>
+#include <vector>
+
+#include "base/cxx17_backports.h"
+#include "base/files/file_path.h"
+#include "base/i18n/rtl.h"
+#include "base/logging.h"
+#include "base/run_loop.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/test/task_environment.h"
+#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/font_render_params.h"
+#include "ui/gfx/text_utils.h"
+
+namespace gfx {
+
+namespace {
+
+struct FileTestcase {
+  const base::FilePath::StringType input;
+  const std::u16string output;
+  // If this value is specified, we will try to cut the path down to the render
+  // width of this string; if not specified, output will be used.
+  const std::u16string using_width_of = std::u16string();
+};
+
+struct Testcase {
+  const std::u16string input;
+  const std::u16string output;
+};
+
+}  // namespace
+
+TEST(TextEliderTest, ElideEmail) {
+  // Test emails and their expected elided forms (from which the available
+  // widths will be derived).
+  // For elided forms in which both the username and domain must be elided:
+  // the result (how many characters are left on each side) can be font
+  // dependent. To avoid this, the username is prefixed with the characters
+  // expected to remain in the domain.
+  Testcase testcases[] = {
+      {u"g@g.c", u"g@g.c"},
+      {u"g@g.c", u"…"},
+      {u"ga@co.ca", u"ga@c…a"},
+      {u"short@small.com", u"s…@s…"},
+      {u"short@small.com", u"s…@small.com"},
+      {u"short@longbutlotsofspace.com", u"short@longbutlotsofspace.com"},
+      {u"short@longbutnotverymuchspace.com", u"short@long….com"},
+      {u"la_short@longbutverytightspace.ca", u"la…@l…a"},
+      {u"longusername@gmail.com", u"long…@gmail.com"},
+      {u"elidetothemax@justfits.com", u"e…@justfits.com"},
+      {u"thatom_somelongemail@thatdoesntfit.com", u"thatom…@tha…om"},
+      {u"namefits@butthedomaindoesnt.com", u"namefits@butthedo…snt.com"},
+      {u"widthtootight@nospace.com", u"…"},
+      {u"nospaceforusername@l", u"…"},
+      {u"little@littlespace.com", u"l…@l…"},
+      {u"l@llllllllllllllllllllllll.com", u"l@lllll….com"},
+      {u"messed\"up@whyanat\"++@notgoogley.com",
+       u"messed\"up@whyanat\"++@notgoogley.com"},
+      {u"messed\"up@whyanat\"++@notgoogley.com",
+       u"messed\"up@why…@notgoogley.com"},
+      {u"noca_messed\"up@whyanat\"++@notgoogley.ca", u"noca…@no…ca"},
+      {u"at\"@@@@@@@@@...@@.@.@.@@@\"@madness.com",
+       u"at\"@@@@@@@@@...@@.@.…@madness.com"},
+      // Special case: "m..." takes more than half of the available width; thus
+      // the domain must elide to "l..." and not "l...l" as it must allow enough
+      // space for the minimal username elision although its half of the
+      // available width would normally allow it to elide to "l...l".
+      {u"mmmmm@llllllllll", u"m…@l…"},
+  };
+
+  const FontList font_list;
+  for (size_t i = 0; i < base::size(testcases); ++i) {
+    const std::u16string expected_output = testcases[i].output;
+    EXPECT_EQ(
+        expected_output,
+        ElideText(testcases[i].input, font_list,
+                  GetStringWidthF(expected_output, font_list), ELIDE_EMAIL));
+  }
+}
+
+TEST(TextEliderTest, ElideEmailMoreSpace) {
+  const int test_widths_extra_spaces[] = {
+      10,
+      1000,
+      100'000,
+  };
+  const char16_t* const test_emails[] = {
+      u"a@c",
+      u"test@email.com",
+      u"short@verysuperdupperlongdomain.com",
+      u"supermegalongusername@withasuperlonnnggggdomain.gouv.qc.ca",
+  };
+
+  const FontList font_list;
+  for (const auto* test_email : test_emails) {
+    const int mimimum_width = GetStringWidth(test_email, font_list);
+    for (int extra_space : test_widths_extra_spaces) {
+      // Extra space is available: the email should not be elided.
+      EXPECT_EQ(test_email,
+                ElideText(test_email, font_list, mimimum_width + extra_space,
+                          ELIDE_EMAIL));
+    }
+  }
+}
+
+TEST(TextEliderTest, TestFilenameEliding) {
+  const base::FilePath::StringType kPathSeparator =
+      base::FilePath::StringType().append(1, base::FilePath::kSeparators[0]);
+
+  FileTestcase testcases[] = {
+      {FILE_PATH_LITERAL(""), u""},
+      {FILE_PATH_LITERAL("."), u"."},
+      {FILE_PATH_LITERAL("filename.exe"), u"filename.exe"},
+      {FILE_PATH_LITERAL(".longext"), u".longext"},
+      {FILE_PATH_LITERAL("pie"), u"pie"},
+      {FILE_PATH_LITERAL("c:") + kPathSeparator + FILE_PATH_LITERAL("path") +
+           kPathSeparator + FILE_PATH_LITERAL("filename.pie"),
+       u"filename.pie"},
+      {FILE_PATH_LITERAL("c:") + kPathSeparator + FILE_PATH_LITERAL("path") +
+           kPathSeparator + FILE_PATH_LITERAL("longfilename.pie"),
+       u"long….pie"},
+      {FILE_PATH_LITERAL("http://path.com/filename.pie"), u"filename.pie"},
+      {FILE_PATH_LITERAL("http://path.com/longfilename.pie"), u"long….pie"},
+      {FILE_PATH_LITERAL("piesmashingtacularpants"), u"pie…"},
+      {FILE_PATH_LITERAL(".piesmashingtacularpants"), u".pie…"},
+      {FILE_PATH_LITERAL("cheese."), u"cheese."},
+      {FILE_PATH_LITERAL("file name.longext"), u"file….longext"},
+      {FILE_PATH_LITERAL("fil ename.longext"), u"fil….longext",
+       u"fil ….longext"},
+      {FILE_PATH_LITERAL("filename.longext"), u"file….longext"},
+      {FILE_PATH_LITERAL("filename.middleext.longext"),
+       u"filename.mid….longext"},
+      {FILE_PATH_LITERAL("filename.superduperextremelylongext"),
+       u"filename.sup…emelylongext"},
+      {FILE_PATH_LITERAL("filenamereallylongtext.superdeduperextremelylongext"),
+       u"filenamereall…emelylongext"},
+      {FILE_PATH_LITERAL(
+           "file.name.really.long.text.superduperextremelylongext"),
+       u"file.name.re…emelylongext"}};
+
+  static const FontList font_list;
+  for (size_t i = 0; i < base::size(testcases); ++i) {
+    base::FilePath filepath(testcases[i].input);
+    std::u16string expected = testcases[i].output;
+    std::u16string using_width_of = testcases[i].using_width_of.empty()
+                                        ? testcases[i].output
+                                        : testcases[i].using_width_of;
+    expected = base::i18n::GetDisplayStringInLTRDirectionality(expected);
+    EXPECT_EQ(expected,
+              ElideFilename(filepath, font_list,
+                            GetStringWidthF(using_width_of, font_list)));
+  }
+}
+
+TEST(TextEliderTest, ElideTextTruncate) {
+  const FontList font_list;
+  const float kTestWidth = GetStringWidthF(u"Test", font_list);
+  struct TestData {
+    const char16_t* input;
+    float width;
+    const char16_t* output;
+  } cases[] = {
+      {u"", 0, u""},
+      {u"Test", 0, u""},
+      {u"", kTestWidth, u""},
+      {u"Tes", kTestWidth, u"Tes"},
+      {u"Test", kTestWidth, u"Test"},
+      {u"Tests", kTestWidth, u"Test"},
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::u16string result =
+        ElideText(cases[i].input, font_list, cases[i].width, TRUNCATE);
+    EXPECT_EQ(cases[i].output, result);
+  }
+}
+
+TEST(TextEliderTest, ElideTextEllipsis) {
+  const FontList font_list;
+  const float kTestWidth = GetStringWidthF(u"Test", font_list);
+  const float kEllipsisWidth = GetStringWidthF(u"…", font_list);
+  struct TestData {
+    const char16_t* input;
+    float width;
+    const char16_t* output;
+  } cases[] = {
+      {u"", 0, u""},
+      {u"Test", 0, u""},
+      {u"Test", kEllipsisWidth, u"…"},
+      {u"", kTestWidth, u""},
+      {u"Tes", kTestWidth, u"Tes"},
+      {u"Test", kTestWidth, u"Test"},
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::u16string result =
+        ElideText(cases[i].input, font_list, cases[i].width, ELIDE_TAIL);
+    EXPECT_EQ(cases[i].output, result);
+  }
+}
+
+TEST(TextEliderTest, ElideTextEllipsisFront) {
+  const FontList font_list;
+  const float kTestWidth = GetStringWidthF(u"Test", font_list);
+  const float kEllipsisWidth = GetStringWidthF(u"…", font_list);
+  const float kEllipsis23Width = GetStringWidthF(u"…23", font_list);
+  struct TestData {
+    const char16_t* input;
+    float width;
+    const std::u16string output;
+  } cases[] = {
+      {u"", 0, std::u16string()},
+      {u"Test", 0, std::u16string()},
+      {u"Test", kEllipsisWidth, u"…"},
+      {u"", kTestWidth, std::u16string()},
+      {u"Tes", kTestWidth, u"Tes"},
+      {u"Test", kTestWidth, u"Test"},
+      {u"Test123", kEllipsis23Width, u"…23"},
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::u16string result =
+        ElideText(cases[i].input, font_list, cases[i].width, ELIDE_HEAD);
+    EXPECT_EQ(cases[i].output, result);
+  }
+}
+
+// Checks that all occurrences of |first_char| are followed by |second_char| and
+// all occurrences of |second_char| are preceded by |first_char| in |text|. Can
+// be used to test surrogate pairs or two-character combining sequences.
+static void CheckCodeUnitPairs(const std::u16string& text,
+                               char16_t first_char,
+                               char16_t second_char) {
+  for (size_t index = 0; index < text.length(); ++index) {
+    EXPECT_NE(second_char, text[index]);
+    if (text[index] == first_char) {
+      ASSERT_LT(++index, text.length());
+      EXPECT_EQ(second_char, text[index]);
+    }
+  }
+}
+
+// Test that both both UTF-16 surrogate pairs and combining character sequences
+// do not get split by ElideText.
+TEST(TextEliderTest, ElideTextAtomicSequences) {
+#if defined(OS_WIN)
+  // Needed to bypass DCHECK in GetFallbackFont.
+  base::test::SingleThreadTaskEnvironment task_environment(
+      base::test::SingleThreadTaskEnvironment::MainThreadType::UI);
+#endif
+  const FontList font_list;
+  std::vector<std::u16string> pairs;
+  // The below is 'MUSICAL SYMBOL G CLEF' (U+1D11E), which is represented in
+  // UTF-16 as two code units forming a surrogate pair: 0xD834 0xDD1E.
+  pairs.push_back(u"\U0001d11e");
+  // The below is a Devanagari two-character combining sequence U+0921 U+093F.
+  // The sequence forms a single display character and should not be separated.
+  pairs.push_back(u"\u0921\u093f");
+
+  for (const std::u16string& pair : pairs) {
+    char16_t first_char = pair[0];
+    char16_t second_char = pair[1];
+    std::u16string test_string = pair + u"x" + pair;
+    SCOPED_TRACE(test_string);
+    const float test_string_width = GetStringWidthF(test_string, font_list);
+    std::u16string result;
+
+    // Elide |text_string| to all possible widths and check that no instance of
+    // |pair| was split in two.
+    for (float width = 0; width <= test_string_width; width++) {
+      result = ElideText(test_string, font_list, width, TRUNCATE);
+      CheckCodeUnitPairs(result, first_char, second_char);
+
+      result = ElideText(test_string, font_list, width, ELIDE_TAIL);
+      CheckCodeUnitPairs(result, first_char, second_char);
+
+      result = ElideText(test_string, font_list, width, ELIDE_MIDDLE);
+      CheckCodeUnitPairs(result, first_char, second_char);
+
+      result = ElideText(test_string, font_list, width, ELIDE_HEAD);
+      CheckCodeUnitPairs(result, first_char, second_char);
+    }
+  }
+}
+
+TEST(TextEliderTest, ElideTextLongStrings) {
+  std::u16string data_scheme(u"data:text/plain,");
+  size_t data_scheme_length = data_scheme.length();
+
+  std::u16string ten_a(10, 'a');
+  std::u16string hundred_a(100, 'a');
+  std::u16string thousand_a(1000, 'a');
+  std::u16string ten_thousand_a(10'000, 'a');
+  std::u16string hundred_thousand_a(100'000, 'a');
+  std::u16string million_a(1'000'000, 'a');
+
+  // TODO(gbillock): Improve these tests by adding more string diversity and
+  // doing string compares instead of length compares. See bug 338836.
+
+  size_t number_of_as = 156;
+  std::u16string long_string_end(data_scheme +
+                                 std::u16string(number_of_as, 'a') + u"…");
+  Testcase testcases_end[] = {
+      {data_scheme + ten_a, data_scheme + ten_a},
+      {data_scheme + hundred_a, data_scheme + hundred_a},
+      {data_scheme + thousand_a, long_string_end},
+      {data_scheme + ten_thousand_a, long_string_end},
+      {data_scheme + hundred_thousand_a, long_string_end},
+      {data_scheme + million_a, long_string_end},
+  };
+
+  const FontList font_list;
+  float ellipsis_width = GetStringWidthF(u"…", font_list);
+  for (size_t i = 0; i < base::size(testcases_end); ++i) {
+    // Compare sizes rather than actual contents because if the test fails,
+    // output is rather long.
+    EXPECT_EQ(testcases_end[i].output.size(),
+              ElideText(testcases_end[i].input, font_list,
+                        GetStringWidthF(testcases_end[i].output, font_list),
+                        ELIDE_TAIL).size());
+    EXPECT_EQ(u"…", ElideText(testcases_end[i].input, font_list, ellipsis_width,
+                              ELIDE_TAIL));
+  }
+
+  size_t number_of_trailing_as = (data_scheme_length + number_of_as) / 2;
+  std::u16string long_string_middle(
+      data_scheme + std::u16string(number_of_as - number_of_trailing_as, 'a') +
+      u"…" + std::u16string(number_of_trailing_as, 'a'));
+#if !defined(OS_IOS)
+  long_string_middle += u"…";
+#endif
+
+  Testcase testcases_middle[] = {
+      {data_scheme + ten_a, data_scheme + ten_a},
+      {data_scheme + hundred_a, data_scheme + hundred_a},
+      {data_scheme + thousand_a, long_string_middle},
+      {data_scheme + ten_thousand_a, long_string_middle},
+      {data_scheme + hundred_thousand_a, long_string_middle},
+      {data_scheme + million_a, long_string_middle},
+  };
+
+  for (size_t i = 0; i < base::size(testcases_middle); ++i) {
+    // Compare sizes rather than actual contents because if the test fails,
+    // output is rather long.
+    EXPECT_EQ(testcases_middle[i].output.size(),
+              ElideText(testcases_middle[i].input, font_list,
+                        GetStringWidthF(testcases_middle[i].output, font_list),
+                        ELIDE_MIDDLE)
+                  .size());
+    EXPECT_EQ(u"…", ElideText(testcases_middle[i].input, font_list,
+                              ellipsis_width, ELIDE_MIDDLE));
+  }
+
+  std::u16string long_string_beginning(u"…" +
+                                       std::u16string(number_of_as, 'a'));
+#if !defined(OS_IOS)
+  long_string_beginning += u"…";
+#endif
+
+  Testcase testcases_beginning[] = {
+      {data_scheme + ten_a, data_scheme + ten_a},
+      {data_scheme + hundred_a, data_scheme + hundred_a},
+      {data_scheme + thousand_a, long_string_beginning},
+      {data_scheme + ten_thousand_a, long_string_beginning},
+      {data_scheme + hundred_thousand_a, long_string_beginning},
+      {data_scheme + million_a, long_string_beginning},
+  };
+  for (size_t i = 0; i < base::size(testcases_beginning); ++i) {
+    EXPECT_EQ(testcases_beginning[i].output.size(),
+              ElideText(
+                  testcases_beginning[i].input, font_list,
+                  GetStringWidthF(testcases_beginning[i].output, font_list),
+                  ELIDE_HEAD).size());
+    EXPECT_EQ(u"…", ElideText(testcases_beginning[i].input, font_list,
+                              ellipsis_width, ELIDE_HEAD));
+  }
+}
+
+// Detailed tests for StringSlicer. These are faster and test more of the edge
+// cases than the above tests which are more end-to-end.
+
+TEST(TextEliderTest, StringSlicerBasicTest) {
+  // Must store strings in variables (StringSlicer retains a reference to them).
+  std::u16string text(u"Hello, world!");
+  std::u16string ellipsis(u"…");
+  StringSlicer slicer(text, ellipsis, false, false);
+
+  EXPECT_EQ(u"", slicer.CutString(0, false));
+  EXPECT_EQ(u"…", slicer.CutString(0, true));
+
+  EXPECT_EQ(u"Hell", slicer.CutString(4, false));
+  EXPECT_EQ(u"Hell…", slicer.CutString(4, true));
+
+  EXPECT_EQ(text, slicer.CutString(text.length(), false));
+  EXPECT_EQ(text + u"…", slicer.CutString(text.length(), true));
+
+  StringSlicer slicer_begin(text, ellipsis, false, true);
+  EXPECT_EQ(u"rld!", slicer_begin.CutString(4, false));
+  EXPECT_EQ(u"…rld!", slicer_begin.CutString(4, true));
+
+  StringSlicer slicer_mid(text, ellipsis, true, false);
+  EXPECT_EQ(u"Held!", slicer_mid.CutString(5, false));
+  EXPECT_EQ(u"Hel…d!", slicer_mid.CutString(5, true));
+}
+
+TEST(TextEliderTest, StringSlicerWhitespace_UseDefault) {
+  // Must store strings in variables (StringSlicer retains a reference to them).
+  std::u16string text(u"Hello, world!");
+  std::u16string ellipsis(u"…");
+
+  // Eliding the end of a string should result in whitespace being removed
+  // before the ellipsis by default.
+  StringSlicer slicer_end(text, ellipsis, false, false);
+  EXPECT_EQ(u"Hello,…", slicer_end.CutString(6, true));
+  EXPECT_EQ(u"Hello,…", slicer_end.CutString(7, true));
+  EXPECT_EQ(u"Hello, w…", slicer_end.CutString(8, true));
+
+  // Eliding the start of a string should result in whitespace being removed
+  // after the ellipsis by default.
+  StringSlicer slicer_begin(text, ellipsis, false, true);
+  EXPECT_EQ(u"…world!", slicer_begin.CutString(6, true));
+  EXPECT_EQ(u"…world!", slicer_begin.CutString(7, true));
+  EXPECT_EQ(u"…, world!", slicer_begin.CutString(8, true));
+
+  // Eliding the middle of a string should *NOT* result in whitespace being
+  // removed around the ellipsis by default.
+  StringSlicer slicer_mid(text, ellipsis, true, false);
+  text = u"Hey world!";
+  EXPECT_EQ(u"Hey…ld!", slicer_mid.CutString(6, true));
+  EXPECT_EQ(u"Hey …ld!", slicer_mid.CutString(7, true));
+  EXPECT_EQ(u"Hey …rld!", slicer_mid.CutString(8, true));
+}
+
+TEST(TextEliderTest, StringSlicerWhitespace_NoTrim) {
+  // Must store strings in variables (StringSlicer retains a reference to them).
+  std::u16string text(u"Hello, world!");
+  std::u16string ellipsis(u"…");
+
+  // Eliding the end of a string should not result in whitespace being removed
+  // before the ellipsis in no-trim mode.
+  StringSlicer slicer_end(text, ellipsis, false, false, false);
+  EXPECT_EQ(u"Hello,…", slicer_end.CutString(6, true));
+  EXPECT_EQ(u"Hello, …", slicer_end.CutString(7, true));
+  EXPECT_EQ(u"Hello, w…", slicer_end.CutString(8, true));
+
+  // Eliding the start of a string should not result in whitespace being removed
+  // after the ellipsis in no-trim mode.
+  StringSlicer slicer_begin(text, ellipsis, false, true, false);
+  EXPECT_EQ(u"…world!", slicer_begin.CutString(6, true));
+  EXPECT_EQ(u"… world!", slicer_begin.CutString(7, true));
+  EXPECT_EQ(u"…, world!", slicer_begin.CutString(8, true));
+
+  // Eliding the middle of a string should *NOT* result in whitespace being
+  // removed around the ellipsis in no-trim mode.
+  StringSlicer slicer_mid(text, ellipsis, true, false, false);
+  text = u"Hey world!";
+  EXPECT_EQ(u"Hey…ld!", slicer_mid.CutString(6, true));
+  EXPECT_EQ(u"Hey …ld!", slicer_mid.CutString(7, true));
+  EXPECT_EQ(u"Hey …rld!", slicer_mid.CutString(8, true));
+}
+
+TEST(TextEliderTest, StringSlicerWhitespace_Trim) {
+  // Must store strings in variables (StringSlicer retains a reference to them).
+  std::u16string text(u"Hello, world!");
+  std::u16string ellipsis(u"…");
+
+  // Eliding the end of a string should result in whitespace being removed
+  // before the ellipsis in trim mode.
+  StringSlicer slicer_end(text, ellipsis, false, false, true);
+  EXPECT_EQ(u"Hello,…", slicer_end.CutString(6, true));
+  EXPECT_EQ(u"Hello,…", slicer_end.CutString(7, true));
+  EXPECT_EQ(u"Hello, w…", slicer_end.CutString(8, true));
+
+  // Eliding the start of a string should result in whitespace being removed
+  // after the ellipsis in trim mode.
+  StringSlicer slicer_begin(text, ellipsis, false, true, true);
+  EXPECT_EQ(u"…world!", slicer_begin.CutString(6, true));
+  EXPECT_EQ(u"…world!", slicer_begin.CutString(7, true));
+  EXPECT_EQ(u"…, world!", slicer_begin.CutString(8, true));
+
+  // Eliding the middle of a string *should* result in whitespace being removed
+  // around the ellipsis in trim mode.
+  StringSlicer slicer_mid(text, ellipsis, true, false, true);
+  text = u"Hey world!";
+  EXPECT_EQ(u"Hey…ld!", slicer_mid.CutString(6, true));
+  EXPECT_EQ(u"Hey…ld!", slicer_mid.CutString(7, true));
+  EXPECT_EQ(u"Hey…rld!", slicer_mid.CutString(8, true));
+}
+
+TEST(TextEliderTest, StringSlicer_ElideMiddle_MultipleWhitespace) {
+  // Must store strings in variables (StringSlicer retains a reference to them).
+  std::u16string text(u"Hello  world!");
+  std::u16string ellipsis(u"…");
+
+  // Eliding the middle of a string should not result in whitespace being
+  // removed around the ellipsis in default whitespace mode.
+  StringSlicer slicer_default(text, ellipsis, true, false);
+  text = u"Hey  U  man";
+  EXPECT_EQ(u"Hey…man", slicer_default.CutString(6, true));
+  EXPECT_EQ(u"Hey …man", slicer_default.CutString(7, true));
+  EXPECT_EQ(u"Hey … man", slicer_default.CutString(8, true));
+  EXPECT_EQ(u"Hey  … man", slicer_default.CutString(9, true));
+  EXPECT_EQ(u"Hey  …  man", slicer_default.CutString(10, true));
+
+  // Eliding the middle of a string should not result in whitespace being
+  // removed around the ellipsis in no-trim mode.
+  StringSlicer slicer_notrim(text, ellipsis, true, false, false);
+  text = u"Hey  U  man";
+  EXPECT_EQ(u"Hey…man", slicer_notrim.CutString(6, true));
+  EXPECT_EQ(u"Hey …man", slicer_notrim.CutString(7, true));
+  EXPECT_EQ(u"Hey … man", slicer_notrim.CutString(8, true));
+  EXPECT_EQ(u"Hey  … man", slicer_notrim.CutString(9, true));
+  EXPECT_EQ(u"Hey  …  man", slicer_notrim.CutString(10, true));
+
+  // Eliding the middle of a string *should* result in whitespace being removed
+  // around the ellipsis in trim mode.
+  StringSlicer slicer_trim(text, ellipsis, true, false, true);
+  text = u"Hey  U  man";
+  EXPECT_EQ(u"Hey…man", slicer_trim.CutString(6, true));
+  EXPECT_EQ(u"Hey…man", slicer_trim.CutString(7, true));
+  EXPECT_EQ(u"Hey…man", slicer_trim.CutString(8, true));
+  EXPECT_EQ(u"Hey…man", slicer_trim.CutString(9, true));
+  EXPECT_EQ(u"Hey…man", slicer_trim.CutString(10, true));
+}
+
+TEST(TextEliderTest, StringSlicerSurrogate) {
+  // The below is 'MUSICAL SYMBOL G CLEF' (U+1D11E), which is represented in
+  // UTF-16 as two code units forming a surrogate pair: 0xD834 0xDD1E.
+  const std::u16string kSurrogate = u"\U0001d11e";
+  ASSERT_EQ(2u, kSurrogate.size());
+  ASSERT_EQ(u'\xD834', kSurrogate[0]);
+  ASSERT_EQ(u'\xDD1E', kSurrogate[1]);
+
+  std::u16string text(u"abc" + kSurrogate + u"xyz");
+  std::u16string ellipsis(u"…");
+  StringSlicer slicer(text, ellipsis, false, false);
+
+  // Cut surrogate on the right. Should round left and exclude the surrogate.
+  EXPECT_EQ(u"…", slicer.CutString(0, true));
+  EXPECT_EQ(u"abc…", slicer.CutString(4, true));
+  EXPECT_EQ(text + u"…", slicer.CutString(text.length(), true));
+
+  // Cut surrogate on the left. Should round right and exclude the surrogate.
+  StringSlicer slicer_begin(text, ellipsis, false, true);
+  EXPECT_EQ(u"…xyz", slicer_begin.CutString(4, true));
+
+  // Cut surrogate in the middle. Should round right and exclude the surrogate.
+  std::u16string short_text(u"abc" + kSurrogate);
+  StringSlicer slicer_mid(short_text, ellipsis, true, false);
+  EXPECT_EQ(u"a…", slicer_mid.CutString(2, true));
+
+  // String that starts with a dangling trailing surrogate.
+  std::u16string dangling_trailing_text = kSurrogate.substr(1);
+  StringSlicer slicer_dangling_trailing(dangling_trailing_text, ellipsis, false,
+                                        false);
+  EXPECT_EQ(u"…", slicer_dangling_trailing.CutString(0, true));
+  EXPECT_EQ(dangling_trailing_text + u"…",
+            slicer_dangling_trailing.CutString(1, true));
+}
+
+TEST(TextEliderTest, StringSlicerCombining) {
+  // The following string contains three combining character sequences (one for
+  // each category of combining mark):
+  // LATIN SMALL LETTER E + COMBINING ACUTE ACCENT + COMBINING CEDILLA
+  // LATIN SMALL LETTER X + COMBINING ENCLOSING KEYCAP
+  // DEVANAGARI LETTER DDA + DEVANAGARI VOWEL SIGN I
+  std::u16string text(u"e\u0301\u0327 x\u20e3 \u0921\u093f");
+  std::u16string ellipsis(u"…");
+  StringSlicer slicer(text, ellipsis, false, false);
+
+  // Attempt to cut the string for all lengths. When a combining sequence is
+  // cut, it should always round left and exclude the combining sequence.
+  // Whitespace is also cut adjacent to the ellipsis.
+
+  // First sequence:
+  EXPECT_EQ(u"…", slicer.CutString(0, true));
+  EXPECT_EQ(u"…", slicer.CutString(1, true));
+  EXPECT_EQ(u"…", slicer.CutString(2, true));
+  EXPECT_EQ(text.substr(0, 3) + u"…", slicer.CutString(3, true));
+  // Second sequence:
+  EXPECT_EQ(text.substr(0, 3) + u"…", slicer.CutString(4, true));
+  EXPECT_EQ(text.substr(0, 3) + u"…", slicer.CutString(5, true));
+  EXPECT_EQ(text.substr(0, 6) + u"…", slicer.CutString(6, true));
+  // Third sequence:
+  EXPECT_EQ(text.substr(0, 6) + u"…", slicer.CutString(7, true));
+  EXPECT_EQ(text.substr(0, 6) + u"…", slicer.CutString(8, true));
+  EXPECT_EQ(text + u"…", slicer.CutString(9, true));
+
+  // Cut string in the middle, splitting the second sequence in half. Should
+  // round both left and right, excluding the second sequence.
+  StringSlicer slicer_mid(text, ellipsis, true, false);
+  EXPECT_EQ(text.substr(0, 4) + u"…" + text.substr(6),
+            slicer_mid.CutString(9, true));
+
+  // String that starts with a dangling combining mark.
+  char16_t dangling_mark_chars[] = {text[1], 0};
+  std::u16string dangling_mark_text(dangling_mark_chars);
+  StringSlicer slicer_dangling_mark(dangling_mark_text, ellipsis, false, false);
+  EXPECT_EQ(u"…", slicer_dangling_mark.CutString(0, true));
+  EXPECT_EQ(dangling_mark_text + u"…", slicer_dangling_mark.CutString(1, true));
+}
+
+TEST(TextEliderTest, StringSlicerCombiningSurrogate) {
+  // The ultimate test: combining sequences comprised of surrogate pairs.
+  // The following string contains a single combining character sequence:
+  // MUSICAL SYMBOL G CLEF (U+1D11E) + MUSICAL SYMBOL COMBINING FLAG-1 (U+1D16E)
+  // Represented as four UTF-16 code units.
+  std::u16string text(u"\U0001d11e\U0001d16e");
+  std::u16string ellipsis(u"…");
+  StringSlicer slicer(text, ellipsis, false, false);
+
+  // Attempt to cut the string for all lengths. Should always round left and
+  // exclude the combining sequence.
+  EXPECT_EQ(u"…", slicer.CutString(0, true));
+  EXPECT_EQ(u"…", slicer.CutString(1, true));
+  EXPECT_EQ(u"…", slicer.CutString(2, true));
+  EXPECT_EQ(u"…", slicer.CutString(3, true));
+  EXPECT_EQ(text + u"…", slicer.CutString(4, true));
+
+  // Cut string in the middle. Should exclude the sequence.
+  StringSlicer slicer_mid(text, ellipsis, true, false);
+  EXPECT_EQ(u"…", slicer_mid.CutString(4, true));
+}
+
+TEST(TextEliderTest, ElideString) {
+  struct TestData {
+    const char16_t* input;
+    size_t max_len;
+    bool result;
+    const char16_t* output;
+  } cases[] = {
+      {u"Hello", 0, true, u""},
+      {u"", 0, false, u""},
+      {u"Hello, my name is Tom", 1, true, u"H"},
+      {u"Hello, my name is Tom", 2, true, u"He"},
+      {u"Hello, my name is Tom", 3, true, u"H.m"},
+      {u"Hello, my name is Tom", 4, true, u"H..m"},
+      {u"Hello, my name is Tom", 5, true, u"H...m"},
+      {u"Hello, my name is Tom", 6, true, u"He...m"},
+      {u"Hello, my name is Tom", 7, true, u"He...om"},
+      {u"Hello, my name is Tom", 10, true, u"Hell...Tom"},
+      {u"Hello, my name is Tom", 100, false, u"Hello, my name is Tom"}};
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::u16string output;
+    EXPECT_EQ(cases[i].result,
+              ElideString(cases[i].input, cases[i].max_len, &output));
+    EXPECT_EQ(cases[i].output, output);
+  }
+}
+
+TEST(TextEliderTest, ElideRectangleText) {
+  const FontList font_list;
+  const int line_height = font_list.GetHeight();
+  const float test_width = GetStringWidthF(u"Test", font_list);
+
+  struct TestData {
+    const char16_t* input;
+    float available_pixel_width;
+    int available_pixel_height;
+    bool truncated_y;
+    const char16_t* output;
+  } cases[] = {
+      {u"", 0, 0, false, nullptr},
+      {u"", 1, 1, false, nullptr},
+      {u"Test", test_width, 0, true, nullptr},
+      {u"Test", test_width, 1, false, u"Test"},
+      {u"Test", test_width, line_height, false, u"Test"},
+      {u"Test Test", test_width, line_height, true, u"Test"},
+      {u"Test Test", test_width, line_height + 1, false, u"Test|Test"},
+      {u"Test Test", test_width, line_height * 2, false, u"Test|Test"},
+      {u"Test Test", test_width, line_height * 3, false, u"Test|Test"},
+      {u"Test Test", test_width * 2, line_height * 2, false, u"Test|Test"},
+      {u"Test Test", test_width * 3, line_height, false, u"Test Test"},
+      {u"Test\nTest", test_width * 3, line_height * 2, false, u"Test|Test"},
+      {u"Te\nst Te", test_width, line_height * 3, false, u"Te|st|Te"},
+      {u"\nTest", test_width, line_height * 2, false, u"|Test"},
+      {u"\nTest", test_width, line_height, true, u""},
+      {u"\n\nTest", test_width, line_height * 3, false, u"||Test"},
+      {u"\n\nTest", test_width, line_height * 2, true, u"|"},
+      {u"Test\n", 2 * test_width, line_height * 5, false, u"Test|"},
+      {u"Test\n\n", 2 * test_width, line_height * 5, false, u"Test||"},
+      {u"Test\n\n\n", 2 * test_width, line_height * 5, false, u"Test|||"},
+      {u"Test\nTest\n\n", 2 * test_width, line_height * 5, false,
+       u"Test|Test||"},
+      {u"Test\n\nTest\n", 2 * test_width, line_height * 5, false,
+       u"Test||Test|"},
+      {u"Test\n\n\nTest", 2 * test_width, line_height * 5, false,
+       u"Test|||Test"},
+      {u"Te ", test_width, line_height, false, u"Te"},
+      {u"Te  Te Test", test_width, 3 * line_height, false, u"Te|Te|Test"},
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::vector<std::u16string> lines;
+    EXPECT_EQ(cases[i].truncated_y ? INSUFFICIENT_SPACE_VERTICAL : 0,
+              ElideRectangleText(cases[i].input, font_list,
+                                 cases[i].available_pixel_width,
+                                 cases[i].available_pixel_height,
+                                 TRUNCATE_LONG_WORDS, &lines));
+    if (cases[i].output) {
+      const std::u16string result = base::JoinString(lines, u"|");
+      EXPECT_EQ(cases[i].output, result) << "Case " << i << " failed!";
+    } else {
+      EXPECT_TRUE(lines.empty()) << "Case " << i << " failed!";
+    }
+  }
+}
+
+TEST(TextEliderTest, ElideRectangleTextFirstWordTruncated) {
+  const FontList font_list;
+  const int line_height = font_list.GetHeight();
+
+  const float test_width = GetStringWidthF(u"Test", font_list);
+  const float tes_width = GetStringWidthF(u"Tes", font_list);
+
+  std::vector<std::u16string> lines;
+
+  auto result_for_width = [&](const char16_t* input, float width) {
+    lines.clear();
+    return ElideRectangleText(input, font_list, width, line_height * 4,
+                              WRAP_LONG_WORDS, &lines);
+  };
+
+  // Test base case.
+  EXPECT_EQ(0, result_for_width(u"Test", test_width));
+  EXPECT_EQ(1u, lines.size());
+  EXPECT_EQ(u"Test", lines[0]);
+
+  // First word truncated.
+  EXPECT_EQ(INSUFFICIENT_SPACE_FOR_FIRST_WORD,
+            result_for_width(u"Test", tes_width));
+  EXPECT_EQ(2u, lines.size());
+  EXPECT_EQ(u"Tes", lines[0]);
+  EXPECT_EQ(u"t", lines[1]);
+
+  // Two words truncated.
+  EXPECT_EQ(INSUFFICIENT_SPACE_FOR_FIRST_WORD,
+            result_for_width(u"Test\nTest", tes_width));
+  EXPECT_EQ(4u, lines.size());
+  EXPECT_EQ(u"Tes", lines[0]);
+  EXPECT_EQ(u"t", lines[1]);
+  EXPECT_EQ(u"Tes", lines[2]);
+  EXPECT_EQ(u"t", lines[3]);
+
+  // Word truncated, but not the first.
+  EXPECT_EQ(0, result_for_width(u"T Test", tes_width));
+  EXPECT_EQ(3u, lines.size());
+  EXPECT_EQ(u"T", lines[0]);
+  EXPECT_EQ(u"Tes", lines[1]);
+  EXPECT_EQ(u"t", lines[2]);
+
+  // Leading \n.
+  EXPECT_EQ(0, result_for_width(u"\nTest", tes_width));
+  EXPECT_EQ(3u, lines.size());
+  EXPECT_EQ(u"", lines[0]);
+  EXPECT_EQ(u"Tes", lines[1]);
+  EXPECT_EQ(u"t", lines[2]);
+}
+
+TEST(TextEliderTest, ElideRectangleTextPunctuation) {
+  const FontList font_list;
+  const int line_height = font_list.GetHeight();
+  const float test_width = GetStringWidthF(u"Test", font_list);
+  const float test_t_width = GetStringWidthF(u"Test T", font_list);
+  constexpr int kResultMask =
+      INSUFFICIENT_SPACE_HORIZONTAL | INSUFFICIENT_SPACE_VERTICAL;
+
+  struct TestData {
+    const char16_t* input;
+    float available_pixel_width;
+    int available_pixel_height;
+    bool wrap_words;
+    bool truncated_x;
+    const char16_t* output;
+  } cases[] = {
+      {u"Test T.", test_t_width, line_height * 2, false, false, u"Test|T."},
+      {u"Test T ?", test_t_width, line_height * 2, false, false, u"Test|T ?"},
+      {u"Test. Test", test_width, line_height * 3, false, true, u"Test|Test"},
+      {u"Test. Test", test_width, line_height * 3, true, false, u"Test|.|Test"},
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::vector<std::u16string> lines;
+    const WordWrapBehavior wrap_behavior =
+        (cases[i].wrap_words ? WRAP_LONG_WORDS : TRUNCATE_LONG_WORDS);
+    EXPECT_EQ(cases[i].truncated_x ? INSUFFICIENT_SPACE_HORIZONTAL : 0,
+              ElideRectangleText(
+                  cases[i].input, font_list, cases[i].available_pixel_width,
+                  cases[i].available_pixel_height, wrap_behavior, &lines) &
+                  kResultMask);
+    if (cases[i].output) {
+      const std::u16string result = base::JoinString(lines, u"|");
+      EXPECT_EQ(cases[i].output, result) << "Case " << i << " failed!";
+    } else {
+      EXPECT_TRUE(lines.empty()) << "Case " << i << " failed!";
+    }
+  }
+}
+
+TEST(TextEliderTest, ElideRectangleTextLongWords) {
+  const FontList font_list;
+  const int kAvailableHeight = 1000;
+  const std::u16string kElidedTesting = u"Tes…";
+  const float elided_width = GetStringWidthF(kElidedTesting, font_list);
+  const float test_width = GetStringWidthF(u"Test", font_list);
+  constexpr int kResultMask =
+      INSUFFICIENT_SPACE_HORIZONTAL | INSUFFICIENT_SPACE_VERTICAL;
+
+  struct TestData {
+    const char16_t* input;
+    float available_pixel_width;
+    WordWrapBehavior wrap_behavior;
+    bool truncated_x;
+    const char16_t* output;
+  } cases[] = {
+      {u"Testing", test_width, IGNORE_LONG_WORDS, false, u"Testing"},
+      {u"X Testing", test_width, IGNORE_LONG_WORDS, false, u"X|Testing"},
+      {u"Test Testing", test_width, IGNORE_LONG_WORDS, false, u"Test|Testing"},
+      {u"Test\nTesting", test_width, IGNORE_LONG_WORDS, false, u"Test|Testing"},
+      {u"Test Tests ", test_width, IGNORE_LONG_WORDS, false, u"Test|Tests"},
+      {u"Test Tests T", test_width, IGNORE_LONG_WORDS, false, u"Test|Tests|T"},
+
+      {u"Testing", elided_width, ELIDE_LONG_WORDS, true, u"Tes…"},
+      {u"X Testing", elided_width, ELIDE_LONG_WORDS, true, u"X|Tes…"},
+      {u"Test Testing", elided_width, ELIDE_LONG_WORDS, true, u"Test|Tes…"},
+      {u"Test\nTesting", elided_width, ELIDE_LONG_WORDS, true, u"Test|Tes…"},
+
+      {u"Testing", test_width, TRUNCATE_LONG_WORDS, true, u"Test"},
+      {u"X Testing", test_width, TRUNCATE_LONG_WORDS, true, u"X|Test"},
+      {u"Test Testing", test_width, TRUNCATE_LONG_WORDS, true, u"Test|Test"},
+      {u"Test\nTesting", test_width, TRUNCATE_LONG_WORDS, true, u"Test|Test"},
+      {u"Test Tests ", test_width, TRUNCATE_LONG_WORDS, true, u"Test|Test"},
+      {u"Test Tests T", test_width, TRUNCATE_LONG_WORDS, true, u"Test|Test|T"},
+
+      {u"Testing", test_width, WRAP_LONG_WORDS, false, u"Test|ing"},
+      {u"X Testing", test_width, WRAP_LONG_WORDS, false, u"X|Test|ing"},
+      {u"Test Testing", test_width, WRAP_LONG_WORDS, false, u"Test|Test|ing"},
+      {u"Test\nTesting", test_width, WRAP_LONG_WORDS, false, u"Test|Test|ing"},
+      {u"Test Tests ", test_width, WRAP_LONG_WORDS, false, u"Test|Test|s"},
+      {u"Test Tests T", test_width, WRAP_LONG_WORDS, false, u"Test|Test|s T"},
+      {u"TestTestTest", test_width, WRAP_LONG_WORDS, false, u"Test|Test|Test"},
+      {u"TestTestTestT", test_width, WRAP_LONG_WORDS, false,
+       u"Test|Test|Test|T"},
+  };
+
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    std::vector<std::u16string> lines;
+    EXPECT_EQ(cases[i].truncated_x ? INSUFFICIENT_SPACE_HORIZONTAL : 0,
+              ElideRectangleText(
+                  cases[i].input, font_list, cases[i].available_pixel_width,
+                  kAvailableHeight, cases[i].wrap_behavior, &lines) &
+                  kResultMask);
+    std::u16string expected_output(cases[i].output);
+    const std::u16string result = base::JoinString(lines, u"|");
+    EXPECT_EQ(expected_output, result) << "Case " << i << " failed!";
+  }
+}
+
+// This test is to make sure that the width of each wrapped line does not
+// exceed the available width. On some platform like Mac, this test used to
+// fail because the truncated integer width is returned for the string
+// and the accumulation of the truncated values causes the elide function
+// to wrap incorrectly.
+TEST(TextEliderTest, ElideRectangleTextCheckLineWidth) {
+  FontList font_list;
+#if defined(OS_MAC)
+  // Use a specific font to expose the line width exceeding problem.
+  font_list = FontList(Font("LucidaGrande", 12));
+#endif
+  const float kAvailableWidth = 235;
+  const int kAvailableHeight = 1000;
+  const char16_t text[] = u"that Russian place we used to go to after fencing";
+  std::vector<std::u16string> lines;
+  EXPECT_EQ(0, ElideRectangleText(text, font_list, kAvailableWidth,
+                                  kAvailableHeight, WRAP_LONG_WORDS, &lines));
+  ASSERT_EQ(2u, lines.size());
+  EXPECT_LE(GetStringWidthF(lines[0], font_list), kAvailableWidth);
+  EXPECT_LE(GetStringWidthF(lines[1], font_list), kAvailableWidth);
+}
+
+#if BUILDFLAG(IS_CHROMEOS_ASH)
+// This test was created specifically to test a message from crbug.com/415213.
+// It tests that width of concatenation of words equals sum of widths of the
+// words.
+TEST(TextEliderTest, ElideRectangleTextCheckConcatWidthEqualsSumOfWidths) {
+  FontList font_list;
+  font_list = FontList("Noto Sans UI,ui-sans, 12px");
+  SetFontRenderParamsDeviceScaleFactor(1.25f);
+#define WIDTH(x) GetStringWidthF((x), font_list)
+  EXPECT_EQ(WIDTH(u"The administrator for this account has"),
+            WIDTH(u"The ") + WIDTH(u"administrator ") + WIDTH(u"for ") +
+                WIDTH(u"this ") + WIDTH(u"account ") + WIDTH(u"has"));
+#undef WIDTH
+  SetFontRenderParamsDeviceScaleFactor(1.0f);
+}
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
+
+TEST(TextEliderTest, ElideRectangleString) {
+  struct TestData {
+    const char16_t* input;
+    int max_rows;
+    int max_cols;
+    bool result;
+    const char16_t* output;
+  } cases[] = {
+      {u"", 0, 0, false, u""},
+      {u"", 1, 1, false, u""},
+      {u"Hi, my name is\nTom", 0, 0, true, u"..."},
+      {u"Hi, my name is\nTom", 1, 0, true, u"\n..."},
+      {u"Hi, my name is\nTom", 0, 1, true, u"..."},
+      {u"Hi, my name is\nTom", 1, 1, true, u"H\n..."},
+      {u"Hi, my name is\nTom", 2, 1, true, u"H\ni\n..."},
+      {u"Hi, my name is\nTom", 3, 1, true, u"H\ni\n,\n..."},
+      {u"Hi, my name is\nTom", 4, 1, true, u"H\ni\n,\n \n..."},
+      {u"Hi, my name is\nTom", 5, 1, true, u"H\ni\n,\n \nm\n..."},
+      {u"Hi, my name is\nTom", 0, 2, true, u"..."},
+      {u"Hi, my name is\nTom", 1, 2, true, u"Hi\n..."},
+      {u"Hi, my name is\nTom", 2, 2, true, u"Hi\n, \n..."},
+      {u"Hi, my name is\nTom", 3, 2, true, u"Hi\n, \nmy\n..."},
+      {u"Hi, my name is\nTom", 4, 2, true, u"Hi\n, \nmy\n n\n..."},
+      {u"Hi, my name is\nTom", 5, 2, true, u"Hi\n, \nmy\n n\nam\n..."},
+      {u"Hi, my name is\nTom", 0, 3, true, u"..."},
+      {u"Hi, my name is\nTom", 1, 3, true, u"Hi,\n..."},
+      {u"Hi, my name is\nTom", 2, 3, true, u"Hi,\n my\n..."},
+      {u"Hi, my name is\nTom", 3, 3, true, u"Hi,\n my\n na\n..."},
+      {u"Hi, my name is\nTom", 4, 3, true, u"Hi,\n my\n na\nme \n..."},
+      {u"Hi, my name is\nTom", 5, 3, true, u"Hi,\n my\n na\nme \nis\n..."},
+      {u"Hi, my name is\nTom", 1, 4, true, u"Hi, \n..."},
+      {u"Hi, my name is\nTom", 2, 4, true, u"Hi, \nmy n\n..."},
+      {u"Hi, my name is\nTom", 3, 4, true, u"Hi, \nmy n\name \n..."},
+      {u"Hi, my name is\nTom", 4, 4, true, u"Hi, \nmy n\name \nis\n..."},
+      {u"Hi, my name is\nTom", 5, 4, false, u"Hi, \nmy n\name \nis\nTom"},
+      {u"Hi, my name is\nTom", 1, 5, true, u"Hi, \n..."},
+      {u"Hi, my name is\nTom", 2, 5, true, u"Hi, \nmy na\n..."},
+      {u"Hi, my name is\nTom", 3, 5, true, u"Hi, \nmy na\nme \n..."},
+      {u"Hi, my name is\nTom", 4, 5, true, u"Hi, \nmy na\nme \nis\n..."},
+      {u"Hi, my name is\nTom", 5, 5, false, u"Hi, \nmy na\nme \nis\nTom"},
+      {u"Hi, my name is\nTom", 1, 6, true, u"Hi, \n..."},
+      {u"Hi, my name is\nTom", 2, 6, true, u"Hi, \nmy \n..."},
+      {u"Hi, my name is\nTom", 3, 6, true, u"Hi, \nmy \nname \n..."},
+      {u"Hi, my name is\nTom", 4, 6, true, u"Hi, \nmy \nname \nis\n..."},
+      {u"Hi, my name is\nTom", 5, 6, false, u"Hi, \nmy \nname \nis\nTom"},
+      {u"Hi, my name is\nTom", 1, 7, true, u"Hi, \n..."},
+      {u"Hi, my name is\nTom", 2, 7, true, u"Hi, \nmy \n..."},
+      {u"Hi, my name is\nTom", 3, 7, true, u"Hi, \nmy \nname \n..."},
+      {u"Hi, my name is\nTom", 4, 7, true, u"Hi, \nmy \nname \nis\n..."},
+      {u"Hi, my name is\nTom", 5, 7, false, u"Hi, \nmy \nname \nis\nTom"},
+      {u"Hi, my name is\nTom", 1, 8, true, u"Hi, my \n..."},
+      {u"Hi, my name is\nTom", 2, 8, true, u"Hi, my \nname \n..."},
+      {u"Hi, my name is\nTom", 3, 8, true, u"Hi, my \nname \nis\n..."},
+      {u"Hi, my name is\nTom", 4, 8, false, u"Hi, my \nname \nis\nTom"},
+      {u"Hi, my name is\nTom", 1, 9, true, u"Hi, my \n..."},
+      {u"Hi, my name is\nTom", 2, 9, true, u"Hi, my \nname is\n..."},
+      {u"Hi, my name is\nTom", 3, 9, false, u"Hi, my \nname is\nTom"},
+      {u"Hi, my name is\nTom", 1, 10, true, u"Hi, my \n..."},
+      {u"Hi, my name is\nTom", 2, 10, true, u"Hi, my \nname is\n..."},
+      {u"Hi, my name is\nTom", 3, 10, false, u"Hi, my \nname is\nTom"},
+      {u"Hi, my name is\nTom", 1, 11, true, u"Hi, my \n..."},
+      {u"Hi, my name is\nTom", 2, 11, true, u"Hi, my \nname is\n..."},
+      {u"Hi, my name is\nTom", 3, 11, false, u"Hi, my \nname is\nTom"},
+      {u"Hi, my name is\nTom", 1, 12, true, u"Hi, my \n..."},
+      {u"Hi, my name is\nTom", 2, 12, true, u"Hi, my \nname is\n..."},
+      {u"Hi, my name is\nTom", 3, 12, false, u"Hi, my \nname is\nTom"},
+      {u"Hi, my name is\nTom", 1, 13, true, u"Hi, my name \n..."},
+      {u"Hi, my name is\nTom", 2, 13, true, u"Hi, my name \nis\n..."},
+      {u"Hi, my name is\nTom", 3, 13, false, u"Hi, my name \nis\nTom"},
+      {u"Hi, my name is\nTom", 1, 20, true, u"Hi, my name is\n..."},
+      {u"Hi, my name is\nTom", 2, 20, false, u"Hi, my name is\nTom"},
+      {u"Hi, my name is Tom", 1, 40, false, u"Hi, my name is Tom"},
+  };
+  std::u16string output;
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    EXPECT_EQ(cases[i].result,
+              ElideRectangleString(cases[i].input, cases[i].max_rows,
+                                   cases[i].max_cols, true, &output));
+    EXPECT_EQ(cases[i].output, output);
+  }
+}
+
+TEST(TextEliderTest, ElideRectangleStringNotStrict) {
+  struct TestData {
+    const char16_t* input;
+    int max_rows;
+    int max_cols;
+    bool result;
+    const char16_t* output;
+  } cases[] = {
+      {u"", 0, 0, false, u""},
+      {u"", 1, 1, false, u""},
+      {u"Hi, my name_is\nDick", 0, 0, true, u"..."},
+      {u"Hi, my name_is\nDick", 1, 0, true, u"\n..."},
+      {u"Hi, my name_is\nDick", 0, 1, true, u"..."},
+      {u"Hi, my name_is\nDick", 1, 1, true, u"H\n..."},
+      {u"Hi, my name_is\nDick", 2, 1, true, u"H\ni\n..."},
+      {u"Hi, my name_is\nDick", 3, 1, true, u"H\ni\n,\n..."},
+      {u"Hi, my name_is\nDick", 4, 1, true, u"H\ni\n,\n \n..."},
+      {u"Hi, my name_is\nDick", 5, 1, true, u"H\ni\n,\n \nm\n..."},
+      {u"Hi, my name_is\nDick", 0, 2, true, u"..."},
+      {u"Hi, my name_is\nDick", 1, 2, true, u"Hi\n..."},
+      {u"Hi, my name_is\nDick", 2, 2, true, u"Hi\n, \n..."},
+      {u"Hi, my name_is\nDick", 3, 2, true, u"Hi\n, \nmy\n..."},
+      {u"Hi, my name_is\nDick", 4, 2, true, u"Hi\n, \nmy\n n\n..."},
+      {u"Hi, my name_is\nDick", 5, 2, true, u"Hi\n, \nmy\n n\nam\n..."},
+      {u"Hi, my name_is\nDick", 0, 3, true, u"..."},
+      {u"Hi, my name_is\nDick", 1, 3, true, u"Hi,\n..."},
+      {u"Hi, my name_is\nDick", 2, 3, true, u"Hi,\n my\n..."},
+      {u"Hi, my name_is\nDick", 3, 3, true, u"Hi,\n my\n na\n..."},
+      {u"Hi, my name_is\nDick", 4, 3, true, u"Hi,\n my\n na\nme_\n..."},
+      {u"Hi, my name_is\nDick", 5, 3, true, u"Hi,\n my\n na\nme_\nis\n..."},
+      {u"Hi, my name_is\nDick", 1, 4, true, u"Hi, ..."},
+      {u"Hi, my name_is\nDick", 2, 4, true, u"Hi, my n\n..."},
+      {u"Hi, my name_is\nDick", 3, 4, true, u"Hi, my n\name_\n..."},
+      {u"Hi, my name_is\nDick", 4, 4, true, u"Hi, my n\name_\nis\n..."},
+      {u"Hi, my name_is\nDick", 5, 4, false, u"Hi, my n\name_\nis\nDick"},
+      {u"Hi, my name_is\nDick", 1, 5, true, u"Hi, ..."},
+      {u"Hi, my name_is\nDick", 2, 5, true, u"Hi, my na\n..."},
+      {u"Hi, my name_is\nDick", 3, 5, true, u"Hi, my na\nme_is\n..."},
+      {u"Hi, my name_is\nDick", 4, 5, true, u"Hi, my na\nme_is\n\n..."},
+      {u"Hi, my name_is\nDick", 5, 5, false, u"Hi, my na\nme_is\n\nDick"},
+      {u"Hi, my name_is\nDick", 1, 6, true, u"Hi, ..."},
+      {u"Hi, my name_is\nDick", 2, 6, true, u"Hi, my nam\n..."},
+      {u"Hi, my name_is\nDick", 3, 6, true, u"Hi, my nam\ne_is\n..."},
+      {u"Hi, my name_is\nDick", 4, 6, false, u"Hi, my nam\ne_is\nDick"},
+      {u"Hi, my name_is\nDick", 5, 6, false, u"Hi, my nam\ne_is\nDick"},
+      {u"Hi, my name_is\nDick", 1, 7, true, u"Hi, ..."},
+      {u"Hi, my name_is\nDick", 2, 7, true, u"Hi, my name\n..."},
+      {u"Hi, my name_is\nDick", 3, 7, true, u"Hi, my name\n_is\n..."},
+      {u"Hi, my name_is\nDick", 4, 7, false, u"Hi, my name\n_is\nDick"},
+      {u"Hi, my name_is\nDick", 5, 7, false, u"Hi, my name\n_is\nDick"},
+      {u"Hi, my name_is\nDick", 1, 8, true, u"Hi, my n\n..."},
+      {u"Hi, my name_is\nDick", 2, 8, true, u"Hi, my n\name_is\n..."},
+      {u"Hi, my name_is\nDick", 3, 8, false, u"Hi, my n\name_is\nDick"},
+      {u"Hi, my name_is\nDick", 1, 9, true, u"Hi, my ..."},
+      {u"Hi, my name_is\nDick", 2, 9, true, u"Hi, my name_is\n..."},
+      {u"Hi, my name_is\nDick", 3, 9, false, u"Hi, my name_is\nDick"},
+      {u"Hi, my name_is\nDick", 1, 10, true, u"Hi, my ..."},
+      {u"Hi, my name_is\nDick", 2, 10, true, u"Hi, my name_is\n..."},
+      {u"Hi, my name_is\nDick", 3, 10, false, u"Hi, my name_is\nDick"},
+      {u"Hi, my name_is\nDick", 1, 11, true, u"Hi, my ..."},
+      {u"Hi, my name_is\nDick", 2, 11, true, u"Hi, my name_is\n..."},
+      {u"Hi, my name_is\nDick", 3, 11, false, u"Hi, my name_is\nDick"},
+      {u"Hi, my name_is\nDick", 1, 12, true, u"Hi, my ..."},
+      {u"Hi, my name_is\nDick", 2, 12, true, u"Hi, my name_is\n..."},
+      {u"Hi, my name_is\nDick", 3, 12, false, u"Hi, my name_is\nDick"},
+      {u"Hi, my name_is\nDick", 1, 13, true, u"Hi, my ..."},
+      {u"Hi, my name_is\nDick", 2, 13, true, u"Hi, my name_is\n..."},
+      {u"Hi, my name_is\nDick", 3, 13, false, u"Hi, my name_is\nDick"},
+      {u"Hi, my name_is\nDick", 1, 20, true, u"Hi, my name_is\n..."},
+      {u"Hi, my name_is\nDick", 2, 20, false, u"Hi, my name_is\nDick"},
+      {u"Hi, my name_is Dick", 1, 40, false, u"Hi, my name_is Dick"},
+  };
+  std::u16string output;
+  for (size_t i = 0; i < base::size(cases); ++i) {
+    EXPECT_EQ(cases[i].result,
+              ElideRectangleString(cases[i].input, cases[i].max_rows,
+                                   cases[i].max_cols, false, &output));
+    EXPECT_EQ(cases[i].output, output);
+  }
+}
+
+TEST(TextEliderTest, ElideRectangleWide16) {
+  // Two greek words separated by space.
+  const std::u16string str(u"Παγκόσμιος Ιστός");
+  const std::u16string out1(u"Παγκ\nόσμι\n...");
+  const std::u16string out2(u"Παγκόσμιος \nΙστός");
+  std::u16string output;
+  EXPECT_TRUE(ElideRectangleString(str, 2, 4, true, &output));
+  EXPECT_EQ(out1, output);
+  EXPECT_FALSE(ElideRectangleString(str, 2, 12, true, &output));
+  EXPECT_EQ(out2, output);
+}
+
+TEST(TextEliderTest, ElideRectangleWide32) {
+  const std::u16string str(u"𝒜𝒜𝒜𝒜 aaaaa");
+  const std::u16string out(u"𝒜𝒜𝒜\n𝒜 \naaa\n...");
+  std::u16string output;
+  EXPECT_TRUE(ElideRectangleString(str, 3, 3, true, &output));
+  EXPECT_EQ(out, output);
+}
+
+TEST(TextEliderTest, TruncateString) {
+  std::u16string str = u"fooooey    bxxxar baz  ";
+
+  // Test breaking at character 0.
+  EXPECT_EQ(std::u16string(), TruncateString(str, 0, WORD_BREAK));
+  EXPECT_EQ(std::u16string(), TruncateString(str, 0, CHARACTER_BREAK));
+
+  // Test breaking at character 1.
+  EXPECT_EQ(u"…", TruncateString(str, 1, WORD_BREAK));
+  EXPECT_EQ(u"…", TruncateString(str, 1, CHARACTER_BREAK));
+
+  // Test breaking in the middle of the first word.
+  EXPECT_EQ(u"f…", TruncateString(str, 2, WORD_BREAK));
+  EXPECT_EQ(u"f…", TruncateString(str, 2, CHARACTER_BREAK));
+
+  // Test breaking in between words.
+  EXPECT_EQ(u"fooooey…", TruncateString(str, 9, WORD_BREAK));
+  EXPECT_EQ(u"fooooey…", TruncateString(str, 9, CHARACTER_BREAK));
+
+  // Test breaking at the start of a later word.
+  EXPECT_EQ(u"fooooey…", TruncateString(str, 11, WORD_BREAK));
+  EXPECT_EQ(u"fooooey…", TruncateString(str, 11, CHARACTER_BREAK));
+
+  // Test breaking in the middle of a word.
+  EXPECT_EQ(u"fooooey…", TruncateString(str, 12, WORD_BREAK));
+  EXPECT_EQ(u"fooooey…", TruncateString(str, 12, CHARACTER_BREAK));
+  EXPECT_EQ(u"fooooey…", TruncateString(str, 14, WORD_BREAK));
+  EXPECT_EQ(u"fooooey    bx…", TruncateString(str, 14, CHARACTER_BREAK));
+
+  // Test breaking in whitespace at the end of the string.
+  EXPECT_EQ(u"fooooey    bxxxar baz…", TruncateString(str, 22, WORD_BREAK));
+  EXPECT_EQ(u"fooooey    bxxxar baz…",
+            TruncateString(str, 22, CHARACTER_BREAK));
+
+  // Test breaking at the end of the string.
+  EXPECT_EQ(str, TruncateString(str, str.length(), WORD_BREAK));
+  EXPECT_EQ(str, TruncateString(str, str.length(), CHARACTER_BREAK));
+
+  // Test breaking past the end of the string.
+  EXPECT_EQ(str, TruncateString(str, str.length() + 10, WORD_BREAK));
+  EXPECT_EQ(str, TruncateString(str, str.length() + 10, CHARACTER_BREAK));
+
+
+  // Tests of strings with leading whitespace:
+  std::u16string str2 = u"   foo";
+
+  // Test breaking in leading whitespace.
+  EXPECT_EQ(u"…", TruncateString(str2, 2, WORD_BREAK));
+  EXPECT_EQ(u"…", TruncateString(str2, 2, CHARACTER_BREAK));
+
+  // Test breaking at the beginning of the first word, with leading whitespace.
+  EXPECT_EQ(u"…", TruncateString(str2, 3, WORD_BREAK));
+  EXPECT_EQ(u"…", TruncateString(str2, 3, CHARACTER_BREAK));
+
+  // Test breaking in the middle of the first word, with leading whitespace.
+  EXPECT_EQ(u"…", TruncateString(str2, 4, WORD_BREAK));
+  EXPECT_EQ(u"…", TruncateString(str2, 4, CHARACTER_BREAK));
+  EXPECT_EQ(u"   f…", TruncateString(str2, 5, WORD_BREAK));
+  EXPECT_EQ(u"   f…", TruncateString(str2, 5, CHARACTER_BREAK));
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/text_utils.cc b/ui/gfx/text_utils.cc
new file mode 100644
index 0000000..2e73a65
--- /dev/null
+++ b/ui/gfx/text_utils.cc
@@ -0,0 +1,212 @@
+// Copyright 2012 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.
+
+#include "ui/gfx/text_utils.h"
+
+#include <stdint.h>
+
+#include "base/i18n/char_iterator.h"
+#include "base/i18n/rtl.h"
+#include "base/numerics/safe_conversions.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "third_party/icu/source/common/unicode/utf16.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace gfx {
+
+using base::i18n::UTF16CharIterator;
+
+namespace {
+
+constexpr char16_t kAcceleratorChar = '&';
+constexpr char16_t kOpenParenthesisChar = '(';
+constexpr char16_t kCloseParenthesisChar = ')';
+
+// Returns true if the specified character must be elided from a string.
+// Examples are combining marks and whitespace.
+bool IsCombiningMark(UChar32 c) {
+  const int8_t char_type = u_charType(c);
+  return char_type == U_NON_SPACING_MARK || char_type == U_ENCLOSING_MARK ||
+         char_type == U_COMBINING_SPACING_MARK;
+}
+
+bool IsSpace(UChar32 c) {
+  // Ignore NUL character.
+  if (!c)
+    return false;
+  const int8_t char_type = u_charType(c);
+  return char_type == U_SPACE_SEPARATOR || char_type == U_LINE_SEPARATOR ||
+         char_type == U_PARAGRAPH_SEPARATOR || char_type == U_CONTROL_CHAR;
+}
+
+std::u16string RemoveAcceleratorChar(bool full_removal,
+                                     const std::u16string& s,
+                                     int* accelerated_char_pos,
+                                     int* accelerated_char_span) {
+  bool escaped = false;
+  ptrdiff_t last_char_pos = -1;
+  int last_char_span = 0;
+  UTF16CharIterator chars(s);
+  std::u16string accelerator_removed;
+
+  // The states of a state machine looking for a CJK-style accelerator (i.e.
+  // "(&x)"). |cjk_state| proceeds up from |kFoundNothing| through these states,
+  // resetting either when it sees a complete accelerator, or gives up because
+  // the current character doesn't match.
+  enum {
+    kFoundNothing,
+    kFoundOpenParen,
+    kFoundAcceleratorChar,
+    kFoundAccelerator
+  } cjk_state = kFoundNothing;
+  size_t pre_cjk_size = 0;
+
+  accelerator_removed.reserve(s.size());
+  while (!chars.end()) {
+    int32_t c = chars.get();
+    int array_pos = chars.array_pos();
+    chars.Advance();
+
+    if (full_removal) {
+      if (cjk_state == kFoundNothing && c == kOpenParenthesisChar) {
+        pre_cjk_size = array_pos;
+        cjk_state = kFoundOpenParen;
+      } else if (cjk_state == kFoundOpenParen && c == kAcceleratorChar) {
+        cjk_state = kFoundAcceleratorChar;
+      } else if (cjk_state == kFoundAcceleratorChar) {
+        // Accept any character as the accelerator.
+        cjk_state = kFoundAccelerator;
+      } else if (cjk_state == kFoundAccelerator && c == kCloseParenthesisChar) {
+        cjk_state = kFoundNothing;
+        accelerator_removed.resize(pre_cjk_size);
+        pre_cjk_size = 0;
+        escaped = false;
+        continue;
+      } else {
+        cjk_state = kFoundNothing;
+      }
+    }
+
+    if (c != kAcceleratorChar || escaped) {
+      int span = chars.array_pos() - array_pos;
+      if (escaped && c != kAcceleratorChar) {
+        last_char_pos = accelerator_removed.size();
+        last_char_span = span;
+      }
+      for (int i = 0; i < span; i++)
+        accelerator_removed.push_back(s[array_pos + i]);
+      escaped = false;
+    } else {
+      escaped = true;
+    }
+  }
+
+  if (accelerated_char_pos && !full_removal)
+    *accelerated_char_pos = last_char_pos;
+  if (accelerated_char_span && !full_removal)
+    *accelerated_char_span = last_char_span;
+
+  return accelerator_removed;
+}
+
+}  // namespace
+
+std::u16string LocateAndRemoveAcceleratorChar(const std::u16string& s,
+                                              int* accelerated_char_pos,
+                                              int* accelerated_char_span) {
+  return RemoveAcceleratorChar(false, s, accelerated_char_pos,
+                               accelerated_char_span);
+}
+
+std::u16string RemoveAccelerator(const std::u16string& s) {
+  return RemoveAcceleratorChar(true, s, nullptr, nullptr);
+}
+
+size_t FindValidBoundaryBefore(const std::u16string& text,
+                               size_t index,
+                               bool trim_whitespace) {
+  UTF16CharIterator it = UTF16CharIterator::LowerBound(text, index);
+
+  // First, move left until we're positioned on a code point that is not a
+  // combining mark.
+  while (!it.start() && IsCombiningMark(it.get()))
+    it.Rewind();
+
+  // Next, maybe trim whitespace to the left of the current position.
+  if (trim_whitespace) {
+    while (!it.start() && IsSpace(it.PreviousCodePoint()))
+      it.Rewind();
+  }
+
+  return it.array_pos();
+}
+
+size_t FindValidBoundaryAfter(const std::u16string& text,
+                              size_t index,
+                              bool trim_whitespace) {
+  UTF16CharIterator it = UTF16CharIterator::UpperBound(text, index);
+
+  // First, move right until we're positioned on a code point that is not a
+  // combining mark.
+  while (!it.end() && IsCombiningMark(it.get()))
+    it.Advance();
+
+  // Next, maybe trim space at the current position.
+  if (trim_whitespace) {
+    // A mark combining with a space is renderable, so we'll prevent
+    // trimming spaces with combining marks.
+    while (!it.end() && IsSpace(it.get()) &&
+           !IsCombiningMark(it.NextCodePoint())) {
+      it.Advance();
+    }
+  }
+
+  return it.array_pos();
+}
+
+HorizontalAlignment MaybeFlipForRTL(HorizontalAlignment alignment) {
+  if (base::i18n::IsRTL() &&
+      (alignment == gfx::ALIGN_LEFT || alignment == gfx::ALIGN_RIGHT)) {
+    alignment =
+        (alignment == gfx::ALIGN_LEFT) ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT;
+  }
+  return alignment;
+}
+
+Size GetStringSize(const std::u16string& text, const FontList& font_list) {
+  return Size(GetStringWidth(text, font_list), font_list.GetHeight());
+}
+
+Insets AdjustVisualBorderForFont(const FontList& font_list,
+                                 const Insets& desired_visual_padding) {
+  Insets result = desired_visual_padding;
+  const int baseline = font_list.GetBaseline();
+  const int leading_space = baseline - font_list.GetCapHeight();
+  const int descender = font_list.GetHeight() - baseline;
+  result.set_top(std::max(0, result.top() - leading_space));
+  result.set_bottom(std::max(0, result.bottom() - descender));
+  return result;
+}
+
+int GetFontCapHeightCenterOffset(const gfx::FontList& original_font,
+                                 const gfx::FontList& to_center) {
+  const int original_cap_height = original_font.GetCapHeight();
+  const int original_cap_leading =
+      original_font.GetBaseline() - original_cap_height;
+  const int to_center_cap_height = to_center.GetCapHeight();
+  const int to_center_leading = to_center.GetBaseline() - to_center_cap_height;
+
+  const int cap_height_diff = original_cap_height - to_center_cap_height;
+  const int new_cap_top =
+      original_cap_leading + std::lround(cap_height_diff / 2.0f);
+  const int new_top = new_cap_top - to_center_leading;
+
+  // Since we assume the old font starts at zero, the new top is the adjustment.
+  return new_top;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/text_utils.h b/ui/gfx/text_utils.h
new file mode 100644
index 0000000..b25a001
--- /dev/null
+++ b/ui/gfx/text_utils.h
@@ -0,0 +1,142 @@
+// Copyright 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_TEXT_UTILS_H_
+#define UI_GFX_TEXT_UTILS_H_
+
+#include <stddef.h>
+
+#include <string>
+
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/text_constants.h"
+
+namespace gfx {
+
+class FontList;
+class Insets;
+class Size;
+
+// Strips the accelerator char ('&') from a menu string. Useful for platforms
+// which use underlining to indicate accelerators.
+//
+// Single accelerator chars ('&') will be stripped from the string. Double
+// accelerator chars ('&&') will be converted to a single '&'. The out params
+// |accelerated_char_pos| and |accelerated_char_span| will be set to the index
+// and span of the last accelerated character, respectively, or -1 and 0 if
+// there was none.
+GFX_EXPORT std::u16string LocateAndRemoveAcceleratorChar(
+    const std::u16string& s,
+    int* accelerated_char_pos,
+    int* accelerated_char_span);
+
+// Strips all accelerator notation from a menu string. Useful for platforms
+// which use underlining to indicate accelerators, as well as situations where
+// accelerators are not indicated.
+//
+// Single accelerator chars ('&') will be stripped from the string. Double
+// accelerator chars ('&&') will be converted to a single '&'. CJK language
+// accelerators, specified as "(&x)", will be entirely removed too.
+GFX_EXPORT std::u16string RemoveAccelerator(const std::u16string& s);
+
+// Returns the number of horizontal pixels needed to display the specified
+// |text| with |font_list|. |typesetter| indicates where the text will be
+// displayed.
+GFX_EXPORT int GetStringWidth(const std::u16string& text,
+                              const FontList& font_list);
+
+// Returns the size required to render |text| in |font_list|. This includes all
+// leading space, descender area, etc. even if the text to render does not
+// contain characters with ascenders or descenders.
+GFX_EXPORT Size GetStringSize(const std::u16string& text,
+                              const FontList& font_list);
+
+// This is same as GetStringWidth except that fractional width is returned.
+GFX_EXPORT float GetStringWidthF(const std::u16string& text,
+                                 const FontList& font_list);
+
+// Returns a valid cut boundary at or before |index|. The surrogate pair and
+// combining characters should not be separated.
+GFX_EXPORT size_t FindValidBoundaryBefore(const std::u16string& text,
+                                          size_t index,
+                                          bool trim_whitespace = false);
+
+// Returns a valid cut boundary at or after |index|. The surrogate pair and
+// combining characters should not be separated.
+GFX_EXPORT size_t FindValidBoundaryAfter(const std::u16string& text,
+                                         size_t index,
+                                         bool trim_whitespace = false);
+
+// If the UI layout is right-to-left, flip the alignment direction.
+GFX_EXPORT HorizontalAlignment MaybeFlipForRTL(HorizontalAlignment alignment);
+
+// Returns insets that can be used to draw a highlight or border that appears to
+// be distance |desired_visual_padding| from the body of a string of text
+// rendered using |font_list|. The insets are adjusted based on the box used to
+// render capital letters (or the bodies of most letters in non-capital fonts
+// like Hebrew and Devanagari), in order to give the best visual appearance.
+//
+// That is, any portion of |desired_visual_padding| overlapping the font's
+// leading space or descender area are truncated, to a minimum of zero.
+//
+// In this example, the text is rendered in a highlight that stretches above and
+// below the height of the H as well as to the left and right of the text
+// (|desired_visual_padding| = {2, 2, 2, 2}). Note that the descender of the 'y'
+// overlaps with the padding, as it is outside the capital letter box.
+//
+// The resulting padding is {1, 2, 1, 2}.
+//
+//  . . . . . . . . . .                               | actual top
+//  .                 .  |              | leading space
+//  .  |  |  _        .  | font    | capital
+//  .  |--| /_\ \  /  .  | height  | height
+//  .  |  | \_   \/   .  |         |
+//  .            /    .  |              | descender
+//  . . . . . . . . . .                               | actual bottom
+//  ___             ___
+//  actual        actual
+//  left           right
+//
+GFX_EXPORT Insets
+AdjustVisualBorderForFont(const FontList& font_list,
+                          const Insets& desired_visual_padding);
+
+// Returns the y adjustment necessary to align the center of the "cap size" box
+// - the space between a capital letter's top and bottom - between two fonts.
+// For non-capital scripts (e.g. Hebrew, Devanagari) the box containing the body
+// of most letters is used.
+//
+// A positive return value means the font |to_center| needs to be moved down
+// relative to the font |original_font|, while a negative value means it needs
+// to be moved up.
+//
+// Illustration:
+//
+//  original_font    to_center
+//  ----------                    ] - return value (+1)
+//  leading          ----------
+//  ----------       leading
+//                   ----------
+//
+//  cap-height       cap-height
+//
+//                   ----------
+//  ----------       descent
+//  descent          ----------
+//  ----------
+//
+// Visual result:           Non-Latin example (Devanagari ऐ "ai"):
+//                               \
+//  |\   |                    ------     \
+//  | \  |   |\ |              |  |    ----
+//  |  \ |   | \|               \ /     \|
+//  |   \|                       \       /
+//                                /
+//
+GFX_EXPORT int GetFontCapHeightCenterOffset(const gfx::FontList& original_font,
+                                            const gfx::FontList& to_center);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_TEXT_UTILS_H_
diff --git a/ui/gfx/text_utils_ios.mm b/ui/gfx/text_utils_ios.mm
new file mode 100644
index 0000000..1f76316
--- /dev/null
+++ b/ui/gfx/text_utils_ios.mm
@@ -0,0 +1,27 @@
+// 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.
+
+#include "ui/gfx/text_utils.h"
+
+#import <UIKit/UIKit.h>
+
+#include <cmath>
+
+#include "base/strings/sys_string_conversions.h"
+#include "ui/gfx/font_list.h"
+
+namespace gfx {
+
+int GetStringWidth(const std::u16string& text, const FontList& font_list) {
+  return std::ceil(GetStringWidthF(text, font_list));
+}
+
+float GetStringWidthF(const std::u16string& text, const FontList& font_list) {
+  NSString* ns_text = base::SysUTF16ToNSString(text);
+  NativeFont native_font = font_list.GetPrimaryFont().GetNativeFont();
+  NSDictionary* attributes = @{NSFontAttributeName : native_font};
+  return [ns_text sizeWithAttributes:attributes].width;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/text_utils_skia.cc b/ui/gfx/text_utils_skia.cc
new file mode 100644
index 0000000..2c8e96c
--- /dev/null
+++ b/ui/gfx/text_utils_skia.cc
@@ -0,0 +1,19 @@
+// 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.
+
+#include "ui/gfx/text_utils.h"
+
+#include "ui/gfx/canvas.h"
+
+namespace gfx {
+
+int GetStringWidth(const std::u16string& text, const FontList& font_list) {
+  return Canvas::GetStringWidth(text, font_list);
+}
+
+float GetStringWidthF(const std::u16string& text, const FontList& font_list) {
+  return Canvas::GetStringWidthF(text, font_list);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/text_utils_unittest.cc b/ui/gfx/text_utils_unittest.cc
new file mode 100644
index 0000000..f1824dc
--- /dev/null
+++ b/ui/gfx/text_utils_unittest.cc
@@ -0,0 +1,358 @@
+// Copyright (c) 2011 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.
+
+#include "ui/gfx/text_utils.h"
+
+#include <stddef.h>
+
+#include <vector>
+
+#include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace gfx {
+namespace {
+
+TEST(TextUtilsTest, GetStringWidth) {
+  FontList font_list;
+  EXPECT_EQ(GetStringWidth(std::u16string(), font_list), 0);
+  EXPECT_GT(GetStringWidth(u"a", font_list),
+            GetStringWidth(std::u16string(), font_list));
+  EXPECT_GT(GetStringWidth(u"ab", font_list), GetStringWidth(u"a", font_list));
+  EXPECT_GT(GetStringWidth(u"abc", font_list),
+            GetStringWidth(u"ab", font_list));
+}
+
+TEST(TextUtilsTest, GetStringSize) {
+  std::vector<std::u16string> strings{
+      std::u16string(),
+      u"a",
+      u"abc",
+  };
+
+  FontList font_list;
+  for (std::u16string string : strings) {
+    gfx::Size size = GetStringSize(string, font_list);
+    EXPECT_EQ(GetStringWidth(string, font_list), size.width())
+        << " input string is \"" << string << "\"";
+    EXPECT_EQ(font_list.GetHeight(), size.height())
+        << " input string is \"" << string << "\"";
+  }
+}
+
+TEST(TextUtilsTest, AdjustVisualBorderForFont_BorderLargerThanFont) {
+  FontList font_list;
+
+  // We will make some assumptions about the default font - specifically that it
+  // has leading space and space for the descender.
+  DCHECK_GT(font_list.GetBaseline(), font_list.GetCapHeight());
+  DCHECK_LT(font_list.GetBaseline(), font_list.GetHeight());
+
+  // Adjust a large border for the default font. Using a large number means that
+  // the border will extend outside the leading and descender area of the font.
+  constexpr gfx::Insets kOriginalBorder(20);
+  const gfx::Insets result =
+      AdjustVisualBorderForFont(font_list, kOriginalBorder);
+  EXPECT_EQ(result.left(), kOriginalBorder.left());
+  EXPECT_EQ(result.right(), kOriginalBorder.right());
+  EXPECT_LT(result.top(), kOriginalBorder.top());
+  EXPECT_LT(result.bottom(), kOriginalBorder.bottom());
+}
+
+TEST(TextUtilsTest, AdjustVisualBorderForFont_BorderSmallerThanFont) {
+  FontList font_list;
+
+  // We will make some assumptions about the default font - specifically that it
+  // has leading space and space for the descender.
+  DCHECK_GT(font_list.GetBaseline(), font_list.GetCapHeight());
+  DCHECK_LT(font_list.GetBaseline(), font_list.GetHeight());
+
+  // Adjust a border with a small vertical component. The vertical component
+  // should go to zero because it overlaps the leading and descender areas of
+  // the font.
+  constexpr gfx::Insets kSmallVerticalInsets(1, 20);
+  const gfx::Insets result =
+      AdjustVisualBorderForFont(font_list, kSmallVerticalInsets);
+  EXPECT_EQ(result.left(), kSmallVerticalInsets.left());
+  EXPECT_EQ(result.right(), kSmallVerticalInsets.right());
+  EXPECT_EQ(result.top(), 0);
+  EXPECT_EQ(result.bottom(), 0);
+}
+
+TEST(TextUtilsTest, GetFontCapHeightCenterOffset_SecondFontIsSmaller) {
+  FontList original_font;
+  FontList smaller_font = original_font.DeriveWithSizeDelta(-3);
+  DCHECK_LT(smaller_font.GetCapHeight(), original_font.GetCapHeight());
+  EXPECT_GT(GetFontCapHeightCenterOffset(original_font, smaller_font), 0);
+}
+
+TEST(TextUtilsTest, GetFontCapHeightCenterOffset_SecondFontIsLarger) {
+  FontList original_font;
+  FontList larger_font = original_font.DeriveWithSizeDelta(3);
+  DCHECK_GT(larger_font.GetCapHeight(), original_font.GetCapHeight());
+  EXPECT_LT(GetFontCapHeightCenterOffset(original_font, larger_font), 0);
+}
+
+TEST(TextUtilsTest, GetFontCapHeightCenterOffset_SameSize) {
+  FontList original_font;
+  EXPECT_EQ(0, GetFontCapHeightCenterOffset(original_font, original_font));
+}
+
+struct RemoveAcceleratorCharData {
+  const char* input;
+  int accelerated_char_pos;
+  int accelerated_char_span;
+  const char* output_locate_and_strip;
+  const char* output_full_strip;
+  const char* name;
+};
+
+class RemoveAcceleratorCharTest
+    : public testing::TestWithParam<RemoveAcceleratorCharData> {
+ public:
+  static const RemoveAcceleratorCharData kCases[];
+};
+
+const RemoveAcceleratorCharData RemoveAcceleratorCharTest::kCases[] = {
+    {"", -1, 0, "", "", "EmptyString"},
+    {"&", -1, 0, "", "", "AcceleratorCharOnly"},
+    {"no accelerator", -1, 0, "no accelerator", "no accelerator",
+     "NoAccelerator"},
+    {"&one accelerator", 0, 1, "one accelerator", "one accelerator",
+     "OneAccelerator_Start"},
+    {"one &accelerator", 4, 1, "one accelerator", "one accelerator",
+     "OneAccelerator_Middle"},
+    {"one accelerator&", -1, 0, "one accelerator", "one accelerator",
+     "OneAccelerator_End"},
+    {"&two &accelerators", 4, 1, "two accelerators", "two accelerators",
+     "TwoAccelerators_OneAtStart"},
+    {"two &accelerators&", 4, 1, "two accelerators", "two accelerators",
+     "TwoAccelerators_OneAtEnd"},
+    {"two& &accelerators", 4, 1, "two accelerators", "two accelerators",
+     "TwoAccelerators_SpaceBetween"},
+    {"&&escaping", -1, 0, "&escaping", "&escaping", "Escape_Start"},
+    {"escap&&ing", -1, 0, "escap&ing", "escap&ing", "Escape_Middle"},
+    {"escaping&&", -1, 0, "escaping&", "escaping&", "Escape_End"},
+    {"accelerator(&A)", 12, 1, "accelerator(A)", "accelerator", "CJK_Style"},
+    {"accelerator(&A)...", 12, 1, "accelerator(A)...", "accelerator...",
+     "CJK_StyleEllipsis"},
+    {"accelerator(paren", -1, 0, "accelerator(paren", "accelerator(paren",
+     "CJK_OpenParen"},
+    {"accelerator(&paren", 12, 1, "accelerator(paren", "accelerator(paren",
+     "CJK_NoClosingParen"},
+    {"accelerator(&paren)", 12, 1, "accelerator(paren)", "accelerator(paren)",
+     "CJK_LateClosingParen"},
+    {"accelerator&paren)", 11, 1, "acceleratorparen)", "acceleratorparen)",
+     "CJK_NoOpeningParen"},
+    {"accelerator(P)", -1, 0, "accelerator(P)", "accelerator(P)",
+     "CJK_JustParens"},
+    {"accelerator(&)", 12, 1, "accelerator()", "accelerator()",
+     "CJK_MissingAccelerator"},
+    {"&mix&&ed", 0, 1, "mix&ed", "mix&ed", "Mixed_EscapeAfterAccelerator"},
+    {"&&m&ix&&e&d&", 6, 1, "&mix&ed", "&mix&ed",
+     "Mixed_MiddleAcceleratorSkipped"},
+    {"&&m&&ix&ed&&", 5, 1, "&m&ixed&", "&m&ixed&", "Mixed_OneAccelerator"},
+    {"&m&&ix&ed&&", 4, 1, "m&ixed&", "m&ixed&",
+     "Mixed_InitialAcceleratorSkipped"},
+    // U+1D49C MATHEMATICAL SCRIPT CAPITAL A, which occupies two |char16|'s.
+    {"&\U0001D49C", 0, 2, "\U0001D49C", "\U0001D49C",
+     "MultibyteAccelerator_Start"},
+    {"Test&\U0001D49Cing", 4, 2, "Test\U0001D49Cing", "Test\U0001D49Cing",
+     "MultibyteAccelerator_Middle"},
+    {"Test\U0001D49C&ing", 6, 1, "Test\U0001D49Cing", "Test\U0001D49Cing",
+     "OneAccelerator_AfterMultibyte"},
+    {"Test&\U0001D49C&ing", 6, 1, "Test\U0001D49Cing", "Test\U0001D49Cing",
+     "MultibyteAccelerator_Skipped"},
+    {"Test&\U0001D49C&&ing", 4, 2, "Test\U0001D49C&ing", "Test\U0001D49C&ing",
+     "MultibyteAccelerator_EscapeAfter"},
+    {"Test&\U0001D49C&\U0001D49Cing", 6, 2, "Test\U0001D49C\U0001D49Cing",
+     "Test\U0001D49C\U0001D49Cing",
+     "MultibyteAccelerator_AfterMultibyteAccelerator"},
+    {"accelerator(&\U0001D49C)", 12, 2, "accelerator(\U0001D49C)",
+     "accelerator", "MultibyteAccelerator_CJK"},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    All,
+    RemoveAcceleratorCharTest,
+    testing::ValuesIn(RemoveAcceleratorCharTest::kCases),
+    [](const testing::TestParamInfo<RemoveAcceleratorCharData>& param_info) {
+      return param_info.param.name;
+    });
+
+TEST_P(RemoveAcceleratorCharTest, RemoveAcceleratorChar) {
+  RemoveAcceleratorCharData data = GetParam();
+  int accelerated_char_pos;
+  int accelerated_char_span;
+  std::u16string result_locate_and_strip = LocateAndRemoveAcceleratorChar(
+      base::UTF8ToUTF16(data.input), &accelerated_char_pos,
+      &accelerated_char_span);
+  std::u16string result_full_strip =
+      RemoveAccelerator(base::UTF8ToUTF16(data.input));
+  EXPECT_EQ(result_locate_and_strip,
+            base::UTF8ToUTF16(data.output_locate_and_strip));
+  EXPECT_EQ(result_full_strip, base::UTF8ToUTF16(data.output_full_strip));
+  EXPECT_EQ(accelerated_char_pos, data.accelerated_char_pos);
+  EXPECT_EQ(accelerated_char_span, data.accelerated_char_span);
+}
+
+struct FindValidBoundaryData {
+  const char16_t* input;
+  size_t index_in;
+  bool trim_whitespace;
+  size_t index_out;
+  const char* name;
+};
+
+class FindValidBoundaryBeforeTest
+    : public testing::TestWithParam<FindValidBoundaryData> {
+ public:
+  static const FindValidBoundaryData kCases[];
+};
+
+const FindValidBoundaryData FindValidBoundaryBeforeTest::kCases[] = {
+    {u"", 0, false, 0, "Empty"},
+    {u"word", 0, false, 0, "StartOfString"},
+    {u"word", 4, false, 4, "EndOfString"},
+    {u"word", 2, false, 2, "MiddleOfString_OnValidCharacter"},
+    {u"w𐐷d", 2, false, 1, "MiddleOfString_OnSurrogatePair"},
+    {u"w𐐷d", 1, false, 1, "MiddleOfString_BeforeSurrogatePair"},
+    {u"w𐐷d", 3, false, 3, "MiddleOfString_AfterSurrogatePair"},
+    {u"wo d", 3, false, 3, "MiddleOfString_OnSpace_NoTrim"},
+    {u"wo d", 3, true, 2, "MiddleOfString_OnSpace_Trim"},
+    {u"wo d", 2, false, 2, "MiddleOfString_LeftOfSpace_NoTrim"},
+    {u"wo d", 2, true, 2, "MiddleOfString_LeftOfSpace_Trim"},
+    {u"wo\td", 3, false, 3, "MiddleOfString_OnTab_NoTrim"},
+    {u"wo\td", 3, true, 2, "MiddleOfString_OnTab_Trim"},
+    {u"w  d", 3, false, 3, "MiddleOfString_MultipleWhitespace_NoTrim"},
+    {u"w  d", 3, true, 1, "MiddleOfString_MultipleWhitespace_Trim"},
+    {u"w  d", 2, false, 2, "MiddleOfString_MiddleOfWhitespace_NoTrim"},
+    {u"w  d", 2, true, 1, "MiddleOfString_MiddleOfWhitespace_Trim"},
+    {u"w  ", 3, false, 3, "EndOfString_Whitespace_NoTrim"},
+    {u"w  ", 3, true, 1, "EndOfString_Whitespace_Trim"},
+    {u"  d", 2, false, 2, "MiddleOfString_Whitespace_NoTrim"},
+    {u"  d", 2, true, 0, "MiddleOfString_Whitespace_Trim"},
+    // COMBINING GRAVE ACCENT (U+0300)
+    {u"wo\u0300d", 2, false, 1, "MiddleOfString_OnCombiningMark"},
+    {u"wo\u0300d", 1, false, 1, "MiddleOfString_BeforeCombiningMark"},
+    {u"wo\u0300d", 3, false, 3, "MiddleOfString_AfterCombiningMark"},
+    {u"w o\u0300d", 3, true, 1, "MiddleOfString_SpaceAndCombinginMark_Trim"},
+    {u"wo\u0300 d", 3, true, 3, "MiddleOfString_CombiningMarkAndSpace_Trim"},
+    {u"w \u0300d", 3, true, 3,
+     "MiddleOfString_AfterSpaceWithCombiningMark_Trim"},
+    {u"w \u0300d", 2, true, 1, "MiddleOfString_OnSpaceWithCombiningMark_Trim"},
+    {u"w \u0300 d", 4, true, 3,
+     "MiddleOfString_AfterSpaceAfterSpaceWithCombiningMark_Trim"},
+    // MUSICAL SYMBOL G CLEF (U+1D11E) + MUSICAL SYMBOL COMBINING FLAG-1
+    // (U+1D16E)
+    {u"w\U0001D11E\U0001D16Ed", 1, false, 1,
+     "MiddleOfString_BeforeCombiningSurrogate"},
+    {u"w\U0001D11E\U0001D16Ed", 2, false, 1,
+     "MiddleOfString_OnCombiningSurrogate_Pos1"},
+    {u"w\U0001D11E\U0001D16Ed", 3, false, 1,
+     "MiddleOfString_OnCombiningSurrogate_Pos2"},
+    {u"w\U0001D11E\U0001D16Ed", 4, false, 1,
+     "MiddleOfString_OnCombiningSurrogate_Pos3"},
+    {u"w\U0001D11E\U0001D16Ed", 5, false, 5,
+     "MiddleOfString_AfterCombiningSurrogate"},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    All,
+    FindValidBoundaryBeforeTest,
+    testing::ValuesIn(FindValidBoundaryBeforeTest::kCases),
+    [](const testing::TestParamInfo<FindValidBoundaryData>& param_info) {
+      return param_info.param.name;
+    });
+
+TEST_P(FindValidBoundaryBeforeTest, FindValidBoundaryBefore) {
+  FindValidBoundaryData data = GetParam();
+  const std::u16string::const_pointer input =
+      reinterpret_cast<std::u16string::const_pointer>(data.input);
+  DLOG(INFO) << input;
+  size_t result =
+      FindValidBoundaryBefore(input, data.index_in, data.trim_whitespace);
+  EXPECT_EQ(data.index_out, result);
+}
+
+class FindValidBoundaryAfterTest
+    : public testing::TestWithParam<FindValidBoundaryData> {
+ public:
+  static const FindValidBoundaryData kCases[];
+};
+
+const FindValidBoundaryData FindValidBoundaryAfterTest::kCases[] = {
+    {u"", 0, false, 0, "Empty"},
+    {u"word", 0, false, 0, "StartOfString"},
+    {u"word", 4, false, 4, "EndOfString"},
+    {u"word", 2, false, 2, "MiddleOfString_OnValidCharacter"},
+    {u"w𐐷d", 2, false, 3, "MiddleOfString_OnSurrogatePair"},
+    {u"w𐐷d", 1, false, 1, "MiddleOfString_BeforeSurrogatePair"},
+    {u"w𐐷d", 3, false, 3, "MiddleOfString_AfterSurrogatePair"},
+    {u"wo d", 2, false, 2, "MiddleOfString_OnSpace_NoTrim"},
+    {u"wo d", 2, true, 3, "MiddleOfString_OnSpace_Trim"},
+    {u"wo d", 3, false, 3, "MiddleOfString_RightOfSpace_NoTrim"},
+    {u"wo d", 3, true, 3, "MiddleOfString_RightOfSpace_Trim"},
+    {u"wo\td", 2, false, 2, "MiddleOfString_OnTab_NoTrim"},
+    {u"wo\td", 2, true, 3, "MiddleOfString_OnTab_Trim"},
+    {u"w  d", 1, false, 1, "MiddleOfString_MultipleWhitespace_NoTrim"},
+    {u"w  d", 1, true, 3, "MiddleOfString_MultipleWhitespace_Trim"},
+    {u"w  d", 2, false, 2, "MiddleOfString_MiddleOfWhitespace_NoTrim"},
+    {u"w  d", 2, true, 3, "MiddleOfString_MiddleOfWhitespace_Trim"},
+    {u"w  ", 1, false, 1, "MiddleOfString_Whitespace_NoTrim"},
+    {u"w  ", 1, true, 3, "MiddleOfString_Whitespace_Trim"},
+    {u"  d", 0, false, 0, "StartOfString_Whitespace_NoTrim"},
+    {u"  d", 0, true, 2, "StartOfString_Whitespace_Trim"},
+    // COMBINING GRAVE ACCENT (U+0300)
+    {u"wo\u0300d", 2, false, 3, "MiddleOfString_OnCombiningMark"},
+    {u"wo\u0300d", 1, false, 1, "MiddleOfString_BeforeCombiningMark"},
+    {u"wo\u0300d", 3, false, 3, "MiddleOfString_AfterCombiningMark"},
+    {u"w o\u0300d", 1, true, 2, "MiddleOfString_SpaceAndCombinginMark_Trim"},
+    {u"wo\u0300 d", 1, true, 1,
+     "MiddleOfString_BeforeCombiningMarkAndSpace_Trim"},
+    {u"wo\u0300 d", 2, true, 4, "MiddleOfString_OnCombiningMarkAndSpace_Trim"},
+    {u"w \u0300d", 1, true, 1,
+     "MiddleOfString_BeforeSpaceWithCombiningMark_Trim"},
+    {u"w \u0300d", 2, true, 3, "MiddleOfString_OnSpaceWithCombiningMark_Trim"},
+    {u"w  \u0300d", 1, true, 2,
+     "MiddleOfString_BeforeSpaceBeforeSpaceWithCombiningMark_Trim"},
+    // MUSICAL SYMBOL G CLEF (U+1D11E) + MUSICAL SYMBOL COMBINING FLAG-1
+    // (U+1D16E)
+    {u"w\U0001D11E\U0001D16Ed", 1, false, 1,
+     "MiddleOfString_BeforeCombiningSurrogate"},
+    {u"w\U0001D11E\U0001D16Ed", 2, false, 5,
+     "MiddleOfString_OnCombiningSurrogate_Pos1"},
+    {u"w\U0001D11E\U0001D16Ed", 3, false, 5,
+     "MiddleOfString_OnCombiningSurrogate_Pos2"},
+    {u"w\U0001D11E\U0001D16Ed", 4, false, 5,
+     "MiddleOfString_OnCombiningSurrogate_Pos3"},
+    {u"w\U0001D11E\U0001D16Ed", 5, false, 5,
+     "MiddleOfString_AfterCombiningSurrogate"},
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    All,
+    FindValidBoundaryAfterTest,
+    testing::ValuesIn(FindValidBoundaryAfterTest::kCases),
+    [](const testing::TestParamInfo<FindValidBoundaryData>& param_info) {
+      return param_info.param.name;
+    });
+
+TEST_P(FindValidBoundaryAfterTest, FindValidBoundaryAfter) {
+  FindValidBoundaryData data = GetParam();
+  const std::u16string::const_pointer input =
+      reinterpret_cast<std::u16string::const_pointer>(data.input);
+  size_t result =
+      FindValidBoundaryAfter(input, data.index_in, data.trim_whitespace);
+  EXPECT_EQ(data.index_out, result);
+}
+
+}  // namespace
+}  // namespace gfx
diff --git a/ui/gfx/ui_gfx_exports.cc b/ui/gfx/ui_gfx_exports.cc
new file mode 100644
index 0000000..ca95eb3
--- /dev/null
+++ b/ui/gfx/ui_gfx_exports.cc
@@ -0,0 +1,10 @@
+// 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.
+
+// This file is for including headers that are not included in any other .cc
+// files contained with the ui/gfx module.  We need to include these here so
+// that linker will know to include the symbols, defined by these headers, in
+// the resulting dynamic library (gfx.dll).
+
+#include "ui/gfx/vsync_provider.h"
diff --git a/ui/gfx/utf16_indexing.cc b/ui/gfx/utf16_indexing.cc
new file mode 100644
index 0000000..164db80
--- /dev/null
+++ b/ui/gfx/utf16_indexing.cc
@@ -0,0 +1,57 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/utf16_indexing.h"
+
+#include "base/check_op.h"
+#include "base/third_party/icu/icu_utf.h"
+
+namespace gfx {
+
+bool IsValidCodePointIndex(const std::u16string& s, size_t index) {
+  return index == 0 || index == s.length() ||
+    !(CBU16_IS_TRAIL(s[index]) && CBU16_IS_LEAD(s[index - 1]));
+}
+
+ptrdiff_t UTF16IndexToOffset(const std::u16string& s, size_t base, size_t pos) {
+  // The indices point between UTF-16 words (range 0 to s.length() inclusive).
+  // In order to consistently handle indices that point to the middle of a
+  // surrogate pair, we count the first word in that surrogate pair and not
+  // the second. The test "s[i] is not the second half of a surrogate pair" is
+  // "IsValidCodePointIndex(s, i)".
+  DCHECK_LE(base, s.length());
+  DCHECK_LE(pos, s.length());
+  ptrdiff_t delta = 0;
+  while (base < pos)
+    delta += IsValidCodePointIndex(s, base++) ? 1 : 0;
+  while (pos < base)
+    delta -= IsValidCodePointIndex(s, pos++) ? 1 : 0;
+  return delta;
+}
+
+size_t UTF16OffsetToIndex(const std::u16string& s,
+                          size_t base,
+                          ptrdiff_t offset) {
+  DCHECK_LE(base, s.length());
+  // As in UTF16IndexToOffset, we count the first half of a surrogate pair, not
+  // the second. When stepping from pos to pos+1 we check s[pos:pos+1] == s[pos]
+  // (Python syntax), hence pos++. When stepping from pos to pos-1 we check
+  // s[pos-1], hence --pos.
+  size_t pos = base;
+  while (offset > 0 && pos < s.length())
+    offset -= IsValidCodePointIndex(s, pos++) ? 1 : 0;
+  while (offset < 0 && pos > 0)
+    offset += IsValidCodePointIndex(s, --pos) ? 1 : 0;
+  // If offset != 0 then we ran off the edge of the string, which is a contract
+  // violation but is handled anyway (by clamping) in release for safety.
+  DCHECK_EQ(offset, 0);
+  // Since the second half of a surrogate pair has "length" zero, there is an
+  // ambiguity in the returned position. Resolve it by always returning a valid
+  // index.
+  if (!IsValidCodePointIndex(s, pos))
+    ++pos;
+  return pos;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/utf16_indexing.h b/ui/gfx/utf16_indexing.h
new file mode 100644
index 0000000..4831c41
--- /dev/null
+++ b/ui/gfx/utf16_indexing.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_UTF16_INDEXING_H_
+#define UI_GFX_UTF16_INDEXING_H_
+
+#include <stddef.h>
+
+#include <string>
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// Returns false if s[index-1] is a high surrogate and s[index] is a low
+// surrogate, true otherwise.
+GFX_EXPORT bool IsValidCodePointIndex(const std::u16string& s, size_t index);
+
+// |UTF16IndexToOffset| returns the number of code points between |base| and
+// |pos| in the given string. |UTF16OffsetToIndex| returns the index that is
+// |offset| code points away from the given |base| index. These functions are
+// named after glib's |g_utf8_pointer_to_offset| and |g_utf8_offset_to_pointer|,
+// which perform the same function for UTF-8. As in glib, it is an error to
+// pass an |offset| that walks off the edge of the string.
+//
+// These functions attempt to deal with invalid use of UTF-16 surrogates in a
+// way that makes as much sense as possible: unpaired surrogates are treated as
+// single characters, and if an argument index points to the middle of a valid
+// surrogate pair, it is treated as though it pointed to the end of that pair.
+// The index returned by |UTF16OffsetToIndex| never points to the middle of a
+// surrogate pair.
+//
+// The following identities hold:
+//   If |s| contains no surrogate pairs, then
+//     UTF16IndexToOffset(s, base, pos) == pos - base
+//     UTF16OffsetToIndex(s, base, offset) == base + offset
+//   If |pos| does not point to the middle of a surrogate pair, then
+//     UTF16OffsetToIndex(s, base, UTF16IndexToOffset(s, base, pos)) == pos
+//   Always,
+//     UTF16IndexToOffset(s, base, UTF16OffsetToIndex(s, base, ofs)) == ofs
+//     UTF16IndexToOffset(s, i, j) == -UTF16IndexToOffset(s, j, i)
+GFX_EXPORT ptrdiff_t UTF16IndexToOffset(const std::u16string& s,
+                                        size_t base,
+                                        size_t pos);
+GFX_EXPORT size_t UTF16OffsetToIndex(const std::u16string& s,
+                                     size_t base,
+                                     ptrdiff_t offset);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_UTF16_INDEXING_H_
diff --git a/ui/gfx/utf16_indexing_unittest.cc b/ui/gfx/utf16_indexing_unittest.cc
new file mode 100644
index 0000000..289fd44
--- /dev/null
+++ b/ui/gfx/utf16_indexing_unittest.cc
@@ -0,0 +1,34 @@
+// Copyright (c) 2012 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.
+
+#include <stddef.h>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/utf16_indexing.h"
+
+namespace gfx {
+
+TEST(UTF16IndexingTest, IndexOffsetConversions) {
+  // Valid surrogate pair surrounded by unpaired surrogates
+  const char16_t foo[] = {0xDC00, 0xD800, 0xD800, 0xDFFF, 0xDFFF, 0xDBFF, 0};
+  const std::u16string s(foo);
+  const size_t the_invalid_index = 3;
+  for (size_t i = 0; i <= s.length(); ++i)
+    EXPECT_EQ(i != the_invalid_index, IsValidCodePointIndex(s, i));
+  for (size_t i = 0; i <= s.length(); ++i) {
+    for (size_t j = i; j <= s.length(); ++j) {
+      ptrdiff_t offset = static_cast<ptrdiff_t>(j - i);
+      if (i <= the_invalid_index && j > the_invalid_index)
+        --offset;
+      EXPECT_EQ(offset, UTF16IndexToOffset(s, i, j));
+      EXPECT_EQ(-offset, UTF16IndexToOffset(s, j, i));
+      size_t adjusted_j = (j == the_invalid_index) ? j + 1 : j;
+      EXPECT_EQ(adjusted_j, UTF16OffsetToIndex(s, i, offset));
+      size_t adjusted_i = (i == the_invalid_index) ? i + 1 : i;
+      EXPECT_EQ(adjusted_i, UTF16OffsetToIndex(s, j, -offset));
+    }
+  }
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/vector_icon_types.h b/ui/gfx/vector_icon_types.h
new file mode 100644
index 0000000..d4ffcdd
--- /dev/null
+++ b/ui/gfx/vector_icon_types.h
@@ -0,0 +1,123 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_VECTOR_ICON_TYPES_H_
+#define UI_GFX_VECTOR_ICON_TYPES_H_
+
+#include "base/macros.h"
+#include "third_party/skia/include/core/SkScalar.h"
+#include "ui/gfx/animation/tween.h"
+
+namespace gfx {
+
+// This macro allows defining the list of commands in this file, then pulling
+// them each in to the template files via using-declarations.  Files which want
+// to do this should do the following:
+//   #define DECLARE_VECTOR_COMMAND(x) using gfx::x;
+//   DECLARE_VECTOR_COMMANDS
+// The alternative would be to have the template files pull in the whole gfx
+// namespace via using-directives, which is banned by the style guide.
+#define DECLARE_VECTOR_COMMANDS                                                \
+  /* A new <path> element. For the first path, this is assumed. */             \
+  DECLARE_VECTOR_COMMAND(NEW_PATH)                                             \
+  /* Sets the alpha for the current path. */                                   \
+  DECLARE_VECTOR_COMMAND(PATH_COLOR_ALPHA)                                     \
+  /* Sets the color for the current path. */                                   \
+  DECLARE_VECTOR_COMMAND(PATH_COLOR_ARGB)                                      \
+  /* Sets the path to clear mode (Skia's kClear_Mode). */                      \
+  DECLARE_VECTOR_COMMAND(PATH_MODE_CLEAR)                                      \
+  /* By default, the path will be filled. This changes the paint action to */  \
+  /* stroke at the given width. */                                             \
+  DECLARE_VECTOR_COMMAND(STROKE)                                               \
+  /* By default, a stroke has a round cap. This sets it to square. */          \
+  DECLARE_VECTOR_COMMAND(CAP_SQUARE)                                           \
+  /* These correspond to pathing commands. */                                  \
+  DECLARE_VECTOR_COMMAND(MOVE_TO)                                              \
+  DECLARE_VECTOR_COMMAND(R_MOVE_TO)                                            \
+  DECLARE_VECTOR_COMMAND(ARC_TO)                                               \
+  DECLARE_VECTOR_COMMAND(R_ARC_TO)                                             \
+  DECLARE_VECTOR_COMMAND(LINE_TO)                                              \
+  DECLARE_VECTOR_COMMAND(R_LINE_TO)                                            \
+  DECLARE_VECTOR_COMMAND(H_LINE_TO)                                            \
+  DECLARE_VECTOR_COMMAND(R_H_LINE_TO)                                          \
+  DECLARE_VECTOR_COMMAND(V_LINE_TO)                                            \
+  DECLARE_VECTOR_COMMAND(R_V_LINE_TO)                                          \
+  DECLARE_VECTOR_COMMAND(CUBIC_TO)                                             \
+  DECLARE_VECTOR_COMMAND(R_CUBIC_TO)                                           \
+  DECLARE_VECTOR_COMMAND(CUBIC_TO_SHORTHAND)                                   \
+  DECLARE_VECTOR_COMMAND(QUADRATIC_TO)                                         \
+  DECLARE_VECTOR_COMMAND(R_QUADRATIC_TO)                                       \
+  DECLARE_VECTOR_COMMAND(QUADRATIC_TO_SHORTHAND)                               \
+  DECLARE_VECTOR_COMMAND(R_QUADRATIC_TO_SHORTHAND)                             \
+  DECLARE_VECTOR_COMMAND(CIRCLE)                                               \
+  DECLARE_VECTOR_COMMAND(OVAL)                                                 \
+  DECLARE_VECTOR_COMMAND(ROUND_RECT)                                           \
+  DECLARE_VECTOR_COMMAND(CLOSE)                                                \
+  /* Sets the dimensions of the canvas in dip. */                              \
+  DECLARE_VECTOR_COMMAND(CANVAS_DIMENSIONS)                                    \
+  /* Sets a bounding rect for the path. This allows fine adjustment because */ \
+  /* it can tweak edge anti-aliasing. Args are x, y, w, h. */                  \
+  DECLARE_VECTOR_COMMAND(CLIP)                                                 \
+  /* Disables anti-aliasing for this path. */                                  \
+  DECLARE_VECTOR_COMMAND(DISABLE_AA)                                           \
+  /* Flips the x-axis in RTL locales. Default is false, this command sets */   \
+  /* it to true. */                                                            \
+  DECLARE_VECTOR_COMMAND(FLIPS_IN_RTL)
+
+#define DECLARE_VECTOR_COMMAND(x) x,
+
+// A command to Skia.
+enum CommandType { DECLARE_VECTOR_COMMANDS };
+
+#undef DECLARE_VECTOR_COMMAND
+
+// A POD that describes either a path command or an argument for it.
+struct PathElement {
+  constexpr PathElement(CommandType value) : command(value) {}
+  constexpr PathElement(SkScalar value) : arg(value) {}
+
+  union {
+    CommandType command;
+    SkScalar arg;
+  };
+};
+
+// Describes the drawing commands for a single vector icon at a particular pixel
+// size or range of sizes.
+struct VectorIconRep {
+  VectorIconRep() = default;
+
+  VectorIconRep(const VectorIconRep&) = delete;
+  VectorIconRep& operator=(const VectorIconRep&) = delete;
+
+  const PathElement* path = nullptr;
+
+  // The length of |path|.
+  size_t path_size = 0u;
+};
+
+// A vector icon that stores one or more representations to be used for various
+// scale factors and pixel dimensions.
+struct VectorIcon {
+  VectorIcon() = default;
+
+  VectorIcon(const VectorIcon&) = delete;
+  VectorIcon& operator=(const VectorIcon&) = delete;
+
+  bool is_empty() const { return !reps; }
+
+  const VectorIconRep* const reps = nullptr;
+  size_t reps_size = 0u;
+
+  // A human-readable name, useful for debugging, derived from the name of the
+  // icon file. This can also be used as an identifier, but vector icon targets
+  // should be careful to ensure this is unique.
+  const char* name = nullptr;
+
+  bool operator<(const VectorIcon& other) const;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_VECTOR_ICON_TYPES_H_
diff --git a/ui/gfx/vector_icon_utils.cc b/ui/gfx/vector_icon_utils.cc
new file mode 100644
index 0000000..44b68fa
--- /dev/null
+++ b/ui/gfx/vector_icon_utils.cc
@@ -0,0 +1,24 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/vector_icon_utils.h"
+
+#include "base/check.h"
+#include "ui/gfx/vector_icon_types.h"
+
+namespace gfx {
+
+int GetDefaultSizeOfVectorIcon(const VectorIcon& icon) {
+  if (icon.is_empty())
+    return -1;
+  const PathElement* default_icon_path = icon.reps[icon.reps_size - 1].path;
+  DCHECK_EQ(default_icon_path[0].command, CANVAS_DIMENSIONS)
+      << " " << icon.name
+      << " has no size in its icon definition, and it seems unlikely you want "
+         "to display at the default of 48dip. Please specify a size in "
+         "CreateVectorIcon().";
+  return default_icon_path[1].arg;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/vector_icon_utils.h b/ui/gfx/vector_icon_utils.h
new file mode 100644
index 0000000..532f29f
--- /dev/null
+++ b/ui/gfx/vector_icon_utils.h
@@ -0,0 +1,20 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_VECTOR_ICON_UTILS_H_
+#define UI_GFX_VECTOR_ICON_UTILS_H_
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+struct VectorIcon;
+
+// Calculates the size that will be default for |icon|, in dip. This will be the
+// smallest icon size |icon| contains.
+GFX_EXPORT int GetDefaultSizeOfVectorIcon(const gfx::VectorIcon& icon);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_VECTOR_ICON_UTILS_H_
diff --git a/ui/gfx/video_types.h b/ui/gfx/video_types.h
new file mode 100644
index 0000000..e8865a6
--- /dev/null
+++ b/ui/gfx/video_types.h
@@ -0,0 +1,19 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_VIDEO_TYPES_H_
+#define UI_GFX_VIDEO_TYPES_H_
+
+namespace gfx {
+
+enum class ProtectedVideoType : uint32_t {
+  kClear = 0,
+  kSoftwareProtected = 1,
+  kHardwareProtected = 2,
+  kMaxValue = kHardwareProtected,
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_VIDEO_TYPES_H_
diff --git a/ui/gfx/vsync_provider.cc b/ui/gfx/vsync_provider.cc
new file mode 100644
index 0000000..ff4b4a5
--- /dev/null
+++ b/ui/gfx/vsync_provider.cc
@@ -0,0 +1,29 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/vsync_provider.h"
+
+namespace gfx {
+
+void FixedVSyncProvider::GetVSyncParameters(UpdateVSyncCallback callback) {
+  std::move(callback).Run(timebase_, interval_);
+}
+
+bool FixedVSyncProvider::GetVSyncParametersIfAvailable(
+    base::TimeTicks* timebase,
+    base::TimeDelta* interval) {
+  *timebase = timebase_;
+  *interval = interval_;
+  return true;
+}
+
+bool FixedVSyncProvider::SupportGetVSyncParametersIfAvailable() const {
+  return true;
+}
+
+bool FixedVSyncProvider::IsHWClock() const {
+  return false;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/vsync_provider.h b/ui/gfx/vsync_provider.h
new file mode 100644
index 0000000..87b0a15
--- /dev/null
+++ b/ui/gfx/vsync_provider.h
@@ -0,0 +1,64 @@
+// 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.
+
+#ifndef UI_GFX_VSYNC_PROVIDER_H_
+#define UI_GFX_VSYNC_PROVIDER_H_
+
+#include "base/callback.h"
+#include "base/time/time.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class GFX_EXPORT VSyncProvider {
+ public:
+  virtual ~VSyncProvider() {}
+
+  typedef base::OnceCallback<void(const base::TimeTicks timebase,
+                                  const base::TimeDelta interval)>
+      UpdateVSyncCallback;
+
+  // Get the time of the most recent screen refresh, along with the time
+  // between consecutive refreshes. The callback is called as soon as
+  // the data is available: it could be immediately from this method,
+  // later via a PostTask to the current MessageLoop, or never (if we have
+  // no data source). We provide the strong guarantee that the callback will
+  // not be called once the instance of this class is destroyed.
+  virtual void GetVSyncParameters(UpdateVSyncCallback callback) = 0;
+
+  // Similar to GetVSyncParameters(). It returns true, if the data is available.
+  // Otherwise false is returned.
+  virtual bool GetVSyncParametersIfAvailable(base::TimeTicks* timebase,
+                                             base::TimeDelta* interval) = 0;
+
+  // Returns true, if GetVSyncParametersIfAvailable is supported.
+  virtual bool SupportGetVSyncParametersIfAvailable() const = 0;
+
+  // Returns true, if VSyncProvider gets VSync timebase from HW.
+  virtual bool IsHWClock() const = 0;
+};
+
+// Provides a constant timebase and interval.
+class GFX_EXPORT FixedVSyncProvider : public VSyncProvider {
+ public:
+  FixedVSyncProvider(base::TimeTicks timebase, base::TimeDelta interval)
+    : timebase_(timebase), interval_(interval) {
+  }
+
+  ~FixedVSyncProvider() override {}
+
+  void GetVSyncParameters(UpdateVSyncCallback callback) override;
+  bool GetVSyncParametersIfAvailable(base::TimeTicks* timebase,
+                                     base::TimeDelta* interval) override;
+  bool SupportGetVSyncParametersIfAvailable() const override;
+  bool IsHWClock() const override;
+
+ private:
+  base::TimeTicks timebase_;
+  base::TimeDelta interval_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_VSYNC_PROVIDER_H_
diff --git a/ui/gfx/win/DEPS b/ui/gfx/win/DEPS
new file mode 100644
index 0000000..99162b4
--- /dev/null
+++ b/ui/gfx/win/DEPS
@@ -0,0 +1,3 @@
+include_rules = [
+  "+components/crash",
+]
diff --git a/ui/gfx/win/OWNERS b/ui/gfx/win/OWNERS
new file mode 100644
index 0000000..6ef3395
--- /dev/null
+++ b/ui/gfx/win/OWNERS
@@ -0,0 +1,4 @@
+# For any other files, defer to ui/gfx/OWNERS.
+
+# Direct Write, fonts and related classes.
+per-file direct_write*=etienneb@chromium.org
diff --git a/ui/gfx/win/crash_id_helper.cc b/ui/gfx/win/crash_id_helper.cc
new file mode 100644
index 0000000..5cbf920
--- /dev/null
+++ b/ui/gfx/win/crash_id_helper.cc
@@ -0,0 +1,80 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/win/crash_id_helper.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/strings/string_util.h"
+
+namespace gfx {
+
+// static
+CrashIdHelper* CrashIdHelper::Get() {
+  static base::NoDestructor<CrashIdHelper> helper;
+  return helper.get();
+}
+
+// static
+void CrashIdHelper::RegisterMainThread(base::PlatformThreadId thread_id) {
+  main_thread_id_ = thread_id;
+}
+
+CrashIdHelper::ScopedLogger::~ScopedLogger() {
+  CrashIdHelper::Get()->OnDidProcessMessages();
+}
+
+CrashIdHelper::ScopedLogger::ScopedLogger() = default;
+
+std::unique_ptr<CrashIdHelper::ScopedLogger>
+CrashIdHelper::OnWillProcessMessages(const std::string& id) {
+  if (main_thread_id_ == base::kInvalidThreadId ||
+      base::PlatformThread::CurrentId() != main_thread_id_) {
+    return nullptr;
+  }
+
+  if (!ids_.empty())
+    was_nested_ = true;
+  ids_.push_back(id.empty() ? "unspecified" : id);
+  debugging_crash_key_.Set(CurrentCrashId());
+  // base::WrapUnique() as constructor is private.
+  return base::WrapUnique(new ScopedLogger);
+}
+
+void CrashIdHelper::OnDidProcessMessages() {
+  DCHECK(!ids_.empty());
+  ids_.pop_back();
+  if (ids_.empty()) {
+    debugging_crash_key_.Clear();
+    was_nested_ = false;
+  } else {
+    debugging_crash_key_.Set(CurrentCrashId());
+  }
+}
+
+CrashIdHelper::CrashIdHelper() = default;
+
+CrashIdHelper::~CrashIdHelper() = default;
+
+std::string CrashIdHelper::CurrentCrashId() const {
+  // This should only be called when there is at least one id.
+  DCHECK(!ids_.empty());
+  // Common case is only one id.
+  if (ids_.size() == 1) {
+    // If the size of |ids_| is 1, then the message loop is not nested. If
+    // |was_nested_| is true, it means in processing the message corresponding
+    // to ids_[0] another message was processed, resulting in nested message
+    // loops.  A nested message loop can lead to reentrancy and/or problems when
+    // the stack unravels. For example, it's entirely possible that when a
+    // nested message loop completes, objects further up in the stack have been
+    // deleted. "(N)" is added to signify that a nested message loop was run at
+    // some point during the current message loop.
+    return was_nested_ ? "(N) " + ids_[0] : ids_[0];
+  }
+  return base::JoinString(ids_, ">");
+}
+
+// static
+base::PlatformThreadId CrashIdHelper::main_thread_id_ = base::kInvalidThreadId;
+
+}  // namespace gfx
diff --git a/ui/gfx/win/crash_id_helper.h b/ui/gfx/win/crash_id_helper.h
new file mode 100644
index 0000000..649e203
--- /dev/null
+++ b/ui/gfx/win/crash_id_helper.h
@@ -0,0 +1,90 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_CRASH_ID_HELPER_H_
+#define UI_GFX_WIN_CRASH_ID_HELPER_H_
+
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/no_destructor.h"
+#include "base/threading/platform_thread.h"
+#include "components/crash/core/common/crash_key.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+// CrashIdHelper is used to log (in crash dumps) the id(s) of the window/widget
+// currently dispatching an event. Often times crashes occur purely in ui
+// code, while the bug lies in client code. Logging an id helps better identify
+// the client code that created the window/widget.
+//
+// This class only logs ids on the thread identified by RegisterMainThread().
+//
+// Example usage:
+// {
+//   auto logger = CrashIdHelper::Get()->OnWillProcessMessages(crash_id);
+//   <do message processing>
+// }
+class GFX_EXPORT CrashIdHelper {
+ public:
+  static CrashIdHelper* Get();
+
+  CrashIdHelper(const CrashIdHelper&) = delete;
+  CrashIdHelper& operator=(const CrashIdHelper&) = delete;
+
+  // Registers the thread used for logging.
+  static void RegisterMainThread(base::PlatformThreadId thread_id);
+
+  // RAII style class that unregisters in the destructor.
+  class GFX_EXPORT ScopedLogger {
+   public:
+    ScopedLogger(const ScopedLogger&) = delete;
+    ScopedLogger& operator=(const ScopedLogger&) = delete;
+
+    ~ScopedLogger();
+
+   private:
+    friend class CrashIdHelper;
+    ScopedLogger();
+  };
+
+  // Adds |id| to the list of active debugging ids. When the returned object
+  // is destroyed, |id| is removed from the list of active debugging ids.
+  // Returns null if logging is not enabled on the current thread.
+  std::unique_ptr<ScopedLogger> OnWillProcessMessages(const std::string& id);
+
+ private:
+  friend base::NoDestructor<CrashIdHelper>;
+  friend class CrashIdHelperTest;
+
+  CrashIdHelper();
+  ~CrashIdHelper();
+
+  // Called from ~ScopedLogger. Removes the most recently added id.
+  void OnDidProcessMessages();
+
+  // Returns the identifier to put in the crash key.
+  std::string CurrentCrashId() const;
+
+  // Ordered list of debugging identifiers added.
+  std::vector<std::string> ids_;
+
+  // Set to true once |ids_| has more than one object, and false once |ids_| is
+  // empty. That is, this is true once processing the windows message resulted
+  // in processing another windows message (nested message loops). See comment
+  // in implementation of CurrentCrashId() as to why this is tracked.
+  bool was_nested_ = false;
+
+  // This uses the name 'widget' as this code is most commonly triggered from
+  // views, which uses the term Widget.
+  crash_reporter::CrashKeyString<128> debugging_crash_key_{"widget-id"};
+
+  static base::PlatformThreadId main_thread_id_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_CRASH_ID_HELPER_H_
diff --git a/ui/gfx/win/crash_id_helper_unittest.cc b/ui/gfx/win/crash_id_helper_unittest.cc
new file mode 100644
index 0000000..5e3e509
--- /dev/null
+++ b/ui/gfx/win/crash_id_helper_unittest.cc
@@ -0,0 +1,54 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/win/crash_id_helper.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+
+class CrashIdHelperTest : public testing::Test {
+ public:
+  CrashIdHelperTest() = default;
+
+  CrashIdHelperTest(const CrashIdHelperTest&) = delete;
+  CrashIdHelperTest& operator=(const CrashIdHelperTest&) = delete;
+
+  ~CrashIdHelperTest() override = default;
+
+  std::string CurrentCrashId() {
+    return CrashIdHelper::Get()->CurrentCrashId();
+  }
+};
+
+// This test verifies CurrentCrashId(). Ideally this would verify at
+// crash_reporter::CrashKeyString, but that class isn't particularly test
+// friendly (and the implementation varies depending upon compile time flags).
+TEST_F(CrashIdHelperTest, Basic) {
+  CrashIdHelper::RegisterMainThread(base::PlatformThread::CurrentId());
+
+  const std::string id1 = "id";
+  {
+    auto scoper = CrashIdHelper::Get()->OnWillProcessMessages(id1);
+    EXPECT_EQ(id1, CurrentCrashId());
+  }
+
+  // No assertions for empty as CurrentCrashId() DCHECKs there is at least
+  // one id.
+
+  const std::string id2 = "id2";
+  {
+    auto scoper = CrashIdHelper::Get()->OnWillProcessMessages(id2);
+    EXPECT_EQ(id2, CurrentCrashId());
+
+    {
+      auto scoper2 = CrashIdHelper::Get()->OnWillProcessMessages(id1);
+      EXPECT_EQ("id2>id", CurrentCrashId());
+    }
+    EXPECT_EQ("(N) id2", CurrentCrashId());
+  }
+  CrashIdHelper::RegisterMainThread(base::kInvalidThreadId);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/win/direct_write.cc b/ui/gfx/win/direct_write.cc
new file mode 100644
index 0000000..fc7356b
--- /dev/null
+++ b/ui/gfx/win/direct_write.cc
@@ -0,0 +1,176 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/win/direct_write.h"
+
+#include <wrl/client.h>
+
+#include <string>
+
+#include "base/debug/alias.h"
+#include "base/metrics/histogram_functions.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/trace_event/trace_event.h"
+#include "base/win/windows_version.h"
+#include "skia/ext/fontmgr_default.h"
+#include "third_party/skia/include/core/SkFontMgr.h"
+#include "third_party/skia/include/ports/SkTypeface_win.h"
+
+namespace gfx {
+namespace win {
+
+namespace {
+
+// Pointer to the global IDWriteFactory interface.
+IDWriteFactory* g_direct_write_factory = nullptr;
+
+void SetDirectWriteFactory(IDWriteFactory* factory) {
+  DCHECK(!g_direct_write_factory);
+  // We grab a reference on the DirectWrite factory. This reference is
+  // leaked, which is ok because skia leaks it as well.
+  factory->AddRef();
+  g_direct_write_factory = factory;
+}
+
+}  // anonymous namespace
+
+void CreateDWriteFactory(IDWriteFactory** factory) {
+  Microsoft::WRL::ComPtr<IUnknown> factory_unknown;
+  HRESULT hr =
+      DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory),
+                          &factory_unknown);
+  if (FAILED(hr)) {
+    base::debug::Alias(&hr);
+    CHECK(false);
+    return;
+  }
+  factory_unknown.CopyTo(factory);
+}
+
+void InitializeDirectWrite() {
+  static bool tried_dwrite_initialize = false;
+  DCHECK(!tried_dwrite_initialize);
+  tried_dwrite_initialize = true;
+
+  TRACE_EVENT0("fonts", "gfx::InitializeDirectWrite");
+  SCOPED_UMA_HISTOGRAM_LONG_TIMER("DirectWrite.Fonts.Gfx.InitializeTime");
+
+  Microsoft::WRL::ComPtr<IDWriteFactory> factory;
+  CreateDWriteFactory(&factory);
+  CHECK(!!factory);
+  SetDirectWriteFactory(factory.Get());
+
+  // The skia call to create a new DirectWrite font manager instance can fail
+  // if we are unable to get the system font collection from the DirectWrite
+  // factory. The GetSystemFontCollection method in the IDWriteFactory
+  // interface fails with E_INVALIDARG on certain Windows 7 gold versions
+  // (6.1.7600.*).
+  sk_sp<SkFontMgr> direct_write_font_mgr =
+      SkFontMgr_New_DirectWrite(factory.Get());
+  int iteration = 0;
+  if (!direct_write_font_mgr &&
+      base::win::GetVersion() == base::win::Version::WIN7) {
+    // Windows (win7_rtm) may fail to map the service sections
+    // (crbug.com/956064).
+    constexpr int kMaxRetries = 5;
+    constexpr base::TimeDelta kRetrySleepTime = base::Microseconds(500);
+    while (iteration < kMaxRetries) {
+      base::PlatformThread::Sleep(kRetrySleepTime);
+      direct_write_font_mgr = SkFontMgr_New_DirectWrite(factory.Get());
+      if (direct_write_font_mgr)
+        break;
+      ++iteration;
+    }
+  }
+  if (!direct_write_font_mgr)
+    iteration = -1;
+  base::UmaHistogramSparse("DirectWrite.Fonts.Gfx.InitializeLoopCount",
+                           iteration);
+  // TODO(crbug.com/956064): Move to a CHECK when the cause of the crash is
+  // fixed and remove the if statement that fallback to GDI font manager.
+  DCHECK(!!direct_write_font_mgr);
+  if (!direct_write_font_mgr)
+    direct_write_font_mgr = SkFontMgr_New_GDI();
+
+  // Override the default skia font manager. This must be called before any
+  // use of the skia font manager is done (e.g. before any call to
+  // SkFontMgr::RefDefault()).
+  skia::OverrideDefaultSkFontMgr(std::move(direct_write_font_mgr));
+}
+
+IDWriteFactory* GetDirectWriteFactory() {
+  // Some unittests may access this accessor without any previous call to
+  // |InitializeDirectWrite|. A call to |InitializeDirectWrite| after this
+  // function being called is still invalid.
+  if (!g_direct_write_factory)
+    InitializeDirectWrite();
+  return g_direct_write_factory;
+}
+
+absl::optional<std::string> RetrieveLocalizedString(
+    IDWriteLocalizedStrings* names,
+    const std::string& locale) {
+  std::wstring locale_wide = base::UTF8ToWide(locale);
+
+  // If locale is empty, index 0 will be used. Otherwise, the locale name must
+  // be found and must exist.
+  UINT32 index = 0;
+  BOOL exists = false;
+  if (!locale.empty() &&
+      (FAILED(names->FindLocaleName(locale_wide.c_str(), &index, &exists)) ||
+       !exists)) {
+    return absl::nullopt;
+  }
+
+  // Get the string length.
+  UINT32 length = 0;
+  if (FAILED(names->GetStringLength(index, &length)))
+    return absl::nullopt;
+
+  // The output buffer length needs to be one larger to receive the NUL
+  // character.
+  std::wstring buffer;
+  buffer.resize(length + 1);
+  if (FAILED(names->GetString(index, &buffer[0], buffer.size())))
+    return absl::nullopt;
+
+  // Shrink the string to fit the actual length.
+  buffer.resize(length);
+
+  return base::WideToUTF8(buffer);
+}
+
+absl::optional<std::string> RetrieveLocalizedFontName(
+    base::StringPiece font_name,
+    const std::string& locale) {
+  Microsoft::WRL::ComPtr<IDWriteFactory> factory;
+  CreateDWriteFactory(&factory);
+
+  Microsoft::WRL::ComPtr<IDWriteFontCollection> font_collection;
+  if (FAILED(factory->GetSystemFontCollection(&font_collection))) {
+    return absl::nullopt;
+  }
+
+  UINT32 index = 0;
+  BOOL exists;
+  std::wstring font_name_wide = base::UTF8ToWide(font_name);
+  if (FAILED(font_collection->FindFamilyName(font_name_wide.c_str(), &index,
+                                             &exists)) ||
+      !exists) {
+    return absl::nullopt;
+  }
+
+  Microsoft::WRL::ComPtr<IDWriteFontFamily> font_family;
+  Microsoft::WRL::ComPtr<IDWriteLocalizedStrings> family_names;
+  if (FAILED(font_collection->GetFontFamily(index, &font_family)) ||
+      FAILED(font_family->GetFamilyNames(&family_names))) {
+    return absl::nullopt;
+  }
+
+  return RetrieveLocalizedString(family_names.Get(), locale);
+}
+
+}  // namespace win
+}  // namespace gfx
diff --git a/ui/gfx/win/direct_write.h b/ui/gfx/win/direct_write.h
new file mode 100644
index 0000000..2cbb4a5
--- /dev/null
+++ b/ui/gfx/win/direct_write.h
@@ -0,0 +1,40 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_DIRECT_WRITE_H_
+#define UI_GFX_WIN_DIRECT_WRITE_H_
+
+#include <dwrite.h>
+
+#include "base/strings/string_piece.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+namespace win {
+
+GFX_EXPORT void InitializeDirectWrite();
+
+// Creates a DirectWrite factory.
+GFX_EXPORT void CreateDWriteFactory(IDWriteFactory** factory);
+
+// Returns the global DirectWrite factory.
+GFX_EXPORT IDWriteFactory* GetDirectWriteFactory();
+
+// Retrieves the localized string for a given locale. If locale is empty,
+// retrieves the first element of |names|.
+GFX_EXPORT absl::optional<std::string> RetrieveLocalizedString(
+    IDWriteLocalizedStrings* names,
+    const std::string& locale);
+
+// Retrieves the localized font name for a given locale. If locale is empty,
+// retrieves the default native font name.
+GFX_EXPORT absl::optional<std::string> RetrieveLocalizedFontName(
+    base::StringPiece font_name,
+    const std::string& locale);
+
+}  // namespace win
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_DIRECT_WRITE_H_
diff --git a/ui/gfx/win/direct_write_unittest.cc b/ui/gfx/win/direct_write_unittest.cc
new file mode 100644
index 0000000..1c136c8
--- /dev/null
+++ b/ui/gfx/win/direct_write_unittest.cc
@@ -0,0 +1,28 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/win/direct_write.h"
+
+#include "base/i18n/rtl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+TEST(DirectWrite, RetrieveLocalizedFontName) {
+  // Retrieve the en-US localized names.
+  EXPECT_EQ(gfx::win::RetrieveLocalizedFontName("MS Gothic", "en-US"),
+            "MS Gothic");
+  EXPECT_EQ(gfx::win::RetrieveLocalizedFontName("Malgun Gothic", "en-US"),
+            "Malgun Gothic");
+
+  // Retrieve the localized names.
+  EXPECT_EQ(gfx::win::RetrieveLocalizedFontName("MS Gothic", "ja-JP"),
+            "ＭＳ ゴシック");
+  EXPECT_EQ(gfx::win::RetrieveLocalizedFontName("Malgun Gothic", "ko-KR"),
+            "맑은 고딕");
+
+  // Retrieve the default font name.
+  EXPECT_EQ(gfx::win::RetrieveLocalizedFontName("ＭＳ ゴシック", ""),
+            "MS Gothic");
+  EXPECT_EQ(gfx::win::RetrieveLocalizedFontName("맑은 고딕", ""),
+            "Malgun Gothic");
+}
diff --git a/ui/gfx/win/hwnd_util.cc b/ui/gfx/win/hwnd_util.cc
new file mode 100644
index 0000000..286b766
--- /dev/null
+++ b/ui/gfx/win/hwnd_util.cc
@@ -0,0 +1,210 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/win/hwnd_util.h"
+
+#include <windows.h>
+
+#include "base/debug/gdi_debug_util_win.h"
+#include "base/logging.h"
+#include "base/notreached.h"
+#include "base/strings/string_util.h"
+#include "base/win/win_util.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace gfx {
+
+namespace {
+
+// Adjust the window to fit.
+void AdjustWindowToFit(HWND hwnd, const RECT& bounds, bool fit_to_monitor) {
+  if (fit_to_monitor) {
+    // Get the monitor.
+    HMONITOR hmon = MonitorFromRect(&bounds, MONITOR_DEFAULTTONEAREST);
+    if (hmon) {
+      MONITORINFO mi;
+      mi.cbSize = sizeof(mi);
+      GetMonitorInfo(hmon, &mi);
+      Rect window_rect(bounds);
+      Rect monitor_rect(mi.rcWork);
+      Rect new_window_rect = window_rect;
+      new_window_rect.AdjustToFit(monitor_rect);
+      if (new_window_rect != window_rect) {
+        // Window doesn't fit on monitor, move and possibly resize.
+        SetWindowPos(hwnd, 0, new_window_rect.x(), new_window_rect.y(),
+                     new_window_rect.width(), new_window_rect.height(),
+                     SWP_NOACTIVATE | SWP_NOZORDER);
+        return;
+      }
+      // Else fall through.
+    } else {
+      NOTREACHED() << "Unable to find default monitor";
+      // Fall through.
+    }
+  }  // Else fall through.
+
+  // The window is not being fit to monitor, or the window fits on the monitor
+  // as is, or we have no monitor info; reset the bounds.
+  ::SetWindowPos(hwnd, 0, bounds.left, bounds.top,
+                 bounds.right - bounds.left, bounds.bottom - bounds.top,
+                 SWP_NOACTIVATE | SWP_NOZORDER);
+}
+
+// Don't inline these functions so they show up in crash reports.
+
+NOINLINE void CrashAccessDenied(DWORD last_error) {
+  LOG(FATAL) << last_error;
+}
+
+// Crash isn't one of the ones we commonly see.
+NOINLINE void CrashOther(DWORD last_error) {
+  LOG(FATAL) << last_error;
+}
+
+}  // namespace
+
+std::wstring GetClassName(HWND window) {
+  // GetClassNameW will return a truncated result (properly null terminated) if
+  // the given buffer is not large enough.  So, it is not possible to determine
+  // that we got the entire class name if the result is exactly equal to the
+  // size of the buffer minus one.
+  DWORD buffer_size = MAX_PATH;
+  while (true) {
+    std::wstring output;
+    DWORD size_ret = GetClassNameW(
+        window, base::WriteInto(&output, buffer_size), buffer_size);
+    if (size_ret == 0)
+      break;
+    if (size_ret < (buffer_size - 1)) {
+      output.resize(size_ret);
+      return output;
+    }
+    buffer_size *= 2;
+  }
+  return std::wstring();  // error
+}
+
+#pragma warning(push)
+#pragma warning(disable:4312 4244)
+
+WNDPROC SetWindowProc(HWND hwnd, WNDPROC proc) {
+  // The reason we don't return the SetwindowLongPtr() value is that it returns
+  // the orignal window procedure and not the current one. I don't know if it is
+  // a bug or an intended feature.
+  WNDPROC oldwindow_proc =
+      reinterpret_cast<WNDPROC>(GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+  SetWindowLongPtr(hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(proc));
+  return oldwindow_proc;
+}
+
+void* SetWindowUserData(HWND hwnd, void* user_data) {
+  return
+      reinterpret_cast<void*>(SetWindowLongPtr(hwnd, GWLP_USERDATA,
+          reinterpret_cast<LONG_PTR>(user_data)));
+}
+
+void* GetWindowUserData(HWND hwnd) {
+  DWORD process_id = 0;
+  GetWindowThreadProcessId(hwnd, &process_id);
+  // A window outside the current process needs to be ignored.
+  if (process_id != ::GetCurrentProcessId())
+    return NULL;
+  return reinterpret_cast<void*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
+}
+
+#pragma warning(pop)
+
+bool DoesWindowBelongToActiveWindow(HWND window) {
+  DCHECK(window);
+  HWND top_window = ::GetAncestor(window, GA_ROOT);
+  if (!top_window)
+    return false;
+
+  HWND active_top_window = ::GetAncestor(::GetForegroundWindow(), GA_ROOT);
+  return (top_window == active_top_window);
+}
+
+void CenterAndSizeWindow(HWND parent,
+                         HWND window,
+                         const Size& pref) {
+  DCHECK(window && pref.width() > 0 && pref.height() > 0);
+
+  // Calculate the ideal bounds.
+  RECT window_bounds;
+  RECT center_bounds = {0};
+  if (parent) {
+    // If there is a parent, center over the parents bounds.
+    ::GetWindowRect(parent, &center_bounds);
+  }
+
+  if (::IsRectEmpty(&center_bounds)) {
+    // No parent or no parent rect. Center over the monitor the window is on.
+    HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST);
+    if (monitor) {
+      MONITORINFO mi = {0};
+      mi.cbSize = sizeof(mi);
+      GetMonitorInfo(monitor, &mi);
+      center_bounds = mi.rcWork;
+    } else {
+      NOTREACHED() << "Unable to get default monitor";
+    }
+  }
+
+  window_bounds.left = center_bounds.left;
+  if (pref.width() < (center_bounds.right - center_bounds.left)) {
+    window_bounds.left +=
+        (center_bounds.right - center_bounds.left - pref.width()) / 2;
+  }
+  window_bounds.right = window_bounds.left + pref.width();
+
+  window_bounds.top = center_bounds.top;
+  if (pref.height() < (center_bounds.bottom - center_bounds.top)) {
+    window_bounds.top +=
+        (center_bounds.bottom - center_bounds.top - pref.height()) / 2;
+  }
+  window_bounds.bottom = window_bounds.top + pref.height();
+
+  // If we're centering a child window, we are positioning in client
+  // coordinates, and as such we need to offset the target rectangle by the
+  // position of the parent window.
+  if (::GetWindowLong(window, GWL_STYLE) & WS_CHILD) {
+    DCHECK(parent && ::GetParent(window) == parent);
+    POINT topleft = { window_bounds.left, window_bounds.top };
+    ::MapWindowPoints(HWND_DESKTOP, parent, &topleft, 1);
+    window_bounds.left = topleft.x;
+    window_bounds.top = topleft.y;
+    window_bounds.right = window_bounds.left + pref.width();
+    window_bounds.bottom = window_bounds.top + pref.height();
+  }
+
+  AdjustWindowToFit(window, window_bounds, !parent);
+}
+
+void CheckWindowCreated(HWND hwnd, DWORD last_error) {
+  if (!hwnd) {
+    switch (last_error) {
+      case ERROR_NOT_ENOUGH_MEMORY:
+        base::debug::CollectGDIUsageAndDie();
+        break;
+      case ERROR_ACCESS_DENIED:
+        CrashAccessDenied(last_error);
+        break;
+      default:
+        CrashOther(last_error);
+        break;
+    }
+    LOG(FATAL) << last_error;
+  }
+}
+
+extern "C" {
+  typedef HWND (*RootWindow)();
+}
+
+HWND GetWindowToParentTo(bool get_real_hwnd) {
+  return get_real_hwnd ? ::GetDesktopWindow() : HWND_DESKTOP;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/win/hwnd_util.h b/ui/gfx/win/hwnd_util.h
new file mode 100644
index 0000000..d4d8eaf
--- /dev/null
+++ b/ui/gfx/win/hwnd_util.h
@@ -0,0 +1,50 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_HWND_UTIL_H_
+#define UI_GFX_WIN_HWND_UTIL_H_
+
+#include <windows.h>
+
+#include <string>
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+class Size;
+
+// A version of the GetClassNameW API that returns the class name in an
+// std::wstring. An empty result indicates a failure to get the class name.
+GFX_EXPORT std::wstring GetClassName(HWND hwnd);
+
+// Useful for subclassing a HWND.  Returns the previous window procedure.
+GFX_EXPORT WNDPROC SetWindowProc(HWND hwnd, WNDPROC wndproc);
+
+// Pointer-friendly wrappers around Get/SetWindowLong(..., GWLP_USERDATA, ...)
+// Returns the previously set value.
+GFX_EXPORT void* SetWindowUserData(HWND hwnd, void* user_data);
+GFX_EXPORT void* GetWindowUserData(HWND hwnd);
+
+// Returns true if the specified window is the current active top window or one
+// of its children.
+GFX_EXPORT bool DoesWindowBelongToActiveWindow(HWND window);
+
+// Sizes the window to have a window size of |pref|, then centers the window
+// over |parent|, ensuring the window fits on screen.
+GFX_EXPORT void CenterAndSizeWindow(HWND parent,
+                                    HWND window,
+                                    const gfx::Size& pref);
+
+// If |hwnd| is nullptr logs various thing and CHECKs. |last_error| must contain
+// the result of ::GetLastError(), called immediately after CreateWindow().
+GFX_EXPORT void CheckWindowCreated(HWND hwnd, DWORD last_error);
+
+// Returns the window you can use to parent a top level window.
+// Note that in some cases we create child windows not parented to its final
+// container so in those cases you should pass true in |get_real_hwnd|.
+GFX_EXPORT HWND GetWindowToParentTo(bool get_real_hwnd);
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_HWND_UTIL_H_
diff --git a/ui/gfx/win/msg_util.h b/ui/gfx/win/msg_util.h
new file mode 100644
index 0000000..7c6b42b
--- /dev/null
+++ b/ui/gfx/win/msg_util.h
@@ -0,0 +1,2261 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_MSG_UTIL_H_
+#define UI_GFX_WIN_MSG_UTIL_H_
+
+#include "base/memory/weak_ptr.h"
+#include "base/notreached.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/size.h"
+
+// Based on WTL version 8.0 atlcrack.h
+
+// This differs from the original atlcrack.h by removing usage of CPoint,
+// CSize, etc.
+
+///////////////////////////////////////////////////////////////////////////////
+// Message map macro for cracked handlers
+
+// Note about message maps with cracked handlers:
+// For ATL 3.0, a message map using cracked handlers MUST use
+// CR_BEGIN_MSG_MAP_EX. For ATL 7.0 or higher, you can use CR_BEGIN_MSG_MAP for
+// CWindowImpl/CDialogImpl derived classes, but must use CR_BEGIN_MSG_MAP_EX for
+// classes that don't derive from CWindowImpl/CDialogImpl.
+// Classes using the CR_BEGIN_MSG_MAP_EX/CR_END_MSG_MAP set of macros must
+// also include a CR_MSG_MAP_CLASS_DECLARATIONS macro after all members in
+// the class definition since the macros add a
+// base::WeakPtrFactory which is only allowed if last in the class.
+
+#define CR_BEGIN_MSG_MAP_EX(theClass)                                       \
+ public:                                                                    \
+  /* "handled" management for cracked handlers */                           \
+  void SetMsgHandled(BOOL handled) { msg_handled_ = handled; }              \
+  BOOL ProcessWindowMessage(HWND hwnd, UINT msg, WPARAM w_param,            \
+                            LPARAM l_param, LRESULT& l_result,              \
+                            DWORD msg_map_id = 0) override {                \
+    auto ref(theClass::msg_handler_weak_factory_.GetWeakPtr());             \
+    BOOL old_msg_handled = msg_handled_;                                    \
+    BOOL ret = _ProcessWindowMessage(hwnd, msg, w_param, l_param, l_result, \
+                                     msg_map_id);                           \
+    if (ref.get())                                                          \
+      msg_handled_ = old_msg_handled;                                       \
+    return ret;                                                             \
+  }                                                                         \
+  BOOL _ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam,           \
+                             LPARAM lParam, LRESULT& lResult,               \
+                             DWORD dwMsgMapID) {                            \
+    auto ref(theClass::msg_handler_weak_factory_.GetWeakPtr());             \
+    BOOL bHandled = TRUE;                                                   \
+    hWnd;                                                                   \
+    uMsg;                                                                   \
+    wParam;                                                                 \
+    lParam;                                                                 \
+    lResult;                                                                \
+    bHandled;                                                               \
+    switch (dwMsgMapID) {                                                   \
+      case 0:
+
+// Replacement for atlwin.h's END_MSG_MAP for removing ATL usage.
+#define CR_END_MSG_MAP()                                      \
+  break;                                                      \
+  default:                                                    \
+    NOTREACHED() << "Invalid message map ID: " << dwMsgMapID; \
+    break;                                                    \
+    }                                                         \
+    return FALSE;                                             \
+    }
+
+// This macro must be last in the class since it contains a
+// base::WeakPtrFactory which must be last in the class.
+#define CR_MSG_MAP_CLASS_DECLARATIONS(theClass) \
+ private:                                       \
+  BOOL msg_handled_{false};                     \
+  base::WeakPtrFactory<theClass> msg_handler_weak_factory_{this};
+
+#define CR_GET_X_LPARAM(lParam) ((int)(short)LOWORD(lParam))
+#define CR_GET_Y_LPARAM(lParam) ((int)(short)HIWORD(lParam))
+
+///////////////////////////////////////////////////////////////////////////////
+// Standard Windows message macros
+
+// int OnCreate(LPCREATESTRUCT lpCreateStruct)
+#define CR_MSG_WM_CREATE(func)                       \
+  if (uMsg == WM_CREATE) {                           \
+    SetMsgHandled(TRUE);                             \
+    lResult = (LRESULT)func((LPCREATESTRUCT)lParam); \
+    if (!ref.get() || msg_handled_)                  \
+      return TRUE;                                   \
+  }
+
+// BOOL OnInitDialog(CWindow wndFocus, LPARAM lInitParam)
+#define CR_MSG_WM_INITDIALOG(func)                 \
+  if (uMsg == WM_INITDIALOG) {                     \
+    SetMsgHandled(TRUE);                           \
+    lResult = (LRESULT)func((HWND)wParam, lParam); \
+    if (!ref.get() || msg_handled_)                \
+      return TRUE;                                 \
+  }
+
+// BOOL OnCopyData(CWindow wnd, PCOPYDATASTRUCT pCopyDataStruct)
+#define CR_MSG_WM_COPYDATA(func)                                    \
+  if (uMsg == WM_COPYDATA) {                                        \
+    SetMsgHandled(TRUE);                                            \
+    lResult = (LRESULT)func((HWND)wParam, (PCOPYDATASTRUCT)lParam); \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// void OnDestroy()
+#define CR_MSG_WM_DESTROY(func)     \
+  if (uMsg == WM_DESTROY) {         \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnMove(CPoint ptPos)
+#define CR_MSG_WM_MOVE(func)                                            \
+  if (uMsg == WM_MOVE) {                                                \
+    SetMsgHandled(TRUE);                                                \
+    func(gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnSize(UINT nType, gfx::Size size)
+#define CR_MSG_WM_SIZE(func)                                           \
+  if (uMsg == WM_SIZE) {                                               \
+    SetMsgHandled(TRUE);                                               \
+    func((UINT)wParam,                                                 \
+         gfx::Size(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                       \
+    if (!ref.get() || msg_handled_)                                    \
+      return TRUE;                                                     \
+  }
+
+// void OnActivate(UINT nState, BOOL bMinimized, CWindow wndOther)
+#define CR_MSG_WM_ACTIVATE(func)                                    \
+  if (uMsg == WM_ACTIVATE) {                                        \
+    SetMsgHandled(TRUE);                                            \
+    func((UINT)LOWORD(wParam), (BOOL)HIWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                    \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// void OnSetFocus(CWindow wndOld)
+#define CR_MSG_WM_SETFOCUS(func)    \
+  if (uMsg == WM_SETFOCUS) {        \
+    SetMsgHandled(TRUE);            \
+    func((HWND)wParam);             \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnKillFocus(CWindow wndFocus)
+#define CR_MSG_WM_KILLFOCUS(func)   \
+  if (uMsg == WM_KILLFOCUS) {       \
+    SetMsgHandled(TRUE);            \
+    func((HWND)wParam);             \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnEnable(BOOL bEnable)
+#define CR_MSG_WM_ENABLE(func)      \
+  if (uMsg == WM_ENABLE) {          \
+    SetMsgHandled(TRUE);            \
+    func((BOOL)wParam);             \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnPaint(CDCHandle dc)
+#define CR_MSG_WM_PAINT(func)       \
+  if (uMsg == WM_PAINT) {           \
+    SetMsgHandled(TRUE);            \
+    func((HDC)wParam);              \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnClose()
+#define CR_MSG_WM_CLOSE(func)       \
+  if (uMsg == WM_CLOSE) {           \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// BOOL OnQueryEndSession(UINT nSource, UINT uLogOff)
+#define CR_MSG_WM_QUERYENDSESSION(func)                  \
+  if (uMsg == WM_QUERYENDSESSION) {                      \
+    SetMsgHandled(TRUE);                                 \
+    lResult = (LRESULT)func((UINT)wParam, (UINT)lParam); \
+    if (!ref.get() || msg_handled_)                      \
+      return TRUE;                                       \
+  }
+
+// BOOL OnQueryOpen()
+#define CR_MSG_WM_QUERYOPEN(func)   \
+  if (uMsg == WM_QUERYOPEN) {       \
+    SetMsgHandled(TRUE);            \
+    lResult = (LRESULT)func();      \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// BOOL OnEraseBkgnd(CDCHandle dc)
+#define CR_MSG_WM_ERASEBKGND(func)        \
+  if (uMsg == WM_ERASEBKGND) {            \
+    SetMsgHandled(TRUE);                  \
+    lResult = (LRESULT)func((HDC)wParam); \
+    if (!ref.get() || msg_handled_)       \
+      return TRUE;                        \
+  }
+
+// void OnSysColorChange()
+#define CR_MSG_WM_SYSCOLORCHANGE(func) \
+  if (uMsg == WM_SYSCOLORCHANGE) {     \
+    SetMsgHandled(TRUE);               \
+    func();                            \
+    lResult = 0;                       \
+    if (!ref.get() || msg_handled_)    \
+      return TRUE;                     \
+  }
+
+// void OnEndSession(BOOL bEnding, UINT uLogOff)
+#define CR_MSG_WM_ENDSESSION(func)    \
+  if (uMsg == WM_ENDSESSION) {        \
+    SetMsgHandled(TRUE);              \
+    func((BOOL)wParam, (UINT)lParam); \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnShowWindow(BOOL bShow, UINT nStatus)
+#define CR_MSG_WM_SHOWWINDOW(func)   \
+  if (uMsg == WM_SHOWWINDOW) {       \
+    SetMsgHandled(TRUE);             \
+    func((BOOL)wParam, (int)lParam); \
+    lResult = 0;                     \
+    if (!ref.get() || msg_handled_)  \
+      return TRUE;                   \
+  }
+
+// HBRUSH OnCtlColorEdit(CDCHandle dc, CEdit edit)
+#define CR_MSG_WM_CTLCOLOREDIT(func)                    \
+  if (uMsg == WM_CTLCOLOREDIT) {                        \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnCtlColorListBox(CDCHandle dc, CListBox listBox)
+#define CR_MSG_WM_CTLCOLORLISTBOX(func)                 \
+  if (uMsg == WM_CTLCOLORLISTBOX) {                     \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnCtlColorBtn(CDCHandle dc, CButton button)
+#define CR_MSG_WM_CTLCOLORBTN(func)                     \
+  if (uMsg == WM_CTLCOLORBTN) {                         \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnCtlColorDlg(CDCHandle dc, CWindow wnd)
+#define CR_MSG_WM_CTLCOLORDLG(func)                     \
+  if (uMsg == WM_CTLCOLORDLG) {                         \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnCtlColorScrollBar(CDCHandle dc, CScrollBar scrollBar)
+#define CR_MSG_WM_CTLCOLORSCROLLBAR(func)               \
+  if (uMsg == WM_CTLCOLORSCROLLBAR) {                   \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnCtlColorStatic(CDCHandle dc, CStatic wndStatic)
+#define CR_MSG_WM_CTLCOLORSTATIC(func)                  \
+  if (uMsg == WM_CTLCOLORSTATIC) {                      \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// void OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
+#define CR_MSG_WM_SETTINGCHANGE(func)    \
+  if (uMsg == WM_SETTINGCHANGE) {        \
+    SetMsgHandled(TRUE);                 \
+    func((UINT)wParam, (LPCTSTR)lParam); \
+    lResult = 0;                         \
+    if (!ref.get() || msg_handled_)      \
+      return TRUE;                       \
+  }
+
+// void OnDevModeChange(LPCTSTR lpDeviceName)
+#define CR_MSG_WM_DEVMODECHANGE(func) \
+  if (uMsg == WM_DEVMODECHANGE) {     \
+    SetMsgHandled(TRUE);              \
+    func((LPCTSTR)lParam);            \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnActivateApp(BOOL bActive, DWORD dwThreadID)
+#define CR_MSG_WM_ACTIVATEAPP(func)    \
+  if (uMsg == WM_ACTIVATEAPP) {        \
+    SetMsgHandled(TRUE);               \
+    func((BOOL)wParam, (DWORD)lParam); \
+    lResult = 0;                       \
+    if (!ref.get() || msg_handled_)    \
+      return TRUE;                     \
+  }
+
+// void OnFontChange()
+#define CR_MSG_WM_FONTCHANGE(func)  \
+  if (uMsg == WM_FONTCHANGE) {      \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnTimeChange()
+#define CR_MSG_WM_TIMECHANGE(func)  \
+  if (uMsg == WM_TIMECHANGE) {      \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnCancelMode()
+#define CR_MSG_WM_CANCELMODE(func)  \
+  if (uMsg == WM_CANCELMODE) {      \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// BOOL OnSetCursor(CWindow wnd, UINT nHitTest, UINT message)
+#define CR_MSG_WM_SETCURSOR(func)                               \
+  if (uMsg == WM_SETCURSOR) {                                   \
+    SetMsgHandled(TRUE);                                        \
+    lResult = (LRESULT)func((HWND)wParam, (UINT)LOWORD(lParam), \
+                            (UINT)HIWORD(lParam));              \
+    if (!ref.get() || msg_handled_)                             \
+      return TRUE;                                              \
+  }
+
+// int OnMouseActivate(CWindow wndTopLevel, UINT nHitTest, UINT message)
+#define CR_MSG_WM_MOUSEACTIVATE(func)                           \
+  if (uMsg == WM_MOUSEACTIVATE) {                               \
+    SetMsgHandled(TRUE);                                        \
+    lResult = (LRESULT)func((HWND)wParam, (UINT)LOWORD(lParam), \
+                            (UINT)HIWORD(lParam));              \
+    if (!ref.get() || msg_handled_)                             \
+      return TRUE;                                              \
+  }
+
+// void OnChildActivate()
+#define CR_MSG_WM_CHILDACTIVATE(func) \
+  if (uMsg == WM_CHILDACTIVATE) {     \
+    SetMsgHandled(TRUE);              \
+    func();                           \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnGetMinMaxInfo(LPMINMAXINFO lpMMI)
+#define CR_MSG_WM_GETMINMAXINFO(func) \
+  if (uMsg == WM_GETMINMAXINFO) {     \
+    SetMsgHandled(TRUE);              \
+    func((LPMINMAXINFO)lParam);       \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnIconEraseBkgnd(CDCHandle dc)
+#define CR_MSG_WM_ICONERASEBKGND(func) \
+  if (uMsg == WM_ICONERASEBKGND) {     \
+    SetMsgHandled(TRUE);               \
+    func((HDC)wParam);                 \
+    lResult = 0;                       \
+    if (!ref.get() || msg_handled_)    \
+      return TRUE;                     \
+  }
+
+// void OnSpoolerStatus(UINT nStatus, UINT nJobs)
+#define CR_MSG_WM_SPOOLERSTATUS(func)         \
+  if (uMsg == WM_SPOOLERSTATUS) {             \
+    SetMsgHandled(TRUE);                      \
+    func((UINT)wParam, (UINT)LOWORD(lParam)); \
+    lResult = 0;                              \
+    if (!ref.get() || msg_handled_)           \
+      return TRUE;                            \
+  }
+
+// void OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
+#define CR_MSG_WM_DRAWITEM(func)                  \
+  if (uMsg == WM_DRAWITEM) {                      \
+    SetMsgHandled(TRUE);                          \
+    func((UINT)wParam, (LPDRAWITEMSTRUCT)lParam); \
+    lResult = TRUE;                               \
+    if (!ref.get() || msg_handled_)               \
+      return TRUE;                                \
+  }
+
+// void OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct)
+#define CR_MSG_WM_MEASUREITEM(func)                  \
+  if (uMsg == WM_MEASUREITEM) {                      \
+    SetMsgHandled(TRUE);                             \
+    func((UINT)wParam, (LPMEASUREITEMSTRUCT)lParam); \
+    lResult = TRUE;                                  \
+    if (!ref.get() || msg_handled_)                  \
+      return TRUE;                                   \
+  }
+
+// void OnDeleteItem(int nIDCtl, LPDELETEITEMSTRUCT lpDeleteItemStruct)
+#define CR_MSG_WM_DELETEITEM(func)                  \
+  if (uMsg == WM_DELETEITEM) {                      \
+    SetMsgHandled(TRUE);                            \
+    func((UINT)wParam, (LPDELETEITEMSTRUCT)lParam); \
+    lResult = TRUE;                                 \
+    if (!ref.get() || msg_handled_)                 \
+      return TRUE;                                  \
+  }
+
+// int OnCharToItem(UINT nChar, UINT nIndex, CListBox listBox)
+#define CR_MSG_WM_CHARTOITEM(func)                                      \
+  if (uMsg == WM_CHARTOITEM) {                                          \
+    SetMsgHandled(TRUE);                                                \
+    lResult = (LRESULT)func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), \
+                            (HWND)lParam);                              \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// int OnVKeyToItem(UINT nKey, UINT nIndex, CListBox listBox)
+#define CR_MSG_WM_VKEYTOITEM(func)                                      \
+  if (uMsg == WM_VKEYTOITEM) {                                          \
+    SetMsgHandled(TRUE);                                                \
+    lResult = (LRESULT)func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), \
+                            (HWND)lParam);                              \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// HCURSOR OnQueryDragIcon()
+#define CR_MSG_WM_QUERYDRAGICON(func) \
+  if (uMsg == WM_QUERYDRAGICON) {     \
+    SetMsgHandled(TRUE);              \
+    lResult = (LRESULT)func();        \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// int OnCompareItem(int nIDCtl, LPCOMPAREITEMSTRUCT lpCompareItemStruct)
+#define CR_MSG_WM_COMPAREITEM(func)                                     \
+  if (uMsg == WM_COMPAREITEM) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    lResult = (LRESULT)func((UINT)wParam, (LPCOMPAREITEMSTRUCT)lParam); \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnCompacting(UINT nCpuTime)
+#define CR_MSG_WM_COMPACTING(func)  \
+  if (uMsg == WM_COMPACTING) {      \
+    SetMsgHandled(TRUE);            \
+    func((UINT)wParam);             \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// BOOL OnNcCreate(LPCREATESTRUCT lpCreateStruct)
+#define CR_MSG_WM_NCCREATE(func)                     \
+  if (uMsg == WM_NCCREATE) {                         \
+    SetMsgHandled(TRUE);                             \
+    lResult = (LRESULT)func((LPCREATESTRUCT)lParam); \
+    if (!ref.get() || msg_handled_)                  \
+      return TRUE;                                   \
+  }
+
+// void OnNcDestroy()
+#define CR_MSG_WM_NCDESTROY(func)   \
+  if (uMsg == WM_NCDESTROY) {       \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// LRESULT OnNcCalcSize(BOOL bCalcValidRects, LPARAM lParam)
+#define CR_MSG_WM_NCCALCSIZE(func)        \
+  if (uMsg == WM_NCCALCSIZE) {            \
+    SetMsgHandled(TRUE);                  \
+    lResult = func((BOOL)wParam, lParam); \
+    if (!ref.get() || msg_handled_)       \
+      return TRUE;                        \
+  }
+
+// UINT OnNcHitTest(gfx::Point point)
+#define CR_MSG_WM_NCHITTEST(func)                                      \
+  if (uMsg == WM_NCHITTEST) {                                          \
+    SetMsgHandled(TRUE);                                               \
+    lResult = (LRESULT)func(                                           \
+        gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    if (!ref.get() || msg_handled_)                                    \
+      return TRUE;                                                     \
+  }
+
+// void OnNcPaint(CRgn rgn)
+#define CR_MSG_WM_NCPAINT(func)     \
+  if (uMsg == WM_NCPAINT) {         \
+    SetMsgHandled(TRUE);            \
+    func((HRGN)wParam);             \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// BOOL OnNcActivate(BOOL bActive)
+#define CR_MSG_WM_NCACTIVATE(func)         \
+  if (uMsg == WM_NCACTIVATE) {             \
+    SetMsgHandled(TRUE);                   \
+    lResult = (LRESULT)func((BOOL)wParam); \
+    if (!ref.get() || msg_handled_)        \
+      return TRUE;                         \
+  }
+
+// UINT OnGetDlgCode(LPMSG lpMsg)
+#define CR_MSG_WM_GETDLGCODE(func)          \
+  if (uMsg == WM_GETDLGCODE) {              \
+    SetMsgHandled(TRUE);                    \
+    lResult = (LRESULT)func((LPMSG)lParam); \
+    if (!ref.get() || msg_handled_)         \
+      return TRUE;                          \
+  }
+
+// void OnNcMouseMove(UINT nHitTest, gfx::Point point)
+#define CR_MSG_WM_NCMOUSEMOVE(func)                                     \
+  if (uMsg == WM_NCMOUSEMOVE) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcLButtonDown(UINT nHitTest, gfx::Point point)
+#define CR_MSG_WM_NCLBUTTONDOWN(func)                                   \
+  if (uMsg == WM_NCLBUTTONDOWN) {                                       \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcLButtonUp(UINT nHitTest, gfx::Point point)
+#define CR_MSG_WM_NCLBUTTONUP(func)                                     \
+  if (uMsg == WM_NCLBUTTONUP) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcLButtonDblClk(UINT nHitTest, gfx::Point point)
+#define CR_MSG_WM_NCLBUTTONDBLCLK(func)                                 \
+  if (uMsg == WM_NCLBUTTONDBLCLK) {                                     \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcRButtonDown(UINT nHitTest, gfx::Point point)
+#define CR_MSG_WM_NCRBUTTONDOWN(func)                                   \
+  if (uMsg == WM_NCRBUTTONDOWN) {                                       \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcRButtonUp(UINT nHitTest, gfx::Point point)
+#define CR_MSG_WM_NCRBUTTONUP(func)                                     \
+  if (uMsg == WM_NCRBUTTONUP) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcRButtonDblClk(UINT nHitTest, CPoint point)
+#define CR_MSG_WM_NCRBUTTONDBLCLK(func)                                 \
+  if (uMsg == WM_NCRBUTTONDBLCLK) {                                     \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcMButtonDown(UINT nHitTest, CPoint point)
+#define CR_MSG_WM_NCMBUTTONDOWN(func)                                   \
+  if (uMsg == WM_NCMBUTTONDOWN) {                                       \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcMButtonUp(UINT nHitTest, CPoint point)
+#define CR_MSG_WM_NCMBUTTONUP(func)                                     \
+  if (uMsg == WM_NCMBUTTONUP) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNcMButtonDblClk(UINT nHitTest, CPoint point)
+#define CR_MSG_WM_NCMBUTTONDBLCLK(func)                                 \
+  if (uMsg == WM_NCMBUTTONDBLCLK) {                                     \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_KEYDOWN(func)                \
+  if (uMsg == WM_KEYDOWN) {                    \
+    SetMsgHandled(TRUE);                       \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF, \
+         (UINT)((lParam & 0xFFFF0000) >> 16)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_KEYUP(func)                  \
+  if (uMsg == WM_KEYUP) {                      \
+    SetMsgHandled(TRUE);                       \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF, \
+         (UINT)((lParam & 0xFFFF0000) >> 16)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_CHAR(func)                   \
+  if (uMsg == WM_CHAR) {                       \
+    SetMsgHandled(TRUE);                       \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF, \
+         (UINT)((lParam & 0xFFFF0000) >> 16)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnDeadChar(UINT nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_DEADCHAR(func)               \
+  if (uMsg == WM_DEADCHAR) {                   \
+    SetMsgHandled(TRUE);                       \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF, \
+         (UINT)((lParam & 0xFFFF0000) >> 16)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_SYSKEYDOWN(func)             \
+  if (uMsg == WM_SYSKEYDOWN) {                 \
+    SetMsgHandled(TRUE);                       \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF, \
+         (UINT)((lParam & 0xFFFF0000) >> 16)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnSysKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_SYSKEYUP(func)               \
+  if (uMsg == WM_SYSKEYUP) {                   \
+    SetMsgHandled(TRUE);                       \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF, \
+         (UINT)((lParam & 0xFFFF0000) >> 16)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnSysChar(UINT nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_SYSCHAR(func)                \
+  if (uMsg == WM_SYSCHAR) {                    \
+    SetMsgHandled(TRUE);                       \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF, \
+         (UINT)((lParam & 0xFFFF0000) >> 16)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnSysDeadChar(UINT nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_SYSDEADCHAR(func)            \
+  if (uMsg == WM_SYSDEADCHAR) {                \
+    SetMsgHandled(TRUE);                       \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF, \
+         (UINT)((lParam & 0xFFFF0000) >> 16)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnSysCommand(UINT nID, LPARAM lParam)
+#define CR_MSG_WM_SYSCOMMAND(func)                                      \
+  if (uMsg == WM_SYSCOMMAND) {                                          \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnTCard(UINT idAction, DWORD dwActionData)
+#define CR_MSG_WM_TCARD(func)          \
+  if (uMsg == WM_TCARD) {              \
+    SetMsgHandled(TRUE);               \
+    func((UINT)wParam, (DWORD)lParam); \
+    lResult = 0;                       \
+    if (!ref.get() || msg_handled_)    \
+      return TRUE;                     \
+  }
+
+// void OnTimer(UINT_PTR nIDEvent)
+#define CR_MSG_WM_TIMER(func)       \
+  if (uMsg == WM_TIMER) {           \
+    SetMsgHandled(TRUE);            \
+    func((UINT_PTR)wParam);         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
+#define CR_MSG_WM_HSCROLL(func)                                     \
+  if (uMsg == WM_HSCROLL) {                                         \
+    SetMsgHandled(TRUE);                                            \
+    func((int)LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                    \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
+#define CR_MSG_WM_VSCROLL(func)                                     \
+  if (uMsg == WM_VSCROLL) {                                         \
+    SetMsgHandled(TRUE);                                            \
+    func((int)LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                    \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// void OnInitMenu(CMenu menu)
+#define CR_MSG_WM_INITMENU(func)    \
+  if (uMsg == WM_INITMENU) {        \
+    SetMsgHandled(TRUE);            \
+    func((HMENU)wParam);            \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnInitMenuPopup(CMenu menuPopup, UINT nIndex, BOOL bSysMenu)
+#define CR_MSG_WM_INITMENUPOPUP(func)                                \
+  if (uMsg == WM_INITMENUPOPUP) {                                    \
+    SetMsgHandled(TRUE);                                             \
+    func((HMENU)wParam, (UINT)LOWORD(lParam), (BOOL)HIWORD(lParam)); \
+    lResult = 0;                                                     \
+    if (!ref.get() || msg_handled_)                                  \
+      return TRUE;                                                   \
+  }
+
+// void OnMenuSelect(UINT nItemID, UINT nFlags, CMenu menu)
+#define CR_MSG_WM_MENUSELECT(func)                                   \
+  if (uMsg == WM_MENUSELECT) {                                       \
+    SetMsgHandled(TRUE);                                             \
+    func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), (HMENU)lParam); \
+    lResult = 0;                                                     \
+    if (!ref.get() || msg_handled_)                                  \
+      return TRUE;                                                   \
+  }
+
+// LRESULT OnMenuChar(UINT nChar, UINT nFlags, CMenu menu)
+#define CR_MSG_WM_MENUCHAR(func)                                          \
+  if (uMsg == WM_MENUCHAR) {                                              \
+    SetMsgHandled(TRUE);                                                  \
+    lResult =                                                             \
+        func((TCHAR)LOWORD(wParam), (UINT)HIWORD(wParam), (HMENU)lParam); \
+    if (!ref.get() || msg_handled_)                                       \
+      return TRUE;                                                        \
+  }
+
+// LRESULT OnNotify(int idCtrl, LPNMHDR pnmh)
+#define CR_MSG_WM_NOTIFY(func)                    \
+  if (uMsg == WM_NOTIFY) {                        \
+    SetMsgHandled(TRUE);                          \
+    lResult = func((int)wParam, (LPNMHDR)lParam); \
+    if (!ref.get() || msg_handled_)               \
+      return TRUE;                                \
+  }
+
+// void OnEnterIdle(UINT nWhy, CWindow wndWho)
+#define CR_MSG_WM_ENTERIDLE(func)     \
+  if (uMsg == WM_ENTERIDLE) {         \
+    SetMsgHandled(TRUE);              \
+    func((UINT)wParam, (HWND)lParam); \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnMouseMove(UINT nFlags, CPoint point)
+#define CR_MSG_WM_MOUSEMOVE(func)                                       \
+  if (uMsg == WM_MOUSEMOVE) {                                           \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// BOOL OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
+#define CR_MSG_WM_MOUSEWHEEL(func)                                     \
+  if (uMsg == WM_MOUSEWHEEL) {                                         \
+    SetMsgHandled(TRUE);                                               \
+    lResult = (LRESULT)func(                                           \
+        (UINT)LOWORD(wParam), (short)HIWORD(wParam),                   \
+        gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    if (!ref.get() || msg_handled_)                                    \
+      return TRUE;                                                     \
+  }
+
+// void OnLButtonDown(UINT nFlags, CPoint point)
+#define CR_MSG_WM_LBUTTONDOWN(func)                                     \
+  if (uMsg == WM_LBUTTONDOWN) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnLButtonUp(UINT nFlags, CPoint point)
+#define CR_MSG_WM_LBUTTONUP(func)                                       \
+  if (uMsg == WM_LBUTTONUP) {                                           \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnLButtonDblClk(UINT nFlags, CPoint point)
+#define CR_MSG_WM_LBUTTONDBLCLK(func)                                   \
+  if (uMsg == WM_LBUTTONDBLCLK) {                                       \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnRButtonDown(UINT nFlags, CPoint point)
+#define CR_MSG_WM_RBUTTONDOWN(func)                                     \
+  if (uMsg == WM_RBUTTONDOWN) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnRButtonUp(UINT nFlags, CPoint point)
+#define CR_MSG_WM_RBUTTONUP(func)                                       \
+  if (uMsg == WM_RBUTTONUP) {                                           \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnRButtonDblClk(UINT nFlags, CPoint point)
+#define CR_MSG_WM_RBUTTONDBLCLK(func)                                   \
+  if (uMsg == WM_RBUTTONDBLCLK) {                                       \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnMButtonDown(UINT nFlags, CPoint point)
+#define CR_MSG_WM_MBUTTONDOWN(func)                                     \
+  if (uMsg == WM_MBUTTONDOWN) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnMButtonUp(UINT nFlags, CPoint point)
+#define CR_MSG_WM_MBUTTONUP(func)                                       \
+  if (uMsg == WM_MBUTTONUP) {                                           \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnMButtonDblClk(UINT nFlags, CPoint point)
+#define CR_MSG_WM_MBUTTONDBLCLK(func)                                   \
+  if (uMsg == WM_MBUTTONDBLCLK) {                                       \
+    SetMsgHandled(TRUE);                                                \
+    func((UINT)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnParentNotify(UINT message, UINT nChildID, LPARAM lParam)
+#define CR_MSG_WM_PARENTNOTIFY(func)                          \
+  if (uMsg == WM_PARENTNOTIFY) {                              \
+    SetMsgHandled(TRUE);                                      \
+    func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), lParam); \
+    lResult = 0;                                              \
+    if (!ref.get() || msg_handled_)                           \
+      return TRUE;                                            \
+  }
+
+// void OnMDIActivate(CWindow wndActivate, CWindow wndDeactivate)
+#define CR_MSG_WM_MDIACTIVATE(func)   \
+  if (uMsg == WM_MDIACTIVATE) {       \
+    SetMsgHandled(TRUE);              \
+    func((HWND)wParam, (HWND)lParam); \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnRenderFormat(UINT nFormat)
+#define CR_MSG_WM_RENDERFORMAT(func) \
+  if (uMsg == WM_RENDERFORMAT) {     \
+    SetMsgHandled(TRUE);             \
+    func((UINT)wParam);              \
+    lResult = 0;                     \
+    if (!ref.get() || msg_handled_)  \
+      return TRUE;                   \
+  }
+
+// void OnRenderAllFormats()
+#define CR_MSG_WM_RENDERALLFORMATS(func) \
+  if (uMsg == WM_RENDERALLFORMATS) {     \
+    SetMsgHandled(TRUE);                 \
+    func();                              \
+    lResult = 0;                         \
+    if (!ref.get() || msg_handled_)      \
+      return TRUE;                       \
+  }
+
+// void OnDestroyClipboard()
+#define CR_MSG_WM_DESTROYCLIPBOARD(func) \
+  if (uMsg == WM_DESTROYCLIPBOARD) {     \
+    SetMsgHandled(TRUE);                 \
+    func();                              \
+    lResult = 0;                         \
+    if (!ref.get() || msg_handled_)      \
+      return TRUE;                       \
+  }
+
+// void OnDrawClipboard()
+#define CR_MSG_WM_DRAWCLIPBOARD(func) \
+  if (uMsg == WM_DRAWCLIPBOARD) {     \
+    SetMsgHandled(TRUE);              \
+    func();                           \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnPaintClipboard(CWindow wndViewer, const LPPAINTSTRUCT lpPaintStruct)
+#define CR_MSG_WM_PAINTCLIPBOARD(func)                                      \
+  if (uMsg == WM_PAINTCLIPBOARD) {                                          \
+    SetMsgHandled(TRUE);                                                    \
+    func((HWND)wParam, (const LPPAINTSTRUCT)::GlobalLock((HGLOBAL)lParam)); \
+    ::GlobalUnlock((HGLOBAL)lParam);                                        \
+    lResult = 0;                                                            \
+    if (!ref.get() || msg_handled_)                                         \
+      return TRUE;                                                          \
+  }
+
+// void OnVScrollClipboard(CWindow wndViewer, UINT nSBCode, UINT nPos)
+#define CR_MSG_WM_VSCROLLCLIPBOARD(func)                            \
+  if (uMsg == WM_VSCROLLCLIPBOARD) {                                \
+    SetMsgHandled(TRUE);                                            \
+    func((HWND)wParam, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); \
+    lResult = 0;                                                    \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// void OnContextMenu(CWindow wnd, CPoint point)
+#define CR_MSG_WM_CONTEXTMENU(func)                                     \
+  if (uMsg == WM_CONTEXTMENU) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func((HWND)wParam,                                                  \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnSizeClipboard(CWindow wndViewer, const LPRECT lpRect)
+#define CR_MSG_WM_SIZECLIPBOARD(func)                                \
+  if (uMsg == WM_SIZECLIPBOARD) {                                    \
+    SetMsgHandled(TRUE);                                             \
+    func((HWND)wParam, (const LPRECT)::GlobalLock((HGLOBAL)lParam)); \
+    ::GlobalUnlock((HGLOBAL)lParam);                                 \
+    lResult = 0;                                                     \
+    if (!ref.get() || msg_handled_)                                  \
+      return TRUE;                                                   \
+  }
+
+// void OnAskCbFormatName(UINT nMaxCount, LPTSTR lpszString)
+#define CR_MSG_WM_ASKCBFORMATNAME(func)  \
+  if (uMsg == WM_ASKCBFORMATNAME) {      \
+    SetMsgHandled(TRUE);                 \
+    func((DWORD)wParam, (LPTSTR)lParam); \
+    lResult = 0;                         \
+    if (!ref.get() || msg_handled_)      \
+      return TRUE;                       \
+  }
+
+// void OnChangeCbChain(CWindow wndRemove, CWindow wndAfter)
+#define CR_MSG_WM_CHANGECBCHAIN(func) \
+  if (uMsg == WM_CHANGECBCHAIN) {     \
+    SetMsgHandled(TRUE);              \
+    func((HWND)wParam, (HWND)lParam); \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnHScrollClipboard(CWindow wndViewer, UINT nSBCode, UINT nPos)
+#define CR_MSG_WM_HSCROLLCLIPBOARD(func)                            \
+  if (uMsg == WM_HSCROLLCLIPBOARD) {                                \
+    SetMsgHandled(TRUE);                                            \
+    func((HWND)wParam, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); \
+    lResult = 0;                                                    \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// BOOL OnQueryNewPalette()
+#define CR_MSG_WM_QUERYNEWPALETTE(func) \
+  if (uMsg == WM_QUERYNEWPALETTE) {     \
+    SetMsgHandled(TRUE);                \
+    lResult = (LRESULT)func();          \
+    if (!ref.get() || msg_handled_)     \
+      return TRUE;                      \
+  }
+
+// void OnPaletteChanged(CWindow wndFocus)
+#define CR_MSG_WM_PALETTECHANGED(func) \
+  if (uMsg == WM_PALETTECHANGED) {     \
+    SetMsgHandled(TRUE);               \
+    func((HWND)wParam);                \
+    lResult = 0;                       \
+    if (!ref.get() || msg_handled_)    \
+      return TRUE;                     \
+  }
+
+// void OnPaletteIsChanging(CWindow wndPalChg)
+#define CR_MSG_WM_PALETTEISCHANGING(func) \
+  if (uMsg == WM_PALETTEISCHANGING) {     \
+    SetMsgHandled(TRUE);                  \
+    func((HWND)wParam);                   \
+    lResult = 0;                          \
+    if (!ref.get() || msg_handled_)       \
+      return TRUE;                        \
+  }
+
+// void OnDropFiles(HDROP hDropInfo)
+#define CR_MSG_WM_DROPFILES(func)   \
+  if (uMsg == WM_DROPFILES) {       \
+    SetMsgHandled(TRUE);            \
+    func((HDROP)wParam);            \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnWindowPosChanging(LPWINDOWPOS lpWndPos)
+#define CR_MSG_WM_WINDOWPOSCHANGING(func) \
+  if (uMsg == WM_WINDOWPOSCHANGING) {     \
+    SetMsgHandled(TRUE);                  \
+    func((LPWINDOWPOS)lParam);            \
+    lResult = 0;                          \
+    if (!ref.get() || msg_handled_)       \
+      return TRUE;                        \
+  }
+
+// void OnWindowPosChanged(LPWINDOWPOS lpWndPos)
+#define CR_MSG_WM_WINDOWPOSCHANGED(func) \
+  if (uMsg == WM_WINDOWPOSCHANGED) {     \
+    SetMsgHandled(TRUE);                 \
+    func((LPWINDOWPOS)lParam);           \
+    lResult = 0;                         \
+    if (!ref.get() || msg_handled_)      \
+      return TRUE;                       \
+  }
+
+// void OnExitMenuLoop(BOOL fIsTrackPopupMenu)
+#define CR_MSG_WM_EXITMENULOOP(func) \
+  if (uMsg == WM_EXITMENULOOP) {     \
+    SetMsgHandled(TRUE);             \
+    func((BOOL)wParam);              \
+    lResult = 0;                     \
+    if (!ref.get() || msg_handled_)  \
+      return TRUE;                   \
+  }
+
+// void OnEnterMenuLoop(BOOL fIsTrackPopupMenu)
+#define CR_MSG_WM_ENTERMENULOOP(func) \
+  if (uMsg == WM_ENTERMENULOOP) {     \
+    SetMsgHandled(TRUE);              \
+    func((BOOL)wParam);               \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnStyleChanged(int nStyleType, LPSTYLESTRUCT lpStyleStruct)
+#define CR_MSG_WM_STYLECHANGED(func)           \
+  if (uMsg == WM_STYLECHANGED) {               \
+    SetMsgHandled(TRUE);                       \
+    func((UINT)wParam, (LPSTYLESTRUCT)lParam); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnStyleChanging(int nStyleType, LPSTYLESTRUCT lpStyleStruct)
+#define CR_MSG_WM_STYLECHANGING(func)          \
+  if (uMsg == WM_STYLECHANGING) {              \
+    SetMsgHandled(TRUE);                       \
+    func((UINT)wParam, (LPSTYLESTRUCT)lParam); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnSizing(UINT fwSide, LPRECT pRect)
+#define CR_MSG_WM_SIZING(func)          \
+  if (uMsg == WM_SIZING) {              \
+    SetMsgHandled(TRUE);                \
+    func((UINT)wParam, (LPRECT)lParam); \
+    lResult = TRUE;                     \
+    if (!ref.get() || msg_handled_)     \
+      return TRUE;                      \
+  }
+
+// void OnMoving(UINT fwSide, LPRECT pRect)
+#define CR_MSG_WM_MOVING(func)          \
+  if (uMsg == WM_MOVING) {              \
+    SetMsgHandled(TRUE);                \
+    func((UINT)wParam, (LPRECT)lParam); \
+    lResult = TRUE;                     \
+    if (!ref.get() || msg_handled_)     \
+      return TRUE;                      \
+  }
+
+// void OnCaptureChanged(CWindow wnd)
+#define CR_MSG_WM_CAPTURECHANGED(func) \
+  if (uMsg == WM_CAPTURECHANGED) {     \
+    SetMsgHandled(TRUE);               \
+    func((HWND)lParam);                \
+    lResult = 0;                       \
+    if (!ref.get() || msg_handled_)    \
+      return TRUE;                     \
+  }
+
+// BOOL OnDeviceChange(UINT nEventType, DWORD dwData)
+#define CR_MSG_WM_DEVICECHANGE(func)                      \
+  if (uMsg == WM_DEVICECHANGE) {                          \
+    SetMsgHandled(TRUE);                                  \
+    lResult = (LRESULT)func((UINT)wParam, (DWORD)lParam); \
+    if (!ref.get() || msg_handled_)                       \
+      return TRUE;                                        \
+  }
+
+// void OnCommand(UINT uNotifyCode, int nID, CWindow wndCtl)
+#define CR_MSG_WM_COMMAND(func)                                    \
+  if (uMsg == WM_COMMAND) {                                        \
+    SetMsgHandled(TRUE);                                           \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                   \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// void OnDisplayChange(UINT uBitsPerPixel, gfx::Size sizeScreen)
+#define CR_MSG_WM_DISPLAYCHANGE(func)                                  \
+  if (uMsg == WM_DISPLAYCHANGE) {                                      \
+    SetMsgHandled(TRUE);                                               \
+    func((UINT)wParam,                                                 \
+         gfx::Size(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                       \
+    if (!ref.get() || msg_handled_)                                    \
+      return TRUE;                                                     \
+  }
+
+// void OnEnterSizeMove()
+#define CR_MSG_WM_ENTERSIZEMOVE(func) \
+  if (uMsg == WM_ENTERSIZEMOVE) {     \
+    SetMsgHandled(TRUE);              \
+    func();                           \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnExitSizeMove()
+#define CR_MSG_WM_EXITSIZEMOVE(func) \
+  if (uMsg == WM_EXITSIZEMOVE) {     \
+    SetMsgHandled(TRUE);             \
+    func();                          \
+    lResult = 0;                     \
+    if (!ref.get() || msg_handled_)  \
+      return TRUE;                   \
+  }
+
+// HFONT OnGetFont()
+#define CR_MSG_WM_GETFONT(func)     \
+  if (uMsg == WM_GETFONT) {         \
+    SetMsgHandled(TRUE);            \
+    lResult = (LRESULT)func();      \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// LRESULT OnGetHotKey()
+#define CR_MSG_WM_GETHOTKEY(func)   \
+  if (uMsg == WM_GETHOTKEY) {       \
+    SetMsgHandled(TRUE);            \
+    lResult = func();               \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// HICON OnGetIcon()
+#define CR_MSG_WM_GETICON(func)            \
+  if (uMsg == WM_GETICON) {                \
+    SetMsgHandled(TRUE);                   \
+    lResult = (LRESULT)func((UINT)wParam); \
+    if (!ref.get() || msg_handled_)        \
+      return TRUE;                         \
+  }
+
+// int OnGetText(int cchTextMax, LPTSTR lpszText)
+#define CR_MSG_WM_GETTEXT(func)                           \
+  if (uMsg == WM_GETTEXT) {                               \
+    SetMsgHandled(TRUE);                                  \
+    lResult = (LRESULT)func((int)wParam, (LPTSTR)lParam); \
+    if (!ref.get() || msg_handled_)                       \
+      return TRUE;                                        \
+  }
+
+// int OnGetTextLength()
+#define CR_MSG_WM_GETTEXTLENGTH(func) \
+  if (uMsg == WM_GETTEXTLENGTH) {     \
+    SetMsgHandled(TRUE);              \
+    lResult = (LRESULT)func();        \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// void OnHelp(LPHELPINFO lpHelpInfo)
+#define CR_MSG_WM_HELP(func)        \
+  if (uMsg == WM_HELP) {            \
+    SetMsgHandled(TRUE);            \
+    func((LPHELPINFO)lParam);       \
+    lResult = TRUE;                 \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnHotKey(int nHotKeyID, UINT uModifiers, UINT uVirtKey)
+#define CR_MSG_WM_HOTKEY(func)                                     \
+  if (uMsg == WM_HOTKEY) {                                         \
+    SetMsgHandled(TRUE);                                           \
+    func((int)wParam, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)); \
+    lResult = 0;                                                   \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// void OnInputLangChange(DWORD dwCharSet, HKL hKbdLayout)
+#define CR_MSG_WM_INPUTLANGCHANGE(func) \
+  if (uMsg == WM_INPUTLANGCHANGE) {     \
+    SetMsgHandled(TRUE);                \
+    func((DWORD)wParam, (HKL)lParam);   \
+    lResult = TRUE;                     \
+    if (!ref.get() || msg_handled_)     \
+      return TRUE;                      \
+  }
+
+// void OnInputLangChangeRequest(BOOL bSysCharSet, HKL hKbdLayout)
+#define CR_MSG_WM_INPUTLANGCHANGEREQUEST(func) \
+  if (uMsg == WM_INPUTLANGCHANGEREQUEST) {     \
+    SetMsgHandled(TRUE);                       \
+    func((BOOL)wParam, (HKL)lParam);           \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnNextDlgCtl(BOOL bHandle, WPARAM wCtlFocus)
+#define CR_MSG_WM_NEXTDLGCTL(func)      \
+  if (uMsg == WM_NEXTDLGCTL) {          \
+    SetMsgHandled(TRUE);                \
+    func((BOOL)LOWORD(lParam), wParam); \
+    lResult = 0;                        \
+    if (!ref.get() || msg_handled_)     \
+      return TRUE;                      \
+  }
+
+// void OnNextMenu(int nVirtKey, LPMDINEXTMENU lpMdiNextMenu)
+#define CR_MSG_WM_NEXTMENU(func)              \
+  if (uMsg == WM_NEXTMENU) {                  \
+    SetMsgHandled(TRUE);                      \
+    func((int)wParam, (LPMDINEXTMENU)lParam); \
+    lResult = 0;                              \
+    if (!ref.get() || msg_handled_)           \
+      return TRUE;                            \
+  }
+
+// int OnNotifyFormat(CWindow wndFrom, int nCommand)
+#define CR_MSG_WM_NOTIFYFORMAT(func)                    \
+  if (uMsg == WM_NOTIFYFORMAT) {                        \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HWND)wParam, (int)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// BOOL OnPowerBroadcast(DWORD dwPowerEvent, DWORD dwData)
+#define CR_MSG_WM_POWERBROADCAST(func)                     \
+  if (uMsg == WM_POWERBROADCAST) {                         \
+    SetMsgHandled(TRUE);                                   \
+    lResult = (LRESULT)func((DWORD)wParam, (DWORD)lParam); \
+    if (!ref.get() || msg_handled_)                        \
+      return TRUE;                                         \
+  }
+
+// void OnPrint(CDCHandle dc, UINT uFlags)
+#define CR_MSG_WM_PRINT(func)        \
+  if (uMsg == WM_PRINT) {            \
+    SetMsgHandled(TRUE);             \
+    func((HDC)wParam, (UINT)lParam); \
+    lResult = 0;                     \
+    if (!ref.get() || msg_handled_)  \
+      return TRUE;                   \
+  }
+
+// void OnPrintClient(CDCHandle dc, UINT uFlags)
+#define CR_MSG_WM_PRINTCLIENT(func)  \
+  if (uMsg == WM_PRINTCLIENT) {      \
+    SetMsgHandled(TRUE);             \
+    func((HDC)wParam, (UINT)lParam); \
+    lResult = 0;                     \
+    if (!ref.get() || msg_handled_)  \
+      return TRUE;                   \
+  }
+
+// void OnRasDialEvent(RASCONNSTATE rasconnstate, DWORD dwError)
+#define CR_MSG_WM_RASDIALEVENT(func)           \
+  if (uMsg == WM_RASDIALEVENT) {               \
+    SetMsgHandled(TRUE);                       \
+    func((RASCONNSTATE)wParam, (DWORD)lParam); \
+    lResult = TRUE;                            \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnSetFont(CFont font, BOOL bRedraw)
+#define CR_MSG_WM_SETFONT(func)                \
+  if (uMsg == WM_SETFONT) {                    \
+    SetMsgHandled(TRUE);                       \
+    func((HFONT)wParam, (BOOL)LOWORD(lParam)); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// int OnSetHotKey(int nVirtKey, UINT uFlags)
+#define CR_MSG_WM_SETHOTKEY(func)                          \
+  if (uMsg == WM_SETHOTKEY) {                              \
+    SetMsgHandled(TRUE);                                   \
+    lResult = (LRESULT)func((int)LOBYTE(LOWORD(wParam)),   \
+                            (UINT)HIBYTE(LOWORD(wParam))); \
+    if (!ref.get() || msg_handled_)                        \
+      return TRUE;                                         \
+  }
+
+// HICON OnSetIcon(UINT uType, HICON hIcon)
+#define CR_MSG_WM_SETICON(func)                           \
+  if (uMsg == WM_SETICON) {                               \
+    SetMsgHandled(TRUE);                                  \
+    lResult = (LRESULT)func((UINT)wParam, (HICON)lParam); \
+    if (!ref.get() || msg_handled_)                       \
+      return TRUE;                                        \
+  }
+
+// void OnSetRedraw(BOOL bRedraw)
+#define CR_MSG_WM_SETREDRAW(func)   \
+  if (uMsg == WM_SETREDRAW) {       \
+    SetMsgHandled(TRUE);            \
+    func((BOOL)wParam);             \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// int OnSetText(LPCTSTR lpstrText)
+#define CR_MSG_WM_SETTEXT(func)               \
+  if (uMsg == WM_SETTEXT) {                   \
+    SetMsgHandled(TRUE);                      \
+    lResult = (LRESULT)func((LPCTSTR)lParam); \
+    if (!ref.get() || msg_handled_)           \
+      return TRUE;                            \
+  }
+
+// void OnUserChanged()
+#define CR_MSG_WM_USERCHANGED(func) \
+  if (uMsg == WM_USERCHANGED) {     \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+///////////////////////////////////////////////////////////////////////////////
+// New NT4 & NT5 messages
+
+#if (_WIN32_WINNT >= 0x0400)
+
+// void OnMouseHover(WPARAM wParam, CPoint ptPos)
+#define CR_MSG_WM_MOUSEHOVER(func)                                      \
+  if (uMsg == WM_MOUSEHOVER) {                                          \
+    SetMsgHandled(TRUE);                                                \
+    func(wParam,                                                        \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnMouseLeave()
+#define CR_MSG_WM_MOUSELEAVE(func)  \
+  if (uMsg == WM_MOUSELEAVE) {      \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+#endif /* _WIN32_WINNT >= 0x0400 */
+
+#if (WINVER >= 0x0500)
+
+// void OnMenuRButtonUp(WPARAM wParam, CMenu menu)
+#define CR_MSG_WM_MENURBUTTONUP(func) \
+  if (uMsg == WM_MENURBUTTONUP) {     \
+    SetMsgHandled(TRUE);              \
+    func(wParam, (HMENU)lParam);      \
+    lResult = 0;                      \
+    if (!ref.get() || msg_handled_)   \
+      return TRUE;                    \
+  }
+
+// LRESULT OnMenuDrag(WPARAM wParam, CMenu menu)
+#define CR_MSG_WM_MENUDRAG(func)           \
+  if (uMsg == WM_MENUDRAG) {               \
+    SetMsgHandled(TRUE);                   \
+    lResult = func(wParam, (HMENU)lParam); \
+    if (!ref.get() || msg_handled_)        \
+      return TRUE;                         \
+  }
+
+// LRESULT OnMenuGetObject(PMENUGETOBJECTINFO info)
+#define CR_MSG_WM_MENUGETOBJECT(func)           \
+  if (uMsg == WM_MENUGETOBJECT) {               \
+    SetMsgHandled(TRUE);                        \
+    lResult = func((PMENUGETOBJECTINFO)lParam); \
+    if (!ref.get() || msg_handled_)             \
+      return TRUE;                              \
+  }
+
+// void OnUnInitMenuPopup(UINT nID, CMenu menu)
+#define CR_MSG_WM_UNINITMENUPOPUP(func)        \
+  if (uMsg == WM_UNINITMENUPOPUP) {            \
+    SetMsgHandled(TRUE);                       \
+    func((UINT)HIWORD(lParam), (HMENU)wParam); \
+    lResult = 0;                               \
+    if (!ref.get() || msg_handled_)            \
+      return TRUE;                             \
+  }
+
+// void OnMenuCommand(WPARAM nIndex, CMenu menu)
+#define CR_MSG_WM_MENUCOMMAND(func) \
+  if (uMsg == WM_MENUCOMMAND) {     \
+    SetMsgHandled(TRUE);            \
+    func(wParam, (HMENU)lParam);    \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+#endif /* WINVER >= 0x0500 */
+
+#if (_WIN32_WINNT >= 0x0500)
+
+// BOOL OnAppCommand(CWindow wndFocus, short cmd, WORD uDevice, int dwKeys)
+#define CR_MSG_WM_APPCOMMAND(func)                                             \
+  if (uMsg == WM_APPCOMMAND) {                                                 \
+    SetMsgHandled(TRUE);                                                       \
+    lResult =                                                                  \
+        (LRESULT)func((HWND)wParam, GET_APPCOMMAND_LPARAM(lParam),             \
+                      GET_DEVICE_LPARAM(lParam), GET_KEYSTATE_LPARAM(lParam)); \
+    if (!ref.get() || msg_handled_)                                            \
+      return TRUE;                                                             \
+  }
+
+// void OnNCXButtonDown(int fwButton, short nHittest, CPoint ptPos)
+#define CR_MSG_WM_NCXBUTTONDOWN(func)                                   \
+  if (uMsg == WM_NCXBUTTONDOWN) {                                       \
+    SetMsgHandled(TRUE);                                                \
+    func(GET_XBUTTON_WPARAM(wParam), GET_NCHITTEST_WPARAM(wParam),      \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNCXButtonUp(int fwButton, short nHittest, CPoint ptPos)
+#define CR_MSG_WM_NCXBUTTONUP(func)                                     \
+  if (uMsg == WM_NCXBUTTONUP) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func(GET_XBUTTON_WPARAM(wParam), GET_NCHITTEST_WPARAM(wParam),      \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnNCXButtonDblClk(int fwButton, short nHittest, CPoint ptPos)
+#define CR_MSG_WM_NCXBUTTONDBLCLK(func)                                 \
+  if (uMsg == WM_NCXBUTTONDBLCLK) {                                     \
+    SetMsgHandled(TRUE);                                                \
+    func(GET_XBUTTON_WPARAM(wParam), GET_NCHITTEST_WPARAM(wParam),      \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnXButtonDown(int fwButton, int dwKeys, CPoint ptPos)
+#define CR_MSG_WM_XBUTTONDOWN(func)                                     \
+  if (uMsg == WM_XBUTTONDOWN) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    func(GET_XBUTTON_WPARAM(wParam), GET_KEYSTATE_WPARAM(wParam),       \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnXButtonUp(int fwButton, int dwKeys, CPoint ptPos)
+#define CR_MSG_WM_XBUTTONUP(func)                                       \
+  if (uMsg == WM_XBUTTONUP) {                                           \
+    SetMsgHandled(TRUE);                                                \
+    func(GET_XBUTTON_WPARAM(wParam), GET_KEYSTATE_WPARAM(wParam),       \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnXButtonDblClk(int fwButton, int dwKeys, CPoint ptPos)
+#define CR_MSG_WM_XBUTTONDBLCLK(func)                                   \
+  if (uMsg == WM_XBUTTONDBLCLK) {                                       \
+    SetMsgHandled(TRUE);                                                \
+    func(GET_XBUTTON_WPARAM(wParam), GET_KEYSTATE_WPARAM(wParam),       \
+         gfx::Point(CR_GET_X_LPARAM(lParam), CR_GET_Y_LPARAM(lParam))); \
+    lResult = 0;                                                        \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnChangeUIState(WORD nAction, WORD nState)
+#define CR_MSG_WM_CHANGEUISTATE(func)     \
+  if (uMsg == WM_CHANGEUISTATE) {         \
+    SetMsgHandled(TRUE);                  \
+    func(LOWORD(wParam), HIWORD(wParam)); \
+    lResult = 0;                          \
+    if (!ref.get() || msg_handled_)       \
+      return TRUE;                        \
+  }
+
+// void OnUpdateUIState(WORD nAction, WORD nState)
+#define CR_MSG_WM_UPDATEUISTATE(func)     \
+  if (uMsg == WM_UPDATEUISTATE) {         \
+    SetMsgHandled(TRUE);                  \
+    func(LOWORD(wParam), HIWORD(wParam)); \
+    lResult = 0;                          \
+    if (!ref.get() || msg_handled_)       \
+      return TRUE;                        \
+  }
+
+// LRESULT OnQueryUIState()
+#define CR_MSG_WM_QUERYUISTATE(func) \
+  if (uMsg == WM_QUERYUISTATE) {     \
+    SetMsgHandled(TRUE);             \
+    lResult = func();                \
+    if (!ref.get() || msg_handled_)  \
+      return TRUE;                   \
+  }
+
+#endif  // (_WIN32_WINNT >= 0x0500)
+
+#if (_WIN32_WINNT >= 0x0501)
+
+// void OnInput(WPARAM RawInputCode, HRAWINPUT hRawInput)
+#define CR_MSG_WM_INPUT(func)                                  \
+  if (uMsg == WM_INPUT) {                                      \
+    SetMsgHandled(TRUE);                                       \
+    func(GET_RAWINPUT_CODE_WPARAM(wParam), (HRAWINPUT)lParam); \
+    lResult = 0;                                               \
+    if (!ref.get() || msg_handled_)                            \
+      return TRUE;                                             \
+  }
+
+// void OnUniChar(TCHAR nChar, UINT nRepCnt, UINT nFlags)
+#define CR_MSG_WM_UNICHAR(func)                            \
+  if (uMsg == WM_UNICHAR) {                                \
+    SetMsgHandled(TRUE);                                   \
+    func((TCHAR)wParam, (UINT)lParam & 0xFFFF,             \
+         (UINT)((lParam & 0xFFFF0000) >> 16));             \
+    if (!ref.get() || msg_handled_) {                      \
+      lResult = (wParam == UNICODE_NOCHAR) ? TRUE : FALSE; \
+      return TRUE;                                         \
+    }                                                      \
+  }
+
+// OnThemeChanged()
+#define CR_MSG_WM_THEMECHANGED(func) \
+  if (uMsg == WM_THEMECHANGED) {     \
+    SetMsgHandled(TRUE);             \
+    func();                          \
+    lResult = 0;                     \
+    if (!ref.get() || msg_handled_)  \
+      return TRUE;                   \
+  }
+
+#endif /* _WIN32_WINNT >= 0x0501 */
+
+///////////////////////////////////////////////////////////////////////////////
+// ATL defined messages
+
+// BOOL OnForwardMsg(LPMSG Msg, DWORD nUserData)
+#define CR_MSG_WM_FORWARDMSG(func)                         \
+  if (uMsg == WM_FORWARDMSG) {                             \
+    SetMsgHandled(TRUE);                                   \
+    lResult = (LRESULT)func((LPMSG)lParam, (DWORD)wParam); \
+    if (!ref.get() || msg_handled_)                        \
+      return TRUE;                                         \
+  }
+
+///////////////////////////////////////////////////////////////////////////////
+// Dialog specific messages
+
+// LRESULT OnDMGetDefID()
+#define MSG_DM_GETDEFID(func)       \
+  if (uMsg == DM_GETDEFID) {        \
+    SetMsgHandled(TRUE);            \
+    lResult = func();               \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnDMSetDefID(UINT DefID)
+#define MSG_DM_SETDEFID(func)       \
+  if (uMsg == DM_SETDEFID) {        \
+    SetMsgHandled(TRUE);            \
+    func((UINT)wParam);             \
+    lResult = TRUE;                 \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnDMReposition()
+#define MSG_DM_REPOSITION(func)     \
+  if (uMsg == DM_REPOSITION) {      \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+///////////////////////////////////////////////////////////////////////////////
+// Reflected messages
+
+// void OnReflectedCommand(UINT uNotifyCode, int nID, CWindow wndCtl)
+#define MSG_OCM_COMMAND(func)                                      \
+  if (uMsg == OCM_COMMAND) {                                       \
+    SetMsgHandled(TRUE);                                           \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                   \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// LRESULT OnReflectedNotify(int idCtrl, LPNMHDR pnmh)
+#define MSG_OCM_NOTIFY(func)                      \
+  if (uMsg == OCM_NOTIFY) {                       \
+    SetMsgHandled(TRUE);                          \
+    lResult = func((int)wParam, (LPNMHDR)lParam); \
+    if (!ref.get() || msg_handled_)               \
+      return TRUE;                                \
+  }
+
+// void OnReflectedParentNotify(UINT message, UINT nChildID, LPARAM lParam)
+#define MSG_OCM_PARENTNOTIFY(func)                            \
+  if (uMsg == OCM_PARENTNOTIFY) {                             \
+    SetMsgHandled(TRUE);                                      \
+    func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), lParam); \
+    lResult = 0;                                              \
+    if (!ref.get() || msg_handled_)                           \
+      return TRUE;                                            \
+  }
+
+// void OnReflectedDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
+#define MSG_OCM_DRAWITEM(func)                    \
+  if (uMsg == OCM_DRAWITEM) {                     \
+    SetMsgHandled(TRUE);                          \
+    func((UINT)wParam, (LPDRAWITEMSTRUCT)lParam); \
+    lResult = TRUE;                               \
+    if (!ref.get() || msg_handled_)               \
+      return TRUE;                                \
+  }
+
+// void OnReflectedMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT
+// lpMeasureItemStruct)
+#define MSG_OCM_MEASUREITEM(func)                    \
+  if (uMsg == OCM_MEASUREITEM) {                     \
+    SetMsgHandled(TRUE);                             \
+    func((UINT)wParam, (LPMEASUREITEMSTRUCT)lParam); \
+    lResult = TRUE;                                  \
+    if (!ref.get() || msg_handled_)                  \
+      return TRUE;                                   \
+  }
+
+// int OnReflectedCompareItem(int nIDCtl, LPCOMPAREITEMSTRUCT
+// lpCompareItemStruct)
+#define MSG_OCM_COMPAREITEM(func)                                       \
+  if (uMsg == OCM_COMPAREITEM) {                                        \
+    SetMsgHandled(TRUE);                                                \
+    lResult = (LRESULT)func((UINT)wParam, (LPCOMPAREITEMSTRUCT)lParam); \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnReflectedDeleteItem(int nIDCtl, LPDELETEITEMSTRUCT lpDeleteItemStruct)
+#define MSG_OCM_DELETEITEM(func)                    \
+  if (uMsg == OCM_DELETEITEM) {                     \
+    SetMsgHandled(TRUE);                            \
+    func((UINT)wParam, (LPDELETEITEMSTRUCT)lParam); \
+    lResult = TRUE;                                 \
+    if (!ref.get() || msg_handled_)                 \
+      return TRUE;                                  \
+  }
+
+// int OnReflectedVKeyToItem(UINT nKey, UINT nIndex, CListBox listBox)
+#define MSG_OCM_VKEYTOITEM(func)                                        \
+  if (uMsg == OCM_VKEYTOITEM) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    lResult = (LRESULT)func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), \
+                            (HWND)lParam);                              \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// int OnReflectedCharToItem(UINT nChar, UINT nIndex, CListBox listBox)
+#define MSG_OCM_CHARTOITEM(func)                                        \
+  if (uMsg == OCM_CHARTOITEM) {                                         \
+    SetMsgHandled(TRUE);                                                \
+    lResult = (LRESULT)func((UINT)LOWORD(wParam), (UINT)HIWORD(wParam), \
+                            (HWND)lParam);                              \
+    if (!ref.get() || msg_handled_)                                     \
+      return TRUE;                                                      \
+  }
+
+// void OnReflectedHScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
+#define MSG_OCM_HSCROLL(func)                                       \
+  if (uMsg == OCM_HSCROLL) {                                        \
+    SetMsgHandled(TRUE);                                            \
+    func((int)LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                    \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// void OnReflectedVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
+#define MSG_OCM_VSCROLL(func)                                       \
+  if (uMsg == OCM_VSCROLL) {                                        \
+    SetMsgHandled(TRUE);                                            \
+    func((int)LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                    \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// HBRUSH OnReflectedCtlColorEdit(CDCHandle dc, CEdit edit)
+#define MSG_OCM_CTLCOLOREDIT(func)                      \
+  if (uMsg == OCM_CTLCOLOREDIT) {                       \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnReflectedCtlColorListBox(CDCHandle dc, CListBox listBox)
+#define MSG_OCM_CTLCOLORLISTBOX(func)                   \
+  if (uMsg == OCM_CTLCOLORLISTBOX) {                    \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnReflectedCtlColorBtn(CDCHandle dc, CButton button)
+#define MSG_OCM_CTLCOLORBTN(func)                       \
+  if (uMsg == OCM_CTLCOLORBTN) {                        \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnReflectedCtlColorDlg(CDCHandle dc, CWindow wnd)
+#define MSG_OCM_CTLCOLORDLG(func)                       \
+  if (uMsg == OCM_CTLCOLORDLG) {                        \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnReflectedCtlColorScrollBar(CDCHandle dc, CScrollBar scrollBar)
+#define MSG_OCM_CTLCOLORSCROLLBAR(func)                 \
+  if (uMsg == OCM_CTLCOLORSCROLLBAR) {                  \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+// HBRUSH OnReflectedCtlColorStatic(CDCHandle dc, CStatic wndStatic)
+#define MSG_OCM_CTLCOLORSTATIC(func)                    \
+  if (uMsg == OCM_CTLCOLORSTATIC) {                     \
+    SetMsgHandled(TRUE);                                \
+    lResult = (LRESULT)func((HDC)wParam, (HWND)lParam); \
+    if (!ref.get() || msg_handled_)                     \
+      return TRUE;                                      \
+  }
+
+///////////////////////////////////////////////////////////////////////////////
+// Edit specific messages
+
+// void OnClear()
+#define CR_MSG_WM_CLEAR(func)       \
+  if (uMsg == WM_CLEAR) {           \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnCopy()
+#define CR_MSG_WM_COPY(func)        \
+  if (uMsg == WM_COPY) {            \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnCut()
+#define CR_MSG_WM_CUT(func)         \
+  if (uMsg == WM_CUT) {             \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnPaste()
+#define CR_MSG_WM_PASTE(func)       \
+  if (uMsg == WM_PASTE) {           \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+// void OnUndo()
+#define CR_MSG_WM_UNDO(func)        \
+  if (uMsg == WM_UNDO) {            \
+    SetMsgHandled(TRUE);            \
+    func();                         \
+    lResult = 0;                    \
+    if (!ref.get() || msg_handled_) \
+      return TRUE;                  \
+  }
+
+///////////////////////////////////////////////////////////////////////////////
+// Generic message handlers
+
+// LRESULT OnMessageHandlerEX(UINT uMsg, WPARAM wParam, LPARAM lParam)
+#define CR_MESSAGE_HANDLER_EX(msg, func)  \
+  if (uMsg == msg) {                      \
+    SetMsgHandled(TRUE);                  \
+    lResult = func(uMsg, wParam, lParam); \
+    if (!ref.get() || msg_handled_)       \
+      return TRUE;                        \
+  }
+
+// LRESULT OnMessageRangeHandlerEX(UINT uMsg, WPARAM wParam, LPARAM lParam)
+#define CR_MESSAGE_RANGE_HANDLER_EX(msgFirst, msgLast, func) \
+  if (uMsg >= msgFirst && uMsg <= msgLast) {                 \
+    SetMsgHandled(TRUE);                                     \
+    lResult = func(uMsg, wParam, lParam);                    \
+    if (!ref.get() || msg_handled_)                          \
+      return TRUE;                                           \
+  }
+
+///////////////////////////////////////////////////////////////////////////////
+// Commands and notifications
+
+// void OnCommandHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
+#define CR_COMMAND_HANDLER_EX(id, code, func)                                 \
+  if (uMsg == WM_COMMAND && code == HIWORD(wParam) && id == LOWORD(wParam)) { \
+    SetMsgHandled(TRUE);                                                      \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);            \
+    lResult = 0;                                                              \
+    if (!ref.get() || msg_handled_)                                           \
+      return TRUE;                                                            \
+  }
+
+// void OnCommandIDHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
+#define CR_COMMAND_ID_HANDLER_EX(id, func)                         \
+  if (uMsg == WM_COMMAND && id == LOWORD(wParam)) {                \
+    SetMsgHandled(TRUE);                                           \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                   \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// void OnCommandCodeHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
+#define CR_COMMAND_CODE_HANDLER_EX(code, func)                     \
+  if (uMsg == WM_COMMAND && code == HIWORD(wParam)) {              \
+    SetMsgHandled(TRUE);                                           \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                   \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// LRESULT OnNotifyHandlerEX(LPNMHDR pnmh)
+#define CR_NOTIFY_HANDLER_EX(id, cd, func)                  \
+  if (uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code && \
+      id == ((LPNMHDR)lParam)->idFrom) {                    \
+    SetMsgHandled(TRUE);                                    \
+    lResult = func((LPNMHDR)lParam);                        \
+    if (!ref.get() || msg_handled_)                         \
+      return TRUE;                                          \
+  }
+
+// LRESULT OnNotifyIDHandlerEX(LPNMHDR pnmh)
+#define CR_NOTIFY_ID_HANDLER_EX(id, func)                     \
+  if (uMsg == WM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom) { \
+    SetMsgHandled(TRUE);                                      \
+    lResult = func((LPNMHDR)lParam);                          \
+    if (!ref.get() || msg_handled_)                           \
+      return TRUE;                                            \
+  }
+
+// LRESULT OnNotifyCodeHandlerEX(LPNMHDR pnmh)
+#define CR_NOTIFY_CODE_HANDLER_EX(cd, func)                 \
+  if (uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code) { \
+    SetMsgHandled(TRUE);                                    \
+    lResult = func((LPNMHDR)lParam);                        \
+    if (!ref.get() || msg_handled_)                         \
+      return TRUE;                                          \
+  }
+
+// void OnCommandRangeHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
+#define CR_COMMAND_RANGE_HANDLER_EX(idFirst, idLast, func)         \
+  if (uMsg == WM_COMMAND && LOWORD(wParam) >= idFirst &&           \
+      LOWORD(wParam) <= idLast) {                                  \
+    SetMsgHandled(TRUE);                                           \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                   \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// void OnCommandRangeCodeHandlerEX(UINT uNotifyCode, int nID, CWindow wndCtl)
+#define CR_COMMAND_RANGE_CODE_HANDLER_EX(idFirst, idLast, code, func) \
+  if (uMsg == WM_COMMAND && code == HIWORD(wParam) &&                 \
+      LOWORD(wParam) >= idFirst && LOWORD(wParam) <= idLast) {        \
+    SetMsgHandled(TRUE);                                              \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);    \
+    lResult = 0;                                                      \
+    if (!ref.get() || msg_handled_)                                   \
+      return TRUE;                                                    \
+  }
+
+// LRESULT OnNotifyRangeHandlerEX(LPNMHDR pnmh)
+#define CR_NOTIFY_RANGE_HANDLER_EX(idFirst, idLast, func)          \
+  if (uMsg == WM_NOTIFY && ((LPNMHDR)lParam)->idFrom >= idFirst && \
+      ((LPNMHDR)lParam)->idFrom <= idLast) {                       \
+    SetMsgHandled(TRUE);                                           \
+    lResult = func((LPNMHDR)lParam);                               \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// LRESULT OnNotifyRangeCodeHandlerEX(LPNMHDR pnmh)
+#define CR_NOTIFY_RANGE_CODE_HANDLER_EX(idFirst, idLast, cd, func) \
+  if (uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code &&        \
+      ((LPNMHDR)lParam)->idFrom >= idFirst &&                      \
+      ((LPNMHDR)lParam)->idFrom <= idLast) {                       \
+    SetMsgHandled(TRUE);                                           \
+    lResult = func((LPNMHDR)lParam);                               \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// LRESULT OnReflectedCommandHandlerEX(UINT uNotifyCode, int nID, CWindow
+// wndCtl)
+#define CR_REFLECTED_COMMAND_HANDLER_EX(id, code, func)                        \
+  if (uMsg == OCM_COMMAND && code == HIWORD(wParam) && id == LOWORD(wParam)) { \
+    SetMsgHandled(TRUE);                                                       \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);             \
+    lResult = 0;                                                               \
+    if (!ref.get() || msg_handled_)                                            \
+      return TRUE;                                                             \
+  }
+
+// LRESULT OnReflectedCommandIDHandlerEX(UINT uNotifyCode, int nID, CWindow
+// wndCtl)
+#define CR_REFLECTED_COMMAND_ID_HANDLER_EX(id, func)               \
+  if (uMsg == OCM_COMMAND && id == LOWORD(wParam)) {               \
+    SetMsgHandled(TRUE);                                           \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                   \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// LRESULT OnReflectedCommandCodeHandlerEX(UINT uNotifyCode, int nID, CWindow
+// wndCtl)
+#define CR_REFLECTED_COMMAND_CODE_HANDLER_EX(code, func)           \
+  if (uMsg == OCM_COMMAND && code == HIWORD(wParam)) {             \
+    SetMsgHandled(TRUE);                                           \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam); \
+    lResult = 0;                                                   \
+    if (!ref.get() || msg_handled_)                                \
+      return TRUE;                                                 \
+  }
+
+// LRESULT OnReflectedNotifyHandlerEX(LPNMHDR pnmh)
+#define CR_REFLECTED_NOTIFY_HANDLER_EX(id, cd, func)         \
+  if (uMsg == OCM_NOTIFY && cd == ((LPNMHDR)lParam)->code && \
+      id == ((LPNMHDR)lParam)->idFrom) {                     \
+    SetMsgHandled(TRUE);                                     \
+    lResult = func((LPNMHDR)lParam);                         \
+    if (!ref.get() || msg_handled_)                          \
+      return TRUE;                                           \
+  }
+
+// LRESULT OnReflectedNotifyIDHandlerEX(LPNMHDR pnmh)
+#define CR_REFLECTED_NOTIFY_ID_HANDLER_EX(id, func)            \
+  if (uMsg == OCM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom) { \
+    SetMsgHandled(TRUE);                                       \
+    lResult = func((LPNMHDR)lParam);                           \
+    if (!ref.get() || msg_handled_)                            \
+      return TRUE;                                             \
+  }
+
+// LRESULT OnReflectedNotifyCodeHandlerEX(LPNMHDR pnmh)
+#define CR_REFLECTED_NOTIFY_CODE_HANDLER_EX(cd, func)        \
+  if (uMsg == OCM_NOTIFY && cd == ((LPNMHDR)lParam)->code) { \
+    SetMsgHandled(TRUE);                                     \
+    lResult = func((LPNMHDR)lParam);                         \
+    if (!ref.get() || msg_handled_)                          \
+      return TRUE;                                           \
+  }
+
+// void OnReflectedCommandRangeHandlerEX(UINT uNotifyCode, int nID, CWindow
+// wndCtl)
+#define CR_REFLECTED_COMMAND_RANGE_HANDLER_EX(idFirst, idLast, func) \
+  if (uMsg == OCM_COMMAND && LOWORD(wParam) >= idFirst &&            \
+      LOWORD(wParam) <= idLast) {                                    \
+    SetMsgHandled(TRUE);                                             \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);   \
+    lResult = 0;                                                     \
+    if (!ref.get() || msg_handled_)                                  \
+      return TRUE;                                                   \
+  }
+
+// void OnReflectedCommandRangeCodeHandlerEX(UINT uNotifyCode, int nID, CWindow
+// wndCtl)
+#define CR_REFLECTED_COMMAND_RANGE_CODE_HANDLER_EX(idFirst, idLast, code, \
+                                                   func)                  \
+  if (uMsg == OCM_COMMAND && code == HIWORD(wParam) &&                    \
+      LOWORD(wParam) >= idFirst && LOWORD(wParam) <= idLast) {            \
+    SetMsgHandled(TRUE);                                                  \
+    func((UINT)HIWORD(wParam), (int)LOWORD(wParam), (HWND)lParam);        \
+    lResult = 0;                                                          \
+    if (!ref.get() || msg_handled_)                                       \
+      return TRUE;                                                        \
+  }
+
+// LRESULT OnReflectedNotifyRangeHandlerEX(LPNMHDR pnmh)
+#define CR_REFLECTED_NOTIFY_RANGE_HANDLER_EX(idFirst, idLast, func) \
+  if (uMsg == OCM_NOTIFY && ((LPNMHDR)lParam)->idFrom >= idFirst && \
+      ((LPNMHDR)lParam)->idFrom <= idLast) {                        \
+    SetMsgHandled(TRUE);                                            \
+    lResult = func((LPNMHDR)lParam);                                \
+    if (!ref.get() || msg_handled_)                                 \
+      return TRUE;                                                  \
+  }
+
+// LRESULT OnReflectedNotifyRangeCodeHandlerEX(LPNMHDR pnmh)
+#define CR_REFLECTED_NOTIFY_RANGE_CODE_HANDLER_EX(idFirst, idLast, cd, func) \
+  if (uMsg == OCM_NOTIFY && cd == ((LPNMHDR)lParam)->code &&                 \
+      ((LPNMHDR)lParam)->idFrom >= idFirst &&                                \
+      ((LPNMHDR)lParam)->idFrom <= idLast) {                                 \
+    SetMsgHandled(TRUE);                                                     \
+    lResult = func((LPNMHDR)lParam);                                         \
+    if (!ref.get() || msg_handled_)                                          \
+      return TRUE;                                                           \
+  }
+
+#define CR_DEFLATE_RECT(rect, by)   \
+  {                                 \
+    (rect)->left += (by)->left;     \
+    (rect)->top += (by)->top;       \
+    (rect)->right -= (by)->right;   \
+    (rect)->bottom -= (by)->bottom; \
+  }
+
+#define CR_POINT_INITIALIZER_FROM_LPARAM(lparam) \
+  { LOWORD(lparam), HIWORD(lparam) }
+
+#endif  // UI_GFX_WIN_MSG_UTIL_H_
diff --git a/ui/gfx/win/physical_size.cc b/ui/gfx/win/physical_size.cc
new file mode 100644
index 0000000..39978f7
--- /dev/null
+++ b/ui/gfx/win/physical_size.cc
@@ -0,0 +1,163 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/win/physical_size.h"
+
+#include <windows.h>
+#include <setupapi.h>
+
+#include <iostream>
+#include <memory>
+
+#include "base/check_op.h"
+#include "base/memory/free_deleter.h"
+#include "base/scoped_generic.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/win/registry.h"
+
+// This GUID {E6F07B5F-EE97-4A90-B076-33F57BF4EAA7} was taken from
+// https://msdn.microsoft.com/en-us/library/windows/hardware/ff545901.aspx
+const GUID GUID_DEVICEINTERFACE_MONITOR = {
+    0xE6F07B5F,
+    0xEE97,
+    0x4A90,
+    {0xB0, 0x76, 0x33, 0xF5, 0x7B, 0xF4, 0xEA, 0xA7}};
+
+namespace {
+
+struct DeviceInfoListScopedTraits {
+  static HDEVINFO InvalidValue() { return INVALID_HANDLE_VALUE; }
+
+  static void Free(HDEVINFO h) { SetupDiDestroyDeviceInfoList(h); }
+};
+
+bool GetSizeFromRegistry(HDEVINFO device_info_list,
+                         SP_DEVINFO_DATA* device_info,
+                         int* width_mm,
+                         int* height_mm) {
+  base::win::RegKey reg_key(SetupDiOpenDevRegKey(
+      device_info_list, device_info, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ));
+  if (!reg_key.Valid())
+    return false;
+
+  BYTE data[128];  // EDID block is exactly 128 bytes long.
+  ZeroMemory(&data[0], sizeof(data));
+  DWORD data_length = sizeof(data);
+  LONG return_value =
+      reg_key.ReadValue(L"EDID", &data[0], &data_length, nullptr);
+  if (return_value != ERROR_SUCCESS)
+    return false;
+
+  // Byte 54 is the start of the first descriptor block, which contains the
+  // required timing information with the highest preference, and 12 bytes
+  // into that block is the size information.
+  // 66: width least significant bits
+  // 67: height least significant bits
+  // 68: 4 bits for each of width and height most significant bits
+  if (data[54] == 0)
+    return false;
+  const int w = ((data[68] & 0xF0) << 4) + data[66];
+  const int h = ((data[68] & 0x0F) << 8) + data[67];
+
+  if (w <= 0 || h <= 0)
+    return false;
+
+  *width_mm = w;
+  *height_mm = h;
+
+  return true;
+}
+
+bool GetInterfaceDetailAndDeviceInfo(
+    HDEVINFO device_info_list,
+    SP_DEVICE_INTERFACE_DATA* interface_data,
+    std::unique_ptr<SP_DEVICE_INTERFACE_DETAIL_DATA, base::FreeDeleter>*
+        interface_detail,
+    SP_DEVINFO_DATA* device_info) {
+  DCHECK_EQ(sizeof(*device_info), device_info->cbSize);
+  DWORD buffer_size;
+  // This call populates device_info. It will also fail, but if the error is
+  // "insufficient buffer" then it will set buffer_size and we can call again
+  // with an allocated buffer.
+  SetupDiGetDeviceInterfaceDetail(device_info_list, interface_data, nullptr, 0,
+                                  &buffer_size, device_info);
+  if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+    return false;
+
+  interface_detail->reset(
+      reinterpret_cast<SP_DEVICE_INTERFACE_DETAIL_DATA*>(malloc(buffer_size)));
+  (*interface_detail)->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+  return SetupDiGetDeviceInterfaceDetail(device_info_list, interface_data,
+                                         interface_detail->get(), buffer_size,
+                                         nullptr, nullptr) != 0;
+}
+
+}  // namespace
+
+namespace gfx {
+
+// The physical size information is only available by looking in the EDID block
+// via setup. However setup has the device path and not the device name that we
+// use to identify displays. Therefore after looking up a device via setup we
+// need to find the display again via EnumDisplayDevices (matching device path
+// to the device ID of the display's interface) so we can return the device name
+// (available from the interface's attached monitor).
+std::vector<PhysicalDisplaySize> GetPhysicalSizeForDisplays() {
+  std::vector<PhysicalDisplaySize> out;
+
+  base::ScopedGeneric<HDEVINFO, DeviceInfoListScopedTraits> device_info_list(
+      SetupDiGetClassDevs(&GUID_DEVICEINTERFACE_MONITOR, nullptr, nullptr,
+                          DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));
+
+  if (!device_info_list.is_valid())
+    return out;
+
+  SP_DEVICE_INTERFACE_DATA interface_data = {};
+  interface_data.cbSize = sizeof(interface_data);
+  int interface_index = 0;
+  while (SetupDiEnumDeviceInterfaces(device_info_list.get(), nullptr,
+                                     &GUID_DEVICEINTERFACE_MONITOR,
+                                     interface_index++, &interface_data)) {
+    std::unique_ptr<SP_DEVICE_INTERFACE_DETAIL_DATA, base::FreeDeleter>
+        interface_detail;
+    SP_DEVINFO_DATA device_info = {};
+    device_info.cbSize = sizeof(device_info);
+    bool get_info_succeeded =
+        GetInterfaceDetailAndDeviceInfo(device_info_list.get(), &interface_data,
+                                        &interface_detail, &device_info);
+    if (!get_info_succeeded)
+      continue;
+
+    DISPLAY_DEVICE display_device = {};
+    display_device.cb = sizeof(display_device);
+    int display_index = 0;
+    while (EnumDisplayDevices(nullptr, display_index++, &display_device,
+                              EDD_GET_DEVICE_INTERFACE_NAME)) {
+      DISPLAY_DEVICE attached_device = {};
+      attached_device.cb = sizeof(attached_device);
+      int attached_index = 0;
+      while (EnumDisplayDevices(display_device.DeviceName, attached_index++,
+                                &attached_device,
+                                EDD_GET_DEVICE_INTERFACE_NAME)) {
+        wchar_t* attached_device_id = attached_device.DeviceID;
+        wchar_t* setup_device_path = interface_detail->DevicePath;
+        if (wcsicmp(attached_device_id, setup_device_path) == 0) {
+          int width_mm;
+          int height_mm;
+          bool found = GetSizeFromRegistry(device_info_list.get(), &device_info,
+                                           &width_mm, &height_mm);
+          if (found) {
+            out.push_back(
+                PhysicalDisplaySize(base::WideToUTF8(display_device.DeviceName),
+                                    width_mm, height_mm));
+          }
+          break;
+        }
+      }
+    }
+  }
+  return out;
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/win/physical_size.h b/ui/gfx/win/physical_size.h
new file mode 100644
index 0000000..5b768ad
--- /dev/null
+++ b/ui/gfx/win/physical_size.h
@@ -0,0 +1,31 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_PHYSICAL_SIZE_H_
+#define UI_GFX_WIN_PHYSICAL_SIZE_H_
+
+#include <string>
+#include <vector>
+
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+struct PhysicalDisplaySize {
+  PhysicalDisplaySize(const std::string& display_name,
+                      int width_mm,
+                      int height_mm)
+      : display_name(display_name), width_mm(width_mm), height_mm(height_mm) {}
+
+  std::string display_name;
+  int width_mm;
+  int height_mm;
+};
+
+// Gets the physical size for all displays.
+GFX_EXPORT std::vector<PhysicalDisplaySize> GetPhysicalSizeForDisplays();
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_PHYSICAL_SIZE_H_
diff --git a/ui/gfx/win/rendering_window_manager.cc b/ui/gfx/win/rendering_window_manager.cc
new file mode 100644
index 0000000..8536882
--- /dev/null
+++ b/ui/gfx/win/rendering_window_manager.cc
@@ -0,0 +1,80 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/win/rendering_window_manager.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
+
+namespace gfx {
+
+// static
+RenderingWindowManager* RenderingWindowManager::GetInstance() {
+  static base::NoDestructor<RenderingWindowManager> instance;
+  return instance.get();
+}
+
+void RenderingWindowManager::RegisterParent(HWND parent) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  registered_hwnds_.emplace(parent, nullptr);
+}
+
+void RenderingWindowManager::RegisterChild(HWND parent,
+                                           HWND child,
+                                           DWORD expected_child_process_id) {
+  if (!child)
+    return;
+
+  // This can be called from any thread, if we're not on the correct thread then
+  // PostTask back to the UI thread before doing anything.
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE, base::BindOnce(&RenderingWindowManager::RegisterChild,
+                                  base::Unretained(this), parent, child,
+                                  expected_child_process_id));
+    return;
+  }
+
+  // Check that |parent| was registered as a HWND that could have a child HWND.
+  auto it = registered_hwnds_.find(parent);
+  if (it == registered_hwnds_.end())
+    return;
+
+  // Check that |child| belongs to the GPU process.
+  DWORD child_process_id = 0;
+  DWORD child_thread_id = GetWindowThreadProcessId(child, &child_process_id);
+  if (!child_thread_id || child_process_id != expected_child_process_id) {
+    DLOG(ERROR) << "Child HWND not owned by GPU process.";
+    return;
+  }
+
+  it->second = child;
+
+  ::SetParent(child, parent);
+  // Move D3D window behind Chrome's window to avoid losing some messages.
+  ::SetWindowPos(child, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+}
+
+void RenderingWindowManager::UnregisterParent(HWND parent) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  registered_hwnds_.erase(parent);
+}
+
+bool RenderingWindowManager::HasValidChildWindow(HWND parent) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  auto it = registered_hwnds_.find(parent);
+  if (it == registered_hwnds_.end())
+    return false;
+  return !!it->second && ::IsWindow(it->second);
+}
+
+RenderingWindowManager::RenderingWindowManager()
+    : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
+
+RenderingWindowManager::~RenderingWindowManager() = default;
+
+}  // namespace gfx
diff --git a/ui/gfx/win/rendering_window_manager.h b/ui/gfx/win/rendering_window_manager.h
new file mode 100644
index 0000000..dd729b1
--- /dev/null
+++ b/ui/gfx/win/rendering_window_manager.h
@@ -0,0 +1,59 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_RENDERING_WINDOW_MANAGER_H_
+#define UI_GFX_WIN_RENDERING_WINDOW_MANAGER_H_
+
+#include <windows.h>
+
+#include "base/containers/flat_map.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/no_destructor.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
+
+namespace gfx {
+
+// This keeps track of whether a given HWND has a child window which the GPU
+// process renders into. This should only be used from the UI thread unless
+// otherwise noted.
+class GFX_EXPORT RenderingWindowManager {
+ public:
+  // The first call to GetInstance() should happen on the UI thread.
+  static RenderingWindowManager* GetInstance();
+
+  RenderingWindowManager(const RenderingWindowManager&) = delete;
+  RenderingWindowManager& operator=(const RenderingWindowManager&) = delete;
+
+  void RegisterParent(HWND parent);
+  // Registers |child| as child window for |parent|. Allows the GPU process to
+  // draw into the |child| HWND instead of |parent|. This will fail and do
+  // nothing if:
+  //   1. |parent| isn't registered.
+  //   2. |child| doesn't belong to |expected_child_process_id|.
+  //
+  // Can be called from any thread, as long GetInstance() has already been
+  // called on the UI thread at least once.
+  void RegisterChild(HWND parent, HWND child, DWORD expected_child_process_id);
+  void UnregisterParent(HWND parent);
+  bool HasValidChildWindow(HWND parent);
+
+ private:
+  friend class base::NoDestructor<RenderingWindowManager>;
+
+  RenderingWindowManager();
+  ~RenderingWindowManager();
+
+  // UI thread task runner.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  // Map from registered parent HWND to child HWND.
+  base::flat_map<HWND, HWND> registered_hwnds_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_RENDERING_WINDOW_MANAGER_H_
diff --git a/ui/gfx/win/scoped_set_map_mode.h b/ui/gfx/win/scoped_set_map_mode.h
new file mode 100644
index 0000000..f5669fe
--- /dev/null
+++ b/ui/gfx/win/scoped_set_map_mode.h
@@ -0,0 +1,41 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_SCOPED_SET_MAP_MODE_H_
+#define UI_GFX_WIN_SCOPED_SET_MAP_MODE_H_
+
+#include <windows.h>
+
+#include "base/check_op.h"
+#include "base/macros.h"
+
+namespace gfx {
+
+// Helper class for setting and restore the map mode on a DC.
+class ScopedSetMapMode {
+ public:
+  ScopedSetMapMode(HDC hdc, int map_mode)
+      : hdc_(hdc),
+        old_map_mode_(SetMapMode(hdc, map_mode)) {
+    DCHECK(hdc_);
+    DCHECK_NE(map_mode, 0);
+    DCHECK_NE(old_map_mode_, 0);
+  }
+
+  ScopedSetMapMode(const ScopedSetMapMode&) = delete;
+  ScopedSetMapMode& operator=(const ScopedSetMapMode&) = delete;
+
+  ~ScopedSetMapMode() {
+    const int mode = SetMapMode(hdc_, old_map_mode_);
+    DCHECK_NE(mode, 0);
+  }
+
+ private:
+  HDC hdc_;
+  int old_map_mode_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_SCOPED_SET_MAP_MODE_H_
diff --git a/ui/gfx/win/singleton_hwnd.cc b/ui/gfx/win/singleton_hwnd.cc
new file mode 100644
index 0000000..1476b11
--- /dev/null
+++ b/ui/gfx/win/singleton_hwnd.cc
@@ -0,0 +1,66 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/win/singleton_hwnd.h"
+
+#include "base/memory/singleton.h"
+#include "base/task/current_thread.h"
+#include "ui/gfx/win/singleton_hwnd_observer.h"
+
+namespace gfx {
+
+// static
+SingletonHwnd* SingletonHwnd::GetInstance() {
+  return base::Singleton<SingletonHwnd>::get();
+}
+
+BOOL SingletonHwnd::ProcessWindowMessage(HWND window,
+                                         UINT message,
+                                         WPARAM wparam,
+                                         LPARAM lparam,
+                                         LRESULT& result,
+                                         DWORD msg_map_id) {
+  if (!base::CurrentUIThread::IsSet()) {
+    // If there is no MessageLoop and SingletonHwnd is receiving messages, this
+    // means it is receiving messages via an external message pump such as COM
+    // uninitialization.
+    //
+    // It is unsafe to forward these messages as observers may depend on the
+    // existence of a MessageLoop to proceed.
+    return false;
+  }
+
+  for (SingletonHwndObserver& observer : observer_list_)
+    observer.OnWndProc(window, message, wparam, lparam);
+  return false;
+}
+
+SingletonHwnd::SingletonHwnd() {
+  if (!base::CurrentUIThread::IsSet()) {
+    // Creating this window in (e.g.) a renderer inhibits shutdown on
+    // Windows. See http://crbug.com/230122 and http://crbug.com/236039.
+    return;
+  }
+  WindowImpl::Init(NULL, Rect());
+}
+
+SingletonHwnd::~SingletonHwnd() {
+  // WindowImpl will clean up the hwnd value on WM_NCDESTROY.
+  if (hwnd())
+    DestroyWindow(hwnd());
+
+  // Tell all of our current observers to clean themselves up.
+  for (SingletonHwndObserver& observer : observer_list_)
+    observer.ClearWndProc();
+}
+
+void SingletonHwnd::AddObserver(SingletonHwndObserver* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void SingletonHwnd::RemoveObserver(SingletonHwndObserver* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/win/singleton_hwnd.h b/ui/gfx/win/singleton_hwnd.h
new file mode 100644
index 0000000..36daf55
--- /dev/null
+++ b/ui/gfx/win/singleton_hwnd.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_SINGLETON_HWND_H_
+#define UI_GFX_WIN_SINGLETON_HWND_H_
+
+#include <windows.h>
+
+#include "base/macros.h"
+#include "base/observer_list.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/win/window_impl.h"
+
+namespace base {
+template<typename T> struct DefaultSingletonTraits;
+}
+
+namespace gfx {
+
+class SingletonHwndObserver;
+
+// Singleton message-only HWND that allows interested clients to receive WM_*
+// notifications.
+class GFX_EXPORT SingletonHwnd : public WindowImpl {
+ public:
+  static SingletonHwnd* GetInstance();
+
+  SingletonHwnd(const SingletonHwnd&) = delete;
+  SingletonHwnd& operator=(const SingletonHwnd&) = delete;
+
+  // Windows callback for WM_* notifications.
+  BOOL ProcessWindowMessage(HWND window,
+                            UINT message,
+                            WPARAM wparam,
+                            LPARAM lparam,
+                            LRESULT& result,
+                            DWORD msg_map_id) override;
+
+ private:
+  friend class SingletonHwndObserver;
+  friend struct base::DefaultSingletonTraits<SingletonHwnd>;
+
+  SingletonHwnd();
+  ~SingletonHwnd() override;
+
+  // Add/remove SingletonHwndObserver to forward WM_* notifications.
+  void AddObserver(SingletonHwndObserver* observer);
+  void RemoveObserver(SingletonHwndObserver* observer);
+
+  // List of registered observers.
+  base::ObserverList<SingletonHwndObserver, true>::Unchecked observer_list_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_SINGLETON_HWND_H_
diff --git a/ui/gfx/win/singleton_hwnd_hot_key_observer.cc b/ui/gfx/win/singleton_hwnd_hot_key_observer.cc
new file mode 100644
index 0000000..be3d7c2
--- /dev/null
+++ b/ui/gfx/win/singleton_hwnd_hot_key_observer.cc
@@ -0,0 +1,96 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/win/singleton_hwnd_hot_key_observer.h"
+
+#include "base/bind.h"
+#include "base/containers/flat_set.h"
+#include "base/memory/ptr_util.h"
+#include "base/no_destructor.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/win/singleton_hwnd.h"
+
+namespace gfx {
+
+namespace {
+
+base::flat_set<int>& GetUsedHotKeyIDs() {
+  static base::NoDestructor<base::flat_set<int>> used_hot_key_ids;
+  return *used_hot_key_ids;
+}
+
+absl::optional<int> GetAvailableHotKeyID() {
+  // Valid hot key IDs are in the range 0x0000 to 0xBFFF. See
+  // https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-registerhotkey
+  for (int i = 0x0000; i < 0xBFFF; i++) {
+    if (!GetUsedHotKeyIDs().contains(i))
+      return i;
+  }
+  return absl::nullopt;
+}
+
+void SetHotKeyIDUsed(int id) {
+  DCHECK(!GetUsedHotKeyIDs().contains(id));
+  GetUsedHotKeyIDs().insert(id);
+}
+
+void SetHotKeyIDAvailable(int id) {
+  DCHECK(GetUsedHotKeyIDs().contains(id));
+  GetUsedHotKeyIDs().erase(id);
+}
+
+}  // anonymous namespace
+
+std::unique_ptr<SingletonHwndHotKeyObserver>
+SingletonHwndHotKeyObserver::Create(
+    const SingletonHwndObserver::WndProc& wnd_proc,
+    UINT key_code,
+    int modifiers) {
+  absl::optional<int> hot_key_id = GetAvailableHotKeyID();
+
+  // If there are no available hot key IDs, return null.
+  if (!hot_key_id.has_value())
+    return nullptr;
+
+  // If we fail to register the hot key, return null. Most likely reason for
+  // failure is that another application has already registered the hot key.
+  if (!RegisterHotKey(gfx::SingletonHwnd::GetInstance()->hwnd(), *hot_key_id,
+                      modifiers, key_code)) {
+    return nullptr;
+  }
+
+  return base::WrapUnique(
+      new SingletonHwndHotKeyObserver(wnd_proc, *hot_key_id));
+}
+
+SingletonHwndHotKeyObserver::SingletonHwndHotKeyObserver(
+    const SingletonHwndObserver::WndProc& wnd_proc,
+    int hot_key_id)
+    : observer_(base::BindRepeating(&SingletonHwndHotKeyObserver::OnWndProc,
+                                    base::Unretained(this))),
+      wnd_proc_(wnd_proc),
+      hot_key_id_(hot_key_id) {
+  SetHotKeyIDUsed(hot_key_id);
+}
+
+SingletonHwndHotKeyObserver::~SingletonHwndHotKeyObserver() {
+  bool success = !!UnregisterHotKey(gfx::SingletonHwnd::GetInstance()->hwnd(),
+                                    hot_key_id_);
+  // This call should always succeed, as long as we pass in the right HWND and
+  // an id we've used to register before.
+  DCHECK(success);
+  SetHotKeyIDAvailable(hot_key_id_);
+}
+
+void SingletonHwndHotKeyObserver::OnWndProc(HWND hwnd,
+                                            UINT message,
+                                            WPARAM wparam,
+                                            LPARAM lparam) {
+  // Only propagate WM_HOTKEY messages for this particular hot key to the owner
+  // of this observer.
+  if (message == WM_HOTKEY && static_cast<int>(wparam) == hot_key_id_)
+    wnd_proc_.Run(hwnd, message, wparam, lparam);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/win/singleton_hwnd_hot_key_observer.h b/ui/gfx/win/singleton_hwnd_hot_key_observer.h
new file mode 100644
index 0000000..5b003ce
--- /dev/null
+++ b/ui/gfx/win/singleton_hwnd_hot_key_observer.h
@@ -0,0 +1,53 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_SINGLETON_HWND_HOT_KEY_OBSERVER_H_
+#define UI_GFX_WIN_SINGLETON_HWND_HOT_KEY_OBSERVER_H_
+
+#include "base/win/windows_types.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/win/singleton_hwnd_observer.h"
+
+namespace gfx {
+
+// We need to avoid duplicate hot key IDs for SingletonHwndObservers that call
+// RegisterHotKey for SingletonHwnd. This class properly handles getting a
+// unique hot key ID, registers the hotkey on construction, and unregisters the
+// hot key on destruction.
+//
+// This class should always be used instead of directly registering hot keys on
+// the SingletonHwnd with a SingletonHwndObserver in order to prevent duplicate
+// hot key IDs.
+class GFX_EXPORT SingletonHwndHotKeyObserver {
+ public:
+  // Registers a hot key with the given |key_code| and |modifiers| and returns
+  // a SingletonHwndHotKeyObserver if successful. Returns null if the hot key
+  // fails to register, which can happen if another application has already
+  // registered the hot key.
+  static std::unique_ptr<SingletonHwndHotKeyObserver> Create(
+      const SingletonHwndObserver::WndProc& wnd_proc,
+      UINT key_code,
+      int modifiers);
+
+  SingletonHwndHotKeyObserver(const SingletonHwndHotKeyObserver&) = delete;
+  SingletonHwndHotKeyObserver& operator=(const SingletonHwndHotKeyObserver&) =
+      delete;
+
+  ~SingletonHwndHotKeyObserver();
+
+ private:
+  SingletonHwndHotKeyObserver(const SingletonHwndObserver::WndProc& wnd_proc,
+                              int hot_key_id);
+
+  // Called by SingletonHwndObserver.
+  void OnWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+
+  SingletonHwndObserver observer_;
+  SingletonHwndObserver::WndProc wnd_proc_;
+  const int hot_key_id_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_SINGLETON_HWND_HOT_KEY_OBSERVER_H_
diff --git a/ui/gfx/win/singleton_hwnd_observer.cc b/ui/gfx/win/singleton_hwnd_observer.cc
new file mode 100644
index 0000000..f439105
--- /dev/null
+++ b/ui/gfx/win/singleton_hwnd_observer.cc
@@ -0,0 +1,35 @@
+// Copyright 2015 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.
+
+#include "ui/gfx/win/singleton_hwnd_observer.h"
+
+#include "ui/gfx/win/singleton_hwnd.h"
+
+namespace gfx {
+
+SingletonHwndObserver::SingletonHwndObserver(const WndProc& wnd_proc)
+    : wnd_proc_(wnd_proc) {
+  DCHECK(!wnd_proc.is_null());
+  SingletonHwnd::GetInstance()->AddObserver(this);
+}
+
+SingletonHwndObserver::~SingletonHwndObserver() {
+  ClearWndProc();
+}
+
+void SingletonHwndObserver::ClearWndProc() {
+  if (!wnd_proc_.is_null()) {
+    SingletonHwnd::GetInstance()->RemoveObserver(this);
+    wnd_proc_.Reset();
+  }
+}
+
+void SingletonHwndObserver::OnWndProc(HWND hwnd,
+                                      UINT message,
+                                      WPARAM wparam,
+                                      LPARAM lparam) {
+  wnd_proc_.Run(hwnd, message, wparam, lparam);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/win/singleton_hwnd_observer.h b/ui/gfx/win/singleton_hwnd_observer.h
new file mode 100644
index 0000000..cc2ef8a
--- /dev/null
+++ b/ui/gfx/win/singleton_hwnd_observer.h
@@ -0,0 +1,44 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_SINGLETON_HWND_OBSERVER_H_
+#define UI_GFX_WIN_SINGLETON_HWND_OBSERVER_H_
+
+#include <windows.h>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+
+class SingletonHwnd;
+
+// Singleton lifetime management is tricky. This observer handles the correct
+// cleanup if either the SingletonHwnd or forwarded object is destroyed first.
+// Note that if you want to register a hot key on the SingletonHwnd, you need to
+// use a SingletonHwndHotKeyObserver instead for each hot key.
+class GFX_EXPORT SingletonHwndObserver {
+ public:
+  using WndProc = base::RepeatingCallback<void(HWND, UINT, WPARAM, LPARAM)>;
+
+  explicit SingletonHwndObserver(const WndProc& wnd_proc);
+
+  SingletonHwndObserver(const SingletonHwndObserver&) = delete;
+  SingletonHwndObserver& operator=(const SingletonHwndObserver&) = delete;
+
+  ~SingletonHwndObserver();
+
+ private:
+  friend class SingletonHwnd;
+
+  void ClearWndProc();
+  void OnWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+
+  WndProc wnd_proc_;
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_SINGLETON_HWND_OBSERVER_H_
diff --git a/ui/gfx/win/text_analysis_source.cc b/ui/gfx/win/text_analysis_source.cc
new file mode 100644
index 0000000..13fef96
--- /dev/null
+++ b/ui/gfx/win/text_analysis_source.cc
@@ -0,0 +1,95 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/win/text_analysis_source.h"
+
+#include "base/check.h"
+
+namespace gfx {
+namespace win {
+
+HRESULT TextAnalysisSource::Create(
+    IDWriteTextAnalysisSource** text_analysis_out,
+    const std::wstring& text,
+    const std::wstring& locale_name,
+    IDWriteNumberSubstitution* number_substitution,
+    DWRITE_READING_DIRECTION reading_direction) {
+  return Microsoft::WRL::MakeAndInitialize<gfx::win::TextAnalysisSource>(
+      text_analysis_out, text, locale_name, number_substitution,
+      reading_direction);
+}
+
+TextAnalysisSource::TextAnalysisSource() = default;
+TextAnalysisSource::~TextAnalysisSource() = default;
+
+HRESULT TextAnalysisSource::GetLocaleName(UINT32 text_position,
+                                          UINT32* text_length,
+                                          const WCHAR** locale_name) {
+  if (text_position >= text_.length() || !text_length || !locale_name)
+    return E_INVALIDARG;
+  *text_length = text_.length() - text_position;
+  *locale_name = locale_name_.c_str();
+  return S_OK;
+}
+
+HRESULT TextAnalysisSource::GetNumberSubstitution(
+    UINT32 text_position,
+    UINT32* text_length,
+    IDWriteNumberSubstitution** number_substitution) {
+  if (text_position >= text_.length() || !text_length || !number_substitution)
+    return E_INVALIDARG;
+  *text_length = text_.length() - text_position;
+  number_substitution_.CopyTo(number_substitution);
+  return S_OK;
+}
+
+DWRITE_READING_DIRECTION TextAnalysisSource::GetParagraphReadingDirection() {
+  return reading_direction_;
+}
+
+HRESULT TextAnalysisSource::GetTextAtPosition(UINT32 text_position,
+                                              const WCHAR** text_string,
+                                              UINT32* text_length) {
+  if (!text_length || !text_string)
+    return E_INVALIDARG;
+  if (text_position >= text_.length()) {
+    *text_string = nullptr;
+    *text_length = 0;
+    return S_OK;
+  }
+  *text_string = text_.c_str() + text_position;
+  *text_length = text_.length() - text_position;
+  return S_OK;
+}
+
+HRESULT TextAnalysisSource::GetTextBeforePosition(UINT32 text_position,
+                                                  const WCHAR** text_string,
+                                                  UINT32* text_length) {
+  if (!text_length || !text_string)
+    return E_INVALIDARG;
+  if (text_position < 1 || text_position > text_.length()) {
+    *text_string = nullptr;
+    *text_length = 0;
+    return S_OK;
+  }
+  *text_string = text_.c_str();
+  *text_length = text_position;
+  return S_OK;
+}
+
+HRESULT TextAnalysisSource::RuntimeClassInitialize(
+    const std::wstring& text,
+    const std::wstring& locale_name,
+    IDWriteNumberSubstitution* number_substitution,
+    DWRITE_READING_DIRECTION reading_direction) {
+  DCHECK(number_substitution);
+  text_ = text;
+  locale_name_ = locale_name;
+  number_substitution_ = number_substitution;
+  reading_direction_ = reading_direction;
+  return S_OK;
+}
+
+}  // namespace win
+}  // namespace gfx
diff --git a/ui/gfx/win/text_analysis_source.h b/ui/gfx/win/text_analysis_source.h
new file mode 100644
index 0000000..93ce417
--- /dev/null
+++ b/ui/gfx/win/text_analysis_source.h
@@ -0,0 +1,78 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_TEXT_ANALYSIS_SOURCE_H_
+#define UI_GFX_WIN_TEXT_ANALYSIS_SOURCE_H_
+
+#include <dwrite.h>
+#include <wrl.h>
+
+#include <string>
+
+#include "base/macros.h"
+#include "ui/gfx/gfx_export.h"
+
+namespace gfx {
+namespace win {
+
+// Implements an IDWriteTextAnalysisSource, describing a single pre-defined
+// chunk of text with a uniform locale, reading direction, and number
+// substitution.
+class TextAnalysisSource
+    : public Microsoft::WRL::RuntimeClass<
+          Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
+          IDWriteTextAnalysisSource> {
+ public:
+  // Factory method to avoid exporting the class and all it derives from.
+  static GFX_EXPORT HRESULT
+  Create(IDWriteTextAnalysisSource** text_analysis_out,
+         const std::wstring& text,
+         const std::wstring& locale_name,
+         IDWriteNumberSubstitution* number_substitution,
+         DWRITE_READING_DIRECTION reading_direction);
+
+  // Use Create() to construct these objects. Direct calls to the constructor
+  // are an error - it is only public because a WRL helper function creates the
+  // objects.
+  TextAnalysisSource();
+
+  TextAnalysisSource& operator=(const TextAnalysisSource&) = delete;
+
+  // IDWriteTextAnalysisSource:
+  HRESULT STDMETHODCALLTYPE GetLocaleName(UINT32 text_position,
+                                          UINT32* text_length,
+                                          const WCHAR** locale_name) override;
+  HRESULT STDMETHODCALLTYPE GetNumberSubstitution(
+      UINT32 text_position,
+      UINT32* text_length,
+      IDWriteNumberSubstitution** number_substitution) override;
+  DWRITE_READING_DIRECTION STDMETHODCALLTYPE
+  GetParagraphReadingDirection() override;
+  HRESULT STDMETHODCALLTYPE GetTextAtPosition(UINT32 text_position,
+                                              const WCHAR** text_string,
+                                              UINT32* text_length) override;
+  HRESULT STDMETHODCALLTYPE GetTextBeforePosition(UINT32 text_position,
+                                                  const WCHAR** text_string,
+                                                  UINT32* text_length) override;
+
+  HRESULT STDMETHODCALLTYPE
+  RuntimeClassInitialize(const std::wstring& text,
+                         const std::wstring& locale_name,
+                         IDWriteNumberSubstitution* number_substitution,
+                         DWRITE_READING_DIRECTION reading_direction);
+
+ protected:
+  ~TextAnalysisSource() override;
+
+ private:
+  std::wstring text_;
+  std::wstring locale_name_;
+  Microsoft::WRL::ComPtr<IDWriteNumberSubstitution> number_substitution_;
+  DWRITE_READING_DIRECTION reading_direction_;
+};
+
+}  // namespace win
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_TEXT_ANALYSIS_SOURCE_H_
diff --git a/ui/gfx/win/text_analysis_source_unittest.cc b/ui/gfx/win/text_analysis_source_unittest.cc
new file mode 100644
index 0000000..7886218
--- /dev/null
+++ b/ui/gfx/win/text_analysis_source_unittest.cc
@@ -0,0 +1,133 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/win/text_analysis_source.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/win/direct_write.h"
+
+namespace mswr = Microsoft::WRL;
+
+namespace gfx {
+namespace win {
+
+namespace {
+
+DWRITE_READING_DIRECTION kReadingDirection =
+    DWRITE_READING_DIRECTION_TOP_TO_BOTTOM;
+const wchar_t* kLocale = L"hi-in";
+const wchar_t kText[] = L"sample text";
+const size_t kTextLength = _countof(kText) - 1;
+
+}  // namespace
+
+class TextAnalysisSourceTest : public testing::Test {
+ public:
+  TextAnalysisSourceTest() {
+    mswr::ComPtr<IDWriteFactory> factory;
+    CreateDWriteFactory(&factory);
+
+    mswr::ComPtr<IDWriteNumberSubstitution> number_substitution;
+    factory->CreateNumberSubstitution(DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE,
+                                      kLocale, true /* ignoreUserOverride */,
+                                      &number_substitution);
+
+    TextAnalysisSource::Create(&source_, kText, kLocale,
+                               number_substitution.Get(), kReadingDirection);
+  }
+
+  TextAnalysisSourceTest(const TextAnalysisSourceTest&) = delete;
+  TextAnalysisSourceTest& operator=(const TextAnalysisSourceTest&) = delete;
+
+ protected:
+  mswr::ComPtr<IDWriteTextAnalysisSource> source_;
+};
+
+TEST_F(TextAnalysisSourceTest, TestGetLocaleName) {
+  UINT32 length = 0;
+  const wchar_t* locale_name = nullptr;
+  HRESULT hr = E_FAIL;
+  hr = source_->GetLocaleName(0, &length, &locale_name);
+
+  EXPECT_TRUE(SUCCEEDED(hr));
+  EXPECT_EQ(kTextLength, length);
+  EXPECT_STREQ(kLocale, locale_name);
+
+  // Attempting to get a locale for a location that does not have a text chunk
+  // should fail.
+  hr = source_->GetLocaleName(kTextLength, &length, &locale_name);
+
+  EXPECT_TRUE(FAILED(hr));
+}
+
+TEST_F(TextAnalysisSourceTest, TestGetNumberSubstitution) {
+  UINT32 length = 0;
+  mswr::ComPtr<IDWriteNumberSubstitution> number_substitution;
+  HRESULT hr = E_FAIL;
+  hr = source_->GetNumberSubstitution(0, &length, &number_substitution);
+
+  EXPECT_TRUE(SUCCEEDED(hr));
+  EXPECT_EQ(kTextLength, length);
+  EXPECT_NE(nullptr, number_substitution.Get());
+
+  // Attempting to get a number substitution for a location that does not have
+  // a text chunk should fail.
+  hr = source_->GetNumberSubstitution(kTextLength, &length,
+                                      &number_substitution);
+
+  EXPECT_TRUE(FAILED(hr));
+}
+
+TEST_F(TextAnalysisSourceTest, TestGetParagraphReadingDirection) {
+  EXPECT_EQ(kReadingDirection, source_->GetParagraphReadingDirection());
+}
+
+TEST_F(TextAnalysisSourceTest, TestGetTextAtPosition) {
+  UINT32 length = 0;
+  const wchar_t* text = nullptr;
+  HRESULT hr = E_FAIL;
+  hr = source_->GetTextAtPosition(0, &text, &length);
+
+  EXPECT_TRUE(SUCCEEDED(hr));
+  EXPECT_EQ(kTextLength, length);
+  EXPECT_STREQ(kText, text);
+
+  hr = source_->GetTextAtPosition(5, &text, &length);
+
+  EXPECT_TRUE(SUCCEEDED(hr));
+  EXPECT_EQ(kTextLength - 5, length);
+  EXPECT_STREQ(kText + 5, text);
+
+  // Trying to get a text chunk past the end should return null.
+  hr = source_->GetTextAtPosition(kTextLength, &text, &length);
+
+  EXPECT_TRUE(SUCCEEDED(hr));
+  EXPECT_EQ(nullptr, text);
+}
+
+TEST_F(TextAnalysisSourceTest, TestGetTextBeforePosition) {
+  UINT32 length = 0;
+  const wchar_t* text = nullptr;
+  HRESULT hr = E_FAIL;
+  // Trying to get a text chunk before the beginning should return null.
+  hr = source_->GetTextBeforePosition(0, &text, &length);
+
+  EXPECT_TRUE(SUCCEEDED(hr));
+  EXPECT_EQ(nullptr, text);
+
+  hr = source_->GetTextBeforePosition(5, &text, &length);
+
+  EXPECT_TRUE(SUCCEEDED(hr));
+  EXPECT_EQ(5u, length);
+  EXPECT_STREQ(kText, text);
+
+  hr = source_->GetTextBeforePosition(kTextLength, &text, &length);
+
+  EXPECT_TRUE(SUCCEEDED(hr));
+  EXPECT_EQ(kTextLength, length);
+  EXPECT_STREQ(kText, text);
+}
+
+}  // namespace win
+}  // namespace gfx
diff --git a/ui/gfx/win/window_impl.cc b/ui/gfx/win/window_impl.cc
new file mode 100644
index 0000000..0fdf80b
--- /dev/null
+++ b/ui/gfx/win/window_impl.cc
@@ -0,0 +1,317 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/win/window_impl.h"
+
+#include <list>
+
+#include "base/bind.h"
+#include "base/cxx17_backports.h"
+#include "base/debug/alias.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/singleton.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/synchronization/lock.h"
+#include "base/win/win_util.h"
+#include "base/win/wrapped_window_proc.h"
+#include "ui/gfx/win/crash_id_helper.h"
+#include "ui/gfx/win/hwnd_util.h"
+
+namespace gfx {
+
+static const DWORD kWindowDefaultChildStyle =
+    WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
+static const DWORD kWindowDefaultStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
+
+///////////////////////////////////////////////////////////////////////////////
+// WindowImpl class tracking.
+
+// Several external scripts rely explicitly on this base class name for
+// acquiring the window handle and will break if this is modified!
+// static
+const wchar_t* const WindowImpl::kBaseClassName = L"Chrome_WidgetWin_";
+
+// WindowImpl class information used for registering unique windows.
+struct ClassInfo {
+  ClassInfo(int style, HICON icon, HICON small_icon)
+      : style(style), icon(icon), small_icon(small_icon) {}
+
+  // Compares two ClassInfos. Returns true if all members match.
+  bool Equals(const ClassInfo& other) const {
+    return (other.style == style && other.icon == icon &&
+            other.small_icon == small_icon);
+  }
+
+  UINT style;
+  HICON icon;
+  HICON small_icon;
+};
+
+// WARNING: this class may be used on multiple threads.
+class ClassRegistrar {
+ public:
+  ClassRegistrar(const ClassRegistrar&) = delete;
+  ClassRegistrar& operator=(const ClassRegistrar&) = delete;
+
+  ~ClassRegistrar();
+
+  static ClassRegistrar* GetInstance();
+
+  void UnregisterClasses();
+
+  // Returns the atom identifying the class matching |class_info|,
+  // creating and registering a new class if the class is not yet known.
+  ATOM RetrieveClassAtom(const ClassInfo& class_info);
+
+ private:
+  // Represents a registered window class.
+  struct RegisteredClass {
+    RegisteredClass(const ClassInfo& info,
+                    const std::wstring& name,
+                    ATOM atom,
+                    HINSTANCE instance);
+
+    // Info used to create the class.
+    ClassInfo info;
+
+    // The name given to the window class
+    std::wstring name;
+
+    // The atom identifying the window class.
+    ATOM atom;
+
+    // The handle of the module containing the window proceedure.
+    HMODULE instance;
+  };
+
+  ClassRegistrar();
+  friend struct base::DefaultSingletonTraits<ClassRegistrar>;
+
+  typedef std::list<RegisteredClass> RegisteredClasses;
+  RegisteredClasses registered_classes_;
+
+  // Counter of how many classes have been registered so far.
+  int registered_count_;
+
+  base::Lock lock_;
+};
+
+ClassRegistrar::~ClassRegistrar() {}
+
+// static
+ClassRegistrar* ClassRegistrar::GetInstance() {
+  return base::Singleton<ClassRegistrar,
+                         base::LeakySingletonTraits<ClassRegistrar>>::get();
+}
+
+void ClassRegistrar::UnregisterClasses() {
+  for (RegisteredClasses::iterator i = registered_classes_.begin();
+        i != registered_classes_.end(); ++i) {
+     if (UnregisterClass(MAKEINTATOM(i->atom), i->instance)) {
+       registered_classes_.erase(i);
+     } else {
+       LOG(ERROR) << "Failed to unregister class " << i->name
+                  << ". Error = " << GetLastError();
+     }
+   }
+}
+
+ATOM ClassRegistrar::RetrieveClassAtom(const ClassInfo& class_info) {
+  base::AutoLock auto_lock(lock_);
+  for (RegisteredClasses::const_iterator i = registered_classes_.begin();
+       i != registered_classes_.end(); ++i) {
+    if (class_info.Equals(i->info))
+      return i->atom;
+  }
+
+  // No class found, need to register one.
+  std::wstring name = std::wstring(WindowImpl::kBaseClassName) +
+                      base::NumberToWString(registered_count_++);
+
+  WNDCLASSEX window_class;
+  base::win::InitializeWindowClass(
+      name.c_str(), &base::win::WrappedWindowProc<WindowImpl::WndProc>,
+      class_info.style, 0, 0, NULL,
+      reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)), NULL,
+      class_info.icon, class_info.small_icon, &window_class);
+  HMODULE instance = window_class.hInstance;
+  ATOM atom = RegisterClassEx(&window_class);
+  if (!atom) {
+    // Perhaps the Window session has run out of atoms; see
+    // https://crbug.com/653493.
+    auto last_error = ::GetLastError();
+    base::debug::Alias(&last_error);
+    wchar_t name_copy[64];
+    base::wcslcpy(name_copy, name.c_str(), base::size(name_copy));
+    base::debug::Alias(name_copy);
+    PCHECK(atom);
+  }
+
+  registered_classes_.push_back(RegisteredClass(
+      class_info, name, atom, instance));
+
+  return atom;
+}
+
+ClassRegistrar::RegisteredClass::RegisteredClass(const ClassInfo& info,
+                                                 const std::wstring& name,
+                                                 ATOM atom,
+                                                 HMODULE instance)
+    : info(info), name(name), atom(atom), instance(instance) {}
+
+ClassRegistrar::ClassRegistrar() : registered_count_(0) {}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// WindowImpl, public
+
+WindowImpl::WindowImpl(const std::string& debugging_id)
+    : debugging_id_(debugging_id), class_style_(CS_DBLCLKS) {}
+
+WindowImpl::~WindowImpl() {
+  ClearUserData();
+}
+
+// static
+void WindowImpl::UnregisterClassesAtExit() {
+  base::AtExitManager::RegisterTask(
+      base::BindOnce(&ClassRegistrar::UnregisterClasses,
+                     base::Unretained(ClassRegistrar::GetInstance())));
+}
+
+void WindowImpl::Init(HWND parent, const Rect& bounds) {
+  if (window_style_ == 0)
+    window_style_ = parent ? kWindowDefaultChildStyle : kWindowDefaultStyle;
+
+  if (parent == HWND_DESKTOP) {
+    // Only non-child windows can have HWND_DESKTOP (0) as their parent.
+    CHECK((window_style_ & WS_CHILD) == 0);
+    parent = GetWindowToParentTo(false);
+  } else if (parent == ::GetDesktopWindow()) {
+    // Any type of window can have the "Desktop Window" as their parent.
+    parent = GetWindowToParentTo(true);
+  } else if (parent != HWND_MESSAGE) {
+    CHECK(::IsWindow(parent));
+  }
+
+  int x, y, width, height;
+  if (bounds.IsEmpty()) {
+    x = y = width = height = CW_USEDEFAULT;
+  } else {
+    x = bounds.x();
+    y = bounds.y();
+    width = bounds.width();
+    height = bounds.height();
+  }
+
+  ATOM atom = GetWindowClassAtom();
+  auto weak_this = weak_factory_.GetWeakPtr();
+  HWND hwnd = CreateWindowEx(window_ex_style_,
+                             reinterpret_cast<wchar_t*>(atom), NULL,
+                             window_style_, x, y, width, height,
+                             parent, NULL, NULL, this);
+  const DWORD create_window_error = ::GetLastError();
+
+  // First nccalcszie (during CreateWindow) for captioned windows is
+  // deliberately ignored so force a second one here to get the right
+  // non-client set up.
+  if (hwnd && (window_style_ & WS_CAPTION)) {
+    SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
+                 SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE |
+                 SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW);
+  }
+
+  if (!hwnd_ && create_window_error == 0) {
+    bool still_alive = !!weak_this;
+    base::debug::Alias(&still_alive);
+    base::debug::Alias(&hwnd);
+    base::debug::Alias(&atom);
+    bool got_create = got_create_;
+    base::debug::Alias(&got_create);
+    bool got_valid_hwnd = got_valid_hwnd_;
+    base::debug::Alias(&got_valid_hwnd);
+    WNDCLASSEX class_info;
+    memset(&class_info, 0, sizeof(WNDCLASSEX));
+    class_info.cbSize = sizeof(WNDCLASSEX);
+    BOOL got_class = GetClassInfoEx(GetModuleHandle(NULL),
+                                    reinterpret_cast<wchar_t*>(atom),
+                                    &class_info);
+    base::debug::Alias(&got_class);
+    bool procs_match = got_class && class_info.lpfnWndProc ==
+        base::win::WrappedWindowProc<&WindowImpl::WndProc>;
+    base::debug::Alias(&procs_match);
+    CHECK(false);
+  }
+
+  CheckWindowCreated(hwnd_, create_window_error);
+
+  // The window procedure should have set the data for us.
+  CHECK_EQ(this, GetWindowUserData(hwnd));
+}
+
+HICON WindowImpl::GetDefaultWindowIcon() const {
+  return nullptr;
+}
+
+HICON WindowImpl::GetSmallWindowIcon() const {
+  return nullptr;
+}
+
+LRESULT WindowImpl::OnWndProc(UINT message, WPARAM w_param, LPARAM l_param) {
+  LRESULT result = 0;
+
+  HWND hwnd = hwnd_;
+  if (message == WM_NCDESTROY)
+    hwnd_ = nullptr;
+
+  // Handle the message if it's in our message map; otherwise, let the system
+  // handle it.
+  if (!ProcessWindowMessage(hwnd, message, w_param, l_param, result))
+    result = DefWindowProc(hwnd, message, w_param, l_param);
+
+  return result;
+}
+
+void WindowImpl::ClearUserData() {
+  if (::IsWindow(hwnd_))
+    gfx::SetWindowUserData(hwnd_, nullptr);
+}
+
+// static
+LRESULT CALLBACK WindowImpl::WndProc(HWND hwnd,
+                                     UINT message,
+                                     WPARAM w_param,
+                                     LPARAM l_param) {
+  WindowImpl* window = nullptr;
+  if (message == WM_NCCREATE) {
+    CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(l_param);
+    window = reinterpret_cast<WindowImpl*>(cs->lpCreateParams);
+    DCHECK(window);
+    gfx::SetWindowUserData(hwnd, window);
+    window->hwnd_ = hwnd;
+    window->got_create_ = true;
+    if (hwnd)
+      window->got_valid_hwnd_ = true;
+  } else {
+    window = reinterpret_cast<WindowImpl*>(GetWindowUserData(hwnd));
+  }
+
+  if (!window)
+    return 0;
+
+  auto logger =
+      CrashIdHelper::Get()->OnWillProcessMessages(window->debugging_id_);
+  return window->OnWndProc(message, w_param, l_param);
+}
+
+ATOM WindowImpl::GetWindowClassAtom() {
+  HICON icon = GetDefaultWindowIcon();
+  HICON small_icon = GetSmallWindowIcon();
+  ClassInfo class_info(initial_class_style(), icon, small_icon);
+  return ClassRegistrar::GetInstance()->RetrieveClassAtom(class_info);
+}
+
+}  // namespace gfx
diff --git a/ui/gfx/win/window_impl.h b/ui/gfx/win/window_impl.h
new file mode 100644
index 0000000..2a5683b
--- /dev/null
+++ b/ui/gfx/win/window_impl.h
@@ -0,0 +1,136 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_WIN_WINDOW_IMPL_H_
+#define UI_GFX_WIN_WINDOW_IMPL_H_
+
+#include <string>
+
+#include "base/check_op.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/gfx_export.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/gfx/win/msg_util.h"
+
+namespace gfx {
+
+// An interface implemented by classes that use message maps.
+// ProcessWindowMessage is implemented by the BEGIN_MESSAGE_MAP_EX macro.
+class MessageMapInterface {
+ public:
+  // Processes one message from the window's message queue.
+  virtual BOOL ProcessWindowMessage(HWND window,
+                                    UINT message,
+                                    WPARAM w_param,
+                                    LPARAM l_param,
+                                    LRESULT& result,
+                                    DWORD msg_map_id = 0) = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// WindowImpl
+//  A convenience class that encapsulates the details of creating and
+//  destroying a HWND.  This class also hosts the windows procedure used by all
+//  Windows.
+//
+///////////////////////////////////////////////////////////////////////////////
+class GFX_EXPORT WindowImpl : public MessageMapInterface {
+ public:
+  // |debugging_id| is reported with crashes to help attribute the code that
+  // created the WindowImpl.
+  explicit WindowImpl(const std::string& debugging_id = std::string());
+
+  WindowImpl(const WindowImpl&) = delete;
+  WindowImpl& operator=(const WindowImpl&) = delete;
+
+  virtual ~WindowImpl();
+
+  // Causes all generated windows classes to be unregistered at exit.
+  // This can cause result in errors for tests that don't destroy all instances
+  // of windows, but is necessary if the tests unload the classes WndProc.
+  static void UnregisterClassesAtExit();
+
+  // Initializes the Window with a parent and an initial desired size.
+  void Init(HWND parent, const gfx::Rect& bounds);
+
+  // Returns the default window icon to use for windows of this type.
+  virtual HICON GetDefaultWindowIcon() const;
+  virtual HICON GetSmallWindowIcon() const;
+
+  // Returns the HWND associated with this Window.
+  HWND hwnd() const { return hwnd_; }
+
+  // Sets the window styles. This is ONLY used when the window is created.
+  // In other words, if you invoke this after invoking Init, nothing happens.
+  void set_window_style(DWORD style) { window_style_ = style; }
+  DWORD window_style() const { return window_style_; }
+
+  // Sets the extended window styles. See comment about |set_window_style|.
+  void set_window_ex_style(DWORD style) { window_ex_style_ = style; }
+  DWORD window_ex_style() const { return window_ex_style_; }
+
+  // Sets the class style to use. The default is CS_DBLCLKS.
+  void set_initial_class_style(UINT class_style) {
+    // We dynamically generate the class name, so don't register it globally!
+    DCHECK_EQ((class_style & CS_GLOBALCLASS), 0u);
+    class_style_ = class_style;
+  }
+  UINT initial_class_style() const { return class_style_; }
+
+  const std::string& debugging_id() const { return debugging_id_; }
+
+ protected:
+  // Handles the WndProc callback for this object.
+  virtual LRESULT OnWndProc(UINT message, WPARAM w_param, LPARAM l_param);
+
+  // Subclasses must call this method from their destructors to ensure that
+  // this object is properly disassociated from the HWND during destruction,
+  // otherwise it's possible this object may still exist while a subclass is
+  // destroyed.
+  void ClearUserData();
+
+ private:
+  friend class ClassRegistrar;
+
+  // The window procedure used by all Windows.
+  static LRESULT CALLBACK WndProc(HWND window,
+                                  UINT message,
+                                  WPARAM w_param,
+                                  LPARAM l_param);
+
+  // Gets the window class atom to use when creating the corresponding HWND.
+  // If necessary, this registers the window class.
+  ATOM GetWindowClassAtom();
+
+  // All classes registered by WindowImpl start with this name.
+  static const wchar_t* const kBaseClassName;
+
+  const std::string debugging_id_;
+
+  // Window Styles used when creating the window.
+  DWORD window_style_ = 0;
+
+  // Window Extended Styles used when creating the window.
+  DWORD window_ex_style_ = 0;
+
+  // Style of the class to use.
+  UINT class_style_;
+
+  // Our hwnd.
+  HWND hwnd_ = nullptr;
+
+  // For debugging.
+  // TODO(sky): nuke this when get crash data.
+  bool got_create_ = false;
+  bool got_valid_hwnd_ = false;
+  // For tracking whether this object has been destroyed. Must be last.
+  base::WeakPtrFactory<WindowImpl> weak_factory_{this};
+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_WIN_WINDOW_IMPL_H_
diff --git a/ui/gfx/x/.style.yapf b/ui/gfx/x/.style.yapf
new file mode 100644
index 0000000..557fa7b
--- /dev/null
+++ b/ui/gfx/x/.style.yapf
@@ -0,0 +1,2 @@
+[style]
+based_on_style = pep8
diff --git a/ui/gfx/x/BUILD.gn b/ui/gfx/x/BUILD.gn
new file mode 100644
index 0000000..87ce467
--- /dev/null
+++ b/ui/gfx/x/BUILD.gn
@@ -0,0 +1,226 @@
+# Copyright 2014 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.
+
+import("//build/config/ozone.gni")
+import("//build/config/ui.gni")
+import("//tools/generate_library_loader/generate_library_loader.gni")
+
+assert(use_x11 || ozone_platform_x11)
+
+declare_args() {
+  regenerate_x11_protos = false
+}
+
+config("x11_private_config") {
+  visibility = [ ":*" ]
+  defines = [ "IS_X11_IMPL" ]
+}
+
+config("build_xprotos_config") {
+  cflags = [
+    # Generated proto files pull all fields from a struct into scope
+    # even if they aren't used.  Rather than adding logic in the
+    # generator to determine which fields are used and keeping only
+    # those, simply ignore unused variable warnings.
+    "-Wno-unused-variable",
+  ]
+}
+
+generate_library_loader("xlib_loader") {
+  name = "XlibLoader"
+  output_h = "xlib_loader.h"
+  output_cc = "xlib_loader.cc"
+  header = "\"ui/gfx/x/xlib.h\""
+
+  functions = [
+    "XInitThreads",
+    "XOpenDisplay",
+    "XCloseDisplay",
+    "XFlush",
+    "XSynchronize",
+    "XSetErrorHandler",
+    "XFree",
+    "XPending",
+  ]
+}
+
+generate_library_loader("xlib_xcb_loader") {
+  name = "XlibXcbLoader"
+  output_h = "xlib_xcb_loader.h"
+  output_cc = "xlib_xcb_loader.cc"
+  header = "\"ui/gfx/x/xlib_xcb.h\""
+
+  functions = [ "XGetXCBConnection" ]
+}
+
+protos = [
+  "bigreq",
+  "composite",
+  "damage",
+  "dpms",
+  "dri2",
+  "dri3",
+  "ge",
+  "glx",
+  "present",
+  "randr",
+  "record",
+  "render",
+  "res",
+  "screensaver",
+  "shape",
+  "shm",
+  "sync",
+  "xc_misc",
+  "xevie",
+  "xf86dri",
+  "xf86vidmode",
+  "xfixes",
+  "xinerama",
+  "xinput",
+  "xkb",
+  "xprint",
+  "xproto",
+  "xselinux",
+  "xtest",
+  "xv",
+  "xvmc",
+]
+proto_generated_files = [
+  "read_event.cc",
+  "read_error.cc",
+  "extension_manager.h",
+  "extension_manager.cc",
+]
+foreach(proto, protos) {
+  proto_generated_files += [
+    "${proto}.h",
+    "${proto}.cc",
+  ]
+}
+
+if (regenerate_x11_protos) {
+  xcbproto_path = "//third_party/xcbproto/src"
+
+  action("gen_xprotos") {
+    visibility = [ ":build_xprotos" ]
+    script = "gen_xproto.py"
+
+    sources = []
+    foreach(proto, protos) {
+      sources += [ "$xcbproto_path/src/${proto}.xml" ]
+    }
+
+    outputs = []
+    foreach(proto_generated_file, proto_generated_files) {
+      outputs += [ "$target_gen_dir/$proto_generated_file" ]
+    }
+
+    args = rebase_path([
+                         xcbproto_path,
+                         target_gen_dir,
+                       ],
+                       root_build_dir) + protos
+  }
+} else {
+  copy("gen_xprotos") {
+    sources = []
+    foreach(proto_generated_file, proto_generated_files) {
+      sources += [ "generated_protos/$proto_generated_file" ]
+    }
+
+    outputs = [ "$target_gen_dir/{{source_file_part}}" ]
+  }
+}
+
+source_set("build_xprotos") {
+  visibility = [ ":xproto" ]
+  deps = [
+    ":gen_xprotos",
+    "//base",
+  ]
+  sources = get_target_outputs(":gen_xprotos")
+  configs += [
+    ":build_xprotos_config",
+    ":x11_private_config",
+  ]
+}
+
+source_set("xproto") {
+  visibility = [ ":x" ]
+  sources = [
+    "connection.cc",
+    "connection.h",
+    "error.cc",
+    "error.h",
+    "event.cc",
+    "event.h",
+    "future.h",
+    "keyboard_state.cc",
+    "keyboard_state.h",
+    "ref_counted_fd.cc",
+    "ref_counted_fd.h",
+    "scoped_ignore_errors.cc",
+    "scoped_ignore_errors.h",
+    "x11_switches.cc",
+    "x11_switches.h",
+    "xlib_support.cc",
+    "xlib_support.h",
+    "xproto_internal.cc",
+    "xproto_internal.h",
+    "xproto_types.cc",
+    "xproto_types.h",
+    "xproto_util.cc",
+    "xproto_util.h",
+  ]
+  deps = [
+    ":xlib_loader",
+    ":xlib_xcb_loader",
+    "//base",
+    "//base:i18n",
+    "//ui/events/platform",
+  ]
+  public_deps = [
+    ":build_xprotos",
+    "//ui/gfx/x/keysyms",
+  ]
+  configs += [ ":x11_private_config" ]
+  libs = [ "xcb" ]
+}
+
+component("x") {
+  output_name = "gfx_x11"
+
+  sources = [
+    "property_cache.cc",
+    "property_cache.h",
+    "x11_atom_cache.cc",
+    "x11_atom_cache.h",
+    "x11_path.cc",
+    "x11_path.h",
+    "x11_window_event_manager.cc",
+    "x11_window_event_manager.h",
+  ]
+
+  configs += [ ":x11_private_config" ]
+
+  deps = [
+    "//base",
+    "//skia",
+  ]
+  public_deps = [ ":xproto" ]
+}
+
+source_set("unit_test") {
+  testonly = true
+  sources = [
+    "connection_unittest.cc",
+    "property_cache_unittest.cc",
+  ]
+  deps = [
+    "//base",
+    "//testing/gtest",
+    "//ui/gfx/x",
+  ]
+}
diff --git a/ui/gfx/x/DEPS b/ui/gfx/x/DEPS
new file mode 100644
index 0000000..eccf1f0
--- /dev/null
+++ b/ui/gfx/x/DEPS
@@ -0,0 +1,6 @@
+include_rules = [
+  "+ui/events/platform/platform_event_source.h",
+  "+third_party/libx11",
+  "+third_party/libxcb-keysyms",
+  "+third_party/x11proto",
+]
diff --git a/ui/gfx/x/OWNERS b/ui/gfx/x/OWNERS
new file mode 100644
index 0000000..c5442ff
--- /dev/null
+++ b/ui/gfx/x/OWNERS
@@ -0,0 +1,4 @@
+thomasanderson@chromium.org
+
+# Adding new atoms is allowed without OWNERS review.
+per-file x11_atom_cache.cc=*
diff --git a/ui/gfx/x/connection.cc b/ui/gfx/x/connection.cc
new file mode 100644
index 0000000..cf033f9
--- /dev/null
+++ b/ui/gfx/x/connection.cc
@@ -0,0 +1,773 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/connection.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include <algorithm>
+#include <string>
+
+#include "base/auto_reset.h"
+#include "base/command_line.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/no_destructor.h"
+#include "base/threading/thread_local.h"
+#include "base/trace_event/trace_event.h"
+#include "ui/gfx/x/bigreq.h"
+#include "ui/gfx/x/event.h"
+#include "ui/gfx/x/keyboard_state.h"
+#include "ui/gfx/x/randr.h"
+#include "ui/gfx/x/x11_switches.h"
+#include "ui/gfx/x/xkb.h"
+#include "ui/gfx/x/xproto.h"
+#include "ui/gfx/x/xproto_internal.h"
+#include "ui/gfx/x/xproto_types.h"
+
+namespace x11 {
+
+namespace {
+
+// On the wire, sequence IDs are 16 bits.  In xcb, they're usually extended to
+// 32 and sometimes 64 bits.  In Xlib, they're extended to unsigned long, which
+// may be 32 or 64 bits depending on the platform.  This function is intended to
+// prevent bugs caused by comparing two differently sized sequences.  Also
+// handles rollover.  To use, compare the result of this function with 0.  For
+// example, to compare seq1 <= seq2, use CompareSequenceIds(seq1, seq2) <= 0.
+template <typename T, typename U>
+auto CompareSequenceIds(T t, U u) {
+  static_assert(std::is_unsigned<T>::value, "");
+  static_assert(std::is_unsigned<U>::value, "");
+  // Cast to the smaller of the two types so that comparisons will always work.
+  // If we casted to the larger type, then the smaller type will be zero-padded
+  // and may incorrectly compare less than the other value.
+  using SmallerType =
+      typename std::conditional<sizeof(T) <= sizeof(U), T, U>::type;
+  SmallerType t0 = static_cast<SmallerType>(t);
+  SmallerType u0 = static_cast<SmallerType>(u);
+  using SignedType = typename std::make_signed<SmallerType>::type;
+  return static_cast<SignedType>(t0 - u0);
+}
+
+base::ThreadLocalOwnedPointer<Connection>& GetConnectionTLS() {
+  static base::NoDestructor<base::ThreadLocalOwnedPointer<Connection>> tls;
+  return *tls;
+}
+
+void DefaultErrorHandler(const Error* error, const char* request_name) {
+  LOG(WARNING) << "X error received.  Request: " << request_name
+               << "Request, Error: " << error->ToString();
+}
+
+void DefaultIOErrorHandler() {
+  LOG(ERROR) << "X connection error received.";
+}
+
+class UnknownError : public Error {
+ public:
+  explicit UnknownError(Connection::RawError error_bytes)
+      : error_bytes_(error_bytes) {}
+
+  ~UnknownError() override = default;
+
+  std::string ToString() const override {
+    std::stringstream ss;
+    ss << "UnknownError{";
+    // Errors are always a fixed 32 bytes.
+    for (size_t i = 0; i < 32; i++) {
+      char buf[3];
+      sprintf(buf, "%02x", error_bytes_->data()[i]);
+      ss << "0x" << buf;
+      if (i != 31)
+        ss << ", ";
+    }
+    ss << "}";
+    return ss.str();
+  }
+
+ private:
+  Connection::RawError error_bytes_;
+};
+
+}  // namespace
+
+// static
+Connection* Connection::Get() {
+  auto& tls = GetConnectionTLS();
+  if (Connection* connection = tls.Get())
+    return connection;
+  auto connection = std::make_unique<Connection>();
+  auto* p_connection = connection.get();
+  tls.Set(std::move(connection));
+  return p_connection;
+}
+
+// static
+void Connection::Set(std::unique_ptr<Connection> connection) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(connection->sequence_checker_);
+  auto& tls = GetConnectionTLS();
+  DCHECK(!tls.Get());
+  tls.Set(std::move(connection));
+}
+
+Connection::Connection(const std::string& address)
+    : XProto(this),
+      display_string_(
+          address.empty()
+              ? base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+                    switches::kX11Display)
+              : address),
+      error_handler_(base::BindRepeating(DefaultErrorHandler)),
+      io_error_handler_(base::BindOnce(DefaultIOErrorHandler)) {
+  connection_ =
+      xcb_connect(display_string_.empty() ? nullptr : display_string_.c_str(),
+                  &default_screen_id_);
+  DCHECK(connection_);
+  if (Ready()) {
+    auto buf = ReadBuffer(base::MakeRefCounted<UnretainedRefCountedMemory>(
+                              xcb_get_setup(XcbConnection())),
+                          true);
+    setup_ = Read<Setup>(&buf);
+    default_screen_ = &setup_.roots[DefaultScreenId()];
+    InitRootDepthAndVisual();
+  } else {
+    // Default-initialize the setup data so we always have something to return.
+    setup_.roots.emplace_back();
+    default_screen_ = &setup_.roots[0];
+    default_screen_->allowed_depths.emplace_back();
+    default_root_depth_ = &default_screen_->allowed_depths[0];
+    default_root_depth_->visuals.emplace_back();
+    default_root_visual_ = &default_root_depth_->visuals[0];
+  }
+
+  ExtensionManager::Init(this);
+  auto enable_bigreq = bigreq().Enable();
+  // Xlib enables XKB on display creation, so we do that here to maintain
+  // compatibility.
+  xkb()
+      .UseExtension({Xkb::major_version, Xkb::minor_version})
+      .OnResponse(base::BindOnce([](Xkb::UseExtensionResponse response) {
+        if (!response || !response->supported)
+          DVLOG(1) << "Xkb extension not available.";
+      }));
+  Flush();
+  if (auto response = enable_bigreq.Sync())
+    extended_max_request_length_ = response->maximum_request_length;
+
+  const Format* formats[256];
+  memset(formats, 0, sizeof(formats));
+  for (const auto& format : setup_.pixmap_formats)
+    formats[format.depth] = &format;
+
+  std::vector<std::pair<VisualId, VisualInfo>> default_screen_visuals;
+  for (const auto& depth : default_screen().allowed_depths) {
+    const Format* format = formats[depth.depth];
+    for (const auto& visual : depth.visuals) {
+      default_screen_visuals.emplace_back(visual.visual_id,
+                                          VisualInfo{format, &visual});
+    }
+  }
+  default_screen_visuals_ =
+      base::flat_map<VisualId, VisualInfo>(std::move(default_screen_visuals));
+
+  keyboard_state_ = CreateKeyboardState(this);
+
+  InitErrorParsers();
+}
+
+Connection::~Connection() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  platform_event_source.reset();
+  xcb_disconnect(connection_);
+}
+
+size_t Connection::MaxRequestSizeInBytes() const {
+  return 4 * std::max<size_t>(extended_max_request_length_,
+                              setup_.maximum_request_length);
+}
+
+XlibDisplayWrapper Connection::GetXlibDisplay(XlibDisplayType type) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (!xlib_display_)
+    xlib_display_ = base::WrapUnique(new XlibDisplay(display_string_));
+  return XlibDisplayWrapper(xlib_display_->display_, type);
+}
+
+Connection::FutureImpl::FutureImpl(Connection* connection,
+                                   SequenceType sequence,
+                                   bool generates_reply,
+                                   const char* request_name_for_tracing)
+    : connection(connection),
+      sequence(sequence),
+      generates_reply(generates_reply),
+      request_name_for_tracing(request_name_for_tracing) {}
+
+void Connection::FutureImpl::Wait() {
+  connection->WaitForResponse(this);
+  ProcessResponse();
+}
+
+void Connection::FutureImpl::Sync(RawReply* raw_reply,
+                                  std::unique_ptr<Error>* error) {
+  connection->WaitForResponse(this);
+  TakeResponse(raw_reply, error);
+}
+
+void Connection::FutureImpl::OnResponse(ResponseCallback callback) {
+  UpdateRequestHandler(std::move(callback));
+}
+
+void Connection::FutureImpl::UpdateRequestHandler(ResponseCallback callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(connection->sequence_checker_);
+  DCHECK(callback);
+
+  auto* request = connection->GetRequestForFuture(this);
+  // Make sure we haven't processed this request yet.
+  DCHECK(request->callback);
+
+  request->callback = std::move(callback);
+}
+
+void Connection::FutureImpl::ProcessResponse() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(connection->sequence_checker_);
+
+  auto* request = connection->GetRequestForFuture(this);
+  DCHECK(request->callback);
+  DCHECK(request->have_response);
+
+  std::move(request->callback)
+      .Run(std::move(request->reply), std::move(request->error));
+}
+
+void Connection::FutureImpl::TakeResponse(RawReply* raw_reply,
+                                          std::unique_ptr<Error>* error) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(connection->sequence_checker_);
+
+  auto* request = connection->GetRequestForFuture(this);
+  DCHECK(request->callback);
+  DCHECK(request->have_response);
+
+  *raw_reply = std::move(request->reply);
+  *error = std::move(request->error);
+  request->callback.Reset();
+}
+
+Connection::Request::Request(ResponseCallback callback)
+    : callback(std::move(callback)) {
+  DCHECK(this->callback);
+}
+
+Connection::Request::Request(Request&& other) = default;
+
+Connection::Request::~Request() = default;
+
+void Connection::Request::SetResponse(Connection* connection,
+                                      void* raw_reply,
+                                      void* raw_error) {
+  have_response = true;
+  if (raw_reply)
+    reply = base::MakeRefCounted<MallocedRefCountedMemory>(raw_reply);
+  if (raw_error) {
+    error = connection->ParseError(
+        base::MakeRefCounted<MallocedRefCountedMemory>(raw_error));
+  }
+}
+
+bool Connection::HasNextResponse() {
+  if (requests_.empty())
+    return false;
+  auto& request = requests_.front();
+  if (request.have_response)
+    return true;
+
+  void* reply = nullptr;
+  xcb_generic_error_t* error = nullptr;
+  if (!xcb_poll_for_reply(XcbConnection(), first_request_id_, &reply, &error))
+    return false;
+
+  request.SetResponse(this, reply, error);
+  return true;
+}
+
+bool Connection::HasNextEvent() {
+  while (!events_.empty()) {
+    if (events_.front().Initialized())
+      return true;
+    events_.pop_front();
+  }
+  return false;
+}
+
+int Connection::GetFd() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return Ready() ? xcb_get_file_descriptor(XcbConnection()) : -1;
+}
+
+const std::string& Connection::DisplayString() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return display_string_;
+}
+
+std::string Connection::GetConnectionHostname() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  char* host = nullptr;
+  int display_id = 0;
+  int screen = 0;
+  if (xcb_parse_display(display_string_.c_str(), &host, &display_id, &screen)) {
+    std::string name = host;
+    free(host);
+    return name;
+  }
+  return std::string();
+}
+
+int Connection::DefaultScreenId() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  // This is not part of the setup data as the server has no concept of a
+  // default screen. Instead, it's part of the display name. Eg in
+  // "localhost:0.0", the screen ID is the second "0".
+  return default_screen_id_;
+}
+
+bool Connection::Ready() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return !xcb_connection_has_error(connection_);
+}
+
+void Connection::Flush() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  xcb_flush(connection_);
+}
+
+void Connection::Sync() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (syncing_)
+    return;
+  {
+    base::AutoReset<bool> auto_reset(&syncing_, true);
+    GetInputFocus().Sync();
+  }
+}
+
+void Connection::SynchronizeForTest(bool synchronous) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  synchronous_ = synchronous;
+  if (synchronous_)
+    Sync();
+}
+
+void Connection::ReadResponses() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  while (ReadResponse(false)) {
+  }
+}
+
+bool Connection::ReadResponse(bool queued) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  auto* event = queued ? xcb_poll_for_queued_event(XcbConnection())
+                       : xcb_poll_for_event(XcbConnection());
+  if (event) {
+    events_.emplace_back(base::MakeRefCounted<MallocedRefCountedMemory>(event),
+                         this);
+  }
+  return event;
+}
+
+Event Connection::WaitForNextEvent() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (HasNextEvent()) {
+    Event event = std::move(events_.front());
+    events_.pop_front();
+    return event;
+  }
+  if (auto* xcb_event = xcb_wait_for_event(XcbConnection())) {
+    return Event(base::MakeRefCounted<MallocedRefCountedMemory>(xcb_event),
+                 this);
+  }
+  return Event();
+}
+
+bool Connection::HasPendingResponses() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return HasNextEvent() || HasNextResponse();
+}
+
+const Connection::VisualInfo* Connection::GetVisualInfoFromId(
+    VisualId id) const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  auto it = default_screen_visuals_.find(id);
+  if (it != default_screen_visuals_.end())
+    return &it->second;
+  return nullptr;
+}
+
+KeyCode Connection::KeysymToKeycode(uint32_t keysym) const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return keyboard_state_->KeysymToKeycode(keysym);
+}
+
+uint32_t Connection::KeycodeToKeysym(KeyCode keycode,
+                                     uint32_t modifiers) const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return keyboard_state_->KeycodeToKeysym(keycode, modifiers);
+}
+
+std::unique_ptr<Connection> Connection::Clone() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return std::make_unique<Connection>(display_string_);
+}
+
+void Connection::DetachFromSequence() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DETACH_FROM_SEQUENCE(sequence_checker_);
+}
+
+bool Connection::Dispatch() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  if (HasNextResponse() && HasNextEvent()) {
+    auto next_response_sequence = first_request_id_;
+    auto next_event_sequence = events_.front().sequence();
+
+    // All events have the sequence number of the last processed request
+    // included in them.  So if a reply and an event have the same sequence,
+    // the reply must have been received first.
+    if (CompareSequenceIds(next_event_sequence, next_response_sequence) <= 0)
+      ProcessNextResponse();
+    else
+      ProcessNextEvent();
+  } else if (HasNextResponse()) {
+    ProcessNextResponse();
+  } else if (HasNextEvent()) {
+    ProcessNextEvent();
+  } else {
+    return false;
+  }
+  return true;
+}
+
+void Connection::DispatchAll() {
+  do {
+    Flush();
+    ReadResponses();
+  } while (Dispatch());
+}
+
+void Connection::DispatchEvent(const Event& event) {
+  PreDispatchEvent(event);
+
+  // NB: The event should be reset to nullptr when this function
+  // returns, not to its initial value, otherwise nested message loops
+  // will incorrectly think that the current event being dispatched is
+  // an old event.  This means base::AutoReset should not be used.
+  dispatching_event_ = &event;
+  for (auto& observer : event_observers_)
+    observer.OnEvent(event);
+  dispatching_event_ = nullptr;
+}
+
+Connection::ErrorHandler Connection::SetErrorHandler(ErrorHandler new_handler) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  return std::exchange(error_handler_, new_handler);
+}
+
+void Connection::SetIOErrorHandler(IOErrorHandler new_handler) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  io_error_handler_ = std::move(new_handler);
+}
+
+void Connection::AddEventObserver(EventObserver* observer) {
+  event_observers_.AddObserver(observer);
+}
+
+void Connection::RemoveEventObserver(EventObserver* observer) {
+  event_observers_.RemoveObserver(observer);
+}
+
+xcb_connection_t* Connection::XcbConnection() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (io_error_handler_ && xcb_connection_has_error(connection_))
+    std::move(io_error_handler_).Run();
+  return connection_;
+}
+
+void Connection::InitRootDepthAndVisual() {
+  for (auto& depth : default_screen_->allowed_depths) {
+    for (auto& visual : depth.visuals) {
+      if (visual.visual_id == default_screen_->root_visual) {
+        default_root_depth_ = &depth;
+        default_root_visual_ = &visual;
+        return;
+      }
+    }
+  }
+  NOTREACHED();
+}
+
+void Connection::ProcessNextEvent() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(HasNextEvent());
+
+  Event event = std::move(events_.front());
+  events_.pop_front();
+
+  DispatchEvent(event);
+}
+
+void Connection::ProcessNextResponse() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(!requests_.empty());
+  DCHECK(requests_.front().have_response);
+
+  Request request = std::move(requests_.front());
+  requests_.pop_front();
+  if (last_non_void_request_id_.has_value() &&
+      last_non_void_request_id_.value() == first_request_id_) {
+    last_non_void_request_id_ = absl::nullopt;
+  }
+  first_request_id_++;
+  if (request.callback) {
+    std::move(request.callback)
+        .Run(std::move(request.reply), std::move(request.error));
+  }
+}
+
+std::unique_ptr<Connection::FutureImpl> Connection::SendRequest(
+    WriteBuffer* buf,
+    const char* request_name_for_tracing,
+    bool generates_reply,
+    bool reply_has_fds) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  xcb_protocol_request_t xpr{
+      .ext = nullptr,
+      .isvoid = !generates_reply,
+  };
+
+  struct RequestHeader {
+    uint8_t major_opcode;
+    uint8_t minor_opcode;
+    uint16_t length;
+  };
+
+  struct ExtendedRequestHeader {
+    RequestHeader header;
+    uint32_t long_length;
+  };
+  static_assert(sizeof(ExtendedRequestHeader) == 8, "");
+
+  auto& first_buffer = buf->GetBuffers()[0];
+  DCHECK_GE(first_buffer->size(), sizeof(RequestHeader));
+  auto* old_header = reinterpret_cast<RequestHeader*>(
+      const_cast<uint8_t*>(first_buffer->data()));
+  ExtendedRequestHeader new_header{*old_header, 0};
+
+  // Requests are always a multiple of 4 bytes on the wire.  Because of this,
+  // the length field represents the size in chunks of 4 bytes.
+  DCHECK_EQ(buf->offset() % 4, 0UL);
+  size_t size32 = buf->offset() / 4;
+
+  // XCB requires 2 iovecs for its own internal usage.
+  std::vector<struct iovec> io{{nullptr, 0}, {nullptr, 0}};
+  if (size32 < setup_.maximum_request_length) {
+    // Regular request
+    old_header->length = size32;
+  } else if (size32 < extended_max_request_length_) {
+    // BigRequests extension request
+    DCHECK_EQ(new_header.header.length, 0U);
+    new_header.long_length = size32 + 1;
+
+    io.push_back({&new_header, sizeof(ExtendedRequestHeader)});
+    first_buffer = base::MakeRefCounted<OffsetRefCountedMemory>(
+        first_buffer, sizeof(RequestHeader),
+        first_buffer->size() - sizeof(RequestHeader));
+  } else {
+    LOG(ERROR) << "Cannot send request of length " << buf->offset();
+    return nullptr;
+  }
+
+  for (auto& buffer : buf->GetBuffers())
+    io.push_back({const_cast<uint8_t*>(buffer->data()), buffer->size()});
+  xpr.count = io.size() - 2;
+
+  xcb_connection_t* conn = XcbConnection();
+  auto flags = XCB_REQUEST_CHECKED | XCB_REQUEST_RAW;
+  if (reply_has_fds)
+    flags |= XCB_REQUEST_REPLY_FDS;
+
+  for (int fd : buf->fds())
+    xcb_send_fd(conn, fd);
+  SequenceType sequence = xcb_send_request(conn, flags, &io[2], &xpr);
+
+  if (xcb_connection_has_error(conn))
+    return nullptr;
+
+  SequenceType next_request_id = first_request_id_ + requests_.size();
+  DCHECK_EQ(CompareSequenceIds(next_request_id, sequence), 0);
+
+  // If we ever reach 2^32 outstanding requests, then bail because sequence IDs
+  // would no longer be unique.
+  next_request_id++;
+  CHECK_NE(next_request_id, first_request_id_);
+
+  // Install a default response-handler that throws away the reply and prints
+  // the error if there is one.  This handler may be overridden by clients.
+  auto callback = base::BindOnce(
+      [](const char* request_name, Connection::ErrorHandler error_handler,
+         RawReply raw_reply, std::unique_ptr<Error> error) {
+        if (error)
+          error_handler.Run(error.get(), request_name);
+      },
+      request_name_for_tracing, error_handler_);
+  requests_.emplace_back(std::move(callback));
+  if (generates_reply)
+    last_non_void_request_id_ = sequence;
+  if (synchronous_)
+    Sync();
+
+  return std::make_unique<FutureImpl>(this, sequence, generates_reply,
+                                      request_name_for_tracing);
+}
+
+void Connection::WaitForResponse(FutureImpl* future) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  auto* request = GetRequestForFuture(future);
+  DCHECK(request->callback);
+  if (request->have_response)
+    return;
+
+  xcb_generic_error_t* error = nullptr;
+  void* reply = nullptr;
+  if (future->generates_reply) {
+    if (!xcb_poll_for_reply(XcbConnection(), future->sequence, &reply,
+                            &error)) {
+      TRACE_EVENT1("ui", "xcb_wait_for_reply", "request",
+                   future->request_name_for_tracing);
+      reply = xcb_wait_for_reply(XcbConnection(), future->sequence, &error);
+    }
+  } else {
+    // There's a special case here.  This request doesn't generate a reply, and
+    // may not generate an error, so the only way to know if it finished is to
+    // send another request that we know will generate a reply or error.  Once
+    // the new request finishes, we know this request has finished, since the
+    // server is guaranteed to process requests in order.  Normally, the
+    // xcb_request_check() below would do this for us automatically, but we need
+    // to keep track of the sequence count ourselves, so we explicitly make a
+    // GetInputFocus request if necessary (which is the request xcb would have
+    // made -- GetInputFocus is chosen since it has the minimum size request and
+    // reply, and can be made at any time).
+    bool needs_extra_request_for_check = false;
+    if (!last_non_void_request_id_.has_value()) {
+      needs_extra_request_for_check = true;
+    } else {
+      SequenceType last_non_void_offset =
+          last_non_void_request_id_.value() - first_request_id_;
+      SequenceType sequence_offset = future->sequence - first_request_id_;
+      needs_extra_request_for_check = sequence_offset > last_non_void_offset;
+    }
+    if (needs_extra_request_for_check) {
+      GetInputFocus().IgnoreError();
+      // The circular_deque may have swapped buffers, so we need to get a fresh
+      // pointer to the request.
+      request = GetRequestForFuture(future);
+    }
+
+    // libxcb has a bug where it doesn't flush in xcb_request_check() under some
+    // circumstances, leading to deadlock [1], so always perform a manual flush.
+    // [1] https://gitlab.freedesktop.org/xorg/lib/libxcb/-/issues/53
+    Flush();
+
+    {
+      TRACE_EVENT1("ui", "xcb_request_check", "request",
+                   future->request_name_for_tracing);
+      error = xcb_request_check(XcbConnection(), {future->sequence});
+    }
+  }
+  request->SetResponse(this, reply, error);
+}
+
+Connection::Request* Connection::GetRequestForFuture(FutureImpl* future) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  SequenceType offset = future->sequence - first_request_id_;
+  DCHECK_LT(offset, requests_.size());
+  return &requests_[offset];
+}
+
+void Connection::PreDispatchEvent(const Event& event) {
+  if (auto* mapping = event.As<MappingNotifyEvent>()) {
+    if (mapping->request == Mapping::Modifier ||
+        mapping->request == Mapping::Keyboard) {
+      setup_.min_keycode = mapping->first_keycode;
+      setup_.max_keycode = static_cast<KeyCode>(
+          static_cast<int>(mapping->first_keycode) + mapping->count - 1);
+      keyboard_state_->UpdateMapping();
+    }
+  }
+  if (auto* notify = event.As<Xkb::NewKeyboardNotifyEvent>()) {
+    setup_.min_keycode = notify->minKeyCode;
+    setup_.max_keycode = notify->maxKeyCode;
+    keyboard_state_->UpdateMapping();
+  }
+
+  // This is adapted from XRRUpdateConfiguration.
+  if (auto* configure = event.As<ConfigureNotifyEvent>()) {
+    int index = ScreenIndexFromRootWindow(configure->window);
+    if (index != -1) {
+      setup_.roots[index].width_in_pixels = configure->width;
+      setup_.roots[index].height_in_pixels = configure->height;
+    }
+  } else if (auto* screen = event.As<RandR::ScreenChangeNotifyEvent>()) {
+    int index = ScreenIndexFromRootWindow(screen->root);
+    DCHECK_GE(index, 0);
+    bool portrait =
+        static_cast<bool>(screen->rotation & (RandR::Rotation::Rotate_90 |
+                                              RandR::Rotation::Rotate_270));
+    if (portrait) {
+      setup_.roots[index].width_in_pixels = screen->height;
+      setup_.roots[index].height_in_pixels = screen->width;
+      setup_.roots[index].width_in_millimeters = screen->mheight;
+      setup_.roots[index].height_in_millimeters = screen->mwidth;
+    } else {
+      setup_.roots[index].width_in_pixels = screen->width;
+      setup_.roots[index].height_in_pixels = screen->height;
+      setup_.roots[index].width_in_millimeters = screen->mwidth;
+      setup_.roots[index].height_in_millimeters = screen->mheight;
+    }
+  }
+}
+
+int Connection::ScreenIndexFromRootWindow(Window root) const {
+  for (size_t i = 0; i < setup_.roots.size(); i++) {
+    if (setup_.roots[i].root == root)
+      return i;
+  }
+  return -1;
+}
+
+std::unique_ptr<Error> Connection::ParseError(RawError error_bytes) {
+  if (!error_bytes)
+    return nullptr;
+  struct ErrorHeader {
+    uint8_t response_type;
+    uint8_t error_code;
+    uint16_t sequence;
+  };
+  auto error_code = error_bytes->front_as<ErrorHeader>()->error_code;
+  if (auto parser = error_parsers_[error_code])
+    return parser(error_bytes);
+  return std::make_unique<UnknownError>(error_bytes);
+}
+
+uint32_t Connection::GenerateIdImpl() {
+  return xcb_generate_id(connection_);
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/connection.h b/ui/gfx/x/connection.h
new file mode 100644
index 0000000..4281481
--- /dev/null
+++ b/ui/gfx/x/connection.h
@@ -0,0 +1,347 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_CONNECTION_H_
+#define UI_GFX_X_CONNECTION_H_
+
+#include "base/callback.h"
+#include "base/component_export.h"
+#include "base/containers/circular_deque.h"
+#include "base/containers/flat_map.h"
+#include "base/sequence_checker.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/events/platform/platform_event_source.h"
+#include "ui/gfx/x/extension_manager.h"
+#include "ui/gfx/x/xlib_support.h"
+#include "ui/gfx/x/xproto.h"
+
+typedef struct xcb_connection_t xcb_connection_t;
+
+namespace x11 {
+
+class Event;
+class KeyboardState;
+class WriteBuffer;
+
+// This interface is used by classes wanting to receive
+// Events directly.  For input events (mouse, keyboard, touch), a
+// PlatformEventObserver should be used instead.
+class EVENTS_EXPORT EventObserver {
+ public:
+  virtual void OnEvent(const Event& xevent) = 0;
+
+ protected:
+  virtual ~EventObserver() = default;
+};
+
+// Represents a socket to the X11 server.
+class COMPONENT_EXPORT(X11) Connection : public XProto,
+                                         public ExtensionManager {
+ public:
+  using ErrorHandler = base::RepeatingCallback<void(const Error*, const char*)>;
+  using IOErrorHandler = base::OnceClosure;
+  using RawReply = scoped_refptr<base::RefCountedMemory>;
+  using RawError = scoped_refptr<base::RefCountedMemory>;
+  using ResponseCallback =
+      base::OnceCallback<void(RawReply reply, std::unique_ptr<Error> error)>;
+
+  // xcb returns unsigned int when making requests.  This may be updated to
+  // uint16_t if/when we stop using xcb for socket IO.
+  using SequenceType = unsigned int;
+
+  struct VisualInfo {
+    const Format* format;
+    const VisualType* visual_type;
+  };
+
+  // Gets or creates the thread local connection instance.
+  static Connection* Get();
+
+  // Sets the thread local connection instance.
+  static void Set(std::unique_ptr<Connection> connection);
+
+  template <typename T>
+  T GenerateId() {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    return static_cast<T>(GenerateIdImpl());
+  }
+
+  template <typename Reply>
+  Future<Reply> SendRequest(WriteBuffer* buf,
+                            const char* request_name,
+                            bool reply_has_fds) {
+    bool generates_reply = !std::is_void<Reply>::value;
+    return Future<Reply>(
+        SendRequest(buf, request_name, generates_reply, reply_has_fds));
+  }
+
+  explicit Connection(const std::string& address = "");
+  ~Connection();
+
+  Connection(const Connection&) = delete;
+  Connection(Connection&&) = delete;
+
+  // Obtain an Xlib display that's connected to the same server as |this|.  This
+  // is meant to be used only for compatibility with components like GLX,
+  // Vulkan, and VAAPI.  The underlying socket is not shared, so synchronization
+  // with |this| may be necessary.  The |type| parameter can be used to achieve
+  // synchronization.  The returned wrapper should not be saved.
+  XlibDisplayWrapper GetXlibDisplay(
+      XlibDisplayType type = XlibDisplayType::kNormal);
+
+  size_t MaxRequestSizeInBytes() const;
+
+  const Setup& setup() const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    return setup_;
+  }
+  const Screen& default_screen() const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    return *default_screen_;
+  }
+  Window default_root() const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    return default_screen().root;
+  }
+  const Depth& default_root_depth() const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    return *default_root_depth_;
+  }
+  const VisualType& default_root_visual() const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    return *default_root_visual_;
+  }
+
+  const Event* dispatching_event() const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    return dispatching_event_;
+  }
+
+  // Returns the underlying socket's FD if the connection is valid, or -1
+  // otherwise.
+  int GetFd();
+
+  const std::string& DisplayString() const;
+
+  std::string GetConnectionHostname() const;
+
+  int DefaultScreenId() const;
+
+  // Is the connection up and error-free?
+  bool Ready() const;
+
+  // Write all requests to the socket.
+  void Flush();
+
+  // Flush and block until the server has responded to all requests.
+  void Sync();
+
+  // If |synchronous| is true, this makes all requests Sync().
+  void SynchronizeForTest(bool synchronous);
+
+  // Read all responses from the socket without blocking.  This function will
+  // make non-blocking read() syscalls.
+  void ReadResponses();
+
+  // Read a single response.  If |queued| is true, no read() will be done; a
+  // response may only be translated from buffered socket data.  If |queued| is
+  // false, a non-blocking read() will only be done if no response is buffered.
+  // Returns true if an event was read.
+  bool ReadResponse(bool queued);
+
+  Event WaitForNextEvent();
+
+  // Are there any events, errors, or replies already buffered?
+  bool HasPendingResponses();
+
+  // Dispatches one event, reply, or error from the server; or returns false
+  // if there's none available.  This function doesn't read or write any data on
+  // the socket.
+  bool Dispatch();
+
+  // Dispatches all available events, replies, and errors.  This function
+  // ensures the read and write buffers on the socket are empty upon returning.
+  void DispatchAll();
+
+  // Directly dispatch an event, bypassing the event queue.
+  void DispatchEvent(const Event& event);
+
+  // Returns the old error handler.
+  ErrorHandler SetErrorHandler(ErrorHandler new_handler);
+
+  void SetIOErrorHandler(IOErrorHandler new_handler);
+
+  void AddEventObserver(EventObserver* observer);
+
+  void RemoveEventObserver(EventObserver* observer);
+
+  // Returns the visual data for |id|, or nullptr if the visual with that ID
+  // doesn't exist or only exists on a non-default screen.
+  const VisualInfo* GetVisualInfoFromId(VisualId id) const;
+
+  KeyCode KeysymToKeycode(uint32_t keysym) const;
+
+  uint32_t KeycodeToKeysym(KeyCode keycode, uint32_t modifiers) const;
+
+  // Access the event buffer.  Clients may modify the queue, including
+  // "deleting" events by setting events[i] = x11::Event(), which will
+  // guarantee all calls to x11::Event::As() will return nullptr.
+  base::circular_deque<Event>& events() {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    return events_;
+  }
+
+  std::unique_ptr<Connection> Clone() const;
+
+  // Releases ownership of this connection to a different thread.
+  void DetachFromSequence();
+
+  // The viz compositor thread hangs a PlatformEventSource off the connection so
+  // that it gets destroyed at the appropriate time.
+  // TODO(thomasanderson): This is a layering violation and this should be moved
+  // somewhere else.
+  std::unique_ptr<ui::PlatformEventSource> platform_event_source;
+
+ private:
+  template <typename Reply>
+  friend class Future;
+
+  class COMPONENT_EXPORT(X11) FutureImpl {
+   public:
+    FutureImpl(Connection* connection,
+               SequenceType sequence,
+               bool generates_reply,
+               const char* request_name_for_tracing);
+
+    void Wait();
+
+    void Sync(RawReply* raw_reply, std::unique_ptr<Error>* error);
+
+    void OnResponse(ResponseCallback callback);
+
+    // Update an existing Request with a new handler.  |sequence| must
+    // correspond to a request in the queue that has not already been processed
+    // out-of-order.
+    void UpdateRequestHandler(ResponseCallback callback);
+
+    // Call the response handler for request |sequence| now (out-of-order).  The
+    // response must already have been obtained from a call to
+    // WaitForResponse().
+    void ProcessResponse();
+
+    // Clear the response handler for request |sequence| and take the response.
+    // The response must already have been obtained using WaitForResponse().
+    void TakeResponse(RawReply* reply, std::unique_ptr<Error>* error);
+
+    Connection* connection = nullptr;
+    SequenceType sequence = 0;
+    bool generates_reply = false;
+    const char* request_name_for_tracing = nullptr;
+  };
+
+  struct Request {
+    explicit Request(ResponseCallback callback);
+    Request(Request&& other);
+    ~Request();
+
+    // Takes ownership of |reply| and |error|.
+    void SetResponse(Connection* connection, void* raw_reply, void* raw_error);
+
+    // If |callback| is nullptr, then this request has already been processed
+    // out-of-order.
+    ResponseCallback callback;
+
+    // Indicates if |reply| and |error| are available.  A separate
+    // |have_response| flag is necessary to distinguish the case where a request
+    // hasn't finished yet from the case where a request finished but didn't
+    // generate a reply or error.
+    bool have_response = false;
+    RawReply reply;
+    std::unique_ptr<Error> error;
+  };
+
+  xcb_connection_t* XcbConnection();
+
+  void InitRootDepthAndVisual();
+
+  void ProcessNextEvent();
+
+  void ProcessNextResponse();
+
+  bool HasNextResponse();
+
+  bool HasNextEvent();
+
+  // Creates a new Request and adds it to the end of the queue.
+  // |request_name_for_tracing| must be valid until the response is
+  // dispatched; currently the string values are only stored in .rodata, so
+  // this constraint is satisfied.
+  std::unique_ptr<FutureImpl> SendRequest(WriteBuffer* buf,
+                                          const char* request_name_for_tracing,
+                                          bool generates_reply,
+                                          bool reply_has_fds);
+
+  // Block until the reply or error for request |sequence| is received.
+  void WaitForResponse(FutureImpl* future);
+
+  Request* GetRequestForFuture(FutureImpl* future);
+
+  void PreDispatchEvent(const Event& event);
+
+  int ScreenIndexFromRootWindow(Window root) const;
+
+  // This function is implemented in the generated read_error.cc.
+  void InitErrorParsers();
+
+  std::unique_ptr<Error> ParseError(RawError error_bytes);
+
+  uint32_t GenerateIdImpl();
+
+  xcb_connection_t* connection_ = nullptr;
+  std::unique_ptr<XlibDisplay> xlib_display_;
+
+  bool synchronous_ = false;
+  bool syncing_ = false;
+
+  uint32_t extended_max_request_length_ = 0;
+
+  std::string display_string_;
+  int default_screen_id_ = 0;
+  Setup setup_;
+  Screen* default_screen_ = nullptr;
+  Depth* default_root_depth_ = nullptr;
+  VisualType* default_root_visual_ = nullptr;
+
+  base::flat_map<VisualId, VisualInfo> default_screen_visuals_;
+
+  std::unique_ptr<KeyboardState> keyboard_state_;
+
+  base::circular_deque<Event> events_;
+
+  base::ObserverList<EventObserver>::Unchecked event_observers_;
+
+  // The Event currently being dispatched, or nullptr if there is none.
+  const Event* dispatching_event_ = nullptr;
+
+  base::circular_deque<Request> requests_;
+  // The sequence ID of requests_.front(), or if |requests_| is empty, then the
+  // ID of the next request that will go in the queue.  This starts at 1 because
+  // the 0'th request is handled internally by XCB when opening the connection.
+  SequenceType first_request_id_ = 1;
+  // If any request in |requests_| will generate a reply, this is the ID of the
+  // latest one, otherwise this is absl::nullopt.
+  absl::optional<SequenceType> last_non_void_request_id_;
+
+  using ErrorParser = std::unique_ptr<Error> (*)(RawError error_bytes);
+  std::array<ErrorParser, 256> error_parsers_{};
+
+  ErrorHandler error_handler_;
+  IOErrorHandler io_error_handler_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_CONNECTION_H_
diff --git a/ui/gfx/x/connection_unittest.cc b/ui/gfx/x/connection_unittest.cc
new file mode 100644
index 0000000..46928a7
--- /dev/null
+++ b/ui/gfx/x/connection_unittest.cc
@@ -0,0 +1,105 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/connection.h"
+
+#include "base/memory/ref_counted_memory.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/x/event.h"
+#include "ui/gfx/x/future.h"
+#include "ui/gfx/x/xproto.h"
+
+namespace x11 {
+
+namespace {
+
+Window CreateWindow(Connection* connection) {
+  Window window = connection->GenerateId<Window>();
+  auto create_window_future = connection->CreateWindow({
+      .depth = connection->default_root_depth().depth,
+      .wid = window,
+      .parent = connection->default_screen().root,
+      .width = 1,
+      .height = 1,
+      .override_redirect = Bool32(true),
+  });
+  auto create_window_response = create_window_future.Sync();
+  EXPECT_FALSE(create_window_response.error);
+  return window;
+}
+
+}  // namespace
+
+// Connection setup and teardown.
+TEST(X11ConnectionTest, Basic) {
+  Connection connection;
+  ASSERT_TRUE(connection.Ready());
+}
+
+TEST(X11ConnectionTest, Request) {
+  Connection connection;
+  ASSERT_TRUE(connection.Ready());
+
+  Window window = CreateWindow(&connection);
+
+  auto attributes = connection.GetWindowAttributes({window}).Sync();
+  ASSERT_TRUE(attributes);
+  EXPECT_EQ(attributes->map_state, MapState::Unmapped);
+  EXPECT_TRUE(attributes->override_redirect);
+
+  auto geometry = connection.GetGeometry(window).Sync();
+  ASSERT_TRUE(geometry);
+  EXPECT_EQ(geometry->x, 0);
+  EXPECT_EQ(geometry->y, 0);
+  EXPECT_EQ(geometry->width, 1u);
+  EXPECT_EQ(geometry->height, 1u);
+}
+
+TEST(X11ConnectionTest, Event) {
+  Connection connection;
+  ASSERT_TRUE(connection.Ready());
+
+  Window window = CreateWindow(&connection);
+
+  auto cwa_future = connection.ChangeWindowAttributes({
+      .window = window,
+      .event_mask = EventMask::PropertyChange,
+  });
+  EXPECT_FALSE(cwa_future.Sync().error);
+
+  std::vector<uint8_t> data{0};
+  auto prop_future = connection.ChangeProperty({
+      .window = static_cast<Window>(window),
+      .property = Atom::WM_NAME,
+      .type = Atom::STRING,
+      .format = CHAR_BIT,
+      .data_len = 1,
+      .data = base::RefCountedBytes::TakeVector(&data),
+  });
+  EXPECT_FALSE(prop_future.Sync().error);
+
+  connection.ReadResponses();
+  ASSERT_EQ(connection.events().size(), 1u);
+  auto* prop = connection.events().front().As<PropertyNotifyEvent>();
+  ASSERT_TRUE(prop);
+  EXPECT_EQ(prop->atom, Atom::WM_NAME);
+  EXPECT_EQ(prop->state, Property::NewValue);
+}
+
+TEST(X11ConnectionTest, Error) {
+  Connection connection;
+  ASSERT_TRUE(connection.Ready());
+
+  Window invalid_window = connection.GenerateId<Window>();
+
+  auto geometry = connection.GetGeometry(invalid_window).Sync();
+  ASSERT_FALSE(geometry);
+  auto* error = geometry.error.get();
+  ASSERT_TRUE(error);
+  // TODO(thomasanderson): Implement As<> for errors, similar to events.
+  auto* drawable_error = reinterpret_cast<DrawableError*>(error);
+  EXPECT_EQ(drawable_error->bad_value, static_cast<uint32_t>(invalid_window));
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/error.cc b/ui/gfx/x/error.cc
new file mode 100644
index 0000000..f33de1a
--- /dev/null
+++ b/ui/gfx/x/error.cc
@@ -0,0 +1,13 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/error.h"
+
+namespace x11 {
+
+Error::Error() = default;
+
+Error::~Error() = default;
+
+}  // namespace x11
diff --git a/ui/gfx/x/error.h b/ui/gfx/x/error.h
new file mode 100644
index 0000000..a9de90b
--- /dev/null
+++ b/ui/gfx/x/error.h
@@ -0,0 +1,26 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_ERROR_H_
+#define UI_GFX_X_ERROR_H_
+
+#include <string>
+
+#include "base/component_export.h"
+
+namespace x11 {
+
+// This class is a generic interface for X11 errors.  Currently the only
+// functionality is printing the error as a human-readable string.
+class COMPONENT_EXPORT(X11) Error {
+ public:
+  Error();
+  virtual ~Error();
+
+  virtual std::string ToString() const = 0;
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_ERROR_H_
diff --git a/ui/gfx/x/event.cc b/ui/gfx/x/event.cc
new file mode 100644
index 0000000..68d6946
--- /dev/null
+++ b/ui/gfx/x/event.cc
@@ -0,0 +1,83 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/event.h"
+
+#include <xcb/xcb.h>
+
+#include <cstring>
+
+#include "base/check_op.h"
+#include "base/memory/scoped_refptr.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/xproto.h"
+#include "ui/gfx/x/xproto_internal.h"
+#include "ui/gfx/x/xproto_types.h"
+
+namespace x11 {
+
+Event::Event() = default;
+
+Event::Event(scoped_refptr<base::RefCountedMemory> event_bytes,
+             Connection* connection) {
+  auto* xcb_event = reinterpret_cast<xcb_generic_event_t*>(
+      const_cast<uint8_t*>(event_bytes->data()));
+  sequence_ = xcb_event->full_sequence;
+  // KeymapNotify events are the only events that don't have a sequence.
+  if ((xcb_event->response_type & ~kSendEventMask) !=
+      KeymapNotifyEvent::opcode) {
+    // On the wire, events are 32 bytes except for generic events which are
+    // trailed by additional data.  XCB inserts an extended 4-byte sequence
+    // between the 32-byte event and the additional data, so we need to shift
+    // the additional data over by 4 bytes so the event is back in its wire
+    // format, which is what Xlib and XProto are expecting.
+    if ((xcb_event->response_type & ~kSendEventMask) ==
+        GeGenericEvent::opcode) {
+      auto* ge = reinterpret_cast<xcb_ge_event_t*>(xcb_event);
+      constexpr size_t ge_length = sizeof(xcb_raw_generic_event_t);
+      constexpr size_t offset = sizeof(ge->full_sequence);
+      size_t extended_length = ge->length * 4;
+      if (extended_length < ge_length) {
+        // If the additional data is smaller than the fixed size event, shift
+        // the additional data to the left.
+        memmove(&ge->full_sequence, &ge[1], extended_length);
+      } else {
+        // Otherwise shift the fixed size event to the right.
+        char* addr = reinterpret_cast<char*>(xcb_event);
+        memmove(addr + offset, addr, ge_length);
+        event_bytes = base::MakeRefCounted<OffsetRefCountedMemory>(
+            event_bytes, offset, ge_length + extended_length);
+        xcb_event = reinterpret_cast<xcb_generic_event_t*>(addr + offset);
+      }
+    }
+  }
+
+  // Xlib sometimes modifies |xcb_event|, so let it handle the event after
+  // we parse it with ReadEvent().
+  ReadBuffer buf(event_bytes);
+  ReadEvent(this, connection, &buf);
+}
+
+Event::Event(Event&& event) {
+  memcpy(this, &event, sizeof(Event));
+  memset(&event, 0, sizeof(Event));
+}
+
+Event& Event::operator=(Event&& event) {
+  Dealloc();
+  memcpy(this, &event, sizeof(Event));
+  memset(&event, 0, sizeof(Event));
+  return *this;
+}
+
+Event::~Event() {
+  Dealloc();
+}
+
+void Event::Dealloc() {
+  if (deleter_)
+    deleter_(event_);
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/event.h b/ui/gfx/x/event.h
new file mode 100644
index 0000000..ed4f9b0
--- /dev/null
+++ b/ui/gfx/x/event.h
@@ -0,0 +1,96 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_EVENT_H_
+#define UI_GFX_X_EVENT_H_
+
+#include <cstdint>
+#include <utility>
+
+#include "base/component_export.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "ui/gfx/x/xproto.h"
+
+namespace x11 {
+
+class Connection;
+class Event;
+struct ReadBuffer;
+
+COMPONENT_EXPORT(X11)
+void ReadEvent(Event* event, Connection* connection, ReadBuffer* buffer);
+
+class COMPONENT_EXPORT(X11) Event {
+ public:
+  template <typename T>
+  explicit Event(T&& xproto_event) {
+    using DecayT = std::decay_t<T>;
+    sequence_ = xproto_event.sequence;
+    type_id_ = DecayT::type_id;
+    deleter_ = [](void* event) { delete reinterpret_cast<DecayT*>(event); };
+    auto* event = new DecayT(std::forward<T>(xproto_event));
+    event_ = event;
+    window_ = event->GetWindow();
+  }
+
+  Event();
+
+  // |event_bytes| is modified and will not be valid after this call.
+  // A copy is necessary if the original data is still needed.
+  Event(scoped_refptr<base::RefCountedMemory> event_bytes,
+        Connection* connection);
+
+  Event(const Event&) = delete;
+  Event& operator=(const Event&) = delete;
+
+  Event(Event&& event);
+  Event& operator=(Event&& event);
+
+  ~Event();
+
+  template <typename T>
+  T* As() {
+    if (type_id_ == T::type_id)
+      return reinterpret_cast<T*>(event_);
+    return nullptr;
+  }
+
+  template <typename T>
+  const T* As() const {
+    return const_cast<Event*>(this)->As<T>();
+  }
+
+  uint32_t sequence() const { return sequence_; }
+
+  Window window() const { return window_ ? *window_ : Window::None; }
+  void set_window(Window window) {
+    if (window_)
+      *window_ = window;
+  }
+
+  bool Initialized() const { return deleter_; }
+
+ private:
+  friend void ReadEvent(Event* event,
+                        Connection* connection,
+                        ReadBuffer* buffer);
+
+  void Dealloc();
+
+  uint16_t sequence_ = 0;
+
+  // XProto event state.
+  int type_id_ = 0;
+  void (*deleter_)(void*) = nullptr;
+  void* event_ = nullptr;
+
+  // This member points to a field in |event_|, or may be nullptr if there's no
+  // associated window for the event.  It's owned by |event_|, not us.
+  Window* window_ = nullptr;
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_EVENT_H_
diff --git a/ui/gfx/x/future.h b/ui/gfx/x/future.h
new file mode 100644
index 0000000..fd20093
--- /dev/null
+++ b/ui/gfx/x/future.h
@@ -0,0 +1,114 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_FUTURE_H_
+#define UI_GFX_X_FUTURE_H_
+
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/xproto_types.h"
+
+namespace x11 {
+
+// An Future wraps an asynchronous response from the X11 server.  The
+// response may be waited-for with Sync(), or asynchronously handled by
+// installing a response handler using OnResponse().
+template <typename Reply>
+class Future {
+ public:
+  using Callback = base::OnceCallback<void(Response<Reply> response)>;
+
+  Future() = default;
+
+  explicit Future(std::unique_ptr<Connection::FutureImpl> impl)
+      : impl_(std::move(impl)) {}
+
+  // Blocks until we receive the response from the server. Returns the response.
+  Response<Reply> Sync() {
+    if (!impl_)
+      return {nullptr, nullptr};
+
+    Connection::RawReply raw_reply;
+    std::unique_ptr<Error> error;
+    impl_->Sync(&raw_reply, &error);
+
+    std::unique_ptr<Reply> reply;
+    if (raw_reply) {
+      auto buf = ReadBuffer(raw_reply);
+      reply = detail::ReadReply<Reply>(&buf);
+    }
+
+    return {std::move(reply), std::move(error)};
+  }
+
+  // Block until this request is handled by the server.  Unlike Sync(), this
+  // method doesn't return the response.  Rather, it calls the response
+  // handler installed for this request out-of-order.
+  void Wait() {
+    if (impl_)
+      impl_->Wait();
+  }
+
+  // Installs |callback| to be run when the response is received.
+  void OnResponse(Callback callback) {
+    if (!impl_)
+      return;
+
+    // This intermediate callback handles the conversion from |raw_reply| to a
+    // real Reply object before feeding the result to |callback|.  This means
+    // |callback| must be bound as the first argument of the intermediate
+    // function.
+    auto wrapper = [](Callback callback, Connection::RawReply raw_reply,
+                      std::unique_ptr<Error> error) {
+      std::unique_ptr<Reply> reply;
+      if (raw_reply) {
+        ReadBuffer buf(raw_reply);
+        reply = detail::ReadReply<Reply>(&buf);
+      }
+      std::move(callback).Run({std::move(reply), std::move(error)});
+    };
+    impl_->OnResponse(base::BindOnce(wrapper, std::move(callback)));
+  }
+
+  void IgnoreError() {
+    OnResponse(base::BindOnce([](Response<Reply>) {}));
+  }
+
+ private:
+  std::unique_ptr<Connection::FutureImpl> impl_;
+};
+
+// Sync() specialization for requests that don't generate replies.  The returned
+// response will only contain an error if there was one.
+template <>
+inline Response<void> Future<void>::Sync() {
+  if (!impl_)
+    return Response<void>{nullptr};
+
+  Connection::RawReply raw_reply;
+  std::unique_ptr<Error> error;
+  impl_->Sync(&raw_reply, &error);
+  DCHECK(!raw_reply);
+  return Response<void>(std::move(error));
+}
+
+// OnResponse() specialization for requests that don't generate replies.  The
+// response argument to |callback| will only contain an error if there was one.
+template <>
+inline void Future<void>::OnResponse(Callback callback) {
+  if (!impl_)
+    return;
+
+  // See Future<Reply>::OnResponse() for an explanation of why
+  // this wrapper is necessary.
+  auto wrapper = [](Callback callback, Connection::RawReply reply,
+                    std::unique_ptr<Error> error) {
+    DCHECK(!reply);
+    std::move(callback).Run(Response<void>{std::move(error)});
+  };
+  impl_->OnResponse(base::BindOnce(wrapper, std::move(callback)));
+}
+
+}  // namespace x11
+
+#endif  //  UI_GFX_X_FUTURE_H_
diff --git a/ui/gfx/x/gen_xproto.py b/ui/gfx/x/gen_xproto.py
new file mode 100644
index 0000000..715d80f
--- /dev/null
+++ b/ui/gfx/x/gen_xproto.py
@@ -0,0 +1,1661 @@
+# Copyright 2020 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.
+
+# This script generates header/source files with C++ language bindings
+# for the X11 protocol and its extensions.  The protocol information
+# is obtained from xcbproto which provides XML files describing the
+# wire format.  However, we don't parse the XML here; xcbproto ships
+# with xcbgen, a python library that parses the files into python data
+# structures for us.
+
+from __future__ import print_function
+
+import argparse
+import collections
+import itertools
+import os
+import re
+import sys
+import types
+
+# __main__.output must be defined before importing xcbgen,
+# so this global is unavoidable.
+output = collections.defaultdict(int)
+
+RENAME = {
+    'ANIMCURSORELT': 'AnimationCursorElement',
+    'CA': 'ChangeAlarmAttribute',
+    'CHAR2B': 'Char16',
+    'CHARINFO': 'CharInfo',
+    'COLORITEM': 'ColorItem',
+    'COLORMAP': 'ColorMap',
+    'Connection': 'RandRConnection',
+    'CP': 'CreatePictureAttribute',
+    'CS': 'ClientSpec',
+    'CW': 'CreateWindowAttribute',
+    'DAMAGE': 'DamageId',
+    'DIRECTFORMAT': 'DirectFormat',
+    'DOTCLOCK': 'DotClock',
+    'FBCONFIG': 'FbConfig',
+    'FONTPROP': 'FontProperty',
+    'GC': 'GraphicsContextAttribute',
+    'GCONTEXT': 'GraphicsContext',
+    'GLYPHINFO': 'GlyphInfo',
+    'GLYPHSET': 'GlyphSet',
+    'INDEXVALUE': 'IndexValue',
+    'KB': 'Keyboard',
+    'KEYCODE': 'KeyCode',
+    'KEYCODE32': 'KeyCode32',
+    'KEYSYM': 'KeySym',
+    'LINEFIX': 'LineFix',
+    'OP': 'Operation',
+    'PBUFFER': 'PBuffer',
+    'PCONTEXT': 'PContext',
+    'PICTDEPTH': 'PictDepth',
+    'PICTFORMAT': 'PictFormat',
+    'PICTFORMINFO': 'PictFormInfo',
+    'PICTSCREEN': 'PictScreen',
+    'PICTVISUAL': 'PictVisual',
+    'POINTFIX': 'PointFix',
+    'SPANFIX': 'SpanFix',
+    'SUBPICTURE': 'SubPicture',
+    'SYSTEMCOUNTER': 'SystemCounter',
+    'TIMECOORD': 'TimeCoord',
+    'TIMESTAMP': 'Time',
+    'VISUALID': 'VisualId',
+    'VISUALTYPE': 'VisualType',
+    'WAITCONDITION': 'WaitCondition',
+}
+
+READ_SPECIAL = set([
+    ('xcb', 'Setup'),
+])
+
+WRITE_SPECIAL = set([
+    ('xcb', 'ClientMessage'),
+    ('xcb', 'Expose'),
+    ('xcb', 'UnmapNotify'),
+    ('xcb', 'SelectionNotify'),
+    ('xcb', 'MotionNotify'),
+    ('xcb', 'Key'),
+    ('xcb', 'Button'),
+    ('xcb', 'PropertyNotify'),
+])
+
+FILE_HEADER = \
+'''// Copyright 2021 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.
+
+// This file was automatically generated with:
+// %s
+''' % ' \\\n//    '.join(sys.argv)
+
+
+def adjust_type_name(name):
+    if name in RENAME:
+        return RENAME[name]
+    # If there's an underscore, then this is either snake case or upper case.
+    if '_' in name:
+        return ''.join([
+            token[0].upper() + token[1:].lower() for token in name.split('_')
+        ])
+    if name.isupper():
+        name = name.lower()
+    # Now the only possibilities are caml case and pascal case.  It could also
+    # be snake case with a single word, but that would be same as caml case.
+    # To convert all of these, just capitalize the first letter.
+    return name[0].upper() + name[1:]
+
+
+# Given a list of event names like ["KeyPress", "KeyRelease"], returns a name
+# suitable for use as a base event like "Key".
+def event_base_name(names):
+    # If there's only one event in this group, the "common name" is just
+    # the event name.
+    if len(names) == 1:
+        return names[0]
+
+    # Handle a few special cases where the longest common prefix is empty: eg.
+    # EnterNotify/LeaveNotify/FocusIn/FocusOut -> Crossing.
+    EVENT_NAMES = [
+        ('TouchBegin', 'Device'),
+        ('RawTouchBegin', 'RawDevice'),
+        ('Enter', 'Crossing'),
+        ('EnterNotify', 'Crossing'),
+        ('DeviceButtonPress', 'LegacyDevice'),
+    ]
+    for name, rename in EVENT_NAMES:
+        if name in names:
+            return rename
+
+    # Use the longest common prefix of the event names as the base name.
+    name = ''.join(
+        chars[0]
+        for chars in itertools.takewhile(lambda chars: len(set(chars)) == 1,
+                                         zip(*names)))
+    assert name
+    return name
+
+
+def list_size(name, list_type):
+    separator = '->' if list_type.is_ref_counted_memory else '.'
+    return '%s%ssize()' % (name, separator)
+
+
+# Left-pad with 2 spaces while this class is alive.
+class Indent:
+    def __init__(self, xproto, opening_line, closing_line):
+        self.xproto = xproto
+        self.opening_line = opening_line
+        self.closing_line = closing_line
+
+    def __enter__(self):
+        self.xproto.write(self.opening_line)
+        self.xproto.indent += 1
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        self.xproto.indent -= 1
+        self.xproto.write(self.closing_line)
+
+
+# Make all members of |obj|, given by |fields|, visible in
+# the local scope while this class is alive.
+class ScopedFields:
+    def __init__(self, xproto, obj, fields):
+        self.xproto = xproto
+        self.obj = obj
+        self.fields = fields
+        self.n_pushed = 0
+
+    def __enter__(self):
+        for field in self.fields:
+            self.n_pushed += self.xproto.add_field_to_scope(field, self.obj)
+
+        if self.n_pushed:
+            self.xproto.write()
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        for _ in range(self.n_pushed):
+            self.xproto.scope.pop()
+
+
+# Ensures |name| is usable as a C++ field by avoiding keywords and
+# symbols that start with numbers.
+def safe_name(name):
+    RESERVED = [
+        'and',
+        'xor',
+        'or',
+        'class',
+        'explicit',
+        'new',
+        'delete',
+        'default',
+        'private',
+    ]
+    if name[0].isdigit() or name in RESERVED:
+        return 'c_' + name
+    return name
+
+
+class FileWriter:
+    def __init__(self):
+        self.indent = 0
+
+    # Write a line to the current file.
+    def write(self, line=''):
+        indent = self.indent if line and not line.startswith('#') else 0
+        print(('  ' * indent) + line, file=self.file)
+
+    def write_header(self):
+        for header_line in FILE_HEADER.split('\n'):
+            self.write(header_line)
+
+
+class GenXproto(FileWriter):
+    def __init__(self, proto, proto_dir, gen_dir, xcbgen, all_types):
+        FileWriter.__init__(self)
+
+        # Command line arguments
+        self.proto = proto
+        self.xml_filename = os.path.join(proto_dir, '%s.xml' % proto)
+        self.header_file = open(os.path.join(gen_dir, '%s.h' % proto), 'w')
+        self.source_file = open(os.path.join(gen_dir, '%s.cc' % proto), 'w')
+
+        # Top-level xcbgen python module
+        self.xcbgen = xcbgen
+
+        # Types for every module including this one
+        self.all_types = all_types
+
+        # The last used UID for making unique names
+        self.prev_id = -1
+
+        # Current file to write to
+        self.file = None
+
+        # Flag to indicate if we're generating code to serialize or
+        # deserialize data.
+        self.is_read = False
+
+        # List of the fields in scope
+        self.scope = []
+
+        # Current place in C++ namespace hierarchy (including classes)
+        self.namespace = []
+
+        # Map from type names to a set of types.  Certain types
+        # like enums and simple types can alias each other.
+        self.types = collections.defaultdict(list)
+
+        # Set of names of simple types to be replaced with enums
+        self.replace_with_enum = set()
+
+        # Map of enums to their underlying types
+        self.enum_types = collections.defaultdict(set)
+
+        # Map from (XML tag, XML name) to XML element
+        self.module_names = {}
+
+        # Enums that represent bit masks.
+        self.bitenums = []
+
+    # Geenerate an ID suitable for use in temporary variable names.
+    def new_uid(self, ):
+        self.prev_id += 1
+        return self.prev_id
+
+    def type_suffix(self, t):
+        if isinstance(t, self.xcbgen.xtypes.Error):
+            return 'Error'
+        elif isinstance(t, self.xcbgen.xtypes.Request):
+            return 'Request'
+        elif t.is_reply:
+            return 'Reply'
+        elif t.is_event:
+            return 'Event'
+        return ''
+
+    def rename_type(self, t, name):
+        name = list(name)
+
+        if name[0] == 'xcb':
+            # Use namespace x11 instead of xcb.
+            name[0] = 'x11'
+
+        for i in range(1, len(name)):
+            name[i] = adjust_type_name(name[i])
+        name[-1] += self.type_suffix(t)
+        return name
+
+    # Given an unqualified |name| like ('Window') and a namespace like ['x11'],
+    # returns a fully qualified name like ('x11', 'Window').
+    def qualify_type(self, name, namespace):
+        if tuple(namespace + name) in self.all_types:
+            return namespace + name
+        return self.qualify_type(name, namespace[:-1])
+
+    # Given an xcbgen.xtypes.Type, returns a C++-namespace-qualified
+    # string that looks like Input::InputClass::Key.
+    def qualtype(self, t, name):
+        name = self.rename_type(t, name)
+
+        # Try to avoid adding namespace qualifiers if they're not necessary.
+        chop = 0
+        for t1, t2 in zip(name, self.namespace):
+            if t1 != t2:
+                break
+            if self.qualify_type(name[chop + 1:], self.namespace) != name:
+                break
+            chop += 1
+        return '::'.join(name[chop:])
+
+    def fieldtype(self, field):
+        if field.isfd:
+            return 'RefCountedFD'
+        return self.qualtype(field.type,
+                             field.enum if field.enum else field.field_type)
+
+    def switch_fields(self, switch):
+        fields = []
+        for case in switch.bitcases:
+            if case.field_name:
+                fields.append(case)
+            else:
+                fields.extend(case.type.fields)
+        return fields
+
+    def add_field_to_scope(self, field, obj):
+        if not field.visible or (not field.wire and not field.isfd):
+            return 0
+
+        field_name = safe_name(field.field_name)
+
+        if field.type.is_switch:
+            self.write('auto& %s = %s;' % (field_name, obj))
+            return 0
+
+        self.scope.append(field)
+
+        if field.for_list or field.for_switch:
+            self.write('%s %s{};' % (self.fieldtype(field), field_name))
+        else:
+            self.write('auto& %s = %s.%s;' % (field_name, obj, field_name))
+
+        if field.type.is_list:
+            len_name = field_name + '_len'
+            if not self.field_from_scope(len_name):
+                len_expr = list_size(field_name, field.type)
+                if field.type.is_ref_counted_memory:
+                    len_expr = '%s ? %s : 0' % (field_name, len_expr)
+                self.write('size_t %s = %s;' % (len_name, len_expr))
+
+        return 1
+
+    # Lookup |name| in the current scope.  Returns the deepest
+    # (most local) occurrence of |name|.
+    def field_from_scope(self, name):
+        for field in reversed(self.scope):
+            if field.field_name == name:
+                return field
+        return None
+
+    def expr(self, expr):
+        if expr.op == 'popcount':
+            return 'PopCount(%s)' % self.expr(expr.rhs)
+        if expr.op == '~':
+            return 'BitNot(%s)' % self.expr(expr.rhs)
+        if expr.op == '&':
+            return 'BitAnd(%s, %s)' % (self.expr(expr.lhs), self.expr(
+                expr.rhs))
+        if expr.op in ('+', '-', '*', '/', '|'):
+            return ('(%s) %s (%s)' %
+                    (self.expr(expr.lhs), expr.op, self.expr(expr.rhs)))
+        if expr.op == 'calculate_len':
+            return expr.lenfield_name
+        if expr.op == 'sumof':
+            tmp_id = self.new_uid()
+            lenfield = self.field_from_scope(expr.lenfield_name)
+            elem_type = lenfield.type.member
+            fields = elem_type.fields if elem_type.is_container else []
+            header = 'auto sum%d_ = SumOf([](%sauto& listelem_ref) {' % (
+                tmp_id, '' if self.is_read else 'const ')
+            footer = '}, %s);' % expr.lenfield_name
+            with Indent(self, header,
+                        footer), ScopedFields(self, 'listelem_ref', fields):
+                body = self.expr(expr.rhs) if expr.rhs else 'listelem_ref'
+                self.write('return %s;' % body)
+            return 'sum%d_' % tmp_id
+        if expr.op == 'listelement-ref':
+            return 'listelem_ref'
+        if expr.op == 'enumref':
+            return '%s::%s' % (self.qualtype(
+                expr.lenfield_type,
+                expr.lenfield_type.name), safe_name(expr.lenfield_name))
+
+        assert expr.op == None
+        if expr.nmemb:
+            return str(expr.nmemb)
+
+        assert expr.lenfield_name
+        return expr.lenfield_name
+
+    def get_xidunion_element(self, name):
+        key = ('xidunion', name[-1])
+        return self.module_names.get(key, None)
+
+    def declare_xidunion(self, xidunion, xidname):
+        names = [type_element.text for type_element in xidunion]
+        types = list(set([self.module.get_type(name) for name in names]))
+        assert len(types) == 1
+        value_type = types[0]
+        value_typename = self.qualtype(value_type, value_type.name)
+        with Indent(self, 'struct %s {' % xidname, '};'):
+            self.write('%s() : value{} {}' % xidname)
+            self.write()
+            for name in names:
+                cpp_name = self.module.get_type_name(name)
+                typename = self.qualtype(value_type, cpp_name)
+                self.write('%s(%s value) : value{static_cast<%s>(value)} {}' %
+                           (xidname, typename, value_typename))
+                self.write(
+                    'operator %s() const { return static_cast<%s>(value); }' %
+                    (typename, typename))
+                self.write()
+            self.write('%s value{};' % value_typename)
+
+    def declare_simple(self, item, name):
+        renamed = tuple(self.rename_type(item, name))
+        if renamed in self.replace_with_enum:
+            return
+
+        xidunion = self.get_xidunion_element(name)
+        if xidunion:
+            self.declare_xidunion(xidunion, renamed[-1])
+        else:
+            self.write('enum class %s : %s {};' %
+                       (renamed[-1], self.qualtype(item, item.name)))
+        self.write()
+
+    def copy_primitive(self, name):
+        if self.is_read:
+            self.write('Read(&%s, &buf);' % name)
+        else:
+            self.write('buf.Write(&%s);' % name)
+
+    def copy_fd(self, field, name):
+        if self.is_read:
+            self.write('%s = RefCountedFD(buf.TakeFd());' % name)
+        else:
+            # We take the request struct as const&, so dup() the fd to preserve
+            # const-correctness because XCB close()s it after writing it.
+            self.write('buf.fds().push_back(HANDLE_EINTR(dup(%s.get())));' %
+                       name)
+
+    def copy_special_field(self, field):
+        type_name = self.fieldtype(field)
+        name = safe_name(field.field_name)
+
+        def copy_basic():
+            self.write('%s %s;' % (type_name, name))
+            self.copy_primitive(name)
+
+        if name in ('major_opcode', 'minor_opcode'):
+            assert not self.is_read
+            is_ext = self.module.namespace.is_ext
+            self.write(
+                '%s %s = %s;' %
+                (type_name, name, 'info_.major_opcode' if is_ext
+                 and name == 'major_opcode' else field.parent[0].opcode))
+            self.copy_primitive(name)
+        elif name == 'response_type':
+            if self.is_read:
+                copy_basic()
+            else:
+                container_type, container_name = field.parent
+                assert container_type.is_event
+                # Extension events require offsetting the opcode, so make
+                # sure this path is only hit for non-extension events for now.
+                assert not self.module.namespace.is_ext
+                opcode = container_type.opcodes.get(container_name,
+                                                    'obj.opcode')
+                self.write('%s %s = %s;' % (type_name, name, opcode))
+                self.copy_primitive(name)
+        elif name in ('extension', 'error_code', 'event_type'):
+            assert self.is_read
+            copy_basic()
+        elif name == 'length':
+            if not self.is_read:
+                self.write('// Caller fills in length for writes.')
+                self.write('Pad(&buf, sizeof(%s));' % type_name)
+            else:
+                copy_basic()
+        else:
+            assert field.type.is_expr
+            assert (not isinstance(field.type, self.xcbgen.xtypes.Enum))
+            self.write('%s %s = %s;' %
+                       (type_name, name, self.expr(field.type.expr)))
+            self.copy_primitive(name)
+
+    def declare_case(self, case):
+        assert case.type.is_case != case.type.is_bitcase
+
+        fields = [
+            field for case_field in case.type.fields
+            for field in self.declare_field(case_field)
+        ]
+        if not case.field_name:
+            return fields
+        name = safe_name(case.field_name)
+        typename = adjust_type_name(name)
+        with Indent(self, 'struct %s {' % typename, '};'):
+            for field in fields:
+                self.write('%s %s{};' % field)
+        return [(typename, name)]
+
+    def copy_case(self, case, switch_name):
+        op = 'CaseEq' if case.type.is_case else 'CaseAnd'
+        condition = ' || '.join([
+            '%s(%s_expr, %s)' % (op, switch_name, self.expr(expr))
+            for expr in case.type.expr
+        ])
+
+        with Indent(self, 'if (%s) {' % condition, '}'):
+            if case.field_name:
+                fields = [case]
+                obj = '(*%s.%s)' % (switch_name, safe_name(case.field_name))
+            else:
+                fields = case.type.fields
+                obj = '*' + switch_name
+            for case_field in fields:
+                name = safe_name(case_field.field_name)
+                if case_field.visible and self.is_read:
+                    self.write('%s.%s.emplace();' % (switch_name, name))
+            with ScopedFields(self, obj, case.type.fields):
+                for case_field in case.type.fields:
+                    self.copy_field(case_field)
+
+    def declare_switch(self, field):
+        return [('absl::optional<%s>' % field_type, field_name)
+                for case in field.type.bitcases
+                for field_type, field_name in self.declare_case(case)]
+
+    def copy_switch(self, field):
+        t = field.type
+        name = safe_name(field.field_name)
+
+        self.write('auto %s_expr = %s;' % (name, self.expr(t.expr)))
+        for case in t.bitcases:
+            self.copy_case(case, name)
+
+    def declare_list(self, field):
+        t = field.type
+        type_name = self.fieldtype(field)
+        name = safe_name(field.field_name)
+
+        assert (t.nmemb not in (0, 1))
+        if t.is_ref_counted_memory:
+            type_name = 'scoped_refptr<base::RefCountedMemory>'
+        elif t.nmemb:
+            type_name = 'std::array<%s, %d>' % (type_name, t.nmemb)
+        elif type_name == 'char':
+            type_name = 'std::string'
+        else:
+            type_name = 'std::vector<%s>' % type_name
+        return [(type_name, name)]
+
+    def copy_list(self, field):
+        t = field.type
+        name = safe_name(field.field_name)
+        size = self.expr(t.expr)
+
+        if t.is_ref_counted_memory:
+            if self.is_read:
+                self.write('%s = buffer->ReadAndAdvance(%s);' % (name, size))
+            else:
+                self.write('buf.AppendBuffer(%s, %s);' % (name, size))
+            return
+
+        if not t.nmemb:
+            if self.is_read:
+                self.write('%s.resize(%s);' % (name, size))
+            else:
+                left = 'static_cast<size_t>(%s)' % size
+                self.write('DCHECK_EQ(%s, %s.size());' % (left, name))
+        with Indent(self, 'for (auto& %s_elem : %s) {' % (name, name), '}'):
+            elem_name = name + '_elem'
+            elem_type = t.member
+            elem_field = self.xcbgen.expr.Field(elem_type, field.field_type,
+                                                elem_name, field.visible,
+                                                field.wire, field.auto,
+                                                field.enum, field.isfd)
+            elem_field.for_list = None
+            elem_field.for_switch = None
+            self.copy_field(elem_field)
+
+    def generate_switch_var(self, field):
+        name = safe_name(field.field_name)
+        for case in field.for_switch.type.bitcases:
+            case_field = case if case.field_name else case.type.fields[0]
+            self.write('SwitchVar(%s, %s.%s.has_value(), %s, &%s);' %
+                       (self.expr(case.type.expr[0]),
+                        safe_name(field.for_switch.field_name),
+                        safe_name(case_field.field_name),
+                        'true' if case.type.is_bitcase else 'false', name))
+
+    def is_field_hidden_from_api(self, field):
+        return not field.visible or getattr(
+            field, 'for_list', False) or getattr(field, 'for_switch', False)
+
+    def declare_field(self, field):
+        t = field.type
+        name = safe_name(field.field_name)
+
+        if self.is_field_hidden_from_api(field):
+            return []
+
+        if t.is_switch:
+            return self.declare_switch(field)
+        if t.is_list:
+            return self.declare_list(field)
+        return [(self.fieldtype(field), name)]
+
+    def copy_field(self, field):
+        if not field.wire and not field.isfd:
+            return
+
+        t = field.type
+        renamed = tuple(self.rename_type(field.type, field.field_type))
+        if t.is_list:
+            t.member = self.all_types.get(renamed, t.member)
+        else:
+            t = self.all_types.get(renamed, t)
+        name = safe_name(field.field_name)
+
+        self.write('// ' + name)
+
+        # If this is a generated field, initialize the value of the field
+        # variable from the given context.
+        if not self.is_read:
+            if field.for_list:
+                size = list_size(safe_name(field.for_list.field_name),
+                                 field.for_list.type)
+                self.write('%s = %s;' % (name, size))
+            if field.for_switch:
+                self.generate_switch_var(field)
+
+        if t.is_pad:
+            if t.align > 1:
+                assert t.nmemb == 1
+                assert t.align in (2, 4)
+                self.write('Align(&buf, %d);' % t.align)
+            else:
+                self.write('Pad(&buf, %d);' % t.nmemb)
+        elif not field.visible:
+            self.copy_special_field(field)
+        elif t.is_switch:
+            self.copy_switch(field)
+        elif t.is_list:
+            self.copy_list(field)
+        elif t.is_union:
+            self.copy_primitive(name)
+        elif t.is_container:
+            with Indent(self, '{', '}'):
+                self.copy_container(t, name)
+        else:
+            assert t.is_simple
+            if field.isfd:
+                self.copy_fd(field, name)
+            elif field.enum:
+                self.copy_enum(field)
+            else:
+                self.copy_primitive(name)
+
+        self.write()
+
+    def declare_enum(self, enum):
+        def declare_enum_entry(name, value):
+            name = safe_name(name)
+            self.write('%s = %s,' % (name, value))
+
+        with Indent(
+                self, 'enum class %s : %s {' %
+            (adjust_type_name(enum.name[-1]), self.enum_types[enum.name][0]
+             if enum.name in self.enum_types else 'int'), '};'):
+            bitnames = set([name for name, _ in enum.bits])
+            for name, value in enum.values:
+                if name not in bitnames:
+                    declare_enum_entry(name, value)
+            for name, value in enum.bits:
+                declare_enum_entry(name, '1 << ' + value)
+        self.write()
+
+    def copy_enum(self, field):
+        # The size of enum types may be different depending on the
+        # context, so they should always be casted to the contextual
+        # underlying type before calling Read() or Write().
+        underlying_type = self.qualtype(field.type, field.type.name)
+        tmp_name = 'tmp%d' % self.new_uid()
+        real_name = safe_name(field.field_name)
+        self.write('%s %s;' % (underlying_type, tmp_name))
+        if not self.is_read:
+            self.write('%s = static_cast<%s>(%s);' %
+                       (tmp_name, underlying_type, real_name))
+        self.copy_primitive(tmp_name)
+        if self.is_read:
+            enum_type = self.qualtype(field.type, field.enum)
+            self.write('%s = static_cast<%s>(%s);' %
+                       (real_name, enum_type, tmp_name))
+
+    def declare_fields(self, fields):
+        for field in fields:
+            for field_type_name in self.declare_field(field):
+                self.write('%s %s{};' % field_type_name)
+
+    # This tries to match XEvent.xany.window, except the window will be
+    # Window::None for events that don't have a window, unlike the XEvent
+    # union which will get whatever data happened to be at the offset of
+    # xany.window.
+    def get_window_field(self, event):
+        # The window field is not stored at any particular offset in the event,
+        # so get a list of all the window fields.
+        WINDOW_TYPES = set([
+            ('xcb', 'WINDOW'),
+            ('xcb', 'DRAWABLE'),
+            ('xcb', 'Glx', 'DRAWABLE'),
+        ])
+        # The window we want may not be the first in the list if there are
+        # multiple windows. This is a list of all possible window names,
+        # ordered from highest to lowest priority.
+        WINDOW_NAMES = [
+            'event',
+            'window',
+            'request_window',
+            'owner',
+        ]
+        windows = set([
+            field.field_name for field in event.fields
+            if field.field_type in WINDOW_TYPES
+        ])
+        if len(windows) == 0:
+            return ''
+        if len(windows) == 1:
+            return list(windows)[0]
+        for name in WINDOW_NAMES:
+            if name in windows:
+                return name
+        assert False
+
+    def declare_event(self, event, name):
+        event_name = name[-1] + 'Event'
+        with Indent(self, 'struct %s {' % adjust_type_name(event_name), '};'):
+            self.write('static constexpr int type_id = %d;' % event.type_id)
+            if len(event.opcodes) == 1:
+                self.write('static constexpr uint8_t opcode = %s;' %
+                           event.opcodes[name])
+            else:
+                with Indent(self, 'enum Opcode {', '} opcode{};'):
+                    items = [(int(x), y)
+                             for (y, x) in event.enum_opcodes.items()]
+                    for opcode, opname in sorted(items):
+                        self.write('%s = %s,' % (opname, opcode))
+            self.write('bool send_event{};')
+            self.declare_fields(event.fields)
+            self.write()
+            window_field = self.get_window_field(event)
+            ret = ('reinterpret_cast<x11::Window*>(&%s)' %
+                   window_field if window_field else 'nullptr')
+            self.write('x11::Window* GetWindow() { return %s; }' % ret)
+        self.write()
+
+    def declare_error(self, error, name):
+        name = adjust_type_name(name[-1] + 'Error')
+        with Indent(self, 'struct %s : public x11::Error {' % name, '};'):
+            self.declare_fields(error.fields)
+            self.write()
+            self.write('std::string ToString() const override;')
+        self.write()
+
+    def declare_container(self, struct, struct_name):
+        name = struct_name[-1] + self.type_suffix(struct)
+        with Indent(self, 'struct %s {' % adjust_type_name(name), '};'):
+            self.declare_fields(struct.fields)
+        self.write()
+
+    def copy_container(self, struct, name):
+        assert not struct.is_union
+        with ScopedFields(self, name, struct.fields):
+            for field in struct.fields:
+                self.copy_field(field)
+
+    def read_special_container(self, struct, name):
+        self.namespace = ['x11']
+        name = self.qualtype(struct, name)
+        self.write('template <> COMPONENT_EXPORT(X11)')
+        self.write('%s Read<%s>(' % (name, name))
+        with Indent(self, '    ReadBuffer* buffer) {', '}'):
+            self.write('auto& buf = *buffer;')
+            self.write('%s obj;' % name)
+            self.write()
+            self.is_read = True
+            self.copy_container(struct, 'obj')
+            self.write('return obj;')
+        self.write()
+
+    def write_special_container(self, struct, name):
+        self.namespace = ['x11']
+        name = self.qualtype(struct, name)
+        self.write('template <> COMPONENT_EXPORT(X11)')
+        self.write('WriteBuffer Write<%s>(' % name)
+        with Indent(self, '    const %s& obj) {' % name, '}'):
+            self.write('WriteBuffer buf;')
+            self.write()
+            self.is_read = False
+            self.copy_container(struct, 'obj')
+            self.write('return buf;')
+        self.write()
+
+    def declare_union(self, union):
+        name = union.name[-1]
+        if union.elt.tag == 'eventstruct':
+            # There's only one of these in all of the protocol descriptions.
+            # It's just used to represent any 32-byte event for XInput.
+            self.write('using %s = std::array<uint8_t, 32>;' % name)
+            return
+        with Indent(self, 'union %s {' % name, '};'):
+            self.write('%s() { memset(this, 0, sizeof(*this)); }' % name)
+            self.write()
+            for field in union.fields:
+                field_type_names = self.declare_field(field)
+                assert len(field_type_names) == 1
+                self.write('%s %s;' % field_type_names[0])
+        self.write(
+            'static_assert(std::is_trivially_copyable<%s>::value, "");' % name)
+        self.write()
+
+    # Returns a list of strings suitable for use as a default-initializer for
+    # |field|.  There may be 0 strings (if the field is hidden from the public
+    # API), 1 string (for normal cases), or many strings (for switch fields).
+    def get_initializer(self, field):
+        if self.is_field_hidden_from_api(field):
+            return []
+
+        if field.type.is_switch:
+            return ['absl::nullopt'] * len(self.declare_switch(field))
+        if field.type.is_list or not field.type.is_container:
+            return ['{}']
+
+        # While using {} as an initializer for structs is fine when nested
+        # in other structs, it causes compiler errors when used as a default
+        # argument initializer, so explicitly initialize each field.
+        return [
+            '{%s}' % ', '.join([
+                init for subfield in field.type.fields
+                if not self.is_field_hidden_from_api(subfield)
+                for init in self.get_initializer(subfield)
+            ])
+        ]
+
+    def declare_request(self, request):
+        method_name = request.name[-1]
+        request_name = method_name + 'Request'
+        reply_name = method_name + 'Reply' if request.reply else 'void'
+
+        in_class = self.namespace == ['x11', self.class_name]
+
+        if not in_class or self.module.namespace.is_ext:
+            self.declare_container(request, request.name)
+            if request.reply:
+                self.declare_container(request.reply, request.reply.name)
+
+            self.write('using %sResponse = Response<%s>;' %
+                       (method_name, reply_name))
+            self.write()
+
+        if in_class:
+            # Generate a request method that takes a Request object.
+            self.write('Future<%s> %s(' % (reply_name, method_name))
+            self.write('    const %s& request);' % request_name)
+            self.write()
+
+            # Generate a request method that takes fields as arguments and
+            # forwards them as a Request object to the above implementation.
+            field_type_names = [
+                field_type_name for field in request.fields
+                for field_type_name in self.declare_field(field)
+            ]
+            inits = [
+                init for field in request.fields
+                for init in self.get_initializer(field)
+            ]
+            assert len(field_type_names) == len(inits)
+            args = [
+                'const %s& %s = %s' % (field_type_name + (init, ))
+                for (field_type_name, init) in zip(field_type_names, inits)
+            ]
+            self.write('Future<%s> %s(%s);' %
+                       (reply_name, method_name, ', '.join(args)))
+            self.write()
+
+    def define_request(self, request):
+        method_name = '%s::%s' % (self.class_name, request.name[-1])
+        prefix = (method_name
+                  if self.module.namespace.is_ext else request.name[-1])
+        request_name = prefix + 'Request'
+        reply_name = prefix + 'Reply'
+
+        reply = request.reply
+        if not reply:
+            reply_name = 'void'
+
+        # Generate a request method that takes a Request object.
+        self.write('Future<%s>' % reply_name)
+        self.write('%s(' % method_name)
+        with Indent(self, '    const %s& request) {' % request_name, '}'):
+            cond = '!connection_->Ready()'
+            if self.module.namespace.is_ext:
+                cond += ' || !present()'
+            self.write('if (%s)' % cond)
+            self.write('  return {};')
+            self.write()
+            self.namespace = ['x11', self.class_name]
+            self.write('WriteBuffer buf;')
+            self.write()
+            self.is_read = False
+            self.copy_container(request, 'request')
+            self.write('Align(&buf, 4);')
+            self.write()
+            reply_has_fds = reply and any(field.isfd for field in reply.fields)
+            self.write(
+                'return connection_->SendRequest<%s>(&buf, "%s", %s);' %
+                (reply_name, prefix, 'true' if reply_has_fds else 'false'))
+        self.write()
+
+        # Generate a request method that takes fields as arguments and
+        # forwards them as a Request object to the above implementation.
+        self.write('Future<%s>' % reply_name)
+        self.write('%s(' % method_name)
+        args = [
+            'const %s& %s' % field_type_name for field in request.fields
+            for field_type_name in self.declare_field(field)
+        ]
+        with Indent(self, '%s) {' % ', '.join(args), '}'):
+            self.write('return %s(%s{%s});' %
+                       (method_name, request_name, ', '.join([
+                           field_name for field in request.fields
+                           for (_, field_name) in self.declare_field(field)
+                       ])))
+        self.write()
+
+        if not reply:
+            return
+
+        self.write('template<> COMPONENT_EXPORT(X11)')
+        self.write('std::unique_ptr<%s>' % reply_name)
+        sig = 'detail::ReadReply<%s>(ReadBuffer* buffer) {' % reply_name
+        with Indent(self, sig, '}'):
+            self.namespace = ['x11']
+            self.write('auto& buf = *buffer;')
+            self.write('auto reply = std::make_unique<%s>();' % reply_name)
+            self.write()
+            self.is_read = True
+            self.copy_container(reply, '(*reply)')
+            self.write('Align(&buf, 4);')
+            offset = 'buf.offset < 32 ? 0 : buf.offset - 32'
+            self.write('DCHECK_EQ(%s, 4 * length);' % offset)
+            self.write()
+            self.write('return reply;')
+        self.write()
+
+    def define_event(self, event, name):
+        self.namespace = ['x11']
+        name = self.qualtype(event, name)
+        self.write('template <> COMPONENT_EXPORT(X11)')
+        self.write('void ReadEvent<%s>(' % name)
+        with Indent(self, '    %s* event_, ReadBuffer* buffer) {' % name, '}'):
+            self.write('auto& buf = *buffer;')
+            self.write()
+            self.is_read = True
+            self.copy_container(event, '(*event_)')
+            if event.is_ge_event:
+                self.write('Align(&buf, 4);')
+                self.write('DCHECK_EQ(buf.offset, 32 + 4 * length);')
+            else:
+                self.write('DCHECK_LE(buf.offset, 32ul);')
+        self.write()
+
+    def define_error(self, error, name):
+        self.namespace = ['x11']
+        name = self.qualtype(error, name)
+        with Indent(self, 'std::string %s::ToString() const {' % name, '}'):
+            self.write('std::stringstream ss_;')
+            self.write('ss_ << "%s{";' % name)
+            fields = [field for field in error.fields if field.visible]
+            for i, field in enumerate(fields):
+                terminator = '' if i == len(fields) - 1 else ' << ", "'
+                self.write('ss_ << ".%s = " << static_cast<uint64_t>(%s)%s;' %
+                           (field.field_name, field.field_name, terminator))
+            self.write('ss_ << "}";')
+            self.write('return ss_.str();')
+        self.write()
+        self.write('template <>')
+        self.write('void ReadError<%s>(' % name)
+        with Indent(self, '    %s* error_, ReadBuffer* buffer) {' % name, '}'):
+            self.write('auto& buf = *buffer;')
+            self.write()
+            self.is_read = True
+            self.copy_container(error, '(*error_)')
+            self.write('DCHECK_LE(buf.offset, 32ul);')
+
+    def define_type(self, item, name):
+        if name in READ_SPECIAL:
+            self.read_special_container(item, name)
+        if name in WRITE_SPECIAL:
+            self.write_special_container(item, name)
+        if isinstance(item, self.xcbgen.xtypes.Request):
+            self.define_request(item)
+        elif item.is_event:
+            self.define_event(item, name)
+        elif isinstance(item, self.xcbgen.xtypes.Error):
+            self.define_error(item, name)
+
+    def declare_type(self, item, name):
+        if item.is_union:
+            self.declare_union(item)
+        elif isinstance(item, self.xcbgen.xtypes.Request):
+            self.declare_request(item)
+        elif item.is_event:
+            self.declare_event(item, name)
+        elif isinstance(item, self.xcbgen.xtypes.Error):
+            self.declare_error(item, name)
+        elif item.is_container:
+            self.declare_container(item, name)
+        elif isinstance(item, self.xcbgen.xtypes.Enum):
+            self.declare_enum(item)
+        else:
+            assert item.is_simple
+            self.declare_simple(item, name)
+
+    # Additional type information identifying the enum/mask is present in the
+    # XML data, but xcbgen doesn't make use of it: it only uses the underlying
+    # type, as it appears on the wire.  We want additional type safety, so
+    # extract this information the from XML directly.
+    def resolve_element(self, xml_element, fields):
+        for child in xml_element:
+            if 'name' not in child.attrib:
+                if child.tag == 'case' or child.tag == 'bitcase':
+                    self.resolve_element(child, fields)
+                continue
+            name = child.attrib['name']
+            field = fields[name]
+            field.elt = child
+            enums = [
+                child.attrib[attr] for attr in ['enum', 'mask']
+                if attr in child.attrib
+            ]
+            if enums:
+                assert len(enums) == 1
+                enum = enums[0]
+                field.enum = self.module.get_type(enum).name
+                self.enum_types[enum].add(field.type.name)
+            else:
+                field.enum = None
+
+    def resolve_type(self, t, name):
+        renamed = tuple(self.rename_type(t, name))
+        assert renamed[0] == 'x11'
+        assert t not in self.types[renamed]
+        self.types[renamed].append(t)
+        self.all_types[renamed] = t
+
+        if isinstance(t, self.xcbgen.xtypes.Enum):
+            self.bitenums.append((t, name))
+
+        if not t.is_container:
+            return
+
+        fields = {
+            field.field_name: field
+            for field in (self.switch_fields(t) if t.is_switch else t.fields)
+        }
+
+        self.resolve_element(t.elt, fields)
+
+        for field in fields.values():
+            if field.field_name == 'sequence':
+                field.visible = True
+            field.parent = (t, name)
+
+            if field.type.is_list:
+                # xcb uses void* in some places to represent arbitrary data.
+                field.type.is_ref_counted_memory = (
+                    not field.type.nmemb and field.field_type[0] == 'void')
+
+            # |for_list| and |for_switch| may have already been set when
+            # processing other fields in this structure.
+            field.for_list = getattr(field, 'for_list', None)
+            field.for_switch = getattr(field, 'for_switch', None)
+
+            for is_type, for_type in ((field.type.is_list, 'for_list'),
+                                      (field.type.is_switch, 'for_switch')):
+                if not is_type:
+                    continue
+                expr = field.type.expr
+                field_name = expr.lenfield_name
+                if (expr.op in (None, 'calculate_len')
+                        and field_name in fields):
+                    setattr(fields[field_name], for_type, field)
+
+            if field.type.is_switch or field.type.is_case_or_bitcase:
+                self.resolve_type(field.type, field.field_type)
+
+        if isinstance(t, self.xcbgen.xtypes.Request) and t.reply:
+            self.resolve_type(t.reply, t.reply.name)
+
+    # Multiple event names may map to the same underlying event.  For these
+    # cases, we want to avoid duplicating the event structure.  Instead, put
+    # all of these events under one structure with an additional opcode field
+    # to indicate the type of event.
+    def uniquify_events(self):
+        types = []
+        events = set()
+        for name, t in self.module.all:
+            if not t.is_event or len(t.opcodes) == 1:
+                types.append((name, t))
+                continue
+
+            renamed = tuple(self.rename_type(t, name))
+            self.all_types[renamed] = t
+            if t in events:
+                continue
+            events.add(t)
+
+            names = [name[-1] for name in t.opcodes.keys()]
+            name = name[:-1] + (event_base_name(names), )
+            types.append((name, t))
+
+            t.enum_opcodes = {}
+            for opname in t.opcodes:
+                opcode = t.opcodes[opname]
+                opname = opname[-1]
+                if opname.startswith(name[-1]):
+                    opname = opname[len(name[-1]):]
+                t.enum_opcodes[opname] = opcode
+        self.module.all = types
+
+    # Perform preprocessing like renaming, reordering, and adding additional
+    # data fields.
+    def resolve(self):
+        self.class_name = (adjust_type_name(self.module.namespace.ext_name)
+                           if self.module.namespace.is_ext else 'XProto')
+
+        self.uniquify_events()
+
+        for name, t in self.module.all:
+            self.resolve_type(t, name)
+
+        for enum, types in list(self.enum_types.items()):
+            if len(types) == 1:
+                self.enum_types[enum] = list(types)[0]
+            else:
+                del self.enum_types[enum]
+
+        for t in self.types:
+            l = self.types[t]
+            if len(l) == 1:
+                continue
+
+            # Allow simple types and enums to alias each other after renaming.
+            # This is done because we want strong typing even for simple types.
+            # If the types were not merged together, then a cast would be
+            # necessary to convert from eg. AtomEnum to AtomSimple.
+            assert len(l) == 2
+            if isinstance(l[0], self.xcbgen.xtypes.Enum):
+                enum = l[0]
+                simple = l[1]
+            elif isinstance(l[1], self.xcbgen.xtypes.Enum):
+                enum = l[1]
+                simple = l[0]
+            assert simple.is_simple
+            assert enum and simple
+            self.replace_with_enum.add(t)
+            self.enum_types[enum.name] = simple.name
+
+        for node in self.module.namespace.root:
+            if 'name' in node.attrib:
+                key = (node.tag, node.attrib['name'])
+                assert key not in self.module_names
+                self.module_names[key] = node
+
+        # The order of types in xcbproto's xml files are inconsistent, so sort
+        # them in the order {type aliases, enums, xidunions, structs,
+        # requests/replies}.
+        def type_order_priority(module_type):
+            name, item = module_type
+            if item.is_simple:
+                return 2 if self.get_xidunion_element(name) else 0
+            if isinstance(item, self.xcbgen.xtypes.Enum):
+                return 1
+            if isinstance(item, self.xcbgen.xtypes.Request):
+                return 4
+            return 3
+
+        # sort() is guaranteed to be stable.
+        self.module.all.sort(key=type_order_priority)
+
+    def gen_header(self):
+        self.file = self.header_file
+        self.write_header()
+        include_guard = 'UI_GFX_X_GENERATED_PROTOS_%s_' % (
+            self.header_file.name.split('/')[-1].upper().replace('.', '_'))
+        self.write('#ifndef ' + include_guard)
+        self.write('#define ' + include_guard)
+        self.write()
+        self.write('#include <array>')
+        self.write('#include <cstddef>')
+        self.write('#include <cstdint>')
+        self.write('#include <cstring>')
+        self.write('#include <vector>')
+        self.write()
+        self.write('#include "base/component_export.h"')
+        self.write('#include "base/memory/ref_counted_memory.h"')
+        self.write('#include "base/memory/scoped_refptr.h"')
+        self.write('#include "third_party/abseil-cpp/absl/types/optional.h"')
+        self.write('#include "base/files/scoped_file.h"')
+        self.write('#include "ui/gfx/x/ref_counted_fd.h"')
+        self.write('#include "ui/gfx/x/error.h"')
+        imports = set(self.module.direct_imports)
+        if self.module.namespace.is_ext:
+            imports.add(('xproto', 'xproto'))
+        for direct_import in sorted(list(imports)):
+            self.write('#include "%s.h"' % direct_import[-1])
+        self.write()
+        self.write('namespace x11 {')
+        self.write()
+        self.write('class Connection;')
+        self.write()
+        self.write('template <typename Reply>')
+        self.write('struct Response;')
+        self.write()
+        self.write('template <typename Reply>')
+        self.write('class Future;')
+        self.write()
+
+        self.namespace = ['x11']
+        if not self.module.namespace.is_ext:
+            for (name, item) in self.module.all:
+                self.declare_type(item, name)
+
+        name = self.class_name
+        with Indent(self, 'class COMPONENT_EXPORT(X11) %s {' % name, '};'):
+            self.namespace = ['x11', self.class_name]
+            self.write('public:')
+            if self.module.namespace.is_ext:
+                self.write('static constexpr unsigned major_version = %s;' %
+                           self.module.namespace.major_version)
+                self.write('static constexpr unsigned minor_version = %s;' %
+                           self.module.namespace.minor_version)
+                self.write()
+                self.write(name + '(Connection* connection,')
+                self.write('    const x11::QueryExtensionReply& info);')
+                self.write()
+                with Indent(self, 'uint8_t present() const {', '}'):
+                    self.write('return info_.present;')
+                with Indent(self, 'uint8_t major_opcode() const {', '}'):
+                    self.write('return info_.major_opcode;')
+                with Indent(self, 'uint8_t first_event() const {', '}'):
+                    self.write('return info_.first_event;')
+                with Indent(self, 'uint8_t first_error() const {', '}'):
+                    self.write('return info_.first_error;')
+            else:
+                self.write('explicit %s(Connection* connection);' % name)
+            self.write()
+            self.write(
+                'Connection* connection() const { return connection_; }')
+            self.write()
+            for (name, item) in self.module.all:
+                if self.module.namespace.is_ext:
+                    self.declare_type(item, name)
+                elif isinstance(item, self.xcbgen.xtypes.Request):
+                    self.declare_request(item)
+            self.write('private:')
+            self.write('Connection* const connection_;')
+            if self.module.namespace.is_ext:
+                self.write('x11::QueryExtensionReply info_{};')
+
+        self.write()
+        self.write('}  // namespace x11')
+        self.write()
+        self.namespace = []
+
+        def binop(op, name):
+            self.write('inline constexpr %s operator%s(' % (name, op))
+            with Indent(self, '    {0} l, {0} r)'.format(name) + ' {', '}'):
+                self.write('using T = std::underlying_type_t<%s>;' % name)
+                self.write('return static_cast<%s>(' % name)
+                self.write('    static_cast<T>(l) %s static_cast<T>(r));' % op)
+            self.write()
+
+        for enum, name in self.bitenums:
+            name = self.qualtype(enum, name)
+            binop('|', name)
+            binop('&', name)
+
+        self.write()
+        self.write('#endif  // ' + include_guard)
+
+    def gen_source(self):
+        self.file = self.source_file
+        self.write_header()
+        self.write('#include "%s.h"' % self.module.namespace.header)
+        self.write()
+        self.write('#include <xcb/xcb.h>')
+        self.write('#include <xcb/xcbext.h>')
+        self.write()
+        self.write('#include "base/logging.h"')
+        self.write('#include "base/posix/eintr_wrapper.h"')
+        self.write('#include "ui/gfx/x/xproto_internal.h"')
+        self.write()
+        self.write('namespace x11 {')
+        self.write()
+        ctor = '%s::%s' % (self.class_name, self.class_name)
+        if self.module.namespace.is_ext:
+            self.write(ctor + '(Connection* connection,')
+            self.write('    const x11::QueryExtensionReply& info)')
+            self.write('    : connection_(connection), info_(info) {}')
+        else:
+            self.write(ctor +
+                       '(Connection* connection) : connection_(connection) {}')
+        self.write()
+        for (name, item) in self.module.all:
+            self.define_type(item, name)
+        self.write('}  // namespace x11')
+
+    def parse(self):
+        self.module = self.xcbgen.state.Module(self.xml_filename, None)
+        self.module.register()
+        self.module.resolve()
+
+    def generate(self):
+        self.gen_header()
+        self.gen_source()
+
+
+class GenExtensionManager(FileWriter):
+    def __init__(self, gen_dir, genprotos):
+        FileWriter.__init__(self)
+
+        self.gen_dir = gen_dir
+        self.genprotos = genprotos
+        self.extensions = [
+            proto for proto in genprotos if proto.module.namespace.is_ext
+        ]
+
+    def gen_header(self):
+        self.file = open(os.path.join(self.gen_dir, 'extension_manager.h'),
+                         'w')
+        self.write_header()
+        self.write('#ifndef UI_GFX_X_GENERATED_PROTOS_EXTENSION_MANAGER_H_')
+        self.write('#define UI_GFX_X_GENERATED_PROTOS_EXTENSION_MANAGER_H_')
+        self.write()
+        self.write('#include <memory>')
+        self.write()
+        self.write('#include "base/component_export.h"')
+        self.write()
+        self.write('namespace x11 {')
+        self.write()
+        self.write('class Connection;')
+        self.write()
+        for genproto in self.genprotos:
+            self.write('class %s;' % genproto.class_name)
+        self.write()
+        with Indent(self, 'class COMPONENT_EXPORT(X11) ExtensionManager {',
+                    '};'):
+            self.write('public:')
+            self.write('ExtensionManager();')
+            self.write('~ExtensionManager();')
+            self.write()
+            for extension in self.extensions:
+                name = extension.proto
+                self.write('%s& %s() { return *%s_; }' %
+                           (extension.class_name, name, name))
+            self.write()
+            self.write('protected:')
+            self.write('void Init(Connection* conn);')
+            self.write()
+            self.write('private:')
+            for extension in self.extensions:
+                self.write('std::unique_ptr<%s> %s_;' %
+                           (extension.class_name, extension.proto))
+        self.write()
+        self.write('}  // namespace x11')
+        self.write()
+        self.write('#endif  // UI_GFX_X_GENERATED_PROTOS_EXTENSION_MANAGER_H_')
+
+    def gen_source(self):
+        self.file = open(os.path.join(self.gen_dir, 'extension_manager.cc'),
+                         'w')
+        self.write_header()
+        self.write('#include "ui/gfx/x/extension_manager.h"')
+        self.write()
+        self.write('#include "ui/gfx/x/connection.h"')
+        self.write('#include "ui/gfx/x/xproto_internal.h"')
+        for genproto in self.genprotos:
+            self.write('#include "ui/gfx/x/%s.h"' % genproto.proto)
+        self.write()
+        self.write('namespace x11 {')
+        self.write()
+        init = 'void ExtensionManager::Init'
+        with Indent(self, init + '(Connection* conn) {', '}'):
+            for extension in self.extensions:
+                self.write(
+                    'auto %s_future = conn->QueryExtension("%s");' %
+                    (extension.proto, extension.module.namespace.ext_xname))
+            # Flush so all requests are sent before waiting on any replies.
+            self.write('conn->Flush();')
+            self.write()
+            for extension in self.extensions:
+                name = extension.proto
+                self.write(
+                    '%s_ = MakeExtension<%s>(conn, std::move(%s_future));' %
+                    (name, extension.class_name, name))
+        self.write()
+        self.write('ExtensionManager::ExtensionManager() = default;')
+        self.write('ExtensionManager::~ExtensionManager() = default;')
+        self.write()
+        self.write('}  // namespace x11')
+
+
+class GenReadEvent(FileWriter):
+    def __init__(self, gen_dir, genprotos):
+        FileWriter.__init__(self)
+
+        self.gen_dir = gen_dir
+        self.genprotos = genprotos
+
+        self.events = []
+        for proto in self.genprotos:
+            for name, item in proto.module.all:
+                if item.is_event:
+                    self.events.append((name, item, proto))
+
+    def event_condition(self, event, typename, proto):
+        ext = 'conn->%s()' % proto.proto
+
+        conds = []
+        if not proto.module.namespace.is_ext:
+            # Core protocol event
+            opcode = 'evtype'
+        elif event.is_ge_event:
+            # GenericEvent extension event
+            conds.extend([
+                'evtype == GeGenericEvent::opcode',
+                '%s.present()' % ext,
+                'ge->extension == %s.major_opcode()' % ext,
+            ])
+            opcode = 'ge->event_type'
+        else:
+            # Extension event
+            opcode = 'evtype - %s.first_event()' % ext
+            conds.append('%s.present()' % ext)
+
+        if len(event.opcodes) == 1:
+            conds.append('%s == %s::opcode' % (opcode, typename))
+        else:
+            conds.append('(%s)' % ' || '.join([
+                '%s == %s::%s' % (opcode, typename, opname)
+                for opname in event.enum_opcodes.keys()
+            ]))
+
+        return ' && '.join(conds), opcode
+
+    def gen_event(self, name, event, proto):
+        # We can't ever have a plain generic event.  It must be a concrete
+        # event provided by an extension.
+        if name == ('xcb', 'GeGeneric'):
+            return
+
+        name = [adjust_type_name(part) for part in name[1:]]
+        typename = '::'.join(name) + 'Event'
+
+        cond, opcode = self.event_condition(event, typename, proto)
+        with Indent(self, 'if (%s) {' % cond, '}'):
+            self.write('event->type_id_ = %d;' % event.type_id)
+            with Indent(self, 'event->deleter_ = [](void* event) {', '};'):
+                self.write('delete reinterpret_cast<%s*>(event);' % typename)
+            self.write('auto* event_ = new %s;' % typename)
+            self.write('ReadEvent(event_, buffer);')
+            if len(event.opcodes) > 1:
+                self.write('{0} = static_cast<decltype({0})>({1});'.format(
+                    'event_->opcode', opcode))
+            self.write('event_->send_event = send_event;')
+            self.write('event->event_ = event_;')
+            self.write('event->window_ = event_->GetWindow();')
+            self.write('return;')
+        self.write()
+
+    def gen_source(self):
+        self.file = open(os.path.join(self.gen_dir, 'read_event.cc'), 'w')
+        self.write_header()
+        self.write('#include "ui/gfx/x/event.h"')
+        self.write()
+        self.write('#include <xcb/xcb.h>')
+        self.write()
+        self.write('#include "ui/gfx/x/connection.h"')
+        self.write('#include "ui/gfx/x/xproto_types.h"')
+        for genproto in self.genprotos:
+            self.write('#include "ui/gfx/x/%s.h"' % genproto.proto)
+        self.write()
+        self.write('namespace x11 {')
+        self.write()
+        self.write('void ReadEvent(')
+        args = 'Event* event, Connection* conn, ReadBuffer* buffer'
+        with Indent(self, '    %s) {' % args, '}'):
+            self.write('auto* buf = buffer->data->data();')
+            cast = 'auto* %s = reinterpret_cast<const %s*>(buf);'
+            self.write(cast % ('ev', 'xcb_generic_event_t'))
+            self.write(cast % ('ge', 'xcb_ge_generic_event_t'))
+            self.write('auto evtype = ev->response_type & ~kSendEventMask;')
+            self.write('bool send_event = ev->response_type & kSendEventMask;')
+            self.write()
+            for name, event, proto in self.events:
+                self.gen_event(name, event, proto)
+            self.write('NOTREACHED();')
+        self.write()
+        self.write('}  // namespace x11')
+
+
+class GenReadError(FileWriter):
+    def __init__(self, gen_dir, genprotos, xcbgen):
+        FileWriter.__init__(self)
+
+        self.gen_dir = gen_dir
+        self.genprotos = genprotos
+        self.xcbgen = xcbgen
+
+    def get_errors_for_proto(self, proto):
+        errors = {}
+        for _, item in proto.module.all:
+            if isinstance(item, self.xcbgen.xtypes.Error):
+                for name in item.opcodes:
+                    id = int(item.opcodes[name])
+                    if id < 0:
+                        continue
+                    name = [adjust_type_name(part) for part in name[1:]]
+                    typename = '::'.join(name) + 'Error'
+                    errors[id] = typename
+        return errors
+
+    def gen_errors_for_proto(self, errors, proto):
+        if proto.module.namespace.is_ext:
+            cond = 'if (%s().present()) {' % proto.proto
+            first_error = '%s().first_error()' % proto.proto
+        else:
+            cond = '{'
+            first_error = '0'
+        with Indent(self, cond, '}'):
+            self.write('uint8_t first_error = %s;' % first_error)
+            for id, name in sorted(errors.items()):
+                with Indent(self, '{', '}'):
+                    self.write('auto error_code = first_error + %d;' % id)
+                    self.write('auto parse = MakeError<%s>;' % name)
+                    self.write('add_parser(error_code, first_error, parse);')
+        self.write()
+
+    def gen_init_error_parsers(self):
+        self.write('uint8_t first_errors[256];')
+        self.write('memset(first_errors, 0, sizeof(first_errors));')
+        self.write()
+        args = 'uint8_t error_code, uint8_t first_error, ErrorParser parser'
+        with Indent(self, 'auto add_parser = [&](%s) {' % args, '};'):
+            cond = ('!error_parsers_[error_code] || ' +
+                    'first_error > first_errors[error_code]')
+            with Indent(self, 'if (%s) {' % cond, '}'):
+                self.write('first_errors[error_code] = error_code;')
+                self.write('error_parsers_[error_code] = parser;')
+        self.write()
+        for proto in self.genprotos:
+            errors = self.get_errors_for_proto(proto)
+            if errors:
+                self.gen_errors_for_proto(errors, proto)
+
+    def gen_source(self):
+        self.file = open(os.path.join(self.gen_dir, 'read_error.cc'), 'w')
+        self.write_header()
+        self.write('#include "ui/gfx/x/connection.h"')
+        self.write('#include "ui/gfx/x/error.h"')
+        self.write('#include "ui/gfx/x/xproto_internal.h"')
+        self.write()
+        for genproto in self.genprotos:
+            self.write('#include "ui/gfx/x/%s.h"' % genproto.proto)
+        self.write()
+        self.write('namespace x11 {')
+        self.write()
+        self.write('namespace {')
+        self.write()
+        self.write('template <typename T>')
+        sig = 'std::unique_ptr<Error> MakeError(Connection::RawError error_)'
+        with Indent(self, '%s {' % sig, '}'):
+            self.write('ReadBuffer buf(error_);')
+            self.write('auto error = std::make_unique<T>();')
+            self.write('ReadError(error.get(), &buf);')
+            self.write('return error;')
+        self.write()
+        self.write('}  // namespace')
+        self.write()
+        with Indent(self, 'void Connection::InitErrorParsers() {', '}'):
+            self.gen_init_error_parsers()
+
+        self.write()
+        self.write('}  // namespace x11')
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('xcbproto_dir', type=str)
+    parser.add_argument('gen_dir', type=str)
+    parser.add_argument('protos', type=str, nargs='*')
+    args = parser.parse_args()
+
+    sys.path.insert(1, args.xcbproto_dir)
+    import xcbgen.xtypes
+    import xcbgen.state
+
+    all_types = {}
+    proto_src_dir = os.path.join(args.xcbproto_dir, 'src')
+    genprotos = [
+        GenXproto(proto, proto_src_dir, args.gen_dir, xcbgen, all_types)
+        for proto in args.protos
+    ]
+    for genproto in genprotos:
+        genproto.parse()
+    for genproto in genprotos:
+        genproto.resolve()
+
+    # Give each event a unique type ID.  This is used by Event to
+    # implement downcasting for events.
+    type_id = 1
+    for proto in genprotos:
+        for _, item in proto.module.all:
+            if item.is_event:
+                item.type_id = type_id
+                type_id += 1
+
+    for genproto in genprotos:
+        genproto.generate()
+
+    gen_extension_manager = GenExtensionManager(args.gen_dir, genprotos)
+    gen_extension_manager.gen_header()
+    gen_extension_manager.gen_source()
+
+    GenReadEvent(args.gen_dir, genprotos).gen_source()
+
+    GenReadError(args.gen_dir, genprotos, xcbgen).gen_source()
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/ui/gfx/x/generated_protos/README.txt b/ui/gfx/x/generated_protos/README.txt
new file mode 100644
index 0000000..aea329b
--- /dev/null
+++ b/ui/gfx/x/generated_protos/README.txt
@@ -0,0 +1,10 @@
+The files in this directory are generated by gen_xproto.py.  To regenerate these
+files, add "regenerate_x11_protos=true" to your gn args, then run the following
+(assuming your build directory is out/Release):
+
+$ rm -f ui/gfx/x/generated_protos/*.h
+$ rm -f ui/gfx/x/generated_protos/*.cc
+$ ninja -C out/Release ui/gfx/x:gen_xprotos
+$ cp out/Release/gen/ui/gfx/x/*.h ui/gfx/x/generated_protos/
+$ cp out/Release/gen/ui/gfx/x/*.cc ui/gfx/x/generated_protos/
+$ git cl format
diff --git a/ui/gfx/x/generated_protos/bigreq.cc b/ui/gfx/x/generated_protos/bigreq.cc
new file mode 100644
index 0000000..8ad0c82
--- /dev/null
+++ b/ui/gfx/x/generated_protos/bigreq.cc
@@ -0,0 +1,118 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "bigreq.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+BigRequests::BigRequests(Connection* connection,
+                         const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<BigRequests::EnableReply> BigRequests::Enable(
+    const BigRequests::EnableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<BigRequests::EnableReply>(
+      &buf, "BigRequests::Enable", false);
+}
+
+Future<BigRequests::EnableReply> BigRequests::Enable() {
+  return BigRequests::Enable(BigRequests::EnableRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<BigRequests::EnableReply> detail::ReadReply<
+    BigRequests::EnableReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<BigRequests::EnableReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& maximum_request_length = (*reply).maximum_request_length;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // maximum_request_length
+  Read(&maximum_request_length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/bigreq.h b/ui/gfx/x/generated_protos/bigreq.h
new file mode 100644
index 0000000..46d12de
--- /dev/null
+++ b/ui/gfx/x/generated_protos/bigreq.h
@@ -0,0 +1,101 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_BIGREQ_H_
+#define UI_GFX_X_GENERATED_PROTOS_BIGREQ_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) BigRequests {
+ public:
+  static constexpr unsigned major_version = 0;
+  static constexpr unsigned minor_version = 0;
+
+  BigRequests(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  struct EnableRequest {};
+
+  struct EnableReply {
+    uint16_t sequence{};
+    uint32_t maximum_request_length{};
+  };
+
+  using EnableResponse = Response<EnableReply>;
+
+  Future<EnableReply> Enable(const EnableRequest& request);
+
+  Future<EnableReply> Enable();
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_BIGREQ_H_
diff --git a/ui/gfx/x/generated_protos/composite.cc b/ui/gfx/x/generated_protos/composite.cc
new file mode 100644
index 0000000..5fda723
--- /dev/null
+++ b/ui/gfx/x/generated_protos/composite.cc
@@ -0,0 +1,504 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "composite.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Composite::Composite(Connection* connection,
+                     const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<Composite::QueryVersionReply> Composite::QueryVersion(
+    const Composite::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Composite::QueryVersionReply>(
+      &buf, "Composite::QueryVersion", false);
+}
+
+Future<Composite::QueryVersionReply> Composite::QueryVersion(
+    const uint32_t& client_major_version,
+    const uint32_t& client_minor_version) {
+  return Composite::QueryVersion(Composite::QueryVersionRequest{
+      client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Composite::QueryVersionReply> detail::ReadReply<
+    Composite::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Composite::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Composite::RedirectWindow(
+    const Composite::RedirectWindowRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& update = request.update;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // update
+  uint8_t tmp0;
+  tmp0 = static_cast<uint8_t>(update);
+  buf.Write(&tmp0);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Composite::RedirectWindow",
+                                        false);
+}
+
+Future<void> Composite::RedirectWindow(const Window& window,
+                                       const Redirect& update) {
+  return Composite::RedirectWindow(
+      Composite::RedirectWindowRequest{window, update});
+}
+
+Future<void> Composite::RedirectSubwindows(
+    const Composite::RedirectSubwindowsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& update = request.update;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // update
+  uint8_t tmp1;
+  tmp1 = static_cast<uint8_t>(update);
+  buf.Write(&tmp1);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Composite::RedirectSubwindows",
+                                        false);
+}
+
+Future<void> Composite::RedirectSubwindows(const Window& window,
+                                           const Redirect& update) {
+  return Composite::RedirectSubwindows(
+      Composite::RedirectSubwindowsRequest{window, update});
+}
+
+Future<void> Composite::UnredirectWindow(
+    const Composite::UnredirectWindowRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& update = request.update;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // update
+  uint8_t tmp2;
+  tmp2 = static_cast<uint8_t>(update);
+  buf.Write(&tmp2);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Composite::UnredirectWindow",
+                                        false);
+}
+
+Future<void> Composite::UnredirectWindow(const Window& window,
+                                         const Redirect& update) {
+  return Composite::UnredirectWindow(
+      Composite::UnredirectWindowRequest{window, update});
+}
+
+Future<void> Composite::UnredirectSubwindows(
+    const Composite::UnredirectSubwindowsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& update = request.update;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // update
+  uint8_t tmp3;
+  tmp3 = static_cast<uint8_t>(update);
+  buf.Write(&tmp3);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Composite::UnredirectSubwindows",
+                                        false);
+}
+
+Future<void> Composite::UnredirectSubwindows(const Window& window,
+                                             const Redirect& update) {
+  return Composite::UnredirectSubwindows(
+      Composite::UnredirectSubwindowsRequest{window, update});
+}
+
+Future<void> Composite::CreateRegionFromBorderClip(
+    const Composite::CreateRegionFromBorderClipRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(
+      &buf, "Composite::CreateRegionFromBorderClip", false);
+}
+
+Future<void> Composite::CreateRegionFromBorderClip(const XFixes::Region& region,
+                                                   const Window& window) {
+  return Composite::CreateRegionFromBorderClip(
+      Composite::CreateRegionFromBorderClipRequest{region, window});
+}
+
+Future<void> Composite::NameWindowPixmap(
+    const Composite::NameWindowPixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& pixmap = request.pixmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Composite::NameWindowPixmap",
+                                        false);
+}
+
+Future<void> Composite::NameWindowPixmap(const Window& window,
+                                         const Pixmap& pixmap) {
+  return Composite::NameWindowPixmap(
+      Composite::NameWindowPixmapRequest{window, pixmap});
+}
+
+Future<Composite::GetOverlayWindowReply> Composite::GetOverlayWindow(
+    const Composite::GetOverlayWindowRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Composite::GetOverlayWindowReply>(
+      &buf, "Composite::GetOverlayWindow", false);
+}
+
+Future<Composite::GetOverlayWindowReply> Composite::GetOverlayWindow(
+    const Window& window) {
+  return Composite::GetOverlayWindow(
+      Composite::GetOverlayWindowRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Composite::GetOverlayWindowReply> detail::ReadReply<
+    Composite::GetOverlayWindowReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Composite::GetOverlayWindowReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& overlay_win = (*reply).overlay_win;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // overlay_win
+  Read(&overlay_win, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Composite::ReleaseOverlayWindow(
+    const Composite::ReleaseOverlayWindowRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Composite::ReleaseOverlayWindow",
+                                        false);
+}
+
+Future<void> Composite::ReleaseOverlayWindow(const Window& window) {
+  return Composite::ReleaseOverlayWindow(
+      Composite::ReleaseOverlayWindowRequest{window});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/composite.h b/ui/gfx/x/generated_protos/composite.h
new file mode 100644
index 0000000..76e8be6
--- /dev/null
+++ b/ui/gfx/x/generated_protos/composite.h
@@ -0,0 +1,230 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_COMPOSITE_H_
+#define UI_GFX_X_GENERATED_PROTOS_COMPOSITE_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xfixes.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Composite {
+ public:
+  static constexpr unsigned major_version = 0;
+  static constexpr unsigned minor_version = 4;
+
+  Composite(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Redirect : int {
+    Automatic = 0,
+    Manual = 1,
+  };
+
+  struct QueryVersionRequest {
+    uint32_t client_major_version{};
+    uint32_t client_minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(
+      const uint32_t& client_major_version = {},
+      const uint32_t& client_minor_version = {});
+
+  struct RedirectWindowRequest {
+    Window window{};
+    Redirect update{};
+  };
+
+  using RedirectWindowResponse = Response<void>;
+
+  Future<void> RedirectWindow(const RedirectWindowRequest& request);
+
+  Future<void> RedirectWindow(const Window& window = {},
+                              const Redirect& update = {});
+
+  struct RedirectSubwindowsRequest {
+    Window window{};
+    Redirect update{};
+  };
+
+  using RedirectSubwindowsResponse = Response<void>;
+
+  Future<void> RedirectSubwindows(const RedirectSubwindowsRequest& request);
+
+  Future<void> RedirectSubwindows(const Window& window = {},
+                                  const Redirect& update = {});
+
+  struct UnredirectWindowRequest {
+    Window window{};
+    Redirect update{};
+  };
+
+  using UnredirectWindowResponse = Response<void>;
+
+  Future<void> UnredirectWindow(const UnredirectWindowRequest& request);
+
+  Future<void> UnredirectWindow(const Window& window = {},
+                                const Redirect& update = {});
+
+  struct UnredirectSubwindowsRequest {
+    Window window{};
+    Redirect update{};
+  };
+
+  using UnredirectSubwindowsResponse = Response<void>;
+
+  Future<void> UnredirectSubwindows(const UnredirectSubwindowsRequest& request);
+
+  Future<void> UnredirectSubwindows(const Window& window = {},
+                                    const Redirect& update = {});
+
+  struct CreateRegionFromBorderClipRequest {
+    XFixes::Region region{};
+    Window window{};
+  };
+
+  using CreateRegionFromBorderClipResponse = Response<void>;
+
+  Future<void> CreateRegionFromBorderClip(
+      const CreateRegionFromBorderClipRequest& request);
+
+  Future<void> CreateRegionFromBorderClip(const XFixes::Region& region = {},
+                                          const Window& window = {});
+
+  struct NameWindowPixmapRequest {
+    Window window{};
+    Pixmap pixmap{};
+  };
+
+  using NameWindowPixmapResponse = Response<void>;
+
+  Future<void> NameWindowPixmap(const NameWindowPixmapRequest& request);
+
+  Future<void> NameWindowPixmap(const Window& window = {},
+                                const Pixmap& pixmap = {});
+
+  struct GetOverlayWindowRequest {
+    Window window{};
+  };
+
+  struct GetOverlayWindowReply {
+    uint16_t sequence{};
+    Window overlay_win{};
+  };
+
+  using GetOverlayWindowResponse = Response<GetOverlayWindowReply>;
+
+  Future<GetOverlayWindowReply> GetOverlayWindow(
+      const GetOverlayWindowRequest& request);
+
+  Future<GetOverlayWindowReply> GetOverlayWindow(const Window& window = {});
+
+  struct ReleaseOverlayWindowRequest {
+    Window window{};
+  };
+
+  using ReleaseOverlayWindowResponse = Response<void>;
+
+  Future<void> ReleaseOverlayWindow(const ReleaseOverlayWindowRequest& request);
+
+  Future<void> ReleaseOverlayWindow(const Window& window = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Composite::Redirect operator|(
+    x11::Composite::Redirect l,
+    x11::Composite::Redirect r) {
+  using T = std::underlying_type_t<x11::Composite::Redirect>;
+  return static_cast<x11::Composite::Redirect>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Composite::Redirect operator&(
+    x11::Composite::Redirect l,
+    x11::Composite::Redirect r) {
+  using T = std::underlying_type_t<x11::Composite::Redirect>;
+  return static_cast<x11::Composite::Redirect>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_COMPOSITE_H_
diff --git a/ui/gfx/x/generated_protos/damage.cc b/ui/gfx/x/generated_protos/damage.cc
new file mode 100644
index 0000000..bfd9c66
--- /dev/null
+++ b/ui/gfx/x/generated_protos/damage.cc
@@ -0,0 +1,400 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "damage.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Damage::Damage(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string Damage::BadDamageError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Damage::BadDamageError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Damage::BadDamageError>(Damage::BadDamageError* error_,
+                                       ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Damage::NotifyEvent>(Damage::NotifyEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& level = (*event_).level;
+  auto& sequence = (*event_).sequence;
+  auto& drawable = (*event_).drawable;
+  auto& damage = (*event_).damage;
+  auto& timestamp = (*event_).timestamp;
+  auto& area = (*event_).area;
+  auto& geometry = (*event_).geometry;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // level
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  level = static_cast<Damage::ReportLevel>(tmp0);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  // damage
+  Read(&damage, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // area
+  {
+    auto& x = area.x;
+    auto& y = area.y;
+    auto& width = area.width;
+    auto& height = area.height;
+
+    // x
+    Read(&x, &buf);
+
+    // y
+    Read(&y, &buf);
+
+    // width
+    Read(&width, &buf);
+
+    // height
+    Read(&height, &buf);
+  }
+
+  // geometry
+  {
+    auto& x = geometry.x;
+    auto& y = geometry.y;
+    auto& width = geometry.width;
+    auto& height = geometry.height;
+
+    // x
+    Read(&x, &buf);
+
+    // y
+    Read(&y, &buf);
+
+    // width
+    Read(&width, &buf);
+
+    // height
+    Read(&height, &buf);
+  }
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<Damage::QueryVersionReply> Damage::QueryVersion(
+    const Damage::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Damage::QueryVersionReply>(
+      &buf, "Damage::QueryVersion", false);
+}
+
+Future<Damage::QueryVersionReply> Damage::QueryVersion(
+    const uint32_t& client_major_version,
+    const uint32_t& client_minor_version) {
+  return Damage::QueryVersion(
+      Damage::QueryVersionRequest{client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Damage::QueryVersionReply> detail::ReadReply<
+    Damage::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Damage::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Damage::Create(const Damage::CreateRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& damage = request.damage;
+  auto& drawable = request.drawable;
+  auto& level = request.level;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // damage
+  buf.Write(&damage);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // level
+  uint8_t tmp1;
+  tmp1 = static_cast<uint8_t>(level);
+  buf.Write(&tmp1);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Damage::Create", false);
+}
+
+Future<void> Damage::Create(const DamageId& damage,
+                            const Drawable& drawable,
+                            const ReportLevel& level) {
+  return Damage::Create(Damage::CreateRequest{damage, drawable, level});
+}
+
+Future<void> Damage::Destroy(const Damage::DestroyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& damage = request.damage;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // damage
+  buf.Write(&damage);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Damage::Destroy", false);
+}
+
+Future<void> Damage::Destroy(const DamageId& damage) {
+  return Damage::Destroy(Damage::DestroyRequest{damage});
+}
+
+Future<void> Damage::Subtract(const Damage::SubtractRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& damage = request.damage;
+  auto& repair = request.repair;
+  auto& parts = request.parts;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // damage
+  buf.Write(&damage);
+
+  // repair
+  buf.Write(&repair);
+
+  // parts
+  buf.Write(&parts);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Damage::Subtract", false);
+}
+
+Future<void> Damage::Subtract(const DamageId& damage,
+                              const XFixes::Region& repair,
+                              const XFixes::Region& parts) {
+  return Damage::Subtract(Damage::SubtractRequest{damage, repair, parts});
+}
+
+Future<void> Damage::Add(const Damage::AddRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& region = request.region;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // region
+  buf.Write(&region);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Damage::Add", false);
+}
+
+Future<void> Damage::Add(const Drawable& drawable,
+                         const XFixes::Region& region) {
+  return Damage::Add(Damage::AddRequest{drawable, region});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/damage.h b/ui/gfx/x/generated_protos/damage.h
new file mode 100644
index 0000000..bcfd8c4
--- /dev/null
+++ b/ui/gfx/x/generated_protos/damage.h
@@ -0,0 +1,208 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_DAMAGE_H_
+#define UI_GFX_X_GENERATED_PROTOS_DAMAGE_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xfixes.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Damage {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 1;
+
+  Damage(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class DamageId : uint32_t {};
+
+  enum class ReportLevel : int {
+    RawRectangles = 0,
+    DeltaRectangles = 1,
+    BoundingBox = 2,
+    NonEmpty = 3,
+  };
+
+  struct BadDamageError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct NotifyEvent {
+    static constexpr int type_id = 1;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    ReportLevel level{};
+    uint16_t sequence{};
+    Drawable drawable{};
+    DamageId damage{};
+    Time timestamp{};
+    Rectangle area{};
+    Rectangle geometry{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&drawable);
+    }
+  };
+
+  struct QueryVersionRequest {
+    uint32_t client_major_version{};
+    uint32_t client_minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(
+      const uint32_t& client_major_version = {},
+      const uint32_t& client_minor_version = {});
+
+  struct CreateRequest {
+    DamageId damage{};
+    Drawable drawable{};
+    ReportLevel level{};
+  };
+
+  using CreateResponse = Response<void>;
+
+  Future<void> Create(const CreateRequest& request);
+
+  Future<void> Create(const DamageId& damage = {},
+                      const Drawable& drawable = {},
+                      const ReportLevel& level = {});
+
+  struct DestroyRequest {
+    DamageId damage{};
+  };
+
+  using DestroyResponse = Response<void>;
+
+  Future<void> Destroy(const DestroyRequest& request);
+
+  Future<void> Destroy(const DamageId& damage = {});
+
+  struct SubtractRequest {
+    DamageId damage{};
+    XFixes::Region repair{};
+    XFixes::Region parts{};
+  };
+
+  using SubtractResponse = Response<void>;
+
+  Future<void> Subtract(const SubtractRequest& request);
+
+  Future<void> Subtract(const DamageId& damage = {},
+                        const XFixes::Region& repair = {},
+                        const XFixes::Region& parts = {});
+
+  struct AddRequest {
+    Drawable drawable{};
+    XFixes::Region region{};
+  };
+
+  using AddResponse = Response<void>;
+
+  Future<void> Add(const AddRequest& request);
+
+  Future<void> Add(const Drawable& drawable = {},
+                   const XFixes::Region& region = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Damage::ReportLevel operator|(
+    x11::Damage::ReportLevel l,
+    x11::Damage::ReportLevel r) {
+  using T = std::underlying_type_t<x11::Damage::ReportLevel>;
+  return static_cast<x11::Damage::ReportLevel>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Damage::ReportLevel operator&(
+    x11::Damage::ReportLevel l,
+    x11::Damage::ReportLevel r) {
+  using T = std::underlying_type_t<x11::Damage::ReportLevel>;
+  return static_cast<x11::Damage::ReportLevel>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_DAMAGE_H_
diff --git a/ui/gfx/x/generated_protos/dpms.cc b/ui/gfx/x/generated_protos/dpms.cc
new file mode 100644
index 0000000..dd007a3
--- /dev/null
+++ b/ui/gfx/x/generated_protos/dpms.cc
@@ -0,0 +1,470 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "dpms.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Dpms::Dpms(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<Dpms::GetVersionReply> Dpms::GetVersion(
+    const Dpms::GetVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dpms::GetVersionReply>(
+      &buf, "Dpms::GetVersion", false);
+}
+
+Future<Dpms::GetVersionReply> Dpms::GetVersion(
+    const uint16_t& client_major_version,
+    const uint16_t& client_minor_version) {
+  return Dpms::GetVersion(
+      Dpms::GetVersionRequest{client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dpms::GetVersionReply> detail::ReadReply<Dpms::GetVersionReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dpms::GetVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& server_major_version = (*reply).server_major_version;
+  auto& server_minor_version = (*reply).server_minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // server_major_version
+  Read(&server_major_version, &buf);
+
+  // server_minor_version
+  Read(&server_minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dpms::CapableReply> Dpms::Capable(const Dpms::CapableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dpms::CapableReply>(&buf, "Dpms::Capable",
+                                                      false);
+}
+
+Future<Dpms::CapableReply> Dpms::Capable() {
+  return Dpms::Capable(Dpms::CapableRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dpms::CapableReply> detail::ReadReply<Dpms::CapableReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dpms::CapableReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& capable = (*reply).capable;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // capable
+  Read(&capable, &buf);
+
+  // pad1
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dpms::GetTimeoutsReply> Dpms::GetTimeouts(
+    const Dpms::GetTimeoutsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dpms::GetTimeoutsReply>(
+      &buf, "Dpms::GetTimeouts", false);
+}
+
+Future<Dpms::GetTimeoutsReply> Dpms::GetTimeouts() {
+  return Dpms::GetTimeouts(Dpms::GetTimeoutsRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dpms::GetTimeoutsReply> detail::ReadReply<
+    Dpms::GetTimeoutsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dpms::GetTimeoutsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& standby_timeout = (*reply).standby_timeout;
+  auto& suspend_timeout = (*reply).suspend_timeout;
+  auto& off_timeout = (*reply).off_timeout;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // standby_timeout
+  Read(&standby_timeout, &buf);
+
+  // suspend_timeout
+  Read(&suspend_timeout, &buf);
+
+  // off_timeout
+  Read(&off_timeout, &buf);
+
+  // pad1
+  Pad(&buf, 18);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Dpms::SetTimeouts(const Dpms::SetTimeoutsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& standby_timeout = request.standby_timeout;
+  auto& suspend_timeout = request.suspend_timeout;
+  auto& off_timeout = request.off_timeout;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // standby_timeout
+  buf.Write(&standby_timeout);
+
+  // suspend_timeout
+  buf.Write(&suspend_timeout);
+
+  // off_timeout
+  buf.Write(&off_timeout);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dpms::SetTimeouts", false);
+}
+
+Future<void> Dpms::SetTimeouts(const uint16_t& standby_timeout,
+                               const uint16_t& suspend_timeout,
+                               const uint16_t& off_timeout) {
+  return Dpms::SetTimeouts(
+      Dpms::SetTimeoutsRequest{standby_timeout, suspend_timeout, off_timeout});
+}
+
+Future<void> Dpms::Enable(const Dpms::EnableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dpms::Enable", false);
+}
+
+Future<void> Dpms::Enable() {
+  return Dpms::Enable(Dpms::EnableRequest{});
+}
+
+Future<void> Dpms::Disable(const Dpms::DisableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dpms::Disable", false);
+}
+
+Future<void> Dpms::Disable() {
+  return Dpms::Disable(Dpms::DisableRequest{});
+}
+
+Future<void> Dpms::ForceLevel(const Dpms::ForceLevelRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& power_level = request.power_level;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // power_level
+  uint16_t tmp0;
+  tmp0 = static_cast<uint16_t>(power_level);
+  buf.Write(&tmp0);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dpms::ForceLevel", false);
+}
+
+Future<void> Dpms::ForceLevel(const DPMSMode& power_level) {
+  return Dpms::ForceLevel(Dpms::ForceLevelRequest{power_level});
+}
+
+Future<Dpms::InfoReply> Dpms::Info(const Dpms::InfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dpms::InfoReply>(&buf, "Dpms::Info", false);
+}
+
+Future<Dpms::InfoReply> Dpms::Info() {
+  return Dpms::Info(Dpms::InfoRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dpms::InfoReply> detail::ReadReply<Dpms::InfoReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dpms::InfoReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& power_level = (*reply).power_level;
+  auto& state = (*reply).state;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // power_level
+  uint16_t tmp1;
+  Read(&tmp1, &buf);
+  power_level = static_cast<Dpms::DPMSMode>(tmp1);
+
+  // state
+  Read(&state, &buf);
+
+  // pad1
+  Pad(&buf, 21);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/dpms.h b/ui/gfx/x/generated_protos/dpms.h
new file mode 100644
index 0000000..f81f656
--- /dev/null
+++ b/ui/gfx/x/generated_protos/dpms.h
@@ -0,0 +1,211 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_DPMS_H_
+#define UI_GFX_X_GENERATED_PROTOS_DPMS_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Dpms {
+ public:
+  static constexpr unsigned major_version = 0;
+  static constexpr unsigned minor_version = 0;
+
+  Dpms(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class DPMSMode : int {
+    On = 0,
+    Standby = 1,
+    Suspend = 2,
+    Off = 3,
+  };
+
+  struct GetVersionRequest {
+    uint16_t client_major_version{};
+    uint16_t client_minor_version{};
+  };
+
+  struct GetVersionReply {
+    uint16_t sequence{};
+    uint16_t server_major_version{};
+    uint16_t server_minor_version{};
+  };
+
+  using GetVersionResponse = Response<GetVersionReply>;
+
+  Future<GetVersionReply> GetVersion(const GetVersionRequest& request);
+
+  Future<GetVersionReply> GetVersion(const uint16_t& client_major_version = {},
+                                     const uint16_t& client_minor_version = {});
+
+  struct CapableRequest {};
+
+  struct CapableReply {
+    uint16_t sequence{};
+    uint8_t capable{};
+  };
+
+  using CapableResponse = Response<CapableReply>;
+
+  Future<CapableReply> Capable(const CapableRequest& request);
+
+  Future<CapableReply> Capable();
+
+  struct GetTimeoutsRequest {};
+
+  struct GetTimeoutsReply {
+    uint16_t sequence{};
+    uint16_t standby_timeout{};
+    uint16_t suspend_timeout{};
+    uint16_t off_timeout{};
+  };
+
+  using GetTimeoutsResponse = Response<GetTimeoutsReply>;
+
+  Future<GetTimeoutsReply> GetTimeouts(const GetTimeoutsRequest& request);
+
+  Future<GetTimeoutsReply> GetTimeouts();
+
+  struct SetTimeoutsRequest {
+    uint16_t standby_timeout{};
+    uint16_t suspend_timeout{};
+    uint16_t off_timeout{};
+  };
+
+  using SetTimeoutsResponse = Response<void>;
+
+  Future<void> SetTimeouts(const SetTimeoutsRequest& request);
+
+  Future<void> SetTimeouts(const uint16_t& standby_timeout = {},
+                           const uint16_t& suspend_timeout = {},
+                           const uint16_t& off_timeout = {});
+
+  struct EnableRequest {};
+
+  using EnableResponse = Response<void>;
+
+  Future<void> Enable(const EnableRequest& request);
+
+  Future<void> Enable();
+
+  struct DisableRequest {};
+
+  using DisableResponse = Response<void>;
+
+  Future<void> Disable(const DisableRequest& request);
+
+  Future<void> Disable();
+
+  struct ForceLevelRequest {
+    DPMSMode power_level{};
+  };
+
+  using ForceLevelResponse = Response<void>;
+
+  Future<void> ForceLevel(const ForceLevelRequest& request);
+
+  Future<void> ForceLevel(const DPMSMode& power_level = {});
+
+  struct InfoRequest {};
+
+  struct InfoReply {
+    uint16_t sequence{};
+    DPMSMode power_level{};
+    uint8_t state{};
+  };
+
+  using InfoResponse = Response<InfoReply>;
+
+  Future<InfoReply> Info(const InfoRequest& request);
+
+  Future<InfoReply> Info();
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Dpms::DPMSMode operator|(x11::Dpms::DPMSMode l,
+                                               x11::Dpms::DPMSMode r) {
+  using T = std::underlying_type_t<x11::Dpms::DPMSMode>;
+  return static_cast<x11::Dpms::DPMSMode>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Dpms::DPMSMode operator&(x11::Dpms::DPMSMode l,
+                                               x11::Dpms::DPMSMode r) {
+  using T = std::underlying_type_t<x11::Dpms::DPMSMode>;
+  return static_cast<x11::Dpms::DPMSMode>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_DPMS_H_
diff --git a/ui/gfx/x/generated_protos/dri2.cc b/ui/gfx/x/generated_protos/dri2.cc
new file mode 100644
index 0000000..0e5eca2
--- /dev/null
+++ b/ui/gfx/x/generated_protos/dri2.cc
@@ -0,0 +1,1316 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "dri2.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Dri2::Dri2(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Dri2::BufferSwapCompleteEvent>(
+    Dri2::BufferSwapCompleteEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event_type = (*event_).event_type;
+  auto& drawable = (*event_).drawable;
+  auto& ust_hi = (*event_).ust_hi;
+  auto& ust_lo = (*event_).ust_lo;
+  auto& msc_hi = (*event_).msc_hi;
+  auto& msc_lo = (*event_).msc_lo;
+  auto& sbc = (*event_).sbc;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event_type
+  uint16_t tmp0;
+  Read(&tmp0, &buf);
+  event_type = static_cast<Dri2::EventType>(tmp0);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  // ust_hi
+  Read(&ust_hi, &buf);
+
+  // ust_lo
+  Read(&ust_lo, &buf);
+
+  // msc_hi
+  Read(&msc_hi, &buf);
+
+  // msc_lo
+  Read(&msc_lo, &buf);
+
+  // sbc
+  Read(&sbc, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Dri2::InvalidateBuffersEvent>(
+    Dri2::InvalidateBuffersEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& drawable = (*event_).drawable;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<Dri2::QueryVersionReply> Dri2::QueryVersion(
+    const Dri2::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::QueryVersionReply>(
+      &buf, "Dri2::QueryVersion", false);
+}
+
+Future<Dri2::QueryVersionReply> Dri2::QueryVersion(
+    const uint32_t& major_version,
+    const uint32_t& minor_version) {
+  return Dri2::QueryVersion(
+      Dri2::QueryVersionRequest{major_version, minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::QueryVersionReply> detail::ReadReply<
+    Dri2::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri2::ConnectReply> Dri2::Connect(const Dri2::ConnectRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& driver_type = request.driver_type;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // driver_type
+  uint32_t tmp1;
+  tmp1 = static_cast<uint32_t>(driver_type);
+  buf.Write(&tmp1);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::ConnectReply>(&buf, "Dri2::Connect",
+                                                      false);
+}
+
+Future<Dri2::ConnectReply> Dri2::Connect(const Window& window,
+                                         const DriverType& driver_type) {
+  return Dri2::Connect(Dri2::ConnectRequest{window, driver_type});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::ConnectReply> detail::ReadReply<Dri2::ConnectReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::ConnectReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t driver_name_length{};
+  uint32_t device_name_length{};
+  auto& driver_name = (*reply).driver_name;
+  size_t driver_name_len = driver_name.size();
+  auto& alignment_pad = (*reply).alignment_pad;
+  size_t alignment_pad_len = alignment_pad ? alignment_pad->size() : 0;
+  auto& device_name = (*reply).device_name;
+  size_t device_name_len = device_name.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // driver_name_length
+  Read(&driver_name_length, &buf);
+
+  // device_name_length
+  Read(&device_name_length, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  // driver_name
+  driver_name.resize(driver_name_length);
+  for (auto& driver_name_elem : driver_name) {
+    // driver_name_elem
+    Read(&driver_name_elem, &buf);
+  }
+
+  // alignment_pad
+  alignment_pad = buffer->ReadAndAdvance(
+      (BitAnd((driver_name_length) + (3), BitNot(3))) - (driver_name_length));
+
+  // device_name
+  device_name.resize(device_name_length);
+  for (auto& device_name_elem : device_name) {
+    // device_name_elem
+    Read(&device_name_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri2::AuthenticateReply> Dri2::Authenticate(
+    const Dri2::AuthenticateRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& magic = request.magic;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // magic
+  buf.Write(&magic);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::AuthenticateReply>(
+      &buf, "Dri2::Authenticate", false);
+}
+
+Future<Dri2::AuthenticateReply> Dri2::Authenticate(const Window& window,
+                                                   const uint32_t& magic) {
+  return Dri2::Authenticate(Dri2::AuthenticateRequest{window, magic});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::AuthenticateReply> detail::ReadReply<
+    Dri2::AuthenticateReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::AuthenticateReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& authenticated = (*reply).authenticated;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // authenticated
+  Read(&authenticated, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Dri2::CreateDrawable(const Dri2::CreateDrawableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dri2::CreateDrawable", false);
+}
+
+Future<void> Dri2::CreateDrawable(const Drawable& drawable) {
+  return Dri2::CreateDrawable(Dri2::CreateDrawableRequest{drawable});
+}
+
+Future<void> Dri2::DestroyDrawable(
+    const Dri2::DestroyDrawableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dri2::DestroyDrawable", false);
+}
+
+Future<void> Dri2::DestroyDrawable(const Drawable& drawable) {
+  return Dri2::DestroyDrawable(Dri2::DestroyDrawableRequest{drawable});
+}
+
+Future<Dri2::GetBuffersReply> Dri2::GetBuffers(
+    const Dri2::GetBuffersRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& count = request.count;
+  auto& attachments = request.attachments;
+  size_t attachments_len = attachments.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // count
+  buf.Write(&count);
+
+  // attachments
+  DCHECK_EQ(static_cast<size_t>(attachments_len), attachments.size());
+  for (auto& attachments_elem : attachments) {
+    // attachments_elem
+    buf.Write(&attachments_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::GetBuffersReply>(
+      &buf, "Dri2::GetBuffers", false);
+}
+
+Future<Dri2::GetBuffersReply> Dri2::GetBuffers(
+    const Drawable& drawable,
+    const uint32_t& count,
+    const std::vector<uint32_t>& attachments) {
+  return Dri2::GetBuffers(
+      Dri2::GetBuffersRequest{drawable, count, attachments});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::GetBuffersReply> detail::ReadReply<Dri2::GetBuffersReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::GetBuffersReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  uint32_t count{};
+  auto& buffers = (*reply).buffers;
+  size_t buffers_len = buffers.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // buffers
+  buffers.resize(count);
+  for (auto& buffers_elem : buffers) {
+    // buffers_elem
+    {
+      auto& attachment = buffers_elem.attachment;
+      auto& name = buffers_elem.name;
+      auto& pitch = buffers_elem.pitch;
+      auto& cpp = buffers_elem.cpp;
+      auto& flags = buffers_elem.flags;
+
+      // attachment
+      uint32_t tmp2;
+      Read(&tmp2, &buf);
+      attachment = static_cast<Dri2::Attachment>(tmp2);
+
+      // name
+      Read(&name, &buf);
+
+      // pitch
+      Read(&pitch, &buf);
+
+      // cpp
+      Read(&cpp, &buf);
+
+      // flags
+      Read(&flags, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri2::CopyRegionReply> Dri2::CopyRegion(
+    const Dri2::CopyRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& region = request.region;
+  auto& dest = request.dest;
+  auto& src = request.src;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // region
+  buf.Write(&region);
+
+  // dest
+  buf.Write(&dest);
+
+  // src
+  buf.Write(&src);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::CopyRegionReply>(
+      &buf, "Dri2::CopyRegion", false);
+}
+
+Future<Dri2::CopyRegionReply> Dri2::CopyRegion(const Drawable& drawable,
+                                               const uint32_t& region,
+                                               const uint32_t& dest,
+                                               const uint32_t& src) {
+  return Dri2::CopyRegion(Dri2::CopyRegionRequest{drawable, region, dest, src});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::CopyRegionReply> detail::ReadReply<Dri2::CopyRegionReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::CopyRegionReply>();
+
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri2::GetBuffersWithFormatReply> Dri2::GetBuffersWithFormat(
+    const Dri2::GetBuffersWithFormatRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& count = request.count;
+  auto& attachments = request.attachments;
+  size_t attachments_len = attachments.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // count
+  buf.Write(&count);
+
+  // attachments
+  DCHECK_EQ(static_cast<size_t>(attachments_len), attachments.size());
+  for (auto& attachments_elem : attachments) {
+    // attachments_elem
+    {
+      auto& attachment = attachments_elem.attachment;
+      auto& format = attachments_elem.format;
+
+      // attachment
+      uint32_t tmp3;
+      tmp3 = static_cast<uint32_t>(attachment);
+      buf.Write(&tmp3);
+
+      // format
+      buf.Write(&format);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::GetBuffersWithFormatReply>(
+      &buf, "Dri2::GetBuffersWithFormat", false);
+}
+
+Future<Dri2::GetBuffersWithFormatReply> Dri2::GetBuffersWithFormat(
+    const Drawable& drawable,
+    const uint32_t& count,
+    const std::vector<AttachFormat>& attachments) {
+  return Dri2::GetBuffersWithFormat(
+      Dri2::GetBuffersWithFormatRequest{drawable, count, attachments});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::GetBuffersWithFormatReply> detail::ReadReply<
+    Dri2::GetBuffersWithFormatReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::GetBuffersWithFormatReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  uint32_t count{};
+  auto& buffers = (*reply).buffers;
+  size_t buffers_len = buffers.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // buffers
+  buffers.resize(count);
+  for (auto& buffers_elem : buffers) {
+    // buffers_elem
+    {
+      auto& attachment = buffers_elem.attachment;
+      auto& name = buffers_elem.name;
+      auto& pitch = buffers_elem.pitch;
+      auto& cpp = buffers_elem.cpp;
+      auto& flags = buffers_elem.flags;
+
+      // attachment
+      uint32_t tmp4;
+      Read(&tmp4, &buf);
+      attachment = static_cast<Dri2::Attachment>(tmp4);
+
+      // name
+      Read(&name, &buf);
+
+      // pitch
+      Read(&pitch, &buf);
+
+      // cpp
+      Read(&cpp, &buf);
+
+      // flags
+      Read(&flags, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri2::SwapBuffersReply> Dri2::SwapBuffers(
+    const Dri2::SwapBuffersRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& target_msc_hi = request.target_msc_hi;
+  auto& target_msc_lo = request.target_msc_lo;
+  auto& divisor_hi = request.divisor_hi;
+  auto& divisor_lo = request.divisor_lo;
+  auto& remainder_hi = request.remainder_hi;
+  auto& remainder_lo = request.remainder_lo;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // target_msc_hi
+  buf.Write(&target_msc_hi);
+
+  // target_msc_lo
+  buf.Write(&target_msc_lo);
+
+  // divisor_hi
+  buf.Write(&divisor_hi);
+
+  // divisor_lo
+  buf.Write(&divisor_lo);
+
+  // remainder_hi
+  buf.Write(&remainder_hi);
+
+  // remainder_lo
+  buf.Write(&remainder_lo);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::SwapBuffersReply>(
+      &buf, "Dri2::SwapBuffers", false);
+}
+
+Future<Dri2::SwapBuffersReply> Dri2::SwapBuffers(const Drawable& drawable,
+                                                 const uint32_t& target_msc_hi,
+                                                 const uint32_t& target_msc_lo,
+                                                 const uint32_t& divisor_hi,
+                                                 const uint32_t& divisor_lo,
+                                                 const uint32_t& remainder_hi,
+                                                 const uint32_t& remainder_lo) {
+  return Dri2::SwapBuffers(Dri2::SwapBuffersRequest{
+      drawable, target_msc_hi, target_msc_lo, divisor_hi, divisor_lo,
+      remainder_hi, remainder_lo});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::SwapBuffersReply> detail::ReadReply<
+    Dri2::SwapBuffersReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::SwapBuffersReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& swap_hi = (*reply).swap_hi;
+  auto& swap_lo = (*reply).swap_lo;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // swap_hi
+  Read(&swap_hi, &buf);
+
+  // swap_lo
+  Read(&swap_lo, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri2::GetMSCReply> Dri2::GetMSC(const Dri2::GetMSCRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::GetMSCReply>(&buf, "Dri2::GetMSC",
+                                                     false);
+}
+
+Future<Dri2::GetMSCReply> Dri2::GetMSC(const Drawable& drawable) {
+  return Dri2::GetMSC(Dri2::GetMSCRequest{drawable});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::GetMSCReply> detail::ReadReply<Dri2::GetMSCReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::GetMSCReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ust_hi = (*reply).ust_hi;
+  auto& ust_lo = (*reply).ust_lo;
+  auto& msc_hi = (*reply).msc_hi;
+  auto& msc_lo = (*reply).msc_lo;
+  auto& sbc_hi = (*reply).sbc_hi;
+  auto& sbc_lo = (*reply).sbc_lo;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ust_hi
+  Read(&ust_hi, &buf);
+
+  // ust_lo
+  Read(&ust_lo, &buf);
+
+  // msc_hi
+  Read(&msc_hi, &buf);
+
+  // msc_lo
+  Read(&msc_lo, &buf);
+
+  // sbc_hi
+  Read(&sbc_hi, &buf);
+
+  // sbc_lo
+  Read(&sbc_lo, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri2::WaitMSCReply> Dri2::WaitMSC(const Dri2::WaitMSCRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& target_msc_hi = request.target_msc_hi;
+  auto& target_msc_lo = request.target_msc_lo;
+  auto& divisor_hi = request.divisor_hi;
+  auto& divisor_lo = request.divisor_lo;
+  auto& remainder_hi = request.remainder_hi;
+  auto& remainder_lo = request.remainder_lo;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // target_msc_hi
+  buf.Write(&target_msc_hi);
+
+  // target_msc_lo
+  buf.Write(&target_msc_lo);
+
+  // divisor_hi
+  buf.Write(&divisor_hi);
+
+  // divisor_lo
+  buf.Write(&divisor_lo);
+
+  // remainder_hi
+  buf.Write(&remainder_hi);
+
+  // remainder_lo
+  buf.Write(&remainder_lo);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::WaitMSCReply>(&buf, "Dri2::WaitMSC",
+                                                      false);
+}
+
+Future<Dri2::WaitMSCReply> Dri2::WaitMSC(const Drawable& drawable,
+                                         const uint32_t& target_msc_hi,
+                                         const uint32_t& target_msc_lo,
+                                         const uint32_t& divisor_hi,
+                                         const uint32_t& divisor_lo,
+                                         const uint32_t& remainder_hi,
+                                         const uint32_t& remainder_lo) {
+  return Dri2::WaitMSC(
+      Dri2::WaitMSCRequest{drawable, target_msc_hi, target_msc_lo, divisor_hi,
+                           divisor_lo, remainder_hi, remainder_lo});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::WaitMSCReply> detail::ReadReply<Dri2::WaitMSCReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::WaitMSCReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ust_hi = (*reply).ust_hi;
+  auto& ust_lo = (*reply).ust_lo;
+  auto& msc_hi = (*reply).msc_hi;
+  auto& msc_lo = (*reply).msc_lo;
+  auto& sbc_hi = (*reply).sbc_hi;
+  auto& sbc_lo = (*reply).sbc_lo;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ust_hi
+  Read(&ust_hi, &buf);
+
+  // ust_lo
+  Read(&ust_lo, &buf);
+
+  // msc_hi
+  Read(&msc_hi, &buf);
+
+  // msc_lo
+  Read(&msc_lo, &buf);
+
+  // sbc_hi
+  Read(&sbc_hi, &buf);
+
+  // sbc_lo
+  Read(&sbc_lo, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri2::WaitSBCReply> Dri2::WaitSBC(const Dri2::WaitSBCRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& target_sbc_hi = request.target_sbc_hi;
+  auto& target_sbc_lo = request.target_sbc_lo;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // target_sbc_hi
+  buf.Write(&target_sbc_hi);
+
+  // target_sbc_lo
+  buf.Write(&target_sbc_lo);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::WaitSBCReply>(&buf, "Dri2::WaitSBC",
+                                                      false);
+}
+
+Future<Dri2::WaitSBCReply> Dri2::WaitSBC(const Drawable& drawable,
+                                         const uint32_t& target_sbc_hi,
+                                         const uint32_t& target_sbc_lo) {
+  return Dri2::WaitSBC(
+      Dri2::WaitSBCRequest{drawable, target_sbc_hi, target_sbc_lo});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::WaitSBCReply> detail::ReadReply<Dri2::WaitSBCReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::WaitSBCReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ust_hi = (*reply).ust_hi;
+  auto& ust_lo = (*reply).ust_lo;
+  auto& msc_hi = (*reply).msc_hi;
+  auto& msc_lo = (*reply).msc_lo;
+  auto& sbc_hi = (*reply).sbc_hi;
+  auto& sbc_lo = (*reply).sbc_lo;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ust_hi
+  Read(&ust_hi, &buf);
+
+  // ust_lo
+  Read(&ust_lo, &buf);
+
+  // msc_hi
+  Read(&msc_hi, &buf);
+
+  // msc_lo
+  Read(&msc_lo, &buf);
+
+  // sbc_hi
+  Read(&sbc_hi, &buf);
+
+  // sbc_lo
+  Read(&sbc_lo, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Dri2::SwapInterval(const Dri2::SwapIntervalRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& interval = request.interval;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // interval
+  buf.Write(&interval);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dri2::SwapInterval", false);
+}
+
+Future<void> Dri2::SwapInterval(const Drawable& drawable,
+                                const uint32_t& interval) {
+  return Dri2::SwapInterval(Dri2::SwapIntervalRequest{drawable, interval});
+}
+
+Future<Dri2::GetParamReply> Dri2::GetParam(
+    const Dri2::GetParamRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& param = request.param;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // param
+  buf.Write(&param);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri2::GetParamReply>(&buf, "Dri2::GetParam",
+                                                       false);
+}
+
+Future<Dri2::GetParamReply> Dri2::GetParam(const Drawable& drawable,
+                                           const uint32_t& param) {
+  return Dri2::GetParam(Dri2::GetParamRequest{drawable, param});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri2::GetParamReply> detail::ReadReply<Dri2::GetParamReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri2::GetParamReply>();
+
+  auto& is_param_recognized = (*reply).is_param_recognized;
+  auto& sequence = (*reply).sequence;
+  auto& value_hi = (*reply).value_hi;
+  auto& value_lo = (*reply).value_lo;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // is_param_recognized
+  Read(&is_param_recognized, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // value_hi
+  Read(&value_hi, &buf);
+
+  // value_lo
+  Read(&value_lo, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/dri2.h b/ui/gfx/x/generated_protos/dri2.h
new file mode 100644
index 0000000..5d4a6bd
--- /dev/null
+++ b/ui/gfx/x/generated_protos/dri2.h
@@ -0,0 +1,474 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_DRI2_H_
+#define UI_GFX_X_GENERATED_PROTOS_DRI2_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Dri2 {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 4;
+
+  Dri2(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Attachment : int {
+    BufferFrontLeft = 0,
+    BufferBackLeft = 1,
+    BufferFrontRight = 2,
+    BufferBackRight = 3,
+    BufferDepth = 4,
+    BufferStencil = 5,
+    BufferAccum = 6,
+    BufferFakeFrontLeft = 7,
+    BufferFakeFrontRight = 8,
+    BufferDepthStencil = 9,
+    BufferHiz = 10,
+  };
+
+  enum class DriverType : int {
+    DRI = 0,
+    VDPAU = 1,
+  };
+
+  enum class EventType : int {
+    ExchangeComplete = 1,
+    BlitComplete = 2,
+    FlipComplete = 3,
+  };
+
+  struct DRI2Buffer {
+    Attachment attachment{};
+    uint32_t name{};
+    uint32_t pitch{};
+    uint32_t cpp{};
+    uint32_t flags{};
+  };
+
+  struct AttachFormat {
+    Attachment attachment{};
+    uint32_t format{};
+  };
+
+  struct BufferSwapCompleteEvent {
+    static constexpr int type_id = 2;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint16_t sequence{};
+    EventType event_type{};
+    Drawable drawable{};
+    uint32_t ust_hi{};
+    uint32_t ust_lo{};
+    uint32_t msc_hi{};
+    uint32_t msc_lo{};
+    uint32_t sbc{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&drawable);
+    }
+  };
+
+  struct InvalidateBuffersEvent {
+    static constexpr int type_id = 3;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint16_t sequence{};
+    Drawable drawable{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&drawable);
+    }
+  };
+
+  struct QueryVersionRequest {
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint32_t& major_version = {},
+                                         const uint32_t& minor_version = {});
+
+  struct ConnectRequest {
+    Window window{};
+    DriverType driver_type{};
+  };
+
+  struct ConnectReply {
+    uint16_t sequence{};
+    std::string driver_name{};
+    scoped_refptr<base::RefCountedMemory> alignment_pad{};
+    std::string device_name{};
+  };
+
+  using ConnectResponse = Response<ConnectReply>;
+
+  Future<ConnectReply> Connect(const ConnectRequest& request);
+
+  Future<ConnectReply> Connect(const Window& window = {},
+                               const DriverType& driver_type = {});
+
+  struct AuthenticateRequest {
+    Window window{};
+    uint32_t magic{};
+  };
+
+  struct AuthenticateReply {
+    uint16_t sequence{};
+    uint32_t authenticated{};
+  };
+
+  using AuthenticateResponse = Response<AuthenticateReply>;
+
+  Future<AuthenticateReply> Authenticate(const AuthenticateRequest& request);
+
+  Future<AuthenticateReply> Authenticate(const Window& window = {},
+                                         const uint32_t& magic = {});
+
+  struct CreateDrawableRequest {
+    Drawable drawable{};
+  };
+
+  using CreateDrawableResponse = Response<void>;
+
+  Future<void> CreateDrawable(const CreateDrawableRequest& request);
+
+  Future<void> CreateDrawable(const Drawable& drawable = {});
+
+  struct DestroyDrawableRequest {
+    Drawable drawable{};
+  };
+
+  using DestroyDrawableResponse = Response<void>;
+
+  Future<void> DestroyDrawable(const DestroyDrawableRequest& request);
+
+  Future<void> DestroyDrawable(const Drawable& drawable = {});
+
+  struct GetBuffersRequest {
+    Drawable drawable{};
+    uint32_t count{};
+    std::vector<uint32_t> attachments{};
+  };
+
+  struct GetBuffersReply {
+    uint16_t sequence{};
+    uint32_t width{};
+    uint32_t height{};
+    std::vector<DRI2Buffer> buffers{};
+  };
+
+  using GetBuffersResponse = Response<GetBuffersReply>;
+
+  Future<GetBuffersReply> GetBuffers(const GetBuffersRequest& request);
+
+  Future<GetBuffersReply> GetBuffers(
+      const Drawable& drawable = {},
+      const uint32_t& count = {},
+      const std::vector<uint32_t>& attachments = {});
+
+  struct CopyRegionRequest {
+    Drawable drawable{};
+    uint32_t region{};
+    uint32_t dest{};
+    uint32_t src{};
+  };
+
+  struct CopyRegionReply {
+    uint16_t sequence{};
+  };
+
+  using CopyRegionResponse = Response<CopyRegionReply>;
+
+  Future<CopyRegionReply> CopyRegion(const CopyRegionRequest& request);
+
+  Future<CopyRegionReply> CopyRegion(const Drawable& drawable = {},
+                                     const uint32_t& region = {},
+                                     const uint32_t& dest = {},
+                                     const uint32_t& src = {});
+
+  struct GetBuffersWithFormatRequest {
+    Drawable drawable{};
+    uint32_t count{};
+    std::vector<AttachFormat> attachments{};
+  };
+
+  struct GetBuffersWithFormatReply {
+    uint16_t sequence{};
+    uint32_t width{};
+    uint32_t height{};
+    std::vector<DRI2Buffer> buffers{};
+  };
+
+  using GetBuffersWithFormatResponse = Response<GetBuffersWithFormatReply>;
+
+  Future<GetBuffersWithFormatReply> GetBuffersWithFormat(
+      const GetBuffersWithFormatRequest& request);
+
+  Future<GetBuffersWithFormatReply> GetBuffersWithFormat(
+      const Drawable& drawable = {},
+      const uint32_t& count = {},
+      const std::vector<AttachFormat>& attachments = {});
+
+  struct SwapBuffersRequest {
+    Drawable drawable{};
+    uint32_t target_msc_hi{};
+    uint32_t target_msc_lo{};
+    uint32_t divisor_hi{};
+    uint32_t divisor_lo{};
+    uint32_t remainder_hi{};
+    uint32_t remainder_lo{};
+  };
+
+  struct SwapBuffersReply {
+    uint16_t sequence{};
+    uint32_t swap_hi{};
+    uint32_t swap_lo{};
+  };
+
+  using SwapBuffersResponse = Response<SwapBuffersReply>;
+
+  Future<SwapBuffersReply> SwapBuffers(const SwapBuffersRequest& request);
+
+  Future<SwapBuffersReply> SwapBuffers(const Drawable& drawable = {},
+                                       const uint32_t& target_msc_hi = {},
+                                       const uint32_t& target_msc_lo = {},
+                                       const uint32_t& divisor_hi = {},
+                                       const uint32_t& divisor_lo = {},
+                                       const uint32_t& remainder_hi = {},
+                                       const uint32_t& remainder_lo = {});
+
+  struct GetMSCRequest {
+    Drawable drawable{};
+  };
+
+  struct GetMSCReply {
+    uint16_t sequence{};
+    uint32_t ust_hi{};
+    uint32_t ust_lo{};
+    uint32_t msc_hi{};
+    uint32_t msc_lo{};
+    uint32_t sbc_hi{};
+    uint32_t sbc_lo{};
+  };
+
+  using GetMSCResponse = Response<GetMSCReply>;
+
+  Future<GetMSCReply> GetMSC(const GetMSCRequest& request);
+
+  Future<GetMSCReply> GetMSC(const Drawable& drawable = {});
+
+  struct WaitMSCRequest {
+    Drawable drawable{};
+    uint32_t target_msc_hi{};
+    uint32_t target_msc_lo{};
+    uint32_t divisor_hi{};
+    uint32_t divisor_lo{};
+    uint32_t remainder_hi{};
+    uint32_t remainder_lo{};
+  };
+
+  struct WaitMSCReply {
+    uint16_t sequence{};
+    uint32_t ust_hi{};
+    uint32_t ust_lo{};
+    uint32_t msc_hi{};
+    uint32_t msc_lo{};
+    uint32_t sbc_hi{};
+    uint32_t sbc_lo{};
+  };
+
+  using WaitMSCResponse = Response<WaitMSCReply>;
+
+  Future<WaitMSCReply> WaitMSC(const WaitMSCRequest& request);
+
+  Future<WaitMSCReply> WaitMSC(const Drawable& drawable = {},
+                               const uint32_t& target_msc_hi = {},
+                               const uint32_t& target_msc_lo = {},
+                               const uint32_t& divisor_hi = {},
+                               const uint32_t& divisor_lo = {},
+                               const uint32_t& remainder_hi = {},
+                               const uint32_t& remainder_lo = {});
+
+  struct WaitSBCRequest {
+    Drawable drawable{};
+    uint32_t target_sbc_hi{};
+    uint32_t target_sbc_lo{};
+  };
+
+  struct WaitSBCReply {
+    uint16_t sequence{};
+    uint32_t ust_hi{};
+    uint32_t ust_lo{};
+    uint32_t msc_hi{};
+    uint32_t msc_lo{};
+    uint32_t sbc_hi{};
+    uint32_t sbc_lo{};
+  };
+
+  using WaitSBCResponse = Response<WaitSBCReply>;
+
+  Future<WaitSBCReply> WaitSBC(const WaitSBCRequest& request);
+
+  Future<WaitSBCReply> WaitSBC(const Drawable& drawable = {},
+                               const uint32_t& target_sbc_hi = {},
+                               const uint32_t& target_sbc_lo = {});
+
+  struct SwapIntervalRequest {
+    Drawable drawable{};
+    uint32_t interval{};
+  };
+
+  using SwapIntervalResponse = Response<void>;
+
+  Future<void> SwapInterval(const SwapIntervalRequest& request);
+
+  Future<void> SwapInterval(const Drawable& drawable = {},
+                            const uint32_t& interval = {});
+
+  struct GetParamRequest {
+    Drawable drawable{};
+    uint32_t param{};
+  };
+
+  struct GetParamReply {
+    uint8_t is_param_recognized{};
+    uint16_t sequence{};
+    uint32_t value_hi{};
+    uint32_t value_lo{};
+  };
+
+  using GetParamResponse = Response<GetParamReply>;
+
+  Future<GetParamReply> GetParam(const GetParamRequest& request);
+
+  Future<GetParamReply> GetParam(const Drawable& drawable = {},
+                                 const uint32_t& param = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Dri2::Attachment operator|(x11::Dri2::Attachment l,
+                                                 x11::Dri2::Attachment r) {
+  using T = std::underlying_type_t<x11::Dri2::Attachment>;
+  return static_cast<x11::Dri2::Attachment>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Dri2::Attachment operator&(x11::Dri2::Attachment l,
+                                                 x11::Dri2::Attachment r) {
+  using T = std::underlying_type_t<x11::Dri2::Attachment>;
+  return static_cast<x11::Dri2::Attachment>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Dri2::DriverType operator|(x11::Dri2::DriverType l,
+                                                 x11::Dri2::DriverType r) {
+  using T = std::underlying_type_t<x11::Dri2::DriverType>;
+  return static_cast<x11::Dri2::DriverType>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Dri2::DriverType operator&(x11::Dri2::DriverType l,
+                                                 x11::Dri2::DriverType r) {
+  using T = std::underlying_type_t<x11::Dri2::DriverType>;
+  return static_cast<x11::Dri2::DriverType>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Dri2::EventType operator|(x11::Dri2::EventType l,
+                                                x11::Dri2::EventType r) {
+  using T = std::underlying_type_t<x11::Dri2::EventType>;
+  return static_cast<x11::Dri2::EventType>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Dri2::EventType operator&(x11::Dri2::EventType l,
+                                                x11::Dri2::EventType r) {
+  using T = std::underlying_type_t<x11::Dri2::EventType>;
+  return static_cast<x11::Dri2::EventType>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_DRI2_H_
diff --git a/ui/gfx/x/generated_protos/dri3.cc b/ui/gfx/x/generated_protos/dri3.cc
new file mode 100644
index 0000000..158cfdf
--- /dev/null
+++ b/ui/gfx/x/generated_protos/dri3.cc
@@ -0,0 +1,855 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "dri3.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Dri3::Dri3(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<Dri3::QueryVersionReply> Dri3::QueryVersion(
+    const Dri3::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri3::QueryVersionReply>(
+      &buf, "Dri3::QueryVersion", false);
+}
+
+Future<Dri3::QueryVersionReply> Dri3::QueryVersion(
+    const uint32_t& major_version,
+    const uint32_t& minor_version) {
+  return Dri3::QueryVersion(
+      Dri3::QueryVersionRequest{major_version, minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri3::QueryVersionReply> detail::ReadReply<
+    Dri3::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri3::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri3::OpenReply> Dri3::Open(const Dri3::OpenRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& provider = request.provider;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // provider
+  buf.Write(&provider);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri3::OpenReply>(&buf, "Dri3::Open", true);
+}
+
+Future<Dri3::OpenReply> Dri3::Open(const Drawable& drawable,
+                                   const uint32_t& provider) {
+  return Dri3::Open(Dri3::OpenRequest{drawable, provider});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri3::OpenReply> detail::ReadReply<Dri3::OpenReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri3::OpenReply>();
+
+  auto& nfd = (*reply).nfd;
+  auto& sequence = (*reply).sequence;
+  auto& device_fd = (*reply).device_fd;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // nfd
+  Read(&nfd, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // device_fd
+  device_fd = RefCountedFD(buf.TakeFd());
+
+  // pad0
+  Pad(&buf, 24);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Dri3::PixmapFromBuffer(
+    const Dri3::PixmapFromBufferRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& pixmap = request.pixmap;
+  auto& drawable = request.drawable;
+  auto& size = request.size;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& stride = request.stride;
+  auto& depth = request.depth;
+  auto& bpp = request.bpp;
+  auto& pixmap_fd = request.pixmap_fd;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // size
+  buf.Write(&size);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // stride
+  buf.Write(&stride);
+
+  // depth
+  buf.Write(&depth);
+
+  // bpp
+  buf.Write(&bpp);
+
+  // pixmap_fd
+  buf.fds().push_back(HANDLE_EINTR(dup(pixmap_fd.get())));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dri3::PixmapFromBuffer", false);
+}
+
+Future<void> Dri3::PixmapFromBuffer(const Pixmap& pixmap,
+                                    const Drawable& drawable,
+                                    const uint32_t& size,
+                                    const uint16_t& width,
+                                    const uint16_t& height,
+                                    const uint16_t& stride,
+                                    const uint8_t& depth,
+                                    const uint8_t& bpp,
+                                    const RefCountedFD& pixmap_fd) {
+  return Dri3::PixmapFromBuffer(Dri3::PixmapFromBufferRequest{
+      pixmap, drawable, size, width, height, stride, depth, bpp, pixmap_fd});
+}
+
+Future<Dri3::BufferFromPixmapReply> Dri3::BufferFromPixmap(
+    const Dri3::BufferFromPixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& pixmap = request.pixmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri3::BufferFromPixmapReply>(
+      &buf, "Dri3::BufferFromPixmap", true);
+}
+
+Future<Dri3::BufferFromPixmapReply> Dri3::BufferFromPixmap(
+    const Pixmap& pixmap) {
+  return Dri3::BufferFromPixmap(Dri3::BufferFromPixmapRequest{pixmap});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri3::BufferFromPixmapReply> detail::ReadReply<
+    Dri3::BufferFromPixmapReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri3::BufferFromPixmapReply>();
+
+  auto& nfd = (*reply).nfd;
+  auto& sequence = (*reply).sequence;
+  auto& size = (*reply).size;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& stride = (*reply).stride;
+  auto& depth = (*reply).depth;
+  auto& bpp = (*reply).bpp;
+  auto& pixmap_fd = (*reply).pixmap_fd;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // nfd
+  Read(&nfd, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // size
+  Read(&size, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // stride
+  Read(&stride, &buf);
+
+  // depth
+  Read(&depth, &buf);
+
+  // bpp
+  Read(&bpp, &buf);
+
+  // pixmap_fd
+  pixmap_fd = RefCountedFD(buf.TakeFd());
+
+  // pad0
+  Pad(&buf, 12);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Dri3::FenceFromFD(const Dri3::FenceFromFDRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& fence = request.fence;
+  auto& initially_triggered = request.initially_triggered;
+  auto& fence_fd = request.fence_fd;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // fence
+  buf.Write(&fence);
+
+  // initially_triggered
+  buf.Write(&initially_triggered);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // fence_fd
+  buf.fds().push_back(HANDLE_EINTR(dup(fence_fd.get())));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dri3::FenceFromFD", false);
+}
+
+Future<void> Dri3::FenceFromFD(const Drawable& drawable,
+                               const uint32_t& fence,
+                               const uint8_t& initially_triggered,
+                               const RefCountedFD& fence_fd) {
+  return Dri3::FenceFromFD(
+      Dri3::FenceFromFDRequest{drawable, fence, initially_triggered, fence_fd});
+}
+
+Future<Dri3::FDFromFenceReply> Dri3::FDFromFence(
+    const Dri3::FDFromFenceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& fence = request.fence;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // fence
+  buf.Write(&fence);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri3::FDFromFenceReply>(
+      &buf, "Dri3::FDFromFence", true);
+}
+
+Future<Dri3::FDFromFenceReply> Dri3::FDFromFence(const Drawable& drawable,
+                                                 const uint32_t& fence) {
+  return Dri3::FDFromFence(Dri3::FDFromFenceRequest{drawable, fence});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri3::FDFromFenceReply> detail::ReadReply<
+    Dri3::FDFromFenceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri3::FDFromFenceReply>();
+
+  auto& nfd = (*reply).nfd;
+  auto& sequence = (*reply).sequence;
+  auto& fence_fd = (*reply).fence_fd;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // nfd
+  Read(&nfd, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // fence_fd
+  fence_fd = RefCountedFD(buf.TakeFd());
+
+  // pad0
+  Pad(&buf, 24);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Dri3::GetSupportedModifiersReply> Dri3::GetSupportedModifiers(
+    const Dri3::GetSupportedModifiersRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& depth = request.depth;
+  auto& bpp = request.bpp;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // depth
+  buf.Write(&depth);
+
+  // bpp
+  buf.Write(&bpp);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri3::GetSupportedModifiersReply>(
+      &buf, "Dri3::GetSupportedModifiers", false);
+}
+
+Future<Dri3::GetSupportedModifiersReply> Dri3::GetSupportedModifiers(
+    const uint32_t& window,
+    const uint8_t& depth,
+    const uint8_t& bpp) {
+  return Dri3::GetSupportedModifiers(
+      Dri3::GetSupportedModifiersRequest{window, depth, bpp});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri3::GetSupportedModifiersReply> detail::ReadReply<
+    Dri3::GetSupportedModifiersReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri3::GetSupportedModifiersReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_window_modifiers{};
+  uint32_t num_screen_modifiers{};
+  auto& window_modifiers = (*reply).window_modifiers;
+  size_t window_modifiers_len = window_modifiers.size();
+  auto& screen_modifiers = (*reply).screen_modifiers;
+  size_t screen_modifiers_len = screen_modifiers.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_window_modifiers
+  Read(&num_window_modifiers, &buf);
+
+  // num_screen_modifiers
+  Read(&num_screen_modifiers, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  // window_modifiers
+  window_modifiers.resize(num_window_modifiers);
+  for (auto& window_modifiers_elem : window_modifiers) {
+    // window_modifiers_elem
+    Read(&window_modifiers_elem, &buf);
+  }
+
+  // screen_modifiers
+  screen_modifiers.resize(num_screen_modifiers);
+  for (auto& screen_modifiers_elem : screen_modifiers) {
+    // screen_modifiers_elem
+    Read(&screen_modifiers_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Dri3::PixmapFromBuffers(
+    const Dri3::PixmapFromBuffersRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& pixmap = request.pixmap;
+  auto& window = request.window;
+  uint8_t num_buffers{};
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& stride0 = request.stride0;
+  auto& offset0 = request.offset0;
+  auto& stride1 = request.stride1;
+  auto& offset1 = request.offset1;
+  auto& stride2 = request.stride2;
+  auto& offset2 = request.offset2;
+  auto& stride3 = request.stride3;
+  auto& offset3 = request.offset3;
+  auto& depth = request.depth;
+  auto& bpp = request.bpp;
+  auto& modifier = request.modifier;
+  auto& buffers = request.buffers;
+  size_t buffers_len = buffers.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  // window
+  buf.Write(&window);
+
+  // num_buffers
+  num_buffers = buffers.size();
+  buf.Write(&num_buffers);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // stride0
+  buf.Write(&stride0);
+
+  // offset0
+  buf.Write(&offset0);
+
+  // stride1
+  buf.Write(&stride1);
+
+  // offset1
+  buf.Write(&offset1);
+
+  // stride2
+  buf.Write(&stride2);
+
+  // offset2
+  buf.Write(&offset2);
+
+  // stride3
+  buf.Write(&stride3);
+
+  // offset3
+  buf.Write(&offset3);
+
+  // depth
+  buf.Write(&depth);
+
+  // bpp
+  buf.Write(&bpp);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // modifier
+  buf.Write(&modifier);
+
+  // buffers
+  DCHECK_EQ(static_cast<size_t>(num_buffers), buffers.size());
+  for (auto& buffers_elem : buffers) {
+    // buffers_elem
+    buf.fds().push_back(HANDLE_EINTR(dup(buffers_elem.get())));
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Dri3::PixmapFromBuffers", false);
+}
+
+Future<void> Dri3::PixmapFromBuffers(const Pixmap& pixmap,
+                                     const Window& window,
+                                     const uint16_t& width,
+                                     const uint16_t& height,
+                                     const uint32_t& stride0,
+                                     const uint32_t& offset0,
+                                     const uint32_t& stride1,
+                                     const uint32_t& offset1,
+                                     const uint32_t& stride2,
+                                     const uint32_t& offset2,
+                                     const uint32_t& stride3,
+                                     const uint32_t& offset3,
+                                     const uint8_t& depth,
+                                     const uint8_t& bpp,
+                                     const uint64_t& modifier,
+                                     const std::vector<RefCountedFD>& buffers) {
+  return Dri3::PixmapFromBuffers(Dri3::PixmapFromBuffersRequest{
+      pixmap, window, width, height, stride0, offset0, stride1, offset1,
+      stride2, offset2, stride3, offset3, depth, bpp, modifier, buffers});
+}
+
+Future<Dri3::BuffersFromPixmapReply> Dri3::BuffersFromPixmap(
+    const Dri3::BuffersFromPixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& pixmap = request.pixmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Dri3::BuffersFromPixmapReply>(
+      &buf, "Dri3::BuffersFromPixmap", true);
+}
+
+Future<Dri3::BuffersFromPixmapReply> Dri3::BuffersFromPixmap(
+    const Pixmap& pixmap) {
+  return Dri3::BuffersFromPixmap(Dri3::BuffersFromPixmapRequest{pixmap});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Dri3::BuffersFromPixmapReply> detail::ReadReply<
+    Dri3::BuffersFromPixmapReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Dri3::BuffersFromPixmapReply>();
+
+  uint8_t nfd{};
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& modifier = (*reply).modifier;
+  auto& depth = (*reply).depth;
+  auto& bpp = (*reply).bpp;
+  auto& strides = (*reply).strides;
+  size_t strides_len = strides.size();
+  auto& offsets = (*reply).offsets;
+  size_t offsets_len = offsets.size();
+  auto& buffers = (*reply).buffers;
+  size_t buffers_len = buffers.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // nfd
+  Read(&nfd, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // pad0
+  Pad(&buf, 4);
+
+  // modifier
+  Read(&modifier, &buf);
+
+  // depth
+  Read(&depth, &buf);
+
+  // bpp
+  Read(&bpp, &buf);
+
+  // pad1
+  Pad(&buf, 6);
+
+  // strides
+  strides.resize(nfd);
+  for (auto& strides_elem : strides) {
+    // strides_elem
+    Read(&strides_elem, &buf);
+  }
+
+  // offsets
+  offsets.resize(nfd);
+  for (auto& offsets_elem : offsets) {
+    // offsets_elem
+    Read(&offsets_elem, &buf);
+  }
+
+  // buffers
+  buffers.resize(nfd);
+  for (auto& buffers_elem : buffers) {
+    // buffers_elem
+    buffers_elem = RefCountedFD(buf.TakeFd());
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/dri3.h b/ui/gfx/x/generated_protos/dri3.h
new file mode 100644
index 0000000..9fda8e3
--- /dev/null
+++ b/ui/gfx/x/generated_protos/dri3.h
@@ -0,0 +1,294 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_DRI3_H_
+#define UI_GFX_X_GENERATED_PROTOS_DRI3_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Dri3 {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 2;
+
+  Dri3(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  struct QueryVersionRequest {
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint32_t& major_version = {},
+                                         const uint32_t& minor_version = {});
+
+  struct OpenRequest {
+    Drawable drawable{};
+    uint32_t provider{};
+  };
+
+  struct OpenReply {
+    uint8_t nfd{};
+    uint16_t sequence{};
+    RefCountedFD device_fd{};
+  };
+
+  using OpenResponse = Response<OpenReply>;
+
+  Future<OpenReply> Open(const OpenRequest& request);
+
+  Future<OpenReply> Open(const Drawable& drawable = {},
+                         const uint32_t& provider = {});
+
+  struct PixmapFromBufferRequest {
+    Pixmap pixmap{};
+    Drawable drawable{};
+    uint32_t size{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t stride{};
+    uint8_t depth{};
+    uint8_t bpp{};
+    RefCountedFD pixmap_fd{};
+  };
+
+  using PixmapFromBufferResponse = Response<void>;
+
+  Future<void> PixmapFromBuffer(const PixmapFromBufferRequest& request);
+
+  Future<void> PixmapFromBuffer(const Pixmap& pixmap = {},
+                                const Drawable& drawable = {},
+                                const uint32_t& size = {},
+                                const uint16_t& width = {},
+                                const uint16_t& height = {},
+                                const uint16_t& stride = {},
+                                const uint8_t& depth = {},
+                                const uint8_t& bpp = {},
+                                const RefCountedFD& pixmap_fd = {});
+
+  struct BufferFromPixmapRequest {
+    Pixmap pixmap{};
+  };
+
+  struct BufferFromPixmapReply {
+    uint8_t nfd{};
+    uint16_t sequence{};
+    uint32_t size{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t stride{};
+    uint8_t depth{};
+    uint8_t bpp{};
+    RefCountedFD pixmap_fd{};
+  };
+
+  using BufferFromPixmapResponse = Response<BufferFromPixmapReply>;
+
+  Future<BufferFromPixmapReply> BufferFromPixmap(
+      const BufferFromPixmapRequest& request);
+
+  Future<BufferFromPixmapReply> BufferFromPixmap(const Pixmap& pixmap = {});
+
+  struct FenceFromFDRequest {
+    Drawable drawable{};
+    uint32_t fence{};
+    uint8_t initially_triggered{};
+    RefCountedFD fence_fd{};
+  };
+
+  using FenceFromFDResponse = Response<void>;
+
+  Future<void> FenceFromFD(const FenceFromFDRequest& request);
+
+  Future<void> FenceFromFD(const Drawable& drawable = {},
+                           const uint32_t& fence = {},
+                           const uint8_t& initially_triggered = {},
+                           const RefCountedFD& fence_fd = {});
+
+  struct FDFromFenceRequest {
+    Drawable drawable{};
+    uint32_t fence{};
+  };
+
+  struct FDFromFenceReply {
+    uint8_t nfd{};
+    uint16_t sequence{};
+    RefCountedFD fence_fd{};
+  };
+
+  using FDFromFenceResponse = Response<FDFromFenceReply>;
+
+  Future<FDFromFenceReply> FDFromFence(const FDFromFenceRequest& request);
+
+  Future<FDFromFenceReply> FDFromFence(const Drawable& drawable = {},
+                                       const uint32_t& fence = {});
+
+  struct GetSupportedModifiersRequest {
+    uint32_t window{};
+    uint8_t depth{};
+    uint8_t bpp{};
+  };
+
+  struct GetSupportedModifiersReply {
+    uint16_t sequence{};
+    std::vector<uint64_t> window_modifiers{};
+    std::vector<uint64_t> screen_modifiers{};
+  };
+
+  using GetSupportedModifiersResponse = Response<GetSupportedModifiersReply>;
+
+  Future<GetSupportedModifiersReply> GetSupportedModifiers(
+      const GetSupportedModifiersRequest& request);
+
+  Future<GetSupportedModifiersReply> GetSupportedModifiers(
+      const uint32_t& window = {},
+      const uint8_t& depth = {},
+      const uint8_t& bpp = {});
+
+  struct PixmapFromBuffersRequest {
+    Pixmap pixmap{};
+    Window window{};
+    uint16_t width{};
+    uint16_t height{};
+    uint32_t stride0{};
+    uint32_t offset0{};
+    uint32_t stride1{};
+    uint32_t offset1{};
+    uint32_t stride2{};
+    uint32_t offset2{};
+    uint32_t stride3{};
+    uint32_t offset3{};
+    uint8_t depth{};
+    uint8_t bpp{};
+    uint64_t modifier{};
+    std::vector<RefCountedFD> buffers{};
+  };
+
+  using PixmapFromBuffersResponse = Response<void>;
+
+  Future<void> PixmapFromBuffers(const PixmapFromBuffersRequest& request);
+
+  Future<void> PixmapFromBuffers(const Pixmap& pixmap = {},
+                                 const Window& window = {},
+                                 const uint16_t& width = {},
+                                 const uint16_t& height = {},
+                                 const uint32_t& stride0 = {},
+                                 const uint32_t& offset0 = {},
+                                 const uint32_t& stride1 = {},
+                                 const uint32_t& offset1 = {},
+                                 const uint32_t& stride2 = {},
+                                 const uint32_t& offset2 = {},
+                                 const uint32_t& stride3 = {},
+                                 const uint32_t& offset3 = {},
+                                 const uint8_t& depth = {},
+                                 const uint8_t& bpp = {},
+                                 const uint64_t& modifier = {},
+                                 const std::vector<RefCountedFD>& buffers = {});
+
+  struct BuffersFromPixmapRequest {
+    Pixmap pixmap{};
+  };
+
+  struct BuffersFromPixmapReply {
+    uint16_t sequence{};
+    uint16_t width{};
+    uint16_t height{};
+    uint64_t modifier{};
+    uint8_t depth{};
+    uint8_t bpp{};
+    std::vector<uint32_t> strides{};
+    std::vector<uint32_t> offsets{};
+    std::vector<RefCountedFD> buffers{};
+  };
+
+  using BuffersFromPixmapResponse = Response<BuffersFromPixmapReply>;
+
+  Future<BuffersFromPixmapReply> BuffersFromPixmap(
+      const BuffersFromPixmapRequest& request);
+
+  Future<BuffersFromPixmapReply> BuffersFromPixmap(const Pixmap& pixmap = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_DRI3_H_
diff --git a/ui/gfx/x/generated_protos/extension_manager.cc b/ui/gfx/x/generated_protos/extension_manager.cc
new file mode 100644
index 0000000..5c680e8
--- /dev/null
+++ b/ui/gfx/x/generated_protos/extension_manager.cc
@@ -0,0 +1,149 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "ui/gfx/x/extension_manager.h"
+
+#include "ui/gfx/x/bigreq.h"
+#include "ui/gfx/x/composite.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/damage.h"
+#include "ui/gfx/x/dpms.h"
+#include "ui/gfx/x/dri2.h"
+#include "ui/gfx/x/dri3.h"
+#include "ui/gfx/x/ge.h"
+#include "ui/gfx/x/glx.h"
+#include "ui/gfx/x/present.h"
+#include "ui/gfx/x/randr.h"
+#include "ui/gfx/x/record.h"
+#include "ui/gfx/x/render.h"
+#include "ui/gfx/x/res.h"
+#include "ui/gfx/x/screensaver.h"
+#include "ui/gfx/x/shape.h"
+#include "ui/gfx/x/shm.h"
+#include "ui/gfx/x/sync.h"
+#include "ui/gfx/x/xc_misc.h"
+#include "ui/gfx/x/xevie.h"
+#include "ui/gfx/x/xf86dri.h"
+#include "ui/gfx/x/xf86vidmode.h"
+#include "ui/gfx/x/xfixes.h"
+#include "ui/gfx/x/xinerama.h"
+#include "ui/gfx/x/xinput.h"
+#include "ui/gfx/x/xkb.h"
+#include "ui/gfx/x/xprint.h"
+#include "ui/gfx/x/xproto.h"
+#include "ui/gfx/x/xproto_internal.h"
+#include "ui/gfx/x/xselinux.h"
+#include "ui/gfx/x/xtest.h"
+#include "ui/gfx/x/xv.h"
+#include "ui/gfx/x/xvmc.h"
+
+namespace x11 {
+
+void ExtensionManager::Init(Connection* conn) {
+  auto bigreq_future = conn->QueryExtension("BIG-REQUESTS");
+  auto composite_future = conn->QueryExtension("Composite");
+  auto damage_future = conn->QueryExtension("DAMAGE");
+  auto dpms_future = conn->QueryExtension("DPMS");
+  auto dri2_future = conn->QueryExtension("DRI2");
+  auto dri3_future = conn->QueryExtension("DRI3");
+  auto ge_future = conn->QueryExtension("Generic Event Extension");
+  auto glx_future = conn->QueryExtension("GLX");
+  auto present_future = conn->QueryExtension("Present");
+  auto randr_future = conn->QueryExtension("RANDR");
+  auto record_future = conn->QueryExtension("RECORD");
+  auto render_future = conn->QueryExtension("RENDER");
+  auto res_future = conn->QueryExtension("X-Resource");
+  auto screensaver_future = conn->QueryExtension("MIT-SCREEN-SAVER");
+  auto shape_future = conn->QueryExtension("SHAPE");
+  auto shm_future = conn->QueryExtension("MIT-SHM");
+  auto sync_future = conn->QueryExtension("SYNC");
+  auto xc_misc_future = conn->QueryExtension("XC-MISC");
+  auto xevie_future = conn->QueryExtension("XEVIE");
+  auto xf86dri_future = conn->QueryExtension("XFree86-DRI");
+  auto xf86vidmode_future = conn->QueryExtension("XFree86-VidModeExtension");
+  auto xfixes_future = conn->QueryExtension("XFIXES");
+  auto xinerama_future = conn->QueryExtension("XINERAMA");
+  auto xinput_future = conn->QueryExtension("XInputExtension");
+  auto xkb_future = conn->QueryExtension("XKEYBOARD");
+  auto xprint_future = conn->QueryExtension("XpExtension");
+  auto xselinux_future = conn->QueryExtension("SELinux");
+  auto xtest_future = conn->QueryExtension("XTEST");
+  auto xv_future = conn->QueryExtension("XVideo");
+  auto xvmc_future = conn->QueryExtension("XVideo-MotionCompensation");
+  conn->Flush();
+
+  bigreq_ = MakeExtension<BigRequests>(conn, std::move(bigreq_future));
+  composite_ = MakeExtension<Composite>(conn, std::move(composite_future));
+  damage_ = MakeExtension<Damage>(conn, std::move(damage_future));
+  dpms_ = MakeExtension<Dpms>(conn, std::move(dpms_future));
+  dri2_ = MakeExtension<Dri2>(conn, std::move(dri2_future));
+  dri3_ = MakeExtension<Dri3>(conn, std::move(dri3_future));
+  ge_ = MakeExtension<GenericEvent>(conn, std::move(ge_future));
+  glx_ = MakeExtension<Glx>(conn, std::move(glx_future));
+  present_ = MakeExtension<Present>(conn, std::move(present_future));
+  randr_ = MakeExtension<RandR>(conn, std::move(randr_future));
+  record_ = MakeExtension<Record>(conn, std::move(record_future));
+  render_ = MakeExtension<Render>(conn, std::move(render_future));
+  res_ = MakeExtension<Res>(conn, std::move(res_future));
+  screensaver_ =
+      MakeExtension<ScreenSaver>(conn, std::move(screensaver_future));
+  shape_ = MakeExtension<Shape>(conn, std::move(shape_future));
+  shm_ = MakeExtension<Shm>(conn, std::move(shm_future));
+  sync_ = MakeExtension<Sync>(conn, std::move(sync_future));
+  xc_misc_ = MakeExtension<XCMisc>(conn, std::move(xc_misc_future));
+  xevie_ = MakeExtension<Xevie>(conn, std::move(xevie_future));
+  xf86dri_ = MakeExtension<XF86Dri>(conn, std::move(xf86dri_future));
+  xf86vidmode_ =
+      MakeExtension<XF86VidMode>(conn, std::move(xf86vidmode_future));
+  xfixes_ = MakeExtension<XFixes>(conn, std::move(xfixes_future));
+  xinerama_ = MakeExtension<Xinerama>(conn, std::move(xinerama_future));
+  xinput_ = MakeExtension<Input>(conn, std::move(xinput_future));
+  xkb_ = MakeExtension<Xkb>(conn, std::move(xkb_future));
+  xprint_ = MakeExtension<XPrint>(conn, std::move(xprint_future));
+  xselinux_ = MakeExtension<SELinux>(conn, std::move(xselinux_future));
+  xtest_ = MakeExtension<Test>(conn, std::move(xtest_future));
+  xv_ = MakeExtension<Xv>(conn, std::move(xv_future));
+  xvmc_ = MakeExtension<XvMC>(conn, std::move(xvmc_future));
+}
+
+ExtensionManager::ExtensionManager() = default;
+ExtensionManager::~ExtensionManager() = default;
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/extension_manager.h b/ui/gfx/x/generated_protos/extension_manager.h
new file mode 100644
index 0000000..625301a
--- /dev/null
+++ b/ui/gfx/x/generated_protos/extension_manager.h
@@ -0,0 +1,158 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_EXTENSION_MANAGER_H_
+#define UI_GFX_X_GENERATED_PROTOS_EXTENSION_MANAGER_H_
+
+#include <memory>
+
+#include "base/component_export.h"
+
+namespace x11 {
+
+class Connection;
+
+class BigRequests;
+class Composite;
+class Damage;
+class Dpms;
+class Dri2;
+class Dri3;
+class GenericEvent;
+class Glx;
+class Present;
+class RandR;
+class Record;
+class Render;
+class Res;
+class ScreenSaver;
+class Shape;
+class Shm;
+class Sync;
+class XCMisc;
+class Xevie;
+class XF86Dri;
+class XF86VidMode;
+class XFixes;
+class Xinerama;
+class Input;
+class Xkb;
+class XPrint;
+class XProto;
+class SELinux;
+class Test;
+class Xv;
+class XvMC;
+
+class COMPONENT_EXPORT(X11) ExtensionManager {
+ public:
+  ExtensionManager();
+  ~ExtensionManager();
+
+  BigRequests& bigreq() { return *bigreq_; }
+  Composite& composite() { return *composite_; }
+  Damage& damage() { return *damage_; }
+  Dpms& dpms() { return *dpms_; }
+  Dri2& dri2() { return *dri2_; }
+  Dri3& dri3() { return *dri3_; }
+  GenericEvent& ge() { return *ge_; }
+  Glx& glx() { return *glx_; }
+  Present& present() { return *present_; }
+  RandR& randr() { return *randr_; }
+  Record& record() { return *record_; }
+  Render& render() { return *render_; }
+  Res& res() { return *res_; }
+  ScreenSaver& screensaver() { return *screensaver_; }
+  Shape& shape() { return *shape_; }
+  Shm& shm() { return *shm_; }
+  Sync& sync() { return *sync_; }
+  XCMisc& xc_misc() { return *xc_misc_; }
+  Xevie& xevie() { return *xevie_; }
+  XF86Dri& xf86dri() { return *xf86dri_; }
+  XF86VidMode& xf86vidmode() { return *xf86vidmode_; }
+  XFixes& xfixes() { return *xfixes_; }
+  Xinerama& xinerama() { return *xinerama_; }
+  Input& xinput() { return *xinput_; }
+  Xkb& xkb() { return *xkb_; }
+  XPrint& xprint() { return *xprint_; }
+  SELinux& xselinux() { return *xselinux_; }
+  Test& xtest() { return *xtest_; }
+  Xv& xv() { return *xv_; }
+  XvMC& xvmc() { return *xvmc_; }
+
+ protected:
+  void Init(Connection* conn);
+
+ private:
+  std::unique_ptr<BigRequests> bigreq_;
+  std::unique_ptr<Composite> composite_;
+  std::unique_ptr<Damage> damage_;
+  std::unique_ptr<Dpms> dpms_;
+  std::unique_ptr<Dri2> dri2_;
+  std::unique_ptr<Dri3> dri3_;
+  std::unique_ptr<GenericEvent> ge_;
+  std::unique_ptr<Glx> glx_;
+  std::unique_ptr<Present> present_;
+  std::unique_ptr<RandR> randr_;
+  std::unique_ptr<Record> record_;
+  std::unique_ptr<Render> render_;
+  std::unique_ptr<Res> res_;
+  std::unique_ptr<ScreenSaver> screensaver_;
+  std::unique_ptr<Shape> shape_;
+  std::unique_ptr<Shm> shm_;
+  std::unique_ptr<Sync> sync_;
+  std::unique_ptr<XCMisc> xc_misc_;
+  std::unique_ptr<Xevie> xevie_;
+  std::unique_ptr<XF86Dri> xf86dri_;
+  std::unique_ptr<XF86VidMode> xf86vidmode_;
+  std::unique_ptr<XFixes> xfixes_;
+  std::unique_ptr<Xinerama> xinerama_;
+  std::unique_ptr<Input> xinput_;
+  std::unique_ptr<Xkb> xkb_;
+  std::unique_ptr<XPrint> xprint_;
+  std::unique_ptr<SELinux> xselinux_;
+  std::unique_ptr<Test> xtest_;
+  std::unique_ptr<Xv> xv_;
+  std::unique_ptr<XvMC> xvmc_;
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_EXTENSION_MANAGER_H_
diff --git a/ui/gfx/x/generated_protos/ge.cc b/ui/gfx/x/generated_protos/ge.cc
new file mode 100644
index 0000000..8afc628
--- /dev/null
+++ b/ui/gfx/x/generated_protos/ge.cc
@@ -0,0 +1,137 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "ge.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+GenericEvent::GenericEvent(Connection* connection,
+                           const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<GenericEvent::QueryVersionReply> GenericEvent::QueryVersion(
+    const GenericEvent::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GenericEvent::QueryVersionReply>(
+      &buf, "GenericEvent::QueryVersion", false);
+}
+
+Future<GenericEvent::QueryVersionReply> GenericEvent::QueryVersion(
+    const uint16_t& client_major_version,
+    const uint16_t& client_minor_version) {
+  return GenericEvent::QueryVersion(GenericEvent::QueryVersionRequest{
+      client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GenericEvent::QueryVersionReply> detail::ReadReply<
+    GenericEvent::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GenericEvent::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/ge.h b/ui/gfx/x/generated_protos/ge.h
new file mode 100644
index 0000000..5e36176
--- /dev/null
+++ b/ui/gfx/x/generated_protos/ge.h
@@ -0,0 +1,107 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_GE_H_
+#define UI_GFX_X_GENERATED_PROTOS_GE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) GenericEvent {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 0;
+
+  GenericEvent(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  struct QueryVersionRequest {
+    uint16_t client_major_version{};
+    uint16_t client_minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(
+      const uint16_t& client_major_version = {},
+      const uint16_t& client_minor_version = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_GE_H_
diff --git a/ui/gfx/x/generated_protos/glx.cc b/ui/gfx/x/generated_protos/glx.cc
new file mode 100644
index 0000000..3ae9c18
--- /dev/null
+++ b/ui/gfx/x/generated_protos/glx.cc
@@ -0,0 +1,8598 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "glx.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Glx::Glx(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string Glx::GenericError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::GenericError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::GenericError>(Glx::GenericError* error_,
+                                  ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadContextError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadContextError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadContextError>(Glx::BadContextError* error_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadContextStateError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadContextStateError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadContextStateError>(Glx::BadContextStateError* error_,
+                                          ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadDrawableError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadDrawableError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadDrawableError>(Glx::BadDrawableError* error_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadPixmapError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadPixmapError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadPixmapError>(Glx::BadPixmapError* error_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadContextTagError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadContextTagError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadContextTagError>(Glx::BadContextTagError* error_,
+                                        ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadCurrentWindowError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadCurrentWindowError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadCurrentWindowError>(Glx::BadCurrentWindowError* error_,
+                                           ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadRenderRequestError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadRenderRequestError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadRenderRequestError>(Glx::BadRenderRequestError* error_,
+                                           ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadLargeRequestError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadLargeRequestError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadLargeRequestError>(Glx::BadLargeRequestError* error_,
+                                          ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::UnsupportedPrivateRequestError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::UnsupportedPrivateRequestError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::UnsupportedPrivateRequestError>(
+    Glx::UnsupportedPrivateRequestError* error_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadFBConfigError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadFBConfigError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadFBConfigError>(Glx::BadFBConfigError* error_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadPbufferError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadPbufferError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadPbufferError>(Glx::BadPbufferError* error_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadCurrentDrawableError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadCurrentDrawableError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadCurrentDrawableError>(
+    Glx::BadCurrentDrawableError* error_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::BadWindowError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::BadWindowError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::BadWindowError>(Glx::BadWindowError* error_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Glx::GLXBadProfileARBError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Glx::GLXBadProfileARBError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Glx::GLXBadProfileARBError>(Glx::GLXBadProfileARBError* error_,
+                                           ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Glx::PbufferClobberEvent>(Glx::PbufferClobberEvent* event_,
+                                         ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event_type = (*event_).event_type;
+  auto& draw_type = (*event_).draw_type;
+  auto& drawable = (*event_).drawable;
+  auto& b_mask = (*event_).b_mask;
+  auto& aux_buffer = (*event_).aux_buffer;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+  auto& count = (*event_).count;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event_type
+  Read(&event_type, &buf);
+
+  // draw_type
+  Read(&draw_type, &buf);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  // b_mask
+  Read(&b_mask, &buf);
+
+  // aux_buffer
+  Read(&aux_buffer, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Glx::BufferSwapCompleteEvent>(
+    Glx::BufferSwapCompleteEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event_type = (*event_).event_type;
+  auto& drawable = (*event_).drawable;
+  auto& ust_hi = (*event_).ust_hi;
+  auto& ust_lo = (*event_).ust_lo;
+  auto& msc_hi = (*event_).msc_hi;
+  auto& msc_lo = (*event_).msc_lo;
+  auto& sbc = (*event_).sbc;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event_type
+  Read(&event_type, &buf);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  // ust_hi
+  Read(&ust_hi, &buf);
+
+  // ust_lo
+  Read(&ust_lo, &buf);
+
+  // msc_hi
+  Read(&msc_hi, &buf);
+
+  // msc_lo
+  Read(&msc_lo, &buf);
+
+  // sbc
+  Read(&sbc, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<void> Glx::Render(const Glx::RenderRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& data = request.data;
+  size_t data_len = data.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // data
+  DCHECK_EQ(static_cast<size_t>(data_len), data.size());
+  for (auto& data_elem : data) {
+    // data_elem
+    buf.Write(&data_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::Render", false);
+}
+
+Future<void> Glx::Render(const ContextTag& context_tag,
+                         const std::vector<uint8_t>& data) {
+  return Glx::Render(Glx::RenderRequest{context_tag, data});
+}
+
+Future<void> Glx::RenderLarge(const Glx::RenderLargeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& request_num = request.request_num;
+  auto& request_total = request.request_total;
+  uint32_t data_len{};
+  auto& data = request.data;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // request_num
+  buf.Write(&request_num);
+
+  // request_total
+  buf.Write(&request_total);
+
+  // data_len
+  data_len = data.size();
+  buf.Write(&data_len);
+
+  // data
+  DCHECK_EQ(static_cast<size_t>(data_len), data.size());
+  for (auto& data_elem : data) {
+    // data_elem
+    buf.Write(&data_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::RenderLarge", false);
+}
+
+Future<void> Glx::RenderLarge(const ContextTag& context_tag,
+                              const uint16_t& request_num,
+                              const uint16_t& request_total,
+                              const std::vector<uint8_t>& data) {
+  return Glx::RenderLarge(
+      Glx::RenderLargeRequest{context_tag, request_num, request_total, data});
+}
+
+Future<void> Glx::CreateContext(const Glx::CreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& visual = request.visual;
+  auto& screen = request.screen;
+  auto& share_list = request.share_list;
+  auto& is_direct = request.is_direct;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // visual
+  buf.Write(&visual);
+
+  // screen
+  buf.Write(&screen);
+
+  // share_list
+  buf.Write(&share_list);
+
+  // is_direct
+  buf.Write(&is_direct);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::CreateContext", false);
+}
+
+Future<void> Glx::CreateContext(const Context& context,
+                                const VisualId& visual,
+                                const uint32_t& screen,
+                                const Context& share_list,
+                                const uint8_t& is_direct) {
+  return Glx::CreateContext(Glx::CreateContextRequest{context, visual, screen,
+                                                      share_list, is_direct});
+}
+
+Future<void> Glx::DestroyContext(const Glx::DestroyContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::DestroyContext", false);
+}
+
+Future<void> Glx::DestroyContext(const Context& context) {
+  return Glx::DestroyContext(Glx::DestroyContextRequest{context});
+}
+
+Future<Glx::MakeCurrentReply> Glx::MakeCurrent(
+    const Glx::MakeCurrentRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& context = request.context;
+  auto& old_context_tag = request.old_context_tag;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // context
+  buf.Write(&context);
+
+  // old_context_tag
+  buf.Write(&old_context_tag);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::MakeCurrentReply>(
+      &buf, "Glx::MakeCurrent", false);
+}
+
+Future<Glx::MakeCurrentReply> Glx::MakeCurrent(
+    const Drawable& drawable,
+    const Context& context,
+    const ContextTag& old_context_tag) {
+  return Glx::MakeCurrent(
+      Glx::MakeCurrentRequest{drawable, context, old_context_tag});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::MakeCurrentReply> detail::ReadReply<Glx::MakeCurrentReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::MakeCurrentReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& context_tag = (*reply).context_tag;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_tag
+  Read(&context_tag, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::IsDirectReply> Glx::IsDirect(const Glx::IsDirectRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::IsDirectReply>(&buf, "Glx::IsDirect",
+                                                      false);
+}
+
+Future<Glx::IsDirectReply> Glx::IsDirect(const Context& context) {
+  return Glx::IsDirect(Glx::IsDirectRequest{context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::IsDirectReply> detail::ReadReply<Glx::IsDirectReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::IsDirectReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& is_direct = (*reply).is_direct;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // is_direct
+  Read(&is_direct, &buf);
+
+  // pad1
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::QueryVersionReply> Glx::QueryVersion(
+    const Glx::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::QueryVersionReply>(
+      &buf, "Glx::QueryVersion", false);
+}
+
+Future<Glx::QueryVersionReply> Glx::QueryVersion(
+    const uint32_t& major_version,
+    const uint32_t& minor_version) {
+  return Glx::QueryVersion(
+      Glx::QueryVersionRequest{major_version, minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::QueryVersionReply> detail::ReadReply<
+    Glx::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::WaitGL(const Glx::WaitGLRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::WaitGL", false);
+}
+
+Future<void> Glx::WaitGL(const ContextTag& context_tag) {
+  return Glx::WaitGL(Glx::WaitGLRequest{context_tag});
+}
+
+Future<void> Glx::WaitX(const Glx::WaitXRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::WaitX", false);
+}
+
+Future<void> Glx::WaitX(const ContextTag& context_tag) {
+  return Glx::WaitX(Glx::WaitXRequest{context_tag});
+}
+
+Future<void> Glx::CopyContext(const Glx::CopyContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& src = request.src;
+  auto& dest = request.dest;
+  auto& mask = request.mask;
+  auto& src_context_tag = request.src_context_tag;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // src
+  buf.Write(&src);
+
+  // dest
+  buf.Write(&dest);
+
+  // mask
+  buf.Write(&mask);
+
+  // src_context_tag
+  buf.Write(&src_context_tag);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::CopyContext", false);
+}
+
+Future<void> Glx::CopyContext(const Context& src,
+                              const Context& dest,
+                              const uint32_t& mask,
+                              const ContextTag& src_context_tag) {
+  return Glx::CopyContext(
+      Glx::CopyContextRequest{src, dest, mask, src_context_tag});
+}
+
+Future<void> Glx::SwapBuffers(const Glx::SwapBuffersRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::SwapBuffers", false);
+}
+
+Future<void> Glx::SwapBuffers(const ContextTag& context_tag,
+                              const Drawable& drawable) {
+  return Glx::SwapBuffers(Glx::SwapBuffersRequest{context_tag, drawable});
+}
+
+Future<void> Glx::UseXFont(const Glx::UseXFontRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& font = request.font;
+  auto& first = request.first;
+  auto& count = request.count;
+  auto& list_base = request.list_base;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // font
+  buf.Write(&font);
+
+  // first
+  buf.Write(&first);
+
+  // count
+  buf.Write(&count);
+
+  // list_base
+  buf.Write(&list_base);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::UseXFont", false);
+}
+
+Future<void> Glx::UseXFont(const ContextTag& context_tag,
+                           const Font& font,
+                           const uint32_t& first,
+                           const uint32_t& count,
+                           const uint32_t& list_base) {
+  return Glx::UseXFont(
+      Glx::UseXFontRequest{context_tag, font, first, count, list_base});
+}
+
+Future<void> Glx::CreateGLXPixmap(const Glx::CreateGLXPixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& visual = request.visual;
+  auto& pixmap = request.pixmap;
+  auto& glx_pixmap = request.glx_pixmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // visual
+  buf.Write(&visual);
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  // glx_pixmap
+  buf.Write(&glx_pixmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::CreateGLXPixmap", false);
+}
+
+Future<void> Glx::CreateGLXPixmap(const uint32_t& screen,
+                                  const VisualId& visual,
+                                  const x11::Pixmap& pixmap,
+                                  const Pixmap& glx_pixmap) {
+  return Glx::CreateGLXPixmap(
+      Glx::CreateGLXPixmapRequest{screen, visual, pixmap, glx_pixmap});
+}
+
+Future<Glx::GetVisualConfigsReply> Glx::GetVisualConfigs(
+    const Glx::GetVisualConfigsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetVisualConfigsReply>(
+      &buf, "Glx::GetVisualConfigs", false);
+}
+
+Future<Glx::GetVisualConfigsReply> Glx::GetVisualConfigs(
+    const uint32_t& screen) {
+  return Glx::GetVisualConfigs(Glx::GetVisualConfigsRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetVisualConfigsReply> detail::ReadReply<
+    Glx::GetVisualConfigsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetVisualConfigsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& num_visuals = (*reply).num_visuals;
+  auto& num_properties = (*reply).num_properties;
+  auto& property_list = (*reply).property_list;
+  size_t property_list_len = property_list.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_visuals
+  Read(&num_visuals, &buf);
+
+  // num_properties
+  Read(&num_properties, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  // property_list
+  property_list.resize(length);
+  for (auto& property_list_elem : property_list) {
+    // property_list_elem
+    Read(&property_list_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::DestroyGLXPixmap(
+    const Glx::DestroyGLXPixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& glx_pixmap = request.glx_pixmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // glx_pixmap
+  buf.Write(&glx_pixmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::DestroyGLXPixmap", false);
+}
+
+Future<void> Glx::DestroyGLXPixmap(const Pixmap& glx_pixmap) {
+  return Glx::DestroyGLXPixmap(Glx::DestroyGLXPixmapRequest{glx_pixmap});
+}
+
+Future<void> Glx::VendorPrivate(const Glx::VendorPrivateRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& vendor_code = request.vendor_code;
+  auto& context_tag = request.context_tag;
+  auto& data = request.data;
+  size_t data_len = data.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // vendor_code
+  buf.Write(&vendor_code);
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // data
+  DCHECK_EQ(static_cast<size_t>(data_len), data.size());
+  for (auto& data_elem : data) {
+    // data_elem
+    buf.Write(&data_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::VendorPrivate", false);
+}
+
+Future<void> Glx::VendorPrivate(const uint32_t& vendor_code,
+                                const ContextTag& context_tag,
+                                const std::vector<uint8_t>& data) {
+  return Glx::VendorPrivate(
+      Glx::VendorPrivateRequest{vendor_code, context_tag, data});
+}
+
+Future<Glx::VendorPrivateWithReplyReply> Glx::VendorPrivateWithReply(
+    const Glx::VendorPrivateWithReplyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& vendor_code = request.vendor_code;
+  auto& context_tag = request.context_tag;
+  auto& data = request.data;
+  size_t data_len = data.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // vendor_code
+  buf.Write(&vendor_code);
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // data
+  DCHECK_EQ(static_cast<size_t>(data_len), data.size());
+  for (auto& data_elem : data) {
+    // data_elem
+    buf.Write(&data_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::VendorPrivateWithReplyReply>(
+      &buf, "Glx::VendorPrivateWithReply", false);
+}
+
+Future<Glx::VendorPrivateWithReplyReply> Glx::VendorPrivateWithReply(
+    const uint32_t& vendor_code,
+    const ContextTag& context_tag,
+    const std::vector<uint8_t>& data) {
+  return Glx::VendorPrivateWithReply(
+      Glx::VendorPrivateWithReplyRequest{vendor_code, context_tag, data});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::VendorPrivateWithReplyReply> detail::ReadReply<
+    Glx::VendorPrivateWithReplyReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::VendorPrivateWithReplyReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& retval = (*reply).retval;
+  auto& data1 = (*reply).data1;
+  size_t data1_len = data1.size();
+  auto& data2 = (*reply).data2;
+  size_t data2_len = data2.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // retval
+  Read(&retval, &buf);
+
+  // data1
+  for (auto& data1_elem : data1) {
+    // data1_elem
+    Read(&data1_elem, &buf);
+  }
+
+  // data2
+  data2.resize((length) * (4));
+  for (auto& data2_elem : data2) {
+    // data2_elem
+    Read(&data2_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::QueryExtensionsStringReply> Glx::QueryExtensionsString(
+    const Glx::QueryExtensionsStringRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::QueryExtensionsStringReply>(
+      &buf, "Glx::QueryExtensionsString", false);
+}
+
+Future<Glx::QueryExtensionsStringReply> Glx::QueryExtensionsString(
+    const uint32_t& screen) {
+  return Glx::QueryExtensionsString(Glx::QueryExtensionsStringRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::QueryExtensionsStringReply> detail::ReadReply<
+    Glx::QueryExtensionsStringReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::QueryExtensionsStringReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& n = (*reply).n;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // pad2
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::QueryServerStringReply> Glx::QueryServerString(
+    const Glx::QueryServerStringRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // name
+  buf.Write(&name);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::QueryServerStringReply>(
+      &buf, "Glx::QueryServerString", false);
+}
+
+Future<Glx::QueryServerStringReply> Glx::QueryServerString(
+    const uint32_t& screen,
+    const uint32_t& name) {
+  return Glx::QueryServerString(Glx::QueryServerStringRequest{screen, name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::QueryServerStringReply> detail::ReadReply<
+    Glx::QueryServerStringReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::QueryServerStringReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t str_len{};
+  auto& string = (*reply).string;
+  size_t string_len = string.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // str_len
+  Read(&str_len, &buf);
+
+  // pad2
+  Pad(&buf, 16);
+
+  // string
+  string.resize(str_len);
+  for (auto& string_elem : string) {
+    // string_elem
+    Read(&string_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::ClientInfo(const Glx::ClientInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+  uint32_t str_len{};
+  auto& string = request.string;
+  size_t string_len = string.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 20;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  // str_len
+  str_len = string.size();
+  buf.Write(&str_len);
+
+  // string
+  DCHECK_EQ(static_cast<size_t>(str_len), string.size());
+  for (auto& string_elem : string) {
+    // string_elem
+    buf.Write(&string_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::ClientInfo", false);
+}
+
+Future<void> Glx::ClientInfo(const uint32_t& major_version,
+                             const uint32_t& minor_version,
+                             const std::string& string) {
+  return Glx::ClientInfo(
+      Glx::ClientInfoRequest{major_version, minor_version, string});
+}
+
+Future<Glx::GetFBConfigsReply> Glx::GetFBConfigs(
+    const Glx::GetFBConfigsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 21;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetFBConfigsReply>(
+      &buf, "Glx::GetFBConfigs", false);
+}
+
+Future<Glx::GetFBConfigsReply> Glx::GetFBConfigs(const uint32_t& screen) {
+  return Glx::GetFBConfigs(Glx::GetFBConfigsRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetFBConfigsReply> detail::ReadReply<
+    Glx::GetFBConfigsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetFBConfigsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& num_FB_configs = (*reply).num_FB_configs;
+  auto& num_properties = (*reply).num_properties;
+  auto& property_list = (*reply).property_list;
+  size_t property_list_len = property_list.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_FB_configs
+  Read(&num_FB_configs, &buf);
+
+  // num_properties
+  Read(&num_properties, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  // property_list
+  property_list.resize(length);
+  for (auto& property_list_elem : property_list) {
+    // property_list_elem
+    Read(&property_list_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::CreatePixmap(const Glx::CreatePixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& fbconfig = request.fbconfig;
+  auto& pixmap = request.pixmap;
+  auto& glx_pixmap = request.glx_pixmap;
+  auto& num_attribs = request.num_attribs;
+  auto& attribs = request.attribs;
+  size_t attribs_len = attribs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 22;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // fbconfig
+  buf.Write(&fbconfig);
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  // glx_pixmap
+  buf.Write(&glx_pixmap);
+
+  // num_attribs
+  buf.Write(&num_attribs);
+
+  // attribs
+  DCHECK_EQ(static_cast<size_t>((num_attribs) * (2)), attribs.size());
+  for (auto& attribs_elem : attribs) {
+    // attribs_elem
+    buf.Write(&attribs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::CreatePixmap", false);
+}
+
+Future<void> Glx::CreatePixmap(const uint32_t& screen,
+                               const FbConfig& fbconfig,
+                               const x11::Pixmap& pixmap,
+                               const Pixmap& glx_pixmap,
+                               const uint32_t& num_attribs,
+                               const std::vector<uint32_t>& attribs) {
+  return Glx::CreatePixmap(Glx::CreatePixmapRequest{
+      screen, fbconfig, pixmap, glx_pixmap, num_attribs, attribs});
+}
+
+Future<void> Glx::DestroyPixmap(const Glx::DestroyPixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& glx_pixmap = request.glx_pixmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 23;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // glx_pixmap
+  buf.Write(&glx_pixmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::DestroyPixmap", false);
+}
+
+Future<void> Glx::DestroyPixmap(const Pixmap& glx_pixmap) {
+  return Glx::DestroyPixmap(Glx::DestroyPixmapRequest{glx_pixmap});
+}
+
+Future<void> Glx::CreateNewContext(
+    const Glx::CreateNewContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& fbconfig = request.fbconfig;
+  auto& screen = request.screen;
+  auto& render_type = request.render_type;
+  auto& share_list = request.share_list;
+  auto& is_direct = request.is_direct;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 24;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // fbconfig
+  buf.Write(&fbconfig);
+
+  // screen
+  buf.Write(&screen);
+
+  // render_type
+  buf.Write(&render_type);
+
+  // share_list
+  buf.Write(&share_list);
+
+  // is_direct
+  buf.Write(&is_direct);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::CreateNewContext", false);
+}
+
+Future<void> Glx::CreateNewContext(const Context& context,
+                                   const FbConfig& fbconfig,
+                                   const uint32_t& screen,
+                                   const uint32_t& render_type,
+                                   const Context& share_list,
+                                   const uint8_t& is_direct) {
+  return Glx::CreateNewContext(Glx::CreateNewContextRequest{
+      context, fbconfig, screen, render_type, share_list, is_direct});
+}
+
+Future<Glx::QueryContextReply> Glx::QueryContext(
+    const Glx::QueryContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 25;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::QueryContextReply>(
+      &buf, "Glx::QueryContext", false);
+}
+
+Future<Glx::QueryContextReply> Glx::QueryContext(const Context& context) {
+  return Glx::QueryContext(Glx::QueryContextRequest{context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::QueryContextReply> detail::ReadReply<
+    Glx::QueryContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::QueryContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& num_attribs = (*reply).num_attribs;
+  auto& attribs = (*reply).attribs;
+  size_t attribs_len = attribs.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_attribs
+  Read(&num_attribs, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // attribs
+  attribs.resize((num_attribs) * (2));
+  for (auto& attribs_elem : attribs) {
+    // attribs_elem
+    Read(&attribs_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::MakeContextCurrentReply> Glx::MakeContextCurrent(
+    const Glx::MakeContextCurrentRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& old_context_tag = request.old_context_tag;
+  auto& drawable = request.drawable;
+  auto& read_drawable = request.read_drawable;
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 26;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // old_context_tag
+  buf.Write(&old_context_tag);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // read_drawable
+  buf.Write(&read_drawable);
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::MakeContextCurrentReply>(
+      &buf, "Glx::MakeContextCurrent", false);
+}
+
+Future<Glx::MakeContextCurrentReply> Glx::MakeContextCurrent(
+    const ContextTag& old_context_tag,
+    const Drawable& drawable,
+    const Drawable& read_drawable,
+    const Context& context) {
+  return Glx::MakeContextCurrent(Glx::MakeContextCurrentRequest{
+      old_context_tag, drawable, read_drawable, context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::MakeContextCurrentReply> detail::ReadReply<
+    Glx::MakeContextCurrentReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::MakeContextCurrentReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& context_tag = (*reply).context_tag;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_tag
+  Read(&context_tag, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::CreatePbuffer(const Glx::CreatePbufferRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& fbconfig = request.fbconfig;
+  auto& pbuffer = request.pbuffer;
+  auto& num_attribs = request.num_attribs;
+  auto& attribs = request.attribs;
+  size_t attribs_len = attribs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 27;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // fbconfig
+  buf.Write(&fbconfig);
+
+  // pbuffer
+  buf.Write(&pbuffer);
+
+  // num_attribs
+  buf.Write(&num_attribs);
+
+  // attribs
+  DCHECK_EQ(static_cast<size_t>((num_attribs) * (2)), attribs.size());
+  for (auto& attribs_elem : attribs) {
+    // attribs_elem
+    buf.Write(&attribs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::CreatePbuffer", false);
+}
+
+Future<void> Glx::CreatePbuffer(const uint32_t& screen,
+                                const FbConfig& fbconfig,
+                                const PBuffer& pbuffer,
+                                const uint32_t& num_attribs,
+                                const std::vector<uint32_t>& attribs) {
+  return Glx::CreatePbuffer(Glx::CreatePbufferRequest{screen, fbconfig, pbuffer,
+                                                      num_attribs, attribs});
+}
+
+Future<void> Glx::DestroyPbuffer(const Glx::DestroyPbufferRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& pbuffer = request.pbuffer;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 28;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pbuffer
+  buf.Write(&pbuffer);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::DestroyPbuffer", false);
+}
+
+Future<void> Glx::DestroyPbuffer(const PBuffer& pbuffer) {
+  return Glx::DestroyPbuffer(Glx::DestroyPbufferRequest{pbuffer});
+}
+
+Future<Glx::GetDrawableAttributesReply> Glx::GetDrawableAttributes(
+    const Glx::GetDrawableAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 29;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetDrawableAttributesReply>(
+      &buf, "Glx::GetDrawableAttributes", false);
+}
+
+Future<Glx::GetDrawableAttributesReply> Glx::GetDrawableAttributes(
+    const Drawable& drawable) {
+  return Glx::GetDrawableAttributes(
+      Glx::GetDrawableAttributesRequest{drawable});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetDrawableAttributesReply> detail::ReadReply<
+    Glx::GetDrawableAttributesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetDrawableAttributesReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& num_attribs = (*reply).num_attribs;
+  auto& attribs = (*reply).attribs;
+  size_t attribs_len = attribs.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_attribs
+  Read(&num_attribs, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // attribs
+  attribs.resize((num_attribs) * (2));
+  for (auto& attribs_elem : attribs) {
+    // attribs_elem
+    Read(&attribs_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::ChangeDrawableAttributes(
+    const Glx::ChangeDrawableAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& num_attribs = request.num_attribs;
+  auto& attribs = request.attribs;
+  size_t attribs_len = attribs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 30;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // num_attribs
+  buf.Write(&num_attribs);
+
+  // attribs
+  DCHECK_EQ(static_cast<size_t>((num_attribs) * (2)), attribs.size());
+  for (auto& attribs_elem : attribs) {
+    // attribs_elem
+    buf.Write(&attribs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::ChangeDrawableAttributes",
+                                        false);
+}
+
+Future<void> Glx::ChangeDrawableAttributes(
+    const Drawable& drawable,
+    const uint32_t& num_attribs,
+    const std::vector<uint32_t>& attribs) {
+  return Glx::ChangeDrawableAttributes(
+      Glx::ChangeDrawableAttributesRequest{drawable, num_attribs, attribs});
+}
+
+Future<void> Glx::CreateWindow(const Glx::CreateWindowRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& fbconfig = request.fbconfig;
+  auto& window = request.window;
+  auto& glx_window = request.glx_window;
+  auto& num_attribs = request.num_attribs;
+  auto& attribs = request.attribs;
+  size_t attribs_len = attribs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 31;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // fbconfig
+  buf.Write(&fbconfig);
+
+  // window
+  buf.Write(&window);
+
+  // glx_window
+  buf.Write(&glx_window);
+
+  // num_attribs
+  buf.Write(&num_attribs);
+
+  // attribs
+  DCHECK_EQ(static_cast<size_t>((num_attribs) * (2)), attribs.size());
+  for (auto& attribs_elem : attribs) {
+    // attribs_elem
+    buf.Write(&attribs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::CreateWindow", false);
+}
+
+Future<void> Glx::CreateWindow(const uint32_t& screen,
+                               const FbConfig& fbconfig,
+                               const x11::Window& window,
+                               const Window& glx_window,
+                               const uint32_t& num_attribs,
+                               const std::vector<uint32_t>& attribs) {
+  return Glx::CreateWindow(Glx::CreateWindowRequest{
+      screen, fbconfig, window, glx_window, num_attribs, attribs});
+}
+
+Future<void> Glx::DeleteWindow(const Glx::DeleteWindowRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& glxwindow = request.glxwindow;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 32;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // glxwindow
+  buf.Write(&glxwindow);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::DeleteWindow", false);
+}
+
+Future<void> Glx::DeleteWindow(const Window& glxwindow) {
+  return Glx::DeleteWindow(Glx::DeleteWindowRequest{glxwindow});
+}
+
+Future<void> Glx::SetClientInfoARB(
+    const Glx::SetClientInfoARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+  auto& num_versions = request.num_versions;
+  uint32_t gl_str_len{};
+  uint32_t glx_str_len{};
+  auto& gl_versions = request.gl_versions;
+  size_t gl_versions_len = gl_versions.size();
+  auto& gl_extension_string = request.gl_extension_string;
+  size_t gl_extension_string_len = gl_extension_string.size();
+  auto& glx_extension_string = request.glx_extension_string;
+  size_t glx_extension_string_len = glx_extension_string.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 33;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  // num_versions
+  buf.Write(&num_versions);
+
+  // gl_str_len
+  gl_str_len = gl_extension_string.size();
+  buf.Write(&gl_str_len);
+
+  // glx_str_len
+  glx_str_len = glx_extension_string.size();
+  buf.Write(&glx_str_len);
+
+  // gl_versions
+  DCHECK_EQ(static_cast<size_t>((num_versions) * (2)), gl_versions.size());
+  for (auto& gl_versions_elem : gl_versions) {
+    // gl_versions_elem
+    buf.Write(&gl_versions_elem);
+  }
+
+  // gl_extension_string
+  DCHECK_EQ(static_cast<size_t>(gl_str_len), gl_extension_string.size());
+  for (auto& gl_extension_string_elem : gl_extension_string) {
+    // gl_extension_string_elem
+    buf.Write(&gl_extension_string_elem);
+  }
+
+  // glx_extension_string
+  DCHECK_EQ(static_cast<size_t>(glx_str_len), glx_extension_string.size());
+  for (auto& glx_extension_string_elem : glx_extension_string) {
+    // glx_extension_string_elem
+    buf.Write(&glx_extension_string_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::SetClientInfoARB", false);
+}
+
+Future<void> Glx::SetClientInfoARB(const uint32_t& major_version,
+                                   const uint32_t& minor_version,
+                                   const uint32_t& num_versions,
+                                   const std::vector<uint32_t>& gl_versions,
+                                   const std::string& gl_extension_string,
+                                   const std::string& glx_extension_string) {
+  return Glx::SetClientInfoARB(Glx::SetClientInfoARBRequest{
+      major_version, minor_version, num_versions, gl_versions,
+      gl_extension_string, glx_extension_string});
+}
+
+Future<void> Glx::CreateContextAttribsARB(
+    const Glx::CreateContextAttribsARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& fbconfig = request.fbconfig;
+  auto& screen = request.screen;
+  auto& share_list = request.share_list;
+  auto& is_direct = request.is_direct;
+  auto& num_attribs = request.num_attribs;
+  auto& attribs = request.attribs;
+  size_t attribs_len = attribs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 34;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // fbconfig
+  buf.Write(&fbconfig);
+
+  // screen
+  buf.Write(&screen);
+
+  // share_list
+  buf.Write(&share_list);
+
+  // is_direct
+  buf.Write(&is_direct);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // num_attribs
+  buf.Write(&num_attribs);
+
+  // attribs
+  DCHECK_EQ(static_cast<size_t>((num_attribs) * (2)), attribs.size());
+  for (auto& attribs_elem : attribs) {
+    // attribs_elem
+    buf.Write(&attribs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::CreateContextAttribsARB",
+                                        false);
+}
+
+Future<void> Glx::CreateContextAttribsARB(
+    const Context& context,
+    const FbConfig& fbconfig,
+    const uint32_t& screen,
+    const Context& share_list,
+    const uint8_t& is_direct,
+    const uint32_t& num_attribs,
+    const std::vector<uint32_t>& attribs) {
+  return Glx::CreateContextAttribsARB(Glx::CreateContextAttribsARBRequest{
+      context, fbconfig, screen, share_list, is_direct, num_attribs, attribs});
+}
+
+Future<void> Glx::SetClientInfo2ARB(
+    const Glx::SetClientInfo2ARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+  auto& num_versions = request.num_versions;
+  uint32_t gl_str_len{};
+  uint32_t glx_str_len{};
+  auto& gl_versions = request.gl_versions;
+  size_t gl_versions_len = gl_versions.size();
+  auto& gl_extension_string = request.gl_extension_string;
+  size_t gl_extension_string_len = gl_extension_string.size();
+  auto& glx_extension_string = request.glx_extension_string;
+  size_t glx_extension_string_len = glx_extension_string.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 35;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  // num_versions
+  buf.Write(&num_versions);
+
+  // gl_str_len
+  gl_str_len = gl_extension_string.size();
+  buf.Write(&gl_str_len);
+
+  // glx_str_len
+  glx_str_len = glx_extension_string.size();
+  buf.Write(&glx_str_len);
+
+  // gl_versions
+  DCHECK_EQ(static_cast<size_t>((num_versions) * (3)), gl_versions.size());
+  for (auto& gl_versions_elem : gl_versions) {
+    // gl_versions_elem
+    buf.Write(&gl_versions_elem);
+  }
+
+  // gl_extension_string
+  DCHECK_EQ(static_cast<size_t>(gl_str_len), gl_extension_string.size());
+  for (auto& gl_extension_string_elem : gl_extension_string) {
+    // gl_extension_string_elem
+    buf.Write(&gl_extension_string_elem);
+  }
+
+  // glx_extension_string
+  DCHECK_EQ(static_cast<size_t>(glx_str_len), glx_extension_string.size());
+  for (auto& glx_extension_string_elem : glx_extension_string) {
+    // glx_extension_string_elem
+    buf.Write(&glx_extension_string_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::SetClientInfo2ARB", false);
+}
+
+Future<void> Glx::SetClientInfo2ARB(const uint32_t& major_version,
+                                    const uint32_t& minor_version,
+                                    const uint32_t& num_versions,
+                                    const std::vector<uint32_t>& gl_versions,
+                                    const std::string& gl_extension_string,
+                                    const std::string& glx_extension_string) {
+  return Glx::SetClientInfo2ARB(Glx::SetClientInfo2ARBRequest{
+      major_version, minor_version, num_versions, gl_versions,
+      gl_extension_string, glx_extension_string});
+}
+
+Future<void> Glx::NewList(const Glx::NewListRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& list = request.list;
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 101;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // list
+  buf.Write(&list);
+
+  // mode
+  buf.Write(&mode);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::NewList", false);
+}
+
+Future<void> Glx::NewList(const ContextTag& context_tag,
+                          const uint32_t& list,
+                          const uint32_t& mode) {
+  return Glx::NewList(Glx::NewListRequest{context_tag, list, mode});
+}
+
+Future<void> Glx::EndList(const Glx::EndListRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 102;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::EndList", false);
+}
+
+Future<void> Glx::EndList(const ContextTag& context_tag) {
+  return Glx::EndList(Glx::EndListRequest{context_tag});
+}
+
+Future<void> Glx::DeleteLists(const Glx::DeleteListsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& list = request.list;
+  auto& range = request.range;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 103;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // list
+  buf.Write(&list);
+
+  // range
+  buf.Write(&range);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::DeleteLists", false);
+}
+
+Future<void> Glx::DeleteLists(const ContextTag& context_tag,
+                              const uint32_t& list,
+                              const int32_t& range) {
+  return Glx::DeleteLists(Glx::DeleteListsRequest{context_tag, list, range});
+}
+
+Future<Glx::GenListsReply> Glx::GenLists(const Glx::GenListsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& range = request.range;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 104;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // range
+  buf.Write(&range);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GenListsReply>(&buf, "Glx::GenLists",
+                                                      false);
+}
+
+Future<Glx::GenListsReply> Glx::GenLists(const ContextTag& context_tag,
+                                         const int32_t& range) {
+  return Glx::GenLists(Glx::GenListsRequest{context_tag, range});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GenListsReply> detail::ReadReply<Glx::GenListsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GenListsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ret_val = (*reply).ret_val;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ret_val
+  Read(&ret_val, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::FeedbackBuffer(const Glx::FeedbackBufferRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& size = request.size;
+  auto& type = request.type;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 105;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // size
+  buf.Write(&size);
+
+  // type
+  buf.Write(&type);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::FeedbackBuffer", false);
+}
+
+Future<void> Glx::FeedbackBuffer(const ContextTag& context_tag,
+                                 const int32_t& size,
+                                 const int32_t& type) {
+  return Glx::FeedbackBuffer(
+      Glx::FeedbackBufferRequest{context_tag, size, type});
+}
+
+Future<void> Glx::SelectBuffer(const Glx::SelectBufferRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& size = request.size;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 106;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // size
+  buf.Write(&size);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::SelectBuffer", false);
+}
+
+Future<void> Glx::SelectBuffer(const ContextTag& context_tag,
+                               const int32_t& size) {
+  return Glx::SelectBuffer(Glx::SelectBufferRequest{context_tag, size});
+}
+
+Future<Glx::RenderModeReply> Glx::RenderMode(
+    const Glx::RenderModeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 107;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // mode
+  buf.Write(&mode);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::RenderModeReply>(&buf, "Glx::RenderMode",
+                                                        false);
+}
+
+Future<Glx::RenderModeReply> Glx::RenderMode(const ContextTag& context_tag,
+                                             const uint32_t& mode) {
+  return Glx::RenderMode(Glx::RenderModeRequest{context_tag, mode});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::RenderModeReply> detail::ReadReply<Glx::RenderModeReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::RenderModeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ret_val = (*reply).ret_val;
+  uint32_t n{};
+  auto& new_mode = (*reply).new_mode;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ret_val
+  Read(&ret_val, &buf);
+
+  // n
+  Read(&n, &buf);
+
+  // new_mode
+  Read(&new_mode, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::FinishReply> Glx::Finish(const Glx::FinishRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 108;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::FinishReply>(&buf, "Glx::Finish", false);
+}
+
+Future<Glx::FinishReply> Glx::Finish(const ContextTag& context_tag) {
+  return Glx::Finish(Glx::FinishRequest{context_tag});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::FinishReply> detail::ReadReply<Glx::FinishReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::FinishReply>();
+
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::PixelStoref(const Glx::PixelStorefRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& pname = request.pname;
+  auto& datum = request.datum;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 109;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // pname
+  buf.Write(&pname);
+
+  // datum
+  buf.Write(&datum);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::PixelStoref", false);
+}
+
+Future<void> Glx::PixelStoref(const ContextTag& context_tag,
+                              const uint32_t& pname,
+                              const float& datum) {
+  return Glx::PixelStoref(Glx::PixelStorefRequest{context_tag, pname, datum});
+}
+
+Future<void> Glx::PixelStorei(const Glx::PixelStoreiRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& pname = request.pname;
+  auto& datum = request.datum;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 110;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // pname
+  buf.Write(&pname);
+
+  // datum
+  buf.Write(&datum);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::PixelStorei", false);
+}
+
+Future<void> Glx::PixelStorei(const ContextTag& context_tag,
+                              const uint32_t& pname,
+                              const int32_t& datum) {
+  return Glx::PixelStorei(Glx::PixelStoreiRequest{context_tag, pname, datum});
+}
+
+Future<Glx::ReadPixelsReply> Glx::ReadPixels(
+    const Glx::ReadPixelsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& format = request.format;
+  auto& type = request.type;
+  auto& swap_bytes = request.swap_bytes;
+  auto& lsb_first = request.lsb_first;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 111;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // format
+  buf.Write(&format);
+
+  // type
+  buf.Write(&type);
+
+  // swap_bytes
+  buf.Write(&swap_bytes);
+
+  // lsb_first
+  buf.Write(&lsb_first);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::ReadPixelsReply>(&buf, "Glx::ReadPixels",
+                                                        false);
+}
+
+Future<Glx::ReadPixelsReply> Glx::ReadPixels(const ContextTag& context_tag,
+                                             const int32_t& x,
+                                             const int32_t& y,
+                                             const int32_t& width,
+                                             const int32_t& height,
+                                             const uint32_t& format,
+                                             const uint32_t& type,
+                                             const uint8_t& swap_bytes,
+                                             const uint8_t& lsb_first) {
+  return Glx::ReadPixels(Glx::ReadPixelsRequest{
+      context_tag, x, y, width, height, format, type, swap_bytes, lsb_first});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::ReadPixelsReply> detail::ReadReply<Glx::ReadPixelsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::ReadPixelsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetBooleanvReply> Glx::GetBooleanv(
+    const Glx::GetBooleanvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 112;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetBooleanvReply>(
+      &buf, "Glx::GetBooleanv", false);
+}
+
+Future<Glx::GetBooleanvReply> Glx::GetBooleanv(const ContextTag& context_tag,
+                                               const int32_t& pname) {
+  return Glx::GetBooleanv(Glx::GetBooleanvRequest{context_tag, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetBooleanvReply> detail::ReadReply<Glx::GetBooleanvReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetBooleanvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 15);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetClipPlaneReply> Glx::GetClipPlane(
+    const Glx::GetClipPlaneRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& plane = request.plane;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 113;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // plane
+  buf.Write(&plane);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetClipPlaneReply>(
+      &buf, "Glx::GetClipPlane", false);
+}
+
+Future<Glx::GetClipPlaneReply> Glx::GetClipPlane(const ContextTag& context_tag,
+                                                 const int32_t& plane) {
+  return Glx::GetClipPlane(Glx::GetClipPlaneRequest{context_tag, plane});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetClipPlaneReply> detail::ReadReply<
+    Glx::GetClipPlaneReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetClipPlaneReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  // data
+  data.resize((length) / (2));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetDoublevReply> Glx::GetDoublev(
+    const Glx::GetDoublevRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 114;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetDoublevReply>(&buf, "Glx::GetDoublev",
+                                                        false);
+}
+
+Future<Glx::GetDoublevReply> Glx::GetDoublev(const ContextTag& context_tag,
+                                             const uint32_t& pname) {
+  return Glx::GetDoublev(Glx::GetDoublevRequest{context_tag, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetDoublevReply> detail::ReadReply<Glx::GetDoublevReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetDoublevReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 8);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetErrorReply> Glx::GetError(const Glx::GetErrorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 115;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetErrorReply>(&buf, "Glx::GetError",
+                                                      false);
+}
+
+Future<Glx::GetErrorReply> Glx::GetError(const ContextTag& context_tag) {
+  return Glx::GetError(Glx::GetErrorRequest{context_tag});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetErrorReply> detail::ReadReply<Glx::GetErrorReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetErrorReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& error = (*reply).error;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // error
+  Read(&error, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetFloatvReply> Glx::GetFloatv(
+    const Glx::GetFloatvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 116;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetFloatvReply>(&buf, "Glx::GetFloatv",
+                                                       false);
+}
+
+Future<Glx::GetFloatvReply> Glx::GetFloatv(const ContextTag& context_tag,
+                                           const uint32_t& pname) {
+  return Glx::GetFloatv(Glx::GetFloatvRequest{context_tag, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetFloatvReply> detail::ReadReply<Glx::GetFloatvReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetFloatvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetIntegervReply> Glx::GetIntegerv(
+    const Glx::GetIntegervRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 117;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetIntegervReply>(
+      &buf, "Glx::GetIntegerv", false);
+}
+
+Future<Glx::GetIntegervReply> Glx::GetIntegerv(const ContextTag& context_tag,
+                                               const uint32_t& pname) {
+  return Glx::GetIntegerv(Glx::GetIntegervRequest{context_tag, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetIntegervReply> detail::ReadReply<Glx::GetIntegervReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetIntegervReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetLightfvReply> Glx::GetLightfv(
+    const Glx::GetLightfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& light = request.light;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 118;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // light
+  buf.Write(&light);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetLightfvReply>(&buf, "Glx::GetLightfv",
+                                                        false);
+}
+
+Future<Glx::GetLightfvReply> Glx::GetLightfv(const ContextTag& context_tag,
+                                             const uint32_t& light,
+                                             const uint32_t& pname) {
+  return Glx::GetLightfv(Glx::GetLightfvRequest{context_tag, light, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetLightfvReply> detail::ReadReply<Glx::GetLightfvReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetLightfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetLightivReply> Glx::GetLightiv(
+    const Glx::GetLightivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& light = request.light;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 119;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // light
+  buf.Write(&light);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetLightivReply>(&buf, "Glx::GetLightiv",
+                                                        false);
+}
+
+Future<Glx::GetLightivReply> Glx::GetLightiv(const ContextTag& context_tag,
+                                             const uint32_t& light,
+                                             const uint32_t& pname) {
+  return Glx::GetLightiv(Glx::GetLightivRequest{context_tag, light, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetLightivReply> detail::ReadReply<Glx::GetLightivReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetLightivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetMapdvReply> Glx::GetMapdv(const Glx::GetMapdvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& query = request.query;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 120;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // query
+  buf.Write(&query);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetMapdvReply>(&buf, "Glx::GetMapdv",
+                                                      false);
+}
+
+Future<Glx::GetMapdvReply> Glx::GetMapdv(const ContextTag& context_tag,
+                                         const uint32_t& target,
+                                         const uint32_t& query) {
+  return Glx::GetMapdv(Glx::GetMapdvRequest{context_tag, target, query});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetMapdvReply> detail::ReadReply<Glx::GetMapdvReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetMapdvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 8);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetMapfvReply> Glx::GetMapfv(const Glx::GetMapfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& query = request.query;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 121;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // query
+  buf.Write(&query);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetMapfvReply>(&buf, "Glx::GetMapfv",
+                                                      false);
+}
+
+Future<Glx::GetMapfvReply> Glx::GetMapfv(const ContextTag& context_tag,
+                                         const uint32_t& target,
+                                         const uint32_t& query) {
+  return Glx::GetMapfv(Glx::GetMapfvRequest{context_tag, target, query});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetMapfvReply> detail::ReadReply<Glx::GetMapfvReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetMapfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetMapivReply> Glx::GetMapiv(const Glx::GetMapivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& query = request.query;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 122;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // query
+  buf.Write(&query);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetMapivReply>(&buf, "Glx::GetMapiv",
+                                                      false);
+}
+
+Future<Glx::GetMapivReply> Glx::GetMapiv(const ContextTag& context_tag,
+                                         const uint32_t& target,
+                                         const uint32_t& query) {
+  return Glx::GetMapiv(Glx::GetMapivRequest{context_tag, target, query});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetMapivReply> detail::ReadReply<Glx::GetMapivReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetMapivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetMaterialfvReply> Glx::GetMaterialfv(
+    const Glx::GetMaterialfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& face = request.face;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 123;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // face
+  buf.Write(&face);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetMaterialfvReply>(
+      &buf, "Glx::GetMaterialfv", false);
+}
+
+Future<Glx::GetMaterialfvReply> Glx::GetMaterialfv(
+    const ContextTag& context_tag,
+    const uint32_t& face,
+    const uint32_t& pname) {
+  return Glx::GetMaterialfv(
+      Glx::GetMaterialfvRequest{context_tag, face, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetMaterialfvReply> detail::ReadReply<
+    Glx::GetMaterialfvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetMaterialfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetMaterialivReply> Glx::GetMaterialiv(
+    const Glx::GetMaterialivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& face = request.face;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 124;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // face
+  buf.Write(&face);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetMaterialivReply>(
+      &buf, "Glx::GetMaterialiv", false);
+}
+
+Future<Glx::GetMaterialivReply> Glx::GetMaterialiv(
+    const ContextTag& context_tag,
+    const uint32_t& face,
+    const uint32_t& pname) {
+  return Glx::GetMaterialiv(
+      Glx::GetMaterialivRequest{context_tag, face, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetMaterialivReply> detail::ReadReply<
+    Glx::GetMaterialivReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetMaterialivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetPixelMapfvReply> Glx::GetPixelMapfv(
+    const Glx::GetPixelMapfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& map = request.map;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 125;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // map
+  buf.Write(&map);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetPixelMapfvReply>(
+      &buf, "Glx::GetPixelMapfv", false);
+}
+
+Future<Glx::GetPixelMapfvReply> Glx::GetPixelMapfv(
+    const ContextTag& context_tag,
+    const uint32_t& map) {
+  return Glx::GetPixelMapfv(Glx::GetPixelMapfvRequest{context_tag, map});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetPixelMapfvReply> detail::ReadReply<
+    Glx::GetPixelMapfvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetPixelMapfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetPixelMapuivReply> Glx::GetPixelMapuiv(
+    const Glx::GetPixelMapuivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& map = request.map;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 126;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // map
+  buf.Write(&map);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetPixelMapuivReply>(
+      &buf, "Glx::GetPixelMapuiv", false);
+}
+
+Future<Glx::GetPixelMapuivReply> Glx::GetPixelMapuiv(
+    const ContextTag& context_tag,
+    const uint32_t& map) {
+  return Glx::GetPixelMapuiv(Glx::GetPixelMapuivRequest{context_tag, map});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetPixelMapuivReply> detail::ReadReply<
+    Glx::GetPixelMapuivReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetPixelMapuivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetPixelMapusvReply> Glx::GetPixelMapusv(
+    const Glx::GetPixelMapusvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& map = request.map;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 127;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // map
+  buf.Write(&map);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetPixelMapusvReply>(
+      &buf, "Glx::GetPixelMapusv", false);
+}
+
+Future<Glx::GetPixelMapusvReply> Glx::GetPixelMapusv(
+    const ContextTag& context_tag,
+    const uint32_t& map) {
+  return Glx::GetPixelMapusv(Glx::GetPixelMapusvRequest{context_tag, map});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetPixelMapusvReply> detail::ReadReply<
+    Glx::GetPixelMapusvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetPixelMapusvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 16);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetPolygonStippleReply> Glx::GetPolygonStipple(
+    const Glx::GetPolygonStippleRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& lsb_first = request.lsb_first;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 128;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // lsb_first
+  buf.Write(&lsb_first);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetPolygonStippleReply>(
+      &buf, "Glx::GetPolygonStipple", false);
+}
+
+Future<Glx::GetPolygonStippleReply> Glx::GetPolygonStipple(
+    const ContextTag& context_tag,
+    const uint8_t& lsb_first) {
+  return Glx::GetPolygonStipple(
+      Glx::GetPolygonStippleRequest{context_tag, lsb_first});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetPolygonStippleReply> detail::ReadReply<
+    Glx::GetPolygonStippleReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetPolygonStippleReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetStringReply> Glx::GetString(
+    const Glx::GetStringRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 129;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // name
+  buf.Write(&name);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetStringReply>(&buf, "Glx::GetString",
+                                                       false);
+}
+
+Future<Glx::GetStringReply> Glx::GetString(const ContextTag& context_tag,
+                                           const uint32_t& name) {
+  return Glx::GetString(Glx::GetStringRequest{context_tag, name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetStringReply> detail::ReadReply<Glx::GetStringReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetStringReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& string = (*reply).string;
+  size_t string_len = string.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // pad2
+  Pad(&buf, 16);
+
+  // string
+  string.resize(n);
+  for (auto& string_elem : string) {
+    // string_elem
+    Read(&string_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexEnvfvReply> Glx::GetTexEnvfv(
+    const Glx::GetTexEnvfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 130;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexEnvfvReply>(
+      &buf, "Glx::GetTexEnvfv", false);
+}
+
+Future<Glx::GetTexEnvfvReply> Glx::GetTexEnvfv(const ContextTag& context_tag,
+                                               const uint32_t& target,
+                                               const uint32_t& pname) {
+  return Glx::GetTexEnvfv(Glx::GetTexEnvfvRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexEnvfvReply> detail::ReadReply<Glx::GetTexEnvfvReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexEnvfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexEnvivReply> Glx::GetTexEnviv(
+    const Glx::GetTexEnvivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 131;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexEnvivReply>(
+      &buf, "Glx::GetTexEnviv", false);
+}
+
+Future<Glx::GetTexEnvivReply> Glx::GetTexEnviv(const ContextTag& context_tag,
+                                               const uint32_t& target,
+                                               const uint32_t& pname) {
+  return Glx::GetTexEnviv(Glx::GetTexEnvivRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexEnvivReply> detail::ReadReply<Glx::GetTexEnvivReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexEnvivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexGendvReply> Glx::GetTexGendv(
+    const Glx::GetTexGendvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& coord = request.coord;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 132;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // coord
+  buf.Write(&coord);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexGendvReply>(
+      &buf, "Glx::GetTexGendv", false);
+}
+
+Future<Glx::GetTexGendvReply> Glx::GetTexGendv(const ContextTag& context_tag,
+                                               const uint32_t& coord,
+                                               const uint32_t& pname) {
+  return Glx::GetTexGendv(Glx::GetTexGendvRequest{context_tag, coord, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexGendvReply> detail::ReadReply<Glx::GetTexGendvReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexGendvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 8);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexGenfvReply> Glx::GetTexGenfv(
+    const Glx::GetTexGenfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& coord = request.coord;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 133;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // coord
+  buf.Write(&coord);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexGenfvReply>(
+      &buf, "Glx::GetTexGenfv", false);
+}
+
+Future<Glx::GetTexGenfvReply> Glx::GetTexGenfv(const ContextTag& context_tag,
+                                               const uint32_t& coord,
+                                               const uint32_t& pname) {
+  return Glx::GetTexGenfv(Glx::GetTexGenfvRequest{context_tag, coord, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexGenfvReply> detail::ReadReply<Glx::GetTexGenfvReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexGenfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexGenivReply> Glx::GetTexGeniv(
+    const Glx::GetTexGenivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& coord = request.coord;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 134;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // coord
+  buf.Write(&coord);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexGenivReply>(
+      &buf, "Glx::GetTexGeniv", false);
+}
+
+Future<Glx::GetTexGenivReply> Glx::GetTexGeniv(const ContextTag& context_tag,
+                                               const uint32_t& coord,
+                                               const uint32_t& pname) {
+  return Glx::GetTexGeniv(Glx::GetTexGenivRequest{context_tag, coord, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexGenivReply> detail::ReadReply<Glx::GetTexGenivReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexGenivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexImageReply> Glx::GetTexImage(
+    const Glx::GetTexImageRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& level = request.level;
+  auto& format = request.format;
+  auto& type = request.type;
+  auto& swap_bytes = request.swap_bytes;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 135;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // level
+  buf.Write(&level);
+
+  // format
+  buf.Write(&format);
+
+  // type
+  buf.Write(&type);
+
+  // swap_bytes
+  buf.Write(&swap_bytes);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexImageReply>(
+      &buf, "Glx::GetTexImage", false);
+}
+
+Future<Glx::GetTexImageReply> Glx::GetTexImage(const ContextTag& context_tag,
+                                               const uint32_t& target,
+                                               const int32_t& level,
+                                               const uint32_t& format,
+                                               const uint32_t& type,
+                                               const uint8_t& swap_bytes) {
+  return Glx::GetTexImage(Glx::GetTexImageRequest{context_tag, target, level,
+                                                  format, type, swap_bytes});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexImageReply> detail::ReadReply<Glx::GetTexImageReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexImageReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& depth = (*reply).depth;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // depth
+  Read(&depth, &buf);
+
+  // pad2
+  Pad(&buf, 4);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexParameterfvReply> Glx::GetTexParameterfv(
+    const Glx::GetTexParameterfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 136;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexParameterfvReply>(
+      &buf, "Glx::GetTexParameterfv", false);
+}
+
+Future<Glx::GetTexParameterfvReply> Glx::GetTexParameterfv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetTexParameterfv(
+      Glx::GetTexParameterfvRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexParameterfvReply> detail::ReadReply<
+    Glx::GetTexParameterfvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexParameterfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexParameterivReply> Glx::GetTexParameteriv(
+    const Glx::GetTexParameterivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 137;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexParameterivReply>(
+      &buf, "Glx::GetTexParameteriv", false);
+}
+
+Future<Glx::GetTexParameterivReply> Glx::GetTexParameteriv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetTexParameteriv(
+      Glx::GetTexParameterivRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexParameterivReply> detail::ReadReply<
+    Glx::GetTexParameterivReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexParameterivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexLevelParameterfvReply> Glx::GetTexLevelParameterfv(
+    const Glx::GetTexLevelParameterfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& level = request.level;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 138;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // level
+  buf.Write(&level);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexLevelParameterfvReply>(
+      &buf, "Glx::GetTexLevelParameterfv", false);
+}
+
+Future<Glx::GetTexLevelParameterfvReply> Glx::GetTexLevelParameterfv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const int32_t& level,
+    const uint32_t& pname) {
+  return Glx::GetTexLevelParameterfv(
+      Glx::GetTexLevelParameterfvRequest{context_tag, target, level, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexLevelParameterfvReply> detail::ReadReply<
+    Glx::GetTexLevelParameterfvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexLevelParameterfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetTexLevelParameterivReply> Glx::GetTexLevelParameteriv(
+    const Glx::GetTexLevelParameterivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& level = request.level;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 139;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // level
+  buf.Write(&level);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetTexLevelParameterivReply>(
+      &buf, "Glx::GetTexLevelParameteriv", false);
+}
+
+Future<Glx::GetTexLevelParameterivReply> Glx::GetTexLevelParameteriv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const int32_t& level,
+    const uint32_t& pname) {
+  return Glx::GetTexLevelParameteriv(
+      Glx::GetTexLevelParameterivRequest{context_tag, target, level, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetTexLevelParameterivReply> detail::ReadReply<
+    Glx::GetTexLevelParameterivReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetTexLevelParameterivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::IsEnabledReply> Glx::IsEnabled(
+    const Glx::IsEnabledRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& capability = request.capability;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 140;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // capability
+  buf.Write(&capability);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::IsEnabledReply>(&buf, "Glx::IsEnabled",
+                                                       false);
+}
+
+Future<Glx::IsEnabledReply> Glx::IsEnabled(const ContextTag& context_tag,
+                                           const uint32_t& capability) {
+  return Glx::IsEnabled(Glx::IsEnabledRequest{context_tag, capability});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::IsEnabledReply> detail::ReadReply<Glx::IsEnabledReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::IsEnabledReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ret_val = (*reply).ret_val;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ret_val
+  Read(&ret_val, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::IsListReply> Glx::IsList(const Glx::IsListRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& list = request.list;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 141;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // list
+  buf.Write(&list);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::IsListReply>(&buf, "Glx::IsList", false);
+}
+
+Future<Glx::IsListReply> Glx::IsList(const ContextTag& context_tag,
+                                     const uint32_t& list) {
+  return Glx::IsList(Glx::IsListRequest{context_tag, list});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::IsListReply> detail::ReadReply<Glx::IsListReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::IsListReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ret_val = (*reply).ret_val;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ret_val
+  Read(&ret_val, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::Flush(const Glx::FlushRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 142;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::Flush", false);
+}
+
+Future<void> Glx::Flush(const ContextTag& context_tag) {
+  return Glx::Flush(Glx::FlushRequest{context_tag});
+}
+
+Future<Glx::AreTexturesResidentReply> Glx::AreTexturesResident(
+    const Glx::AreTexturesResidentRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  int32_t n{};
+  auto& textures = request.textures;
+  size_t textures_len = textures.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 143;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // n
+  n = textures.size();
+  buf.Write(&n);
+
+  // textures
+  DCHECK_EQ(static_cast<size_t>(n), textures.size());
+  for (auto& textures_elem : textures) {
+    // textures_elem
+    buf.Write(&textures_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::AreTexturesResidentReply>(
+      &buf, "Glx::AreTexturesResident", false);
+}
+
+Future<Glx::AreTexturesResidentReply> Glx::AreTexturesResident(
+    const ContextTag& context_tag,
+    const std::vector<uint32_t>& textures) {
+  return Glx::AreTexturesResident(
+      Glx::AreTexturesResidentRequest{context_tag, textures});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::AreTexturesResidentReply> detail::ReadReply<
+    Glx::AreTexturesResidentReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::AreTexturesResidentReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ret_val = (*reply).ret_val;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ret_val
+  Read(&ret_val, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::DeleteTextures(const Glx::DeleteTexturesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  int32_t n{};
+  auto& textures = request.textures;
+  size_t textures_len = textures.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 144;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // n
+  n = textures.size();
+  buf.Write(&n);
+
+  // textures
+  DCHECK_EQ(static_cast<size_t>(n), textures.size());
+  for (auto& textures_elem : textures) {
+    // textures_elem
+    buf.Write(&textures_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::DeleteTextures", false);
+}
+
+Future<void> Glx::DeleteTextures(const ContextTag& context_tag,
+                                 const std::vector<uint32_t>& textures) {
+  return Glx::DeleteTextures(Glx::DeleteTexturesRequest{context_tag, textures});
+}
+
+Future<Glx::GenTexturesReply> Glx::GenTextures(
+    const Glx::GenTexturesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& n = request.n;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 145;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // n
+  buf.Write(&n);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GenTexturesReply>(
+      &buf, "Glx::GenTextures", false);
+}
+
+Future<Glx::GenTexturesReply> Glx::GenTextures(const ContextTag& context_tag,
+                                               const int32_t& n) {
+  return Glx::GenTextures(Glx::GenTexturesRequest{context_tag, n});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GenTexturesReply> detail::ReadReply<Glx::GenTexturesReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GenTexturesReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  // data
+  data.resize(length);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::IsTextureReply> Glx::IsTexture(
+    const Glx::IsTextureRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& texture = request.texture;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 146;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // texture
+  buf.Write(&texture);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::IsTextureReply>(&buf, "Glx::IsTexture",
+                                                       false);
+}
+
+Future<Glx::IsTextureReply> Glx::IsTexture(const ContextTag& context_tag,
+                                           const uint32_t& texture) {
+  return Glx::IsTexture(Glx::IsTextureRequest{context_tag, texture});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::IsTextureReply> detail::ReadReply<Glx::IsTextureReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::IsTextureReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ret_val = (*reply).ret_val;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ret_val
+  Read(&ret_val, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetColorTableReply> Glx::GetColorTable(
+    const Glx::GetColorTableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& format = request.format;
+  auto& type = request.type;
+  auto& swap_bytes = request.swap_bytes;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 147;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // format
+  buf.Write(&format);
+
+  // type
+  buf.Write(&type);
+
+  // swap_bytes
+  buf.Write(&swap_bytes);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetColorTableReply>(
+      &buf, "Glx::GetColorTable", false);
+}
+
+Future<Glx::GetColorTableReply> Glx::GetColorTable(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& format,
+    const uint32_t& type,
+    const uint8_t& swap_bytes) {
+  return Glx::GetColorTable(
+      Glx::GetColorTableRequest{context_tag, target, format, type, swap_bytes});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetColorTableReply> detail::ReadReply<
+    Glx::GetColorTableReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetColorTableReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // width
+  Read(&width, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetColorTableParameterfvReply> Glx::GetColorTableParameterfv(
+    const Glx::GetColorTableParameterfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 148;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetColorTableParameterfvReply>(
+      &buf, "Glx::GetColorTableParameterfv", false);
+}
+
+Future<Glx::GetColorTableParameterfvReply> Glx::GetColorTableParameterfv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetColorTableParameterfv(
+      Glx::GetColorTableParameterfvRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetColorTableParameterfvReply> detail::ReadReply<
+    Glx::GetColorTableParameterfvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetColorTableParameterfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetColorTableParameterivReply> Glx::GetColorTableParameteriv(
+    const Glx::GetColorTableParameterivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 149;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetColorTableParameterivReply>(
+      &buf, "Glx::GetColorTableParameteriv", false);
+}
+
+Future<Glx::GetColorTableParameterivReply> Glx::GetColorTableParameteriv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetColorTableParameteriv(
+      Glx::GetColorTableParameterivRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetColorTableParameterivReply> detail::ReadReply<
+    Glx::GetColorTableParameterivReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetColorTableParameterivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetConvolutionFilterReply> Glx::GetConvolutionFilter(
+    const Glx::GetConvolutionFilterRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& format = request.format;
+  auto& type = request.type;
+  auto& swap_bytes = request.swap_bytes;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 150;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // format
+  buf.Write(&format);
+
+  // type
+  buf.Write(&type);
+
+  // swap_bytes
+  buf.Write(&swap_bytes);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetConvolutionFilterReply>(
+      &buf, "Glx::GetConvolutionFilter", false);
+}
+
+Future<Glx::GetConvolutionFilterReply> Glx::GetConvolutionFilter(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& format,
+    const uint32_t& type,
+    const uint8_t& swap_bytes) {
+  return Glx::GetConvolutionFilter(Glx::GetConvolutionFilterRequest{
+      context_tag, target, format, type, swap_bytes});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetConvolutionFilterReply> detail::ReadReply<
+    Glx::GetConvolutionFilterReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetConvolutionFilterReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // pad2
+  Pad(&buf, 8);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetConvolutionParameterfvReply> Glx::GetConvolutionParameterfv(
+    const Glx::GetConvolutionParameterfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 151;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetConvolutionParameterfvReply>(
+      &buf, "Glx::GetConvolutionParameterfv", false);
+}
+
+Future<Glx::GetConvolutionParameterfvReply> Glx::GetConvolutionParameterfv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetConvolutionParameterfv(
+      Glx::GetConvolutionParameterfvRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetConvolutionParameterfvReply> detail::ReadReply<
+    Glx::GetConvolutionParameterfvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetConvolutionParameterfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetConvolutionParameterivReply> Glx::GetConvolutionParameteriv(
+    const Glx::GetConvolutionParameterivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 152;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetConvolutionParameterivReply>(
+      &buf, "Glx::GetConvolutionParameteriv", false);
+}
+
+Future<Glx::GetConvolutionParameterivReply> Glx::GetConvolutionParameteriv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetConvolutionParameteriv(
+      Glx::GetConvolutionParameterivRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetConvolutionParameterivReply> detail::ReadReply<
+    Glx::GetConvolutionParameterivReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetConvolutionParameterivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetSeparableFilterReply> Glx::GetSeparableFilter(
+    const Glx::GetSeparableFilterRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& format = request.format;
+  auto& type = request.type;
+  auto& swap_bytes = request.swap_bytes;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 153;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // format
+  buf.Write(&format);
+
+  // type
+  buf.Write(&type);
+
+  // swap_bytes
+  buf.Write(&swap_bytes);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetSeparableFilterReply>(
+      &buf, "Glx::GetSeparableFilter", false);
+}
+
+Future<Glx::GetSeparableFilterReply> Glx::GetSeparableFilter(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& format,
+    const uint32_t& type,
+    const uint8_t& swap_bytes) {
+  return Glx::GetSeparableFilter(Glx::GetSeparableFilterRequest{
+      context_tag, target, format, type, swap_bytes});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetSeparableFilterReply> detail::ReadReply<
+    Glx::GetSeparableFilterReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetSeparableFilterReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& row_w = (*reply).row_w;
+  auto& col_h = (*reply).col_h;
+  auto& rows_and_cols = (*reply).rows_and_cols;
+  size_t rows_and_cols_len = rows_and_cols.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // row_w
+  Read(&row_w, &buf);
+
+  // col_h
+  Read(&col_h, &buf);
+
+  // pad2
+  Pad(&buf, 8);
+
+  // rows_and_cols
+  rows_and_cols.resize((length) * (4));
+  for (auto& rows_and_cols_elem : rows_and_cols) {
+    // rows_and_cols_elem
+    Read(&rows_and_cols_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetHistogramReply> Glx::GetHistogram(
+    const Glx::GetHistogramRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& format = request.format;
+  auto& type = request.type;
+  auto& swap_bytes = request.swap_bytes;
+  auto& reset = request.reset;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 154;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // format
+  buf.Write(&format);
+
+  // type
+  buf.Write(&type);
+
+  // swap_bytes
+  buf.Write(&swap_bytes);
+
+  // reset
+  buf.Write(&reset);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetHistogramReply>(
+      &buf, "Glx::GetHistogram", false);
+}
+
+Future<Glx::GetHistogramReply> Glx::GetHistogram(const ContextTag& context_tag,
+                                                 const uint32_t& target,
+                                                 const uint32_t& format,
+                                                 const uint32_t& type,
+                                                 const uint8_t& swap_bytes,
+                                                 const uint8_t& reset) {
+  return Glx::GetHistogram(Glx::GetHistogramRequest{context_tag, target, format,
+                                                    type, swap_bytes, reset});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetHistogramReply> detail::ReadReply<
+    Glx::GetHistogramReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetHistogramReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // width
+  Read(&width, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetHistogramParameterfvReply> Glx::GetHistogramParameterfv(
+    const Glx::GetHistogramParameterfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 155;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetHistogramParameterfvReply>(
+      &buf, "Glx::GetHistogramParameterfv", false);
+}
+
+Future<Glx::GetHistogramParameterfvReply> Glx::GetHistogramParameterfv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetHistogramParameterfv(
+      Glx::GetHistogramParameterfvRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetHistogramParameterfvReply> detail::ReadReply<
+    Glx::GetHistogramParameterfvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetHistogramParameterfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetHistogramParameterivReply> Glx::GetHistogramParameteriv(
+    const Glx::GetHistogramParameterivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 156;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetHistogramParameterivReply>(
+      &buf, "Glx::GetHistogramParameteriv", false);
+}
+
+Future<Glx::GetHistogramParameterivReply> Glx::GetHistogramParameteriv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetHistogramParameteriv(
+      Glx::GetHistogramParameterivRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetHistogramParameterivReply> detail::ReadReply<
+    Glx::GetHistogramParameterivReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetHistogramParameterivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetMinmaxReply> Glx::GetMinmax(
+    const Glx::GetMinmaxRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& format = request.format;
+  auto& type = request.type;
+  auto& swap_bytes = request.swap_bytes;
+  auto& reset = request.reset;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 157;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // format
+  buf.Write(&format);
+
+  // type
+  buf.Write(&type);
+
+  // swap_bytes
+  buf.Write(&swap_bytes);
+
+  // reset
+  buf.Write(&reset);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetMinmaxReply>(&buf, "Glx::GetMinmax",
+                                                       false);
+}
+
+Future<Glx::GetMinmaxReply> Glx::GetMinmax(const ContextTag& context_tag,
+                                           const uint32_t& target,
+                                           const uint32_t& format,
+                                           const uint32_t& type,
+                                           const uint8_t& swap_bytes,
+                                           const uint8_t& reset) {
+  return Glx::GetMinmax(Glx::GetMinmaxRequest{context_tag, target, format, type,
+                                              swap_bytes, reset});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetMinmaxReply> detail::ReadReply<Glx::GetMinmaxReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetMinmaxReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetMinmaxParameterfvReply> Glx::GetMinmaxParameterfv(
+    const Glx::GetMinmaxParameterfvRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 158;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetMinmaxParameterfvReply>(
+      &buf, "Glx::GetMinmaxParameterfv", false);
+}
+
+Future<Glx::GetMinmaxParameterfvReply> Glx::GetMinmaxParameterfv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetMinmaxParameterfv(
+      Glx::GetMinmaxParameterfvRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetMinmaxParameterfvReply> detail::ReadReply<
+    Glx::GetMinmaxParameterfvReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetMinmaxParameterfvReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetMinmaxParameterivReply> Glx::GetMinmaxParameteriv(
+    const Glx::GetMinmaxParameterivRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 159;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetMinmaxParameterivReply>(
+      &buf, "Glx::GetMinmaxParameteriv", false);
+}
+
+Future<Glx::GetMinmaxParameterivReply> Glx::GetMinmaxParameteriv(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetMinmaxParameteriv(
+      Glx::GetMinmaxParameterivRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetMinmaxParameterivReply> detail::ReadReply<
+    Glx::GetMinmaxParameterivReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetMinmaxParameterivReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetCompressedTexImageARBReply> Glx::GetCompressedTexImageARB(
+    const Glx::GetCompressedTexImageARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& level = request.level;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 160;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // level
+  buf.Write(&level);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetCompressedTexImageARBReply>(
+      &buf, "Glx::GetCompressedTexImageARB", false);
+}
+
+Future<Glx::GetCompressedTexImageARBReply> Glx::GetCompressedTexImageARB(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const int32_t& level) {
+  return Glx::GetCompressedTexImageARB(
+      Glx::GetCompressedTexImageARBRequest{context_tag, target, level});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetCompressedTexImageARBReply> detail::ReadReply<
+    Glx::GetCompressedTexImageARBReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetCompressedTexImageARBReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& size = (*reply).size;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // size
+  Read(&size, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Glx::DeleteQueriesARB(
+    const Glx::DeleteQueriesARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  int32_t n{};
+  auto& ids = request.ids;
+  size_t ids_len = ids.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 161;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // n
+  n = ids.size();
+  buf.Write(&n);
+
+  // ids
+  DCHECK_EQ(static_cast<size_t>(n), ids.size());
+  for (auto& ids_elem : ids) {
+    // ids_elem
+    buf.Write(&ids_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Glx::DeleteQueriesARB", false);
+}
+
+Future<void> Glx::DeleteQueriesARB(const ContextTag& context_tag,
+                                   const std::vector<uint32_t>& ids) {
+  return Glx::DeleteQueriesARB(Glx::DeleteQueriesARBRequest{context_tag, ids});
+}
+
+Future<Glx::GenQueriesARBReply> Glx::GenQueriesARB(
+    const Glx::GenQueriesARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& n = request.n;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 162;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // n
+  buf.Write(&n);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GenQueriesARBReply>(
+      &buf, "Glx::GenQueriesARB", false);
+}
+
+Future<Glx::GenQueriesARBReply> Glx::GenQueriesARB(
+    const ContextTag& context_tag,
+    const int32_t& n) {
+  return Glx::GenQueriesARB(Glx::GenQueriesARBRequest{context_tag, n});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GenQueriesARBReply> detail::ReadReply<
+    Glx::GenQueriesARBReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GenQueriesARBReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  // data
+  data.resize(length);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::IsQueryARBReply> Glx::IsQueryARB(
+    const Glx::IsQueryARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& id = request.id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 163;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // id
+  buf.Write(&id);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::IsQueryARBReply>(&buf, "Glx::IsQueryARB",
+                                                        false);
+}
+
+Future<Glx::IsQueryARBReply> Glx::IsQueryARB(const ContextTag& context_tag,
+                                             const uint32_t& id) {
+  return Glx::IsQueryARB(Glx::IsQueryARBRequest{context_tag, id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::IsQueryARBReply> detail::ReadReply<Glx::IsQueryARBReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::IsQueryARBReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& ret_val = (*reply).ret_val;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ret_val
+  Read(&ret_val, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetQueryivARBReply> Glx::GetQueryivARB(
+    const Glx::GetQueryivARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& target = request.target;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 164;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // target
+  buf.Write(&target);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetQueryivARBReply>(
+      &buf, "Glx::GetQueryivARB", false);
+}
+
+Future<Glx::GetQueryivARBReply> Glx::GetQueryivARB(
+    const ContextTag& context_tag,
+    const uint32_t& target,
+    const uint32_t& pname) {
+  return Glx::GetQueryivARB(
+      Glx::GetQueryivARBRequest{context_tag, target, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetQueryivARBReply> detail::ReadReply<
+    Glx::GetQueryivARBReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetQueryivARBReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetQueryObjectivARBReply> Glx::GetQueryObjectivARB(
+    const Glx::GetQueryObjectivARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& id = request.id;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 165;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // id
+  buf.Write(&id);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetQueryObjectivARBReply>(
+      &buf, "Glx::GetQueryObjectivARB", false);
+}
+
+Future<Glx::GetQueryObjectivARBReply> Glx::GetQueryObjectivARB(
+    const ContextTag& context_tag,
+    const uint32_t& id,
+    const uint32_t& pname) {
+  return Glx::GetQueryObjectivARB(
+      Glx::GetQueryObjectivARBRequest{context_tag, id, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetQueryObjectivARBReply> detail::ReadReply<
+    Glx::GetQueryObjectivARBReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetQueryObjectivARBReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Glx::GetQueryObjectuivARBReply> Glx::GetQueryObjectuivARB(
+    const Glx::GetQueryObjectuivARBRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_tag = request.context_tag;
+  auto& id = request.id;
+  auto& pname = request.pname;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 166;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_tag
+  buf.Write(&context_tag);
+
+  // id
+  buf.Write(&id);
+
+  // pname
+  buf.Write(&pname);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Glx::GetQueryObjectuivARBReply>(
+      &buf, "Glx::GetQueryObjectuivARB", false);
+}
+
+Future<Glx::GetQueryObjectuivARBReply> Glx::GetQueryObjectuivARB(
+    const ContextTag& context_tag,
+    const uint32_t& id,
+    const uint32_t& pname) {
+  return Glx::GetQueryObjectuivARB(
+      Glx::GetQueryObjectuivARBRequest{context_tag, id, pname});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Glx::GetQueryObjectuivARBReply> detail::ReadReply<
+    Glx::GetQueryObjectuivARBReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Glx::GetQueryObjectuivARBReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t n{};
+  auto& datum = (*reply).datum;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // n
+  Read(&n, &buf);
+
+  // datum
+  Read(&datum, &buf);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // data
+  data.resize(n);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/glx.h b/ui/gfx/x/generated_protos/glx.h
new file mode 100644
index 0000000..cc805bb
--- /dev/null
+++ b/ui/gfx/x/generated_protos/glx.h
@@ -0,0 +1,2235 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_GLX_H_
+#define UI_GFX_X_GENERATED_PROTOS_GLX_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Glx {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 4;
+
+  Glx(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Pixmap : uint32_t {};
+
+  enum class Context : uint32_t {};
+
+  enum class PBuffer : uint32_t {};
+
+  enum class Window : uint32_t {};
+
+  enum class FbConfig : uint32_t {};
+
+  enum class Bool32 : uint32_t {};
+
+  enum class ContextTag : uint32_t {};
+
+  enum class Pbcet : int {
+    Damaged = 32791,
+    Saved = 32792,
+  };
+
+  enum class Pbcdt : int {
+    Window = 32793,
+    Pbuffer = 32794,
+  };
+
+  enum class GraphicsContextAttribute : int {
+    XPROTO_GL_ALL_ATTRIB_BITS = 16777215,
+    XPROTO_GL_CURRENT_BIT = 1 << 0,
+    XPROTO_GL_POINT_BIT = 1 << 1,
+    XPROTO_GL_LINE_BIT = 1 << 2,
+    XPROTO_GL_POLYGON_BIT = 1 << 3,
+    XPROTO_GL_POLYGON_STIPPLE_BIT = 1 << 4,
+    XPROTO_GL_PIXEL_MODE_BIT = 1 << 5,
+    XPROTO_GL_LIGHTING_BIT = 1 << 6,
+    XPROTO_GL_FOG_BIT = 1 << 7,
+    XPROTO_GL_DEPTH_BUFFER_BIT = 1 << 8,
+    XPROTO_GL_ACCUM_BUFFER_BIT = 1 << 9,
+    XPROTO_GL_STENCIL_BUFFER_BIT = 1 << 10,
+    XPROTO_GL_VIEWPORT_BIT = 1 << 11,
+    XPROTO_GL_TRANSFORM_BIT = 1 << 12,
+    XPROTO_GL_ENABLE_BIT = 1 << 13,
+    XPROTO_GL_COLOR_BUFFER_BIT = 1 << 14,
+    XPROTO_GL_HINT_BIT = 1 << 15,
+    XPROTO_GL_EVAL_BIT = 1 << 16,
+    XPROTO_GL_LIST_BIT = 1 << 17,
+    XPROTO_GL_TEXTURE_BIT = 1 << 18,
+    XPROTO_GL_SCISSOR_BIT = 1 << 19,
+  };
+
+  enum class Rm : int {
+    XPROTO_GL_RENDER = 7168,
+    XPROTO_GL_FEEDBACK = 7169,
+    XPROTO_GL_SELECT = 7170,
+  };
+
+  struct Drawable {
+    Drawable() : value{} {}
+
+    Drawable(x11::Window value) : value{static_cast<uint32_t>(value)} {}
+    operator x11::Window() const { return static_cast<x11::Window>(value); }
+
+    Drawable(PBuffer value) : value{static_cast<uint32_t>(value)} {}
+    operator PBuffer() const { return static_cast<PBuffer>(value); }
+
+    Drawable(Pixmap value) : value{static_cast<uint32_t>(value)} {}
+    operator Pixmap() const { return static_cast<Pixmap>(value); }
+
+    Drawable(Window value) : value{static_cast<uint32_t>(value)} {}
+    operator Window() const { return static_cast<Window>(value); }
+
+    uint32_t value{};
+  };
+
+  struct GenericError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadContextError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadContextStateError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadDrawableError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadPixmapError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadContextTagError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadCurrentWindowError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadRenderRequestError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadLargeRequestError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct UnsupportedPrivateRequestError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadFBConfigError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadPbufferError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadCurrentDrawableError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadWindowError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct GLXBadProfileARBError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct PbufferClobberEvent {
+    static constexpr int type_id = 4;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint16_t sequence{};
+    uint16_t event_type{};
+    uint16_t draw_type{};
+    Drawable drawable{};
+    uint32_t b_mask{};
+    uint16_t aux_buffer{};
+    uint16_t x{};
+    uint16_t y{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t count{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&drawable);
+    }
+  };
+
+  struct BufferSwapCompleteEvent {
+    static constexpr int type_id = 5;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint16_t sequence{};
+    uint16_t event_type{};
+    Drawable drawable{};
+    uint32_t ust_hi{};
+    uint32_t ust_lo{};
+    uint32_t msc_hi{};
+    uint32_t msc_lo{};
+    uint32_t sbc{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&drawable);
+    }
+  };
+
+  struct RenderRequest {
+    ContextTag context_tag{};
+    std::vector<uint8_t> data{};
+  };
+
+  using RenderResponse = Response<void>;
+
+  Future<void> Render(const RenderRequest& request);
+
+  Future<void> Render(const ContextTag& context_tag = {},
+                      const std::vector<uint8_t>& data = {});
+
+  struct RenderLargeRequest {
+    ContextTag context_tag{};
+    uint16_t request_num{};
+    uint16_t request_total{};
+    std::vector<uint8_t> data{};
+  };
+
+  using RenderLargeResponse = Response<void>;
+
+  Future<void> RenderLarge(const RenderLargeRequest& request);
+
+  Future<void> RenderLarge(const ContextTag& context_tag = {},
+                           const uint16_t& request_num = {},
+                           const uint16_t& request_total = {},
+                           const std::vector<uint8_t>& data = {});
+
+  struct CreateContextRequest {
+    Context context{};
+    VisualId visual{};
+    uint32_t screen{};
+    Context share_list{};
+    uint8_t is_direct{};
+  };
+
+  using CreateContextResponse = Response<void>;
+
+  Future<void> CreateContext(const CreateContextRequest& request);
+
+  Future<void> CreateContext(const Context& context = {},
+                             const VisualId& visual = {},
+                             const uint32_t& screen = {},
+                             const Context& share_list = {},
+                             const uint8_t& is_direct = {});
+
+  struct DestroyContextRequest {
+    Context context{};
+  };
+
+  using DestroyContextResponse = Response<void>;
+
+  Future<void> DestroyContext(const DestroyContextRequest& request);
+
+  Future<void> DestroyContext(const Context& context = {});
+
+  struct MakeCurrentRequest {
+    Drawable drawable{};
+    Context context{};
+    ContextTag old_context_tag{};
+  };
+
+  struct MakeCurrentReply {
+    uint16_t sequence{};
+    ContextTag context_tag{};
+  };
+
+  using MakeCurrentResponse = Response<MakeCurrentReply>;
+
+  Future<MakeCurrentReply> MakeCurrent(const MakeCurrentRequest& request);
+
+  Future<MakeCurrentReply> MakeCurrent(const Drawable& drawable = {},
+                                       const Context& context = {},
+                                       const ContextTag& old_context_tag = {});
+
+  struct IsDirectRequest {
+    Context context{};
+  };
+
+  struct IsDirectReply {
+    uint16_t sequence{};
+    uint8_t is_direct{};
+  };
+
+  using IsDirectResponse = Response<IsDirectReply>;
+
+  Future<IsDirectReply> IsDirect(const IsDirectRequest& request);
+
+  Future<IsDirectReply> IsDirect(const Context& context = {});
+
+  struct QueryVersionRequest {
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint32_t& major_version = {},
+                                         const uint32_t& minor_version = {});
+
+  struct WaitGLRequest {
+    ContextTag context_tag{};
+  };
+
+  using WaitGLResponse = Response<void>;
+
+  Future<void> WaitGL(const WaitGLRequest& request);
+
+  Future<void> WaitGL(const ContextTag& context_tag = {});
+
+  struct WaitXRequest {
+    ContextTag context_tag{};
+  };
+
+  using WaitXResponse = Response<void>;
+
+  Future<void> WaitX(const WaitXRequest& request);
+
+  Future<void> WaitX(const ContextTag& context_tag = {});
+
+  struct CopyContextRequest {
+    Context src{};
+    Context dest{};
+    uint32_t mask{};
+    ContextTag src_context_tag{};
+  };
+
+  using CopyContextResponse = Response<void>;
+
+  Future<void> CopyContext(const CopyContextRequest& request);
+
+  Future<void> CopyContext(const Context& src = {},
+                           const Context& dest = {},
+                           const uint32_t& mask = {},
+                           const ContextTag& src_context_tag = {});
+
+  struct SwapBuffersRequest {
+    ContextTag context_tag{};
+    Drawable drawable{};
+  };
+
+  using SwapBuffersResponse = Response<void>;
+
+  Future<void> SwapBuffers(const SwapBuffersRequest& request);
+
+  Future<void> SwapBuffers(const ContextTag& context_tag = {},
+                           const Drawable& drawable = {});
+
+  struct UseXFontRequest {
+    ContextTag context_tag{};
+    Font font{};
+    uint32_t first{};
+    uint32_t count{};
+    uint32_t list_base{};
+  };
+
+  using UseXFontResponse = Response<void>;
+
+  Future<void> UseXFont(const UseXFontRequest& request);
+
+  Future<void> UseXFont(const ContextTag& context_tag = {},
+                        const Font& font = {},
+                        const uint32_t& first = {},
+                        const uint32_t& count = {},
+                        const uint32_t& list_base = {});
+
+  struct CreateGLXPixmapRequest {
+    uint32_t screen{};
+    VisualId visual{};
+    x11::Pixmap pixmap{};
+    Pixmap glx_pixmap{};
+  };
+
+  using CreateGLXPixmapResponse = Response<void>;
+
+  Future<void> CreateGLXPixmap(const CreateGLXPixmapRequest& request);
+
+  Future<void> CreateGLXPixmap(const uint32_t& screen = {},
+                               const VisualId& visual = {},
+                               const x11::Pixmap& pixmap = {},
+                               const Pixmap& glx_pixmap = {});
+
+  struct GetVisualConfigsRequest {
+    uint32_t screen{};
+  };
+
+  struct GetVisualConfigsReply {
+    uint16_t sequence{};
+    uint32_t num_visuals{};
+    uint32_t num_properties{};
+    std::vector<uint32_t> property_list{};
+  };
+
+  using GetVisualConfigsResponse = Response<GetVisualConfigsReply>;
+
+  Future<GetVisualConfigsReply> GetVisualConfigs(
+      const GetVisualConfigsRequest& request);
+
+  Future<GetVisualConfigsReply> GetVisualConfigs(const uint32_t& screen = {});
+
+  struct DestroyGLXPixmapRequest {
+    Pixmap glx_pixmap{};
+  };
+
+  using DestroyGLXPixmapResponse = Response<void>;
+
+  Future<void> DestroyGLXPixmap(const DestroyGLXPixmapRequest& request);
+
+  Future<void> DestroyGLXPixmap(const Pixmap& glx_pixmap = {});
+
+  struct VendorPrivateRequest {
+    uint32_t vendor_code{};
+    ContextTag context_tag{};
+    std::vector<uint8_t> data{};
+  };
+
+  using VendorPrivateResponse = Response<void>;
+
+  Future<void> VendorPrivate(const VendorPrivateRequest& request);
+
+  Future<void> VendorPrivate(const uint32_t& vendor_code = {},
+                             const ContextTag& context_tag = {},
+                             const std::vector<uint8_t>& data = {});
+
+  struct VendorPrivateWithReplyRequest {
+    uint32_t vendor_code{};
+    ContextTag context_tag{};
+    std::vector<uint8_t> data{};
+  };
+
+  struct VendorPrivateWithReplyReply {
+    uint16_t sequence{};
+    uint32_t retval{};
+    std::array<uint8_t, 24> data1{};
+    std::vector<uint8_t> data2{};
+  };
+
+  using VendorPrivateWithReplyResponse = Response<VendorPrivateWithReplyReply>;
+
+  Future<VendorPrivateWithReplyReply> VendorPrivateWithReply(
+      const VendorPrivateWithReplyRequest& request);
+
+  Future<VendorPrivateWithReplyReply> VendorPrivateWithReply(
+      const uint32_t& vendor_code = {},
+      const ContextTag& context_tag = {},
+      const std::vector<uint8_t>& data = {});
+
+  struct QueryExtensionsStringRequest {
+    uint32_t screen{};
+  };
+
+  struct QueryExtensionsStringReply {
+    uint16_t sequence{};
+    uint32_t n{};
+  };
+
+  using QueryExtensionsStringResponse = Response<QueryExtensionsStringReply>;
+
+  Future<QueryExtensionsStringReply> QueryExtensionsString(
+      const QueryExtensionsStringRequest& request);
+
+  Future<QueryExtensionsStringReply> QueryExtensionsString(
+      const uint32_t& screen = {});
+
+  struct QueryServerStringRequest {
+    uint32_t screen{};
+    uint32_t name{};
+  };
+
+  struct QueryServerStringReply {
+    uint16_t sequence{};
+    std::string string{};
+  };
+
+  using QueryServerStringResponse = Response<QueryServerStringReply>;
+
+  Future<QueryServerStringReply> QueryServerString(
+      const QueryServerStringRequest& request);
+
+  Future<QueryServerStringReply> QueryServerString(const uint32_t& screen = {},
+                                                   const uint32_t& name = {});
+
+  struct ClientInfoRequest {
+    uint32_t major_version{};
+    uint32_t minor_version{};
+    std::string string{};
+  };
+
+  using ClientInfoResponse = Response<void>;
+
+  Future<void> ClientInfo(const ClientInfoRequest& request);
+
+  Future<void> ClientInfo(const uint32_t& major_version = {},
+                          const uint32_t& minor_version = {},
+                          const std::string& string = {});
+
+  struct GetFBConfigsRequest {
+    uint32_t screen{};
+  };
+
+  struct GetFBConfigsReply {
+    uint16_t sequence{};
+    uint32_t num_FB_configs{};
+    uint32_t num_properties{};
+    std::vector<uint32_t> property_list{};
+  };
+
+  using GetFBConfigsResponse = Response<GetFBConfigsReply>;
+
+  Future<GetFBConfigsReply> GetFBConfigs(const GetFBConfigsRequest& request);
+
+  Future<GetFBConfigsReply> GetFBConfigs(const uint32_t& screen = {});
+
+  struct CreatePixmapRequest {
+    uint32_t screen{};
+    FbConfig fbconfig{};
+    x11::Pixmap pixmap{};
+    Pixmap glx_pixmap{};
+    uint32_t num_attribs{};
+    std::vector<uint32_t> attribs{};
+  };
+
+  using CreatePixmapResponse = Response<void>;
+
+  Future<void> CreatePixmap(const CreatePixmapRequest& request);
+
+  Future<void> CreatePixmap(const uint32_t& screen = {},
+                            const FbConfig& fbconfig = {},
+                            const x11::Pixmap& pixmap = {},
+                            const Pixmap& glx_pixmap = {},
+                            const uint32_t& num_attribs = {},
+                            const std::vector<uint32_t>& attribs = {});
+
+  struct DestroyPixmapRequest {
+    Pixmap glx_pixmap{};
+  };
+
+  using DestroyPixmapResponse = Response<void>;
+
+  Future<void> DestroyPixmap(const DestroyPixmapRequest& request);
+
+  Future<void> DestroyPixmap(const Pixmap& glx_pixmap = {});
+
+  struct CreateNewContextRequest {
+    Context context{};
+    FbConfig fbconfig{};
+    uint32_t screen{};
+    uint32_t render_type{};
+    Context share_list{};
+    uint8_t is_direct{};
+  };
+
+  using CreateNewContextResponse = Response<void>;
+
+  Future<void> CreateNewContext(const CreateNewContextRequest& request);
+
+  Future<void> CreateNewContext(const Context& context = {},
+                                const FbConfig& fbconfig = {},
+                                const uint32_t& screen = {},
+                                const uint32_t& render_type = {},
+                                const Context& share_list = {},
+                                const uint8_t& is_direct = {});
+
+  struct QueryContextRequest {
+    Context context{};
+  };
+
+  struct QueryContextReply {
+    uint16_t sequence{};
+    uint32_t num_attribs{};
+    std::vector<uint32_t> attribs{};
+  };
+
+  using QueryContextResponse = Response<QueryContextReply>;
+
+  Future<QueryContextReply> QueryContext(const QueryContextRequest& request);
+
+  Future<QueryContextReply> QueryContext(const Context& context = {});
+
+  struct MakeContextCurrentRequest {
+    ContextTag old_context_tag{};
+    Drawable drawable{};
+    Drawable read_drawable{};
+    Context context{};
+  };
+
+  struct MakeContextCurrentReply {
+    uint16_t sequence{};
+    ContextTag context_tag{};
+  };
+
+  using MakeContextCurrentResponse = Response<MakeContextCurrentReply>;
+
+  Future<MakeContextCurrentReply> MakeContextCurrent(
+      const MakeContextCurrentRequest& request);
+
+  Future<MakeContextCurrentReply> MakeContextCurrent(
+      const ContextTag& old_context_tag = {},
+      const Drawable& drawable = {},
+      const Drawable& read_drawable = {},
+      const Context& context = {});
+
+  struct CreatePbufferRequest {
+    uint32_t screen{};
+    FbConfig fbconfig{};
+    PBuffer pbuffer{};
+    uint32_t num_attribs{};
+    std::vector<uint32_t> attribs{};
+  };
+
+  using CreatePbufferResponse = Response<void>;
+
+  Future<void> CreatePbuffer(const CreatePbufferRequest& request);
+
+  Future<void> CreatePbuffer(const uint32_t& screen = {},
+                             const FbConfig& fbconfig = {},
+                             const PBuffer& pbuffer = {},
+                             const uint32_t& num_attribs = {},
+                             const std::vector<uint32_t>& attribs = {});
+
+  struct DestroyPbufferRequest {
+    PBuffer pbuffer{};
+  };
+
+  using DestroyPbufferResponse = Response<void>;
+
+  Future<void> DestroyPbuffer(const DestroyPbufferRequest& request);
+
+  Future<void> DestroyPbuffer(const PBuffer& pbuffer = {});
+
+  struct GetDrawableAttributesRequest {
+    Drawable drawable{};
+  };
+
+  struct GetDrawableAttributesReply {
+    uint16_t sequence{};
+    uint32_t num_attribs{};
+    std::vector<uint32_t> attribs{};
+  };
+
+  using GetDrawableAttributesResponse = Response<GetDrawableAttributesReply>;
+
+  Future<GetDrawableAttributesReply> GetDrawableAttributes(
+      const GetDrawableAttributesRequest& request);
+
+  Future<GetDrawableAttributesReply> GetDrawableAttributes(
+      const Drawable& drawable = {});
+
+  struct ChangeDrawableAttributesRequest {
+    Drawable drawable{};
+    uint32_t num_attribs{};
+    std::vector<uint32_t> attribs{};
+  };
+
+  using ChangeDrawableAttributesResponse = Response<void>;
+
+  Future<void> ChangeDrawableAttributes(
+      const ChangeDrawableAttributesRequest& request);
+
+  Future<void> ChangeDrawableAttributes(
+      const Drawable& drawable = {},
+      const uint32_t& num_attribs = {},
+      const std::vector<uint32_t>& attribs = {});
+
+  struct CreateWindowRequest {
+    uint32_t screen{};
+    FbConfig fbconfig{};
+    x11::Window window{};
+    Window glx_window{};
+    uint32_t num_attribs{};
+    std::vector<uint32_t> attribs{};
+  };
+
+  using CreateWindowResponse = Response<void>;
+
+  Future<void> CreateWindow(const CreateWindowRequest& request);
+
+  Future<void> CreateWindow(const uint32_t& screen = {},
+                            const FbConfig& fbconfig = {},
+                            const x11::Window& window = {},
+                            const Window& glx_window = {},
+                            const uint32_t& num_attribs = {},
+                            const std::vector<uint32_t>& attribs = {});
+
+  struct DeleteWindowRequest {
+    Window glxwindow{};
+  };
+
+  using DeleteWindowResponse = Response<void>;
+
+  Future<void> DeleteWindow(const DeleteWindowRequest& request);
+
+  Future<void> DeleteWindow(const Window& glxwindow = {});
+
+  struct SetClientInfoARBRequest {
+    uint32_t major_version{};
+    uint32_t minor_version{};
+    uint32_t num_versions{};
+    std::vector<uint32_t> gl_versions{};
+    std::string gl_extension_string{};
+    std::string glx_extension_string{};
+  };
+
+  using SetClientInfoARBResponse = Response<void>;
+
+  Future<void> SetClientInfoARB(const SetClientInfoARBRequest& request);
+
+  Future<void> SetClientInfoARB(const uint32_t& major_version = {},
+                                const uint32_t& minor_version = {},
+                                const uint32_t& num_versions = {},
+                                const std::vector<uint32_t>& gl_versions = {},
+                                const std::string& gl_extension_string = {},
+                                const std::string& glx_extension_string = {});
+
+  struct CreateContextAttribsARBRequest {
+    Context context{};
+    FbConfig fbconfig{};
+    uint32_t screen{};
+    Context share_list{};
+    uint8_t is_direct{};
+    uint32_t num_attribs{};
+    std::vector<uint32_t> attribs{};
+  };
+
+  using CreateContextAttribsARBResponse = Response<void>;
+
+  Future<void> CreateContextAttribsARB(
+      const CreateContextAttribsARBRequest& request);
+
+  Future<void> CreateContextAttribsARB(
+      const Context& context = {},
+      const FbConfig& fbconfig = {},
+      const uint32_t& screen = {},
+      const Context& share_list = {},
+      const uint8_t& is_direct = {},
+      const uint32_t& num_attribs = {},
+      const std::vector<uint32_t>& attribs = {});
+
+  struct SetClientInfo2ARBRequest {
+    uint32_t major_version{};
+    uint32_t minor_version{};
+    uint32_t num_versions{};
+    std::vector<uint32_t> gl_versions{};
+    std::string gl_extension_string{};
+    std::string glx_extension_string{};
+  };
+
+  using SetClientInfo2ARBResponse = Response<void>;
+
+  Future<void> SetClientInfo2ARB(const SetClientInfo2ARBRequest& request);
+
+  Future<void> SetClientInfo2ARB(const uint32_t& major_version = {},
+                                 const uint32_t& minor_version = {},
+                                 const uint32_t& num_versions = {},
+                                 const std::vector<uint32_t>& gl_versions = {},
+                                 const std::string& gl_extension_string = {},
+                                 const std::string& glx_extension_string = {});
+
+  struct NewListRequest {
+    ContextTag context_tag{};
+    uint32_t list{};
+    uint32_t mode{};
+  };
+
+  using NewListResponse = Response<void>;
+
+  Future<void> NewList(const NewListRequest& request);
+
+  Future<void> NewList(const ContextTag& context_tag = {},
+                       const uint32_t& list = {},
+                       const uint32_t& mode = {});
+
+  struct EndListRequest {
+    ContextTag context_tag{};
+  };
+
+  using EndListResponse = Response<void>;
+
+  Future<void> EndList(const EndListRequest& request);
+
+  Future<void> EndList(const ContextTag& context_tag = {});
+
+  struct DeleteListsRequest {
+    ContextTag context_tag{};
+    uint32_t list{};
+    int32_t range{};
+  };
+
+  using DeleteListsResponse = Response<void>;
+
+  Future<void> DeleteLists(const DeleteListsRequest& request);
+
+  Future<void> DeleteLists(const ContextTag& context_tag = {},
+                           const uint32_t& list = {},
+                           const int32_t& range = {});
+
+  struct GenListsRequest {
+    ContextTag context_tag{};
+    int32_t range{};
+  };
+
+  struct GenListsReply {
+    uint16_t sequence{};
+    uint32_t ret_val{};
+  };
+
+  using GenListsResponse = Response<GenListsReply>;
+
+  Future<GenListsReply> GenLists(const GenListsRequest& request);
+
+  Future<GenListsReply> GenLists(const ContextTag& context_tag = {},
+                                 const int32_t& range = {});
+
+  struct FeedbackBufferRequest {
+    ContextTag context_tag{};
+    int32_t size{};
+    int32_t type{};
+  };
+
+  using FeedbackBufferResponse = Response<void>;
+
+  Future<void> FeedbackBuffer(const FeedbackBufferRequest& request);
+
+  Future<void> FeedbackBuffer(const ContextTag& context_tag = {},
+                              const int32_t& size = {},
+                              const int32_t& type = {});
+
+  struct SelectBufferRequest {
+    ContextTag context_tag{};
+    int32_t size{};
+  };
+
+  using SelectBufferResponse = Response<void>;
+
+  Future<void> SelectBuffer(const SelectBufferRequest& request);
+
+  Future<void> SelectBuffer(const ContextTag& context_tag = {},
+                            const int32_t& size = {});
+
+  struct RenderModeRequest {
+    ContextTag context_tag{};
+    uint32_t mode{};
+  };
+
+  struct RenderModeReply {
+    uint16_t sequence{};
+    uint32_t ret_val{};
+    uint32_t new_mode{};
+    std::vector<uint32_t> data{};
+  };
+
+  using RenderModeResponse = Response<RenderModeReply>;
+
+  Future<RenderModeReply> RenderMode(const RenderModeRequest& request);
+
+  Future<RenderModeReply> RenderMode(const ContextTag& context_tag = {},
+                                     const uint32_t& mode = {});
+
+  struct FinishRequest {
+    ContextTag context_tag{};
+  };
+
+  struct FinishReply {
+    uint16_t sequence{};
+  };
+
+  using FinishResponse = Response<FinishReply>;
+
+  Future<FinishReply> Finish(const FinishRequest& request);
+
+  Future<FinishReply> Finish(const ContextTag& context_tag = {});
+
+  struct PixelStorefRequest {
+    ContextTag context_tag{};
+    uint32_t pname{};
+    float datum{};
+  };
+
+  using PixelStorefResponse = Response<void>;
+
+  Future<void> PixelStoref(const PixelStorefRequest& request);
+
+  Future<void> PixelStoref(const ContextTag& context_tag = {},
+                           const uint32_t& pname = {},
+                           const float& datum = {});
+
+  struct PixelStoreiRequest {
+    ContextTag context_tag{};
+    uint32_t pname{};
+    int32_t datum{};
+  };
+
+  using PixelStoreiResponse = Response<void>;
+
+  Future<void> PixelStorei(const PixelStoreiRequest& request);
+
+  Future<void> PixelStorei(const ContextTag& context_tag = {},
+                           const uint32_t& pname = {},
+                           const int32_t& datum = {});
+
+  struct ReadPixelsRequest {
+    ContextTag context_tag{};
+    int32_t x{};
+    int32_t y{};
+    int32_t width{};
+    int32_t height{};
+    uint32_t format{};
+    uint32_t type{};
+    uint8_t swap_bytes{};
+    uint8_t lsb_first{};
+  };
+
+  struct ReadPixelsReply {
+    uint16_t sequence{};
+    std::vector<uint8_t> data{};
+  };
+
+  using ReadPixelsResponse = Response<ReadPixelsReply>;
+
+  Future<ReadPixelsReply> ReadPixels(const ReadPixelsRequest& request);
+
+  Future<ReadPixelsReply> ReadPixels(const ContextTag& context_tag = {},
+                                     const int32_t& x = {},
+                                     const int32_t& y = {},
+                                     const int32_t& width = {},
+                                     const int32_t& height = {},
+                                     const uint32_t& format = {},
+                                     const uint32_t& type = {},
+                                     const uint8_t& swap_bytes = {},
+                                     const uint8_t& lsb_first = {});
+
+  struct GetBooleanvRequest {
+    ContextTag context_tag{};
+    int32_t pname{};
+  };
+
+  struct GetBooleanvReply {
+    uint16_t sequence{};
+    uint8_t datum{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetBooleanvResponse = Response<GetBooleanvReply>;
+
+  Future<GetBooleanvReply> GetBooleanv(const GetBooleanvRequest& request);
+
+  Future<GetBooleanvReply> GetBooleanv(const ContextTag& context_tag = {},
+                                       const int32_t& pname = {});
+
+  struct GetClipPlaneRequest {
+    ContextTag context_tag{};
+    int32_t plane{};
+  };
+
+  struct GetClipPlaneReply {
+    uint16_t sequence{};
+    std::vector<double> data{};
+  };
+
+  using GetClipPlaneResponse = Response<GetClipPlaneReply>;
+
+  Future<GetClipPlaneReply> GetClipPlane(const GetClipPlaneRequest& request);
+
+  Future<GetClipPlaneReply> GetClipPlane(const ContextTag& context_tag = {},
+                                         const int32_t& plane = {});
+
+  struct GetDoublevRequest {
+    ContextTag context_tag{};
+    uint32_t pname{};
+  };
+
+  struct GetDoublevReply {
+    uint16_t sequence{};
+    double datum{};
+    std::vector<double> data{};
+  };
+
+  using GetDoublevResponse = Response<GetDoublevReply>;
+
+  Future<GetDoublevReply> GetDoublev(const GetDoublevRequest& request);
+
+  Future<GetDoublevReply> GetDoublev(const ContextTag& context_tag = {},
+                                     const uint32_t& pname = {});
+
+  struct GetErrorRequest {
+    ContextTag context_tag{};
+  };
+
+  struct GetErrorReply {
+    uint16_t sequence{};
+    int32_t error{};
+  };
+
+  using GetErrorResponse = Response<GetErrorReply>;
+
+  Future<GetErrorReply> GetError(const GetErrorRequest& request);
+
+  Future<GetErrorReply> GetError(const ContextTag& context_tag = {});
+
+  struct GetFloatvRequest {
+    ContextTag context_tag{};
+    uint32_t pname{};
+  };
+
+  struct GetFloatvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetFloatvResponse = Response<GetFloatvReply>;
+
+  Future<GetFloatvReply> GetFloatv(const GetFloatvRequest& request);
+
+  Future<GetFloatvReply> GetFloatv(const ContextTag& context_tag = {},
+                                   const uint32_t& pname = {});
+
+  struct GetIntegervRequest {
+    ContextTag context_tag{};
+    uint32_t pname{};
+  };
+
+  struct GetIntegervReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetIntegervResponse = Response<GetIntegervReply>;
+
+  Future<GetIntegervReply> GetIntegerv(const GetIntegervRequest& request);
+
+  Future<GetIntegervReply> GetIntegerv(const ContextTag& context_tag = {},
+                                       const uint32_t& pname = {});
+
+  struct GetLightfvRequest {
+    ContextTag context_tag{};
+    uint32_t light{};
+    uint32_t pname{};
+  };
+
+  struct GetLightfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetLightfvResponse = Response<GetLightfvReply>;
+
+  Future<GetLightfvReply> GetLightfv(const GetLightfvRequest& request);
+
+  Future<GetLightfvReply> GetLightfv(const ContextTag& context_tag = {},
+                                     const uint32_t& light = {},
+                                     const uint32_t& pname = {});
+
+  struct GetLightivRequest {
+    ContextTag context_tag{};
+    uint32_t light{};
+    uint32_t pname{};
+  };
+
+  struct GetLightivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetLightivResponse = Response<GetLightivReply>;
+
+  Future<GetLightivReply> GetLightiv(const GetLightivRequest& request);
+
+  Future<GetLightivReply> GetLightiv(const ContextTag& context_tag = {},
+                                     const uint32_t& light = {},
+                                     const uint32_t& pname = {});
+
+  struct GetMapdvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t query{};
+  };
+
+  struct GetMapdvReply {
+    uint16_t sequence{};
+    double datum{};
+    std::vector<double> data{};
+  };
+
+  using GetMapdvResponse = Response<GetMapdvReply>;
+
+  Future<GetMapdvReply> GetMapdv(const GetMapdvRequest& request);
+
+  Future<GetMapdvReply> GetMapdv(const ContextTag& context_tag = {},
+                                 const uint32_t& target = {},
+                                 const uint32_t& query = {});
+
+  struct GetMapfvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t query{};
+  };
+
+  struct GetMapfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetMapfvResponse = Response<GetMapfvReply>;
+
+  Future<GetMapfvReply> GetMapfv(const GetMapfvRequest& request);
+
+  Future<GetMapfvReply> GetMapfv(const ContextTag& context_tag = {},
+                                 const uint32_t& target = {},
+                                 const uint32_t& query = {});
+
+  struct GetMapivRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t query{};
+  };
+
+  struct GetMapivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetMapivResponse = Response<GetMapivReply>;
+
+  Future<GetMapivReply> GetMapiv(const GetMapivRequest& request);
+
+  Future<GetMapivReply> GetMapiv(const ContextTag& context_tag = {},
+                                 const uint32_t& target = {},
+                                 const uint32_t& query = {});
+
+  struct GetMaterialfvRequest {
+    ContextTag context_tag{};
+    uint32_t face{};
+    uint32_t pname{};
+  };
+
+  struct GetMaterialfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetMaterialfvResponse = Response<GetMaterialfvReply>;
+
+  Future<GetMaterialfvReply> GetMaterialfv(const GetMaterialfvRequest& request);
+
+  Future<GetMaterialfvReply> GetMaterialfv(const ContextTag& context_tag = {},
+                                           const uint32_t& face = {},
+                                           const uint32_t& pname = {});
+
+  struct GetMaterialivRequest {
+    ContextTag context_tag{};
+    uint32_t face{};
+    uint32_t pname{};
+  };
+
+  struct GetMaterialivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetMaterialivResponse = Response<GetMaterialivReply>;
+
+  Future<GetMaterialivReply> GetMaterialiv(const GetMaterialivRequest& request);
+
+  Future<GetMaterialivReply> GetMaterialiv(const ContextTag& context_tag = {},
+                                           const uint32_t& face = {},
+                                           const uint32_t& pname = {});
+
+  struct GetPixelMapfvRequest {
+    ContextTag context_tag{};
+    uint32_t map{};
+  };
+
+  struct GetPixelMapfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetPixelMapfvResponse = Response<GetPixelMapfvReply>;
+
+  Future<GetPixelMapfvReply> GetPixelMapfv(const GetPixelMapfvRequest& request);
+
+  Future<GetPixelMapfvReply> GetPixelMapfv(const ContextTag& context_tag = {},
+                                           const uint32_t& map = {});
+
+  struct GetPixelMapuivRequest {
+    ContextTag context_tag{};
+    uint32_t map{};
+  };
+
+  struct GetPixelMapuivReply {
+    uint16_t sequence{};
+    uint32_t datum{};
+    std::vector<uint32_t> data{};
+  };
+
+  using GetPixelMapuivResponse = Response<GetPixelMapuivReply>;
+
+  Future<GetPixelMapuivReply> GetPixelMapuiv(
+      const GetPixelMapuivRequest& request);
+
+  Future<GetPixelMapuivReply> GetPixelMapuiv(const ContextTag& context_tag = {},
+                                             const uint32_t& map = {});
+
+  struct GetPixelMapusvRequest {
+    ContextTag context_tag{};
+    uint32_t map{};
+  };
+
+  struct GetPixelMapusvReply {
+    uint16_t sequence{};
+    uint16_t datum{};
+    std::vector<uint16_t> data{};
+  };
+
+  using GetPixelMapusvResponse = Response<GetPixelMapusvReply>;
+
+  Future<GetPixelMapusvReply> GetPixelMapusv(
+      const GetPixelMapusvRequest& request);
+
+  Future<GetPixelMapusvReply> GetPixelMapusv(const ContextTag& context_tag = {},
+                                             const uint32_t& map = {});
+
+  struct GetPolygonStippleRequest {
+    ContextTag context_tag{};
+    uint8_t lsb_first{};
+  };
+
+  struct GetPolygonStippleReply {
+    uint16_t sequence{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetPolygonStippleResponse = Response<GetPolygonStippleReply>;
+
+  Future<GetPolygonStippleReply> GetPolygonStipple(
+      const GetPolygonStippleRequest& request);
+
+  Future<GetPolygonStippleReply> GetPolygonStipple(
+      const ContextTag& context_tag = {},
+      const uint8_t& lsb_first = {});
+
+  struct GetStringRequest {
+    ContextTag context_tag{};
+    uint32_t name{};
+  };
+
+  struct GetStringReply {
+    uint16_t sequence{};
+    std::string string{};
+  };
+
+  using GetStringResponse = Response<GetStringReply>;
+
+  Future<GetStringReply> GetString(const GetStringRequest& request);
+
+  Future<GetStringReply> GetString(const ContextTag& context_tag = {},
+                                   const uint32_t& name = {});
+
+  struct GetTexEnvfvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetTexEnvfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetTexEnvfvResponse = Response<GetTexEnvfvReply>;
+
+  Future<GetTexEnvfvReply> GetTexEnvfv(const GetTexEnvfvRequest& request);
+
+  Future<GetTexEnvfvReply> GetTexEnvfv(const ContextTag& context_tag = {},
+                                       const uint32_t& target = {},
+                                       const uint32_t& pname = {});
+
+  struct GetTexEnvivRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetTexEnvivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetTexEnvivResponse = Response<GetTexEnvivReply>;
+
+  Future<GetTexEnvivReply> GetTexEnviv(const GetTexEnvivRequest& request);
+
+  Future<GetTexEnvivReply> GetTexEnviv(const ContextTag& context_tag = {},
+                                       const uint32_t& target = {},
+                                       const uint32_t& pname = {});
+
+  struct GetTexGendvRequest {
+    ContextTag context_tag{};
+    uint32_t coord{};
+    uint32_t pname{};
+  };
+
+  struct GetTexGendvReply {
+    uint16_t sequence{};
+    double datum{};
+    std::vector<double> data{};
+  };
+
+  using GetTexGendvResponse = Response<GetTexGendvReply>;
+
+  Future<GetTexGendvReply> GetTexGendv(const GetTexGendvRequest& request);
+
+  Future<GetTexGendvReply> GetTexGendv(const ContextTag& context_tag = {},
+                                       const uint32_t& coord = {},
+                                       const uint32_t& pname = {});
+
+  struct GetTexGenfvRequest {
+    ContextTag context_tag{};
+    uint32_t coord{};
+    uint32_t pname{};
+  };
+
+  struct GetTexGenfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetTexGenfvResponse = Response<GetTexGenfvReply>;
+
+  Future<GetTexGenfvReply> GetTexGenfv(const GetTexGenfvRequest& request);
+
+  Future<GetTexGenfvReply> GetTexGenfv(const ContextTag& context_tag = {},
+                                       const uint32_t& coord = {},
+                                       const uint32_t& pname = {});
+
+  struct GetTexGenivRequest {
+    ContextTag context_tag{};
+    uint32_t coord{};
+    uint32_t pname{};
+  };
+
+  struct GetTexGenivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetTexGenivResponse = Response<GetTexGenivReply>;
+
+  Future<GetTexGenivReply> GetTexGeniv(const GetTexGenivRequest& request);
+
+  Future<GetTexGenivReply> GetTexGeniv(const ContextTag& context_tag = {},
+                                       const uint32_t& coord = {},
+                                       const uint32_t& pname = {});
+
+  struct GetTexImageRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    int32_t level{};
+    uint32_t format{};
+    uint32_t type{};
+    uint8_t swap_bytes{};
+  };
+
+  struct GetTexImageReply {
+    uint16_t sequence{};
+    int32_t width{};
+    int32_t height{};
+    int32_t depth{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetTexImageResponse = Response<GetTexImageReply>;
+
+  Future<GetTexImageReply> GetTexImage(const GetTexImageRequest& request);
+
+  Future<GetTexImageReply> GetTexImage(const ContextTag& context_tag = {},
+                                       const uint32_t& target = {},
+                                       const int32_t& level = {},
+                                       const uint32_t& format = {},
+                                       const uint32_t& type = {},
+                                       const uint8_t& swap_bytes = {});
+
+  struct GetTexParameterfvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetTexParameterfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetTexParameterfvResponse = Response<GetTexParameterfvReply>;
+
+  Future<GetTexParameterfvReply> GetTexParameterfv(
+      const GetTexParameterfvRequest& request);
+
+  Future<GetTexParameterfvReply> GetTexParameterfv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetTexParameterivRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetTexParameterivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetTexParameterivResponse = Response<GetTexParameterivReply>;
+
+  Future<GetTexParameterivReply> GetTexParameteriv(
+      const GetTexParameterivRequest& request);
+
+  Future<GetTexParameterivReply> GetTexParameteriv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetTexLevelParameterfvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    int32_t level{};
+    uint32_t pname{};
+  };
+
+  struct GetTexLevelParameterfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetTexLevelParameterfvResponse = Response<GetTexLevelParameterfvReply>;
+
+  Future<GetTexLevelParameterfvReply> GetTexLevelParameterfv(
+      const GetTexLevelParameterfvRequest& request);
+
+  Future<GetTexLevelParameterfvReply> GetTexLevelParameterfv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const int32_t& level = {},
+      const uint32_t& pname = {});
+
+  struct GetTexLevelParameterivRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    int32_t level{};
+    uint32_t pname{};
+  };
+
+  struct GetTexLevelParameterivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetTexLevelParameterivResponse = Response<GetTexLevelParameterivReply>;
+
+  Future<GetTexLevelParameterivReply> GetTexLevelParameteriv(
+      const GetTexLevelParameterivRequest& request);
+
+  Future<GetTexLevelParameterivReply> GetTexLevelParameteriv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const int32_t& level = {},
+      const uint32_t& pname = {});
+
+  struct IsEnabledRequest {
+    ContextTag context_tag{};
+    uint32_t capability{};
+  };
+
+  struct IsEnabledReply {
+    uint16_t sequence{};
+    Bool32 ret_val{};
+  };
+
+  using IsEnabledResponse = Response<IsEnabledReply>;
+
+  Future<IsEnabledReply> IsEnabled(const IsEnabledRequest& request);
+
+  Future<IsEnabledReply> IsEnabled(const ContextTag& context_tag = {},
+                                   const uint32_t& capability = {});
+
+  struct IsListRequest {
+    ContextTag context_tag{};
+    uint32_t list{};
+  };
+
+  struct IsListReply {
+    uint16_t sequence{};
+    Bool32 ret_val{};
+  };
+
+  using IsListResponse = Response<IsListReply>;
+
+  Future<IsListReply> IsList(const IsListRequest& request);
+
+  Future<IsListReply> IsList(const ContextTag& context_tag = {},
+                             const uint32_t& list = {});
+
+  struct FlushRequest {
+    ContextTag context_tag{};
+  };
+
+  using FlushResponse = Response<void>;
+
+  Future<void> Flush(const FlushRequest& request);
+
+  Future<void> Flush(const ContextTag& context_tag = {});
+
+  struct AreTexturesResidentRequest {
+    ContextTag context_tag{};
+    std::vector<uint32_t> textures{};
+  };
+
+  struct AreTexturesResidentReply {
+    uint16_t sequence{};
+    Bool32 ret_val{};
+    std::vector<uint8_t> data{};
+  };
+
+  using AreTexturesResidentResponse = Response<AreTexturesResidentReply>;
+
+  Future<AreTexturesResidentReply> AreTexturesResident(
+      const AreTexturesResidentRequest& request);
+
+  Future<AreTexturesResidentReply> AreTexturesResident(
+      const ContextTag& context_tag = {},
+      const std::vector<uint32_t>& textures = {});
+
+  struct DeleteTexturesRequest {
+    ContextTag context_tag{};
+    std::vector<uint32_t> textures{};
+  };
+
+  using DeleteTexturesResponse = Response<void>;
+
+  Future<void> DeleteTextures(const DeleteTexturesRequest& request);
+
+  Future<void> DeleteTextures(const ContextTag& context_tag = {},
+                              const std::vector<uint32_t>& textures = {});
+
+  struct GenTexturesRequest {
+    ContextTag context_tag{};
+    int32_t n{};
+  };
+
+  struct GenTexturesReply {
+    uint16_t sequence{};
+    std::vector<uint32_t> data{};
+  };
+
+  using GenTexturesResponse = Response<GenTexturesReply>;
+
+  Future<GenTexturesReply> GenTextures(const GenTexturesRequest& request);
+
+  Future<GenTexturesReply> GenTextures(const ContextTag& context_tag = {},
+                                       const int32_t& n = {});
+
+  struct IsTextureRequest {
+    ContextTag context_tag{};
+    uint32_t texture{};
+  };
+
+  struct IsTextureReply {
+    uint16_t sequence{};
+    Bool32 ret_val{};
+  };
+
+  using IsTextureResponse = Response<IsTextureReply>;
+
+  Future<IsTextureReply> IsTexture(const IsTextureRequest& request);
+
+  Future<IsTextureReply> IsTexture(const ContextTag& context_tag = {},
+                                   const uint32_t& texture = {});
+
+  struct GetColorTableRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t format{};
+    uint32_t type{};
+    uint8_t swap_bytes{};
+  };
+
+  struct GetColorTableReply {
+    uint16_t sequence{};
+    int32_t width{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetColorTableResponse = Response<GetColorTableReply>;
+
+  Future<GetColorTableReply> GetColorTable(const GetColorTableRequest& request);
+
+  Future<GetColorTableReply> GetColorTable(const ContextTag& context_tag = {},
+                                           const uint32_t& target = {},
+                                           const uint32_t& format = {},
+                                           const uint32_t& type = {},
+                                           const uint8_t& swap_bytes = {});
+
+  struct GetColorTableParameterfvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetColorTableParameterfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetColorTableParameterfvResponse =
+      Response<GetColorTableParameterfvReply>;
+
+  Future<GetColorTableParameterfvReply> GetColorTableParameterfv(
+      const GetColorTableParameterfvRequest& request);
+
+  Future<GetColorTableParameterfvReply> GetColorTableParameterfv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetColorTableParameterivRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetColorTableParameterivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetColorTableParameterivResponse =
+      Response<GetColorTableParameterivReply>;
+
+  Future<GetColorTableParameterivReply> GetColorTableParameteriv(
+      const GetColorTableParameterivRequest& request);
+
+  Future<GetColorTableParameterivReply> GetColorTableParameteriv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetConvolutionFilterRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t format{};
+    uint32_t type{};
+    uint8_t swap_bytes{};
+  };
+
+  struct GetConvolutionFilterReply {
+    uint16_t sequence{};
+    int32_t width{};
+    int32_t height{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetConvolutionFilterResponse = Response<GetConvolutionFilterReply>;
+
+  Future<GetConvolutionFilterReply> GetConvolutionFilter(
+      const GetConvolutionFilterRequest& request);
+
+  Future<GetConvolutionFilterReply> GetConvolutionFilter(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& format = {},
+      const uint32_t& type = {},
+      const uint8_t& swap_bytes = {});
+
+  struct GetConvolutionParameterfvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetConvolutionParameterfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetConvolutionParameterfvResponse =
+      Response<GetConvolutionParameterfvReply>;
+
+  Future<GetConvolutionParameterfvReply> GetConvolutionParameterfv(
+      const GetConvolutionParameterfvRequest& request);
+
+  Future<GetConvolutionParameterfvReply> GetConvolutionParameterfv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetConvolutionParameterivRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetConvolutionParameterivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetConvolutionParameterivResponse =
+      Response<GetConvolutionParameterivReply>;
+
+  Future<GetConvolutionParameterivReply> GetConvolutionParameteriv(
+      const GetConvolutionParameterivRequest& request);
+
+  Future<GetConvolutionParameterivReply> GetConvolutionParameteriv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetSeparableFilterRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t format{};
+    uint32_t type{};
+    uint8_t swap_bytes{};
+  };
+
+  struct GetSeparableFilterReply {
+    uint16_t sequence{};
+    int32_t row_w{};
+    int32_t col_h{};
+    std::vector<uint8_t> rows_and_cols{};
+  };
+
+  using GetSeparableFilterResponse = Response<GetSeparableFilterReply>;
+
+  Future<GetSeparableFilterReply> GetSeparableFilter(
+      const GetSeparableFilterRequest& request);
+
+  Future<GetSeparableFilterReply> GetSeparableFilter(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& format = {},
+      const uint32_t& type = {},
+      const uint8_t& swap_bytes = {});
+
+  struct GetHistogramRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t format{};
+    uint32_t type{};
+    uint8_t swap_bytes{};
+    uint8_t reset{};
+  };
+
+  struct GetHistogramReply {
+    uint16_t sequence{};
+    int32_t width{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetHistogramResponse = Response<GetHistogramReply>;
+
+  Future<GetHistogramReply> GetHistogram(const GetHistogramRequest& request);
+
+  Future<GetHistogramReply> GetHistogram(const ContextTag& context_tag = {},
+                                         const uint32_t& target = {},
+                                         const uint32_t& format = {},
+                                         const uint32_t& type = {},
+                                         const uint8_t& swap_bytes = {},
+                                         const uint8_t& reset = {});
+
+  struct GetHistogramParameterfvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetHistogramParameterfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetHistogramParameterfvResponse =
+      Response<GetHistogramParameterfvReply>;
+
+  Future<GetHistogramParameterfvReply> GetHistogramParameterfv(
+      const GetHistogramParameterfvRequest& request);
+
+  Future<GetHistogramParameterfvReply> GetHistogramParameterfv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetHistogramParameterivRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetHistogramParameterivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetHistogramParameterivResponse =
+      Response<GetHistogramParameterivReply>;
+
+  Future<GetHistogramParameterivReply> GetHistogramParameteriv(
+      const GetHistogramParameterivRequest& request);
+
+  Future<GetHistogramParameterivReply> GetHistogramParameteriv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetMinmaxRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t format{};
+    uint32_t type{};
+    uint8_t swap_bytes{};
+    uint8_t reset{};
+  };
+
+  struct GetMinmaxReply {
+    uint16_t sequence{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetMinmaxResponse = Response<GetMinmaxReply>;
+
+  Future<GetMinmaxReply> GetMinmax(const GetMinmaxRequest& request);
+
+  Future<GetMinmaxReply> GetMinmax(const ContextTag& context_tag = {},
+                                   const uint32_t& target = {},
+                                   const uint32_t& format = {},
+                                   const uint32_t& type = {},
+                                   const uint8_t& swap_bytes = {},
+                                   const uint8_t& reset = {});
+
+  struct GetMinmaxParameterfvRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetMinmaxParameterfvReply {
+    uint16_t sequence{};
+    float datum{};
+    std::vector<float> data{};
+  };
+
+  using GetMinmaxParameterfvResponse = Response<GetMinmaxParameterfvReply>;
+
+  Future<GetMinmaxParameterfvReply> GetMinmaxParameterfv(
+      const GetMinmaxParameterfvRequest& request);
+
+  Future<GetMinmaxParameterfvReply> GetMinmaxParameterfv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetMinmaxParameterivRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetMinmaxParameterivReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetMinmaxParameterivResponse = Response<GetMinmaxParameterivReply>;
+
+  Future<GetMinmaxParameterivReply> GetMinmaxParameteriv(
+      const GetMinmaxParameterivRequest& request);
+
+  Future<GetMinmaxParameterivReply> GetMinmaxParameteriv(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const uint32_t& pname = {});
+
+  struct GetCompressedTexImageARBRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    int32_t level{};
+  };
+
+  struct GetCompressedTexImageARBReply {
+    uint16_t sequence{};
+    int32_t size{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetCompressedTexImageARBResponse =
+      Response<GetCompressedTexImageARBReply>;
+
+  Future<GetCompressedTexImageARBReply> GetCompressedTexImageARB(
+      const GetCompressedTexImageARBRequest& request);
+
+  Future<GetCompressedTexImageARBReply> GetCompressedTexImageARB(
+      const ContextTag& context_tag = {},
+      const uint32_t& target = {},
+      const int32_t& level = {});
+
+  struct DeleteQueriesARBRequest {
+    ContextTag context_tag{};
+    std::vector<uint32_t> ids{};
+  };
+
+  using DeleteQueriesARBResponse = Response<void>;
+
+  Future<void> DeleteQueriesARB(const DeleteQueriesARBRequest& request);
+
+  Future<void> DeleteQueriesARB(const ContextTag& context_tag = {},
+                                const std::vector<uint32_t>& ids = {});
+
+  struct GenQueriesARBRequest {
+    ContextTag context_tag{};
+    int32_t n{};
+  };
+
+  struct GenQueriesARBReply {
+    uint16_t sequence{};
+    std::vector<uint32_t> data{};
+  };
+
+  using GenQueriesARBResponse = Response<GenQueriesARBReply>;
+
+  Future<GenQueriesARBReply> GenQueriesARB(const GenQueriesARBRequest& request);
+
+  Future<GenQueriesARBReply> GenQueriesARB(const ContextTag& context_tag = {},
+                                           const int32_t& n = {});
+
+  struct IsQueryARBRequest {
+    ContextTag context_tag{};
+    uint32_t id{};
+  };
+
+  struct IsQueryARBReply {
+    uint16_t sequence{};
+    Bool32 ret_val{};
+  };
+
+  using IsQueryARBResponse = Response<IsQueryARBReply>;
+
+  Future<IsQueryARBReply> IsQueryARB(const IsQueryARBRequest& request);
+
+  Future<IsQueryARBReply> IsQueryARB(const ContextTag& context_tag = {},
+                                     const uint32_t& id = {});
+
+  struct GetQueryivARBRequest {
+    ContextTag context_tag{};
+    uint32_t target{};
+    uint32_t pname{};
+  };
+
+  struct GetQueryivARBReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetQueryivARBResponse = Response<GetQueryivARBReply>;
+
+  Future<GetQueryivARBReply> GetQueryivARB(const GetQueryivARBRequest& request);
+
+  Future<GetQueryivARBReply> GetQueryivARB(const ContextTag& context_tag = {},
+                                           const uint32_t& target = {},
+                                           const uint32_t& pname = {});
+
+  struct GetQueryObjectivARBRequest {
+    ContextTag context_tag{};
+    uint32_t id{};
+    uint32_t pname{};
+  };
+
+  struct GetQueryObjectivARBReply {
+    uint16_t sequence{};
+    int32_t datum{};
+    std::vector<int32_t> data{};
+  };
+
+  using GetQueryObjectivARBResponse = Response<GetQueryObjectivARBReply>;
+
+  Future<GetQueryObjectivARBReply> GetQueryObjectivARB(
+      const GetQueryObjectivARBRequest& request);
+
+  Future<GetQueryObjectivARBReply> GetQueryObjectivARB(
+      const ContextTag& context_tag = {},
+      const uint32_t& id = {},
+      const uint32_t& pname = {});
+
+  struct GetQueryObjectuivARBRequest {
+    ContextTag context_tag{};
+    uint32_t id{};
+    uint32_t pname{};
+  };
+
+  struct GetQueryObjectuivARBReply {
+    uint16_t sequence{};
+    uint32_t datum{};
+    std::vector<uint32_t> data{};
+  };
+
+  using GetQueryObjectuivARBResponse = Response<GetQueryObjectuivARBReply>;
+
+  Future<GetQueryObjectuivARBReply> GetQueryObjectuivARB(
+      const GetQueryObjectuivARBRequest& request);
+
+  Future<GetQueryObjectuivARBReply> GetQueryObjectuivARB(
+      const ContextTag& context_tag = {},
+      const uint32_t& id = {},
+      const uint32_t& pname = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Glx::Pbcet operator|(x11::Glx::Pbcet l,
+                                           x11::Glx::Pbcet r) {
+  using T = std::underlying_type_t<x11::Glx::Pbcet>;
+  return static_cast<x11::Glx::Pbcet>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Glx::Pbcet operator&(x11::Glx::Pbcet l,
+                                           x11::Glx::Pbcet r) {
+  using T = std::underlying_type_t<x11::Glx::Pbcet>;
+  return static_cast<x11::Glx::Pbcet>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Glx::Pbcdt operator|(x11::Glx::Pbcdt l,
+                                           x11::Glx::Pbcdt r) {
+  using T = std::underlying_type_t<x11::Glx::Pbcdt>;
+  return static_cast<x11::Glx::Pbcdt>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Glx::Pbcdt operator&(x11::Glx::Pbcdt l,
+                                           x11::Glx::Pbcdt r) {
+  using T = std::underlying_type_t<x11::Glx::Pbcdt>;
+  return static_cast<x11::Glx::Pbcdt>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Glx::GraphicsContextAttribute operator|(
+    x11::Glx::GraphicsContextAttribute l,
+    x11::Glx::GraphicsContextAttribute r) {
+  using T = std::underlying_type_t<x11::Glx::GraphicsContextAttribute>;
+  return static_cast<x11::Glx::GraphicsContextAttribute>(static_cast<T>(l) |
+                                                         static_cast<T>(r));
+}
+
+inline constexpr x11::Glx::GraphicsContextAttribute operator&(
+    x11::Glx::GraphicsContextAttribute l,
+    x11::Glx::GraphicsContextAttribute r) {
+  using T = std::underlying_type_t<x11::Glx::GraphicsContextAttribute>;
+  return static_cast<x11::Glx::GraphicsContextAttribute>(static_cast<T>(l) &
+                                                         static_cast<T>(r));
+}
+
+inline constexpr x11::Glx::Rm operator|(x11::Glx::Rm l, x11::Glx::Rm r) {
+  using T = std::underlying_type_t<x11::Glx::Rm>;
+  return static_cast<x11::Glx::Rm>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Glx::Rm operator&(x11::Glx::Rm l, x11::Glx::Rm r) {
+  using T = std::underlying_type_t<x11::Glx::Rm>;
+  return static_cast<x11::Glx::Rm>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_GLX_H_
diff --git a/ui/gfx/x/generated_protos/present.cc b/ui/gfx/x/generated_protos/present.cc
new file mode 100644
index 0000000..b4edda6
--- /dev/null
+++ b/ui/gfx/x/generated_protos/present.cc
@@ -0,0 +1,825 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "present.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Present::Present(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Present::GenericEvent>(Present::GenericEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& extension = (*event_).extension;
+  auto& sequence = (*event_).sequence;
+  auto& length = (*event_).length;
+  auto& evtype = (*event_).evtype;
+  auto& event = (*event_).event;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  Read(&length, &buf);
+
+  // evtype
+  Read(&evtype, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // event
+  Read(&event, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Present::ConfigureNotifyEvent>(
+    Present::ConfigureNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+  auto& off_x = (*event_).off_x;
+  auto& off_y = (*event_).off_y;
+  auto& pixmap_width = (*event_).pixmap_width;
+  auto& pixmap_height = (*event_).pixmap_height;
+  auto& pixmap_flags = (*event_).pixmap_flags;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // off_x
+  Read(&off_x, &buf);
+
+  // off_y
+  Read(&off_y, &buf);
+
+  // pixmap_width
+  Read(&pixmap_width, &buf);
+
+  // pixmap_height
+  Read(&pixmap_height, &buf);
+
+  // pixmap_flags
+  Read(&pixmap_flags, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Present::CompleteNotifyEvent>(
+    Present::CompleteNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& kind = (*event_).kind;
+  auto& mode = (*event_).mode;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& serial = (*event_).serial;
+  auto& ust = (*event_).ust;
+  auto& msc = (*event_).msc;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // kind
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  kind = static_cast<Present::CompleteKind>(tmp0);
+
+  // mode
+  uint8_t tmp1;
+  Read(&tmp1, &buf);
+  mode = static_cast<Present::CompleteMode>(tmp1);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // serial
+  Read(&serial, &buf);
+
+  // ust
+  Read(&ust, &buf);
+
+  // msc
+  Read(&msc, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Present::IdleNotifyEvent>(Present::IdleNotifyEvent* event_,
+                                         ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& serial = (*event_).serial;
+  auto& pixmap = (*event_).pixmap;
+  auto& idle_fence = (*event_).idle_fence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // serial
+  Read(&serial, &buf);
+
+  // pixmap
+  Read(&pixmap, &buf);
+
+  // idle_fence
+  Read(&idle_fence, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Present::RedirectNotifyEvent>(
+    Present::RedirectNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& update_window = (*event_).update_window;
+  auto& event = (*event_).event;
+  auto& event_window = (*event_).event_window;
+  auto& window = (*event_).window;
+  auto& pixmap = (*event_).pixmap;
+  auto& serial = (*event_).serial;
+  auto& valid_region = (*event_).valid_region;
+  auto& update_region = (*event_).update_region;
+  auto& valid_rect = (*event_).valid_rect;
+  auto& update_rect = (*event_).update_rect;
+  auto& x_off = (*event_).x_off;
+  auto& y_off = (*event_).y_off;
+  auto& target_crtc = (*event_).target_crtc;
+  auto& wait_fence = (*event_).wait_fence;
+  auto& idle_fence = (*event_).idle_fence;
+  auto& options = (*event_).options;
+  auto& target_msc = (*event_).target_msc;
+  auto& divisor = (*event_).divisor;
+  auto& remainder = (*event_).remainder;
+  auto& notifies = (*event_).notifies;
+  size_t notifies_len = notifies.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // update_window
+  Read(&update_window, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // event
+  Read(&event, &buf);
+
+  // event_window
+  Read(&event_window, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // pixmap
+  Read(&pixmap, &buf);
+
+  // serial
+  Read(&serial, &buf);
+
+  // valid_region
+  Read(&valid_region, &buf);
+
+  // update_region
+  Read(&update_region, &buf);
+
+  // valid_rect
+  {
+    auto& x = valid_rect.x;
+    auto& y = valid_rect.y;
+    auto& width = valid_rect.width;
+    auto& height = valid_rect.height;
+
+    // x
+    Read(&x, &buf);
+
+    // y
+    Read(&y, &buf);
+
+    // width
+    Read(&width, &buf);
+
+    // height
+    Read(&height, &buf);
+  }
+
+  // update_rect
+  {
+    auto& x = update_rect.x;
+    auto& y = update_rect.y;
+    auto& width = update_rect.width;
+    auto& height = update_rect.height;
+
+    // x
+    Read(&x, &buf);
+
+    // y
+    Read(&y, &buf);
+
+    // width
+    Read(&width, &buf);
+
+    // height
+    Read(&height, &buf);
+  }
+
+  // x_off
+  Read(&x_off, &buf);
+
+  // y_off
+  Read(&y_off, &buf);
+
+  // target_crtc
+  Read(&target_crtc, &buf);
+
+  // wait_fence
+  Read(&wait_fence, &buf);
+
+  // idle_fence
+  Read(&idle_fence, &buf);
+
+  // options
+  Read(&options, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // target_msc
+  Read(&target_msc, &buf);
+
+  // divisor
+  Read(&divisor, &buf);
+
+  // remainder
+  Read(&remainder, &buf);
+
+  // notifies
+  notifies.resize(notifies_len);
+  for (auto& notifies_elem : notifies) {
+    // notifies_elem
+    {
+      auto& window = notifies_elem.window;
+      auto& serial = notifies_elem.serial;
+
+      // window
+      Read(&window, &buf);
+
+      // serial
+      Read(&serial, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+Future<Present::QueryVersionReply> Present::QueryVersion(
+    const Present::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Present::QueryVersionReply>(
+      &buf, "Present::QueryVersion", false);
+}
+
+Future<Present::QueryVersionReply> Present::QueryVersion(
+    const uint32_t& major_version,
+    const uint32_t& minor_version) {
+  return Present::QueryVersion(
+      Present::QueryVersionRequest{major_version, minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Present::QueryVersionReply> detail::ReadReply<
+    Present::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Present::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Present::PresentPixmap(
+    const Present::PresentPixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& pixmap = request.pixmap;
+  auto& serial = request.serial;
+  auto& valid = request.valid;
+  auto& update = request.update;
+  auto& x_off = request.x_off;
+  auto& y_off = request.y_off;
+  auto& target_crtc = request.target_crtc;
+  auto& wait_fence = request.wait_fence;
+  auto& idle_fence = request.idle_fence;
+  auto& options = request.options;
+  auto& target_msc = request.target_msc;
+  auto& divisor = request.divisor;
+  auto& remainder = request.remainder;
+  auto& notifies = request.notifies;
+  size_t notifies_len = notifies.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  // serial
+  buf.Write(&serial);
+
+  // valid
+  buf.Write(&valid);
+
+  // update
+  buf.Write(&update);
+
+  // x_off
+  buf.Write(&x_off);
+
+  // y_off
+  buf.Write(&y_off);
+
+  // target_crtc
+  buf.Write(&target_crtc);
+
+  // wait_fence
+  buf.Write(&wait_fence);
+
+  // idle_fence
+  buf.Write(&idle_fence);
+
+  // options
+  buf.Write(&options);
+
+  // pad0
+  Pad(&buf, 4);
+
+  // target_msc
+  buf.Write(&target_msc);
+
+  // divisor
+  buf.Write(&divisor);
+
+  // remainder
+  buf.Write(&remainder);
+
+  // notifies
+  DCHECK_EQ(static_cast<size_t>(notifies_len), notifies.size());
+  for (auto& notifies_elem : notifies) {
+    // notifies_elem
+    {
+      auto& window = notifies_elem.window;
+      auto& serial = notifies_elem.serial;
+
+      // window
+      buf.Write(&window);
+
+      // serial
+      buf.Write(&serial);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Present::PresentPixmap", false);
+}
+
+Future<void> Present::PresentPixmap(const Window& window,
+                                    const Pixmap& pixmap,
+                                    const uint32_t& serial,
+                                    const XFixes::Region& valid,
+                                    const XFixes::Region& update,
+                                    const int16_t& x_off,
+                                    const int16_t& y_off,
+                                    const RandR::Crtc& target_crtc,
+                                    const Sync::Fence& wait_fence,
+                                    const Sync::Fence& idle_fence,
+                                    const uint32_t& options,
+                                    const uint64_t& target_msc,
+                                    const uint64_t& divisor,
+                                    const uint64_t& remainder,
+                                    const std::vector<Notify>& notifies) {
+  return Present::PresentPixmap(Present::PresentPixmapRequest{
+      window, pixmap, serial, valid, update, x_off, y_off, target_crtc,
+      wait_fence, idle_fence, options, target_msc, divisor, remainder,
+      notifies});
+}
+
+Future<void> Present::NotifyMSC(const Present::NotifyMSCRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& serial = request.serial;
+  auto& target_msc = request.target_msc;
+  auto& divisor = request.divisor;
+  auto& remainder = request.remainder;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // serial
+  buf.Write(&serial);
+
+  // pad0
+  Pad(&buf, 4);
+
+  // target_msc
+  buf.Write(&target_msc);
+
+  // divisor
+  buf.Write(&divisor);
+
+  // remainder
+  buf.Write(&remainder);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Present::NotifyMSC", false);
+}
+
+Future<void> Present::NotifyMSC(const Window& window,
+                                const uint32_t& serial,
+                                const uint64_t& target_msc,
+                                const uint64_t& divisor,
+                                const uint64_t& remainder) {
+  return Present::NotifyMSC(Present::NotifyMSCRequest{
+      window, serial, target_msc, divisor, remainder});
+}
+
+Future<void> Present::SelectInput(const Present::SelectInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& eid = request.eid;
+  auto& window = request.window;
+  auto& event_mask = request.event_mask;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // eid
+  buf.Write(&eid);
+
+  // window
+  buf.Write(&window);
+
+  // event_mask
+  uint32_t tmp2;
+  tmp2 = static_cast<uint32_t>(event_mask);
+  buf.Write(&tmp2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Present::SelectInput", false);
+}
+
+Future<void> Present::SelectInput(const Event& eid,
+                                  const Window& window,
+                                  const EventMask& event_mask) {
+  return Present::SelectInput(
+      Present::SelectInputRequest{eid, window, event_mask});
+}
+
+Future<Present::QueryCapabilitiesReply> Present::QueryCapabilities(
+    const Present::QueryCapabilitiesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& target = request.target;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // target
+  buf.Write(&target);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Present::QueryCapabilitiesReply>(
+      &buf, "Present::QueryCapabilities", false);
+}
+
+Future<Present::QueryCapabilitiesReply> Present::QueryCapabilities(
+    const uint32_t& target) {
+  return Present::QueryCapabilities(Present::QueryCapabilitiesRequest{target});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Present::QueryCapabilitiesReply> detail::ReadReply<
+    Present::QueryCapabilitiesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Present::QueryCapabilitiesReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& capabilities = (*reply).capabilities;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // capabilities
+  Read(&capabilities, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/present.h b/ui/gfx/x/generated_protos/present.h
new file mode 100644
index 0000000..dcfd695
--- /dev/null
+++ b/ui/gfx/x/generated_protos/present.h
@@ -0,0 +1,426 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_PRESENT_H_
+#define UI_GFX_X_GENERATED_PROTOS_PRESENT_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "randr.h"
+#include "sync.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xfixes.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Present {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 2;
+
+  Present(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Event : uint32_t {
+    ConfigureNotify = 0,
+    CompleteNotify = 1,
+    IdleNotify = 2,
+    RedirectNotify = 3,
+  };
+
+  enum class EventMask : int {
+    NoEvent = 0,
+    ConfigureNotify = 1 << 0,
+    CompleteNotify = 1 << 1,
+    IdleNotify = 1 << 2,
+    RedirectNotify = 1 << 3,
+  };
+
+  enum class Option : int {
+    None = 0,
+    Async = 1 << 0,
+    Copy = 1 << 1,
+    UST = 1 << 2,
+    Suboptimal = 1 << 3,
+  };
+
+  enum class Capability : int {
+    None = 0,
+    Async = 1 << 0,
+    Fence = 1 << 1,
+    UST = 1 << 2,
+  };
+
+  enum class CompleteKind : int {
+    Pixmap = 0,
+    NotifyMSC = 1,
+  };
+
+  enum class CompleteMode : int {
+    Copy = 0,
+    Flip = 1,
+    Skip = 2,
+    SuboptimalCopy = 3,
+  };
+
+  struct Notify {
+    Window window{};
+    uint32_t serial{};
+  };
+
+  struct GenericEvent {
+    static constexpr int type_id = 6;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint8_t extension{};
+    uint16_t sequence{};
+    uint32_t length{};
+    uint16_t evtype{};
+    Event event{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct ConfigureNotifyEvent {
+    static constexpr int type_id = 7;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint16_t sequence{};
+    Event event{};
+    Window window{};
+    int16_t x{};
+    int16_t y{};
+    uint16_t width{};
+    uint16_t height{};
+    int16_t off_x{};
+    int16_t off_y{};
+    uint16_t pixmap_width{};
+    uint16_t pixmap_height{};
+    uint32_t pixmap_flags{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct CompleteNotifyEvent {
+    static constexpr int type_id = 8;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint16_t sequence{};
+    CompleteKind kind{};
+    CompleteMode mode{};
+    Event event{};
+    Window window{};
+    uint32_t serial{};
+    uint64_t ust{};
+    uint64_t msc{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct IdleNotifyEvent {
+    static constexpr int type_id = 9;
+    static constexpr uint8_t opcode = 2;
+    bool send_event{};
+    uint16_t sequence{};
+    Event event{};
+    Window window{};
+    uint32_t serial{};
+    Pixmap pixmap{};
+    Sync::Fence idle_fence{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct RedirectNotifyEvent {
+    static constexpr int type_id = 10;
+    static constexpr uint8_t opcode = 3;
+    bool send_event{};
+    uint16_t sequence{};
+    uint8_t update_window{};
+    Event event{};
+    Window event_window{};
+    Window window{};
+    Pixmap pixmap{};
+    uint32_t serial{};
+    XFixes::Region valid_region{};
+    XFixes::Region update_region{};
+    Rectangle valid_rect{};
+    Rectangle update_rect{};
+    int16_t x_off{};
+    int16_t y_off{};
+    RandR::Crtc target_crtc{};
+    Sync::Fence wait_fence{};
+    Sync::Fence idle_fence{};
+    uint32_t options{};
+    uint64_t target_msc{};
+    uint64_t divisor{};
+    uint64_t remainder{};
+    std::vector<Notify> notifies{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct QueryVersionRequest {
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint32_t& major_version = {},
+                                         const uint32_t& minor_version = {});
+
+  struct PresentPixmapRequest {
+    Window window{};
+    Pixmap pixmap{};
+    uint32_t serial{};
+    XFixes::Region valid{};
+    XFixes::Region update{};
+    int16_t x_off{};
+    int16_t y_off{};
+    RandR::Crtc target_crtc{};
+    Sync::Fence wait_fence{};
+    Sync::Fence idle_fence{};
+    uint32_t options{};
+    uint64_t target_msc{};
+    uint64_t divisor{};
+    uint64_t remainder{};
+    std::vector<Notify> notifies{};
+  };
+
+  using PresentPixmapResponse = Response<void>;
+
+  Future<void> PresentPixmap(const PresentPixmapRequest& request);
+
+  Future<void> PresentPixmap(const Window& window = {},
+                             const Pixmap& pixmap = {},
+                             const uint32_t& serial = {},
+                             const XFixes::Region& valid = {},
+                             const XFixes::Region& update = {},
+                             const int16_t& x_off = {},
+                             const int16_t& y_off = {},
+                             const RandR::Crtc& target_crtc = {},
+                             const Sync::Fence& wait_fence = {},
+                             const Sync::Fence& idle_fence = {},
+                             const uint32_t& options = {},
+                             const uint64_t& target_msc = {},
+                             const uint64_t& divisor = {},
+                             const uint64_t& remainder = {},
+                             const std::vector<Notify>& notifies = {});
+
+  struct NotifyMSCRequest {
+    Window window{};
+    uint32_t serial{};
+    uint64_t target_msc{};
+    uint64_t divisor{};
+    uint64_t remainder{};
+  };
+
+  using NotifyMSCResponse = Response<void>;
+
+  Future<void> NotifyMSC(const NotifyMSCRequest& request);
+
+  Future<void> NotifyMSC(const Window& window = {},
+                         const uint32_t& serial = {},
+                         const uint64_t& target_msc = {},
+                         const uint64_t& divisor = {},
+                         const uint64_t& remainder = {});
+
+  struct SelectInputRequest {
+    Event eid{};
+    Window window{};
+    EventMask event_mask{};
+  };
+
+  using SelectInputResponse = Response<void>;
+
+  Future<void> SelectInput(const SelectInputRequest& request);
+
+  Future<void> SelectInput(const Event& eid = {},
+                           const Window& window = {},
+                           const EventMask& event_mask = {});
+
+  struct QueryCapabilitiesRequest {
+    uint32_t target{};
+  };
+
+  struct QueryCapabilitiesReply {
+    uint16_t sequence{};
+    uint32_t capabilities{};
+  };
+
+  using QueryCapabilitiesResponse = Response<QueryCapabilitiesReply>;
+
+  Future<QueryCapabilitiesReply> QueryCapabilities(
+      const QueryCapabilitiesRequest& request);
+
+  Future<QueryCapabilitiesReply> QueryCapabilities(const uint32_t& target = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Present::Event operator|(x11::Present::Event l,
+                                               x11::Present::Event r) {
+  using T = std::underlying_type_t<x11::Present::Event>;
+  return static_cast<x11::Present::Event>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Present::Event operator&(x11::Present::Event l,
+                                               x11::Present::Event r) {
+  using T = std::underlying_type_t<x11::Present::Event>;
+  return static_cast<x11::Present::Event>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Present::EventMask operator|(x11::Present::EventMask l,
+                                                   x11::Present::EventMask r) {
+  using T = std::underlying_type_t<x11::Present::EventMask>;
+  return static_cast<x11::Present::EventMask>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Present::EventMask operator&(x11::Present::EventMask l,
+                                                   x11::Present::EventMask r) {
+  using T = std::underlying_type_t<x11::Present::EventMask>;
+  return static_cast<x11::Present::EventMask>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Present::Option operator|(x11::Present::Option l,
+                                                x11::Present::Option r) {
+  using T = std::underlying_type_t<x11::Present::Option>;
+  return static_cast<x11::Present::Option>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Present::Option operator&(x11::Present::Option l,
+                                                x11::Present::Option r) {
+  using T = std::underlying_type_t<x11::Present::Option>;
+  return static_cast<x11::Present::Option>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Present::Capability operator|(
+    x11::Present::Capability l,
+    x11::Present::Capability r) {
+  using T = std::underlying_type_t<x11::Present::Capability>;
+  return static_cast<x11::Present::Capability>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Present::Capability operator&(
+    x11::Present::Capability l,
+    x11::Present::Capability r) {
+  using T = std::underlying_type_t<x11::Present::Capability>;
+  return static_cast<x11::Present::Capability>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Present::CompleteKind operator|(
+    x11::Present::CompleteKind l,
+    x11::Present::CompleteKind r) {
+  using T = std::underlying_type_t<x11::Present::CompleteKind>;
+  return static_cast<x11::Present::CompleteKind>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Present::CompleteKind operator&(
+    x11::Present::CompleteKind l,
+    x11::Present::CompleteKind r) {
+  using T = std::underlying_type_t<x11::Present::CompleteKind>;
+  return static_cast<x11::Present::CompleteKind>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Present::CompleteMode operator|(
+    x11::Present::CompleteMode l,
+    x11::Present::CompleteMode r) {
+  using T = std::underlying_type_t<x11::Present::CompleteMode>;
+  return static_cast<x11::Present::CompleteMode>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Present::CompleteMode operator&(
+    x11::Present::CompleteMode l,
+    x11::Present::CompleteMode r) {
+  using T = std::underlying_type_t<x11::Present::CompleteMode>;
+  return static_cast<x11::Present::CompleteMode>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_PRESENT_H_
diff --git a/ui/gfx/x/generated_protos/randr.cc b/ui/gfx/x/generated_protos/randr.cc
new file mode 100644
index 0000000..7228c86
--- /dev/null
+++ b/ui/gfx/x/generated_protos/randr.cc
@@ -0,0 +1,4599 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "randr.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+RandR::RandR(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string RandR::BadOutputError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "RandR::BadOutputError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<RandR::BadOutputError>(RandR::BadOutputError* error_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string RandR::BadCrtcError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "RandR::BadCrtcError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<RandR::BadCrtcError>(RandR::BadCrtcError* error_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string RandR::BadModeError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "RandR::BadModeError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<RandR::BadModeError>(RandR::BadModeError* error_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string RandR::BadProviderError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "RandR::BadProviderError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<RandR::BadProviderError>(RandR::BadProviderError* error_,
+                                        ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<RandR::ScreenChangeNotifyEvent>(
+    RandR::ScreenChangeNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& rotation = (*event_).rotation;
+  auto& sequence = (*event_).sequence;
+  auto& timestamp = (*event_).timestamp;
+  auto& config_timestamp = (*event_).config_timestamp;
+  auto& root = (*event_).root;
+  auto& request_window = (*event_).request_window;
+  auto& sizeID = (*event_).sizeID;
+  auto& subpixel_order = (*event_).subpixel_order;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+  auto& mwidth = (*event_).mwidth;
+  auto& mheight = (*event_).mheight;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // rotation
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  rotation = static_cast<RandR::Rotation>(tmp0);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // config_timestamp
+  Read(&config_timestamp, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // request_window
+  Read(&request_window, &buf);
+
+  // sizeID
+  Read(&sizeID, &buf);
+
+  // subpixel_order
+  uint16_t tmp1;
+  Read(&tmp1, &buf);
+  subpixel_order = static_cast<Render::SubPixel>(tmp1);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // mwidth
+  Read(&mwidth, &buf);
+
+  // mheight
+  Read(&mheight, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<RandR::NotifyEvent>(RandR::NotifyEvent* event_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  RandR::Notify subCode{};
+  auto& sequence = (*event_).sequence;
+  auto& data = (*event_);
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // subCode
+  uint8_t tmp2;
+  Read(&tmp2, &buf);
+  subCode = static_cast<RandR::Notify>(tmp2);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // data
+  auto data_expr = subCode;
+  if (CaseEq(data_expr, RandR::Notify::CrtcChange)) {
+    data.cc.emplace();
+    auto& timestamp = (*data.cc).timestamp;
+    auto& window = (*data.cc).window;
+    auto& crtc = (*data.cc).crtc;
+    auto& mode = (*data.cc).mode;
+    auto& rotation = (*data.cc).rotation;
+    auto& x = (*data.cc).x;
+    auto& y = (*data.cc).y;
+    auto& width = (*data.cc).width;
+    auto& height = (*data.cc).height;
+
+    // timestamp
+    Read(&timestamp, &buf);
+
+    // window
+    Read(&window, &buf);
+
+    // crtc
+    Read(&crtc, &buf);
+
+    // mode
+    Read(&mode, &buf);
+
+    // rotation
+    uint16_t tmp3;
+    Read(&tmp3, &buf);
+    rotation = static_cast<RandR::Rotation>(tmp3);
+
+    // pad0
+    Pad(&buf, 2);
+
+    // x
+    Read(&x, &buf);
+
+    // y
+    Read(&y, &buf);
+
+    // width
+    Read(&width, &buf);
+
+    // height
+    Read(&height, &buf);
+  }
+  if (CaseEq(data_expr, RandR::Notify::OutputChange)) {
+    data.oc.emplace();
+    auto& timestamp = (*data.oc).timestamp;
+    auto& config_timestamp = (*data.oc).config_timestamp;
+    auto& window = (*data.oc).window;
+    auto& output = (*data.oc).output;
+    auto& crtc = (*data.oc).crtc;
+    auto& mode = (*data.oc).mode;
+    auto& rotation = (*data.oc).rotation;
+    auto& connection = (*data.oc).connection;
+    auto& subpixel_order = (*data.oc).subpixel_order;
+
+    // timestamp
+    Read(&timestamp, &buf);
+
+    // config_timestamp
+    Read(&config_timestamp, &buf);
+
+    // window
+    Read(&window, &buf);
+
+    // output
+    Read(&output, &buf);
+
+    // crtc
+    Read(&crtc, &buf);
+
+    // mode
+    Read(&mode, &buf);
+
+    // rotation
+    uint16_t tmp4;
+    Read(&tmp4, &buf);
+    rotation = static_cast<RandR::Rotation>(tmp4);
+
+    // connection
+    uint8_t tmp5;
+    Read(&tmp5, &buf);
+    connection = static_cast<RandR::RandRConnection>(tmp5);
+
+    // subpixel_order
+    uint8_t tmp6;
+    Read(&tmp6, &buf);
+    subpixel_order = static_cast<Render::SubPixel>(tmp6);
+  }
+  if (CaseEq(data_expr, RandR::Notify::OutputProperty)) {
+    data.op.emplace();
+    auto& window = (*data.op).window;
+    auto& output = (*data.op).output;
+    auto& atom = (*data.op).atom;
+    auto& timestamp = (*data.op).timestamp;
+    auto& status = (*data.op).status;
+
+    // window
+    Read(&window, &buf);
+
+    // output
+    Read(&output, &buf);
+
+    // atom
+    Read(&atom, &buf);
+
+    // timestamp
+    Read(&timestamp, &buf);
+
+    // status
+    uint8_t tmp7;
+    Read(&tmp7, &buf);
+    status = static_cast<Property>(tmp7);
+
+    // pad1
+    Pad(&buf, 11);
+  }
+  if (CaseEq(data_expr, RandR::Notify::ProviderChange)) {
+    data.pc.emplace();
+    auto& timestamp = (*data.pc).timestamp;
+    auto& window = (*data.pc).window;
+    auto& provider = (*data.pc).provider;
+
+    // timestamp
+    Read(&timestamp, &buf);
+
+    // window
+    Read(&window, &buf);
+
+    // provider
+    Read(&provider, &buf);
+
+    // pad2
+    Pad(&buf, 16);
+  }
+  if (CaseEq(data_expr, RandR::Notify::ProviderProperty)) {
+    data.pp.emplace();
+    auto& window = (*data.pp).window;
+    auto& provider = (*data.pp).provider;
+    auto& atom = (*data.pp).atom;
+    auto& timestamp = (*data.pp).timestamp;
+    auto& state = (*data.pp).state;
+
+    // window
+    Read(&window, &buf);
+
+    // provider
+    Read(&provider, &buf);
+
+    // atom
+    Read(&atom, &buf);
+
+    // timestamp
+    Read(&timestamp, &buf);
+
+    // state
+    Read(&state, &buf);
+
+    // pad3
+    Pad(&buf, 11);
+  }
+  if (CaseEq(data_expr, RandR::Notify::ResourceChange)) {
+    data.rc.emplace();
+    auto& timestamp = (*data.rc).timestamp;
+    auto& window = (*data.rc).window;
+
+    // timestamp
+    Read(&timestamp, &buf);
+
+    // window
+    Read(&window, &buf);
+
+    // pad4
+    Pad(&buf, 20);
+  }
+  if (CaseEq(data_expr, RandR::Notify::Lease)) {
+    data.lc.emplace();
+    auto& timestamp = (*data.lc).timestamp;
+    auto& window = (*data.lc).window;
+    auto& lease = (*data.lc).lease;
+    auto& created = (*data.lc).created;
+
+    // timestamp
+    Read(&timestamp, &buf);
+
+    // window
+    Read(&window, &buf);
+
+    // lease
+    Read(&lease, &buf);
+
+    // created
+    Read(&created, &buf);
+
+    // pad5
+    Pad(&buf, 15);
+  }
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<RandR::QueryVersionReply> RandR::QueryVersion(
+    const RandR::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::QueryVersionReply>(
+      &buf, "RandR::QueryVersion", false);
+}
+
+Future<RandR::QueryVersionReply> RandR::QueryVersion(
+    const uint32_t& major_version,
+    const uint32_t& minor_version) {
+  return RandR::QueryVersion(
+      RandR::QueryVersionRequest{major_version, minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::QueryVersionReply> detail::ReadReply<
+    RandR::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::SetScreenConfigReply> RandR::SetScreenConfig(
+    const RandR::SetScreenConfigRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& timestamp = request.timestamp;
+  auto& config_timestamp = request.config_timestamp;
+  auto& sizeID = request.sizeID;
+  auto& rotation = request.rotation;
+  auto& rate = request.rate;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // timestamp
+  buf.Write(&timestamp);
+
+  // config_timestamp
+  buf.Write(&config_timestamp);
+
+  // sizeID
+  buf.Write(&sizeID);
+
+  // rotation
+  uint16_t tmp8;
+  tmp8 = static_cast<uint16_t>(rotation);
+  buf.Write(&tmp8);
+
+  // rate
+  buf.Write(&rate);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::SetScreenConfigReply>(
+      &buf, "RandR::SetScreenConfig", false);
+}
+
+Future<RandR::SetScreenConfigReply> RandR::SetScreenConfig(
+    const Window& window,
+    const Time& timestamp,
+    const Time& config_timestamp,
+    const uint16_t& sizeID,
+    const Rotation& rotation,
+    const uint16_t& rate) {
+  return RandR::SetScreenConfig(RandR::SetScreenConfigRequest{
+      window, timestamp, config_timestamp, sizeID, rotation, rate});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::SetScreenConfigReply> detail::ReadReply<
+    RandR::SetScreenConfigReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::SetScreenConfigReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+  auto& new_timestamp = (*reply).new_timestamp;
+  auto& config_timestamp = (*reply).config_timestamp;
+  auto& root = (*reply).root;
+  auto& subpixel_order = (*reply).subpixel_order;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp9;
+  Read(&tmp9, &buf);
+  status = static_cast<RandR::SetConfig>(tmp9);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // new_timestamp
+  Read(&new_timestamp, &buf);
+
+  // config_timestamp
+  Read(&config_timestamp, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // subpixel_order
+  uint16_t tmp10;
+  Read(&tmp10, &buf);
+  subpixel_order = static_cast<Render::SubPixel>(tmp10);
+
+  // pad0
+  Pad(&buf, 10);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::SelectInput(const RandR::SelectInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& enable = request.enable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // enable
+  uint16_t tmp11;
+  tmp11 = static_cast<uint16_t>(enable);
+  buf.Write(&tmp11);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::SelectInput", false);
+}
+
+Future<void> RandR::SelectInput(const Window& window,
+                                const NotifyMask& enable) {
+  return RandR::SelectInput(RandR::SelectInputRequest{window, enable});
+}
+
+Future<RandR::GetScreenInfoReply> RandR::GetScreenInfo(
+    const RandR::GetScreenInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetScreenInfoReply>(
+      &buf, "RandR::GetScreenInfo", false);
+}
+
+Future<RandR::GetScreenInfoReply> RandR::GetScreenInfo(const Window& window) {
+  return RandR::GetScreenInfo(RandR::GetScreenInfoRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetScreenInfoReply> detail::ReadReply<
+    RandR::GetScreenInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetScreenInfoReply>();
+
+  auto& rotations = (*reply).rotations;
+  auto& sequence = (*reply).sequence;
+  auto& root = (*reply).root;
+  auto& timestamp = (*reply).timestamp;
+  auto& config_timestamp = (*reply).config_timestamp;
+  uint16_t nSizes{};
+  auto& sizeID = (*reply).sizeID;
+  auto& rotation = (*reply).rotation;
+  auto& rate = (*reply).rate;
+  auto& nInfo = (*reply).nInfo;
+  auto& sizes = (*reply).sizes;
+  size_t sizes_len = sizes.size();
+  auto& rates = (*reply).rates;
+  size_t rates_len = rates.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // rotations
+  uint8_t tmp12;
+  Read(&tmp12, &buf);
+  rotations = static_cast<RandR::Rotation>(tmp12);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // config_timestamp
+  Read(&config_timestamp, &buf);
+
+  // nSizes
+  Read(&nSizes, &buf);
+
+  // sizeID
+  Read(&sizeID, &buf);
+
+  // rotation
+  uint16_t tmp13;
+  Read(&tmp13, &buf);
+  rotation = static_cast<RandR::Rotation>(tmp13);
+
+  // rate
+  Read(&rate, &buf);
+
+  // nInfo
+  Read(&nInfo, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // sizes
+  sizes.resize(nSizes);
+  for (auto& sizes_elem : sizes) {
+    // sizes_elem
+    {
+      auto& width = sizes_elem.width;
+      auto& height = sizes_elem.height;
+      auto& mwidth = sizes_elem.mwidth;
+      auto& mheight = sizes_elem.mheight;
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+
+      // mwidth
+      Read(&mwidth, &buf);
+
+      // mheight
+      Read(&mheight, &buf);
+    }
+  }
+
+  // rates
+  rates.resize((nInfo) - (nSizes));
+  for (auto& rates_elem : rates) {
+    // rates_elem
+    {
+      uint16_t nRates{};
+      auto& rates = rates_elem.rates;
+      size_t rates_len = rates.size();
+
+      // nRates
+      Read(&nRates, &buf);
+
+      // rates
+      rates.resize(nRates);
+      for (auto& rates_elem : rates) {
+        // rates_elem
+        Read(&rates_elem, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::GetScreenSizeRangeReply> RandR::GetScreenSizeRange(
+    const RandR::GetScreenSizeRangeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetScreenSizeRangeReply>(
+      &buf, "RandR::GetScreenSizeRange", false);
+}
+
+Future<RandR::GetScreenSizeRangeReply> RandR::GetScreenSizeRange(
+    const Window& window) {
+  return RandR::GetScreenSizeRange(RandR::GetScreenSizeRangeRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetScreenSizeRangeReply> detail::ReadReply<
+    RandR::GetScreenSizeRangeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetScreenSizeRangeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& min_width = (*reply).min_width;
+  auto& min_height = (*reply).min_height;
+  auto& max_width = (*reply).max_width;
+  auto& max_height = (*reply).max_height;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // min_width
+  Read(&min_width, &buf);
+
+  // min_height
+  Read(&min_height, &buf);
+
+  // max_width
+  Read(&max_width, &buf);
+
+  // max_height
+  Read(&max_height, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::SetScreenSize(const RandR::SetScreenSizeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& mm_width = request.mm_width;
+  auto& mm_height = request.mm_height;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // mm_width
+  buf.Write(&mm_width);
+
+  // mm_height
+  buf.Write(&mm_height);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::SetScreenSize", false);
+}
+
+Future<void> RandR::SetScreenSize(const Window& window,
+                                  const uint16_t& width,
+                                  const uint16_t& height,
+                                  const uint32_t& mm_width,
+                                  const uint32_t& mm_height) {
+  return RandR::SetScreenSize(
+      RandR::SetScreenSizeRequest{window, width, height, mm_width, mm_height});
+}
+
+Future<RandR::GetScreenResourcesReply> RandR::GetScreenResources(
+    const RandR::GetScreenResourcesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetScreenResourcesReply>(
+      &buf, "RandR::GetScreenResources", false);
+}
+
+Future<RandR::GetScreenResourcesReply> RandR::GetScreenResources(
+    const Window& window) {
+  return RandR::GetScreenResources(RandR::GetScreenResourcesRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetScreenResourcesReply> detail::ReadReply<
+    RandR::GetScreenResourcesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetScreenResourcesReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+  auto& config_timestamp = (*reply).config_timestamp;
+  uint16_t num_crtcs{};
+  uint16_t num_outputs{};
+  uint16_t num_modes{};
+  uint16_t names_len{};
+  auto& crtcs = (*reply).crtcs;
+  size_t crtcs_len = crtcs.size();
+  auto& outputs = (*reply).outputs;
+  size_t outputs_len = outputs.size();
+  auto& modes = (*reply).modes;
+  size_t modes_len = modes.size();
+  auto& names = (*reply).names;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // config_timestamp
+  Read(&config_timestamp, &buf);
+
+  // num_crtcs
+  Read(&num_crtcs, &buf);
+
+  // num_outputs
+  Read(&num_outputs, &buf);
+
+  // num_modes
+  Read(&num_modes, &buf);
+
+  // names_len
+  Read(&names_len, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // crtcs
+  crtcs.resize(num_crtcs);
+  for (auto& crtcs_elem : crtcs) {
+    // crtcs_elem
+    Read(&crtcs_elem, &buf);
+  }
+
+  // outputs
+  outputs.resize(num_outputs);
+  for (auto& outputs_elem : outputs) {
+    // outputs_elem
+    Read(&outputs_elem, &buf);
+  }
+
+  // modes
+  modes.resize(num_modes);
+  for (auto& modes_elem : modes) {
+    // modes_elem
+    {
+      auto& id = modes_elem.id;
+      auto& width = modes_elem.width;
+      auto& height = modes_elem.height;
+      auto& dot_clock = modes_elem.dot_clock;
+      auto& hsync_start = modes_elem.hsync_start;
+      auto& hsync_end = modes_elem.hsync_end;
+      auto& htotal = modes_elem.htotal;
+      auto& hskew = modes_elem.hskew;
+      auto& vsync_start = modes_elem.vsync_start;
+      auto& vsync_end = modes_elem.vsync_end;
+      auto& vtotal = modes_elem.vtotal;
+      auto& name_len = modes_elem.name_len;
+      auto& mode_flags = modes_elem.mode_flags;
+
+      // id
+      Read(&id, &buf);
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+
+      // dot_clock
+      Read(&dot_clock, &buf);
+
+      // hsync_start
+      Read(&hsync_start, &buf);
+
+      // hsync_end
+      Read(&hsync_end, &buf);
+
+      // htotal
+      Read(&htotal, &buf);
+
+      // hskew
+      Read(&hskew, &buf);
+
+      // vsync_start
+      Read(&vsync_start, &buf);
+
+      // vsync_end
+      Read(&vsync_end, &buf);
+
+      // vtotal
+      Read(&vtotal, &buf);
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // mode_flags
+      uint32_t tmp14;
+      Read(&tmp14, &buf);
+      mode_flags = static_cast<RandR::ModeFlag>(tmp14);
+    }
+  }
+
+  // names
+  names.resize(names_len);
+  for (auto& names_elem : names) {
+    // names_elem
+    Read(&names_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::GetOutputInfoReply> RandR::GetOutputInfo(
+    const RandR::GetOutputInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+  auto& config_timestamp = request.config_timestamp;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  // config_timestamp
+  buf.Write(&config_timestamp);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetOutputInfoReply>(
+      &buf, "RandR::GetOutputInfo", false);
+}
+
+Future<RandR::GetOutputInfoReply> RandR::GetOutputInfo(
+    const Output& output,
+    const Time& config_timestamp) {
+  return RandR::GetOutputInfo(
+      RandR::GetOutputInfoRequest{output, config_timestamp});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetOutputInfoReply> detail::ReadReply<
+    RandR::GetOutputInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetOutputInfoReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+  auto& crtc = (*reply).crtc;
+  auto& mm_width = (*reply).mm_width;
+  auto& mm_height = (*reply).mm_height;
+  auto& connection = (*reply).connection;
+  auto& subpixel_order = (*reply).subpixel_order;
+  uint16_t num_crtcs{};
+  uint16_t num_modes{};
+  auto& num_preferred = (*reply).num_preferred;
+  uint16_t num_clones{};
+  uint16_t name_len{};
+  auto& crtcs = (*reply).crtcs;
+  size_t crtcs_len = crtcs.size();
+  auto& modes = (*reply).modes;
+  size_t modes_len = modes.size();
+  auto& clones = (*reply).clones;
+  size_t clones_len = clones.size();
+  auto& name = (*reply).name;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp15;
+  Read(&tmp15, &buf);
+  status = static_cast<RandR::SetConfig>(tmp15);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // crtc
+  Read(&crtc, &buf);
+
+  // mm_width
+  Read(&mm_width, &buf);
+
+  // mm_height
+  Read(&mm_height, &buf);
+
+  // connection
+  uint8_t tmp16;
+  Read(&tmp16, &buf);
+  connection = static_cast<RandR::RandRConnection>(tmp16);
+
+  // subpixel_order
+  uint8_t tmp17;
+  Read(&tmp17, &buf);
+  subpixel_order = static_cast<Render::SubPixel>(tmp17);
+
+  // num_crtcs
+  Read(&num_crtcs, &buf);
+
+  // num_modes
+  Read(&num_modes, &buf);
+
+  // num_preferred
+  Read(&num_preferred, &buf);
+
+  // num_clones
+  Read(&num_clones, &buf);
+
+  // name_len
+  Read(&name_len, &buf);
+
+  // crtcs
+  crtcs.resize(num_crtcs);
+  for (auto& crtcs_elem : crtcs) {
+    // crtcs_elem
+    Read(&crtcs_elem, &buf);
+  }
+
+  // modes
+  modes.resize(num_modes);
+  for (auto& modes_elem : modes) {
+    // modes_elem
+    Read(&modes_elem, &buf);
+  }
+
+  // clones
+  clones.resize(num_clones);
+  for (auto& clones_elem : clones) {
+    // clones_elem
+    Read(&clones_elem, &buf);
+  }
+
+  // name
+  name.resize(name_len);
+  for (auto& name_elem : name) {
+    // name_elem
+    Read(&name_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::ListOutputPropertiesReply> RandR::ListOutputProperties(
+    const RandR::ListOutputPropertiesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::ListOutputPropertiesReply>(
+      &buf, "RandR::ListOutputProperties", false);
+}
+
+Future<RandR::ListOutputPropertiesReply> RandR::ListOutputProperties(
+    const Output& output) {
+  return RandR::ListOutputProperties(
+      RandR::ListOutputPropertiesRequest{output});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::ListOutputPropertiesReply> detail::ReadReply<
+    RandR::ListOutputPropertiesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::ListOutputPropertiesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t num_atoms{};
+  auto& atoms = (*reply).atoms;
+  size_t atoms_len = atoms.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_atoms
+  Read(&num_atoms, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // atoms
+  atoms.resize(num_atoms);
+  for (auto& atoms_elem : atoms) {
+    // atoms_elem
+    Read(&atoms_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::QueryOutputPropertyReply> RandR::QueryOutputProperty(
+    const RandR::QueryOutputPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+  auto& property = request.property;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  // property
+  buf.Write(&property);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::QueryOutputPropertyReply>(
+      &buf, "RandR::QueryOutputProperty", false);
+}
+
+Future<RandR::QueryOutputPropertyReply> RandR::QueryOutputProperty(
+    const Output& output,
+    const Atom& property) {
+  return RandR::QueryOutputProperty(
+      RandR::QueryOutputPropertyRequest{output, property});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::QueryOutputPropertyReply> detail::ReadReply<
+    RandR::QueryOutputPropertyReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::QueryOutputPropertyReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& pending = (*reply).pending;
+  auto& range = (*reply).range;
+  auto& immutable = (*reply).immutable;
+  auto& validValues = (*reply).validValues;
+  size_t validValues_len = validValues.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pending
+  Read(&pending, &buf);
+
+  // range
+  Read(&range, &buf);
+
+  // immutable
+  Read(&immutable, &buf);
+
+  // pad1
+  Pad(&buf, 21);
+
+  // validValues
+  validValues.resize(length);
+  for (auto& validValues_elem : validValues) {
+    // validValues_elem
+    Read(&validValues_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::ConfigureOutputProperty(
+    const RandR::ConfigureOutputPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+  auto& property = request.property;
+  auto& pending = request.pending;
+  auto& range = request.range;
+  auto& values = request.values;
+  size_t values_len = values.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  // property
+  buf.Write(&property);
+
+  // pending
+  buf.Write(&pending);
+
+  // range
+  buf.Write(&range);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // values
+  DCHECK_EQ(static_cast<size_t>(values_len), values.size());
+  for (auto& values_elem : values) {
+    // values_elem
+    buf.Write(&values_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::ConfigureOutputProperty",
+                                        false);
+}
+
+Future<void> RandR::ConfigureOutputProperty(
+    const Output& output,
+    const Atom& property,
+    const uint8_t& pending,
+    const uint8_t& range,
+    const std::vector<int32_t>& values) {
+  return RandR::ConfigureOutputProperty(RandR::ConfigureOutputPropertyRequest{
+      output, property, pending, range, values});
+}
+
+Future<void> RandR::ChangeOutputProperty(
+    const RandR::ChangeOutputPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& format = request.format;
+  auto& mode = request.mode;
+  auto& num_units = request.num_units;
+  auto& data = request.data;
+  size_t data_len = data ? data->size() : 0;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // format
+  buf.Write(&format);
+
+  // mode
+  uint8_t tmp18;
+  tmp18 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp18);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // num_units
+  buf.Write(&num_units);
+
+  // data
+  buf.AppendBuffer(data, ((num_units) * (format)) / (8));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::ChangeOutputProperty",
+                                        false);
+}
+
+Future<void> RandR::ChangeOutputProperty(
+    const Output& output,
+    const Atom& property,
+    const Atom& type,
+    const uint8_t& format,
+    const PropMode& mode,
+    const uint32_t& num_units,
+    const scoped_refptr<base::RefCountedMemory>& data) {
+  return RandR::ChangeOutputProperty(RandR::ChangeOutputPropertyRequest{
+      output, property, type, format, mode, num_units, data});
+}
+
+Future<void> RandR::DeleteOutputProperty(
+    const RandR::DeleteOutputPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+  auto& property = request.property;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  // property
+  buf.Write(&property);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::DeleteOutputProperty",
+                                        false);
+}
+
+Future<void> RandR::DeleteOutputProperty(const Output& output,
+                                         const Atom& property) {
+  return RandR::DeleteOutputProperty(
+      RandR::DeleteOutputPropertyRequest{output, property});
+}
+
+Future<RandR::GetOutputPropertyReply> RandR::GetOutputProperty(
+    const RandR::GetOutputPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& long_offset = request.long_offset;
+  auto& long_length = request.long_length;
+  auto& c_delete = request.c_delete;
+  auto& pending = request.pending;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // long_offset
+  buf.Write(&long_offset);
+
+  // long_length
+  buf.Write(&long_length);
+
+  // c_delete
+  buf.Write(&c_delete);
+
+  // pending
+  buf.Write(&pending);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetOutputPropertyReply>(
+      &buf, "RandR::GetOutputProperty", false);
+}
+
+Future<RandR::GetOutputPropertyReply> RandR::GetOutputProperty(
+    const Output& output,
+    const Atom& property,
+    const Atom& type,
+    const uint32_t& long_offset,
+    const uint32_t& long_length,
+    const uint8_t& c_delete,
+    const uint8_t& pending) {
+  return RandR::GetOutputProperty(RandR::GetOutputPropertyRequest{
+      output, property, type, long_offset, long_length, c_delete, pending});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetOutputPropertyReply> detail::ReadReply<
+    RandR::GetOutputPropertyReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetOutputPropertyReply>();
+
+  auto& format = (*reply).format;
+  auto& sequence = (*reply).sequence;
+  auto& type = (*reply).type;
+  auto& bytes_after = (*reply).bytes_after;
+  auto& num_items = (*reply).num_items;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // format
+  Read(&format, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // type
+  Read(&type, &buf);
+
+  // bytes_after
+  Read(&bytes_after, &buf);
+
+  // num_items
+  Read(&num_items, &buf);
+
+  // pad0
+  Pad(&buf, 12);
+
+  // data
+  data.resize((num_items) * ((format) / (8)));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::CreateModeReply> RandR::CreateMode(
+    const RandR::CreateModeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& mode_info = request.mode_info;
+  auto& name = request.name;
+  size_t name_len = name.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // mode_info
+  {
+    auto& id = mode_info.id;
+    auto& width = mode_info.width;
+    auto& height = mode_info.height;
+    auto& dot_clock = mode_info.dot_clock;
+    auto& hsync_start = mode_info.hsync_start;
+    auto& hsync_end = mode_info.hsync_end;
+    auto& htotal = mode_info.htotal;
+    auto& hskew = mode_info.hskew;
+    auto& vsync_start = mode_info.vsync_start;
+    auto& vsync_end = mode_info.vsync_end;
+    auto& vtotal = mode_info.vtotal;
+    auto& name_len = mode_info.name_len;
+    auto& mode_flags = mode_info.mode_flags;
+
+    // id
+    buf.Write(&id);
+
+    // width
+    buf.Write(&width);
+
+    // height
+    buf.Write(&height);
+
+    // dot_clock
+    buf.Write(&dot_clock);
+
+    // hsync_start
+    buf.Write(&hsync_start);
+
+    // hsync_end
+    buf.Write(&hsync_end);
+
+    // htotal
+    buf.Write(&htotal);
+
+    // hskew
+    buf.Write(&hskew);
+
+    // vsync_start
+    buf.Write(&vsync_start);
+
+    // vsync_end
+    buf.Write(&vsync_end);
+
+    // vtotal
+    buf.Write(&vtotal);
+
+    // name_len
+    buf.Write(&name_len);
+
+    // mode_flags
+    uint32_t tmp19;
+    tmp19 = static_cast<uint32_t>(mode_flags);
+    buf.Write(&tmp19);
+  }
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::CreateModeReply>(
+      &buf, "RandR::CreateMode", false);
+}
+
+Future<RandR::CreateModeReply> RandR::CreateMode(const Window& window,
+                                                 const ModeInfo& mode_info,
+                                                 const std::string& name) {
+  return RandR::CreateMode(RandR::CreateModeRequest{window, mode_info, name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::CreateModeReply> detail::ReadReply<
+    RandR::CreateModeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::CreateModeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& mode = (*reply).mode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // mode
+  Read(&mode, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::DestroyMode(const RandR::DestroyModeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // mode
+  buf.Write(&mode);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::DestroyMode", false);
+}
+
+Future<void> RandR::DestroyMode(const Mode& mode) {
+  return RandR::DestroyMode(RandR::DestroyModeRequest{mode});
+}
+
+Future<void> RandR::AddOutputMode(const RandR::AddOutputModeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  // mode
+  buf.Write(&mode);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::AddOutputMode", false);
+}
+
+Future<void> RandR::AddOutputMode(const Output& output, const Mode& mode) {
+  return RandR::AddOutputMode(RandR::AddOutputModeRequest{output, mode});
+}
+
+Future<void> RandR::DeleteOutputMode(
+    const RandR::DeleteOutputModeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output = request.output;
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output
+  buf.Write(&output);
+
+  // mode
+  buf.Write(&mode);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::DeleteOutputMode", false);
+}
+
+Future<void> RandR::DeleteOutputMode(const Output& output, const Mode& mode) {
+  return RandR::DeleteOutputMode(RandR::DeleteOutputModeRequest{output, mode});
+}
+
+Future<RandR::GetCrtcInfoReply> RandR::GetCrtcInfo(
+    const RandR::GetCrtcInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+  auto& config_timestamp = request.config_timestamp;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 20;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  // config_timestamp
+  buf.Write(&config_timestamp);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetCrtcInfoReply>(
+      &buf, "RandR::GetCrtcInfo", false);
+}
+
+Future<RandR::GetCrtcInfoReply> RandR::GetCrtcInfo(
+    const Crtc& crtc,
+    const Time& config_timestamp) {
+  return RandR::GetCrtcInfo(RandR::GetCrtcInfoRequest{crtc, config_timestamp});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetCrtcInfoReply> detail::ReadReply<
+    RandR::GetCrtcInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetCrtcInfoReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+  auto& x = (*reply).x;
+  auto& y = (*reply).y;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& mode = (*reply).mode;
+  auto& rotation = (*reply).rotation;
+  auto& rotations = (*reply).rotations;
+  uint16_t num_outputs{};
+  uint16_t num_possible_outputs{};
+  auto& outputs = (*reply).outputs;
+  size_t outputs_len = outputs.size();
+  auto& possible = (*reply).possible;
+  size_t possible_len = possible.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp20;
+  Read(&tmp20, &buf);
+  status = static_cast<RandR::SetConfig>(tmp20);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // mode
+  Read(&mode, &buf);
+
+  // rotation
+  uint16_t tmp21;
+  Read(&tmp21, &buf);
+  rotation = static_cast<RandR::Rotation>(tmp21);
+
+  // rotations
+  uint16_t tmp22;
+  Read(&tmp22, &buf);
+  rotations = static_cast<RandR::Rotation>(tmp22);
+
+  // num_outputs
+  Read(&num_outputs, &buf);
+
+  // num_possible_outputs
+  Read(&num_possible_outputs, &buf);
+
+  // outputs
+  outputs.resize(num_outputs);
+  for (auto& outputs_elem : outputs) {
+    // outputs_elem
+    Read(&outputs_elem, &buf);
+  }
+
+  // possible
+  possible.resize(num_possible_outputs);
+  for (auto& possible_elem : possible) {
+    // possible_elem
+    Read(&possible_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::SetCrtcConfigReply> RandR::SetCrtcConfig(
+    const RandR::SetCrtcConfigRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+  auto& timestamp = request.timestamp;
+  auto& config_timestamp = request.config_timestamp;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& mode = request.mode;
+  auto& rotation = request.rotation;
+  auto& outputs = request.outputs;
+  size_t outputs_len = outputs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 21;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  // timestamp
+  buf.Write(&timestamp);
+
+  // config_timestamp
+  buf.Write(&config_timestamp);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // mode
+  buf.Write(&mode);
+
+  // rotation
+  uint16_t tmp23;
+  tmp23 = static_cast<uint16_t>(rotation);
+  buf.Write(&tmp23);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // outputs
+  DCHECK_EQ(static_cast<size_t>(outputs_len), outputs.size());
+  for (auto& outputs_elem : outputs) {
+    // outputs_elem
+    buf.Write(&outputs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::SetCrtcConfigReply>(
+      &buf, "RandR::SetCrtcConfig", false);
+}
+
+Future<RandR::SetCrtcConfigReply> RandR::SetCrtcConfig(
+    const Crtc& crtc,
+    const Time& timestamp,
+    const Time& config_timestamp,
+    const int16_t& x,
+    const int16_t& y,
+    const Mode& mode,
+    const Rotation& rotation,
+    const std::vector<Output>& outputs) {
+  return RandR::SetCrtcConfig(RandR::SetCrtcConfigRequest{
+      crtc, timestamp, config_timestamp, x, y, mode, rotation, outputs});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::SetCrtcConfigReply> detail::ReadReply<
+    RandR::SetCrtcConfigReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::SetCrtcConfigReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp24;
+  Read(&tmp24, &buf);
+  status = static_cast<RandR::SetConfig>(tmp24);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // pad0
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::GetCrtcGammaSizeReply> RandR::GetCrtcGammaSize(
+    const RandR::GetCrtcGammaSizeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 22;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetCrtcGammaSizeReply>(
+      &buf, "RandR::GetCrtcGammaSize", false);
+}
+
+Future<RandR::GetCrtcGammaSizeReply> RandR::GetCrtcGammaSize(const Crtc& crtc) {
+  return RandR::GetCrtcGammaSize(RandR::GetCrtcGammaSizeRequest{crtc});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetCrtcGammaSizeReply> detail::ReadReply<
+    RandR::GetCrtcGammaSizeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetCrtcGammaSizeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& size = (*reply).size;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // size
+  Read(&size, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::GetCrtcGammaReply> RandR::GetCrtcGamma(
+    const RandR::GetCrtcGammaRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 23;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetCrtcGammaReply>(
+      &buf, "RandR::GetCrtcGamma", false);
+}
+
+Future<RandR::GetCrtcGammaReply> RandR::GetCrtcGamma(const Crtc& crtc) {
+  return RandR::GetCrtcGamma(RandR::GetCrtcGammaRequest{crtc});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetCrtcGammaReply> detail::ReadReply<
+    RandR::GetCrtcGammaReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetCrtcGammaReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t size{};
+  auto& red = (*reply).red;
+  size_t red_len = red.size();
+  auto& green = (*reply).green;
+  size_t green_len = green.size();
+  auto& blue = (*reply).blue;
+  size_t blue_len = blue.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // size
+  Read(&size, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // red
+  red.resize(size);
+  for (auto& red_elem : red) {
+    // red_elem
+    Read(&red_elem, &buf);
+  }
+
+  // green
+  green.resize(size);
+  for (auto& green_elem : green) {
+    // green_elem
+    Read(&green_elem, &buf);
+  }
+
+  // blue
+  blue.resize(size);
+  for (auto& blue_elem : blue) {
+    // blue_elem
+    Read(&blue_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::SetCrtcGamma(const RandR::SetCrtcGammaRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+  uint16_t size{};
+  auto& red = request.red;
+  size_t red_len = red.size();
+  auto& green = request.green;
+  size_t green_len = green.size();
+  auto& blue = request.blue;
+  size_t blue_len = blue.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 24;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  // size
+  size = red.size();
+  buf.Write(&size);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // red
+  DCHECK_EQ(static_cast<size_t>(size), red.size());
+  for (auto& red_elem : red) {
+    // red_elem
+    buf.Write(&red_elem);
+  }
+
+  // green
+  DCHECK_EQ(static_cast<size_t>(size), green.size());
+  for (auto& green_elem : green) {
+    // green_elem
+    buf.Write(&green_elem);
+  }
+
+  // blue
+  DCHECK_EQ(static_cast<size_t>(size), blue.size());
+  for (auto& blue_elem : blue) {
+    // blue_elem
+    buf.Write(&blue_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::SetCrtcGamma", false);
+}
+
+Future<void> RandR::SetCrtcGamma(const Crtc& crtc,
+                                 const std::vector<uint16_t>& red,
+                                 const std::vector<uint16_t>& green,
+                                 const std::vector<uint16_t>& blue) {
+  return RandR::SetCrtcGamma(
+      RandR::SetCrtcGammaRequest{crtc, red, green, blue});
+}
+
+Future<RandR::GetScreenResourcesCurrentReply> RandR::GetScreenResourcesCurrent(
+    const RandR::GetScreenResourcesCurrentRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 25;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetScreenResourcesCurrentReply>(
+      &buf, "RandR::GetScreenResourcesCurrent", false);
+}
+
+Future<RandR::GetScreenResourcesCurrentReply> RandR::GetScreenResourcesCurrent(
+    const Window& window) {
+  return RandR::GetScreenResourcesCurrent(
+      RandR::GetScreenResourcesCurrentRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetScreenResourcesCurrentReply> detail::ReadReply<
+    RandR::GetScreenResourcesCurrentReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetScreenResourcesCurrentReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+  auto& config_timestamp = (*reply).config_timestamp;
+  uint16_t num_crtcs{};
+  uint16_t num_outputs{};
+  uint16_t num_modes{};
+  uint16_t names_len{};
+  auto& crtcs = (*reply).crtcs;
+  size_t crtcs_len = crtcs.size();
+  auto& outputs = (*reply).outputs;
+  size_t outputs_len = outputs.size();
+  auto& modes = (*reply).modes;
+  size_t modes_len = modes.size();
+  auto& names = (*reply).names;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // config_timestamp
+  Read(&config_timestamp, &buf);
+
+  // num_crtcs
+  Read(&num_crtcs, &buf);
+
+  // num_outputs
+  Read(&num_outputs, &buf);
+
+  // num_modes
+  Read(&num_modes, &buf);
+
+  // names_len
+  Read(&names_len, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // crtcs
+  crtcs.resize(num_crtcs);
+  for (auto& crtcs_elem : crtcs) {
+    // crtcs_elem
+    Read(&crtcs_elem, &buf);
+  }
+
+  // outputs
+  outputs.resize(num_outputs);
+  for (auto& outputs_elem : outputs) {
+    // outputs_elem
+    Read(&outputs_elem, &buf);
+  }
+
+  // modes
+  modes.resize(num_modes);
+  for (auto& modes_elem : modes) {
+    // modes_elem
+    {
+      auto& id = modes_elem.id;
+      auto& width = modes_elem.width;
+      auto& height = modes_elem.height;
+      auto& dot_clock = modes_elem.dot_clock;
+      auto& hsync_start = modes_elem.hsync_start;
+      auto& hsync_end = modes_elem.hsync_end;
+      auto& htotal = modes_elem.htotal;
+      auto& hskew = modes_elem.hskew;
+      auto& vsync_start = modes_elem.vsync_start;
+      auto& vsync_end = modes_elem.vsync_end;
+      auto& vtotal = modes_elem.vtotal;
+      auto& name_len = modes_elem.name_len;
+      auto& mode_flags = modes_elem.mode_flags;
+
+      // id
+      Read(&id, &buf);
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+
+      // dot_clock
+      Read(&dot_clock, &buf);
+
+      // hsync_start
+      Read(&hsync_start, &buf);
+
+      // hsync_end
+      Read(&hsync_end, &buf);
+
+      // htotal
+      Read(&htotal, &buf);
+
+      // hskew
+      Read(&hskew, &buf);
+
+      // vsync_start
+      Read(&vsync_start, &buf);
+
+      // vsync_end
+      Read(&vsync_end, &buf);
+
+      // vtotal
+      Read(&vtotal, &buf);
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // mode_flags
+      uint32_t tmp25;
+      Read(&tmp25, &buf);
+      mode_flags = static_cast<RandR::ModeFlag>(tmp25);
+    }
+  }
+
+  // names
+  names.resize(names_len);
+  for (auto& names_elem : names) {
+    // names_elem
+    Read(&names_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::SetCrtcTransform(
+    const RandR::SetCrtcTransformRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+  auto& transform = request.transform;
+  uint16_t filter_len{};
+  auto& filter_name = request.filter_name;
+  size_t filter_name_len = filter_name.size();
+  auto& filter_params = request.filter_params;
+  size_t filter_params_len = filter_params.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 26;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  // transform
+  {
+    auto& matrix11 = transform.matrix11;
+    auto& matrix12 = transform.matrix12;
+    auto& matrix13 = transform.matrix13;
+    auto& matrix21 = transform.matrix21;
+    auto& matrix22 = transform.matrix22;
+    auto& matrix23 = transform.matrix23;
+    auto& matrix31 = transform.matrix31;
+    auto& matrix32 = transform.matrix32;
+    auto& matrix33 = transform.matrix33;
+
+    // matrix11
+    buf.Write(&matrix11);
+
+    // matrix12
+    buf.Write(&matrix12);
+
+    // matrix13
+    buf.Write(&matrix13);
+
+    // matrix21
+    buf.Write(&matrix21);
+
+    // matrix22
+    buf.Write(&matrix22);
+
+    // matrix23
+    buf.Write(&matrix23);
+
+    // matrix31
+    buf.Write(&matrix31);
+
+    // matrix32
+    buf.Write(&matrix32);
+
+    // matrix33
+    buf.Write(&matrix33);
+  }
+
+  // filter_len
+  filter_len = filter_name.size();
+  buf.Write(&filter_len);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // filter_name
+  DCHECK_EQ(static_cast<size_t>(filter_len), filter_name.size());
+  for (auto& filter_name_elem : filter_name) {
+    // filter_name_elem
+    buf.Write(&filter_name_elem);
+  }
+
+  // pad1
+  Align(&buf, 4);
+
+  // filter_params
+  DCHECK_EQ(static_cast<size_t>(filter_params_len), filter_params.size());
+  for (auto& filter_params_elem : filter_params) {
+    // filter_params_elem
+    buf.Write(&filter_params_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::SetCrtcTransform", false);
+}
+
+Future<void> RandR::SetCrtcTransform(
+    const Crtc& crtc,
+    const Render::Transform& transform,
+    const std::string& filter_name,
+    const std::vector<Render::Fixed>& filter_params) {
+  return RandR::SetCrtcTransform(RandR::SetCrtcTransformRequest{
+      crtc, transform, filter_name, filter_params});
+}
+
+Future<RandR::GetCrtcTransformReply> RandR::GetCrtcTransform(
+    const RandR::GetCrtcTransformRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 27;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetCrtcTransformReply>(
+      &buf, "RandR::GetCrtcTransform", false);
+}
+
+Future<RandR::GetCrtcTransformReply> RandR::GetCrtcTransform(const Crtc& crtc) {
+  return RandR::GetCrtcTransform(RandR::GetCrtcTransformRequest{crtc});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetCrtcTransformReply> detail::ReadReply<
+    RandR::GetCrtcTransformReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetCrtcTransformReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& pending_transform = (*reply).pending_transform;
+  auto& has_transforms = (*reply).has_transforms;
+  auto& current_transform = (*reply).current_transform;
+  uint16_t pending_len{};
+  uint16_t pending_nparams{};
+  uint16_t current_len{};
+  uint16_t current_nparams{};
+  auto& pending_filter_name = (*reply).pending_filter_name;
+  size_t pending_filter_name_len = pending_filter_name.size();
+  auto& pending_params = (*reply).pending_params;
+  size_t pending_params_len = pending_params.size();
+  auto& current_filter_name = (*reply).current_filter_name;
+  size_t current_filter_name_len = current_filter_name.size();
+  auto& current_params = (*reply).current_params;
+  size_t current_params_len = current_params.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pending_transform
+  {
+    auto& matrix11 = pending_transform.matrix11;
+    auto& matrix12 = pending_transform.matrix12;
+    auto& matrix13 = pending_transform.matrix13;
+    auto& matrix21 = pending_transform.matrix21;
+    auto& matrix22 = pending_transform.matrix22;
+    auto& matrix23 = pending_transform.matrix23;
+    auto& matrix31 = pending_transform.matrix31;
+    auto& matrix32 = pending_transform.matrix32;
+    auto& matrix33 = pending_transform.matrix33;
+
+    // matrix11
+    Read(&matrix11, &buf);
+
+    // matrix12
+    Read(&matrix12, &buf);
+
+    // matrix13
+    Read(&matrix13, &buf);
+
+    // matrix21
+    Read(&matrix21, &buf);
+
+    // matrix22
+    Read(&matrix22, &buf);
+
+    // matrix23
+    Read(&matrix23, &buf);
+
+    // matrix31
+    Read(&matrix31, &buf);
+
+    // matrix32
+    Read(&matrix32, &buf);
+
+    // matrix33
+    Read(&matrix33, &buf);
+  }
+
+  // has_transforms
+  Read(&has_transforms, &buf);
+
+  // pad1
+  Pad(&buf, 3);
+
+  // current_transform
+  {
+    auto& matrix11 = current_transform.matrix11;
+    auto& matrix12 = current_transform.matrix12;
+    auto& matrix13 = current_transform.matrix13;
+    auto& matrix21 = current_transform.matrix21;
+    auto& matrix22 = current_transform.matrix22;
+    auto& matrix23 = current_transform.matrix23;
+    auto& matrix31 = current_transform.matrix31;
+    auto& matrix32 = current_transform.matrix32;
+    auto& matrix33 = current_transform.matrix33;
+
+    // matrix11
+    Read(&matrix11, &buf);
+
+    // matrix12
+    Read(&matrix12, &buf);
+
+    // matrix13
+    Read(&matrix13, &buf);
+
+    // matrix21
+    Read(&matrix21, &buf);
+
+    // matrix22
+    Read(&matrix22, &buf);
+
+    // matrix23
+    Read(&matrix23, &buf);
+
+    // matrix31
+    Read(&matrix31, &buf);
+
+    // matrix32
+    Read(&matrix32, &buf);
+
+    // matrix33
+    Read(&matrix33, &buf);
+  }
+
+  // pad2
+  Pad(&buf, 4);
+
+  // pending_len
+  Read(&pending_len, &buf);
+
+  // pending_nparams
+  Read(&pending_nparams, &buf);
+
+  // current_len
+  Read(&current_len, &buf);
+
+  // current_nparams
+  Read(&current_nparams, &buf);
+
+  // pending_filter_name
+  pending_filter_name.resize(pending_len);
+  for (auto& pending_filter_name_elem : pending_filter_name) {
+    // pending_filter_name_elem
+    Read(&pending_filter_name_elem, &buf);
+  }
+
+  // pad3
+  Align(&buf, 4);
+
+  // pending_params
+  pending_params.resize(pending_nparams);
+  for (auto& pending_params_elem : pending_params) {
+    // pending_params_elem
+    Read(&pending_params_elem, &buf);
+  }
+
+  // current_filter_name
+  current_filter_name.resize(current_len);
+  for (auto& current_filter_name_elem : current_filter_name) {
+    // current_filter_name_elem
+    Read(&current_filter_name_elem, &buf);
+  }
+
+  // pad4
+  Align(&buf, 4);
+
+  // current_params
+  current_params.resize(current_nparams);
+  for (auto& current_params_elem : current_params) {
+    // current_params_elem
+    Read(&current_params_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::GetPanningReply> RandR::GetPanning(
+    const RandR::GetPanningRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 28;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetPanningReply>(
+      &buf, "RandR::GetPanning", false);
+}
+
+Future<RandR::GetPanningReply> RandR::GetPanning(const Crtc& crtc) {
+  return RandR::GetPanning(RandR::GetPanningRequest{crtc});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetPanningReply> detail::ReadReply<
+    RandR::GetPanningReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetPanningReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+  auto& left = (*reply).left;
+  auto& top = (*reply).top;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& track_left = (*reply).track_left;
+  auto& track_top = (*reply).track_top;
+  auto& track_width = (*reply).track_width;
+  auto& track_height = (*reply).track_height;
+  auto& border_left = (*reply).border_left;
+  auto& border_top = (*reply).border_top;
+  auto& border_right = (*reply).border_right;
+  auto& border_bottom = (*reply).border_bottom;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp26;
+  Read(&tmp26, &buf);
+  status = static_cast<RandR::SetConfig>(tmp26);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // left
+  Read(&left, &buf);
+
+  // top
+  Read(&top, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // track_left
+  Read(&track_left, &buf);
+
+  // track_top
+  Read(&track_top, &buf);
+
+  // track_width
+  Read(&track_width, &buf);
+
+  // track_height
+  Read(&track_height, &buf);
+
+  // border_left
+  Read(&border_left, &buf);
+
+  // border_top
+  Read(&border_top, &buf);
+
+  // border_right
+  Read(&border_right, &buf);
+
+  // border_bottom
+  Read(&border_bottom, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::SetPanningReply> RandR::SetPanning(
+    const RandR::SetPanningRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& crtc = request.crtc;
+  auto& timestamp = request.timestamp;
+  auto& left = request.left;
+  auto& top = request.top;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& track_left = request.track_left;
+  auto& track_top = request.track_top;
+  auto& track_width = request.track_width;
+  auto& track_height = request.track_height;
+  auto& border_left = request.border_left;
+  auto& border_top = request.border_top;
+  auto& border_right = request.border_right;
+  auto& border_bottom = request.border_bottom;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 29;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // crtc
+  buf.Write(&crtc);
+
+  // timestamp
+  buf.Write(&timestamp);
+
+  // left
+  buf.Write(&left);
+
+  // top
+  buf.Write(&top);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // track_left
+  buf.Write(&track_left);
+
+  // track_top
+  buf.Write(&track_top);
+
+  // track_width
+  buf.Write(&track_width);
+
+  // track_height
+  buf.Write(&track_height);
+
+  // border_left
+  buf.Write(&border_left);
+
+  // border_top
+  buf.Write(&border_top);
+
+  // border_right
+  buf.Write(&border_right);
+
+  // border_bottom
+  buf.Write(&border_bottom);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::SetPanningReply>(
+      &buf, "RandR::SetPanning", false);
+}
+
+Future<RandR::SetPanningReply> RandR::SetPanning(const Crtc& crtc,
+                                                 const Time& timestamp,
+                                                 const uint16_t& left,
+                                                 const uint16_t& top,
+                                                 const uint16_t& width,
+                                                 const uint16_t& height,
+                                                 const uint16_t& track_left,
+                                                 const uint16_t& track_top,
+                                                 const uint16_t& track_width,
+                                                 const uint16_t& track_height,
+                                                 const int16_t& border_left,
+                                                 const int16_t& border_top,
+                                                 const int16_t& border_right,
+                                                 const int16_t& border_bottom) {
+  return RandR::SetPanning(RandR::SetPanningRequest{
+      crtc, timestamp, left, top, width, height, track_left, track_top,
+      track_width, track_height, border_left, border_top, border_right,
+      border_bottom});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::SetPanningReply> detail::ReadReply<
+    RandR::SetPanningReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::SetPanningReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp27;
+  Read(&tmp27, &buf);
+  status = static_cast<RandR::SetConfig>(tmp27);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::SetOutputPrimary(
+    const RandR::SetOutputPrimaryRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& output = request.output;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 30;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // output
+  buf.Write(&output);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::SetOutputPrimary", false);
+}
+
+Future<void> RandR::SetOutputPrimary(const Window& window,
+                                     const Output& output) {
+  return RandR::SetOutputPrimary(
+      RandR::SetOutputPrimaryRequest{window, output});
+}
+
+Future<RandR::GetOutputPrimaryReply> RandR::GetOutputPrimary(
+    const RandR::GetOutputPrimaryRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 31;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetOutputPrimaryReply>(
+      &buf, "RandR::GetOutputPrimary", false);
+}
+
+Future<RandR::GetOutputPrimaryReply> RandR::GetOutputPrimary(
+    const Window& window) {
+  return RandR::GetOutputPrimary(RandR::GetOutputPrimaryRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetOutputPrimaryReply> detail::ReadReply<
+    RandR::GetOutputPrimaryReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetOutputPrimaryReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& output = (*reply).output;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // output
+  Read(&output, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::GetProvidersReply> RandR::GetProviders(
+    const RandR::GetProvidersRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 32;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetProvidersReply>(
+      &buf, "RandR::GetProviders", false);
+}
+
+Future<RandR::GetProvidersReply> RandR::GetProviders(const Window& window) {
+  return RandR::GetProviders(RandR::GetProvidersRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetProvidersReply> detail::ReadReply<
+    RandR::GetProvidersReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetProvidersReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+  uint16_t num_providers{};
+  auto& providers = (*reply).providers;
+  size_t providers_len = providers.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // num_providers
+  Read(&num_providers, &buf);
+
+  // pad1
+  Pad(&buf, 18);
+
+  // providers
+  providers.resize(num_providers);
+  for (auto& providers_elem : providers) {
+    // providers_elem
+    Read(&providers_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::GetProviderInfoReply> RandR::GetProviderInfo(
+    const RandR::GetProviderInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+  auto& config_timestamp = request.config_timestamp;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 33;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  // config_timestamp
+  buf.Write(&config_timestamp);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetProviderInfoReply>(
+      &buf, "RandR::GetProviderInfo", false);
+}
+
+Future<RandR::GetProviderInfoReply> RandR::GetProviderInfo(
+    const Provider& provider,
+    const Time& config_timestamp) {
+  return RandR::GetProviderInfo(
+      RandR::GetProviderInfoRequest{provider, config_timestamp});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetProviderInfoReply> detail::ReadReply<
+    RandR::GetProviderInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetProviderInfoReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+  auto& capabilities = (*reply).capabilities;
+  uint16_t num_crtcs{};
+  uint16_t num_outputs{};
+  uint16_t num_associated_providers{};
+  uint16_t name_len{};
+  auto& crtcs = (*reply).crtcs;
+  size_t crtcs_len = crtcs.size();
+  auto& outputs = (*reply).outputs;
+  size_t outputs_len = outputs.size();
+  auto& associated_providers = (*reply).associated_providers;
+  size_t associated_providers_len = associated_providers.size();
+  auto& associated_capability = (*reply).associated_capability;
+  size_t associated_capability_len = associated_capability.size();
+  auto& name = (*reply).name;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  Read(&status, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // capabilities
+  uint32_t tmp28;
+  Read(&tmp28, &buf);
+  capabilities = static_cast<RandR::ProviderCapability>(tmp28);
+
+  // num_crtcs
+  Read(&num_crtcs, &buf);
+
+  // num_outputs
+  Read(&num_outputs, &buf);
+
+  // num_associated_providers
+  Read(&num_associated_providers, &buf);
+
+  // name_len
+  Read(&name_len, &buf);
+
+  // pad0
+  Pad(&buf, 8);
+
+  // crtcs
+  crtcs.resize(num_crtcs);
+  for (auto& crtcs_elem : crtcs) {
+    // crtcs_elem
+    Read(&crtcs_elem, &buf);
+  }
+
+  // outputs
+  outputs.resize(num_outputs);
+  for (auto& outputs_elem : outputs) {
+    // outputs_elem
+    Read(&outputs_elem, &buf);
+  }
+
+  // associated_providers
+  associated_providers.resize(num_associated_providers);
+  for (auto& associated_providers_elem : associated_providers) {
+    // associated_providers_elem
+    Read(&associated_providers_elem, &buf);
+  }
+
+  // associated_capability
+  associated_capability.resize(num_associated_providers);
+  for (auto& associated_capability_elem : associated_capability) {
+    // associated_capability_elem
+    Read(&associated_capability_elem, &buf);
+  }
+
+  // name
+  name.resize(name_len);
+  for (auto& name_elem : name) {
+    // name_elem
+    Read(&name_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::SetProviderOffloadSink(
+    const RandR::SetProviderOffloadSinkRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+  auto& sink_provider = request.sink_provider;
+  auto& config_timestamp = request.config_timestamp;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 34;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  // sink_provider
+  buf.Write(&sink_provider);
+
+  // config_timestamp
+  buf.Write(&config_timestamp);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::SetProviderOffloadSink",
+                                        false);
+}
+
+Future<void> RandR::SetProviderOffloadSink(const Provider& provider,
+                                           const Provider& sink_provider,
+                                           const Time& config_timestamp) {
+  return RandR::SetProviderOffloadSink(RandR::SetProviderOffloadSinkRequest{
+      provider, sink_provider, config_timestamp});
+}
+
+Future<void> RandR::SetProviderOutputSource(
+    const RandR::SetProviderOutputSourceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+  auto& source_provider = request.source_provider;
+  auto& config_timestamp = request.config_timestamp;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 35;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  // source_provider
+  buf.Write(&source_provider);
+
+  // config_timestamp
+  buf.Write(&config_timestamp);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::SetProviderOutputSource",
+                                        false);
+}
+
+Future<void> RandR::SetProviderOutputSource(const Provider& provider,
+                                            const Provider& source_provider,
+                                            const Time& config_timestamp) {
+  return RandR::SetProviderOutputSource(RandR::SetProviderOutputSourceRequest{
+      provider, source_provider, config_timestamp});
+}
+
+Future<RandR::ListProviderPropertiesReply> RandR::ListProviderProperties(
+    const RandR::ListProviderPropertiesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 36;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::ListProviderPropertiesReply>(
+      &buf, "RandR::ListProviderProperties", false);
+}
+
+Future<RandR::ListProviderPropertiesReply> RandR::ListProviderProperties(
+    const Provider& provider) {
+  return RandR::ListProviderProperties(
+      RandR::ListProviderPropertiesRequest{provider});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::ListProviderPropertiesReply> detail::ReadReply<
+    RandR::ListProviderPropertiesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::ListProviderPropertiesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t num_atoms{};
+  auto& atoms = (*reply).atoms;
+  size_t atoms_len = atoms.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_atoms
+  Read(&num_atoms, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // atoms
+  atoms.resize(num_atoms);
+  for (auto& atoms_elem : atoms) {
+    // atoms_elem
+    Read(&atoms_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::QueryProviderPropertyReply> RandR::QueryProviderProperty(
+    const RandR::QueryProviderPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+  auto& property = request.property;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 37;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  // property
+  buf.Write(&property);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::QueryProviderPropertyReply>(
+      &buf, "RandR::QueryProviderProperty", false);
+}
+
+Future<RandR::QueryProviderPropertyReply> RandR::QueryProviderProperty(
+    const Provider& provider,
+    const Atom& property) {
+  return RandR::QueryProviderProperty(
+      RandR::QueryProviderPropertyRequest{provider, property});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::QueryProviderPropertyReply> detail::ReadReply<
+    RandR::QueryProviderPropertyReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::QueryProviderPropertyReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& pending = (*reply).pending;
+  auto& range = (*reply).range;
+  auto& immutable = (*reply).immutable;
+  auto& valid_values = (*reply).valid_values;
+  size_t valid_values_len = valid_values.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pending
+  Read(&pending, &buf);
+
+  // range
+  Read(&range, &buf);
+
+  // immutable
+  Read(&immutable, &buf);
+
+  // pad1
+  Pad(&buf, 21);
+
+  // valid_values
+  valid_values.resize(length);
+  for (auto& valid_values_elem : valid_values) {
+    // valid_values_elem
+    Read(&valid_values_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::ConfigureProviderProperty(
+    const RandR::ConfigureProviderPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+  auto& property = request.property;
+  auto& pending = request.pending;
+  auto& range = request.range;
+  auto& values = request.values;
+  size_t values_len = values.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 38;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  // property
+  buf.Write(&property);
+
+  // pending
+  buf.Write(&pending);
+
+  // range
+  buf.Write(&range);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // values
+  DCHECK_EQ(static_cast<size_t>(values_len), values.size());
+  for (auto& values_elem : values) {
+    // values_elem
+    buf.Write(&values_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(
+      &buf, "RandR::ConfigureProviderProperty", false);
+}
+
+Future<void> RandR::ConfigureProviderProperty(
+    const Provider& provider,
+    const Atom& property,
+    const uint8_t& pending,
+    const uint8_t& range,
+    const std::vector<int32_t>& values) {
+  return RandR::ConfigureProviderProperty(
+      RandR::ConfigureProviderPropertyRequest{provider, property, pending,
+                                              range, values});
+}
+
+Future<void> RandR::ChangeProviderProperty(
+    const RandR::ChangeProviderPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& format = request.format;
+  auto& mode = request.mode;
+  auto& num_items = request.num_items;
+  auto& data = request.data;
+  size_t data_len = data ? data->size() : 0;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 39;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // format
+  buf.Write(&format);
+
+  // mode
+  buf.Write(&mode);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // num_items
+  buf.Write(&num_items);
+
+  // data
+  buf.AppendBuffer(data, (num_items) * ((format) / (8)));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::ChangeProviderProperty",
+                                        false);
+}
+
+Future<void> RandR::ChangeProviderProperty(
+    const Provider& provider,
+    const Atom& property,
+    const Atom& type,
+    const uint8_t& format,
+    const uint8_t& mode,
+    const uint32_t& num_items,
+    const scoped_refptr<base::RefCountedMemory>& data) {
+  return RandR::ChangeProviderProperty(RandR::ChangeProviderPropertyRequest{
+      provider, property, type, format, mode, num_items, data});
+}
+
+Future<void> RandR::DeleteProviderProperty(
+    const RandR::DeleteProviderPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+  auto& property = request.property;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 40;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  // property
+  buf.Write(&property);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::DeleteProviderProperty",
+                                        false);
+}
+
+Future<void> RandR::DeleteProviderProperty(const Provider& provider,
+                                           const Atom& property) {
+  return RandR::DeleteProviderProperty(
+      RandR::DeleteProviderPropertyRequest{provider, property});
+}
+
+Future<RandR::GetProviderPropertyReply> RandR::GetProviderProperty(
+    const RandR::GetProviderPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& provider = request.provider;
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& long_offset = request.long_offset;
+  auto& long_length = request.long_length;
+  auto& c_delete = request.c_delete;
+  auto& pending = request.pending;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 41;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // provider
+  buf.Write(&provider);
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // long_offset
+  buf.Write(&long_offset);
+
+  // long_length
+  buf.Write(&long_length);
+
+  // c_delete
+  buf.Write(&c_delete);
+
+  // pending
+  buf.Write(&pending);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetProviderPropertyReply>(
+      &buf, "RandR::GetProviderProperty", false);
+}
+
+Future<RandR::GetProviderPropertyReply> RandR::GetProviderProperty(
+    const Provider& provider,
+    const Atom& property,
+    const Atom& type,
+    const uint32_t& long_offset,
+    const uint32_t& long_length,
+    const uint8_t& c_delete,
+    const uint8_t& pending) {
+  return RandR::GetProviderProperty(RandR::GetProviderPropertyRequest{
+      provider, property, type, long_offset, long_length, c_delete, pending});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetProviderPropertyReply> detail::ReadReply<
+    RandR::GetProviderPropertyReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetProviderPropertyReply>();
+
+  auto& format = (*reply).format;
+  auto& sequence = (*reply).sequence;
+  auto& type = (*reply).type;
+  auto& bytes_after = (*reply).bytes_after;
+  auto& num_items = (*reply).num_items;
+  auto& data = (*reply).data;
+  size_t data_len = data ? data->size() : 0;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // format
+  Read(&format, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // type
+  Read(&type, &buf);
+
+  // bytes_after
+  Read(&bytes_after, &buf);
+
+  // num_items
+  Read(&num_items, &buf);
+
+  // pad0
+  Pad(&buf, 12);
+
+  // data
+  data = buffer->ReadAndAdvance((num_items) * ((format) / (8)));
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<RandR::GetMonitorsReply> RandR::GetMonitors(
+    const RandR::GetMonitorsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& get_active = request.get_active;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 42;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // get_active
+  buf.Write(&get_active);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::GetMonitorsReply>(
+      &buf, "RandR::GetMonitors", false);
+}
+
+Future<RandR::GetMonitorsReply> RandR::GetMonitors(const Window& window,
+                                                   const uint8_t& get_active) {
+  return RandR::GetMonitors(RandR::GetMonitorsRequest{window, get_active});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::GetMonitorsReply> detail::ReadReply<
+    RandR::GetMonitorsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::GetMonitorsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& timestamp = (*reply).timestamp;
+  uint32_t nMonitors{};
+  auto& nOutputs = (*reply).nOutputs;
+  auto& monitors = (*reply).monitors;
+  size_t monitors_len = monitors.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // nMonitors
+  Read(&nMonitors, &buf);
+
+  // nOutputs
+  Read(&nOutputs, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // monitors
+  monitors.resize(nMonitors);
+  for (auto& monitors_elem : monitors) {
+    // monitors_elem
+    {
+      auto& name = monitors_elem.name;
+      auto& primary = monitors_elem.primary;
+      auto& automatic = monitors_elem.automatic;
+      uint16_t nOutput{};
+      auto& x = monitors_elem.x;
+      auto& y = monitors_elem.y;
+      auto& width = monitors_elem.width;
+      auto& height = monitors_elem.height;
+      auto& width_in_millimeters = monitors_elem.width_in_millimeters;
+      auto& height_in_millimeters = monitors_elem.height_in_millimeters;
+      auto& outputs = monitors_elem.outputs;
+      size_t outputs_len = outputs.size();
+
+      // name
+      Read(&name, &buf);
+
+      // primary
+      Read(&primary, &buf);
+
+      // automatic
+      Read(&automatic, &buf);
+
+      // nOutput
+      Read(&nOutput, &buf);
+
+      // x
+      Read(&x, &buf);
+
+      // y
+      Read(&y, &buf);
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+
+      // width_in_millimeters
+      Read(&width_in_millimeters, &buf);
+
+      // height_in_millimeters
+      Read(&height_in_millimeters, &buf);
+
+      // outputs
+      outputs.resize(nOutput);
+      for (auto& outputs_elem : outputs) {
+        // outputs_elem
+        Read(&outputs_elem, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::SetMonitor(const RandR::SetMonitorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& monitorinfo = request.monitorinfo;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 43;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // monitorinfo
+  {
+    auto& name = monitorinfo.name;
+    auto& primary = monitorinfo.primary;
+    auto& automatic = monitorinfo.automatic;
+    uint16_t nOutput{};
+    auto& x = monitorinfo.x;
+    auto& y = monitorinfo.y;
+    auto& width = monitorinfo.width;
+    auto& height = monitorinfo.height;
+    auto& width_in_millimeters = monitorinfo.width_in_millimeters;
+    auto& height_in_millimeters = monitorinfo.height_in_millimeters;
+    auto& outputs = monitorinfo.outputs;
+    size_t outputs_len = outputs.size();
+
+    // name
+    buf.Write(&name);
+
+    // primary
+    buf.Write(&primary);
+
+    // automatic
+    buf.Write(&automatic);
+
+    // nOutput
+    nOutput = outputs.size();
+    buf.Write(&nOutput);
+
+    // x
+    buf.Write(&x);
+
+    // y
+    buf.Write(&y);
+
+    // width
+    buf.Write(&width);
+
+    // height
+    buf.Write(&height);
+
+    // width_in_millimeters
+    buf.Write(&width_in_millimeters);
+
+    // height_in_millimeters
+    buf.Write(&height_in_millimeters);
+
+    // outputs
+    DCHECK_EQ(static_cast<size_t>(nOutput), outputs.size());
+    for (auto& outputs_elem : outputs) {
+      // outputs_elem
+      buf.Write(&outputs_elem);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::SetMonitor", false);
+}
+
+Future<void> RandR::SetMonitor(const Window& window,
+                               const MonitorInfo& monitorinfo) {
+  return RandR::SetMonitor(RandR::SetMonitorRequest{window, monitorinfo});
+}
+
+Future<void> RandR::DeleteMonitor(const RandR::DeleteMonitorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 44;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // name
+  buf.Write(&name);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::DeleteMonitor", false);
+}
+
+Future<void> RandR::DeleteMonitor(const Window& window, const Atom& name) {
+  return RandR::DeleteMonitor(RandR::DeleteMonitorRequest{window, name});
+}
+
+Future<RandR::CreateLeaseReply> RandR::CreateLease(
+    const RandR::CreateLeaseRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& lid = request.lid;
+  uint16_t num_crtcs{};
+  uint16_t num_outputs{};
+  auto& crtcs = request.crtcs;
+  size_t crtcs_len = crtcs.size();
+  auto& outputs = request.outputs;
+  size_t outputs_len = outputs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 45;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // lid
+  buf.Write(&lid);
+
+  // num_crtcs
+  num_crtcs = crtcs.size();
+  buf.Write(&num_crtcs);
+
+  // num_outputs
+  num_outputs = outputs.size();
+  buf.Write(&num_outputs);
+
+  // crtcs
+  DCHECK_EQ(static_cast<size_t>(num_crtcs), crtcs.size());
+  for (auto& crtcs_elem : crtcs) {
+    // crtcs_elem
+    buf.Write(&crtcs_elem);
+  }
+
+  // outputs
+  DCHECK_EQ(static_cast<size_t>(num_outputs), outputs.size());
+  for (auto& outputs_elem : outputs) {
+    // outputs_elem
+    buf.Write(&outputs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<RandR::CreateLeaseReply>(
+      &buf, "RandR::CreateLease", true);
+}
+
+Future<RandR::CreateLeaseReply> RandR::CreateLease(
+    const Window& window,
+    const Lease& lid,
+    const std::vector<Crtc>& crtcs,
+    const std::vector<Output>& outputs) {
+  return RandR::CreateLease(
+      RandR::CreateLeaseRequest{window, lid, crtcs, outputs});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<RandR::CreateLeaseReply> detail::ReadReply<
+    RandR::CreateLeaseReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<RandR::CreateLeaseReply>();
+
+  auto& nfd = (*reply).nfd;
+  auto& sequence = (*reply).sequence;
+  auto& master_fd = (*reply).master_fd;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // nfd
+  Read(&nfd, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // master_fd
+  master_fd = RefCountedFD(buf.TakeFd());
+
+  // pad0
+  Pad(&buf, 24);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> RandR::FreeLease(const RandR::FreeLeaseRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& lid = request.lid;
+  auto& terminate = request.terminate;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 46;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // lid
+  buf.Write(&lid);
+
+  // terminate
+  buf.Write(&terminate);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RandR::FreeLease", false);
+}
+
+Future<void> RandR::FreeLease(const Lease& lid, const uint8_t& terminate) {
+  return RandR::FreeLease(RandR::FreeLeaseRequest{lid, terminate});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/randr.h b/ui/gfx/x/generated_protos/randr.h
new file mode 100644
index 0000000..1f420bb
--- /dev/null
+++ b/ui/gfx/x/generated_protos/randr.h
@@ -0,0 +1,1337 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_RANDR_H_
+#define UI_GFX_X_GENERATED_PROTOS_RANDR_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "render.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) RandR {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 6;
+
+  RandR(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Mode : uint32_t {};
+
+  enum class Crtc : uint32_t {};
+
+  enum class Output : uint32_t {};
+
+  enum class Provider : uint32_t {};
+
+  enum class Lease : uint32_t {};
+
+  enum class Rotation : int {
+    Rotate_0 = 1 << 0,
+    Rotate_90 = 1 << 1,
+    Rotate_180 = 1 << 2,
+    Rotate_270 = 1 << 3,
+    Reflect_X = 1 << 4,
+    Reflect_Y = 1 << 5,
+  };
+
+  enum class SetConfig : int {
+    Success = 0,
+    InvalidConfigTime = 1,
+    InvalidTime = 2,
+    Failed = 3,
+  };
+
+  enum class NotifyMask : int {
+    ScreenChange = 1 << 0,
+    CrtcChange = 1 << 1,
+    OutputChange = 1 << 2,
+    OutputProperty = 1 << 3,
+    ProviderChange = 1 << 4,
+    ProviderProperty = 1 << 5,
+    ResourceChange = 1 << 6,
+    Lease = 1 << 7,
+  };
+
+  enum class ModeFlag : int {
+    HsyncPositive = 1 << 0,
+    HsyncNegative = 1 << 1,
+    VsyncPositive = 1 << 2,
+    VsyncNegative = 1 << 3,
+    Interlace = 1 << 4,
+    DoubleScan = 1 << 5,
+    Csync = 1 << 6,
+    CsyncPositive = 1 << 7,
+    CsyncNegative = 1 << 8,
+    HskewPresent = 1 << 9,
+    Bcast = 1 << 10,
+    PixelMultiplex = 1 << 11,
+    DoubleClock = 1 << 12,
+    HalveClock = 1 << 13,
+  };
+
+  enum class RandRConnection : int {
+    Connected = 0,
+    Disconnected = 1,
+    Unknown = 2,
+  };
+
+  enum class Transform : int {
+    Unit = 1 << 0,
+    ScaleUp = 1 << 1,
+    ScaleDown = 1 << 2,
+    Projective = 1 << 3,
+  };
+
+  enum class ProviderCapability : int {
+    SourceOutput = 1 << 0,
+    SinkOutput = 1 << 1,
+    SourceOffload = 1 << 2,
+    SinkOffload = 1 << 3,
+  };
+
+  enum class Notify : int {
+    CrtcChange = 0,
+    OutputChange = 1,
+    OutputProperty = 2,
+    ProviderChange = 3,
+    ProviderProperty = 4,
+    ResourceChange = 5,
+    Lease = 6,
+  };
+
+  struct BadOutputError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadCrtcError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadModeError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadProviderError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct ScreenSize {
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t mwidth{};
+    uint16_t mheight{};
+  };
+
+  struct RefreshRates {
+    std::vector<uint16_t> rates{};
+  };
+
+  struct ModeInfo {
+    uint32_t id{};
+    uint16_t width{};
+    uint16_t height{};
+    uint32_t dot_clock{};
+    uint16_t hsync_start{};
+    uint16_t hsync_end{};
+    uint16_t htotal{};
+    uint16_t hskew{};
+    uint16_t vsync_start{};
+    uint16_t vsync_end{};
+    uint16_t vtotal{};
+    uint16_t name_len{};
+    ModeFlag mode_flags{};
+  };
+
+  struct ScreenChangeNotifyEvent {
+    static constexpr int type_id = 11;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    Rotation rotation{};
+    uint16_t sequence{};
+    Time timestamp{};
+    Time config_timestamp{};
+    Window root{};
+    Window request_window{};
+    uint16_t sizeID{};
+    Render::SubPixel subpixel_order{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t mwidth{};
+    uint16_t mheight{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&request_window);
+    }
+  };
+
+  struct MonitorInfo {
+    Atom name{};
+    uint8_t primary{};
+    uint8_t automatic{};
+    int16_t x{};
+    int16_t y{};
+    uint16_t width{};
+    uint16_t height{};
+    uint32_t width_in_millimeters{};
+    uint32_t height_in_millimeters{};
+    std::vector<Output> outputs{};
+  };
+
+  struct NotifyEvent {
+    static constexpr int type_id = 12;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint16_t sequence{};
+    struct Cc {
+      Time timestamp{};
+      Window window{};
+      Crtc crtc{};
+      Mode mode{};
+      Rotation rotation{};
+      int16_t x{};
+      int16_t y{};
+      uint16_t width{};
+      uint16_t height{};
+    };
+    struct Oc {
+      Time timestamp{};
+      Time config_timestamp{};
+      Window window{};
+      Output output{};
+      Crtc crtc{};
+      Mode mode{};
+      Rotation rotation{};
+      RandRConnection connection{};
+      Render::SubPixel subpixel_order{};
+    };
+    struct Op {
+      Window window{};
+      Output output{};
+      Atom atom{};
+      Time timestamp{};
+      Property status{};
+    };
+    struct Pc {
+      Time timestamp{};
+      Window window{};
+      Provider provider{};
+    };
+    struct Pp {
+      Window window{};
+      Provider provider{};
+      Atom atom{};
+      Time timestamp{};
+      uint8_t state{};
+    };
+    struct Rc {
+      Time timestamp{};
+      Window window{};
+    };
+    struct Lc {
+      Time timestamp{};
+      Window window{};
+      Lease lease{};
+      uint8_t created{};
+    };
+    absl::optional<Cc> cc{};
+    absl::optional<Oc> oc{};
+    absl::optional<Op> op{};
+    absl::optional<Pc> pc{};
+    absl::optional<Pp> pp{};
+    absl::optional<Rc> rc{};
+    absl::optional<Lc> lc{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct QueryVersionRequest {
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint32_t& major_version = {},
+                                         const uint32_t& minor_version = {});
+
+  struct SetScreenConfigRequest {
+    Window window{};
+    Time timestamp{};
+    Time config_timestamp{};
+    uint16_t sizeID{};
+    Rotation rotation{};
+    uint16_t rate{};
+  };
+
+  struct SetScreenConfigReply {
+    SetConfig status{};
+    uint16_t sequence{};
+    Time new_timestamp{};
+    Time config_timestamp{};
+    Window root{};
+    Render::SubPixel subpixel_order{};
+  };
+
+  using SetScreenConfigResponse = Response<SetScreenConfigReply>;
+
+  Future<SetScreenConfigReply> SetScreenConfig(
+      const SetScreenConfigRequest& request);
+
+  Future<SetScreenConfigReply> SetScreenConfig(
+      const Window& window = {},
+      const Time& timestamp = {},
+      const Time& config_timestamp = {},
+      const uint16_t& sizeID = {},
+      const Rotation& rotation = {},
+      const uint16_t& rate = {});
+
+  struct SelectInputRequest {
+    Window window{};
+    NotifyMask enable{};
+  };
+
+  using SelectInputResponse = Response<void>;
+
+  Future<void> SelectInput(const SelectInputRequest& request);
+
+  Future<void> SelectInput(const Window& window = {},
+                           const NotifyMask& enable = {});
+
+  struct GetScreenInfoRequest {
+    Window window{};
+  };
+
+  struct GetScreenInfoReply {
+    Rotation rotations{};
+    uint16_t sequence{};
+    Window root{};
+    Time timestamp{};
+    Time config_timestamp{};
+    uint16_t sizeID{};
+    Rotation rotation{};
+    uint16_t rate{};
+    uint16_t nInfo{};
+    std::vector<ScreenSize> sizes{};
+    std::vector<RefreshRates> rates{};
+  };
+
+  using GetScreenInfoResponse = Response<GetScreenInfoReply>;
+
+  Future<GetScreenInfoReply> GetScreenInfo(const GetScreenInfoRequest& request);
+
+  Future<GetScreenInfoReply> GetScreenInfo(const Window& window = {});
+
+  struct GetScreenSizeRangeRequest {
+    Window window{};
+  };
+
+  struct GetScreenSizeRangeReply {
+    uint16_t sequence{};
+    uint16_t min_width{};
+    uint16_t min_height{};
+    uint16_t max_width{};
+    uint16_t max_height{};
+  };
+
+  using GetScreenSizeRangeResponse = Response<GetScreenSizeRangeReply>;
+
+  Future<GetScreenSizeRangeReply> GetScreenSizeRange(
+      const GetScreenSizeRangeRequest& request);
+
+  Future<GetScreenSizeRangeReply> GetScreenSizeRange(const Window& window = {});
+
+  struct SetScreenSizeRequest {
+    Window window{};
+    uint16_t width{};
+    uint16_t height{};
+    uint32_t mm_width{};
+    uint32_t mm_height{};
+  };
+
+  using SetScreenSizeResponse = Response<void>;
+
+  Future<void> SetScreenSize(const SetScreenSizeRequest& request);
+
+  Future<void> SetScreenSize(const Window& window = {},
+                             const uint16_t& width = {},
+                             const uint16_t& height = {},
+                             const uint32_t& mm_width = {},
+                             const uint32_t& mm_height = {});
+
+  struct GetScreenResourcesRequest {
+    Window window{};
+  };
+
+  struct GetScreenResourcesReply {
+    uint16_t sequence{};
+    Time timestamp{};
+    Time config_timestamp{};
+    std::vector<Crtc> crtcs{};
+    std::vector<Output> outputs{};
+    std::vector<ModeInfo> modes{};
+    std::vector<uint8_t> names{};
+  };
+
+  using GetScreenResourcesResponse = Response<GetScreenResourcesReply>;
+
+  Future<GetScreenResourcesReply> GetScreenResources(
+      const GetScreenResourcesRequest& request);
+
+  Future<GetScreenResourcesReply> GetScreenResources(const Window& window = {});
+
+  struct GetOutputInfoRequest {
+    Output output{};
+    Time config_timestamp{};
+  };
+
+  struct GetOutputInfoReply {
+    SetConfig status{};
+    uint16_t sequence{};
+    Time timestamp{};
+    Crtc crtc{};
+    uint32_t mm_width{};
+    uint32_t mm_height{};
+    RandRConnection connection{};
+    Render::SubPixel subpixel_order{};
+    uint16_t num_preferred{};
+    std::vector<Crtc> crtcs{};
+    std::vector<Mode> modes{};
+    std::vector<Output> clones{};
+    std::vector<uint8_t> name{};
+  };
+
+  using GetOutputInfoResponse = Response<GetOutputInfoReply>;
+
+  Future<GetOutputInfoReply> GetOutputInfo(const GetOutputInfoRequest& request);
+
+  Future<GetOutputInfoReply> GetOutputInfo(const Output& output = {},
+                                           const Time& config_timestamp = {});
+
+  struct ListOutputPropertiesRequest {
+    Output output{};
+  };
+
+  struct ListOutputPropertiesReply {
+    uint16_t sequence{};
+    std::vector<Atom> atoms{};
+  };
+
+  using ListOutputPropertiesResponse = Response<ListOutputPropertiesReply>;
+
+  Future<ListOutputPropertiesReply> ListOutputProperties(
+      const ListOutputPropertiesRequest& request);
+
+  Future<ListOutputPropertiesReply> ListOutputProperties(
+      const Output& output = {});
+
+  struct QueryOutputPropertyRequest {
+    Output output{};
+    Atom property{};
+  };
+
+  struct QueryOutputPropertyReply {
+    uint16_t sequence{};
+    uint8_t pending{};
+    uint8_t range{};
+    uint8_t immutable{};
+    std::vector<int32_t> validValues{};
+  };
+
+  using QueryOutputPropertyResponse = Response<QueryOutputPropertyReply>;
+
+  Future<QueryOutputPropertyReply> QueryOutputProperty(
+      const QueryOutputPropertyRequest& request);
+
+  Future<QueryOutputPropertyReply> QueryOutputProperty(
+      const Output& output = {},
+      const Atom& property = {});
+
+  struct ConfigureOutputPropertyRequest {
+    Output output{};
+    Atom property{};
+    uint8_t pending{};
+    uint8_t range{};
+    std::vector<int32_t> values{};
+  };
+
+  using ConfigureOutputPropertyResponse = Response<void>;
+
+  Future<void> ConfigureOutputProperty(
+      const ConfigureOutputPropertyRequest& request);
+
+  Future<void> ConfigureOutputProperty(const Output& output = {},
+                                       const Atom& property = {},
+                                       const uint8_t& pending = {},
+                                       const uint8_t& range = {},
+                                       const std::vector<int32_t>& values = {});
+
+  struct ChangeOutputPropertyRequest {
+    Output output{};
+    Atom property{};
+    Atom type{};
+    uint8_t format{};
+    PropMode mode{};
+    uint32_t num_units{};
+    scoped_refptr<base::RefCountedMemory> data{};
+  };
+
+  using ChangeOutputPropertyResponse = Response<void>;
+
+  Future<void> ChangeOutputProperty(const ChangeOutputPropertyRequest& request);
+
+  Future<void> ChangeOutputProperty(
+      const Output& output = {},
+      const Atom& property = {},
+      const Atom& type = {},
+      const uint8_t& format = {},
+      const PropMode& mode = {},
+      const uint32_t& num_units = {},
+      const scoped_refptr<base::RefCountedMemory>& data = {});
+
+  struct DeleteOutputPropertyRequest {
+    Output output{};
+    Atom property{};
+  };
+
+  using DeleteOutputPropertyResponse = Response<void>;
+
+  Future<void> DeleteOutputProperty(const DeleteOutputPropertyRequest& request);
+
+  Future<void> DeleteOutputProperty(const Output& output = {},
+                                    const Atom& property = {});
+
+  struct GetOutputPropertyRequest {
+    Output output{};
+    Atom property{};
+    Atom type{};
+    uint32_t long_offset{};
+    uint32_t long_length{};
+    uint8_t c_delete{};
+    uint8_t pending{};
+  };
+
+  struct GetOutputPropertyReply {
+    uint8_t format{};
+    uint16_t sequence{};
+    Atom type{};
+    uint32_t bytes_after{};
+    uint32_t num_items{};
+    std::vector<uint8_t> data{};
+  };
+
+  using GetOutputPropertyResponse = Response<GetOutputPropertyReply>;
+
+  Future<GetOutputPropertyReply> GetOutputProperty(
+      const GetOutputPropertyRequest& request);
+
+  Future<GetOutputPropertyReply> GetOutputProperty(
+      const Output& output = {},
+      const Atom& property = {},
+      const Atom& type = {},
+      const uint32_t& long_offset = {},
+      const uint32_t& long_length = {},
+      const uint8_t& c_delete = {},
+      const uint8_t& pending = {});
+
+  struct CreateModeRequest {
+    Window window{};
+    ModeInfo mode_info{};
+    std::string name{};
+  };
+
+  struct CreateModeReply {
+    uint16_t sequence{};
+    Mode mode{};
+  };
+
+  using CreateModeResponse = Response<CreateModeReply>;
+
+  Future<CreateModeReply> CreateMode(const CreateModeRequest& request);
+
+  Future<CreateModeReply> CreateMode(
+      const Window& window = {},
+      const ModeInfo& mode_info =
+          {{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}},
+      const std::string& name = {});
+
+  struct DestroyModeRequest {
+    Mode mode{};
+  };
+
+  using DestroyModeResponse = Response<void>;
+
+  Future<void> DestroyMode(const DestroyModeRequest& request);
+
+  Future<void> DestroyMode(const Mode& mode = {});
+
+  struct AddOutputModeRequest {
+    Output output{};
+    Mode mode{};
+  };
+
+  using AddOutputModeResponse = Response<void>;
+
+  Future<void> AddOutputMode(const AddOutputModeRequest& request);
+
+  Future<void> AddOutputMode(const Output& output = {}, const Mode& mode = {});
+
+  struct DeleteOutputModeRequest {
+    Output output{};
+    Mode mode{};
+  };
+
+  using DeleteOutputModeResponse = Response<void>;
+
+  Future<void> DeleteOutputMode(const DeleteOutputModeRequest& request);
+
+  Future<void> DeleteOutputMode(const Output& output = {},
+                                const Mode& mode = {});
+
+  struct GetCrtcInfoRequest {
+    Crtc crtc{};
+    Time config_timestamp{};
+  };
+
+  struct GetCrtcInfoReply {
+    SetConfig status{};
+    uint16_t sequence{};
+    Time timestamp{};
+    int16_t x{};
+    int16_t y{};
+    uint16_t width{};
+    uint16_t height{};
+    Mode mode{};
+    Rotation rotation{};
+    Rotation rotations{};
+    std::vector<Output> outputs{};
+    std::vector<Output> possible{};
+  };
+
+  using GetCrtcInfoResponse = Response<GetCrtcInfoReply>;
+
+  Future<GetCrtcInfoReply> GetCrtcInfo(const GetCrtcInfoRequest& request);
+
+  Future<GetCrtcInfoReply> GetCrtcInfo(const Crtc& crtc = {},
+                                       const Time& config_timestamp = {});
+
+  struct SetCrtcConfigRequest {
+    Crtc crtc{};
+    Time timestamp{};
+    Time config_timestamp{};
+    int16_t x{};
+    int16_t y{};
+    Mode mode{};
+    Rotation rotation{};
+    std::vector<Output> outputs{};
+  };
+
+  struct SetCrtcConfigReply {
+    SetConfig status{};
+    uint16_t sequence{};
+    Time timestamp{};
+  };
+
+  using SetCrtcConfigResponse = Response<SetCrtcConfigReply>;
+
+  Future<SetCrtcConfigReply> SetCrtcConfig(const SetCrtcConfigRequest& request);
+
+  Future<SetCrtcConfigReply> SetCrtcConfig(
+      const Crtc& crtc = {},
+      const Time& timestamp = {},
+      const Time& config_timestamp = {},
+      const int16_t& x = {},
+      const int16_t& y = {},
+      const Mode& mode = {},
+      const Rotation& rotation = {},
+      const std::vector<Output>& outputs = {});
+
+  struct GetCrtcGammaSizeRequest {
+    Crtc crtc{};
+  };
+
+  struct GetCrtcGammaSizeReply {
+    uint16_t sequence{};
+    uint16_t size{};
+  };
+
+  using GetCrtcGammaSizeResponse = Response<GetCrtcGammaSizeReply>;
+
+  Future<GetCrtcGammaSizeReply> GetCrtcGammaSize(
+      const GetCrtcGammaSizeRequest& request);
+
+  Future<GetCrtcGammaSizeReply> GetCrtcGammaSize(const Crtc& crtc = {});
+
+  struct GetCrtcGammaRequest {
+    Crtc crtc{};
+  };
+
+  struct GetCrtcGammaReply {
+    uint16_t sequence{};
+    std::vector<uint16_t> red{};
+    std::vector<uint16_t> green{};
+    std::vector<uint16_t> blue{};
+  };
+
+  using GetCrtcGammaResponse = Response<GetCrtcGammaReply>;
+
+  Future<GetCrtcGammaReply> GetCrtcGamma(const GetCrtcGammaRequest& request);
+
+  Future<GetCrtcGammaReply> GetCrtcGamma(const Crtc& crtc = {});
+
+  struct SetCrtcGammaRequest {
+    Crtc crtc{};
+    std::vector<uint16_t> red{};
+    std::vector<uint16_t> green{};
+    std::vector<uint16_t> blue{};
+  };
+
+  using SetCrtcGammaResponse = Response<void>;
+
+  Future<void> SetCrtcGamma(const SetCrtcGammaRequest& request);
+
+  Future<void> SetCrtcGamma(const Crtc& crtc = {},
+                            const std::vector<uint16_t>& red = {},
+                            const std::vector<uint16_t>& green = {},
+                            const std::vector<uint16_t>& blue = {});
+
+  struct GetScreenResourcesCurrentRequest {
+    Window window{};
+  };
+
+  struct GetScreenResourcesCurrentReply {
+    uint16_t sequence{};
+    Time timestamp{};
+    Time config_timestamp{};
+    std::vector<Crtc> crtcs{};
+    std::vector<Output> outputs{};
+    std::vector<ModeInfo> modes{};
+    std::vector<uint8_t> names{};
+  };
+
+  using GetScreenResourcesCurrentResponse =
+      Response<GetScreenResourcesCurrentReply>;
+
+  Future<GetScreenResourcesCurrentReply> GetScreenResourcesCurrent(
+      const GetScreenResourcesCurrentRequest& request);
+
+  Future<GetScreenResourcesCurrentReply> GetScreenResourcesCurrent(
+      const Window& window = {});
+
+  struct SetCrtcTransformRequest {
+    Crtc crtc{};
+    Render::Transform transform{};
+    std::string filter_name{};
+    std::vector<Render::Fixed> filter_params{};
+  };
+
+  using SetCrtcTransformResponse = Response<void>;
+
+  Future<void> SetCrtcTransform(const SetCrtcTransformRequest& request);
+
+  Future<void> SetCrtcTransform(
+      const Crtc& crtc = {},
+      const Render::Transform& transform = {{}, {}, {}, {}, {}, {}, {}, {}, {}},
+      const std::string& filter_name = {},
+      const std::vector<Render::Fixed>& filter_params = {});
+
+  struct GetCrtcTransformRequest {
+    Crtc crtc{};
+  };
+
+  struct GetCrtcTransformReply {
+    uint16_t sequence{};
+    Render::Transform pending_transform{};
+    uint8_t has_transforms{};
+    Render::Transform current_transform{};
+    std::string pending_filter_name{};
+    std::vector<Render::Fixed> pending_params{};
+    std::string current_filter_name{};
+    std::vector<Render::Fixed> current_params{};
+  };
+
+  using GetCrtcTransformResponse = Response<GetCrtcTransformReply>;
+
+  Future<GetCrtcTransformReply> GetCrtcTransform(
+      const GetCrtcTransformRequest& request);
+
+  Future<GetCrtcTransformReply> GetCrtcTransform(const Crtc& crtc = {});
+
+  struct GetPanningRequest {
+    Crtc crtc{};
+  };
+
+  struct GetPanningReply {
+    SetConfig status{};
+    uint16_t sequence{};
+    Time timestamp{};
+    uint16_t left{};
+    uint16_t top{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t track_left{};
+    uint16_t track_top{};
+    uint16_t track_width{};
+    uint16_t track_height{};
+    int16_t border_left{};
+    int16_t border_top{};
+    int16_t border_right{};
+    int16_t border_bottom{};
+  };
+
+  using GetPanningResponse = Response<GetPanningReply>;
+
+  Future<GetPanningReply> GetPanning(const GetPanningRequest& request);
+
+  Future<GetPanningReply> GetPanning(const Crtc& crtc = {});
+
+  struct SetPanningRequest {
+    Crtc crtc{};
+    Time timestamp{};
+    uint16_t left{};
+    uint16_t top{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t track_left{};
+    uint16_t track_top{};
+    uint16_t track_width{};
+    uint16_t track_height{};
+    int16_t border_left{};
+    int16_t border_top{};
+    int16_t border_right{};
+    int16_t border_bottom{};
+  };
+
+  struct SetPanningReply {
+    SetConfig status{};
+    uint16_t sequence{};
+    Time timestamp{};
+  };
+
+  using SetPanningResponse = Response<SetPanningReply>;
+
+  Future<SetPanningReply> SetPanning(const SetPanningRequest& request);
+
+  Future<SetPanningReply> SetPanning(const Crtc& crtc = {},
+                                     const Time& timestamp = {},
+                                     const uint16_t& left = {},
+                                     const uint16_t& top = {},
+                                     const uint16_t& width = {},
+                                     const uint16_t& height = {},
+                                     const uint16_t& track_left = {},
+                                     const uint16_t& track_top = {},
+                                     const uint16_t& track_width = {},
+                                     const uint16_t& track_height = {},
+                                     const int16_t& border_left = {},
+                                     const int16_t& border_top = {},
+                                     const int16_t& border_right = {},
+                                     const int16_t& border_bottom = {});
+
+  struct SetOutputPrimaryRequest {
+    Window window{};
+    Output output{};
+  };
+
+  using SetOutputPrimaryResponse = Response<void>;
+
+  Future<void> SetOutputPrimary(const SetOutputPrimaryRequest& request);
+
+  Future<void> SetOutputPrimary(const Window& window = {},
+                                const Output& output = {});
+
+  struct GetOutputPrimaryRequest {
+    Window window{};
+  };
+
+  struct GetOutputPrimaryReply {
+    uint16_t sequence{};
+    Output output{};
+  };
+
+  using GetOutputPrimaryResponse = Response<GetOutputPrimaryReply>;
+
+  Future<GetOutputPrimaryReply> GetOutputPrimary(
+      const GetOutputPrimaryRequest& request);
+
+  Future<GetOutputPrimaryReply> GetOutputPrimary(const Window& window = {});
+
+  struct GetProvidersRequest {
+    Window window{};
+  };
+
+  struct GetProvidersReply {
+    uint16_t sequence{};
+    Time timestamp{};
+    std::vector<Provider> providers{};
+  };
+
+  using GetProvidersResponse = Response<GetProvidersReply>;
+
+  Future<GetProvidersReply> GetProviders(const GetProvidersRequest& request);
+
+  Future<GetProvidersReply> GetProviders(const Window& window = {});
+
+  struct GetProviderInfoRequest {
+    Provider provider{};
+    Time config_timestamp{};
+  };
+
+  struct GetProviderInfoReply {
+    uint8_t status{};
+    uint16_t sequence{};
+    Time timestamp{};
+    ProviderCapability capabilities{};
+    std::vector<Crtc> crtcs{};
+    std::vector<Output> outputs{};
+    std::vector<Provider> associated_providers{};
+    std::vector<uint32_t> associated_capability{};
+    std::string name{};
+  };
+
+  using GetProviderInfoResponse = Response<GetProviderInfoReply>;
+
+  Future<GetProviderInfoReply> GetProviderInfo(
+      const GetProviderInfoRequest& request);
+
+  Future<GetProviderInfoReply> GetProviderInfo(
+      const Provider& provider = {},
+      const Time& config_timestamp = {});
+
+  struct SetProviderOffloadSinkRequest {
+    Provider provider{};
+    Provider sink_provider{};
+    Time config_timestamp{};
+  };
+
+  using SetProviderOffloadSinkResponse = Response<void>;
+
+  Future<void> SetProviderOffloadSink(
+      const SetProviderOffloadSinkRequest& request);
+
+  Future<void> SetProviderOffloadSink(const Provider& provider = {},
+                                      const Provider& sink_provider = {},
+                                      const Time& config_timestamp = {});
+
+  struct SetProviderOutputSourceRequest {
+    Provider provider{};
+    Provider source_provider{};
+    Time config_timestamp{};
+  };
+
+  using SetProviderOutputSourceResponse = Response<void>;
+
+  Future<void> SetProviderOutputSource(
+      const SetProviderOutputSourceRequest& request);
+
+  Future<void> SetProviderOutputSource(const Provider& provider = {},
+                                       const Provider& source_provider = {},
+                                       const Time& config_timestamp = {});
+
+  struct ListProviderPropertiesRequest {
+    Provider provider{};
+  };
+
+  struct ListProviderPropertiesReply {
+    uint16_t sequence{};
+    std::vector<Atom> atoms{};
+  };
+
+  using ListProviderPropertiesResponse = Response<ListProviderPropertiesReply>;
+
+  Future<ListProviderPropertiesReply> ListProviderProperties(
+      const ListProviderPropertiesRequest& request);
+
+  Future<ListProviderPropertiesReply> ListProviderProperties(
+      const Provider& provider = {});
+
+  struct QueryProviderPropertyRequest {
+    Provider provider{};
+    Atom property{};
+  };
+
+  struct QueryProviderPropertyReply {
+    uint16_t sequence{};
+    uint8_t pending{};
+    uint8_t range{};
+    uint8_t immutable{};
+    std::vector<int32_t> valid_values{};
+  };
+
+  using QueryProviderPropertyResponse = Response<QueryProviderPropertyReply>;
+
+  Future<QueryProviderPropertyReply> QueryProviderProperty(
+      const QueryProviderPropertyRequest& request);
+
+  Future<QueryProviderPropertyReply> QueryProviderProperty(
+      const Provider& provider = {},
+      const Atom& property = {});
+
+  struct ConfigureProviderPropertyRequest {
+    Provider provider{};
+    Atom property{};
+    uint8_t pending{};
+    uint8_t range{};
+    std::vector<int32_t> values{};
+  };
+
+  using ConfigureProviderPropertyResponse = Response<void>;
+
+  Future<void> ConfigureProviderProperty(
+      const ConfigureProviderPropertyRequest& request);
+
+  Future<void> ConfigureProviderProperty(
+      const Provider& provider = {},
+      const Atom& property = {},
+      const uint8_t& pending = {},
+      const uint8_t& range = {},
+      const std::vector<int32_t>& values = {});
+
+  struct ChangeProviderPropertyRequest {
+    Provider provider{};
+    Atom property{};
+    Atom type{};
+    uint8_t format{};
+    uint8_t mode{};
+    uint32_t num_items{};
+    scoped_refptr<base::RefCountedMemory> data{};
+  };
+
+  using ChangeProviderPropertyResponse = Response<void>;
+
+  Future<void> ChangeProviderProperty(
+      const ChangeProviderPropertyRequest& request);
+
+  Future<void> ChangeProviderProperty(
+      const Provider& provider = {},
+      const Atom& property = {},
+      const Atom& type = {},
+      const uint8_t& format = {},
+      const uint8_t& mode = {},
+      const uint32_t& num_items = {},
+      const scoped_refptr<base::RefCountedMemory>& data = {});
+
+  struct DeleteProviderPropertyRequest {
+    Provider provider{};
+    Atom property{};
+  };
+
+  using DeleteProviderPropertyResponse = Response<void>;
+
+  Future<void> DeleteProviderProperty(
+      const DeleteProviderPropertyRequest& request);
+
+  Future<void> DeleteProviderProperty(const Provider& provider = {},
+                                      const Atom& property = {});
+
+  struct GetProviderPropertyRequest {
+    Provider provider{};
+    Atom property{};
+    Atom type{};
+    uint32_t long_offset{};
+    uint32_t long_length{};
+    uint8_t c_delete{};
+    uint8_t pending{};
+  };
+
+  struct GetProviderPropertyReply {
+    uint8_t format{};
+    uint16_t sequence{};
+    Atom type{};
+    uint32_t bytes_after{};
+    uint32_t num_items{};
+    scoped_refptr<base::RefCountedMemory> data{};
+  };
+
+  using GetProviderPropertyResponse = Response<GetProviderPropertyReply>;
+
+  Future<GetProviderPropertyReply> GetProviderProperty(
+      const GetProviderPropertyRequest& request);
+
+  Future<GetProviderPropertyReply> GetProviderProperty(
+      const Provider& provider = {},
+      const Atom& property = {},
+      const Atom& type = {},
+      const uint32_t& long_offset = {},
+      const uint32_t& long_length = {},
+      const uint8_t& c_delete = {},
+      const uint8_t& pending = {});
+
+  struct GetMonitorsRequest {
+    Window window{};
+    uint8_t get_active{};
+  };
+
+  struct GetMonitorsReply {
+    uint16_t sequence{};
+    Time timestamp{};
+    uint32_t nOutputs{};
+    std::vector<MonitorInfo> monitors{};
+  };
+
+  using GetMonitorsResponse = Response<GetMonitorsReply>;
+
+  Future<GetMonitorsReply> GetMonitors(const GetMonitorsRequest& request);
+
+  Future<GetMonitorsReply> GetMonitors(const Window& window = {},
+                                       const uint8_t& get_active = {});
+
+  struct SetMonitorRequest {
+    Window window{};
+    MonitorInfo monitorinfo{};
+  };
+
+  using SetMonitorResponse = Response<void>;
+
+  Future<void> SetMonitor(const SetMonitorRequest& request);
+
+  Future<void> SetMonitor(const Window& window = {},
+                          const MonitorInfo& monitorinfo =
+                              {{}, {}, {}, {}, {}, {}, {}, {}, {}, {}});
+
+  struct DeleteMonitorRequest {
+    Window window{};
+    Atom name{};
+  };
+
+  using DeleteMonitorResponse = Response<void>;
+
+  Future<void> DeleteMonitor(const DeleteMonitorRequest& request);
+
+  Future<void> DeleteMonitor(const Window& window = {}, const Atom& name = {});
+
+  struct CreateLeaseRequest {
+    Window window{};
+    Lease lid{};
+    std::vector<Crtc> crtcs{};
+    std::vector<Output> outputs{};
+  };
+
+  struct CreateLeaseReply {
+    uint8_t nfd{};
+    uint16_t sequence{};
+    RefCountedFD master_fd{};
+  };
+
+  using CreateLeaseResponse = Response<CreateLeaseReply>;
+
+  Future<CreateLeaseReply> CreateLease(const CreateLeaseRequest& request);
+
+  Future<CreateLeaseReply> CreateLease(const Window& window = {},
+                                       const Lease& lid = {},
+                                       const std::vector<Crtc>& crtcs = {},
+                                       const std::vector<Output>& outputs = {});
+
+  struct FreeLeaseRequest {
+    Lease lid{};
+    uint8_t terminate{};
+  };
+
+  using FreeLeaseResponse = Response<void>;
+
+  Future<void> FreeLease(const FreeLeaseRequest& request);
+
+  Future<void> FreeLease(const Lease& lid = {}, const uint8_t& terminate = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::RandR::Rotation operator|(x11::RandR::Rotation l,
+                                                x11::RandR::Rotation r) {
+  using T = std::underlying_type_t<x11::RandR::Rotation>;
+  return static_cast<x11::RandR::Rotation>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::Rotation operator&(x11::RandR::Rotation l,
+                                                x11::RandR::Rotation r) {
+  using T = std::underlying_type_t<x11::RandR::Rotation>;
+  return static_cast<x11::RandR::Rotation>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::SetConfig operator|(x11::RandR::SetConfig l,
+                                                 x11::RandR::SetConfig r) {
+  using T = std::underlying_type_t<x11::RandR::SetConfig>;
+  return static_cast<x11::RandR::SetConfig>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::SetConfig operator&(x11::RandR::SetConfig l,
+                                                 x11::RandR::SetConfig r) {
+  using T = std::underlying_type_t<x11::RandR::SetConfig>;
+  return static_cast<x11::RandR::SetConfig>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::NotifyMask operator|(x11::RandR::NotifyMask l,
+                                                  x11::RandR::NotifyMask r) {
+  using T = std::underlying_type_t<x11::RandR::NotifyMask>;
+  return static_cast<x11::RandR::NotifyMask>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::NotifyMask operator&(x11::RandR::NotifyMask l,
+                                                  x11::RandR::NotifyMask r) {
+  using T = std::underlying_type_t<x11::RandR::NotifyMask>;
+  return static_cast<x11::RandR::NotifyMask>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::ModeFlag operator|(x11::RandR::ModeFlag l,
+                                                x11::RandR::ModeFlag r) {
+  using T = std::underlying_type_t<x11::RandR::ModeFlag>;
+  return static_cast<x11::RandR::ModeFlag>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::ModeFlag operator&(x11::RandR::ModeFlag l,
+                                                x11::RandR::ModeFlag r) {
+  using T = std::underlying_type_t<x11::RandR::ModeFlag>;
+  return static_cast<x11::RandR::ModeFlag>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::RandRConnection operator|(
+    x11::RandR::RandRConnection l,
+    x11::RandR::RandRConnection r) {
+  using T = std::underlying_type_t<x11::RandR::RandRConnection>;
+  return static_cast<x11::RandR::RandRConnection>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::RandRConnection operator&(
+    x11::RandR::RandRConnection l,
+    x11::RandR::RandRConnection r) {
+  using T = std::underlying_type_t<x11::RandR::RandRConnection>;
+  return static_cast<x11::RandR::RandRConnection>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::Transform operator|(x11::RandR::Transform l,
+                                                 x11::RandR::Transform r) {
+  using T = std::underlying_type_t<x11::RandR::Transform>;
+  return static_cast<x11::RandR::Transform>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::Transform operator&(x11::RandR::Transform l,
+                                                 x11::RandR::Transform r) {
+  using T = std::underlying_type_t<x11::RandR::Transform>;
+  return static_cast<x11::RandR::Transform>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::ProviderCapability operator|(
+    x11::RandR::ProviderCapability l,
+    x11::RandR::ProviderCapability r) {
+  using T = std::underlying_type_t<x11::RandR::ProviderCapability>;
+  return static_cast<x11::RandR::ProviderCapability>(static_cast<T>(l) |
+                                                     static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::ProviderCapability operator&(
+    x11::RandR::ProviderCapability l,
+    x11::RandR::ProviderCapability r) {
+  using T = std::underlying_type_t<x11::RandR::ProviderCapability>;
+  return static_cast<x11::RandR::ProviderCapability>(static_cast<T>(l) &
+                                                     static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::Notify operator|(x11::RandR::Notify l,
+                                              x11::RandR::Notify r) {
+  using T = std::underlying_type_t<x11::RandR::Notify>;
+  return static_cast<x11::RandR::Notify>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::RandR::Notify operator&(x11::RandR::Notify l,
+                                              x11::RandR::Notify r) {
+  using T = std::underlying_type_t<x11::RandR::Notify>;
+  return static_cast<x11::RandR::Notify>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_RANDR_H_
diff --git a/ui/gfx/x/generated_protos/read_error.cc b/ui/gfx/x/generated_protos/read_error.cc
new file mode 100644
index 0000000..1414180
--- /dev/null
+++ b/ui/gfx/x/generated_protos/read_error.cc
@@ -0,0 +1,530 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+#include "ui/gfx/x/bigreq.h"
+#include "ui/gfx/x/composite.h"
+#include "ui/gfx/x/damage.h"
+#include "ui/gfx/x/dpms.h"
+#include "ui/gfx/x/dri2.h"
+#include "ui/gfx/x/dri3.h"
+#include "ui/gfx/x/ge.h"
+#include "ui/gfx/x/glx.h"
+#include "ui/gfx/x/present.h"
+#include "ui/gfx/x/randr.h"
+#include "ui/gfx/x/record.h"
+#include "ui/gfx/x/render.h"
+#include "ui/gfx/x/res.h"
+#include "ui/gfx/x/screensaver.h"
+#include "ui/gfx/x/shape.h"
+#include "ui/gfx/x/shm.h"
+#include "ui/gfx/x/sync.h"
+#include "ui/gfx/x/xc_misc.h"
+#include "ui/gfx/x/xevie.h"
+#include "ui/gfx/x/xf86dri.h"
+#include "ui/gfx/x/xf86vidmode.h"
+#include "ui/gfx/x/xfixes.h"
+#include "ui/gfx/x/xinerama.h"
+#include "ui/gfx/x/xinput.h"
+#include "ui/gfx/x/xkb.h"
+#include "ui/gfx/x/xprint.h"
+#include "ui/gfx/x/xproto.h"
+#include "ui/gfx/x/xselinux.h"
+#include "ui/gfx/x/xtest.h"
+#include "ui/gfx/x/xv.h"
+#include "ui/gfx/x/xvmc.h"
+
+namespace x11 {
+
+namespace {
+
+template <typename T>
+std::unique_ptr<Error> MakeError(Connection::RawError error_) {
+  ReadBuffer buf(error_);
+  auto error = std::make_unique<T>();
+  ReadError(error.get(), &buf);
+  return error;
+}
+
+}  // namespace
+
+void Connection::InitErrorParsers() {
+  uint8_t first_errors[256];
+  memset(first_errors, 0, sizeof(first_errors));
+
+  auto add_parser = [&](uint8_t error_code, uint8_t first_error,
+                        ErrorParser parser) {
+    if (!error_parsers_[error_code] || first_error > first_errors[error_code]) {
+      first_errors[error_code] = error_code;
+      error_parsers_[error_code] = parser;
+    }
+  };
+
+  if (damage().present()) {
+    uint8_t first_error = damage().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Damage::BadDamageError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (glx().present()) {
+    uint8_t first_error = glx().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Glx::BadContextError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<Glx::BadContextStateError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 2;
+      auto parse = MakeError<Glx::BadDrawableError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 3;
+      auto parse = MakeError<Glx::BadPixmapError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 4;
+      auto parse = MakeError<Glx::BadContextTagError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 5;
+      auto parse = MakeError<Glx::BadCurrentWindowError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 6;
+      auto parse = MakeError<Glx::BadRenderRequestError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 7;
+      auto parse = MakeError<Glx::BadLargeRequestError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 8;
+      auto parse = MakeError<Glx::UnsupportedPrivateRequestError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 9;
+      auto parse = MakeError<Glx::BadFBConfigError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 10;
+      auto parse = MakeError<Glx::BadPbufferError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 11;
+      auto parse = MakeError<Glx::BadCurrentDrawableError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 12;
+      auto parse = MakeError<Glx::BadWindowError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 13;
+      auto parse = MakeError<Glx::GLXBadProfileARBError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (randr().present()) {
+    uint8_t first_error = randr().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<RandR::BadOutputError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<RandR::BadCrtcError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 2;
+      auto parse = MakeError<RandR::BadModeError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 3;
+      auto parse = MakeError<RandR::BadProviderError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (record().present()) {
+    uint8_t first_error = record().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Record::BadContextError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (render().present()) {
+    uint8_t first_error = render().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Render::PictFormatError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<Render::PictureError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 2;
+      auto parse = MakeError<Render::PictOpError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 3;
+      auto parse = MakeError<Render::GlyphSetError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 4;
+      auto parse = MakeError<Render::GlyphError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (shm().present()) {
+    uint8_t first_error = shm().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Shm::BadSegError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 2;
+      auto parse = MakeError<ValueError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 3;
+      auto parse = MakeError<WindowError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 4;
+      auto parse = MakeError<PixmapError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 5;
+      auto parse = MakeError<AtomError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 6;
+      auto parse = MakeError<CursorError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 7;
+      auto parse = MakeError<FontError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 9;
+      auto parse = MakeError<DrawableError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 12;
+      auto parse = MakeError<ColormapError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 13;
+      auto parse = MakeError<GContextError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 14;
+      auto parse = MakeError<IDChoiceError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (sync().present()) {
+    uint8_t first_error = sync().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Sync::CounterError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<Sync::AlarmError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (xf86vidmode().present()) {
+    uint8_t first_error = xf86vidmode().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<XF86VidMode::BadClockError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<XF86VidMode::BadHTimingsError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 2;
+      auto parse = MakeError<XF86VidMode::BadVTimingsError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 3;
+      auto parse = MakeError<XF86VidMode::ModeUnsuitableError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 4;
+      auto parse = MakeError<XF86VidMode::ExtensionDisabledError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 5;
+      auto parse = MakeError<XF86VidMode::ClientNotLocalError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 6;
+      auto parse = MakeError<XF86VidMode::ZoomLockedError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (xfixes().present()) {
+    uint8_t first_error = xfixes().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<XFixes::BadRegionError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (xinput().present()) {
+    uint8_t first_error = xinput().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Input::DeviceError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<Input::EventError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 2;
+      auto parse = MakeError<Input::ModeError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 3;
+      auto parse = MakeError<Input::DeviceBusyError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 4;
+      auto parse = MakeError<Input::ClassError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (xkb().present()) {
+    uint8_t first_error = xkb().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Xkb::KeyboardError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (xprint().present()) {
+    uint8_t first_error = xprint().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<XPrint::BadContextError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<XPrint::BadSequenceError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  {
+    uint8_t first_error = 0;
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<RequestError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 2;
+      auto parse = MakeError<ValueError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 3;
+      auto parse = MakeError<WindowError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 4;
+      auto parse = MakeError<PixmapError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 5;
+      auto parse = MakeError<AtomError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 6;
+      auto parse = MakeError<CursorError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 7;
+      auto parse = MakeError<FontError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 8;
+      auto parse = MakeError<MatchError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 9;
+      auto parse = MakeError<DrawableError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 10;
+      auto parse = MakeError<AccessError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 11;
+      auto parse = MakeError<AllocError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 12;
+      auto parse = MakeError<ColormapError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 13;
+      auto parse = MakeError<GContextError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 14;
+      auto parse = MakeError<IDChoiceError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 15;
+      auto parse = MakeError<NameError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 16;
+      auto parse = MakeError<LengthError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 17;
+      auto parse = MakeError<ImplementationError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+
+  if (xv().present()) {
+    uint8_t first_error = xv().first_error();
+    {
+      auto error_code = first_error + 0;
+      auto parse = MakeError<Xv::BadPortError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 1;
+      auto parse = MakeError<Xv::BadEncodingError>;
+      add_parser(error_code, first_error, parse);
+    }
+    {
+      auto error_code = first_error + 2;
+      auto parse = MakeError<Xv::BadControlError>;
+      add_parser(error_code, first_error, parse);
+    }
+  }
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/read_event.cc b/ui/gfx/x/generated_protos/read_event.cc
new file mode 100644
index 0000000..a6a308f
--- /dev/null
+++ b/ui/gfx/x/generated_protos/read_event.cc
@@ -0,0 +1,1260 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "ui/gfx/x/event.h"
+
+#include <xcb/xcb.h>
+
+#include "ui/gfx/x/bigreq.h"
+#include "ui/gfx/x/composite.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/damage.h"
+#include "ui/gfx/x/dpms.h"
+#include "ui/gfx/x/dri2.h"
+#include "ui/gfx/x/dri3.h"
+#include "ui/gfx/x/ge.h"
+#include "ui/gfx/x/glx.h"
+#include "ui/gfx/x/present.h"
+#include "ui/gfx/x/randr.h"
+#include "ui/gfx/x/record.h"
+#include "ui/gfx/x/render.h"
+#include "ui/gfx/x/res.h"
+#include "ui/gfx/x/screensaver.h"
+#include "ui/gfx/x/shape.h"
+#include "ui/gfx/x/shm.h"
+#include "ui/gfx/x/sync.h"
+#include "ui/gfx/x/xc_misc.h"
+#include "ui/gfx/x/xevie.h"
+#include "ui/gfx/x/xf86dri.h"
+#include "ui/gfx/x/xf86vidmode.h"
+#include "ui/gfx/x/xfixes.h"
+#include "ui/gfx/x/xinerama.h"
+#include "ui/gfx/x/xinput.h"
+#include "ui/gfx/x/xkb.h"
+#include "ui/gfx/x/xprint.h"
+#include "ui/gfx/x/xproto.h"
+#include "ui/gfx/x/xproto_types.h"
+#include "ui/gfx/x/xselinux.h"
+#include "ui/gfx/x/xtest.h"
+#include "ui/gfx/x/xv.h"
+#include "ui/gfx/x/xvmc.h"
+
+namespace x11 {
+
+void ReadEvent(Event* event, Connection* conn, ReadBuffer* buffer) {
+  auto* buf = buffer->data->data();
+  auto* ev = reinterpret_cast<const xcb_generic_event_t*>(buf);
+  auto* ge = reinterpret_cast<const xcb_ge_generic_event_t*>(buf);
+  auto evtype = ev->response_type & ~kSendEventMask;
+  bool send_event = ev->response_type & kSendEventMask;
+
+  if (conn->damage().present() &&
+      evtype - conn->damage().first_event() == Damage::NotifyEvent::opcode) {
+    event->type_id_ = 1;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Damage::NotifyEvent*>(event);
+    };
+    auto* event_ = new Damage::NotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->dri2().present() && evtype - conn->dri2().first_event() ==
+                                    Dri2::BufferSwapCompleteEvent::opcode) {
+    event->type_id_ = 2;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Dri2::BufferSwapCompleteEvent*>(event);
+    };
+    auto* event_ = new Dri2::BufferSwapCompleteEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->dri2().present() && evtype - conn->dri2().first_event() ==
+                                    Dri2::InvalidateBuffersEvent::opcode) {
+    event->type_id_ = 3;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Dri2::InvalidateBuffersEvent*>(event);
+    };
+    auto* event_ = new Dri2::InvalidateBuffersEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->glx().present() &&
+      evtype - conn->glx().first_event() == Glx::PbufferClobberEvent::opcode) {
+    event->type_id_ = 4;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Glx::PbufferClobberEvent*>(event);
+    };
+    auto* event_ = new Glx::PbufferClobberEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->glx().present() && evtype - conn->glx().first_event() ==
+                                   Glx::BufferSwapCompleteEvent::opcode) {
+    event->type_id_ = 5;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Glx::BufferSwapCompleteEvent*>(event);
+    };
+    auto* event_ = new Glx::BufferSwapCompleteEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->present().present() &&
+      evtype - conn->present().first_event() == Present::GenericEvent::opcode) {
+    event->type_id_ = 6;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Present::GenericEvent*>(event);
+    };
+    auto* event_ = new Present::GenericEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->present().present() &&
+      ge->extension == conn->present().major_opcode() &&
+      ge->event_type == Present::ConfigureNotifyEvent::opcode) {
+    event->type_id_ = 7;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Present::ConfigureNotifyEvent*>(event);
+    };
+    auto* event_ = new Present::ConfigureNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->present().present() &&
+      ge->extension == conn->present().major_opcode() &&
+      ge->event_type == Present::CompleteNotifyEvent::opcode) {
+    event->type_id_ = 8;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Present::CompleteNotifyEvent*>(event);
+    };
+    auto* event_ = new Present::CompleteNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->present().present() &&
+      ge->extension == conn->present().major_opcode() &&
+      ge->event_type == Present::IdleNotifyEvent::opcode) {
+    event->type_id_ = 9;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Present::IdleNotifyEvent*>(event);
+    };
+    auto* event_ = new Present::IdleNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->present().present() &&
+      ge->extension == conn->present().major_opcode() &&
+      ge->event_type == Present::RedirectNotifyEvent::opcode) {
+    event->type_id_ = 10;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Present::RedirectNotifyEvent*>(event);
+    };
+    auto* event_ = new Present::RedirectNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->randr().present() && evtype - conn->randr().first_event() ==
+                                     RandR::ScreenChangeNotifyEvent::opcode) {
+    event->type_id_ = 11;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<RandR::ScreenChangeNotifyEvent*>(event);
+    };
+    auto* event_ = new RandR::ScreenChangeNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->randr().present() &&
+      evtype - conn->randr().first_event() == RandR::NotifyEvent::opcode) {
+    event->type_id_ = 12;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<RandR::NotifyEvent*>(event);
+    };
+    auto* event_ = new RandR::NotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->screensaver().present() &&
+      evtype - conn->screensaver().first_event() ==
+          ScreenSaver::NotifyEvent::opcode) {
+    event->type_id_ = 13;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ScreenSaver::NotifyEvent*>(event);
+    };
+    auto* event_ = new ScreenSaver::NotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->shape().present() &&
+      evtype - conn->shape().first_event() == Shape::NotifyEvent::opcode) {
+    event->type_id_ = 14;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Shape::NotifyEvent*>(event);
+    };
+    auto* event_ = new Shape::NotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->shm().present() &&
+      evtype - conn->shm().first_event() == Shm::CompletionEvent::opcode) {
+    event->type_id_ = 15;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Shm::CompletionEvent*>(event);
+    };
+    auto* event_ = new Shm::CompletionEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->sync().present() &&
+      evtype - conn->sync().first_event() == Sync::CounterNotifyEvent::opcode) {
+    event->type_id_ = 16;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Sync::CounterNotifyEvent*>(event);
+    };
+    auto* event_ = new Sync::CounterNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->sync().present() &&
+      evtype - conn->sync().first_event() == Sync::AlarmNotifyEvent::opcode) {
+    event->type_id_ = 17;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Sync::AlarmNotifyEvent*>(event);
+    };
+    auto* event_ = new Sync::AlarmNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xfixes().present() && evtype - conn->xfixes().first_event() ==
+                                      XFixes::SelectionNotifyEvent::opcode) {
+    event->type_id_ = 18;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<XFixes::SelectionNotifyEvent*>(event);
+    };
+    auto* event_ = new XFixes::SelectionNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xfixes().present() && evtype - conn->xfixes().first_event() ==
+                                      XFixes::CursorNotifyEvent::opcode) {
+    event->type_id_ = 19;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<XFixes::CursorNotifyEvent*>(event);
+    };
+    auto* event_ = new XFixes::CursorNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() && evtype - conn->xinput().first_event() ==
+                                      Input::DeviceValuatorEvent::opcode) {
+    event->type_id_ = 20;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DeviceValuatorEvent*>(event);
+    };
+    auto* event_ = new Input::DeviceValuatorEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() &&
+      (evtype - conn->xinput().first_event() ==
+           Input::LegacyDeviceEvent::DeviceButtonRelease ||
+       evtype - conn->xinput().first_event() ==
+           Input::LegacyDeviceEvent::ProximityIn ||
+       evtype - conn->xinput().first_event() ==
+           Input::LegacyDeviceEvent::DeviceKeyRelease ||
+       evtype - conn->xinput().first_event() ==
+           Input::LegacyDeviceEvent::DeviceButtonPress ||
+       evtype - conn->xinput().first_event() ==
+           Input::LegacyDeviceEvent::ProximityOut ||
+       evtype - conn->xinput().first_event() ==
+           Input::LegacyDeviceEvent::DeviceKeyPress ||
+       evtype - conn->xinput().first_event() ==
+           Input::LegacyDeviceEvent::DeviceMotionNotify)) {
+    event->type_id_ = 21;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::LegacyDeviceEvent*>(event);
+    };
+    auto* event_ = new Input::LegacyDeviceEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(
+        evtype - conn->xinput().first_event());
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() &&
+      (evtype - conn->xinput().first_event() == Input::DeviceFocusEvent::In ||
+       evtype - conn->xinput().first_event() == Input::DeviceFocusEvent::Out)) {
+    event->type_id_ = 22;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DeviceFocusEvent*>(event);
+    };
+    auto* event_ = new Input::DeviceFocusEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(
+        evtype - conn->xinput().first_event());
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() && evtype - conn->xinput().first_event() ==
+                                      Input::DeviceStateNotifyEvent::opcode) {
+    event->type_id_ = 23;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DeviceStateNotifyEvent*>(event);
+    };
+    auto* event_ = new Input::DeviceStateNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() && evtype - conn->xinput().first_event() ==
+                                      Input::DeviceMappingNotifyEvent::opcode) {
+    event->type_id_ = 24;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DeviceMappingNotifyEvent*>(event);
+    };
+    auto* event_ = new Input::DeviceMappingNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() && evtype - conn->xinput().first_event() ==
+                                      Input::ChangeDeviceNotifyEvent::opcode) {
+    event->type_id_ = 25;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::ChangeDeviceNotifyEvent*>(event);
+    };
+    auto* event_ = new Input::ChangeDeviceNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() &&
+      evtype - conn->xinput().first_event() ==
+          Input::DeviceKeyStateNotifyEvent::opcode) {
+    event->type_id_ = 26;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DeviceKeyStateNotifyEvent*>(event);
+    };
+    auto* event_ = new Input::DeviceKeyStateNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() &&
+      evtype - conn->xinput().first_event() ==
+          Input::DeviceButtonStateNotifyEvent::opcode) {
+    event->type_id_ = 27;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DeviceButtonStateNotifyEvent*>(event);
+    };
+    auto* event_ = new Input::DeviceButtonStateNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() &&
+      evtype - conn->xinput().first_event() ==
+          Input::DevicePresenceNotifyEvent::opcode) {
+    event->type_id_ = 28;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DevicePresenceNotifyEvent*>(event);
+    };
+    auto* event_ = new Input::DevicePresenceNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xinput().present() &&
+      evtype - conn->xinput().first_event() ==
+          Input::DevicePropertyNotifyEvent::opcode) {
+    event->type_id_ = 29;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DevicePropertyNotifyEvent*>(event);
+    };
+    auto* event_ = new Input::DevicePropertyNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->xinput().present() &&
+      ge->extension == conn->xinput().major_opcode() &&
+      ge->event_type == Input::DeviceChangedEvent::opcode) {
+    event->type_id_ = 30;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DeviceChangedEvent*>(event);
+    };
+    auto* event_ = new Input::DeviceChangedEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->xinput().present() &&
+      ge->extension == conn->xinput().major_opcode() &&
+      (ge->event_type == Input::DeviceEvent::ButtonPress ||
+       ge->event_type == Input::DeviceEvent::TouchEnd ||
+       ge->event_type == Input::DeviceEvent::KeyRelease ||
+       ge->event_type == Input::DeviceEvent::TouchUpdate ||
+       ge->event_type == Input::DeviceEvent::KeyPress ||
+       ge->event_type == Input::DeviceEvent::Motion ||
+       ge->event_type == Input::DeviceEvent::TouchBegin ||
+       ge->event_type == Input::DeviceEvent::ButtonRelease)) {
+    event->type_id_ = 31;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::DeviceEvent*>(event);
+    };
+    auto* event_ = new Input::DeviceEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(ge->event_type);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->xinput().present() &&
+      ge->extension == conn->xinput().major_opcode() &&
+      (ge->event_type == Input::CrossingEvent::Leave ||
+       ge->event_type == Input::CrossingEvent::FocusIn ||
+       ge->event_type == Input::CrossingEvent::FocusOut ||
+       ge->event_type == Input::CrossingEvent::Enter)) {
+    event->type_id_ = 32;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::CrossingEvent*>(event);
+    };
+    auto* event_ = new Input::CrossingEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(ge->event_type);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->xinput().present() &&
+      ge->extension == conn->xinput().major_opcode() &&
+      ge->event_type == Input::HierarchyEvent::opcode) {
+    event->type_id_ = 33;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::HierarchyEvent*>(event);
+    };
+    auto* event_ = new Input::HierarchyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->xinput().present() &&
+      ge->extension == conn->xinput().major_opcode() &&
+      ge->event_type == Input::PropertyEvent::opcode) {
+    event->type_id_ = 34;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::PropertyEvent*>(event);
+    };
+    auto* event_ = new Input::PropertyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->xinput().present() &&
+      ge->extension == conn->xinput().major_opcode() &&
+      (ge->event_type == Input::RawDeviceEvent::RawTouchEnd ||
+       ge->event_type == Input::RawDeviceEvent::RawTouchUpdate ||
+       ge->event_type == Input::RawDeviceEvent::RawTouchBegin ||
+       ge->event_type == Input::RawDeviceEvent::RawButtonRelease ||
+       ge->event_type == Input::RawDeviceEvent::RawMotion ||
+       ge->event_type == Input::RawDeviceEvent::RawButtonPress ||
+       ge->event_type == Input::RawDeviceEvent::RawKeyRelease ||
+       ge->event_type == Input::RawDeviceEvent::RawKeyPress)) {
+    event->type_id_ = 35;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::RawDeviceEvent*>(event);
+    };
+    auto* event_ = new Input::RawDeviceEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(ge->event_type);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->xinput().present() &&
+      ge->extension == conn->xinput().major_opcode() &&
+      ge->event_type == Input::TouchOwnershipEvent::opcode) {
+    event->type_id_ = 36;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::TouchOwnershipEvent*>(event);
+    };
+    auto* event_ = new Input::TouchOwnershipEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GeGenericEvent::opcode && conn->xinput().present() &&
+      ge->extension == conn->xinput().major_opcode() &&
+      (ge->event_type == Input::BarrierEvent::Leave ||
+       ge->event_type == Input::BarrierEvent::Hit)) {
+    event->type_id_ = 37;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Input::BarrierEvent*>(event);
+    };
+    auto* event_ = new Input::BarrierEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(ge->event_type);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() && evtype - conn->xkb().first_event() ==
+                                   Xkb::NewKeyboardNotifyEvent::opcode) {
+    event->type_id_ = 38;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::NewKeyboardNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::NewKeyboardNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() &&
+      evtype - conn->xkb().first_event() == Xkb::MapNotifyEvent::opcode) {
+    event->type_id_ = 39;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::MapNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::MapNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() &&
+      evtype - conn->xkb().first_event() == Xkb::StateNotifyEvent::opcode) {
+    event->type_id_ = 40;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::StateNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::StateNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() &&
+      evtype - conn->xkb().first_event() == Xkb::ControlsNotifyEvent::opcode) {
+    event->type_id_ = 41;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::ControlsNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::ControlsNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() && evtype - conn->xkb().first_event() ==
+                                   Xkb::IndicatorStateNotifyEvent::opcode) {
+    event->type_id_ = 42;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::IndicatorStateNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::IndicatorStateNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() && evtype - conn->xkb().first_event() ==
+                                   Xkb::IndicatorMapNotifyEvent::opcode) {
+    event->type_id_ = 43;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::IndicatorMapNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::IndicatorMapNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() &&
+      evtype - conn->xkb().first_event() == Xkb::NamesNotifyEvent::opcode) {
+    event->type_id_ = 44;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::NamesNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::NamesNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() &&
+      evtype - conn->xkb().first_event() == Xkb::CompatMapNotifyEvent::opcode) {
+    event->type_id_ = 45;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::CompatMapNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::CompatMapNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() &&
+      evtype - conn->xkb().first_event() == Xkb::BellNotifyEvent::opcode) {
+    event->type_id_ = 46;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::BellNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::BellNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() &&
+      evtype - conn->xkb().first_event() == Xkb::ActionMessageEvent::opcode) {
+    event->type_id_ = 47;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::ActionMessageEvent*>(event);
+    };
+    auto* event_ = new Xkb::ActionMessageEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() &&
+      evtype - conn->xkb().first_event() == Xkb::AccessXNotifyEvent::opcode) {
+    event->type_id_ = 48;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::AccessXNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::AccessXNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xkb().present() && evtype - conn->xkb().first_event() ==
+                                   Xkb::ExtensionDeviceNotifyEvent::opcode) {
+    event->type_id_ = 49;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xkb::ExtensionDeviceNotifyEvent*>(event);
+    };
+    auto* event_ = new Xkb::ExtensionDeviceNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xprint().present() &&
+      evtype - conn->xprint().first_event() == XPrint::NotifyEvent::opcode) {
+    event->type_id_ = 50;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<XPrint::NotifyEvent*>(event);
+    };
+    auto* event_ = new XPrint::NotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xprint().present() && evtype - conn->xprint().first_event() ==
+                                      XPrint::AttributNotifyEvent::opcode) {
+    event->type_id_ = 51;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<XPrint::AttributNotifyEvent*>(event);
+    };
+    auto* event_ = new XPrint::AttributNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if ((evtype == KeyEvent::Release || evtype == KeyEvent::Press)) {
+    event->type_id_ = 52;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<KeyEvent*>(event);
+    };
+    auto* event_ = new KeyEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(evtype);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if ((evtype == ButtonEvent::Release || evtype == ButtonEvent::Press)) {
+    event->type_id_ = 53;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ButtonEvent*>(event);
+    };
+    auto* event_ = new ButtonEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(evtype);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == MotionNotifyEvent::opcode) {
+    event->type_id_ = 54;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<MotionNotifyEvent*>(event);
+    };
+    auto* event_ = new MotionNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if ((evtype == CrossingEvent::EnterNotify ||
+       evtype == CrossingEvent::LeaveNotify)) {
+    event->type_id_ = 55;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<CrossingEvent*>(event);
+    };
+    auto* event_ = new CrossingEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(evtype);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if ((evtype == FocusEvent::Out || evtype == FocusEvent::In)) {
+    event->type_id_ = 56;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<FocusEvent*>(event);
+    };
+    auto* event_ = new FocusEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(evtype);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == KeymapNotifyEvent::opcode) {
+    event->type_id_ = 57;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<KeymapNotifyEvent*>(event);
+    };
+    auto* event_ = new KeymapNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == ExposeEvent::opcode) {
+    event->type_id_ = 58;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ExposeEvent*>(event);
+    };
+    auto* event_ = new ExposeEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GraphicsExposureEvent::opcode) {
+    event->type_id_ = 59;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<GraphicsExposureEvent*>(event);
+    };
+    auto* event_ = new GraphicsExposureEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == NoExposureEvent::opcode) {
+    event->type_id_ = 60;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<NoExposureEvent*>(event);
+    };
+    auto* event_ = new NoExposureEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == VisibilityNotifyEvent::opcode) {
+    event->type_id_ = 61;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<VisibilityNotifyEvent*>(event);
+    };
+    auto* event_ = new VisibilityNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == CreateNotifyEvent::opcode) {
+    event->type_id_ = 62;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<CreateNotifyEvent*>(event);
+    };
+    auto* event_ = new CreateNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == DestroyNotifyEvent::opcode) {
+    event->type_id_ = 63;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<DestroyNotifyEvent*>(event);
+    };
+    auto* event_ = new DestroyNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == UnmapNotifyEvent::opcode) {
+    event->type_id_ = 64;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<UnmapNotifyEvent*>(event);
+    };
+    auto* event_ = new UnmapNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == MapNotifyEvent::opcode) {
+    event->type_id_ = 65;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<MapNotifyEvent*>(event);
+    };
+    auto* event_ = new MapNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == MapRequestEvent::opcode) {
+    event->type_id_ = 66;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<MapRequestEvent*>(event);
+    };
+    auto* event_ = new MapRequestEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == ReparentNotifyEvent::opcode) {
+    event->type_id_ = 67;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ReparentNotifyEvent*>(event);
+    };
+    auto* event_ = new ReparentNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == ConfigureNotifyEvent::opcode) {
+    event->type_id_ = 68;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ConfigureNotifyEvent*>(event);
+    };
+    auto* event_ = new ConfigureNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == ConfigureRequestEvent::opcode) {
+    event->type_id_ = 69;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ConfigureRequestEvent*>(event);
+    };
+    auto* event_ = new ConfigureRequestEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == GravityNotifyEvent::opcode) {
+    event->type_id_ = 70;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<GravityNotifyEvent*>(event);
+    };
+    auto* event_ = new GravityNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == ResizeRequestEvent::opcode) {
+    event->type_id_ = 71;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ResizeRequestEvent*>(event);
+    };
+    auto* event_ = new ResizeRequestEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if ((evtype == CirculateEvent::Request || evtype == CirculateEvent::Notify)) {
+    event->type_id_ = 72;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<CirculateEvent*>(event);
+    };
+    auto* event_ = new CirculateEvent;
+    ReadEvent(event_, buffer);
+    event_->opcode = static_cast<decltype(event_->opcode)>(evtype);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == PropertyNotifyEvent::opcode) {
+    event->type_id_ = 73;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<PropertyNotifyEvent*>(event);
+    };
+    auto* event_ = new PropertyNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == SelectionClearEvent::opcode) {
+    event->type_id_ = 74;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<SelectionClearEvent*>(event);
+    };
+    auto* event_ = new SelectionClearEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == SelectionRequestEvent::opcode) {
+    event->type_id_ = 75;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<SelectionRequestEvent*>(event);
+    };
+    auto* event_ = new SelectionRequestEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == SelectionNotifyEvent::opcode) {
+    event->type_id_ = 76;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<SelectionNotifyEvent*>(event);
+    };
+    auto* event_ = new SelectionNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == ColormapNotifyEvent::opcode) {
+    event->type_id_ = 77;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ColormapNotifyEvent*>(event);
+    };
+    auto* event_ = new ColormapNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == ClientMessageEvent::opcode) {
+    event->type_id_ = 78;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<ClientMessageEvent*>(event);
+    };
+    auto* event_ = new ClientMessageEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (evtype == MappingNotifyEvent::opcode) {
+    event->type_id_ = 79;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<MappingNotifyEvent*>(event);
+    };
+    auto* event_ = new MappingNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xv().present() &&
+      evtype - conn->xv().first_event() == Xv::VideoNotifyEvent::opcode) {
+    event->type_id_ = 81;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xv::VideoNotifyEvent*>(event);
+    };
+    auto* event_ = new Xv::VideoNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  if (conn->xv().present() &&
+      evtype - conn->xv().first_event() == Xv::PortNotifyEvent::opcode) {
+    event->type_id_ = 82;
+    event->deleter_ = [](void* event) {
+      delete reinterpret_cast<Xv::PortNotifyEvent*>(event);
+    };
+    auto* event_ = new Xv::PortNotifyEvent;
+    ReadEvent(event_, buffer);
+    event_->send_event = send_event;
+    event->event_ = event_;
+    event->window_ = event_->GetWindow();
+    return;
+  }
+
+  NOTREACHED();
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/record.cc b/ui/gfx/x/generated_protos/record.cc
new file mode 100644
index 0000000..3976979
--- /dev/null
+++ b/ui/gfx/x/generated_protos/record.cc
@@ -0,0 +1,1040 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "record.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Record::Record(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string Record::BadContextError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Record::BadContextError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".invalid_record = " << static_cast<uint64_t>(invalid_record);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Record::BadContextError>(Record::BadContextError* error_,
+                                        ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& invalid_record = (*error_).invalid_record;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // invalid_record
+  Read(&invalid_record, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+Future<Record::QueryVersionReply> Record::QueryVersion(
+    const Record::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Record::QueryVersionReply>(
+      &buf, "Record::QueryVersion", false);
+}
+
+Future<Record::QueryVersionReply> Record::QueryVersion(
+    const uint16_t& major_version,
+    const uint16_t& minor_version) {
+  return Record::QueryVersion(
+      Record::QueryVersionRequest{major_version, minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Record::QueryVersionReply> detail::ReadReply<
+    Record::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Record::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Record::CreateContext(
+    const Record::CreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& element_header = request.element_header;
+  uint32_t num_client_specs{};
+  uint32_t num_ranges{};
+  auto& client_specs = request.client_specs;
+  size_t client_specs_len = client_specs.size();
+  auto& ranges = request.ranges;
+  size_t ranges_len = ranges.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // element_header
+  buf.Write(&element_header);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // num_client_specs
+  num_client_specs = client_specs.size();
+  buf.Write(&num_client_specs);
+
+  // num_ranges
+  num_ranges = ranges.size();
+  buf.Write(&num_ranges);
+
+  // client_specs
+  DCHECK_EQ(static_cast<size_t>(num_client_specs), client_specs.size());
+  for (auto& client_specs_elem : client_specs) {
+    // client_specs_elem
+    buf.Write(&client_specs_elem);
+  }
+
+  // ranges
+  DCHECK_EQ(static_cast<size_t>(num_ranges), ranges.size());
+  for (auto& ranges_elem : ranges) {
+    // ranges_elem
+    {
+      auto& core_requests = ranges_elem.core_requests;
+      auto& core_replies = ranges_elem.core_replies;
+      auto& ext_requests = ranges_elem.ext_requests;
+      auto& ext_replies = ranges_elem.ext_replies;
+      auto& delivered_events = ranges_elem.delivered_events;
+      auto& device_events = ranges_elem.device_events;
+      auto& errors = ranges_elem.errors;
+      auto& client_started = ranges_elem.client_started;
+      auto& client_died = ranges_elem.client_died;
+
+      // core_requests
+      {
+        auto& first = core_requests.first;
+        auto& last = core_requests.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // core_replies
+      {
+        auto& first = core_replies.first;
+        auto& last = core_replies.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // ext_requests
+      {
+        auto& major = ext_requests.major;
+        auto& minor = ext_requests.minor;
+
+        // major
+        {
+          auto& first = major.first;
+          auto& last = major.last;
+
+          // first
+          buf.Write(&first);
+
+          // last
+          buf.Write(&last);
+        }
+
+        // minor
+        {
+          auto& first = minor.first;
+          auto& last = minor.last;
+
+          // first
+          buf.Write(&first);
+
+          // last
+          buf.Write(&last);
+        }
+      }
+
+      // ext_replies
+      {
+        auto& major = ext_replies.major;
+        auto& minor = ext_replies.minor;
+
+        // major
+        {
+          auto& first = major.first;
+          auto& last = major.last;
+
+          // first
+          buf.Write(&first);
+
+          // last
+          buf.Write(&last);
+        }
+
+        // minor
+        {
+          auto& first = minor.first;
+          auto& last = minor.last;
+
+          // first
+          buf.Write(&first);
+
+          // last
+          buf.Write(&last);
+        }
+      }
+
+      // delivered_events
+      {
+        auto& first = delivered_events.first;
+        auto& last = delivered_events.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // device_events
+      {
+        auto& first = device_events.first;
+        auto& last = device_events.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // errors
+      {
+        auto& first = errors.first;
+        auto& last = errors.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // client_started
+      buf.Write(&client_started);
+
+      // client_died
+      buf.Write(&client_died);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Record::CreateContext", false);
+}
+
+Future<void> Record::CreateContext(const Context& context,
+                                   const ElementHeader& element_header,
+                                   const std::vector<ClientSpec>& client_specs,
+                                   const std::vector<Range>& ranges) {
+  return Record::CreateContext(Record::CreateContextRequest{
+      context, element_header, client_specs, ranges});
+}
+
+Future<void> Record::RegisterClients(
+    const Record::RegisterClientsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& element_header = request.element_header;
+  uint32_t num_client_specs{};
+  uint32_t num_ranges{};
+  auto& client_specs = request.client_specs;
+  size_t client_specs_len = client_specs.size();
+  auto& ranges = request.ranges;
+  size_t ranges_len = ranges.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // element_header
+  buf.Write(&element_header);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // num_client_specs
+  num_client_specs = client_specs.size();
+  buf.Write(&num_client_specs);
+
+  // num_ranges
+  num_ranges = ranges.size();
+  buf.Write(&num_ranges);
+
+  // client_specs
+  DCHECK_EQ(static_cast<size_t>(num_client_specs), client_specs.size());
+  for (auto& client_specs_elem : client_specs) {
+    // client_specs_elem
+    buf.Write(&client_specs_elem);
+  }
+
+  // ranges
+  DCHECK_EQ(static_cast<size_t>(num_ranges), ranges.size());
+  for (auto& ranges_elem : ranges) {
+    // ranges_elem
+    {
+      auto& core_requests = ranges_elem.core_requests;
+      auto& core_replies = ranges_elem.core_replies;
+      auto& ext_requests = ranges_elem.ext_requests;
+      auto& ext_replies = ranges_elem.ext_replies;
+      auto& delivered_events = ranges_elem.delivered_events;
+      auto& device_events = ranges_elem.device_events;
+      auto& errors = ranges_elem.errors;
+      auto& client_started = ranges_elem.client_started;
+      auto& client_died = ranges_elem.client_died;
+
+      // core_requests
+      {
+        auto& first = core_requests.first;
+        auto& last = core_requests.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // core_replies
+      {
+        auto& first = core_replies.first;
+        auto& last = core_replies.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // ext_requests
+      {
+        auto& major = ext_requests.major;
+        auto& minor = ext_requests.minor;
+
+        // major
+        {
+          auto& first = major.first;
+          auto& last = major.last;
+
+          // first
+          buf.Write(&first);
+
+          // last
+          buf.Write(&last);
+        }
+
+        // minor
+        {
+          auto& first = minor.first;
+          auto& last = minor.last;
+
+          // first
+          buf.Write(&first);
+
+          // last
+          buf.Write(&last);
+        }
+      }
+
+      // ext_replies
+      {
+        auto& major = ext_replies.major;
+        auto& minor = ext_replies.minor;
+
+        // major
+        {
+          auto& first = major.first;
+          auto& last = major.last;
+
+          // first
+          buf.Write(&first);
+
+          // last
+          buf.Write(&last);
+        }
+
+        // minor
+        {
+          auto& first = minor.first;
+          auto& last = minor.last;
+
+          // first
+          buf.Write(&first);
+
+          // last
+          buf.Write(&last);
+        }
+      }
+
+      // delivered_events
+      {
+        auto& first = delivered_events.first;
+        auto& last = delivered_events.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // device_events
+      {
+        auto& first = device_events.first;
+        auto& last = device_events.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // errors
+      {
+        auto& first = errors.first;
+        auto& last = errors.last;
+
+        // first
+        buf.Write(&first);
+
+        // last
+        buf.Write(&last);
+      }
+
+      // client_started
+      buf.Write(&client_started);
+
+      // client_died
+      buf.Write(&client_died);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Record::RegisterClients", false);
+}
+
+Future<void> Record::RegisterClients(
+    const Context& context,
+    const ElementHeader& element_header,
+    const std::vector<ClientSpec>& client_specs,
+    const std::vector<Range>& ranges) {
+  return Record::RegisterClients(Record::RegisterClientsRequest{
+      context, element_header, client_specs, ranges});
+}
+
+Future<void> Record::UnregisterClients(
+    const Record::UnregisterClientsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  uint32_t num_client_specs{};
+  auto& client_specs = request.client_specs;
+  size_t client_specs_len = client_specs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // num_client_specs
+  num_client_specs = client_specs.size();
+  buf.Write(&num_client_specs);
+
+  // client_specs
+  DCHECK_EQ(static_cast<size_t>(num_client_specs), client_specs.size());
+  for (auto& client_specs_elem : client_specs) {
+    // client_specs_elem
+    buf.Write(&client_specs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Record::UnregisterClients",
+                                        false);
+}
+
+Future<void> Record::UnregisterClients(
+    const Context& context,
+    const std::vector<ClientSpec>& client_specs) {
+  return Record::UnregisterClients(
+      Record::UnregisterClientsRequest{context, client_specs});
+}
+
+Future<Record::GetContextReply> Record::GetContext(
+    const Record::GetContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Record::GetContextReply>(
+      &buf, "Record::GetContext", false);
+}
+
+Future<Record::GetContextReply> Record::GetContext(const Context& context) {
+  return Record::GetContext(Record::GetContextRequest{context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Record::GetContextReply> detail::ReadReply<
+    Record::GetContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Record::GetContextReply>();
+
+  auto& enabled = (*reply).enabled;
+  auto& sequence = (*reply).sequence;
+  auto& element_header = (*reply).element_header;
+  uint32_t num_intercepted_clients{};
+  auto& intercepted_clients = (*reply).intercepted_clients;
+  size_t intercepted_clients_len = intercepted_clients.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // enabled
+  Read(&enabled, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // element_header
+  Read(&element_header, &buf);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // num_intercepted_clients
+  Read(&num_intercepted_clients, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  // intercepted_clients
+  intercepted_clients.resize(num_intercepted_clients);
+  for (auto& intercepted_clients_elem : intercepted_clients) {
+    // intercepted_clients_elem
+    {
+      auto& client_resource = intercepted_clients_elem.client_resource;
+      uint32_t num_ranges{};
+      auto& ranges = intercepted_clients_elem.ranges;
+      size_t ranges_len = ranges.size();
+
+      // client_resource
+      Read(&client_resource, &buf);
+
+      // num_ranges
+      Read(&num_ranges, &buf);
+
+      // ranges
+      ranges.resize(num_ranges);
+      for (auto& ranges_elem : ranges) {
+        // ranges_elem
+        {
+          auto& core_requests = ranges_elem.core_requests;
+          auto& core_replies = ranges_elem.core_replies;
+          auto& ext_requests = ranges_elem.ext_requests;
+          auto& ext_replies = ranges_elem.ext_replies;
+          auto& delivered_events = ranges_elem.delivered_events;
+          auto& device_events = ranges_elem.device_events;
+          auto& errors = ranges_elem.errors;
+          auto& client_started = ranges_elem.client_started;
+          auto& client_died = ranges_elem.client_died;
+
+          // core_requests
+          {
+            auto& first = core_requests.first;
+            auto& last = core_requests.last;
+
+            // first
+            Read(&first, &buf);
+
+            // last
+            Read(&last, &buf);
+          }
+
+          // core_replies
+          {
+            auto& first = core_replies.first;
+            auto& last = core_replies.last;
+
+            // first
+            Read(&first, &buf);
+
+            // last
+            Read(&last, &buf);
+          }
+
+          // ext_requests
+          {
+            auto& major = ext_requests.major;
+            auto& minor = ext_requests.minor;
+
+            // major
+            {
+              auto& first = major.first;
+              auto& last = major.last;
+
+              // first
+              Read(&first, &buf);
+
+              // last
+              Read(&last, &buf);
+            }
+
+            // minor
+            {
+              auto& first = minor.first;
+              auto& last = minor.last;
+
+              // first
+              Read(&first, &buf);
+
+              // last
+              Read(&last, &buf);
+            }
+          }
+
+          // ext_replies
+          {
+            auto& major = ext_replies.major;
+            auto& minor = ext_replies.minor;
+
+            // major
+            {
+              auto& first = major.first;
+              auto& last = major.last;
+
+              // first
+              Read(&first, &buf);
+
+              // last
+              Read(&last, &buf);
+            }
+
+            // minor
+            {
+              auto& first = minor.first;
+              auto& last = minor.last;
+
+              // first
+              Read(&first, &buf);
+
+              // last
+              Read(&last, &buf);
+            }
+          }
+
+          // delivered_events
+          {
+            auto& first = delivered_events.first;
+            auto& last = delivered_events.last;
+
+            // first
+            Read(&first, &buf);
+
+            // last
+            Read(&last, &buf);
+          }
+
+          // device_events
+          {
+            auto& first = device_events.first;
+            auto& last = device_events.last;
+
+            // first
+            Read(&first, &buf);
+
+            // last
+            Read(&last, &buf);
+          }
+
+          // errors
+          {
+            auto& first = errors.first;
+            auto& last = errors.last;
+
+            // first
+            Read(&first, &buf);
+
+            // last
+            Read(&last, &buf);
+          }
+
+          // client_started
+          Read(&client_started, &buf);
+
+          // client_died
+          Read(&client_died, &buf);
+        }
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Record::EnableContextReply> Record::EnableContext(
+    const Record::EnableContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Record::EnableContextReply>(
+      &buf, "Record::EnableContext", false);
+}
+
+Future<Record::EnableContextReply> Record::EnableContext(
+    const Context& context) {
+  return Record::EnableContext(Record::EnableContextRequest{context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Record::EnableContextReply> detail::ReadReply<
+    Record::EnableContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Record::EnableContextReply>();
+
+  auto& category = (*reply).category;
+  auto& sequence = (*reply).sequence;
+  auto& element_header = (*reply).element_header;
+  auto& client_swapped = (*reply).client_swapped;
+  auto& xid_base = (*reply).xid_base;
+  auto& server_time = (*reply).server_time;
+  auto& rec_sequence_num = (*reply).rec_sequence_num;
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // category
+  Read(&category, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // element_header
+  Read(&element_header, &buf);
+
+  // client_swapped
+  Read(&client_swapped, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // xid_base
+  Read(&xid_base, &buf);
+
+  // server_time
+  Read(&server_time, &buf);
+
+  // rec_sequence_num
+  Read(&rec_sequence_num, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // data
+  data.resize((length) * (4));
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Record::DisableContext(
+    const Record::DisableContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Record::DisableContext", false);
+}
+
+Future<void> Record::DisableContext(const Context& context) {
+  return Record::DisableContext(Record::DisableContextRequest{context});
+}
+
+Future<void> Record::FreeContext(const Record::FreeContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Record::FreeContext", false);
+}
+
+Future<void> Record::FreeContext(const Context& context) {
+  return Record::FreeContext(Record::FreeContextRequest{context});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/record.h b/ui/gfx/x/generated_protos/record.h
new file mode 100644
index 0000000..123f200
--- /dev/null
+++ b/ui/gfx/x/generated_protos/record.h
@@ -0,0 +1,292 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_RECORD_H_
+#define UI_GFX_X_GENERATED_PROTOS_RECORD_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Record {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 13;
+
+  Record(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Context : uint32_t {};
+
+  enum class ElementHeader : uint8_t {};
+
+  enum class HType : int {
+    FromServerTime = 1 << 0,
+    FromClientTime = 1 << 1,
+    FromClientSequence = 1 << 2,
+  };
+
+  enum class ClientSpec : uint32_t {
+    CurrentClients = 1,
+    FutureClients = 2,
+    AllClients = 3,
+  };
+
+  struct Range8 {
+    uint8_t first{};
+    uint8_t last{};
+  };
+
+  struct Range16 {
+    uint16_t first{};
+    uint16_t last{};
+  };
+
+  struct ExtRange {
+    Range8 major{};
+    Range16 minor{};
+  };
+
+  struct Range {
+    Range8 core_requests{};
+    Range8 core_replies{};
+    ExtRange ext_requests{};
+    ExtRange ext_replies{};
+    Range8 delivered_events{};
+    Range8 device_events{};
+    Range8 errors{};
+    uint8_t client_started{};
+    uint8_t client_died{};
+  };
+
+  struct ClientInfo {
+    ClientSpec client_resource{};
+    std::vector<Range> ranges{};
+  };
+
+  struct BadContextError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t invalid_record{};
+
+    std::string ToString() const override;
+  };
+
+  struct QueryVersionRequest {
+    uint16_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint16_t& major_version = {},
+                                         const uint16_t& minor_version = {});
+
+  struct CreateContextRequest {
+    Context context{};
+    ElementHeader element_header{};
+    std::vector<ClientSpec> client_specs{};
+    std::vector<Range> ranges{};
+  };
+
+  using CreateContextResponse = Response<void>;
+
+  Future<void> CreateContext(const CreateContextRequest& request);
+
+  Future<void> CreateContext(const Context& context = {},
+                             const ElementHeader& element_header = {},
+                             const std::vector<ClientSpec>& client_specs = {},
+                             const std::vector<Range>& ranges = {});
+
+  struct RegisterClientsRequest {
+    Context context{};
+    ElementHeader element_header{};
+    std::vector<ClientSpec> client_specs{};
+    std::vector<Range> ranges{};
+  };
+
+  using RegisterClientsResponse = Response<void>;
+
+  Future<void> RegisterClients(const RegisterClientsRequest& request);
+
+  Future<void> RegisterClients(const Context& context = {},
+                               const ElementHeader& element_header = {},
+                               const std::vector<ClientSpec>& client_specs = {},
+                               const std::vector<Range>& ranges = {});
+
+  struct UnregisterClientsRequest {
+    Context context{};
+    std::vector<ClientSpec> client_specs{};
+  };
+
+  using UnregisterClientsResponse = Response<void>;
+
+  Future<void> UnregisterClients(const UnregisterClientsRequest& request);
+
+  Future<void> UnregisterClients(
+      const Context& context = {},
+      const std::vector<ClientSpec>& client_specs = {});
+
+  struct GetContextRequest {
+    Context context{};
+  };
+
+  struct GetContextReply {
+    uint8_t enabled{};
+    uint16_t sequence{};
+    ElementHeader element_header{};
+    std::vector<ClientInfo> intercepted_clients{};
+  };
+
+  using GetContextResponse = Response<GetContextReply>;
+
+  Future<GetContextReply> GetContext(const GetContextRequest& request);
+
+  Future<GetContextReply> GetContext(const Context& context = {});
+
+  struct EnableContextRequest {
+    Context context{};
+  };
+
+  struct EnableContextReply {
+    uint8_t category{};
+    uint16_t sequence{};
+    ElementHeader element_header{};
+    uint8_t client_swapped{};
+    uint32_t xid_base{};
+    uint32_t server_time{};
+    uint32_t rec_sequence_num{};
+    std::vector<uint8_t> data{};
+  };
+
+  using EnableContextResponse = Response<EnableContextReply>;
+
+  Future<EnableContextReply> EnableContext(const EnableContextRequest& request);
+
+  Future<EnableContextReply> EnableContext(const Context& context = {});
+
+  struct DisableContextRequest {
+    Context context{};
+  };
+
+  using DisableContextResponse = Response<void>;
+
+  Future<void> DisableContext(const DisableContextRequest& request);
+
+  Future<void> DisableContext(const Context& context = {});
+
+  struct FreeContextRequest {
+    Context context{};
+  };
+
+  using FreeContextResponse = Response<void>;
+
+  Future<void> FreeContext(const FreeContextRequest& request);
+
+  Future<void> FreeContext(const Context& context = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Record::HType operator|(x11::Record::HType l,
+                                              x11::Record::HType r) {
+  using T = std::underlying_type_t<x11::Record::HType>;
+  return static_cast<x11::Record::HType>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Record::HType operator&(x11::Record::HType l,
+                                              x11::Record::HType r) {
+  using T = std::underlying_type_t<x11::Record::HType>;
+  return static_cast<x11::Record::HType>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Record::ClientSpec operator|(x11::Record::ClientSpec l,
+                                                   x11::Record::ClientSpec r) {
+  using T = std::underlying_type_t<x11::Record::ClientSpec>;
+  return static_cast<x11::Record::ClientSpec>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Record::ClientSpec operator&(x11::Record::ClientSpec l,
+                                                   x11::Record::ClientSpec r) {
+  using T = std::underlying_type_t<x11::Record::ClientSpec>;
+  return static_cast<x11::Record::ClientSpec>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_RECORD_H_
diff --git a/ui/gfx/x/generated_protos/render.cc b/ui/gfx/x/generated_protos/render.cc
new file mode 100644
index 0000000..553afbd
--- /dev/null
+++ b/ui/gfx/x/generated_protos/render.cc
@@ -0,0 +1,2960 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "render.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Render::Render(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string Render::PictFormatError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Render::PictFormatError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Render::PictFormatError>(Render::PictFormatError* error_,
+                                        ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Render::PictureError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Render::PictureError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Render::PictureError>(Render::PictureError* error_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Render::PictOpError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Render::PictOpError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Render::PictOpError>(Render::PictOpError* error_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Render::GlyphSetError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Render::GlyphSetError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Render::GlyphSetError>(Render::GlyphSetError* error_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Render::GlyphError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Render::GlyphError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Render::GlyphError>(Render::GlyphError* error_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+Future<Render::QueryVersionReply> Render::QueryVersion(
+    const Render::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Render::QueryVersionReply>(
+      &buf, "Render::QueryVersion", false);
+}
+
+Future<Render::QueryVersionReply> Render::QueryVersion(
+    const uint32_t& client_major_version,
+    const uint32_t& client_minor_version) {
+  return Render::QueryVersion(
+      Render::QueryVersionRequest{client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Render::QueryVersionReply> detail::ReadReply<
+    Render::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Render::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Render::QueryPictFormatsReply> Render::QueryPictFormats(
+    const Render::QueryPictFormatsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Render::QueryPictFormatsReply>(
+      &buf, "Render::QueryPictFormats", false);
+}
+
+Future<Render::QueryPictFormatsReply> Render::QueryPictFormats() {
+  return Render::QueryPictFormats(Render::QueryPictFormatsRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Render::QueryPictFormatsReply> detail::ReadReply<
+    Render::QueryPictFormatsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Render::QueryPictFormatsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_formats{};
+  uint32_t num_screens{};
+  auto& num_depths = (*reply).num_depths;
+  auto& num_visuals = (*reply).num_visuals;
+  uint32_t num_subpixel{};
+  auto& formats = (*reply).formats;
+  size_t formats_len = formats.size();
+  auto& screens = (*reply).screens;
+  size_t screens_len = screens.size();
+  auto& subpixels = (*reply).subpixels;
+  size_t subpixels_len = subpixels.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_formats
+  Read(&num_formats, &buf);
+
+  // num_screens
+  Read(&num_screens, &buf);
+
+  // num_depths
+  Read(&num_depths, &buf);
+
+  // num_visuals
+  Read(&num_visuals, &buf);
+
+  // num_subpixel
+  Read(&num_subpixel, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // formats
+  formats.resize(num_formats);
+  for (auto& formats_elem : formats) {
+    // formats_elem
+    {
+      auto& id = formats_elem.id;
+      auto& type = formats_elem.type;
+      auto& depth = formats_elem.depth;
+      auto& direct = formats_elem.direct;
+      auto& colormap = formats_elem.colormap;
+
+      // id
+      Read(&id, &buf);
+
+      // type
+      uint8_t tmp0;
+      Read(&tmp0, &buf);
+      type = static_cast<Render::PictType>(tmp0);
+
+      // depth
+      Read(&depth, &buf);
+
+      // pad0
+      Pad(&buf, 2);
+
+      // direct
+      {
+        auto& red_shift = direct.red_shift;
+        auto& red_mask = direct.red_mask;
+        auto& green_shift = direct.green_shift;
+        auto& green_mask = direct.green_mask;
+        auto& blue_shift = direct.blue_shift;
+        auto& blue_mask = direct.blue_mask;
+        auto& alpha_shift = direct.alpha_shift;
+        auto& alpha_mask = direct.alpha_mask;
+
+        // red_shift
+        Read(&red_shift, &buf);
+
+        // red_mask
+        Read(&red_mask, &buf);
+
+        // green_shift
+        Read(&green_shift, &buf);
+
+        // green_mask
+        Read(&green_mask, &buf);
+
+        // blue_shift
+        Read(&blue_shift, &buf);
+
+        // blue_mask
+        Read(&blue_mask, &buf);
+
+        // alpha_shift
+        Read(&alpha_shift, &buf);
+
+        // alpha_mask
+        Read(&alpha_mask, &buf);
+      }
+
+      // colormap
+      Read(&colormap, &buf);
+    }
+  }
+
+  // screens
+  screens.resize(num_screens);
+  for (auto& screens_elem : screens) {
+    // screens_elem
+    {
+      uint32_t num_depths{};
+      auto& fallback = screens_elem.fallback;
+      auto& depths = screens_elem.depths;
+      size_t depths_len = depths.size();
+
+      // num_depths
+      Read(&num_depths, &buf);
+
+      // fallback
+      Read(&fallback, &buf);
+
+      // depths
+      depths.resize(num_depths);
+      for (auto& depths_elem : depths) {
+        // depths_elem
+        {
+          auto& depth = depths_elem.depth;
+          uint16_t num_visuals{};
+          auto& visuals = depths_elem.visuals;
+          size_t visuals_len = visuals.size();
+
+          // depth
+          Read(&depth, &buf);
+
+          // pad0
+          Pad(&buf, 1);
+
+          // num_visuals
+          Read(&num_visuals, &buf);
+
+          // pad1
+          Pad(&buf, 4);
+
+          // visuals
+          visuals.resize(num_visuals);
+          for (auto& visuals_elem : visuals) {
+            // visuals_elem
+            {
+              auto& visual = visuals_elem.visual;
+              auto& format = visuals_elem.format;
+
+              // visual
+              Read(&visual, &buf);
+
+              // format
+              Read(&format, &buf);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // subpixels
+  subpixels.resize(num_subpixel);
+  for (auto& subpixels_elem : subpixels) {
+    // subpixels_elem
+    uint32_t tmp1;
+    Read(&tmp1, &buf);
+    subpixels_elem = static_cast<Render::SubPixel>(tmp1);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Render::QueryPictIndexValuesReply> Render::QueryPictIndexValues(
+    const Render::QueryPictIndexValuesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& format = request.format;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // format
+  buf.Write(&format);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Render::QueryPictIndexValuesReply>(
+      &buf, "Render::QueryPictIndexValues", false);
+}
+
+Future<Render::QueryPictIndexValuesReply> Render::QueryPictIndexValues(
+    const PictFormat& format) {
+  return Render::QueryPictIndexValues(
+      Render::QueryPictIndexValuesRequest{format});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Render::QueryPictIndexValuesReply> detail::ReadReply<
+    Render::QueryPictIndexValuesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Render::QueryPictIndexValuesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_values{};
+  auto& values = (*reply).values;
+  size_t values_len = values.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_values
+  Read(&num_values, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // values
+  values.resize(num_values);
+  for (auto& values_elem : values) {
+    // values_elem
+    {
+      auto& pixel = values_elem.pixel;
+      auto& red = values_elem.red;
+      auto& green = values_elem.green;
+      auto& blue = values_elem.blue;
+      auto& alpha = values_elem.alpha;
+
+      // pixel
+      Read(&pixel, &buf);
+
+      // red
+      Read(&red, &buf);
+
+      // green
+      Read(&green, &buf);
+
+      // blue
+      Read(&blue, &buf);
+
+      // alpha
+      Read(&alpha, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Render::CreatePicture(
+    const Render::CreatePictureRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& pid = request.pid;
+  auto& drawable = request.drawable;
+  auto& format = request.format;
+  CreatePictureAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pid
+  buf.Write(&pid);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // format
+  buf.Write(&format);
+
+  // value_mask
+  SwitchVar(CreatePictureAttribute::Repeat, value_list.repeat.has_value(), true,
+            &value_mask);
+  SwitchVar(CreatePictureAttribute::AlphaMap, value_list.alphamap.has_value(),
+            true, &value_mask);
+  SwitchVar(CreatePictureAttribute::AlphaXOrigin,
+            value_list.alphaxorigin.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::AlphaYOrigin,
+            value_list.alphayorigin.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::ClipXOrigin,
+            value_list.clipxorigin.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::ClipYOrigin,
+            value_list.clipyorigin.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::ClipMask, value_list.clipmask.has_value(),
+            true, &value_mask);
+  SwitchVar(CreatePictureAttribute::GraphicsExposure,
+            value_list.graphicsexposure.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::SubwindowMode,
+            value_list.subwindowmode.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::PolyEdge, value_list.polyedge.has_value(),
+            true, &value_mask);
+  SwitchVar(CreatePictureAttribute::PolyMode, value_list.polymode.has_value(),
+            true, &value_mask);
+  SwitchVar(CreatePictureAttribute::Dither, value_list.dither.has_value(), true,
+            &value_mask);
+  SwitchVar(CreatePictureAttribute::ComponentAlpha,
+            value_list.componentalpha.has_value(), true, &value_mask);
+  uint32_t tmp2;
+  tmp2 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp2);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::Repeat)) {
+    auto& repeat = *value_list.repeat;
+
+    // repeat
+    uint32_t tmp3;
+    tmp3 = static_cast<uint32_t>(repeat);
+    buf.Write(&tmp3);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaMap)) {
+    auto& alphamap = *value_list.alphamap;
+
+    // alphamap
+    buf.Write(&alphamap);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaXOrigin)) {
+    auto& alphaxorigin = *value_list.alphaxorigin;
+
+    // alphaxorigin
+    buf.Write(&alphaxorigin);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaYOrigin)) {
+    auto& alphayorigin = *value_list.alphayorigin;
+
+    // alphayorigin
+    buf.Write(&alphayorigin);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipXOrigin)) {
+    auto& clipxorigin = *value_list.clipxorigin;
+
+    // clipxorigin
+    buf.Write(&clipxorigin);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipYOrigin)) {
+    auto& clipyorigin = *value_list.clipyorigin;
+
+    // clipyorigin
+    buf.Write(&clipyorigin);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipMask)) {
+    auto& clipmask = *value_list.clipmask;
+
+    // clipmask
+    buf.Write(&clipmask);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::GraphicsExposure)) {
+    auto& graphicsexposure = *value_list.graphicsexposure;
+
+    // graphicsexposure
+    buf.Write(&graphicsexposure);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::SubwindowMode)) {
+    auto& subwindowmode = *value_list.subwindowmode;
+
+    // subwindowmode
+    uint32_t tmp4;
+    tmp4 = static_cast<uint32_t>(subwindowmode);
+    buf.Write(&tmp4);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::PolyEdge)) {
+    auto& polyedge = *value_list.polyedge;
+
+    // polyedge
+    uint32_t tmp5;
+    tmp5 = static_cast<uint32_t>(polyedge);
+    buf.Write(&tmp5);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::PolyMode)) {
+    auto& polymode = *value_list.polymode;
+
+    // polymode
+    uint32_t tmp6;
+    tmp6 = static_cast<uint32_t>(polymode);
+    buf.Write(&tmp6);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::Dither)) {
+    auto& dither = *value_list.dither;
+
+    // dither
+    buf.Write(&dither);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::ComponentAlpha)) {
+    auto& componentalpha = *value_list.componentalpha;
+
+    // componentalpha
+    buf.Write(&componentalpha);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CreatePicture", false);
+}
+
+Future<void> Render::CreatePicture(
+    const Picture& pid,
+    const Drawable& drawable,
+    const PictFormat& format,
+    const absl::optional<Repeat>& repeat,
+    const absl::optional<Picture>& alphamap,
+    const absl::optional<int32_t>& alphaxorigin,
+    const absl::optional<int32_t>& alphayorigin,
+    const absl::optional<int32_t>& clipxorigin,
+    const absl::optional<int32_t>& clipyorigin,
+    const absl::optional<Pixmap>& clipmask,
+    const absl::optional<uint32_t>& graphicsexposure,
+    const absl::optional<SubwindowMode>& subwindowmode,
+    const absl::optional<PolyEdge>& polyedge,
+    const absl::optional<PolyMode>& polymode,
+    const absl::optional<Atom>& dither,
+    const absl::optional<uint32_t>& componentalpha) {
+  return Render::CreatePicture(Render::CreatePictureRequest{
+      pid, drawable, format, repeat, alphamap, alphaxorigin, alphayorigin,
+      clipxorigin, clipyorigin, clipmask, graphicsexposure, subwindowmode,
+      polyedge, polymode, dither, componentalpha});
+}
+
+Future<void> Render::ChangePicture(
+    const Render::ChangePictureRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  CreatePictureAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // value_mask
+  SwitchVar(CreatePictureAttribute::Repeat, value_list.repeat.has_value(), true,
+            &value_mask);
+  SwitchVar(CreatePictureAttribute::AlphaMap, value_list.alphamap.has_value(),
+            true, &value_mask);
+  SwitchVar(CreatePictureAttribute::AlphaXOrigin,
+            value_list.alphaxorigin.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::AlphaYOrigin,
+            value_list.alphayorigin.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::ClipXOrigin,
+            value_list.clipxorigin.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::ClipYOrigin,
+            value_list.clipyorigin.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::ClipMask, value_list.clipmask.has_value(),
+            true, &value_mask);
+  SwitchVar(CreatePictureAttribute::GraphicsExposure,
+            value_list.graphicsexposure.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::SubwindowMode,
+            value_list.subwindowmode.has_value(), true, &value_mask);
+  SwitchVar(CreatePictureAttribute::PolyEdge, value_list.polyedge.has_value(),
+            true, &value_mask);
+  SwitchVar(CreatePictureAttribute::PolyMode, value_list.polymode.has_value(),
+            true, &value_mask);
+  SwitchVar(CreatePictureAttribute::Dither, value_list.dither.has_value(), true,
+            &value_mask);
+  SwitchVar(CreatePictureAttribute::ComponentAlpha,
+            value_list.componentalpha.has_value(), true, &value_mask);
+  uint32_t tmp7;
+  tmp7 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp7);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::Repeat)) {
+    auto& repeat = *value_list.repeat;
+
+    // repeat
+    uint32_t tmp8;
+    tmp8 = static_cast<uint32_t>(repeat);
+    buf.Write(&tmp8);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaMap)) {
+    auto& alphamap = *value_list.alphamap;
+
+    // alphamap
+    buf.Write(&alphamap);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaXOrigin)) {
+    auto& alphaxorigin = *value_list.alphaxorigin;
+
+    // alphaxorigin
+    buf.Write(&alphaxorigin);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaYOrigin)) {
+    auto& alphayorigin = *value_list.alphayorigin;
+
+    // alphayorigin
+    buf.Write(&alphayorigin);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipXOrigin)) {
+    auto& clipxorigin = *value_list.clipxorigin;
+
+    // clipxorigin
+    buf.Write(&clipxorigin);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipYOrigin)) {
+    auto& clipyorigin = *value_list.clipyorigin;
+
+    // clipyorigin
+    buf.Write(&clipyorigin);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipMask)) {
+    auto& clipmask = *value_list.clipmask;
+
+    // clipmask
+    buf.Write(&clipmask);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::GraphicsExposure)) {
+    auto& graphicsexposure = *value_list.graphicsexposure;
+
+    // graphicsexposure
+    buf.Write(&graphicsexposure);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::SubwindowMode)) {
+    auto& subwindowmode = *value_list.subwindowmode;
+
+    // subwindowmode
+    uint32_t tmp9;
+    tmp9 = static_cast<uint32_t>(subwindowmode);
+    buf.Write(&tmp9);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::PolyEdge)) {
+    auto& polyedge = *value_list.polyedge;
+
+    // polyedge
+    uint32_t tmp10;
+    tmp10 = static_cast<uint32_t>(polyedge);
+    buf.Write(&tmp10);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::PolyMode)) {
+    auto& polymode = *value_list.polymode;
+
+    // polymode
+    uint32_t tmp11;
+    tmp11 = static_cast<uint32_t>(polymode);
+    buf.Write(&tmp11);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::Dither)) {
+    auto& dither = *value_list.dither;
+
+    // dither
+    buf.Write(&dither);
+  }
+  if (CaseAnd(value_list_expr, CreatePictureAttribute::ComponentAlpha)) {
+    auto& componentalpha = *value_list.componentalpha;
+
+    // componentalpha
+    buf.Write(&componentalpha);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::ChangePicture", false);
+}
+
+Future<void> Render::ChangePicture(
+    const Picture& picture,
+    const absl::optional<Repeat>& repeat,
+    const absl::optional<Picture>& alphamap,
+    const absl::optional<int32_t>& alphaxorigin,
+    const absl::optional<int32_t>& alphayorigin,
+    const absl::optional<int32_t>& clipxorigin,
+    const absl::optional<int32_t>& clipyorigin,
+    const absl::optional<Pixmap>& clipmask,
+    const absl::optional<uint32_t>& graphicsexposure,
+    const absl::optional<SubwindowMode>& subwindowmode,
+    const absl::optional<PolyEdge>& polyedge,
+    const absl::optional<PolyMode>& polymode,
+    const absl::optional<Atom>& dither,
+    const absl::optional<uint32_t>& componentalpha) {
+  return Render::ChangePicture(Render::ChangePictureRequest{
+      picture, repeat, alphamap, alphaxorigin, alphayorigin, clipxorigin,
+      clipyorigin, clipmask, graphicsexposure, subwindowmode, polyedge,
+      polymode, dither, componentalpha});
+}
+
+Future<void> Render::SetPictureClipRectangles(
+    const Render::SetPictureClipRectanglesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  auto& clip_x_origin = request.clip_x_origin;
+  auto& clip_y_origin = request.clip_y_origin;
+  auto& rectangles = request.rectangles;
+  size_t rectangles_len = rectangles.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // clip_x_origin
+  buf.Write(&clip_x_origin);
+
+  // clip_y_origin
+  buf.Write(&clip_y_origin);
+
+  // rectangles
+  DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size());
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(
+      &buf, "Render::SetPictureClipRectangles", false);
+}
+
+Future<void> Render::SetPictureClipRectangles(
+    const Picture& picture,
+    const int16_t& clip_x_origin,
+    const int16_t& clip_y_origin,
+    const std::vector<Rectangle>& rectangles) {
+  return Render::SetPictureClipRectangles(
+      Render::SetPictureClipRectanglesRequest{picture, clip_x_origin,
+                                              clip_y_origin, rectangles});
+}
+
+Future<void> Render::FreePicture(const Render::FreePictureRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::FreePicture", false);
+}
+
+Future<void> Render::FreePicture(const Picture& picture) {
+  return Render::FreePicture(Render::FreePictureRequest{picture});
+}
+
+Future<void> Render::Composite(const Render::CompositeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& src = request.src;
+  auto& mask = request.mask;
+  auto& dst = request.dst;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& mask_x = request.mask_x;
+  auto& mask_y = request.mask_y;
+  auto& dst_x = request.dst_x;
+  auto& dst_y = request.dst_y;
+  auto& width = request.width;
+  auto& height = request.height;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp12;
+  tmp12 = static_cast<uint8_t>(op);
+  buf.Write(&tmp12);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // src
+  buf.Write(&src);
+
+  // mask
+  buf.Write(&mask);
+
+  // dst
+  buf.Write(&dst);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // mask_x
+  buf.Write(&mask_x);
+
+  // mask_y
+  buf.Write(&mask_y);
+
+  // dst_x
+  buf.Write(&dst_x);
+
+  // dst_y
+  buf.Write(&dst_y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::Composite", false);
+}
+
+Future<void> Render::Composite(const PictOp& op,
+                               const Picture& src,
+                               const Picture& mask,
+                               const Picture& dst,
+                               const int16_t& src_x,
+                               const int16_t& src_y,
+                               const int16_t& mask_x,
+                               const int16_t& mask_y,
+                               const int16_t& dst_x,
+                               const int16_t& dst_y,
+                               const uint16_t& width,
+                               const uint16_t& height) {
+  return Render::Composite(
+      Render::CompositeRequest{op, src, mask, dst, src_x, src_y, mask_x, mask_y,
+                               dst_x, dst_y, width, height});
+}
+
+Future<void> Render::Trapezoids(const Render::TrapezoidsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& src = request.src;
+  auto& dst = request.dst;
+  auto& mask_format = request.mask_format;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& traps = request.traps;
+  size_t traps_len = traps.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp13;
+  tmp13 = static_cast<uint8_t>(op);
+  buf.Write(&tmp13);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // src
+  buf.Write(&src);
+
+  // dst
+  buf.Write(&dst);
+
+  // mask_format
+  buf.Write(&mask_format);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // traps
+  DCHECK_EQ(static_cast<size_t>(traps_len), traps.size());
+  for (auto& traps_elem : traps) {
+    // traps_elem
+    {
+      auto& top = traps_elem.top;
+      auto& bottom = traps_elem.bottom;
+      auto& left = traps_elem.left;
+      auto& right = traps_elem.right;
+
+      // top
+      buf.Write(&top);
+
+      // bottom
+      buf.Write(&bottom);
+
+      // left
+      {
+        auto& p1 = left.p1;
+        auto& p2 = left.p2;
+
+        // p1
+        {
+          auto& x = p1.x;
+          auto& y = p1.y;
+
+          // x
+          buf.Write(&x);
+
+          // y
+          buf.Write(&y);
+        }
+
+        // p2
+        {
+          auto& x = p2.x;
+          auto& y = p2.y;
+
+          // x
+          buf.Write(&x);
+
+          // y
+          buf.Write(&y);
+        }
+      }
+
+      // right
+      {
+        auto& p1 = right.p1;
+        auto& p2 = right.p2;
+
+        // p1
+        {
+          auto& x = p1.x;
+          auto& y = p1.y;
+
+          // x
+          buf.Write(&x);
+
+          // y
+          buf.Write(&y);
+        }
+
+        // p2
+        {
+          auto& x = p2.x;
+          auto& y = p2.y;
+
+          // x
+          buf.Write(&x);
+
+          // y
+          buf.Write(&y);
+        }
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::Trapezoids", false);
+}
+
+Future<void> Render::Trapezoids(const PictOp& op,
+                                const Picture& src,
+                                const Picture& dst,
+                                const PictFormat& mask_format,
+                                const int16_t& src_x,
+                                const int16_t& src_y,
+                                const std::vector<Trapezoid>& traps) {
+  return Render::Trapezoids(Render::TrapezoidsRequest{op, src, dst, mask_format,
+                                                      src_x, src_y, traps});
+}
+
+Future<void> Render::Triangles(const Render::TrianglesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& src = request.src;
+  auto& dst = request.dst;
+  auto& mask_format = request.mask_format;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& triangles = request.triangles;
+  size_t triangles_len = triangles.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp14;
+  tmp14 = static_cast<uint8_t>(op);
+  buf.Write(&tmp14);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // src
+  buf.Write(&src);
+
+  // dst
+  buf.Write(&dst);
+
+  // mask_format
+  buf.Write(&mask_format);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // triangles
+  DCHECK_EQ(static_cast<size_t>(triangles_len), triangles.size());
+  for (auto& triangles_elem : triangles) {
+    // triangles_elem
+    {
+      auto& p1 = triangles_elem.p1;
+      auto& p2 = triangles_elem.p2;
+      auto& p3 = triangles_elem.p3;
+
+      // p1
+      {
+        auto& x = p1.x;
+        auto& y = p1.y;
+
+        // x
+        buf.Write(&x);
+
+        // y
+        buf.Write(&y);
+      }
+
+      // p2
+      {
+        auto& x = p2.x;
+        auto& y = p2.y;
+
+        // x
+        buf.Write(&x);
+
+        // y
+        buf.Write(&y);
+      }
+
+      // p3
+      {
+        auto& x = p3.x;
+        auto& y = p3.y;
+
+        // x
+        buf.Write(&x);
+
+        // y
+        buf.Write(&y);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::Triangles", false);
+}
+
+Future<void> Render::Triangles(const PictOp& op,
+                               const Picture& src,
+                               const Picture& dst,
+                               const PictFormat& mask_format,
+                               const int16_t& src_x,
+                               const int16_t& src_y,
+                               const std::vector<Triangle>& triangles) {
+  return Render::Triangles(Render::TrianglesRequest{op, src, dst, mask_format,
+                                                    src_x, src_y, triangles});
+}
+
+Future<void> Render::TriStrip(const Render::TriStripRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& src = request.src;
+  auto& dst = request.dst;
+  auto& mask_format = request.mask_format;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& points = request.points;
+  size_t points_len = points.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp15;
+  tmp15 = static_cast<uint8_t>(op);
+  buf.Write(&tmp15);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // src
+  buf.Write(&src);
+
+  // dst
+  buf.Write(&dst);
+
+  // mask_format
+  buf.Write(&mask_format);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // points
+  DCHECK_EQ(static_cast<size_t>(points_len), points.size());
+  for (auto& points_elem : points) {
+    // points_elem
+    {
+      auto& x = points_elem.x;
+      auto& y = points_elem.y;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::TriStrip", false);
+}
+
+Future<void> Render::TriStrip(const PictOp& op,
+                              const Picture& src,
+                              const Picture& dst,
+                              const PictFormat& mask_format,
+                              const int16_t& src_x,
+                              const int16_t& src_y,
+                              const std::vector<PointFix>& points) {
+  return Render::TriStrip(
+      Render::TriStripRequest{op, src, dst, mask_format, src_x, src_y, points});
+}
+
+Future<void> Render::TriFan(const Render::TriFanRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& src = request.src;
+  auto& dst = request.dst;
+  auto& mask_format = request.mask_format;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& points = request.points;
+  size_t points_len = points.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp16;
+  tmp16 = static_cast<uint8_t>(op);
+  buf.Write(&tmp16);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // src
+  buf.Write(&src);
+
+  // dst
+  buf.Write(&dst);
+
+  // mask_format
+  buf.Write(&mask_format);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // points
+  DCHECK_EQ(static_cast<size_t>(points_len), points.size());
+  for (auto& points_elem : points) {
+    // points_elem
+    {
+      auto& x = points_elem.x;
+      auto& y = points_elem.y;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::TriFan", false);
+}
+
+Future<void> Render::TriFan(const PictOp& op,
+                            const Picture& src,
+                            const Picture& dst,
+                            const PictFormat& mask_format,
+                            const int16_t& src_x,
+                            const int16_t& src_y,
+                            const std::vector<PointFix>& points) {
+  return Render::TriFan(
+      Render::TriFanRequest{op, src, dst, mask_format, src_x, src_y, points});
+}
+
+Future<void> Render::CreateGlyphSet(
+    const Render::CreateGlyphSetRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& gsid = request.gsid;
+  auto& format = request.format;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // gsid
+  buf.Write(&gsid);
+
+  // format
+  buf.Write(&format);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CreateGlyphSet", false);
+}
+
+Future<void> Render::CreateGlyphSet(const GlyphSet& gsid,
+                                    const PictFormat& format) {
+  return Render::CreateGlyphSet(Render::CreateGlyphSetRequest{gsid, format});
+}
+
+Future<void> Render::ReferenceGlyphSet(
+    const Render::ReferenceGlyphSetRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& gsid = request.gsid;
+  auto& existing = request.existing;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // gsid
+  buf.Write(&gsid);
+
+  // existing
+  buf.Write(&existing);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::ReferenceGlyphSet",
+                                        false);
+}
+
+Future<void> Render::ReferenceGlyphSet(const GlyphSet& gsid,
+                                       const GlyphSet& existing) {
+  return Render::ReferenceGlyphSet(
+      Render::ReferenceGlyphSetRequest{gsid, existing});
+}
+
+Future<void> Render::FreeGlyphSet(const Render::FreeGlyphSetRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& glyphset = request.glyphset;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // glyphset
+  buf.Write(&glyphset);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::FreeGlyphSet", false);
+}
+
+Future<void> Render::FreeGlyphSet(const GlyphSet& glyphset) {
+  return Render::FreeGlyphSet(Render::FreeGlyphSetRequest{glyphset});
+}
+
+Future<void> Render::AddGlyphs(const Render::AddGlyphsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& glyphset = request.glyphset;
+  uint32_t glyphs_len{};
+  auto& glyphids = request.glyphids;
+  size_t glyphids_len = glyphids.size();
+  auto& glyphs = request.glyphs;
+  auto& data = request.data;
+  size_t data_len = data.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 20;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // glyphset
+  buf.Write(&glyphset);
+
+  // glyphs_len
+  glyphs_len = glyphs.size();
+  buf.Write(&glyphs_len);
+
+  // glyphids
+  DCHECK_EQ(static_cast<size_t>(glyphs_len), glyphids.size());
+  for (auto& glyphids_elem : glyphids) {
+    // glyphids_elem
+    buf.Write(&glyphids_elem);
+  }
+
+  // glyphs
+  DCHECK_EQ(static_cast<size_t>(glyphs_len), glyphs.size());
+  for (auto& glyphs_elem : glyphs) {
+    // glyphs_elem
+    {
+      auto& width = glyphs_elem.width;
+      auto& height = glyphs_elem.height;
+      auto& x = glyphs_elem.x;
+      auto& y = glyphs_elem.y;
+      auto& x_off = glyphs_elem.x_off;
+      auto& y_off = glyphs_elem.y_off;
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // x_off
+      buf.Write(&x_off);
+
+      // y_off
+      buf.Write(&y_off);
+    }
+  }
+
+  // data
+  DCHECK_EQ(static_cast<size_t>(data_len), data.size());
+  for (auto& data_elem : data) {
+    // data_elem
+    buf.Write(&data_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::AddGlyphs", false);
+}
+
+Future<void> Render::AddGlyphs(const GlyphSet& glyphset,
+                               const std::vector<uint32_t>& glyphids,
+                               const std::vector<GlyphInfo>& glyphs,
+                               const std::vector<uint8_t>& data) {
+  return Render::AddGlyphs(
+      Render::AddGlyphsRequest{glyphset, glyphids, glyphs, data});
+}
+
+Future<void> Render::FreeGlyphs(const Render::FreeGlyphsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& glyphset = request.glyphset;
+  auto& glyphs = request.glyphs;
+  size_t glyphs_len = glyphs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 22;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // glyphset
+  buf.Write(&glyphset);
+
+  // glyphs
+  DCHECK_EQ(static_cast<size_t>(glyphs_len), glyphs.size());
+  for (auto& glyphs_elem : glyphs) {
+    // glyphs_elem
+    buf.Write(&glyphs_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::FreeGlyphs", false);
+}
+
+Future<void> Render::FreeGlyphs(const GlyphSet& glyphset,
+                                const std::vector<Glyph>& glyphs) {
+  return Render::FreeGlyphs(Render::FreeGlyphsRequest{glyphset, glyphs});
+}
+
+Future<void> Render::CompositeGlyphs8(
+    const Render::CompositeGlyphs8Request& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& src = request.src;
+  auto& dst = request.dst;
+  auto& mask_format = request.mask_format;
+  auto& glyphset = request.glyphset;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& glyphcmds = request.glyphcmds;
+  size_t glyphcmds_len = glyphcmds.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 23;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp17;
+  tmp17 = static_cast<uint8_t>(op);
+  buf.Write(&tmp17);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // src
+  buf.Write(&src);
+
+  // dst
+  buf.Write(&dst);
+
+  // mask_format
+  buf.Write(&mask_format);
+
+  // glyphset
+  buf.Write(&glyphset);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // glyphcmds
+  DCHECK_EQ(static_cast<size_t>(glyphcmds_len), glyphcmds.size());
+  for (auto& glyphcmds_elem : glyphcmds) {
+    // glyphcmds_elem
+    buf.Write(&glyphcmds_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CompositeGlyphs8",
+                                        false);
+}
+
+Future<void> Render::CompositeGlyphs8(const PictOp& op,
+                                      const Picture& src,
+                                      const Picture& dst,
+                                      const PictFormat& mask_format,
+                                      const GlyphSet& glyphset,
+                                      const int16_t& src_x,
+                                      const int16_t& src_y,
+                                      const std::vector<uint8_t>& glyphcmds) {
+  return Render::CompositeGlyphs8(Render::CompositeGlyphs8Request{
+      op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds});
+}
+
+Future<void> Render::CompositeGlyphs16(
+    const Render::CompositeGlyphs16Request& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& src = request.src;
+  auto& dst = request.dst;
+  auto& mask_format = request.mask_format;
+  auto& glyphset = request.glyphset;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& glyphcmds = request.glyphcmds;
+  size_t glyphcmds_len = glyphcmds.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 24;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp18;
+  tmp18 = static_cast<uint8_t>(op);
+  buf.Write(&tmp18);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // src
+  buf.Write(&src);
+
+  // dst
+  buf.Write(&dst);
+
+  // mask_format
+  buf.Write(&mask_format);
+
+  // glyphset
+  buf.Write(&glyphset);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // glyphcmds
+  DCHECK_EQ(static_cast<size_t>(glyphcmds_len), glyphcmds.size());
+  for (auto& glyphcmds_elem : glyphcmds) {
+    // glyphcmds_elem
+    buf.Write(&glyphcmds_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CompositeGlyphs16",
+                                        false);
+}
+
+Future<void> Render::CompositeGlyphs16(const PictOp& op,
+                                       const Picture& src,
+                                       const Picture& dst,
+                                       const PictFormat& mask_format,
+                                       const GlyphSet& glyphset,
+                                       const int16_t& src_x,
+                                       const int16_t& src_y,
+                                       const std::vector<uint8_t>& glyphcmds) {
+  return Render::CompositeGlyphs16(Render::CompositeGlyphs16Request{
+      op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds});
+}
+
+Future<void> Render::CompositeGlyphs32(
+    const Render::CompositeGlyphs32Request& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& src = request.src;
+  auto& dst = request.dst;
+  auto& mask_format = request.mask_format;
+  auto& glyphset = request.glyphset;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& glyphcmds = request.glyphcmds;
+  size_t glyphcmds_len = glyphcmds.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 25;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp19;
+  tmp19 = static_cast<uint8_t>(op);
+  buf.Write(&tmp19);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // src
+  buf.Write(&src);
+
+  // dst
+  buf.Write(&dst);
+
+  // mask_format
+  buf.Write(&mask_format);
+
+  // glyphset
+  buf.Write(&glyphset);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // glyphcmds
+  DCHECK_EQ(static_cast<size_t>(glyphcmds_len), glyphcmds.size());
+  for (auto& glyphcmds_elem : glyphcmds) {
+    // glyphcmds_elem
+    buf.Write(&glyphcmds_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CompositeGlyphs32",
+                                        false);
+}
+
+Future<void> Render::CompositeGlyphs32(const PictOp& op,
+                                       const Picture& src,
+                                       const Picture& dst,
+                                       const PictFormat& mask_format,
+                                       const GlyphSet& glyphset,
+                                       const int16_t& src_x,
+                                       const int16_t& src_y,
+                                       const std::vector<uint8_t>& glyphcmds) {
+  return Render::CompositeGlyphs32(Render::CompositeGlyphs32Request{
+      op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds});
+}
+
+Future<void> Render::FillRectangles(
+    const Render::FillRectanglesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& op = request.op;
+  auto& dst = request.dst;
+  auto& color = request.color;
+  auto& rects = request.rects;
+  size_t rects_len = rects.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 26;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // op
+  uint8_t tmp20;
+  tmp20 = static_cast<uint8_t>(op);
+  buf.Write(&tmp20);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // dst
+  buf.Write(&dst);
+
+  // color
+  {
+    auto& red = color.red;
+    auto& green = color.green;
+    auto& blue = color.blue;
+    auto& alpha = color.alpha;
+
+    // red
+    buf.Write(&red);
+
+    // green
+    buf.Write(&green);
+
+    // blue
+    buf.Write(&blue);
+
+    // alpha
+    buf.Write(&alpha);
+  }
+
+  // rects
+  DCHECK_EQ(static_cast<size_t>(rects_len), rects.size());
+  for (auto& rects_elem : rects) {
+    // rects_elem
+    {
+      auto& x = rects_elem.x;
+      auto& y = rects_elem.y;
+      auto& width = rects_elem.width;
+      auto& height = rects_elem.height;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::FillRectangles", false);
+}
+
+Future<void> Render::FillRectangles(const PictOp& op,
+                                    const Picture& dst,
+                                    const Color& color,
+                                    const std::vector<Rectangle>& rects) {
+  return Render::FillRectangles(
+      Render::FillRectanglesRequest{op, dst, color, rects});
+}
+
+Future<void> Render::CreateCursor(const Render::CreateCursorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cid = request.cid;
+  auto& source = request.source;
+  auto& x = request.x;
+  auto& y = request.y;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 27;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cid
+  buf.Write(&cid);
+
+  // source
+  buf.Write(&source);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CreateCursor", false);
+}
+
+Future<void> Render::CreateCursor(const Cursor& cid,
+                                  const Picture& source,
+                                  const uint16_t& x,
+                                  const uint16_t& y) {
+  return Render::CreateCursor(Render::CreateCursorRequest{cid, source, x, y});
+}
+
+Future<void> Render::SetPictureTransform(
+    const Render::SetPictureTransformRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  auto& transform = request.transform;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 28;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // transform
+  {
+    auto& matrix11 = transform.matrix11;
+    auto& matrix12 = transform.matrix12;
+    auto& matrix13 = transform.matrix13;
+    auto& matrix21 = transform.matrix21;
+    auto& matrix22 = transform.matrix22;
+    auto& matrix23 = transform.matrix23;
+    auto& matrix31 = transform.matrix31;
+    auto& matrix32 = transform.matrix32;
+    auto& matrix33 = transform.matrix33;
+
+    // matrix11
+    buf.Write(&matrix11);
+
+    // matrix12
+    buf.Write(&matrix12);
+
+    // matrix13
+    buf.Write(&matrix13);
+
+    // matrix21
+    buf.Write(&matrix21);
+
+    // matrix22
+    buf.Write(&matrix22);
+
+    // matrix23
+    buf.Write(&matrix23);
+
+    // matrix31
+    buf.Write(&matrix31);
+
+    // matrix32
+    buf.Write(&matrix32);
+
+    // matrix33
+    buf.Write(&matrix33);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::SetPictureTransform",
+                                        false);
+}
+
+Future<void> Render::SetPictureTransform(const Picture& picture,
+                                         const Transform& transform) {
+  return Render::SetPictureTransform(
+      Render::SetPictureTransformRequest{picture, transform});
+}
+
+Future<Render::QueryFiltersReply> Render::QueryFilters(
+    const Render::QueryFiltersRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 29;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Render::QueryFiltersReply>(
+      &buf, "Render::QueryFilters", false);
+}
+
+Future<Render::QueryFiltersReply> Render::QueryFilters(
+    const Drawable& drawable) {
+  return Render::QueryFilters(Render::QueryFiltersRequest{drawable});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Render::QueryFiltersReply> detail::ReadReply<
+    Render::QueryFiltersReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Render::QueryFiltersReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_aliases{};
+  uint32_t num_filters{};
+  auto& aliases = (*reply).aliases;
+  size_t aliases_len = aliases.size();
+  auto& filters = (*reply).filters;
+  size_t filters_len = filters.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_aliases
+  Read(&num_aliases, &buf);
+
+  // num_filters
+  Read(&num_filters, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  // aliases
+  aliases.resize(num_aliases);
+  for (auto& aliases_elem : aliases) {
+    // aliases_elem
+    Read(&aliases_elem, &buf);
+  }
+
+  // filters
+  filters.resize(num_filters);
+  for (auto& filters_elem : filters) {
+    // filters_elem
+    {
+      uint8_t name_len{};
+      auto& name = filters_elem.name;
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // name
+      name.resize(name_len);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Render::SetPictureFilter(
+    const Render::SetPictureFilterRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  uint16_t filter_len{};
+  auto& filter = request.filter;
+  auto& values = request.values;
+  size_t values_len = values.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 30;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // filter_len
+  filter_len = filter.size();
+  buf.Write(&filter_len);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // filter
+  DCHECK_EQ(static_cast<size_t>(filter_len), filter.size());
+  for (auto& filter_elem : filter) {
+    // filter_elem
+    buf.Write(&filter_elem);
+  }
+
+  // pad1
+  Align(&buf, 4);
+
+  // values
+  DCHECK_EQ(static_cast<size_t>(values_len), values.size());
+  for (auto& values_elem : values) {
+    // values_elem
+    buf.Write(&values_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::SetPictureFilter",
+                                        false);
+}
+
+Future<void> Render::SetPictureFilter(const Picture& picture,
+                                      const std::string& filter,
+                                      const std::vector<Fixed>& values) {
+  return Render::SetPictureFilter(
+      Render::SetPictureFilterRequest{picture, filter, values});
+}
+
+Future<void> Render::CreateAnimCursor(
+    const Render::CreateAnimCursorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cid = request.cid;
+  auto& cursors = request.cursors;
+  size_t cursors_len = cursors.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 31;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cid
+  buf.Write(&cid);
+
+  // cursors
+  DCHECK_EQ(static_cast<size_t>(cursors_len), cursors.size());
+  for (auto& cursors_elem : cursors) {
+    // cursors_elem
+    {
+      auto& cursor = cursors_elem.cursor;
+      auto& delay = cursors_elem.delay;
+
+      // cursor
+      buf.Write(&cursor);
+
+      // delay
+      buf.Write(&delay);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CreateAnimCursor",
+                                        false);
+}
+
+Future<void> Render::CreateAnimCursor(
+    const Cursor& cid,
+    const std::vector<AnimationCursorElement>& cursors) {
+  return Render::CreateAnimCursor(
+      Render::CreateAnimCursorRequest{cid, cursors});
+}
+
+Future<void> Render::AddTraps(const Render::AddTrapsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  auto& x_off = request.x_off;
+  auto& y_off = request.y_off;
+  auto& traps = request.traps;
+  size_t traps_len = traps.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 32;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // x_off
+  buf.Write(&x_off);
+
+  // y_off
+  buf.Write(&y_off);
+
+  // traps
+  DCHECK_EQ(static_cast<size_t>(traps_len), traps.size());
+  for (auto& traps_elem : traps) {
+    // traps_elem
+    {
+      auto& top = traps_elem.top;
+      auto& bot = traps_elem.bot;
+
+      // top
+      {
+        auto& l = top.l;
+        auto& r = top.r;
+        auto& y = top.y;
+
+        // l
+        buf.Write(&l);
+
+        // r
+        buf.Write(&r);
+
+        // y
+        buf.Write(&y);
+      }
+
+      // bot
+      {
+        auto& l = bot.l;
+        auto& r = bot.r;
+        auto& y = bot.y;
+
+        // l
+        buf.Write(&l);
+
+        // r
+        buf.Write(&r);
+
+        // y
+        buf.Write(&y);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::AddTraps", false);
+}
+
+Future<void> Render::AddTraps(const Picture& picture,
+                              const int16_t& x_off,
+                              const int16_t& y_off,
+                              const std::vector<Trap>& traps) {
+  return Render::AddTraps(
+      Render::AddTrapsRequest{picture, x_off, y_off, traps});
+}
+
+Future<void> Render::CreateSolidFill(
+    const Render::CreateSolidFillRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  auto& color = request.color;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 33;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // color
+  {
+    auto& red = color.red;
+    auto& green = color.green;
+    auto& blue = color.blue;
+    auto& alpha = color.alpha;
+
+    // red
+    buf.Write(&red);
+
+    // green
+    buf.Write(&green);
+
+    // blue
+    buf.Write(&blue);
+
+    // alpha
+    buf.Write(&alpha);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CreateSolidFill", false);
+}
+
+Future<void> Render::CreateSolidFill(const Picture& picture,
+                                     const Color& color) {
+  return Render::CreateSolidFill(
+      Render::CreateSolidFillRequest{picture, color});
+}
+
+Future<void> Render::CreateLinearGradient(
+    const Render::CreateLinearGradientRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  auto& p1 = request.p1;
+  auto& p2 = request.p2;
+  uint32_t num_stops{};
+  auto& stops = request.stops;
+  size_t stops_len = stops.size();
+  auto& colors = request.colors;
+  size_t colors_len = colors.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 34;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // p1
+  {
+    auto& x = p1.x;
+    auto& y = p1.y;
+
+    // x
+    buf.Write(&x);
+
+    // y
+    buf.Write(&y);
+  }
+
+  // p2
+  {
+    auto& x = p2.x;
+    auto& y = p2.y;
+
+    // x
+    buf.Write(&x);
+
+    // y
+    buf.Write(&y);
+  }
+
+  // num_stops
+  num_stops = stops.size();
+  buf.Write(&num_stops);
+
+  // stops
+  DCHECK_EQ(static_cast<size_t>(num_stops), stops.size());
+  for (auto& stops_elem : stops) {
+    // stops_elem
+    buf.Write(&stops_elem);
+  }
+
+  // colors
+  DCHECK_EQ(static_cast<size_t>(num_stops), colors.size());
+  for (auto& colors_elem : colors) {
+    // colors_elem
+    {
+      auto& red = colors_elem.red;
+      auto& green = colors_elem.green;
+      auto& blue = colors_elem.blue;
+      auto& alpha = colors_elem.alpha;
+
+      // red
+      buf.Write(&red);
+
+      // green
+      buf.Write(&green);
+
+      // blue
+      buf.Write(&blue);
+
+      // alpha
+      buf.Write(&alpha);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CreateLinearGradient",
+                                        false);
+}
+
+Future<void> Render::CreateLinearGradient(const Picture& picture,
+                                          const PointFix& p1,
+                                          const PointFix& p2,
+                                          const std::vector<Fixed>& stops,
+                                          const std::vector<Color>& colors) {
+  return Render::CreateLinearGradient(
+      Render::CreateLinearGradientRequest{picture, p1, p2, stops, colors});
+}
+
+Future<void> Render::CreateRadialGradient(
+    const Render::CreateRadialGradientRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  auto& inner = request.inner;
+  auto& outer = request.outer;
+  auto& inner_radius = request.inner_radius;
+  auto& outer_radius = request.outer_radius;
+  uint32_t num_stops{};
+  auto& stops = request.stops;
+  size_t stops_len = stops.size();
+  auto& colors = request.colors;
+  size_t colors_len = colors.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 35;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // inner
+  {
+    auto& x = inner.x;
+    auto& y = inner.y;
+
+    // x
+    buf.Write(&x);
+
+    // y
+    buf.Write(&y);
+  }
+
+  // outer
+  {
+    auto& x = outer.x;
+    auto& y = outer.y;
+
+    // x
+    buf.Write(&x);
+
+    // y
+    buf.Write(&y);
+  }
+
+  // inner_radius
+  buf.Write(&inner_radius);
+
+  // outer_radius
+  buf.Write(&outer_radius);
+
+  // num_stops
+  num_stops = stops.size();
+  buf.Write(&num_stops);
+
+  // stops
+  DCHECK_EQ(static_cast<size_t>(num_stops), stops.size());
+  for (auto& stops_elem : stops) {
+    // stops_elem
+    buf.Write(&stops_elem);
+  }
+
+  // colors
+  DCHECK_EQ(static_cast<size_t>(num_stops), colors.size());
+  for (auto& colors_elem : colors) {
+    // colors_elem
+    {
+      auto& red = colors_elem.red;
+      auto& green = colors_elem.green;
+      auto& blue = colors_elem.blue;
+      auto& alpha = colors_elem.alpha;
+
+      // red
+      buf.Write(&red);
+
+      // green
+      buf.Write(&green);
+
+      // blue
+      buf.Write(&blue);
+
+      // alpha
+      buf.Write(&alpha);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CreateRadialGradient",
+                                        false);
+}
+
+Future<void> Render::CreateRadialGradient(const Picture& picture,
+                                          const PointFix& inner,
+                                          const PointFix& outer,
+                                          const Fixed& inner_radius,
+                                          const Fixed& outer_radius,
+                                          const std::vector<Fixed>& stops,
+                                          const std::vector<Color>& colors) {
+  return Render::CreateRadialGradient(Render::CreateRadialGradientRequest{
+      picture, inner, outer, inner_radius, outer_radius, stops, colors});
+}
+
+Future<void> Render::CreateConicalGradient(
+    const Render::CreateConicalGradientRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  auto& center = request.center;
+  auto& angle = request.angle;
+  uint32_t num_stops{};
+  auto& stops = request.stops;
+  size_t stops_len = stops.size();
+  auto& colors = request.colors;
+  size_t colors_len = colors.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 36;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // center
+  {
+    auto& x = center.x;
+    auto& y = center.y;
+
+    // x
+    buf.Write(&x);
+
+    // y
+    buf.Write(&y);
+  }
+
+  // angle
+  buf.Write(&angle);
+
+  // num_stops
+  num_stops = stops.size();
+  buf.Write(&num_stops);
+
+  // stops
+  DCHECK_EQ(static_cast<size_t>(num_stops), stops.size());
+  for (auto& stops_elem : stops) {
+    // stops_elem
+    buf.Write(&stops_elem);
+  }
+
+  // colors
+  DCHECK_EQ(static_cast<size_t>(num_stops), colors.size());
+  for (auto& colors_elem : colors) {
+    // colors_elem
+    {
+      auto& red = colors_elem.red;
+      auto& green = colors_elem.green;
+      auto& blue = colors_elem.blue;
+      auto& alpha = colors_elem.alpha;
+
+      // red
+      buf.Write(&red);
+
+      // green
+      buf.Write(&green);
+
+      // blue
+      buf.Write(&blue);
+
+      // alpha
+      buf.Write(&alpha);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Render::CreateConicalGradient",
+                                        false);
+}
+
+Future<void> Render::CreateConicalGradient(const Picture& picture,
+                                           const PointFix& center,
+                                           const Fixed& angle,
+                                           const std::vector<Fixed>& stops,
+                                           const std::vector<Color>& colors) {
+  return Render::CreateConicalGradient(Render::CreateConicalGradientRequest{
+      picture, center, angle, stops, colors});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/render.h b/ui/gfx/x/generated_protos/render.h
new file mode 100644
index 0000000..62d784f
--- /dev/null
+++ b/ui/gfx/x/generated_protos/render.h
@@ -0,0 +1,1047 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_RENDER_H_
+#define UI_GFX_X_GENERATED_PROTOS_RENDER_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Render {
+ public:
+  static constexpr unsigned major_version = 0;
+  static constexpr unsigned minor_version = 11;
+
+  Render(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class PictType : int {
+    Indexed = 0,
+    Direct = 1,
+  };
+
+  enum class Picture : uint32_t {
+    None = 0,
+  };
+
+  enum class PictOp : int {
+    Clear = 0,
+    Src = 1,
+    Dst = 2,
+    Over = 3,
+    OverReverse = 4,
+    In = 5,
+    InReverse = 6,
+    Out = 7,
+    OutReverse = 8,
+    Atop = 9,
+    AtopReverse = 10,
+    Xor = 11,
+    Add = 12,
+    Saturate = 13,
+    DisjointClear = 16,
+    DisjointSrc = 17,
+    DisjointDst = 18,
+    DisjointOver = 19,
+    DisjointOverReverse = 20,
+    DisjointIn = 21,
+    DisjointInReverse = 22,
+    DisjointOut = 23,
+    DisjointOutReverse = 24,
+    DisjointAtop = 25,
+    DisjointAtopReverse = 26,
+    DisjointXor = 27,
+    ConjointClear = 32,
+    ConjointSrc = 33,
+    ConjointDst = 34,
+    ConjointOver = 35,
+    ConjointOverReverse = 36,
+    ConjointIn = 37,
+    ConjointInReverse = 38,
+    ConjointOut = 39,
+    ConjointOutReverse = 40,
+    ConjointAtop = 41,
+    ConjointAtopReverse = 42,
+    ConjointXor = 43,
+    Multiply = 48,
+    Screen = 49,
+    Overlay = 50,
+    Darken = 51,
+    Lighten = 52,
+    ColorDodge = 53,
+    ColorBurn = 54,
+    HardLight = 55,
+    SoftLight = 56,
+    Difference = 57,
+    Exclusion = 58,
+    HSLHue = 59,
+    HSLSaturation = 60,
+    HSLColor = 61,
+    HSLLuminosity = 62,
+  };
+
+  enum class PolyEdge : int {
+    Sharp = 0,
+    Smooth = 1,
+  };
+
+  enum class PolyMode : int {
+    Precise = 0,
+    Imprecise = 1,
+  };
+
+  enum class CreatePictureAttribute : int {
+    Repeat = 1 << 0,
+    AlphaMap = 1 << 1,
+    AlphaXOrigin = 1 << 2,
+    AlphaYOrigin = 1 << 3,
+    ClipXOrigin = 1 << 4,
+    ClipYOrigin = 1 << 5,
+    ClipMask = 1 << 6,
+    GraphicsExposure = 1 << 7,
+    SubwindowMode = 1 << 8,
+    PolyEdge = 1 << 9,
+    PolyMode = 1 << 10,
+    Dither = 1 << 11,
+    ComponentAlpha = 1 << 12,
+  };
+
+  enum class SubPixel : int {
+    Unknown = 0,
+    HorizontalRGB = 1,
+    HorizontalBGR = 2,
+    VerticalRGB = 3,
+    VerticalBGR = 4,
+    None = 5,
+  };
+
+  enum class Repeat : int {
+    None = 0,
+    Normal = 1,
+    Pad = 2,
+    Reflect = 3,
+  };
+
+  enum class Glyph : uint32_t {};
+
+  enum class GlyphSet : uint32_t {};
+
+  enum class PictFormat : uint32_t {};
+
+  enum class Fixed : int32_t {};
+
+  struct PictFormatError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct PictureError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct PictOpError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct GlyphSetError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct GlyphError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct DirectFormat {
+    uint16_t red_shift{};
+    uint16_t red_mask{};
+    uint16_t green_shift{};
+    uint16_t green_mask{};
+    uint16_t blue_shift{};
+    uint16_t blue_mask{};
+    uint16_t alpha_shift{};
+    uint16_t alpha_mask{};
+  };
+
+  struct PictFormInfo {
+    PictFormat id{};
+    PictType type{};
+    uint8_t depth{};
+    DirectFormat direct{};
+    ColorMap colormap{};
+  };
+
+  struct PictVisual {
+    VisualId visual{};
+    PictFormat format{};
+  };
+
+  struct PictDepth {
+    uint8_t depth{};
+    std::vector<PictVisual> visuals{};
+  };
+
+  struct PictScreen {
+    PictFormat fallback{};
+    std::vector<PictDepth> depths{};
+  };
+
+  struct IndexValue {
+    uint32_t pixel{};
+    uint16_t red{};
+    uint16_t green{};
+    uint16_t blue{};
+    uint16_t alpha{};
+  };
+
+  struct Color {
+    uint16_t red{};
+    uint16_t green{};
+    uint16_t blue{};
+    uint16_t alpha{};
+  };
+
+  struct PointFix {
+    Fixed x{};
+    Fixed y{};
+  };
+
+  struct LineFix {
+    PointFix p1{};
+    PointFix p2{};
+  };
+
+  struct Triangle {
+    PointFix p1{};
+    PointFix p2{};
+    PointFix p3{};
+  };
+
+  struct Trapezoid {
+    Fixed top{};
+    Fixed bottom{};
+    LineFix left{};
+    LineFix right{};
+  };
+
+  struct GlyphInfo {
+    uint16_t width{};
+    uint16_t height{};
+    int16_t x{};
+    int16_t y{};
+    int16_t x_off{};
+    int16_t y_off{};
+  };
+
+  struct Transform {
+    Fixed matrix11{};
+    Fixed matrix12{};
+    Fixed matrix13{};
+    Fixed matrix21{};
+    Fixed matrix22{};
+    Fixed matrix23{};
+    Fixed matrix31{};
+    Fixed matrix32{};
+    Fixed matrix33{};
+  };
+
+  struct AnimationCursorElement {
+    Cursor cursor{};
+    uint32_t delay{};
+  };
+
+  struct SpanFix {
+    Fixed l{};
+    Fixed r{};
+    Fixed y{};
+  };
+
+  struct Trap {
+    SpanFix top{};
+    SpanFix bot{};
+  };
+
+  struct QueryVersionRequest {
+    uint32_t client_major_version{};
+    uint32_t client_minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(
+      const uint32_t& client_major_version = {},
+      const uint32_t& client_minor_version = {});
+
+  struct QueryPictFormatsRequest {};
+
+  struct QueryPictFormatsReply {
+    uint16_t sequence{};
+    uint32_t num_depths{};
+    uint32_t num_visuals{};
+    std::vector<PictFormInfo> formats{};
+    std::vector<PictScreen> screens{};
+    std::vector<SubPixel> subpixels{};
+  };
+
+  using QueryPictFormatsResponse = Response<QueryPictFormatsReply>;
+
+  Future<QueryPictFormatsReply> QueryPictFormats(
+      const QueryPictFormatsRequest& request);
+
+  Future<QueryPictFormatsReply> QueryPictFormats();
+
+  struct QueryPictIndexValuesRequest {
+    PictFormat format{};
+  };
+
+  struct QueryPictIndexValuesReply {
+    uint16_t sequence{};
+    std::vector<IndexValue> values{};
+  };
+
+  using QueryPictIndexValuesResponse = Response<QueryPictIndexValuesReply>;
+
+  Future<QueryPictIndexValuesReply> QueryPictIndexValues(
+      const QueryPictIndexValuesRequest& request);
+
+  Future<QueryPictIndexValuesReply> QueryPictIndexValues(
+      const PictFormat& format = {});
+
+  struct CreatePictureRequest {
+    Picture pid{};
+    Drawable drawable{};
+    PictFormat format{};
+    absl::optional<Repeat> repeat{};
+    absl::optional<Picture> alphamap{};
+    absl::optional<int32_t> alphaxorigin{};
+    absl::optional<int32_t> alphayorigin{};
+    absl::optional<int32_t> clipxorigin{};
+    absl::optional<int32_t> clipyorigin{};
+    absl::optional<Pixmap> clipmask{};
+    absl::optional<uint32_t> graphicsexposure{};
+    absl::optional<SubwindowMode> subwindowmode{};
+    absl::optional<PolyEdge> polyedge{};
+    absl::optional<PolyMode> polymode{};
+    absl::optional<Atom> dither{};
+    absl::optional<uint32_t> componentalpha{};
+  };
+
+  using CreatePictureResponse = Response<void>;
+
+  Future<void> CreatePicture(const CreatePictureRequest& request);
+
+  Future<void> CreatePicture(
+      const Picture& pid = {},
+      const Drawable& drawable = {},
+      const PictFormat& format = {},
+      const absl::optional<Repeat>& repeat = absl::nullopt,
+      const absl::optional<Picture>& alphamap = absl::nullopt,
+      const absl::optional<int32_t>& alphaxorigin = absl::nullopt,
+      const absl::optional<int32_t>& alphayorigin = absl::nullopt,
+      const absl::optional<int32_t>& clipxorigin = absl::nullopt,
+      const absl::optional<int32_t>& clipyorigin = absl::nullopt,
+      const absl::optional<Pixmap>& clipmask = absl::nullopt,
+      const absl::optional<uint32_t>& graphicsexposure = absl::nullopt,
+      const absl::optional<SubwindowMode>& subwindowmode = absl::nullopt,
+      const absl::optional<PolyEdge>& polyedge = absl::nullopt,
+      const absl::optional<PolyMode>& polymode = absl::nullopt,
+      const absl::optional<Atom>& dither = absl::nullopt,
+      const absl::optional<uint32_t>& componentalpha = absl::nullopt);
+
+  struct ChangePictureRequest {
+    Picture picture{};
+    absl::optional<Repeat> repeat{};
+    absl::optional<Picture> alphamap{};
+    absl::optional<int32_t> alphaxorigin{};
+    absl::optional<int32_t> alphayorigin{};
+    absl::optional<int32_t> clipxorigin{};
+    absl::optional<int32_t> clipyorigin{};
+    absl::optional<Pixmap> clipmask{};
+    absl::optional<uint32_t> graphicsexposure{};
+    absl::optional<SubwindowMode> subwindowmode{};
+    absl::optional<PolyEdge> polyedge{};
+    absl::optional<PolyMode> polymode{};
+    absl::optional<Atom> dither{};
+    absl::optional<uint32_t> componentalpha{};
+  };
+
+  using ChangePictureResponse = Response<void>;
+
+  Future<void> ChangePicture(const ChangePictureRequest& request);
+
+  Future<void> ChangePicture(
+      const Picture& picture = {},
+      const absl::optional<Repeat>& repeat = absl::nullopt,
+      const absl::optional<Picture>& alphamap = absl::nullopt,
+      const absl::optional<int32_t>& alphaxorigin = absl::nullopt,
+      const absl::optional<int32_t>& alphayorigin = absl::nullopt,
+      const absl::optional<int32_t>& clipxorigin = absl::nullopt,
+      const absl::optional<int32_t>& clipyorigin = absl::nullopt,
+      const absl::optional<Pixmap>& clipmask = absl::nullopt,
+      const absl::optional<uint32_t>& graphicsexposure = absl::nullopt,
+      const absl::optional<SubwindowMode>& subwindowmode = absl::nullopt,
+      const absl::optional<PolyEdge>& polyedge = absl::nullopt,
+      const absl::optional<PolyMode>& polymode = absl::nullopt,
+      const absl::optional<Atom>& dither = absl::nullopt,
+      const absl::optional<uint32_t>& componentalpha = absl::nullopt);
+
+  struct SetPictureClipRectanglesRequest {
+    Picture picture{};
+    int16_t clip_x_origin{};
+    int16_t clip_y_origin{};
+    std::vector<Rectangle> rectangles{};
+  };
+
+  using SetPictureClipRectanglesResponse = Response<void>;
+
+  Future<void> SetPictureClipRectangles(
+      const SetPictureClipRectanglesRequest& request);
+
+  Future<void> SetPictureClipRectangles(
+      const Picture& picture = {},
+      const int16_t& clip_x_origin = {},
+      const int16_t& clip_y_origin = {},
+      const std::vector<Rectangle>& rectangles = {});
+
+  struct FreePictureRequest {
+    Picture picture{};
+  };
+
+  using FreePictureResponse = Response<void>;
+
+  Future<void> FreePicture(const FreePictureRequest& request);
+
+  Future<void> FreePicture(const Picture& picture = {});
+
+  struct CompositeRequest {
+    PictOp op{};
+    Picture src{};
+    Picture mask{};
+    Picture dst{};
+    int16_t src_x{};
+    int16_t src_y{};
+    int16_t mask_x{};
+    int16_t mask_y{};
+    int16_t dst_x{};
+    int16_t dst_y{};
+    uint16_t width{};
+    uint16_t height{};
+  };
+
+  using CompositeResponse = Response<void>;
+
+  Future<void> Composite(const CompositeRequest& request);
+
+  Future<void> Composite(const PictOp& op = {},
+                         const Picture& src = {},
+                         const Picture& mask = {},
+                         const Picture& dst = {},
+                         const int16_t& src_x = {},
+                         const int16_t& src_y = {},
+                         const int16_t& mask_x = {},
+                         const int16_t& mask_y = {},
+                         const int16_t& dst_x = {},
+                         const int16_t& dst_y = {},
+                         const uint16_t& width = {},
+                         const uint16_t& height = {});
+
+  struct TrapezoidsRequest {
+    PictOp op{};
+    Picture src{};
+    Picture dst{};
+    PictFormat mask_format{};
+    int16_t src_x{};
+    int16_t src_y{};
+    std::vector<Trapezoid> traps{};
+  };
+
+  using TrapezoidsResponse = Response<void>;
+
+  Future<void> Trapezoids(const TrapezoidsRequest& request);
+
+  Future<void> Trapezoids(const PictOp& op = {},
+                          const Picture& src = {},
+                          const Picture& dst = {},
+                          const PictFormat& mask_format = {},
+                          const int16_t& src_x = {},
+                          const int16_t& src_y = {},
+                          const std::vector<Trapezoid>& traps = {});
+
+  struct TrianglesRequest {
+    PictOp op{};
+    Picture src{};
+    Picture dst{};
+    PictFormat mask_format{};
+    int16_t src_x{};
+    int16_t src_y{};
+    std::vector<Triangle> triangles{};
+  };
+
+  using TrianglesResponse = Response<void>;
+
+  Future<void> Triangles(const TrianglesRequest& request);
+
+  Future<void> Triangles(const PictOp& op = {},
+                         const Picture& src = {},
+                         const Picture& dst = {},
+                         const PictFormat& mask_format = {},
+                         const int16_t& src_x = {},
+                         const int16_t& src_y = {},
+                         const std::vector<Triangle>& triangles = {});
+
+  struct TriStripRequest {
+    PictOp op{};
+    Picture src{};
+    Picture dst{};
+    PictFormat mask_format{};
+    int16_t src_x{};
+    int16_t src_y{};
+    std::vector<PointFix> points{};
+  };
+
+  using TriStripResponse = Response<void>;
+
+  Future<void> TriStrip(const TriStripRequest& request);
+
+  Future<void> TriStrip(const PictOp& op = {},
+                        const Picture& src = {},
+                        const Picture& dst = {},
+                        const PictFormat& mask_format = {},
+                        const int16_t& src_x = {},
+                        const int16_t& src_y = {},
+                        const std::vector<PointFix>& points = {});
+
+  struct TriFanRequest {
+    PictOp op{};
+    Picture src{};
+    Picture dst{};
+    PictFormat mask_format{};
+    int16_t src_x{};
+    int16_t src_y{};
+    std::vector<PointFix> points{};
+  };
+
+  using TriFanResponse = Response<void>;
+
+  Future<void> TriFan(const TriFanRequest& request);
+
+  Future<void> TriFan(const PictOp& op = {},
+                      const Picture& src = {},
+                      const Picture& dst = {},
+                      const PictFormat& mask_format = {},
+                      const int16_t& src_x = {},
+                      const int16_t& src_y = {},
+                      const std::vector<PointFix>& points = {});
+
+  struct CreateGlyphSetRequest {
+    GlyphSet gsid{};
+    PictFormat format{};
+  };
+
+  using CreateGlyphSetResponse = Response<void>;
+
+  Future<void> CreateGlyphSet(const CreateGlyphSetRequest& request);
+
+  Future<void> CreateGlyphSet(const GlyphSet& gsid = {},
+                              const PictFormat& format = {});
+
+  struct ReferenceGlyphSetRequest {
+    GlyphSet gsid{};
+    GlyphSet existing{};
+  };
+
+  using ReferenceGlyphSetResponse = Response<void>;
+
+  Future<void> ReferenceGlyphSet(const ReferenceGlyphSetRequest& request);
+
+  Future<void> ReferenceGlyphSet(const GlyphSet& gsid = {},
+                                 const GlyphSet& existing = {});
+
+  struct FreeGlyphSetRequest {
+    GlyphSet glyphset{};
+  };
+
+  using FreeGlyphSetResponse = Response<void>;
+
+  Future<void> FreeGlyphSet(const FreeGlyphSetRequest& request);
+
+  Future<void> FreeGlyphSet(const GlyphSet& glyphset = {});
+
+  struct AddGlyphsRequest {
+    GlyphSet glyphset{};
+    std::vector<uint32_t> glyphids{};
+    std::vector<GlyphInfo> glyphs{};
+    std::vector<uint8_t> data{};
+  };
+
+  using AddGlyphsResponse = Response<void>;
+
+  Future<void> AddGlyphs(const AddGlyphsRequest& request);
+
+  Future<void> AddGlyphs(const GlyphSet& glyphset = {},
+                         const std::vector<uint32_t>& glyphids = {},
+                         const std::vector<GlyphInfo>& glyphs = {},
+                         const std::vector<uint8_t>& data = {});
+
+  struct FreeGlyphsRequest {
+    GlyphSet glyphset{};
+    std::vector<Glyph> glyphs{};
+  };
+
+  using FreeGlyphsResponse = Response<void>;
+
+  Future<void> FreeGlyphs(const FreeGlyphsRequest& request);
+
+  Future<void> FreeGlyphs(const GlyphSet& glyphset = {},
+                          const std::vector<Glyph>& glyphs = {});
+
+  struct CompositeGlyphs8Request {
+    PictOp op{};
+    Picture src{};
+    Picture dst{};
+    PictFormat mask_format{};
+    GlyphSet glyphset{};
+    int16_t src_x{};
+    int16_t src_y{};
+    std::vector<uint8_t> glyphcmds{};
+  };
+
+  using CompositeGlyphs8Response = Response<void>;
+
+  Future<void> CompositeGlyphs8(const CompositeGlyphs8Request& request);
+
+  Future<void> CompositeGlyphs8(const PictOp& op = {},
+                                const Picture& src = {},
+                                const Picture& dst = {},
+                                const PictFormat& mask_format = {},
+                                const GlyphSet& glyphset = {},
+                                const int16_t& src_x = {},
+                                const int16_t& src_y = {},
+                                const std::vector<uint8_t>& glyphcmds = {});
+
+  struct CompositeGlyphs16Request {
+    PictOp op{};
+    Picture src{};
+    Picture dst{};
+    PictFormat mask_format{};
+    GlyphSet glyphset{};
+    int16_t src_x{};
+    int16_t src_y{};
+    std::vector<uint8_t> glyphcmds{};
+  };
+
+  using CompositeGlyphs16Response = Response<void>;
+
+  Future<void> CompositeGlyphs16(const CompositeGlyphs16Request& request);
+
+  Future<void> CompositeGlyphs16(const PictOp& op = {},
+                                 const Picture& src = {},
+                                 const Picture& dst = {},
+                                 const PictFormat& mask_format = {},
+                                 const GlyphSet& glyphset = {},
+                                 const int16_t& src_x = {},
+                                 const int16_t& src_y = {},
+                                 const std::vector<uint8_t>& glyphcmds = {});
+
+  struct CompositeGlyphs32Request {
+    PictOp op{};
+    Picture src{};
+    Picture dst{};
+    PictFormat mask_format{};
+    GlyphSet glyphset{};
+    int16_t src_x{};
+    int16_t src_y{};
+    std::vector<uint8_t> glyphcmds{};
+  };
+
+  using CompositeGlyphs32Response = Response<void>;
+
+  Future<void> CompositeGlyphs32(const CompositeGlyphs32Request& request);
+
+  Future<void> CompositeGlyphs32(const PictOp& op = {},
+                                 const Picture& src = {},
+                                 const Picture& dst = {},
+                                 const PictFormat& mask_format = {},
+                                 const GlyphSet& glyphset = {},
+                                 const int16_t& src_x = {},
+                                 const int16_t& src_y = {},
+                                 const std::vector<uint8_t>& glyphcmds = {});
+
+  struct FillRectanglesRequest {
+    PictOp op{};
+    Picture dst{};
+    Color color{};
+    std::vector<Rectangle> rects{};
+  };
+
+  using FillRectanglesResponse = Response<void>;
+
+  Future<void> FillRectangles(const FillRectanglesRequest& request);
+
+  Future<void> FillRectangles(const PictOp& op = {},
+                              const Picture& dst = {},
+                              const Color& color = {{}, {}, {}, {}},
+                              const std::vector<Rectangle>& rects = {});
+
+  struct CreateCursorRequest {
+    Cursor cid{};
+    Picture source{};
+    uint16_t x{};
+    uint16_t y{};
+  };
+
+  using CreateCursorResponse = Response<void>;
+
+  Future<void> CreateCursor(const CreateCursorRequest& request);
+
+  Future<void> CreateCursor(const Cursor& cid = {},
+                            const Picture& source = {},
+                            const uint16_t& x = {},
+                            const uint16_t& y = {});
+
+  struct SetPictureTransformRequest {
+    Picture picture{};
+    Transform transform{};
+  };
+
+  using SetPictureTransformResponse = Response<void>;
+
+  Future<void> SetPictureTransform(const SetPictureTransformRequest& request);
+
+  Future<void> SetPictureTransform(
+      const Picture& picture = {},
+      const Transform& transform = {{}, {}, {}, {}, {}, {}, {}, {}, {}});
+
+  struct QueryFiltersRequest {
+    Drawable drawable{};
+  };
+
+  struct QueryFiltersReply {
+    uint16_t sequence{};
+    std::vector<uint16_t> aliases{};
+    std::vector<Str> filters{};
+  };
+
+  using QueryFiltersResponse = Response<QueryFiltersReply>;
+
+  Future<QueryFiltersReply> QueryFilters(const QueryFiltersRequest& request);
+
+  Future<QueryFiltersReply> QueryFilters(const Drawable& drawable = {});
+
+  struct SetPictureFilterRequest {
+    Picture picture{};
+    std::string filter{};
+    std::vector<Fixed> values{};
+  };
+
+  using SetPictureFilterResponse = Response<void>;
+
+  Future<void> SetPictureFilter(const SetPictureFilterRequest& request);
+
+  Future<void> SetPictureFilter(const Picture& picture = {},
+                                const std::string& filter = {},
+                                const std::vector<Fixed>& values = {});
+
+  struct CreateAnimCursorRequest {
+    Cursor cid{};
+    std::vector<AnimationCursorElement> cursors{};
+  };
+
+  using CreateAnimCursorResponse = Response<void>;
+
+  Future<void> CreateAnimCursor(const CreateAnimCursorRequest& request);
+
+  Future<void> CreateAnimCursor(
+      const Cursor& cid = {},
+      const std::vector<AnimationCursorElement>& cursors = {});
+
+  struct AddTrapsRequest {
+    Picture picture{};
+    int16_t x_off{};
+    int16_t y_off{};
+    std::vector<Trap> traps{};
+  };
+
+  using AddTrapsResponse = Response<void>;
+
+  Future<void> AddTraps(const AddTrapsRequest& request);
+
+  Future<void> AddTraps(const Picture& picture = {},
+                        const int16_t& x_off = {},
+                        const int16_t& y_off = {},
+                        const std::vector<Trap>& traps = {});
+
+  struct CreateSolidFillRequest {
+    Picture picture{};
+    Color color{};
+  };
+
+  using CreateSolidFillResponse = Response<void>;
+
+  Future<void> CreateSolidFill(const CreateSolidFillRequest& request);
+
+  Future<void> CreateSolidFill(const Picture& picture = {},
+                               const Color& color = {{}, {}, {}, {}});
+
+  struct CreateLinearGradientRequest {
+    Picture picture{};
+    PointFix p1{};
+    PointFix p2{};
+    std::vector<Fixed> stops{};
+    std::vector<Color> colors{};
+  };
+
+  using CreateLinearGradientResponse = Response<void>;
+
+  Future<void> CreateLinearGradient(const CreateLinearGradientRequest& request);
+
+  Future<void> CreateLinearGradient(const Picture& picture = {},
+                                    const PointFix& p1 = {{}, {}},
+                                    const PointFix& p2 = {{}, {}},
+                                    const std::vector<Fixed>& stops = {},
+                                    const std::vector<Color>& colors = {});
+
+  struct CreateRadialGradientRequest {
+    Picture picture{};
+    PointFix inner{};
+    PointFix outer{};
+    Fixed inner_radius{};
+    Fixed outer_radius{};
+    std::vector<Fixed> stops{};
+    std::vector<Color> colors{};
+  };
+
+  using CreateRadialGradientResponse = Response<void>;
+
+  Future<void> CreateRadialGradient(const CreateRadialGradientRequest& request);
+
+  Future<void> CreateRadialGradient(const Picture& picture = {},
+                                    const PointFix& inner = {{}, {}},
+                                    const PointFix& outer = {{}, {}},
+                                    const Fixed& inner_radius = {},
+                                    const Fixed& outer_radius = {},
+                                    const std::vector<Fixed>& stops = {},
+                                    const std::vector<Color>& colors = {});
+
+  struct CreateConicalGradientRequest {
+    Picture picture{};
+    PointFix center{};
+    Fixed angle{};
+    std::vector<Fixed> stops{};
+    std::vector<Color> colors{};
+  };
+
+  using CreateConicalGradientResponse = Response<void>;
+
+  Future<void> CreateConicalGradient(
+      const CreateConicalGradientRequest& request);
+
+  Future<void> CreateConicalGradient(const Picture& picture = {},
+                                     const PointFix& center = {{}, {}},
+                                     const Fixed& angle = {},
+                                     const std::vector<Fixed>& stops = {},
+                                     const std::vector<Color>& colors = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Render::PictType operator|(x11::Render::PictType l,
+                                                 x11::Render::PictType r) {
+  using T = std::underlying_type_t<x11::Render::PictType>;
+  return static_cast<x11::Render::PictType>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Render::PictType operator&(x11::Render::PictType l,
+                                                 x11::Render::PictType r) {
+  using T = std::underlying_type_t<x11::Render::PictType>;
+  return static_cast<x11::Render::PictType>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Render::Picture operator|(x11::Render::Picture l,
+                                                x11::Render::Picture r) {
+  using T = std::underlying_type_t<x11::Render::Picture>;
+  return static_cast<x11::Render::Picture>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Render::Picture operator&(x11::Render::Picture l,
+                                                x11::Render::Picture r) {
+  using T = std::underlying_type_t<x11::Render::Picture>;
+  return static_cast<x11::Render::Picture>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Render::PictOp operator|(x11::Render::PictOp l,
+                                               x11::Render::PictOp r) {
+  using T = std::underlying_type_t<x11::Render::PictOp>;
+  return static_cast<x11::Render::PictOp>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Render::PictOp operator&(x11::Render::PictOp l,
+                                               x11::Render::PictOp r) {
+  using T = std::underlying_type_t<x11::Render::PictOp>;
+  return static_cast<x11::Render::PictOp>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Render::PolyEdge operator|(x11::Render::PolyEdge l,
+                                                 x11::Render::PolyEdge r) {
+  using T = std::underlying_type_t<x11::Render::PolyEdge>;
+  return static_cast<x11::Render::PolyEdge>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Render::PolyEdge operator&(x11::Render::PolyEdge l,
+                                                 x11::Render::PolyEdge r) {
+  using T = std::underlying_type_t<x11::Render::PolyEdge>;
+  return static_cast<x11::Render::PolyEdge>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Render::PolyMode operator|(x11::Render::PolyMode l,
+                                                 x11::Render::PolyMode r) {
+  using T = std::underlying_type_t<x11::Render::PolyMode>;
+  return static_cast<x11::Render::PolyMode>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Render::PolyMode operator&(x11::Render::PolyMode l,
+                                                 x11::Render::PolyMode r) {
+  using T = std::underlying_type_t<x11::Render::PolyMode>;
+  return static_cast<x11::Render::PolyMode>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Render::CreatePictureAttribute operator|(
+    x11::Render::CreatePictureAttribute l,
+    x11::Render::CreatePictureAttribute r) {
+  using T = std::underlying_type_t<x11::Render::CreatePictureAttribute>;
+  return static_cast<x11::Render::CreatePictureAttribute>(static_cast<T>(l) |
+                                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Render::CreatePictureAttribute operator&(
+    x11::Render::CreatePictureAttribute l,
+    x11::Render::CreatePictureAttribute r) {
+  using T = std::underlying_type_t<x11::Render::CreatePictureAttribute>;
+  return static_cast<x11::Render::CreatePictureAttribute>(static_cast<T>(l) &
+                                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Render::SubPixel operator|(x11::Render::SubPixel l,
+                                                 x11::Render::SubPixel r) {
+  using T = std::underlying_type_t<x11::Render::SubPixel>;
+  return static_cast<x11::Render::SubPixel>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Render::SubPixel operator&(x11::Render::SubPixel l,
+                                                 x11::Render::SubPixel r) {
+  using T = std::underlying_type_t<x11::Render::SubPixel>;
+  return static_cast<x11::Render::SubPixel>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Render::Repeat operator|(x11::Render::Repeat l,
+                                               x11::Render::Repeat r) {
+  using T = std::underlying_type_t<x11::Render::Repeat>;
+  return static_cast<x11::Render::Repeat>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Render::Repeat operator&(x11::Render::Repeat l,
+                                               x11::Render::Repeat r) {
+  using T = std::underlying_type_t<x11::Render::Repeat>;
+  return static_cast<x11::Render::Repeat>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_RENDER_H_
diff --git a/ui/gfx/x/generated_protos/res.cc b/ui/gfx/x/generated_protos/res.cc
new file mode 100644
index 0000000..a17dcff
--- /dev/null
+++ b/ui/gfx/x/generated_protos/res.cc
@@ -0,0 +1,680 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "res.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Res::Res(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<Res::QueryVersionReply> Res::QueryVersion(
+    const Res::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major = request.client_major;
+  auto& client_minor = request.client_minor;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major
+  buf.Write(&client_major);
+
+  // client_minor
+  buf.Write(&client_minor);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Res::QueryVersionReply>(
+      &buf, "Res::QueryVersion", false);
+}
+
+Future<Res::QueryVersionReply> Res::QueryVersion(const uint8_t& client_major,
+                                                 const uint8_t& client_minor) {
+  return Res::QueryVersion(
+      Res::QueryVersionRequest{client_major, client_minor});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Res::QueryVersionReply> detail::ReadReply<
+    Res::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Res::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& server_major = (*reply).server_major;
+  auto& server_minor = (*reply).server_minor;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // server_major
+  Read(&server_major, &buf);
+
+  // server_minor
+  Read(&server_minor, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Res::QueryClientsReply> Res::QueryClients(
+    const Res::QueryClientsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Res::QueryClientsReply>(
+      &buf, "Res::QueryClients", false);
+}
+
+Future<Res::QueryClientsReply> Res::QueryClients() {
+  return Res::QueryClients(Res::QueryClientsRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Res::QueryClientsReply> detail::ReadReply<
+    Res::QueryClientsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Res::QueryClientsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_clients{};
+  auto& clients = (*reply).clients;
+  size_t clients_len = clients.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_clients
+  Read(&num_clients, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // clients
+  clients.resize(num_clients);
+  for (auto& clients_elem : clients) {
+    // clients_elem
+    {
+      auto& resource_base = clients_elem.resource_base;
+      auto& resource_mask = clients_elem.resource_mask;
+
+      // resource_base
+      Read(&resource_base, &buf);
+
+      // resource_mask
+      Read(&resource_mask, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Res::QueryClientResourcesReply> Res::QueryClientResources(
+    const Res::QueryClientResourcesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& xid = request.xid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // xid
+  buf.Write(&xid);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Res::QueryClientResourcesReply>(
+      &buf, "Res::QueryClientResources", false);
+}
+
+Future<Res::QueryClientResourcesReply> Res::QueryClientResources(
+    const uint32_t& xid) {
+  return Res::QueryClientResources(Res::QueryClientResourcesRequest{xid});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Res::QueryClientResourcesReply> detail::ReadReply<
+    Res::QueryClientResourcesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Res::QueryClientResourcesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_types{};
+  auto& types = (*reply).types;
+  size_t types_len = types.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_types
+  Read(&num_types, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // types
+  types.resize(num_types);
+  for (auto& types_elem : types) {
+    // types_elem
+    {
+      auto& resource_type = types_elem.resource_type;
+      auto& count = types_elem.count;
+
+      // resource_type
+      Read(&resource_type, &buf);
+
+      // count
+      Read(&count, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Res::QueryClientPixmapBytesReply> Res::QueryClientPixmapBytes(
+    const Res::QueryClientPixmapBytesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& xid = request.xid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // xid
+  buf.Write(&xid);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Res::QueryClientPixmapBytesReply>(
+      &buf, "Res::QueryClientPixmapBytes", false);
+}
+
+Future<Res::QueryClientPixmapBytesReply> Res::QueryClientPixmapBytes(
+    const uint32_t& xid) {
+  return Res::QueryClientPixmapBytes(Res::QueryClientPixmapBytesRequest{xid});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Res::QueryClientPixmapBytesReply> detail::ReadReply<
+    Res::QueryClientPixmapBytesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Res::QueryClientPixmapBytesReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& bytes = (*reply).bytes;
+  auto& bytes_overflow = (*reply).bytes_overflow;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // bytes
+  Read(&bytes, &buf);
+
+  // bytes_overflow
+  Read(&bytes_overflow, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Res::QueryClientIdsReply> Res::QueryClientIds(
+    const Res::QueryClientIdsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t num_specs{};
+  auto& specs = request.specs;
+  size_t specs_len = specs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // num_specs
+  num_specs = specs.size();
+  buf.Write(&num_specs);
+
+  // specs
+  DCHECK_EQ(static_cast<size_t>(num_specs), specs.size());
+  for (auto& specs_elem : specs) {
+    // specs_elem
+    {
+      auto& client = specs_elem.client;
+      auto& mask = specs_elem.mask;
+
+      // client
+      buf.Write(&client);
+
+      // mask
+      uint32_t tmp0;
+      tmp0 = static_cast<uint32_t>(mask);
+      buf.Write(&tmp0);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Res::QueryClientIdsReply>(
+      &buf, "Res::QueryClientIds", false);
+}
+
+Future<Res::QueryClientIdsReply> Res::QueryClientIds(
+    const std::vector<ClientIdSpec>& specs) {
+  return Res::QueryClientIds(Res::QueryClientIdsRequest{specs});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Res::QueryClientIdsReply> detail::ReadReply<
+    Res::QueryClientIdsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Res::QueryClientIdsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_ids{};
+  auto& ids = (*reply).ids;
+  size_t ids_len = ids.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_ids
+  Read(&num_ids, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // ids
+  ids.resize(num_ids);
+  for (auto& ids_elem : ids) {
+    // ids_elem
+    {
+      auto& spec = ids_elem.spec;
+      auto& length = ids_elem.length;
+      auto& value = ids_elem.value;
+      size_t value_len = value.size();
+
+      // spec
+      {
+        auto& client = spec.client;
+        auto& mask = spec.mask;
+
+        // client
+        Read(&client, &buf);
+
+        // mask
+        uint32_t tmp1;
+        Read(&tmp1, &buf);
+        mask = static_cast<Res::ClientIdMask>(tmp1);
+      }
+
+      // length
+      Read(&length, &buf);
+
+      // value
+      value.resize((length) / (4));
+      for (auto& value_elem : value) {
+        // value_elem
+        Read(&value_elem, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Res::QueryResourceBytesReply> Res::QueryResourceBytes(
+    const Res::QueryResourceBytesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client = request.client;
+  uint32_t num_specs{};
+  auto& specs = request.specs;
+  size_t specs_len = specs.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client
+  buf.Write(&client);
+
+  // num_specs
+  num_specs = specs.size();
+  buf.Write(&num_specs);
+
+  // specs
+  DCHECK_EQ(static_cast<size_t>(num_specs), specs.size());
+  for (auto& specs_elem : specs) {
+    // specs_elem
+    {
+      auto& resource = specs_elem.resource;
+      auto& type = specs_elem.type;
+
+      // resource
+      buf.Write(&resource);
+
+      // type
+      buf.Write(&type);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Res::QueryResourceBytesReply>(
+      &buf, "Res::QueryResourceBytes", false);
+}
+
+Future<Res::QueryResourceBytesReply> Res::QueryResourceBytes(
+    const uint32_t& client,
+    const std::vector<ResourceIdSpec>& specs) {
+  return Res::QueryResourceBytes(Res::QueryResourceBytesRequest{client, specs});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Res::QueryResourceBytesReply> detail::ReadReply<
+    Res::QueryResourceBytesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Res::QueryResourceBytesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_sizes{};
+  auto& sizes = (*reply).sizes;
+  size_t sizes_len = sizes.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_sizes
+  Read(&num_sizes, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // sizes
+  sizes.resize(num_sizes);
+  for (auto& sizes_elem : sizes) {
+    // sizes_elem
+    {
+      auto& size = sizes_elem.size;
+      uint32_t num_cross_references{};
+      auto& cross_references = sizes_elem.cross_references;
+      size_t cross_references_len = cross_references.size();
+
+      // size
+      {
+        auto& spec = size.spec;
+        auto& bytes = size.bytes;
+        auto& ref_count = size.ref_count;
+        auto& use_count = size.use_count;
+
+        // spec
+        {
+          auto& resource = spec.resource;
+          auto& type = spec.type;
+
+          // resource
+          Read(&resource, &buf);
+
+          // type
+          Read(&type, &buf);
+        }
+
+        // bytes
+        Read(&bytes, &buf);
+
+        // ref_count
+        Read(&ref_count, &buf);
+
+        // use_count
+        Read(&use_count, &buf);
+      }
+
+      // num_cross_references
+      Read(&num_cross_references, &buf);
+
+      // cross_references
+      cross_references.resize(num_cross_references);
+      for (auto& cross_references_elem : cross_references) {
+        // cross_references_elem
+        {
+          auto& spec = cross_references_elem.spec;
+          auto& bytes = cross_references_elem.bytes;
+          auto& ref_count = cross_references_elem.ref_count;
+          auto& use_count = cross_references_elem.use_count;
+
+          // spec
+          {
+            auto& resource = spec.resource;
+            auto& type = spec.type;
+
+            // resource
+            Read(&resource, &buf);
+
+            // type
+            Read(&type, &buf);
+          }
+
+          // bytes
+          Read(&bytes, &buf);
+
+          // ref_count
+          Read(&ref_count, &buf);
+
+          // use_count
+          Read(&use_count, &buf);
+        }
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/res.h b/ui/gfx/x/generated_protos/res.h
new file mode 100644
index 0000000..11bd310
--- /dev/null
+++ b/ui/gfx/x/generated_protos/res.h
@@ -0,0 +1,249 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_RES_H_
+#define UI_GFX_X_GENERATED_PROTOS_RES_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Res {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 2;
+
+  Res(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class ClientIdMask : int {
+    ClientXID = 1 << 0,
+    LocalClientPID = 1 << 1,
+  };
+
+  struct Client {
+    uint32_t resource_base{};
+    uint32_t resource_mask{};
+  };
+
+  struct Type {
+    Atom resource_type{};
+    uint32_t count{};
+  };
+
+  struct ClientIdSpec {
+    uint32_t client{};
+    ClientIdMask mask{};
+  };
+
+  struct ClientIdValue {
+    ClientIdSpec spec{};
+    uint32_t length{};
+    std::vector<uint32_t> value{};
+  };
+
+  struct ResourceIdSpec {
+    uint32_t resource{};
+    uint32_t type{};
+  };
+
+  struct ResourceSizeSpec {
+    ResourceIdSpec spec{};
+    uint32_t bytes{};
+    uint32_t ref_count{};
+    uint32_t use_count{};
+  };
+
+  struct ResourceSizeValue {
+    ResourceSizeSpec size{};
+    std::vector<ResourceSizeSpec> cross_references{};
+  };
+
+  struct QueryVersionRequest {
+    uint8_t client_major{};
+    uint8_t client_minor{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t server_major{};
+    uint16_t server_minor{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint8_t& client_major = {},
+                                         const uint8_t& client_minor = {});
+
+  struct QueryClientsRequest {};
+
+  struct QueryClientsReply {
+    uint16_t sequence{};
+    std::vector<Client> clients{};
+  };
+
+  using QueryClientsResponse = Response<QueryClientsReply>;
+
+  Future<QueryClientsReply> QueryClients(const QueryClientsRequest& request);
+
+  Future<QueryClientsReply> QueryClients();
+
+  struct QueryClientResourcesRequest {
+    uint32_t xid{};
+  };
+
+  struct QueryClientResourcesReply {
+    uint16_t sequence{};
+    std::vector<Type> types{};
+  };
+
+  using QueryClientResourcesResponse = Response<QueryClientResourcesReply>;
+
+  Future<QueryClientResourcesReply> QueryClientResources(
+      const QueryClientResourcesRequest& request);
+
+  Future<QueryClientResourcesReply> QueryClientResources(
+      const uint32_t& xid = {});
+
+  struct QueryClientPixmapBytesRequest {
+    uint32_t xid{};
+  };
+
+  struct QueryClientPixmapBytesReply {
+    uint16_t sequence{};
+    uint32_t bytes{};
+    uint32_t bytes_overflow{};
+  };
+
+  using QueryClientPixmapBytesResponse = Response<QueryClientPixmapBytesReply>;
+
+  Future<QueryClientPixmapBytesReply> QueryClientPixmapBytes(
+      const QueryClientPixmapBytesRequest& request);
+
+  Future<QueryClientPixmapBytesReply> QueryClientPixmapBytes(
+      const uint32_t& xid = {});
+
+  struct QueryClientIdsRequest {
+    std::vector<ClientIdSpec> specs{};
+  };
+
+  struct QueryClientIdsReply {
+    uint16_t sequence{};
+    std::vector<ClientIdValue> ids{};
+  };
+
+  using QueryClientIdsResponse = Response<QueryClientIdsReply>;
+
+  Future<QueryClientIdsReply> QueryClientIds(
+      const QueryClientIdsRequest& request);
+
+  Future<QueryClientIdsReply> QueryClientIds(
+      const std::vector<ClientIdSpec>& specs = {});
+
+  struct QueryResourceBytesRequest {
+    uint32_t client{};
+    std::vector<ResourceIdSpec> specs{};
+  };
+
+  struct QueryResourceBytesReply {
+    uint16_t sequence{};
+    std::vector<ResourceSizeValue> sizes{};
+  };
+
+  using QueryResourceBytesResponse = Response<QueryResourceBytesReply>;
+
+  Future<QueryResourceBytesReply> QueryResourceBytes(
+      const QueryResourceBytesRequest& request);
+
+  Future<QueryResourceBytesReply> QueryResourceBytes(
+      const uint32_t& client = {},
+      const std::vector<ResourceIdSpec>& specs = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Res::ClientIdMask operator|(x11::Res::ClientIdMask l,
+                                                  x11::Res::ClientIdMask r) {
+  using T = std::underlying_type_t<x11::Res::ClientIdMask>;
+  return static_cast<x11::Res::ClientIdMask>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Res::ClientIdMask operator&(x11::Res::ClientIdMask l,
+                                                  x11::Res::ClientIdMask r) {
+  using T = std::underlying_type_t<x11::Res::ClientIdMask>;
+  return static_cast<x11::Res::ClientIdMask>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_RES_H_
diff --git a/ui/gfx/x/generated_protos/screensaver.cc b/ui/gfx/x/generated_protos/screensaver.cc
new file mode 100644
index 0000000..b28f663
--- /dev/null
+++ b/ui/gfx/x/generated_protos/screensaver.cc
@@ -0,0 +1,644 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "screensaver.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+ScreenSaver::ScreenSaver(Connection* connection,
+                         const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ScreenSaver::NotifyEvent>(ScreenSaver::NotifyEvent* event_,
+                                         ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& state = (*event_).state;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& root = (*event_).root;
+  auto& window = (*event_).window;
+  auto& kind = (*event_).kind;
+  auto& forced = (*event_).forced;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // state
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  state = static_cast<ScreenSaver::State>(tmp0);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // kind
+  uint8_t tmp1;
+  Read(&tmp1, &buf);
+  kind = static_cast<ScreenSaver::Kind>(tmp1);
+
+  // forced
+  Read(&forced, &buf);
+
+  // pad0
+  Pad(&buf, 14);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<ScreenSaver::QueryVersionReply> ScreenSaver::QueryVersion(
+    const ScreenSaver::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<ScreenSaver::QueryVersionReply>(
+      &buf, "ScreenSaver::QueryVersion", false);
+}
+
+Future<ScreenSaver::QueryVersionReply> ScreenSaver::QueryVersion(
+    const uint8_t& client_major_version,
+    const uint8_t& client_minor_version) {
+  return ScreenSaver::QueryVersion(ScreenSaver::QueryVersionRequest{
+      client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<ScreenSaver::QueryVersionReply> detail::ReadReply<
+    ScreenSaver::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<ScreenSaver::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& server_major_version = (*reply).server_major_version;
+  auto& server_minor_version = (*reply).server_minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // server_major_version
+  Read(&server_major_version, &buf);
+
+  // server_minor_version
+  Read(&server_minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<ScreenSaver::QueryInfoReply> ScreenSaver::QueryInfo(
+    const ScreenSaver::QueryInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<ScreenSaver::QueryInfoReply>(
+      &buf, "ScreenSaver::QueryInfo", false);
+}
+
+Future<ScreenSaver::QueryInfoReply> ScreenSaver::QueryInfo(
+    const Drawable& drawable) {
+  return ScreenSaver::QueryInfo(ScreenSaver::QueryInfoRequest{drawable});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<ScreenSaver::QueryInfoReply> detail::ReadReply<
+    ScreenSaver::QueryInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<ScreenSaver::QueryInfoReply>();
+
+  auto& state = (*reply).state;
+  auto& sequence = (*reply).sequence;
+  auto& saver_window = (*reply).saver_window;
+  auto& ms_until_server = (*reply).ms_until_server;
+  auto& ms_since_user_input = (*reply).ms_since_user_input;
+  auto& event_mask = (*reply).event_mask;
+  auto& kind = (*reply).kind;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // state
+  Read(&state, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // saver_window
+  Read(&saver_window, &buf);
+
+  // ms_until_server
+  Read(&ms_until_server, &buf);
+
+  // ms_since_user_input
+  Read(&ms_since_user_input, &buf);
+
+  // event_mask
+  Read(&event_mask, &buf);
+
+  // kind
+  uint8_t tmp2;
+  Read(&tmp2, &buf);
+  kind = static_cast<ScreenSaver::Kind>(tmp2);
+
+  // pad0
+  Pad(&buf, 7);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> ScreenSaver::SelectInput(
+    const ScreenSaver::SelectInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& event_mask = request.event_mask;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // event_mask
+  uint32_t tmp3;
+  tmp3 = static_cast<uint32_t>(event_mask);
+  buf.Write(&tmp3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ScreenSaver::SelectInput",
+                                        false);
+}
+
+Future<void> ScreenSaver::SelectInput(const Drawable& drawable,
+                                      const Event& event_mask) {
+  return ScreenSaver::SelectInput(
+      ScreenSaver::SelectInputRequest{drawable, event_mask});
+}
+
+Future<void> ScreenSaver::SetAttributes(
+    const ScreenSaver::SetAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& border_width = request.border_width;
+  auto& c_class = request.c_class;
+  auto& depth = request.depth;
+  auto& visual = request.visual;
+  CreateWindowAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // border_width
+  buf.Write(&border_width);
+
+  // c_class
+  uint8_t tmp4;
+  tmp4 = static_cast<uint8_t>(c_class);
+  buf.Write(&tmp4);
+
+  // depth
+  buf.Write(&depth);
+
+  // visual
+  buf.Write(&visual);
+
+  // value_mask
+  SwitchVar(CreateWindowAttribute::BackPixmap,
+            value_list.background_pixmap.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackPixel,
+            value_list.background_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BorderPixmap,
+            value_list.border_pixmap.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BorderPixel,
+            value_list.border_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BitGravity,
+            value_list.bit_gravity.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::WinGravity,
+            value_list.win_gravity.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingStore,
+            value_list.backing_store.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingPlanes,
+            value_list.backing_planes.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingPixel,
+            value_list.backing_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::OverrideRedirect,
+            value_list.override_redirect.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::SaveUnder, value_list.save_under.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::EventMask, value_list.event_mask.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::DontPropagate,
+            value_list.do_not_propogate_mask.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::Colormap, value_list.colormap.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::Cursor, value_list.cursor.has_value(), true,
+            &value_mask);
+  uint32_t tmp5;
+  tmp5 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp5);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackPixmap)) {
+    auto& background_pixmap = *value_list.background_pixmap;
+
+    // background_pixmap
+    buf.Write(&background_pixmap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackPixel)) {
+    auto& background_pixel = *value_list.background_pixel;
+
+    // background_pixel
+    buf.Write(&background_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BorderPixmap)) {
+    auto& border_pixmap = *value_list.border_pixmap;
+
+    // border_pixmap
+    buf.Write(&border_pixmap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BorderPixel)) {
+    auto& border_pixel = *value_list.border_pixel;
+
+    // border_pixel
+    buf.Write(&border_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BitGravity)) {
+    auto& bit_gravity = *value_list.bit_gravity;
+
+    // bit_gravity
+    uint32_t tmp6;
+    tmp6 = static_cast<uint32_t>(bit_gravity);
+    buf.Write(&tmp6);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::WinGravity)) {
+    auto& win_gravity = *value_list.win_gravity;
+
+    // win_gravity
+    uint32_t tmp7;
+    tmp7 = static_cast<uint32_t>(win_gravity);
+    buf.Write(&tmp7);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingStore)) {
+    auto& backing_store = *value_list.backing_store;
+
+    // backing_store
+    uint32_t tmp8;
+    tmp8 = static_cast<uint32_t>(backing_store);
+    buf.Write(&tmp8);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingPlanes)) {
+    auto& backing_planes = *value_list.backing_planes;
+
+    // backing_planes
+    buf.Write(&backing_planes);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingPixel)) {
+    auto& backing_pixel = *value_list.backing_pixel;
+
+    // backing_pixel
+    buf.Write(&backing_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::OverrideRedirect)) {
+    auto& override_redirect = *value_list.override_redirect;
+
+    // override_redirect
+    buf.Write(&override_redirect);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::SaveUnder)) {
+    auto& save_under = *value_list.save_under;
+
+    // save_under
+    buf.Write(&save_under);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::EventMask)) {
+    auto& event_mask = *value_list.event_mask;
+
+    // event_mask
+    uint32_t tmp9;
+    tmp9 = static_cast<uint32_t>(event_mask);
+    buf.Write(&tmp9);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::DontPropagate)) {
+    auto& do_not_propogate_mask = *value_list.do_not_propogate_mask;
+
+    // do_not_propogate_mask
+    uint32_t tmp10;
+    tmp10 = static_cast<uint32_t>(do_not_propogate_mask);
+    buf.Write(&tmp10);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::Colormap)) {
+    auto& colormap = *value_list.colormap;
+
+    // colormap
+    buf.Write(&colormap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::Cursor)) {
+    auto& cursor = *value_list.cursor;
+
+    // cursor
+    buf.Write(&cursor);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ScreenSaver::SetAttributes",
+                                        false);
+}
+
+Future<void> ScreenSaver::SetAttributes(
+    const Drawable& drawable,
+    const int16_t& x,
+    const int16_t& y,
+    const uint16_t& width,
+    const uint16_t& height,
+    const uint16_t& border_width,
+    const WindowClass& c_class,
+    const uint8_t& depth,
+    const VisualId& visual,
+    const absl::optional<Pixmap>& background_pixmap,
+    const absl::optional<uint32_t>& background_pixel,
+    const absl::optional<Pixmap>& border_pixmap,
+    const absl::optional<uint32_t>& border_pixel,
+    const absl::optional<Gravity>& bit_gravity,
+    const absl::optional<Gravity>& win_gravity,
+    const absl::optional<BackingStore>& backing_store,
+    const absl::optional<uint32_t>& backing_planes,
+    const absl::optional<uint32_t>& backing_pixel,
+    const absl::optional<Bool32>& override_redirect,
+    const absl::optional<Bool32>& save_under,
+    const absl::optional<EventMask>& event_mask,
+    const absl::optional<EventMask>& do_not_propogate_mask,
+    const absl::optional<ColorMap>& colormap,
+    const absl::optional<Cursor>& cursor) {
+  return ScreenSaver::SetAttributes(
+      ScreenSaver::SetAttributesRequest{drawable,
+                                        x,
+                                        y,
+                                        width,
+                                        height,
+                                        border_width,
+                                        c_class,
+                                        depth,
+                                        visual,
+                                        background_pixmap,
+                                        background_pixel,
+                                        border_pixmap,
+                                        border_pixel,
+                                        bit_gravity,
+                                        win_gravity,
+                                        backing_store,
+                                        backing_planes,
+                                        backing_pixel,
+                                        override_redirect,
+                                        save_under,
+                                        event_mask,
+                                        do_not_propogate_mask,
+                                        colormap,
+                                        cursor});
+}
+
+Future<void> ScreenSaver::UnsetAttributes(
+    const ScreenSaver::UnsetAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ScreenSaver::UnsetAttributes",
+                                        false);
+}
+
+Future<void> ScreenSaver::UnsetAttributes(const Drawable& drawable) {
+  return ScreenSaver::UnsetAttributes(
+      ScreenSaver::UnsetAttributesRequest{drawable});
+}
+
+Future<void> ScreenSaver::Suspend(const ScreenSaver::SuspendRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& suspend = request.suspend;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // suspend
+  buf.Write(&suspend);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ScreenSaver::Suspend", false);
+}
+
+Future<void> ScreenSaver::Suspend(const uint32_t& suspend) {
+  return ScreenSaver::Suspend(ScreenSaver::SuspendRequest{suspend});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/screensaver.h b/ui/gfx/x/generated_protos/screensaver.h
new file mode 100644
index 0000000..7f43bcd
--- /dev/null
+++ b/ui/gfx/x/generated_protos/screensaver.h
@@ -0,0 +1,293 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_SCREENSAVER_H_
+#define UI_GFX_X_GENERATED_PROTOS_SCREENSAVER_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) ScreenSaver {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 1;
+
+  ScreenSaver(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Kind : int {
+    Blanked = 0,
+    Internal = 1,
+    External = 2,
+  };
+
+  enum class Event : int {
+    NotifyMask = 1 << 0,
+    CycleMask = 1 << 1,
+  };
+
+  enum class State : int {
+    Off = 0,
+    On = 1,
+    Cycle = 2,
+    Disabled = 3,
+  };
+
+  struct NotifyEvent {
+    static constexpr int type_id = 13;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    State state{};
+    uint16_t sequence{};
+    Time time{};
+    Window root{};
+    Window window{};
+    Kind kind{};
+    uint8_t forced{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct QueryVersionRequest {
+    uint8_t client_major_version{};
+    uint8_t client_minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t server_major_version{};
+    uint16_t server_minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(
+      const uint8_t& client_major_version = {},
+      const uint8_t& client_minor_version = {});
+
+  struct QueryInfoRequest {
+    Drawable drawable{};
+  };
+
+  struct QueryInfoReply {
+    uint8_t state{};
+    uint16_t sequence{};
+    Window saver_window{};
+    uint32_t ms_until_server{};
+    uint32_t ms_since_user_input{};
+    uint32_t event_mask{};
+    Kind kind{};
+  };
+
+  using QueryInfoResponse = Response<QueryInfoReply>;
+
+  Future<QueryInfoReply> QueryInfo(const QueryInfoRequest& request);
+
+  Future<QueryInfoReply> QueryInfo(const Drawable& drawable = {});
+
+  struct SelectInputRequest {
+    Drawable drawable{};
+    Event event_mask{};
+  };
+
+  using SelectInputResponse = Response<void>;
+
+  Future<void> SelectInput(const SelectInputRequest& request);
+
+  Future<void> SelectInput(const Drawable& drawable = {},
+                           const Event& event_mask = {});
+
+  struct SetAttributesRequest {
+    Drawable drawable{};
+    int16_t x{};
+    int16_t y{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t border_width{};
+    WindowClass c_class{};
+    uint8_t depth{};
+    VisualId visual{};
+    absl::optional<Pixmap> background_pixmap{};
+    absl::optional<uint32_t> background_pixel{};
+    absl::optional<Pixmap> border_pixmap{};
+    absl::optional<uint32_t> border_pixel{};
+    absl::optional<Gravity> bit_gravity{};
+    absl::optional<Gravity> win_gravity{};
+    absl::optional<BackingStore> backing_store{};
+    absl::optional<uint32_t> backing_planes{};
+    absl::optional<uint32_t> backing_pixel{};
+    absl::optional<Bool32> override_redirect{};
+    absl::optional<Bool32> save_under{};
+    absl::optional<EventMask> event_mask{};
+    absl::optional<EventMask> do_not_propogate_mask{};
+    absl::optional<ColorMap> colormap{};
+    absl::optional<Cursor> cursor{};
+  };
+
+  using SetAttributesResponse = Response<void>;
+
+  Future<void> SetAttributes(const SetAttributesRequest& request);
+
+  Future<void> SetAttributes(
+      const Drawable& drawable = {},
+      const int16_t& x = {},
+      const int16_t& y = {},
+      const uint16_t& width = {},
+      const uint16_t& height = {},
+      const uint16_t& border_width = {},
+      const WindowClass& c_class = {},
+      const uint8_t& depth = {},
+      const VisualId& visual = {},
+      const absl::optional<Pixmap>& background_pixmap = absl::nullopt,
+      const absl::optional<uint32_t>& background_pixel = absl::nullopt,
+      const absl::optional<Pixmap>& border_pixmap = absl::nullopt,
+      const absl::optional<uint32_t>& border_pixel = absl::nullopt,
+      const absl::optional<Gravity>& bit_gravity = absl::nullopt,
+      const absl::optional<Gravity>& win_gravity = absl::nullopt,
+      const absl::optional<BackingStore>& backing_store = absl::nullopt,
+      const absl::optional<uint32_t>& backing_planes = absl::nullopt,
+      const absl::optional<uint32_t>& backing_pixel = absl::nullopt,
+      const absl::optional<Bool32>& override_redirect = absl::nullopt,
+      const absl::optional<Bool32>& save_under = absl::nullopt,
+      const absl::optional<EventMask>& event_mask = absl::nullopt,
+      const absl::optional<EventMask>& do_not_propogate_mask = absl::nullopt,
+      const absl::optional<ColorMap>& colormap = absl::nullopt,
+      const absl::optional<Cursor>& cursor = absl::nullopt);
+
+  struct UnsetAttributesRequest {
+    Drawable drawable{};
+  };
+
+  using UnsetAttributesResponse = Response<void>;
+
+  Future<void> UnsetAttributes(const UnsetAttributesRequest& request);
+
+  Future<void> UnsetAttributes(const Drawable& drawable = {});
+
+  struct SuspendRequest {
+    uint32_t suspend{};
+  };
+
+  using SuspendResponse = Response<void>;
+
+  Future<void> Suspend(const SuspendRequest& request);
+
+  Future<void> Suspend(const uint32_t& suspend = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::ScreenSaver::Kind operator|(x11::ScreenSaver::Kind l,
+                                                  x11::ScreenSaver::Kind r) {
+  using T = std::underlying_type_t<x11::ScreenSaver::Kind>;
+  return static_cast<x11::ScreenSaver::Kind>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::ScreenSaver::Kind operator&(x11::ScreenSaver::Kind l,
+                                                  x11::ScreenSaver::Kind r) {
+  using T = std::underlying_type_t<x11::ScreenSaver::Kind>;
+  return static_cast<x11::ScreenSaver::Kind>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::ScreenSaver::Event operator|(x11::ScreenSaver::Event l,
+                                                   x11::ScreenSaver::Event r) {
+  using T = std::underlying_type_t<x11::ScreenSaver::Event>;
+  return static_cast<x11::ScreenSaver::Event>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::ScreenSaver::Event operator&(x11::ScreenSaver::Event l,
+                                                   x11::ScreenSaver::Event r) {
+  using T = std::underlying_type_t<x11::ScreenSaver::Event>;
+  return static_cast<x11::ScreenSaver::Event>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::ScreenSaver::State operator|(x11::ScreenSaver::State l,
+                                                   x11::ScreenSaver::State r) {
+  using T = std::underlying_type_t<x11::ScreenSaver::State>;
+  return static_cast<x11::ScreenSaver::State>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::ScreenSaver::State operator&(x11::ScreenSaver::State l,
+                                                   x11::ScreenSaver::State r) {
+  using T = std::underlying_type_t<x11::ScreenSaver::State>;
+  return static_cast<x11::ScreenSaver::State>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_SCREENSAVER_H_
diff --git a/ui/gfx/x/generated_protos/shape.cc b/ui/gfx/x/generated_protos/shape.cc
new file mode 100644
index 0000000..946080a
--- /dev/null
+++ b/ui/gfx/x/generated_protos/shape.cc
@@ -0,0 +1,784 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "shape.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Shape::Shape(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Shape::NotifyEvent>(Shape::NotifyEvent* event_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& shape_kind = (*event_).shape_kind;
+  auto& sequence = (*event_).sequence;
+  auto& affected_window = (*event_).affected_window;
+  auto& extents_x = (*event_).extents_x;
+  auto& extents_y = (*event_).extents_y;
+  auto& extents_width = (*event_).extents_width;
+  auto& extents_height = (*event_).extents_height;
+  auto& server_time = (*event_).server_time;
+  auto& shaped = (*event_).shaped;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // shape_kind
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  shape_kind = static_cast<Shape::Sk>(tmp0);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // affected_window
+  Read(&affected_window, &buf);
+
+  // extents_x
+  Read(&extents_x, &buf);
+
+  // extents_y
+  Read(&extents_y, &buf);
+
+  // extents_width
+  Read(&extents_width, &buf);
+
+  // extents_height
+  Read(&extents_height, &buf);
+
+  // server_time
+  Read(&server_time, &buf);
+
+  // shaped
+  Read(&shaped, &buf);
+
+  // pad0
+  Pad(&buf, 11);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<Shape::QueryVersionReply> Shape::QueryVersion(
+    const Shape::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Shape::QueryVersionReply>(
+      &buf, "Shape::QueryVersion", false);
+}
+
+Future<Shape::QueryVersionReply> Shape::QueryVersion() {
+  return Shape::QueryVersion(Shape::QueryVersionRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Shape::QueryVersionReply> detail::ReadReply<
+    Shape::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Shape::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Shape::Rectangles(const Shape::RectanglesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& operation = request.operation;
+  auto& destination_kind = request.destination_kind;
+  auto& ordering = request.ordering;
+  auto& destination_window = request.destination_window;
+  auto& x_offset = request.x_offset;
+  auto& y_offset = request.y_offset;
+  auto& rectangles = request.rectangles;
+  size_t rectangles_len = rectangles.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // operation
+  uint8_t tmp1;
+  tmp1 = static_cast<uint8_t>(operation);
+  buf.Write(&tmp1);
+
+  // destination_kind
+  uint8_t tmp2;
+  tmp2 = static_cast<uint8_t>(destination_kind);
+  buf.Write(&tmp2);
+
+  // ordering
+  uint8_t tmp3;
+  tmp3 = static_cast<uint8_t>(ordering);
+  buf.Write(&tmp3);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // destination_window
+  buf.Write(&destination_window);
+
+  // x_offset
+  buf.Write(&x_offset);
+
+  // y_offset
+  buf.Write(&y_offset);
+
+  // rectangles
+  DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size());
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shape::Rectangles", false);
+}
+
+Future<void> Shape::Rectangles(const So& operation,
+                               const Sk& destination_kind,
+                               const ClipOrdering& ordering,
+                               const Window& destination_window,
+                               const int16_t& x_offset,
+                               const int16_t& y_offset,
+                               const std::vector<Rectangle>& rectangles) {
+  return Shape::Rectangles(Shape::RectanglesRequest{
+      operation, destination_kind, ordering, destination_window, x_offset,
+      y_offset, rectangles});
+}
+
+Future<void> Shape::Mask(const Shape::MaskRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& operation = request.operation;
+  auto& destination_kind = request.destination_kind;
+  auto& destination_window = request.destination_window;
+  auto& x_offset = request.x_offset;
+  auto& y_offset = request.y_offset;
+  auto& source_bitmap = request.source_bitmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // operation
+  uint8_t tmp4;
+  tmp4 = static_cast<uint8_t>(operation);
+  buf.Write(&tmp4);
+
+  // destination_kind
+  uint8_t tmp5;
+  tmp5 = static_cast<uint8_t>(destination_kind);
+  buf.Write(&tmp5);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // destination_window
+  buf.Write(&destination_window);
+
+  // x_offset
+  buf.Write(&x_offset);
+
+  // y_offset
+  buf.Write(&y_offset);
+
+  // source_bitmap
+  buf.Write(&source_bitmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shape::Mask", false);
+}
+
+Future<void> Shape::Mask(const So& operation,
+                         const Sk& destination_kind,
+                         const Window& destination_window,
+                         const int16_t& x_offset,
+                         const int16_t& y_offset,
+                         const Pixmap& source_bitmap) {
+  return Shape::Mask(Shape::MaskRequest{operation, destination_kind,
+                                        destination_window, x_offset, y_offset,
+                                        source_bitmap});
+}
+
+Future<void> Shape::Combine(const Shape::CombineRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& operation = request.operation;
+  auto& destination_kind = request.destination_kind;
+  auto& source_kind = request.source_kind;
+  auto& destination_window = request.destination_window;
+  auto& x_offset = request.x_offset;
+  auto& y_offset = request.y_offset;
+  auto& source_window = request.source_window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // operation
+  uint8_t tmp6;
+  tmp6 = static_cast<uint8_t>(operation);
+  buf.Write(&tmp6);
+
+  // destination_kind
+  uint8_t tmp7;
+  tmp7 = static_cast<uint8_t>(destination_kind);
+  buf.Write(&tmp7);
+
+  // source_kind
+  uint8_t tmp8;
+  tmp8 = static_cast<uint8_t>(source_kind);
+  buf.Write(&tmp8);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // destination_window
+  buf.Write(&destination_window);
+
+  // x_offset
+  buf.Write(&x_offset);
+
+  // y_offset
+  buf.Write(&y_offset);
+
+  // source_window
+  buf.Write(&source_window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shape::Combine", false);
+}
+
+Future<void> Shape::Combine(const So& operation,
+                            const Sk& destination_kind,
+                            const Sk& source_kind,
+                            const Window& destination_window,
+                            const int16_t& x_offset,
+                            const int16_t& y_offset,
+                            const Window& source_window) {
+  return Shape::Combine(Shape::CombineRequest{
+      operation, destination_kind, source_kind, destination_window, x_offset,
+      y_offset, source_window});
+}
+
+Future<void> Shape::Offset(const Shape::OffsetRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& destination_kind = request.destination_kind;
+  auto& destination_window = request.destination_window;
+  auto& x_offset = request.x_offset;
+  auto& y_offset = request.y_offset;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // destination_kind
+  uint8_t tmp9;
+  tmp9 = static_cast<uint8_t>(destination_kind);
+  buf.Write(&tmp9);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // destination_window
+  buf.Write(&destination_window);
+
+  // x_offset
+  buf.Write(&x_offset);
+
+  // y_offset
+  buf.Write(&y_offset);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shape::Offset", false);
+}
+
+Future<void> Shape::Offset(const Sk& destination_kind,
+                           const Window& destination_window,
+                           const int16_t& x_offset,
+                           const int16_t& y_offset) {
+  return Shape::Offset(Shape::OffsetRequest{
+      destination_kind, destination_window, x_offset, y_offset});
+}
+
+Future<Shape::QueryExtentsReply> Shape::QueryExtents(
+    const Shape::QueryExtentsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& destination_window = request.destination_window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // destination_window
+  buf.Write(&destination_window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Shape::QueryExtentsReply>(
+      &buf, "Shape::QueryExtents", false);
+}
+
+Future<Shape::QueryExtentsReply> Shape::QueryExtents(
+    const Window& destination_window) {
+  return Shape::QueryExtents(Shape::QueryExtentsRequest{destination_window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Shape::QueryExtentsReply> detail::ReadReply<
+    Shape::QueryExtentsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Shape::QueryExtentsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& bounding_shaped = (*reply).bounding_shaped;
+  auto& clip_shaped = (*reply).clip_shaped;
+  auto& bounding_shape_extents_x = (*reply).bounding_shape_extents_x;
+  auto& bounding_shape_extents_y = (*reply).bounding_shape_extents_y;
+  auto& bounding_shape_extents_width = (*reply).bounding_shape_extents_width;
+  auto& bounding_shape_extents_height = (*reply).bounding_shape_extents_height;
+  auto& clip_shape_extents_x = (*reply).clip_shape_extents_x;
+  auto& clip_shape_extents_y = (*reply).clip_shape_extents_y;
+  auto& clip_shape_extents_width = (*reply).clip_shape_extents_width;
+  auto& clip_shape_extents_height = (*reply).clip_shape_extents_height;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // bounding_shaped
+  Read(&bounding_shaped, &buf);
+
+  // clip_shaped
+  Read(&clip_shaped, &buf);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // bounding_shape_extents_x
+  Read(&bounding_shape_extents_x, &buf);
+
+  // bounding_shape_extents_y
+  Read(&bounding_shape_extents_y, &buf);
+
+  // bounding_shape_extents_width
+  Read(&bounding_shape_extents_width, &buf);
+
+  // bounding_shape_extents_height
+  Read(&bounding_shape_extents_height, &buf);
+
+  // clip_shape_extents_x
+  Read(&clip_shape_extents_x, &buf);
+
+  // clip_shape_extents_y
+  Read(&clip_shape_extents_y, &buf);
+
+  // clip_shape_extents_width
+  Read(&clip_shape_extents_width, &buf);
+
+  // clip_shape_extents_height
+  Read(&clip_shape_extents_height, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Shape::SelectInput(const Shape::SelectInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& destination_window = request.destination_window;
+  auto& enable = request.enable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // destination_window
+  buf.Write(&destination_window);
+
+  // enable
+  buf.Write(&enable);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shape::SelectInput", false);
+}
+
+Future<void> Shape::SelectInput(const Window& destination_window,
+                                const uint8_t& enable) {
+  return Shape::SelectInput(
+      Shape::SelectInputRequest{destination_window, enable});
+}
+
+Future<Shape::InputSelectedReply> Shape::InputSelected(
+    const Shape::InputSelectedRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& destination_window = request.destination_window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // destination_window
+  buf.Write(&destination_window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Shape::InputSelectedReply>(
+      &buf, "Shape::InputSelected", false);
+}
+
+Future<Shape::InputSelectedReply> Shape::InputSelected(
+    const Window& destination_window) {
+  return Shape::InputSelected(Shape::InputSelectedRequest{destination_window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Shape::InputSelectedReply> detail::ReadReply<
+    Shape::InputSelectedReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Shape::InputSelectedReply>();
+
+  auto& enabled = (*reply).enabled;
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // enabled
+  Read(&enabled, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Shape::GetRectanglesReply> Shape::GetRectangles(
+    const Shape::GetRectanglesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& source_kind = request.source_kind;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // source_kind
+  uint8_t tmp10;
+  tmp10 = static_cast<uint8_t>(source_kind);
+  buf.Write(&tmp10);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Shape::GetRectanglesReply>(
+      &buf, "Shape::GetRectangles", false);
+}
+
+Future<Shape::GetRectanglesReply> Shape::GetRectangles(const Window& window,
+                                                       const Sk& source_kind) {
+  return Shape::GetRectangles(Shape::GetRectanglesRequest{window, source_kind});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Shape::GetRectanglesReply> detail::ReadReply<
+    Shape::GetRectanglesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Shape::GetRectanglesReply>();
+
+  auto& ordering = (*reply).ordering;
+  auto& sequence = (*reply).sequence;
+  uint32_t rectangles_len{};
+  auto& rectangles = (*reply).rectangles;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // ordering
+  uint8_t tmp11;
+  Read(&tmp11, &buf);
+  ordering = static_cast<ClipOrdering>(tmp11);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // rectangles_len
+  Read(&rectangles_len, &buf);
+
+  // pad0
+  Pad(&buf, 20);
+
+  // rectangles
+  rectangles.resize(rectangles_len);
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      Read(&x, &buf);
+
+      // y
+      Read(&y, &buf);
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/shape.h b/ui/gfx/x/generated_protos/shape.h
new file mode 100644
index 0000000..7262c39
--- /dev/null
+++ b/ui/gfx/x/generated_protos/shape.h
@@ -0,0 +1,311 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_SHAPE_H_
+#define UI_GFX_X_GENERATED_PROTOS_SHAPE_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Shape {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 1;
+
+  Shape(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Operation : uint8_t {};
+
+  enum class Kind : uint8_t {};
+
+  enum class So : int {
+    Set = 0,
+    Union = 1,
+    Intersect = 2,
+    Subtract = 3,
+    Invert = 4,
+  };
+
+  enum class Sk : int {
+    Bounding = 0,
+    Clip = 1,
+    Input = 2,
+  };
+
+  struct NotifyEvent {
+    static constexpr int type_id = 14;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    Sk shape_kind{};
+    uint16_t sequence{};
+    Window affected_window{};
+    int16_t extents_x{};
+    int16_t extents_y{};
+    uint16_t extents_width{};
+    uint16_t extents_height{};
+    Time server_time{};
+    uint8_t shaped{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&affected_window);
+    }
+  };
+
+  struct QueryVersionRequest {};
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion();
+
+  struct RectanglesRequest {
+    So operation{};
+    Sk destination_kind{};
+    ClipOrdering ordering{};
+    Window destination_window{};
+    int16_t x_offset{};
+    int16_t y_offset{};
+    std::vector<Rectangle> rectangles{};
+  };
+
+  using RectanglesResponse = Response<void>;
+
+  Future<void> Rectangles(const RectanglesRequest& request);
+
+  Future<void> Rectangles(const So& operation = {},
+                          const Sk& destination_kind = {},
+                          const ClipOrdering& ordering = {},
+                          const Window& destination_window = {},
+                          const int16_t& x_offset = {},
+                          const int16_t& y_offset = {},
+                          const std::vector<Rectangle>& rectangles = {});
+
+  struct MaskRequest {
+    So operation{};
+    Sk destination_kind{};
+    Window destination_window{};
+    int16_t x_offset{};
+    int16_t y_offset{};
+    Pixmap source_bitmap{};
+  };
+
+  using MaskResponse = Response<void>;
+
+  Future<void> Mask(const MaskRequest& request);
+
+  Future<void> Mask(const So& operation = {},
+                    const Sk& destination_kind = {},
+                    const Window& destination_window = {},
+                    const int16_t& x_offset = {},
+                    const int16_t& y_offset = {},
+                    const Pixmap& source_bitmap = {});
+
+  struct CombineRequest {
+    So operation{};
+    Sk destination_kind{};
+    Sk source_kind{};
+    Window destination_window{};
+    int16_t x_offset{};
+    int16_t y_offset{};
+    Window source_window{};
+  };
+
+  using CombineResponse = Response<void>;
+
+  Future<void> Combine(const CombineRequest& request);
+
+  Future<void> Combine(const So& operation = {},
+                       const Sk& destination_kind = {},
+                       const Sk& source_kind = {},
+                       const Window& destination_window = {},
+                       const int16_t& x_offset = {},
+                       const int16_t& y_offset = {},
+                       const Window& source_window = {});
+
+  struct OffsetRequest {
+    Sk destination_kind{};
+    Window destination_window{};
+    int16_t x_offset{};
+    int16_t y_offset{};
+  };
+
+  using OffsetResponse = Response<void>;
+
+  Future<void> Offset(const OffsetRequest& request);
+
+  Future<void> Offset(const Sk& destination_kind = {},
+                      const Window& destination_window = {},
+                      const int16_t& x_offset = {},
+                      const int16_t& y_offset = {});
+
+  struct QueryExtentsRequest {
+    Window destination_window{};
+  };
+
+  struct QueryExtentsReply {
+    uint16_t sequence{};
+    uint8_t bounding_shaped{};
+    uint8_t clip_shaped{};
+    int16_t bounding_shape_extents_x{};
+    int16_t bounding_shape_extents_y{};
+    uint16_t bounding_shape_extents_width{};
+    uint16_t bounding_shape_extents_height{};
+    int16_t clip_shape_extents_x{};
+    int16_t clip_shape_extents_y{};
+    uint16_t clip_shape_extents_width{};
+    uint16_t clip_shape_extents_height{};
+  };
+
+  using QueryExtentsResponse = Response<QueryExtentsReply>;
+
+  Future<QueryExtentsReply> QueryExtents(const QueryExtentsRequest& request);
+
+  Future<QueryExtentsReply> QueryExtents(const Window& destination_window = {});
+
+  struct SelectInputRequest {
+    Window destination_window{};
+    uint8_t enable{};
+  };
+
+  using SelectInputResponse = Response<void>;
+
+  Future<void> SelectInput(const SelectInputRequest& request);
+
+  Future<void> SelectInput(const Window& destination_window = {},
+                           const uint8_t& enable = {});
+
+  struct InputSelectedRequest {
+    Window destination_window{};
+  };
+
+  struct InputSelectedReply {
+    uint8_t enabled{};
+    uint16_t sequence{};
+  };
+
+  using InputSelectedResponse = Response<InputSelectedReply>;
+
+  Future<InputSelectedReply> InputSelected(const InputSelectedRequest& request);
+
+  Future<InputSelectedReply> InputSelected(
+      const Window& destination_window = {});
+
+  struct GetRectanglesRequest {
+    Window window{};
+    Sk source_kind{};
+  };
+
+  struct GetRectanglesReply {
+    ClipOrdering ordering{};
+    uint16_t sequence{};
+    std::vector<Rectangle> rectangles{};
+  };
+
+  using GetRectanglesResponse = Response<GetRectanglesReply>;
+
+  Future<GetRectanglesReply> GetRectangles(const GetRectanglesRequest& request);
+
+  Future<GetRectanglesReply> GetRectangles(const Window& window = {},
+                                           const Sk& source_kind = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Shape::So operator|(x11::Shape::So l, x11::Shape::So r) {
+  using T = std::underlying_type_t<x11::Shape::So>;
+  return static_cast<x11::Shape::So>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Shape::So operator&(x11::Shape::So l, x11::Shape::So r) {
+  using T = std::underlying_type_t<x11::Shape::So>;
+  return static_cast<x11::Shape::So>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Shape::Sk operator|(x11::Shape::Sk l, x11::Shape::Sk r) {
+  using T = std::underlying_type_t<x11::Shape::Sk>;
+  return static_cast<x11::Shape::Sk>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Shape::Sk operator&(x11::Shape::Sk l, x11::Shape::Sk r) {
+  using T = std::underlying_type_t<x11::Shape::Sk>;
+  return static_cast<x11::Shape::Sk>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_SHAPE_H_
diff --git a/ui/gfx/x/generated_protos/shm.cc b/ui/gfx/x/generated_protos/shm.cc
new file mode 100644
index 0000000..fc795c6
--- /dev/null
+++ b/ui/gfx/x/generated_protos/shm.cc
@@ -0,0 +1,722 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "shm.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Shm::Shm(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Shm::CompletionEvent>(Shm::CompletionEvent* event_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& drawable = (*event_).drawable;
+  auto& minor_event = (*event_).minor_event;
+  auto& major_event = (*event_).major_event;
+  auto& shmseg = (*event_).shmseg;
+  auto& offset = (*event_).offset;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  // minor_event
+  Read(&minor_event, &buf);
+
+  // major_event
+  Read(&major_event, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  // shmseg
+  Read(&shmseg, &buf);
+
+  // offset
+  Read(&offset, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+std::string Shm::BadSegError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Shm::BadSegError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Shm::BadSegError>(Shm::BadSegError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+Future<Shm::QueryVersionReply> Shm::QueryVersion(
+    const Shm::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Shm::QueryVersionReply>(
+      &buf, "Shm::QueryVersion", false);
+}
+
+Future<Shm::QueryVersionReply> Shm::QueryVersion() {
+  return Shm::QueryVersion(Shm::QueryVersionRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Shm::QueryVersionReply> detail::ReadReply<
+    Shm::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Shm::QueryVersionReply>();
+
+  auto& shared_pixmaps = (*reply).shared_pixmaps;
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+  auto& uid = (*reply).uid;
+  auto& gid = (*reply).gid;
+  auto& pixmap_format = (*reply).pixmap_format;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // shared_pixmaps
+  Read(&shared_pixmaps, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // uid
+  Read(&uid, &buf);
+
+  // gid
+  Read(&gid, &buf);
+
+  // pixmap_format
+  Read(&pixmap_format, &buf);
+
+  // pad0
+  Pad(&buf, 15);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Shm::Attach(const Shm::AttachRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& shmseg = request.shmseg;
+  auto& shmid = request.shmid;
+  auto& read_only = request.read_only;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // shmseg
+  buf.Write(&shmseg);
+
+  // shmid
+  buf.Write(&shmid);
+
+  // read_only
+  buf.Write(&read_only);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shm::Attach", false);
+}
+
+Future<void> Shm::Attach(const Seg& shmseg,
+                         const uint32_t& shmid,
+                         const uint8_t& read_only) {
+  return Shm::Attach(Shm::AttachRequest{shmseg, shmid, read_only});
+}
+
+Future<void> Shm::Detach(const Shm::DetachRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& shmseg = request.shmseg;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // shmseg
+  buf.Write(&shmseg);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shm::Detach", false);
+}
+
+Future<void> Shm::Detach(const Seg& shmseg) {
+  return Shm::Detach(Shm::DetachRequest{shmseg});
+}
+
+Future<void> Shm::PutImage(const Shm::PutImageRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& total_width = request.total_width;
+  auto& total_height = request.total_height;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& src_width = request.src_width;
+  auto& src_height = request.src_height;
+  auto& dst_x = request.dst_x;
+  auto& dst_y = request.dst_y;
+  auto& depth = request.depth;
+  auto& format = request.format;
+  auto& send_event = request.send_event;
+  auto& shmseg = request.shmseg;
+  auto& offset = request.offset;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // total_width
+  buf.Write(&total_width);
+
+  // total_height
+  buf.Write(&total_height);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // src_width
+  buf.Write(&src_width);
+
+  // src_height
+  buf.Write(&src_height);
+
+  // dst_x
+  buf.Write(&dst_x);
+
+  // dst_y
+  buf.Write(&dst_y);
+
+  // depth
+  buf.Write(&depth);
+
+  // format
+  uint8_t tmp0;
+  tmp0 = static_cast<uint8_t>(format);
+  buf.Write(&tmp0);
+
+  // send_event
+  buf.Write(&send_event);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // shmseg
+  buf.Write(&shmseg);
+
+  // offset
+  buf.Write(&offset);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shm::PutImage", false);
+}
+
+Future<void> Shm::PutImage(const Drawable& drawable,
+                           const GraphicsContext& gc,
+                           const uint16_t& total_width,
+                           const uint16_t& total_height,
+                           const uint16_t& src_x,
+                           const uint16_t& src_y,
+                           const uint16_t& src_width,
+                           const uint16_t& src_height,
+                           const int16_t& dst_x,
+                           const int16_t& dst_y,
+                           const uint8_t& depth,
+                           const ImageFormat& format,
+                           const uint8_t& send_event,
+                           const Seg& shmseg,
+                           const uint32_t& offset) {
+  return Shm::PutImage(Shm::PutImageRequest{
+      drawable, gc, total_width, total_height, src_x, src_y, src_width,
+      src_height, dst_x, dst_y, depth, format, send_event, shmseg, offset});
+}
+
+Future<Shm::GetImageReply> Shm::GetImage(const Shm::GetImageRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& plane_mask = request.plane_mask;
+  auto& format = request.format;
+  auto& shmseg = request.shmseg;
+  auto& offset = request.offset;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // plane_mask
+  buf.Write(&plane_mask);
+
+  // format
+  buf.Write(&format);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // shmseg
+  buf.Write(&shmseg);
+
+  // offset
+  buf.Write(&offset);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Shm::GetImageReply>(&buf, "Shm::GetImage",
+                                                      false);
+}
+
+Future<Shm::GetImageReply> Shm::GetImage(const Drawable& drawable,
+                                         const int16_t& x,
+                                         const int16_t& y,
+                                         const uint16_t& width,
+                                         const uint16_t& height,
+                                         const uint32_t& plane_mask,
+                                         const uint8_t& format,
+                                         const Seg& shmseg,
+                                         const uint32_t& offset) {
+  return Shm::GetImage(Shm::GetImageRequest{
+      drawable, x, y, width, height, plane_mask, format, shmseg, offset});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Shm::GetImageReply> detail::ReadReply<Shm::GetImageReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Shm::GetImageReply>();
+
+  auto& depth = (*reply).depth;
+  auto& sequence = (*reply).sequence;
+  auto& visual = (*reply).visual;
+  auto& size = (*reply).size;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // depth
+  Read(&depth, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // visual
+  Read(&visual, &buf);
+
+  // size
+  Read(&size, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Shm::CreatePixmap(const Shm::CreatePixmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& pid = request.pid;
+  auto& drawable = request.drawable;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& depth = request.depth;
+  auto& shmseg = request.shmseg;
+  auto& offset = request.offset;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pid
+  buf.Write(&pid);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // depth
+  buf.Write(&depth);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // shmseg
+  buf.Write(&shmseg);
+
+  // offset
+  buf.Write(&offset);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shm::CreatePixmap", false);
+}
+
+Future<void> Shm::CreatePixmap(const Pixmap& pid,
+                               const Drawable& drawable,
+                               const uint16_t& width,
+                               const uint16_t& height,
+                               const uint8_t& depth,
+                               const Seg& shmseg,
+                               const uint32_t& offset) {
+  return Shm::CreatePixmap(Shm::CreatePixmapRequest{
+      pid, drawable, width, height, depth, shmseg, offset});
+}
+
+Future<void> Shm::AttachFd(const Shm::AttachFdRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& shmseg = request.shmseg;
+  auto& shm_fd = request.shm_fd;
+  auto& read_only = request.read_only;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // shmseg
+  buf.Write(&shmseg);
+
+  // shm_fd
+  buf.fds().push_back(HANDLE_EINTR(dup(shm_fd.get())));
+
+  // read_only
+  buf.Write(&read_only);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Shm::AttachFd", false);
+}
+
+Future<void> Shm::AttachFd(const Seg& shmseg,
+                           const RefCountedFD& shm_fd,
+                           const uint8_t& read_only) {
+  return Shm::AttachFd(Shm::AttachFdRequest{shmseg, shm_fd, read_only});
+}
+
+Future<Shm::CreateSegmentReply> Shm::CreateSegment(
+    const Shm::CreateSegmentRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& shmseg = request.shmseg;
+  auto& size = request.size;
+  auto& read_only = request.read_only;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // shmseg
+  buf.Write(&shmseg);
+
+  // size
+  buf.Write(&size);
+
+  // read_only
+  buf.Write(&read_only);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Shm::CreateSegmentReply>(
+      &buf, "Shm::CreateSegment", true);
+}
+
+Future<Shm::CreateSegmentReply> Shm::CreateSegment(const Seg& shmseg,
+                                                   const uint32_t& size,
+                                                   const uint8_t& read_only) {
+  return Shm::CreateSegment(Shm::CreateSegmentRequest{shmseg, size, read_only});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Shm::CreateSegmentReply> detail::ReadReply<
+    Shm::CreateSegmentReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Shm::CreateSegmentReply>();
+
+  auto& nfd = (*reply).nfd;
+  auto& sequence = (*reply).sequence;
+  auto& shm_fd = (*reply).shm_fd;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // nfd
+  Read(&nfd, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // shm_fd
+  shm_fd = RefCountedFD(buf.TakeFd());
+
+  // pad0
+  Pad(&buf, 24);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/shm.h b/ui/gfx/x/generated_protos/shm.h
new file mode 100644
index 0000000..6df3185
--- /dev/null
+++ b/ui/gfx/x/generated_protos/shm.h
@@ -0,0 +1,286 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_SHM_H_
+#define UI_GFX_X_GENERATED_PROTOS_SHM_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Shm {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 2;
+
+  Shm(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Seg : uint32_t {};
+
+  struct CompletionEvent {
+    static constexpr int type_id = 15;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint16_t sequence{};
+    Drawable drawable{};
+    uint16_t minor_event{};
+    uint8_t major_event{};
+    Seg shmseg{};
+    uint32_t offset{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&drawable);
+    }
+  };
+
+  struct BadSegError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_value{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct QueryVersionRequest {};
+
+  struct QueryVersionReply {
+    uint8_t shared_pixmaps{};
+    uint16_t sequence{};
+    uint16_t major_version{};
+    uint16_t minor_version{};
+    uint16_t uid{};
+    uint16_t gid{};
+    uint8_t pixmap_format{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion();
+
+  struct AttachRequest {
+    Seg shmseg{};
+    uint32_t shmid{};
+    uint8_t read_only{};
+  };
+
+  using AttachResponse = Response<void>;
+
+  Future<void> Attach(const AttachRequest& request);
+
+  Future<void> Attach(const Seg& shmseg = {},
+                      const uint32_t& shmid = {},
+                      const uint8_t& read_only = {});
+
+  struct DetachRequest {
+    Seg shmseg{};
+  };
+
+  using DetachResponse = Response<void>;
+
+  Future<void> Detach(const DetachRequest& request);
+
+  Future<void> Detach(const Seg& shmseg = {});
+
+  struct PutImageRequest {
+    Drawable drawable{};
+    GraphicsContext gc{};
+    uint16_t total_width{};
+    uint16_t total_height{};
+    uint16_t src_x{};
+    uint16_t src_y{};
+    uint16_t src_width{};
+    uint16_t src_height{};
+    int16_t dst_x{};
+    int16_t dst_y{};
+    uint8_t depth{};
+    ImageFormat format{};
+    uint8_t send_event{};
+    Seg shmseg{};
+    uint32_t offset{};
+  };
+
+  using PutImageResponse = Response<void>;
+
+  Future<void> PutImage(const PutImageRequest& request);
+
+  Future<void> PutImage(const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const uint16_t& total_width = {},
+                        const uint16_t& total_height = {},
+                        const uint16_t& src_x = {},
+                        const uint16_t& src_y = {},
+                        const uint16_t& src_width = {},
+                        const uint16_t& src_height = {},
+                        const int16_t& dst_x = {},
+                        const int16_t& dst_y = {},
+                        const uint8_t& depth = {},
+                        const ImageFormat& format = {},
+                        const uint8_t& send_event = {},
+                        const Seg& shmseg = {},
+                        const uint32_t& offset = {});
+
+  struct GetImageRequest {
+    Drawable drawable{};
+    int16_t x{};
+    int16_t y{};
+    uint16_t width{};
+    uint16_t height{};
+    uint32_t plane_mask{};
+    uint8_t format{};
+    Seg shmseg{};
+    uint32_t offset{};
+  };
+
+  struct GetImageReply {
+    uint8_t depth{};
+    uint16_t sequence{};
+    VisualId visual{};
+    uint32_t size{};
+  };
+
+  using GetImageResponse = Response<GetImageReply>;
+
+  Future<GetImageReply> GetImage(const GetImageRequest& request);
+
+  Future<GetImageReply> GetImage(const Drawable& drawable = {},
+                                 const int16_t& x = {},
+                                 const int16_t& y = {},
+                                 const uint16_t& width = {},
+                                 const uint16_t& height = {},
+                                 const uint32_t& plane_mask = {},
+                                 const uint8_t& format = {},
+                                 const Seg& shmseg = {},
+                                 const uint32_t& offset = {});
+
+  struct CreatePixmapRequest {
+    Pixmap pid{};
+    Drawable drawable{};
+    uint16_t width{};
+    uint16_t height{};
+    uint8_t depth{};
+    Seg shmseg{};
+    uint32_t offset{};
+  };
+
+  using CreatePixmapResponse = Response<void>;
+
+  Future<void> CreatePixmap(const CreatePixmapRequest& request);
+
+  Future<void> CreatePixmap(const Pixmap& pid = {},
+                            const Drawable& drawable = {},
+                            const uint16_t& width = {},
+                            const uint16_t& height = {},
+                            const uint8_t& depth = {},
+                            const Seg& shmseg = {},
+                            const uint32_t& offset = {});
+
+  struct AttachFdRequest {
+    Seg shmseg{};
+    RefCountedFD shm_fd{};
+    uint8_t read_only{};
+  };
+
+  using AttachFdResponse = Response<void>;
+
+  Future<void> AttachFd(const AttachFdRequest& request);
+
+  Future<void> AttachFd(const Seg& shmseg = {},
+                        const RefCountedFD& shm_fd = {},
+                        const uint8_t& read_only = {});
+
+  struct CreateSegmentRequest {
+    Seg shmseg{};
+    uint32_t size{};
+    uint8_t read_only{};
+  };
+
+  struct CreateSegmentReply {
+    uint8_t nfd{};
+    uint16_t sequence{};
+    RefCountedFD shm_fd{};
+  };
+
+  using CreateSegmentResponse = Response<CreateSegmentReply>;
+
+  Future<CreateSegmentReply> CreateSegment(const CreateSegmentRequest& request);
+
+  Future<CreateSegmentReply> CreateSegment(const Seg& shmseg = {},
+                                           const uint32_t& size = {},
+                                           const uint8_t& read_only = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_SHM_H_
diff --git a/ui/gfx/x/generated_protos/sync.cc b/ui/gfx/x/generated_protos/sync.cc
new file mode 100644
index 0000000..f175c29
--- /dev/null
+++ b/ui/gfx/x/generated_protos/sync.cc
@@ -0,0 +1,1530 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "sync.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Sync::Sync(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string Sync::CounterError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Sync::CounterError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_counter = " << static_cast<uint64_t>(bad_counter) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Sync::CounterError>(Sync::CounterError* error_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_counter = (*error_).bad_counter;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_counter
+  Read(&bad_counter, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Sync::AlarmError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Sync::AlarmError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_alarm = " << static_cast<uint64_t>(bad_alarm) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Sync::AlarmError>(Sync::AlarmError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_alarm = (*error_).bad_alarm;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_alarm
+  Read(&bad_alarm, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Sync::CounterNotifyEvent>(Sync::CounterNotifyEvent* event_,
+                                         ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& kind = (*event_).kind;
+  auto& sequence = (*event_).sequence;
+  auto& counter = (*event_).counter;
+  auto& wait_value = (*event_).wait_value;
+  auto& counter_value = (*event_).counter_value;
+  auto& timestamp = (*event_).timestamp;
+  auto& count = (*event_).count;
+  auto& destroyed = (*event_).destroyed;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // kind
+  Read(&kind, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // counter
+  Read(&counter, &buf);
+
+  // wait_value
+  {
+    auto& hi = wait_value.hi;
+    auto& lo = wait_value.lo;
+
+    // hi
+    Read(&hi, &buf);
+
+    // lo
+    Read(&lo, &buf);
+  }
+
+  // counter_value
+  {
+    auto& hi = counter_value.hi;
+    auto& lo = counter_value.lo;
+
+    // hi
+    Read(&hi, &buf);
+
+    // lo
+    Read(&lo, &buf);
+  }
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  // destroyed
+  Read(&destroyed, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Sync::AlarmNotifyEvent>(Sync::AlarmNotifyEvent* event_,
+                                       ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& kind = (*event_).kind;
+  auto& sequence = (*event_).sequence;
+  auto& alarm = (*event_).alarm;
+  auto& counter_value = (*event_).counter_value;
+  auto& alarm_value = (*event_).alarm_value;
+  auto& timestamp = (*event_).timestamp;
+  auto& state = (*event_).state;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // kind
+  Read(&kind, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // alarm
+  Read(&alarm, &buf);
+
+  // counter_value
+  {
+    auto& hi = counter_value.hi;
+    auto& lo = counter_value.lo;
+
+    // hi
+    Read(&hi, &buf);
+
+    // lo
+    Read(&lo, &buf);
+  }
+
+  // alarm_value
+  {
+    auto& hi = alarm_value.hi;
+    auto& lo = alarm_value.lo;
+
+    // hi
+    Read(&hi, &buf);
+
+    // lo
+    Read(&lo, &buf);
+  }
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // state
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  state = static_cast<Sync::Alarmstate>(tmp0);
+
+  // pad0
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<Sync::InitializeReply> Sync::Initialize(
+    const Sync::InitializeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& desired_major_version = request.desired_major_version;
+  auto& desired_minor_version = request.desired_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // desired_major_version
+  buf.Write(&desired_major_version);
+
+  // desired_minor_version
+  buf.Write(&desired_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Sync::InitializeReply>(
+      &buf, "Sync::Initialize", false);
+}
+
+Future<Sync::InitializeReply> Sync::Initialize(
+    const uint8_t& desired_major_version,
+    const uint8_t& desired_minor_version) {
+  return Sync::Initialize(
+      Sync::InitializeRequest{desired_major_version, desired_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Sync::InitializeReply> detail::ReadReply<Sync::InitializeReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Sync::InitializeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Sync::ListSystemCountersReply> Sync::ListSystemCounters(
+    const Sync::ListSystemCountersRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Sync::ListSystemCountersReply>(
+      &buf, "Sync::ListSystemCounters", false);
+}
+
+Future<Sync::ListSystemCountersReply> Sync::ListSystemCounters() {
+  return Sync::ListSystemCounters(Sync::ListSystemCountersRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Sync::ListSystemCountersReply> detail::ReadReply<
+    Sync::ListSystemCountersReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Sync::ListSystemCountersReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t counters_len{};
+  auto& counters = (*reply).counters;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // counters_len
+  Read(&counters_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // counters
+  counters.resize(counters_len);
+  for (auto& counters_elem : counters) {
+    // counters_elem
+    {
+      auto& counter = counters_elem.counter;
+      auto& resolution = counters_elem.resolution;
+      uint16_t name_len{};
+      auto& name = counters_elem.name;
+
+      // counter
+      Read(&counter, &buf);
+
+      // resolution
+      {
+        auto& hi = resolution.hi;
+        auto& lo = resolution.lo;
+
+        // hi
+        Read(&hi, &buf);
+
+        // lo
+        Read(&lo, &buf);
+      }
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // name
+      name.resize(name_len);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 4);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Sync::CreateCounter(const Sync::CreateCounterRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& id = request.id;
+  auto& initial_value = request.initial_value;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // id
+  buf.Write(&id);
+
+  // initial_value
+  {
+    auto& hi = initial_value.hi;
+    auto& lo = initial_value.lo;
+
+    // hi
+    buf.Write(&hi);
+
+    // lo
+    buf.Write(&lo);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::CreateCounter", false);
+}
+
+Future<void> Sync::CreateCounter(const Counter& id,
+                                 const Int64& initial_value) {
+  return Sync::CreateCounter(Sync::CreateCounterRequest{id, initial_value});
+}
+
+Future<void> Sync::DestroyCounter(const Sync::DestroyCounterRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& counter = request.counter;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // counter
+  buf.Write(&counter);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::DestroyCounter", false);
+}
+
+Future<void> Sync::DestroyCounter(const Counter& counter) {
+  return Sync::DestroyCounter(Sync::DestroyCounterRequest{counter});
+}
+
+Future<Sync::QueryCounterReply> Sync::QueryCounter(
+    const Sync::QueryCounterRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& counter = request.counter;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // counter
+  buf.Write(&counter);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Sync::QueryCounterReply>(
+      &buf, "Sync::QueryCounter", false);
+}
+
+Future<Sync::QueryCounterReply> Sync::QueryCounter(const Counter& counter) {
+  return Sync::QueryCounter(Sync::QueryCounterRequest{counter});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Sync::QueryCounterReply> detail::ReadReply<
+    Sync::QueryCounterReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Sync::QueryCounterReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& counter_value = (*reply).counter_value;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // counter_value
+  {
+    auto& hi = counter_value.hi;
+    auto& lo = counter_value.lo;
+
+    // hi
+    Read(&hi, &buf);
+
+    // lo
+    Read(&lo, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Sync::Await(const Sync::AwaitRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& wait_list = request.wait_list;
+  size_t wait_list_len = wait_list.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // wait_list
+  DCHECK_EQ(static_cast<size_t>(wait_list_len), wait_list.size());
+  for (auto& wait_list_elem : wait_list) {
+    // wait_list_elem
+    {
+      auto& trigger = wait_list_elem.trigger;
+      auto& event_threshold = wait_list_elem.event_threshold;
+
+      // trigger
+      {
+        auto& counter = trigger.counter;
+        auto& wait_type = trigger.wait_type;
+        auto& wait_value = trigger.wait_value;
+        auto& test_type = trigger.test_type;
+
+        // counter
+        buf.Write(&counter);
+
+        // wait_type
+        uint32_t tmp1;
+        tmp1 = static_cast<uint32_t>(wait_type);
+        buf.Write(&tmp1);
+
+        // wait_value
+        {
+          auto& hi = wait_value.hi;
+          auto& lo = wait_value.lo;
+
+          // hi
+          buf.Write(&hi);
+
+          // lo
+          buf.Write(&lo);
+        }
+
+        // test_type
+        uint32_t tmp2;
+        tmp2 = static_cast<uint32_t>(test_type);
+        buf.Write(&tmp2);
+      }
+
+      // event_threshold
+      {
+        auto& hi = event_threshold.hi;
+        auto& lo = event_threshold.lo;
+
+        // hi
+        buf.Write(&hi);
+
+        // lo
+        buf.Write(&lo);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::Await", false);
+}
+
+Future<void> Sync::Await(const std::vector<WaitCondition>& wait_list) {
+  return Sync::Await(Sync::AwaitRequest{wait_list});
+}
+
+Future<void> Sync::ChangeCounter(const Sync::ChangeCounterRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& counter = request.counter;
+  auto& amount = request.amount;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // counter
+  buf.Write(&counter);
+
+  // amount
+  {
+    auto& hi = amount.hi;
+    auto& lo = amount.lo;
+
+    // hi
+    buf.Write(&hi);
+
+    // lo
+    buf.Write(&lo);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::ChangeCounter", false);
+}
+
+Future<void> Sync::ChangeCounter(const Counter& counter, const Int64& amount) {
+  return Sync::ChangeCounter(Sync::ChangeCounterRequest{counter, amount});
+}
+
+Future<void> Sync::SetCounter(const Sync::SetCounterRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& counter = request.counter;
+  auto& value = request.value;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // counter
+  buf.Write(&counter);
+
+  // value
+  {
+    auto& hi = value.hi;
+    auto& lo = value.lo;
+
+    // hi
+    buf.Write(&hi);
+
+    // lo
+    buf.Write(&lo);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::SetCounter", false);
+}
+
+Future<void> Sync::SetCounter(const Counter& counter, const Int64& value) {
+  return Sync::SetCounter(Sync::SetCounterRequest{counter, value});
+}
+
+Future<void> Sync::CreateAlarm(const Sync::CreateAlarmRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& id = request.id;
+  ChangeAlarmAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // id
+  buf.Write(&id);
+
+  // value_mask
+  SwitchVar(ChangeAlarmAttribute::Counter, value_list.counter.has_value(), true,
+            &value_mask);
+  SwitchVar(ChangeAlarmAttribute::ValueType, value_list.valueType.has_value(),
+            true, &value_mask);
+  SwitchVar(ChangeAlarmAttribute::Value, value_list.value.has_value(), true,
+            &value_mask);
+  SwitchVar(ChangeAlarmAttribute::TestType, value_list.testType.has_value(),
+            true, &value_mask);
+  SwitchVar(ChangeAlarmAttribute::Delta, value_list.delta.has_value(), true,
+            &value_mask);
+  SwitchVar(ChangeAlarmAttribute::Events, value_list.events.has_value(), true,
+            &value_mask);
+  uint32_t tmp3;
+  tmp3 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp3);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Counter)) {
+    auto& counter = *value_list.counter;
+
+    // counter
+    buf.Write(&counter);
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::ValueType)) {
+    auto& valueType = *value_list.valueType;
+
+    // valueType
+    uint32_t tmp4;
+    tmp4 = static_cast<uint32_t>(valueType);
+    buf.Write(&tmp4);
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Value)) {
+    auto& value = *value_list.value;
+
+    // value
+    {
+      auto& hi = value.hi;
+      auto& lo = value.lo;
+
+      // hi
+      buf.Write(&hi);
+
+      // lo
+      buf.Write(&lo);
+    }
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::TestType)) {
+    auto& testType = *value_list.testType;
+
+    // testType
+    uint32_t tmp5;
+    tmp5 = static_cast<uint32_t>(testType);
+    buf.Write(&tmp5);
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Delta)) {
+    auto& delta = *value_list.delta;
+
+    // delta
+    {
+      auto& hi = delta.hi;
+      auto& lo = delta.lo;
+
+      // hi
+      buf.Write(&hi);
+
+      // lo
+      buf.Write(&lo);
+    }
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Events)) {
+    auto& events = *value_list.events;
+
+    // events
+    buf.Write(&events);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::CreateAlarm", false);
+}
+
+Future<void> Sync::CreateAlarm(const Alarm& id,
+                               const absl::optional<Counter>& counter,
+                               const absl::optional<Valuetype>& valueType,
+                               const absl::optional<Int64>& value,
+                               const absl::optional<Testtype>& testType,
+                               const absl::optional<Int64>& delta,
+                               const absl::optional<uint32_t>& events) {
+  return Sync::CreateAlarm(Sync::CreateAlarmRequest{
+      id, counter, valueType, value, testType, delta, events});
+}
+
+Future<void> Sync::ChangeAlarm(const Sync::ChangeAlarmRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& id = request.id;
+  ChangeAlarmAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // id
+  buf.Write(&id);
+
+  // value_mask
+  SwitchVar(ChangeAlarmAttribute::Counter, value_list.counter.has_value(), true,
+            &value_mask);
+  SwitchVar(ChangeAlarmAttribute::ValueType, value_list.valueType.has_value(),
+            true, &value_mask);
+  SwitchVar(ChangeAlarmAttribute::Value, value_list.value.has_value(), true,
+            &value_mask);
+  SwitchVar(ChangeAlarmAttribute::TestType, value_list.testType.has_value(),
+            true, &value_mask);
+  SwitchVar(ChangeAlarmAttribute::Delta, value_list.delta.has_value(), true,
+            &value_mask);
+  SwitchVar(ChangeAlarmAttribute::Events, value_list.events.has_value(), true,
+            &value_mask);
+  uint32_t tmp6;
+  tmp6 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp6);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Counter)) {
+    auto& counter = *value_list.counter;
+
+    // counter
+    buf.Write(&counter);
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::ValueType)) {
+    auto& valueType = *value_list.valueType;
+
+    // valueType
+    uint32_t tmp7;
+    tmp7 = static_cast<uint32_t>(valueType);
+    buf.Write(&tmp7);
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Value)) {
+    auto& value = *value_list.value;
+
+    // value
+    {
+      auto& hi = value.hi;
+      auto& lo = value.lo;
+
+      // hi
+      buf.Write(&hi);
+
+      // lo
+      buf.Write(&lo);
+    }
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::TestType)) {
+    auto& testType = *value_list.testType;
+
+    // testType
+    uint32_t tmp8;
+    tmp8 = static_cast<uint32_t>(testType);
+    buf.Write(&tmp8);
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Delta)) {
+    auto& delta = *value_list.delta;
+
+    // delta
+    {
+      auto& hi = delta.hi;
+      auto& lo = delta.lo;
+
+      // hi
+      buf.Write(&hi);
+
+      // lo
+      buf.Write(&lo);
+    }
+  }
+  if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Events)) {
+    auto& events = *value_list.events;
+
+    // events
+    buf.Write(&events);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::ChangeAlarm", false);
+}
+
+Future<void> Sync::ChangeAlarm(const Alarm& id,
+                               const absl::optional<Counter>& counter,
+                               const absl::optional<Valuetype>& valueType,
+                               const absl::optional<Int64>& value,
+                               const absl::optional<Testtype>& testType,
+                               const absl::optional<Int64>& delta,
+                               const absl::optional<uint32_t>& events) {
+  return Sync::ChangeAlarm(Sync::ChangeAlarmRequest{
+      id, counter, valueType, value, testType, delta, events});
+}
+
+Future<void> Sync::DestroyAlarm(const Sync::DestroyAlarmRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& alarm = request.alarm;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // alarm
+  buf.Write(&alarm);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::DestroyAlarm", false);
+}
+
+Future<void> Sync::DestroyAlarm(const Alarm& alarm) {
+  return Sync::DestroyAlarm(Sync::DestroyAlarmRequest{alarm});
+}
+
+Future<Sync::QueryAlarmReply> Sync::QueryAlarm(
+    const Sync::QueryAlarmRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& alarm = request.alarm;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // alarm
+  buf.Write(&alarm);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Sync::QueryAlarmReply>(
+      &buf, "Sync::QueryAlarm", false);
+}
+
+Future<Sync::QueryAlarmReply> Sync::QueryAlarm(const Alarm& alarm) {
+  return Sync::QueryAlarm(Sync::QueryAlarmRequest{alarm});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Sync::QueryAlarmReply> detail::ReadReply<Sync::QueryAlarmReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Sync::QueryAlarmReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& trigger = (*reply).trigger;
+  auto& delta = (*reply).delta;
+  auto& events = (*reply).events;
+  auto& state = (*reply).state;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // trigger
+  {
+    auto& counter = trigger.counter;
+    auto& wait_type = trigger.wait_type;
+    auto& wait_value = trigger.wait_value;
+    auto& test_type = trigger.test_type;
+
+    // counter
+    Read(&counter, &buf);
+
+    // wait_type
+    uint32_t tmp9;
+    Read(&tmp9, &buf);
+    wait_type = static_cast<Sync::Valuetype>(tmp9);
+
+    // wait_value
+    {
+      auto& hi = wait_value.hi;
+      auto& lo = wait_value.lo;
+
+      // hi
+      Read(&hi, &buf);
+
+      // lo
+      Read(&lo, &buf);
+    }
+
+    // test_type
+    uint32_t tmp10;
+    Read(&tmp10, &buf);
+    test_type = static_cast<Sync::Testtype>(tmp10);
+  }
+
+  // delta
+  {
+    auto& hi = delta.hi;
+    auto& lo = delta.lo;
+
+    // hi
+    Read(&hi, &buf);
+
+    // lo
+    Read(&lo, &buf);
+  }
+
+  // events
+  Read(&events, &buf);
+
+  // state
+  uint8_t tmp11;
+  Read(&tmp11, &buf);
+  state = static_cast<Sync::Alarmstate>(tmp11);
+
+  // pad1
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Sync::SetPriority(const Sync::SetPriorityRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& id = request.id;
+  auto& priority = request.priority;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // id
+  buf.Write(&id);
+
+  // priority
+  buf.Write(&priority);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::SetPriority", false);
+}
+
+Future<void> Sync::SetPriority(const uint32_t& id, const int32_t& priority) {
+  return Sync::SetPriority(Sync::SetPriorityRequest{id, priority});
+}
+
+Future<Sync::GetPriorityReply> Sync::GetPriority(
+    const Sync::GetPriorityRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& id = request.id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // id
+  buf.Write(&id);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Sync::GetPriorityReply>(
+      &buf, "Sync::GetPriority", false);
+}
+
+Future<Sync::GetPriorityReply> Sync::GetPriority(const uint32_t& id) {
+  return Sync::GetPriority(Sync::GetPriorityRequest{id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Sync::GetPriorityReply> detail::ReadReply<
+    Sync::GetPriorityReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Sync::GetPriorityReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& priority = (*reply).priority;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // priority
+  Read(&priority, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Sync::CreateFence(const Sync::CreateFenceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& fence = request.fence;
+  auto& initially_triggered = request.initially_triggered;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // fence
+  buf.Write(&fence);
+
+  // initially_triggered
+  buf.Write(&initially_triggered);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::CreateFence", false);
+}
+
+Future<void> Sync::CreateFence(const Drawable& drawable,
+                               const Fence& fence,
+                               const uint8_t& initially_triggered) {
+  return Sync::CreateFence(
+      Sync::CreateFenceRequest{drawable, fence, initially_triggered});
+}
+
+Future<void> Sync::TriggerFence(const Sync::TriggerFenceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& fence = request.fence;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // fence
+  buf.Write(&fence);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::TriggerFence", false);
+}
+
+Future<void> Sync::TriggerFence(const Fence& fence) {
+  return Sync::TriggerFence(Sync::TriggerFenceRequest{fence});
+}
+
+Future<void> Sync::ResetFence(const Sync::ResetFenceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& fence = request.fence;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // fence
+  buf.Write(&fence);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::ResetFence", false);
+}
+
+Future<void> Sync::ResetFence(const Fence& fence) {
+  return Sync::ResetFence(Sync::ResetFenceRequest{fence});
+}
+
+Future<void> Sync::DestroyFence(const Sync::DestroyFenceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& fence = request.fence;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // fence
+  buf.Write(&fence);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::DestroyFence", false);
+}
+
+Future<void> Sync::DestroyFence(const Fence& fence) {
+  return Sync::DestroyFence(Sync::DestroyFenceRequest{fence});
+}
+
+Future<Sync::QueryFenceReply> Sync::QueryFence(
+    const Sync::QueryFenceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& fence = request.fence;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // fence
+  buf.Write(&fence);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Sync::QueryFenceReply>(
+      &buf, "Sync::QueryFence", false);
+}
+
+Future<Sync::QueryFenceReply> Sync::QueryFence(const Fence& fence) {
+  return Sync::QueryFence(Sync::QueryFenceRequest{fence});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Sync::QueryFenceReply> detail::ReadReply<Sync::QueryFenceReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Sync::QueryFenceReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& triggered = (*reply).triggered;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // triggered
+  Read(&triggered, &buf);
+
+  // pad1
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Sync::AwaitFence(const Sync::AwaitFenceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& fence_list = request.fence_list;
+  size_t fence_list_len = fence_list.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // fence_list
+  DCHECK_EQ(static_cast<size_t>(fence_list_len), fence_list.size());
+  for (auto& fence_list_elem : fence_list) {
+    // fence_list_elem
+    buf.Write(&fence_list_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Sync::AwaitFence", false);
+}
+
+Future<void> Sync::AwaitFence(const std::vector<Fence>& fence_list) {
+  return Sync::AwaitFence(Sync::AwaitFenceRequest{fence_list});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/sync.h b/ui/gfx/x/generated_protos/sync.h
new file mode 100644
index 0000000..85ef3d1
--- /dev/null
+++ b/ui/gfx/x/generated_protos/sync.h
@@ -0,0 +1,526 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_SYNC_H_
+#define UI_GFX_X_GENERATED_PROTOS_SYNC_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Sync {
+ public:
+  static constexpr unsigned major_version = 3;
+  static constexpr unsigned minor_version = 1;
+
+  Sync(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Alarm : uint32_t {};
+
+  enum class Alarmstate : int {
+    Active = 0,
+    Inactive = 1,
+    Destroyed = 2,
+  };
+
+  enum class Counter : uint32_t {};
+
+  enum class Fence : uint32_t {};
+
+  enum class Testtype : int {
+    PositiveTransition = 0,
+    NegativeTransition = 1,
+    PositiveComparison = 2,
+    NegativeComparison = 3,
+  };
+
+  enum class Valuetype : int {
+    Absolute = 0,
+    Relative = 1,
+  };
+
+  enum class ChangeAlarmAttribute : int {
+    Counter = 1 << 0,
+    ValueType = 1 << 1,
+    Value = 1 << 2,
+    TestType = 1 << 3,
+    Delta = 1 << 4,
+    Events = 1 << 5,
+  };
+
+  struct Int64 {
+    int32_t hi{};
+    uint32_t lo{};
+  };
+
+  struct SystemCounter {
+    Counter counter{};
+    Int64 resolution{};
+    std::string name{};
+  };
+
+  struct Trigger {
+    Counter counter{};
+    Valuetype wait_type{};
+    Int64 wait_value{};
+    Testtype test_type{};
+  };
+
+  struct WaitCondition {
+    Trigger trigger{};
+    Int64 event_threshold{};
+  };
+
+  struct CounterError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_counter{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct AlarmError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t bad_alarm{};
+    uint16_t minor_opcode{};
+    uint8_t major_opcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct CounterNotifyEvent {
+    static constexpr int type_id = 16;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint8_t kind{};
+    uint16_t sequence{};
+    Counter counter{};
+    Int64 wait_value{};
+    Int64 counter_value{};
+    Time timestamp{};
+    uint16_t count{};
+    uint8_t destroyed{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct AlarmNotifyEvent {
+    static constexpr int type_id = 17;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint8_t kind{};
+    uint16_t sequence{};
+    Alarm alarm{};
+    Int64 counter_value{};
+    Int64 alarm_value{};
+    Time timestamp{};
+    Alarmstate state{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct InitializeRequest {
+    uint8_t desired_major_version{};
+    uint8_t desired_minor_version{};
+  };
+
+  struct InitializeReply {
+    uint16_t sequence{};
+    uint8_t major_version{};
+    uint8_t minor_version{};
+  };
+
+  using InitializeResponse = Response<InitializeReply>;
+
+  Future<InitializeReply> Initialize(const InitializeRequest& request);
+
+  Future<InitializeReply> Initialize(const uint8_t& desired_major_version = {},
+                                     const uint8_t& desired_minor_version = {});
+
+  struct ListSystemCountersRequest {};
+
+  struct ListSystemCountersReply {
+    uint16_t sequence{};
+    std::vector<SystemCounter> counters{};
+  };
+
+  using ListSystemCountersResponse = Response<ListSystemCountersReply>;
+
+  Future<ListSystemCountersReply> ListSystemCounters(
+      const ListSystemCountersRequest& request);
+
+  Future<ListSystemCountersReply> ListSystemCounters();
+
+  struct CreateCounterRequest {
+    Counter id{};
+    Int64 initial_value{};
+  };
+
+  using CreateCounterResponse = Response<void>;
+
+  Future<void> CreateCounter(const CreateCounterRequest& request);
+
+  Future<void> CreateCounter(const Counter& id = {},
+                             const Int64& initial_value = {{}, {}});
+
+  struct DestroyCounterRequest {
+    Counter counter{};
+  };
+
+  using DestroyCounterResponse = Response<void>;
+
+  Future<void> DestroyCounter(const DestroyCounterRequest& request);
+
+  Future<void> DestroyCounter(const Counter& counter = {});
+
+  struct QueryCounterRequest {
+    Counter counter{};
+  };
+
+  struct QueryCounterReply {
+    uint16_t sequence{};
+    Int64 counter_value{};
+  };
+
+  using QueryCounterResponse = Response<QueryCounterReply>;
+
+  Future<QueryCounterReply> QueryCounter(const QueryCounterRequest& request);
+
+  Future<QueryCounterReply> QueryCounter(const Counter& counter = {});
+
+  struct AwaitRequest {
+    std::vector<WaitCondition> wait_list{};
+  };
+
+  using AwaitResponse = Response<void>;
+
+  Future<void> Await(const AwaitRequest& request);
+
+  Future<void> Await(const std::vector<WaitCondition>& wait_list = {});
+
+  struct ChangeCounterRequest {
+    Counter counter{};
+    Int64 amount{};
+  };
+
+  using ChangeCounterResponse = Response<void>;
+
+  Future<void> ChangeCounter(const ChangeCounterRequest& request);
+
+  Future<void> ChangeCounter(const Counter& counter = {},
+                             const Int64& amount = {{}, {}});
+
+  struct SetCounterRequest {
+    Counter counter{};
+    Int64 value{};
+  };
+
+  using SetCounterResponse = Response<void>;
+
+  Future<void> SetCounter(const SetCounterRequest& request);
+
+  Future<void> SetCounter(const Counter& counter = {},
+                          const Int64& value = {{}, {}});
+
+  struct CreateAlarmRequest {
+    Alarm id{};
+    absl::optional<Counter> counter{};
+    absl::optional<Valuetype> valueType{};
+    absl::optional<Int64> value{};
+    absl::optional<Testtype> testType{};
+    absl::optional<Int64> delta{};
+    absl::optional<uint32_t> events{};
+  };
+
+  using CreateAlarmResponse = Response<void>;
+
+  Future<void> CreateAlarm(const CreateAlarmRequest& request);
+
+  Future<void> CreateAlarm(
+      const Alarm& id = {},
+      const absl::optional<Counter>& counter = absl::nullopt,
+      const absl::optional<Valuetype>& valueType = absl::nullopt,
+      const absl::optional<Int64>& value = absl::nullopt,
+      const absl::optional<Testtype>& testType = absl::nullopt,
+      const absl::optional<Int64>& delta = absl::nullopt,
+      const absl::optional<uint32_t>& events = absl::nullopt);
+
+  struct ChangeAlarmRequest {
+    Alarm id{};
+    absl::optional<Counter> counter{};
+    absl::optional<Valuetype> valueType{};
+    absl::optional<Int64> value{};
+    absl::optional<Testtype> testType{};
+    absl::optional<Int64> delta{};
+    absl::optional<uint32_t> events{};
+  };
+
+  using ChangeAlarmResponse = Response<void>;
+
+  Future<void> ChangeAlarm(const ChangeAlarmRequest& request);
+
+  Future<void> ChangeAlarm(
+      const Alarm& id = {},
+      const absl::optional<Counter>& counter = absl::nullopt,
+      const absl::optional<Valuetype>& valueType = absl::nullopt,
+      const absl::optional<Int64>& value = absl::nullopt,
+      const absl::optional<Testtype>& testType = absl::nullopt,
+      const absl::optional<Int64>& delta = absl::nullopt,
+      const absl::optional<uint32_t>& events = absl::nullopt);
+
+  struct DestroyAlarmRequest {
+    Alarm alarm{};
+  };
+
+  using DestroyAlarmResponse = Response<void>;
+
+  Future<void> DestroyAlarm(const DestroyAlarmRequest& request);
+
+  Future<void> DestroyAlarm(const Alarm& alarm = {});
+
+  struct QueryAlarmRequest {
+    Alarm alarm{};
+  };
+
+  struct QueryAlarmReply {
+    uint16_t sequence{};
+    Trigger trigger{};
+    Int64 delta{};
+    uint8_t events{};
+    Alarmstate state{};
+  };
+
+  using QueryAlarmResponse = Response<QueryAlarmReply>;
+
+  Future<QueryAlarmReply> QueryAlarm(const QueryAlarmRequest& request);
+
+  Future<QueryAlarmReply> QueryAlarm(const Alarm& alarm = {});
+
+  struct SetPriorityRequest {
+    uint32_t id{};
+    int32_t priority{};
+  };
+
+  using SetPriorityResponse = Response<void>;
+
+  Future<void> SetPriority(const SetPriorityRequest& request);
+
+  Future<void> SetPriority(const uint32_t& id = {},
+                           const int32_t& priority = {});
+
+  struct GetPriorityRequest {
+    uint32_t id{};
+  };
+
+  struct GetPriorityReply {
+    uint16_t sequence{};
+    int32_t priority{};
+  };
+
+  using GetPriorityResponse = Response<GetPriorityReply>;
+
+  Future<GetPriorityReply> GetPriority(const GetPriorityRequest& request);
+
+  Future<GetPriorityReply> GetPriority(const uint32_t& id = {});
+
+  struct CreateFenceRequest {
+    Drawable drawable{};
+    Fence fence{};
+    uint8_t initially_triggered{};
+  };
+
+  using CreateFenceResponse = Response<void>;
+
+  Future<void> CreateFence(const CreateFenceRequest& request);
+
+  Future<void> CreateFence(const Drawable& drawable = {},
+                           const Fence& fence = {},
+                           const uint8_t& initially_triggered = {});
+
+  struct TriggerFenceRequest {
+    Fence fence{};
+  };
+
+  using TriggerFenceResponse = Response<void>;
+
+  Future<void> TriggerFence(const TriggerFenceRequest& request);
+
+  Future<void> TriggerFence(const Fence& fence = {});
+
+  struct ResetFenceRequest {
+    Fence fence{};
+  };
+
+  using ResetFenceResponse = Response<void>;
+
+  Future<void> ResetFence(const ResetFenceRequest& request);
+
+  Future<void> ResetFence(const Fence& fence = {});
+
+  struct DestroyFenceRequest {
+    Fence fence{};
+  };
+
+  using DestroyFenceResponse = Response<void>;
+
+  Future<void> DestroyFence(const DestroyFenceRequest& request);
+
+  Future<void> DestroyFence(const Fence& fence = {});
+
+  struct QueryFenceRequest {
+    Fence fence{};
+  };
+
+  struct QueryFenceReply {
+    uint16_t sequence{};
+    uint8_t triggered{};
+  };
+
+  using QueryFenceResponse = Response<QueryFenceReply>;
+
+  Future<QueryFenceReply> QueryFence(const QueryFenceRequest& request);
+
+  Future<QueryFenceReply> QueryFence(const Fence& fence = {});
+
+  struct AwaitFenceRequest {
+    std::vector<Fence> fence_list{};
+  };
+
+  using AwaitFenceResponse = Response<void>;
+
+  Future<void> AwaitFence(const AwaitFenceRequest& request);
+
+  Future<void> AwaitFence(const std::vector<Fence>& fence_list = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Sync::Alarmstate operator|(x11::Sync::Alarmstate l,
+                                                 x11::Sync::Alarmstate r) {
+  using T = std::underlying_type_t<x11::Sync::Alarmstate>;
+  return static_cast<x11::Sync::Alarmstate>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Sync::Alarmstate operator&(x11::Sync::Alarmstate l,
+                                                 x11::Sync::Alarmstate r) {
+  using T = std::underlying_type_t<x11::Sync::Alarmstate>;
+  return static_cast<x11::Sync::Alarmstate>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Sync::Testtype operator|(x11::Sync::Testtype l,
+                                               x11::Sync::Testtype r) {
+  using T = std::underlying_type_t<x11::Sync::Testtype>;
+  return static_cast<x11::Sync::Testtype>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Sync::Testtype operator&(x11::Sync::Testtype l,
+                                               x11::Sync::Testtype r) {
+  using T = std::underlying_type_t<x11::Sync::Testtype>;
+  return static_cast<x11::Sync::Testtype>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Sync::Valuetype operator|(x11::Sync::Valuetype l,
+                                                x11::Sync::Valuetype r) {
+  using T = std::underlying_type_t<x11::Sync::Valuetype>;
+  return static_cast<x11::Sync::Valuetype>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Sync::Valuetype operator&(x11::Sync::Valuetype l,
+                                                x11::Sync::Valuetype r) {
+  using T = std::underlying_type_t<x11::Sync::Valuetype>;
+  return static_cast<x11::Sync::Valuetype>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Sync::ChangeAlarmAttribute operator|(
+    x11::Sync::ChangeAlarmAttribute l,
+    x11::Sync::ChangeAlarmAttribute r) {
+  using T = std::underlying_type_t<x11::Sync::ChangeAlarmAttribute>;
+  return static_cast<x11::Sync::ChangeAlarmAttribute>(static_cast<T>(l) |
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::Sync::ChangeAlarmAttribute operator&(
+    x11::Sync::ChangeAlarmAttribute l,
+    x11::Sync::ChangeAlarmAttribute r) {
+  using T = std::underlying_type_t<x11::Sync::ChangeAlarmAttribute>;
+  return static_cast<x11::Sync::ChangeAlarmAttribute>(static_cast<T>(l) &
+                                                      static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_SYNC_H_
diff --git a/ui/gfx/x/generated_protos/xc_misc.cc b/ui/gfx/x/generated_protos/xc_misc.cc
new file mode 100644
index 0000000..e75c0a8
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xc_misc.cc
@@ -0,0 +1,277 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xc_misc.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+XCMisc::XCMisc(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<XCMisc::GetVersionReply> XCMisc::GetVersion(
+    const XCMisc::GetVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XCMisc::GetVersionReply>(
+      &buf, "XCMisc::GetVersion", false);
+}
+
+Future<XCMisc::GetVersionReply> XCMisc::GetVersion(
+    const uint16_t& client_major_version,
+    const uint16_t& client_minor_version) {
+  return XCMisc::GetVersion(
+      XCMisc::GetVersionRequest{client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XCMisc::GetVersionReply> detail::ReadReply<
+    XCMisc::GetVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XCMisc::GetVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& server_major_version = (*reply).server_major_version;
+  auto& server_minor_version = (*reply).server_minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // server_major_version
+  Read(&server_major_version, &buf);
+
+  // server_minor_version
+  Read(&server_minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XCMisc::GetXIDRangeReply> XCMisc::GetXIDRange(
+    const XCMisc::GetXIDRangeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XCMisc::GetXIDRangeReply>(
+      &buf, "XCMisc::GetXIDRange", false);
+}
+
+Future<XCMisc::GetXIDRangeReply> XCMisc::GetXIDRange() {
+  return XCMisc::GetXIDRange(XCMisc::GetXIDRangeRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XCMisc::GetXIDRangeReply> detail::ReadReply<
+    XCMisc::GetXIDRangeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XCMisc::GetXIDRangeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& start_id = (*reply).start_id;
+  auto& count = (*reply).count;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // start_id
+  Read(&start_id, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XCMisc::GetXIDListReply> XCMisc::GetXIDList(
+    const XCMisc::GetXIDListRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& count = request.count;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // count
+  buf.Write(&count);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XCMisc::GetXIDListReply>(
+      &buf, "XCMisc::GetXIDList", false);
+}
+
+Future<XCMisc::GetXIDListReply> XCMisc::GetXIDList(const uint32_t& count) {
+  return XCMisc::GetXIDList(XCMisc::GetXIDListRequest{count});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XCMisc::GetXIDListReply> detail::ReadReply<
+    XCMisc::GetXIDListReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XCMisc::GetXIDListReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t ids_len{};
+  auto& ids = (*reply).ids;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // ids_len
+  Read(&ids_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // ids
+  ids.resize(ids_len);
+  for (auto& ids_elem : ids) {
+    // ids_elem
+    Read(&ids_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xc_misc.h b/ui/gfx/x/generated_protos/xc_misc.h
new file mode 100644
index 0000000..ea890fe
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xc_misc.h
@@ -0,0 +1,137 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XC_MISC_H_
+#define UI_GFX_X_GENERATED_PROTOS_XC_MISC_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) XCMisc {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 1;
+
+  XCMisc(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  struct GetVersionRequest {
+    uint16_t client_major_version{};
+    uint16_t client_minor_version{};
+  };
+
+  struct GetVersionReply {
+    uint16_t sequence{};
+    uint16_t server_major_version{};
+    uint16_t server_minor_version{};
+  };
+
+  using GetVersionResponse = Response<GetVersionReply>;
+
+  Future<GetVersionReply> GetVersion(const GetVersionRequest& request);
+
+  Future<GetVersionReply> GetVersion(const uint16_t& client_major_version = {},
+                                     const uint16_t& client_minor_version = {});
+
+  struct GetXIDRangeRequest {};
+
+  struct GetXIDRangeReply {
+    uint16_t sequence{};
+    uint32_t start_id{};
+    uint32_t count{};
+  };
+
+  using GetXIDRangeResponse = Response<GetXIDRangeReply>;
+
+  Future<GetXIDRangeReply> GetXIDRange(const GetXIDRangeRequest& request);
+
+  Future<GetXIDRangeReply> GetXIDRange();
+
+  struct GetXIDListRequest {
+    uint32_t count{};
+  };
+
+  struct GetXIDListReply {
+    uint16_t sequence{};
+    std::vector<uint32_t> ids{};
+  };
+
+  using GetXIDListResponse = Response<GetXIDListReply>;
+
+  Future<GetXIDListReply> GetXIDList(const GetXIDListRequest& request);
+
+  Future<GetXIDListReply> GetXIDList(const uint32_t& count = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XC_MISC_H_
diff --git a/ui/gfx/x/generated_protos/xevie.cc b/ui/gfx/x/generated_protos/xevie.cc
new file mode 100644
index 0000000..8eeb44d
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xevie.cc
@@ -0,0 +1,406 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xevie.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Xevie::Xevie(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<Xevie::QueryVersionReply> Xevie::QueryVersion(
+    const Xevie::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xevie::QueryVersionReply>(
+      &buf, "Xevie::QueryVersion", false);
+}
+
+Future<Xevie::QueryVersionReply> Xevie::QueryVersion(
+    const uint16_t& client_major_version,
+    const uint16_t& client_minor_version) {
+  return Xevie::QueryVersion(
+      Xevie::QueryVersionRequest{client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xevie::QueryVersionReply> detail::ReadReply<
+    Xevie::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xevie::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& server_major_version = (*reply).server_major_version;
+  auto& server_minor_version = (*reply).server_minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // server_major_version
+  Read(&server_major_version, &buf);
+
+  // server_minor_version
+  Read(&server_minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xevie::StartReply> Xevie::Start(const Xevie::StartRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xevie::StartReply>(&buf, "Xevie::Start",
+                                                     false);
+}
+
+Future<Xevie::StartReply> Xevie::Start(const uint32_t& screen) {
+  return Xevie::Start(Xevie::StartRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xevie::StartReply> detail::ReadReply<Xevie::StartReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xevie::StartReply>();
+
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xevie::EndReply> Xevie::End(const Xevie::EndRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xevie::EndReply>(&buf, "Xevie::End", false);
+}
+
+Future<Xevie::EndReply> Xevie::End(const uint32_t& cmap) {
+  return Xevie::End(Xevie::EndRequest{cmap});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xevie::EndReply> detail::ReadReply<Xevie::EndReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xevie::EndReply>();
+
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xevie::SendReply> Xevie::Send(const Xevie::SendRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& event = request.event;
+  auto& data_type = request.data_type;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // event
+  {
+    // pad0
+    Pad(&buf, 32);
+  }
+
+  // data_type
+  buf.Write(&data_type);
+
+  // pad0
+  Pad(&buf, 64);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xevie::SendReply>(&buf, "Xevie::Send", false);
+}
+
+Future<Xevie::SendReply> Xevie::Send(const Event& event,
+                                     const uint32_t& data_type) {
+  return Xevie::Send(Xevie::SendRequest{event, data_type});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xevie::SendReply> detail::ReadReply<Xevie::SendReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xevie::SendReply>();
+
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xevie::SelectInputReply> Xevie::SelectInput(
+    const Xevie::SelectInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& event_mask = request.event_mask;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // event_mask
+  buf.Write(&event_mask);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xevie::SelectInputReply>(
+      &buf, "Xevie::SelectInput", false);
+}
+
+Future<Xevie::SelectInputReply> Xevie::SelectInput(const uint32_t& event_mask) {
+  return Xevie::SelectInput(Xevie::SelectInputRequest{event_mask});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xevie::SelectInputReply> detail::ReadReply<
+    Xevie::SelectInputReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xevie::SelectInputReply>();
+
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xevie.h b/ui/gfx/x/generated_protos/xevie.h
new file mode 100644
index 0000000..be6723c
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xevie.h
@@ -0,0 +1,188 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XEVIE_H_
+#define UI_GFX_X_GENERATED_PROTOS_XEVIE_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Xevie {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 0;
+
+  Xevie(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Datatype : int {
+    Unmodified = 0,
+    Modified = 1,
+  };
+
+  struct Event {};
+
+  struct QueryVersionRequest {
+    uint16_t client_major_version{};
+    uint16_t client_minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t server_major_version{};
+    uint16_t server_minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(
+      const uint16_t& client_major_version = {},
+      const uint16_t& client_minor_version = {});
+
+  struct StartRequest {
+    uint32_t screen{};
+  };
+
+  struct StartReply {
+    uint16_t sequence{};
+  };
+
+  using StartResponse = Response<StartReply>;
+
+  Future<StartReply> Start(const StartRequest& request);
+
+  Future<StartReply> Start(const uint32_t& screen = {});
+
+  struct EndRequest {
+    uint32_t cmap{};
+  };
+
+  struct EndReply {
+    uint16_t sequence{};
+  };
+
+  using EndResponse = Response<EndReply>;
+
+  Future<EndReply> End(const EndRequest& request);
+
+  Future<EndReply> End(const uint32_t& cmap = {});
+
+  struct SendRequest {
+    Event event{};
+    uint32_t data_type{};
+  };
+
+  struct SendReply {
+    uint16_t sequence{};
+  };
+
+  using SendResponse = Response<SendReply>;
+
+  Future<SendReply> Send(const SendRequest& request);
+
+  Future<SendReply> Send(const Event& event = {},
+                         const uint32_t& data_type = {});
+
+  struct SelectInputRequest {
+    uint32_t event_mask{};
+  };
+
+  struct SelectInputReply {
+    uint16_t sequence{};
+  };
+
+  using SelectInputResponse = Response<SelectInputReply>;
+
+  Future<SelectInputReply> SelectInput(const SelectInputRequest& request);
+
+  Future<SelectInputReply> SelectInput(const uint32_t& event_mask = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Xevie::Datatype operator|(x11::Xevie::Datatype l,
+                                                x11::Xevie::Datatype r) {
+  using T = std::underlying_type_t<x11::Xevie::Datatype>;
+  return static_cast<x11::Xevie::Datatype>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xevie::Datatype operator&(x11::Xevie::Datatype l,
+                                                x11::Xevie::Datatype r) {
+  using T = std::underlying_type_t<x11::Xevie::Datatype>;
+  return static_cast<x11::Xevie::Datatype>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XEVIE_H_
diff --git a/ui/gfx/x/generated_protos/xf86dri.cc b/ui/gfx/x/generated_protos/xf86dri.cc
new file mode 100644
index 0000000..4acebbe
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xf86dri.cc
@@ -0,0 +1,972 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xf86dri.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+XF86Dri::XF86Dri(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<XF86Dri::QueryVersionReply> XF86Dri::QueryVersion(
+    const XF86Dri::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::QueryVersionReply>(
+      &buf, "XF86Dri::QueryVersion", false);
+}
+
+Future<XF86Dri::QueryVersionReply> XF86Dri::QueryVersion() {
+  return XF86Dri::QueryVersion(XF86Dri::QueryVersionRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::QueryVersionReply> detail::ReadReply<
+    XF86Dri::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& dri_major_version = (*reply).dri_major_version;
+  auto& dri_minor_version = (*reply).dri_minor_version;
+  auto& dri_minor_patch = (*reply).dri_minor_patch;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // dri_major_version
+  Read(&dri_major_version, &buf);
+
+  // dri_minor_version
+  Read(&dri_minor_version, &buf);
+
+  // dri_minor_patch
+  Read(&dri_minor_patch, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XF86Dri::QueryDirectRenderingCapableReply>
+XF86Dri::QueryDirectRenderingCapable(
+    const XF86Dri::QueryDirectRenderingCapableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::QueryDirectRenderingCapableReply>(
+      &buf, "XF86Dri::QueryDirectRenderingCapable", false);
+}
+
+Future<XF86Dri::QueryDirectRenderingCapableReply>
+XF86Dri::QueryDirectRenderingCapable(const uint32_t& screen) {
+  return XF86Dri::QueryDirectRenderingCapable(
+      XF86Dri::QueryDirectRenderingCapableRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::QueryDirectRenderingCapableReply> detail::ReadReply<
+    XF86Dri::QueryDirectRenderingCapableReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::QueryDirectRenderingCapableReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& is_capable = (*reply).is_capable;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // is_capable
+  Read(&is_capable, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XF86Dri::OpenConnectionReply> XF86Dri::OpenConnection(
+    const XF86Dri::OpenConnectionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::OpenConnectionReply>(
+      &buf, "XF86Dri::OpenConnection", false);
+}
+
+Future<XF86Dri::OpenConnectionReply> XF86Dri::OpenConnection(
+    const uint32_t& screen) {
+  return XF86Dri::OpenConnection(XF86Dri::OpenConnectionRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::OpenConnectionReply> detail::ReadReply<
+    XF86Dri::OpenConnectionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::OpenConnectionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& sarea_handle_low = (*reply).sarea_handle_low;
+  auto& sarea_handle_high = (*reply).sarea_handle_high;
+  uint32_t bus_id_len{};
+  auto& bus_id = (*reply).bus_id;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // sarea_handle_low
+  Read(&sarea_handle_low, &buf);
+
+  // sarea_handle_high
+  Read(&sarea_handle_high, &buf);
+
+  // bus_id_len
+  Read(&bus_id_len, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // bus_id
+  bus_id.resize(bus_id_len);
+  for (auto& bus_id_elem : bus_id) {
+    // bus_id_elem
+    Read(&bus_id_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86Dri::CloseConnection(
+    const XF86Dri::CloseConnectionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86Dri::CloseConnection",
+                                        false);
+}
+
+Future<void> XF86Dri::CloseConnection(const uint32_t& screen) {
+  return XF86Dri::CloseConnection(XF86Dri::CloseConnectionRequest{screen});
+}
+
+Future<XF86Dri::GetClientDriverNameReply> XF86Dri::GetClientDriverName(
+    const XF86Dri::GetClientDriverNameRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::GetClientDriverNameReply>(
+      &buf, "XF86Dri::GetClientDriverName", false);
+}
+
+Future<XF86Dri::GetClientDriverNameReply> XF86Dri::GetClientDriverName(
+    const uint32_t& screen) {
+  return XF86Dri::GetClientDriverName(
+      XF86Dri::GetClientDriverNameRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::GetClientDriverNameReply> detail::ReadReply<
+    XF86Dri::GetClientDriverNameReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::GetClientDriverNameReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& client_driver_major_version = (*reply).client_driver_major_version;
+  auto& client_driver_minor_version = (*reply).client_driver_minor_version;
+  auto& client_driver_patch_version = (*reply).client_driver_patch_version;
+  uint32_t client_driver_name_len{};
+  auto& client_driver_name = (*reply).client_driver_name;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // client_driver_major_version
+  Read(&client_driver_major_version, &buf);
+
+  // client_driver_minor_version
+  Read(&client_driver_minor_version, &buf);
+
+  // client_driver_patch_version
+  Read(&client_driver_patch_version, &buf);
+
+  // client_driver_name_len
+  Read(&client_driver_name_len, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // client_driver_name
+  client_driver_name.resize(client_driver_name_len);
+  for (auto& client_driver_name_elem : client_driver_name) {
+    // client_driver_name_elem
+    Read(&client_driver_name_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XF86Dri::CreateContextReply> XF86Dri::CreateContext(
+    const XF86Dri::CreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& visual = request.visual;
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // visual
+  buf.Write(&visual);
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::CreateContextReply>(
+      &buf, "XF86Dri::CreateContext", false);
+}
+
+Future<XF86Dri::CreateContextReply> XF86Dri::CreateContext(
+    const uint32_t& screen,
+    const uint32_t& visual,
+    const uint32_t& context) {
+  return XF86Dri::CreateContext(
+      XF86Dri::CreateContextRequest{screen, visual, context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::CreateContextReply> detail::ReadReply<
+    XF86Dri::CreateContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::CreateContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& hw_context = (*reply).hw_context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // hw_context
+  Read(&hw_context, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86Dri::DestroyContext(
+    const XF86Dri::DestroyContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86Dri::DestroyContext", false);
+}
+
+Future<void> XF86Dri::DestroyContext(const uint32_t& screen,
+                                     const uint32_t& context) {
+  return XF86Dri::DestroyContext(
+      XF86Dri::DestroyContextRequest{screen, context});
+}
+
+Future<XF86Dri::CreateDrawableReply> XF86Dri::CreateDrawable(
+    const XF86Dri::CreateDrawableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::CreateDrawableReply>(
+      &buf, "XF86Dri::CreateDrawable", false);
+}
+
+Future<XF86Dri::CreateDrawableReply> XF86Dri::CreateDrawable(
+    const uint32_t& screen,
+    const uint32_t& drawable) {
+  return XF86Dri::CreateDrawable(
+      XF86Dri::CreateDrawableRequest{screen, drawable});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::CreateDrawableReply> detail::ReadReply<
+    XF86Dri::CreateDrawableReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::CreateDrawableReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& hw_drawable_handle = (*reply).hw_drawable_handle;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // hw_drawable_handle
+  Read(&hw_drawable_handle, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86Dri::DestroyDrawable(
+    const XF86Dri::DestroyDrawableRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86Dri::DestroyDrawable",
+                                        false);
+}
+
+Future<void> XF86Dri::DestroyDrawable(const uint32_t& screen,
+                                      const uint32_t& drawable) {
+  return XF86Dri::DestroyDrawable(
+      XF86Dri::DestroyDrawableRequest{screen, drawable});
+}
+
+Future<XF86Dri::GetDrawableInfoReply> XF86Dri::GetDrawableInfo(
+    const XF86Dri::GetDrawableInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::GetDrawableInfoReply>(
+      &buf, "XF86Dri::GetDrawableInfo", false);
+}
+
+Future<XF86Dri::GetDrawableInfoReply> XF86Dri::GetDrawableInfo(
+    const uint32_t& screen,
+    const uint32_t& drawable) {
+  return XF86Dri::GetDrawableInfo(
+      XF86Dri::GetDrawableInfoRequest{screen, drawable});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::GetDrawableInfoReply> detail::ReadReply<
+    XF86Dri::GetDrawableInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::GetDrawableInfoReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& drawable_table_index = (*reply).drawable_table_index;
+  auto& drawable_table_stamp = (*reply).drawable_table_stamp;
+  auto& drawable_origin_X = (*reply).drawable_origin_X;
+  auto& drawable_origin_Y = (*reply).drawable_origin_Y;
+  auto& drawable_size_W = (*reply).drawable_size_W;
+  auto& drawable_size_H = (*reply).drawable_size_H;
+  uint32_t num_clip_rects{};
+  auto& back_x = (*reply).back_x;
+  auto& back_y = (*reply).back_y;
+  uint32_t num_back_clip_rects{};
+  auto& clip_rects = (*reply).clip_rects;
+  size_t clip_rects_len = clip_rects.size();
+  auto& back_clip_rects = (*reply).back_clip_rects;
+  size_t back_clip_rects_len = back_clip_rects.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // drawable_table_index
+  Read(&drawable_table_index, &buf);
+
+  // drawable_table_stamp
+  Read(&drawable_table_stamp, &buf);
+
+  // drawable_origin_X
+  Read(&drawable_origin_X, &buf);
+
+  // drawable_origin_Y
+  Read(&drawable_origin_Y, &buf);
+
+  // drawable_size_W
+  Read(&drawable_size_W, &buf);
+
+  // drawable_size_H
+  Read(&drawable_size_H, &buf);
+
+  // num_clip_rects
+  Read(&num_clip_rects, &buf);
+
+  // back_x
+  Read(&back_x, &buf);
+
+  // back_y
+  Read(&back_y, &buf);
+
+  // num_back_clip_rects
+  Read(&num_back_clip_rects, &buf);
+
+  // clip_rects
+  clip_rects.resize(num_clip_rects);
+  for (auto& clip_rects_elem : clip_rects) {
+    // clip_rects_elem
+    {
+      auto& x1 = clip_rects_elem.x1;
+      auto& y1 = clip_rects_elem.y1;
+      auto& x2 = clip_rects_elem.x2;
+      auto& x3 = clip_rects_elem.x3;
+
+      // x1
+      Read(&x1, &buf);
+
+      // y1
+      Read(&y1, &buf);
+
+      // x2
+      Read(&x2, &buf);
+
+      // x3
+      Read(&x3, &buf);
+    }
+  }
+
+  // back_clip_rects
+  back_clip_rects.resize(num_back_clip_rects);
+  for (auto& back_clip_rects_elem : back_clip_rects) {
+    // back_clip_rects_elem
+    {
+      auto& x1 = back_clip_rects_elem.x1;
+      auto& y1 = back_clip_rects_elem.y1;
+      auto& x2 = back_clip_rects_elem.x2;
+      auto& x3 = back_clip_rects_elem.x3;
+
+      // x1
+      Read(&x1, &buf);
+
+      // y1
+      Read(&y1, &buf);
+
+      // x2
+      Read(&x2, &buf);
+
+      // x3
+      Read(&x3, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XF86Dri::GetDeviceInfoReply> XF86Dri::GetDeviceInfo(
+    const XF86Dri::GetDeviceInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::GetDeviceInfoReply>(
+      &buf, "XF86Dri::GetDeviceInfo", false);
+}
+
+Future<XF86Dri::GetDeviceInfoReply> XF86Dri::GetDeviceInfo(
+    const uint32_t& screen) {
+  return XF86Dri::GetDeviceInfo(XF86Dri::GetDeviceInfoRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::GetDeviceInfoReply> detail::ReadReply<
+    XF86Dri::GetDeviceInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::GetDeviceInfoReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& framebuffer_handle_low = (*reply).framebuffer_handle_low;
+  auto& framebuffer_handle_high = (*reply).framebuffer_handle_high;
+  auto& framebuffer_origin_offset = (*reply).framebuffer_origin_offset;
+  auto& framebuffer_size = (*reply).framebuffer_size;
+  auto& framebuffer_stride = (*reply).framebuffer_stride;
+  uint32_t device_private_size{};
+  auto& device_private = (*reply).device_private;
+  size_t device_private_len = device_private.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // framebuffer_handle_low
+  Read(&framebuffer_handle_low, &buf);
+
+  // framebuffer_handle_high
+  Read(&framebuffer_handle_high, &buf);
+
+  // framebuffer_origin_offset
+  Read(&framebuffer_origin_offset, &buf);
+
+  // framebuffer_size
+  Read(&framebuffer_size, &buf);
+
+  // framebuffer_stride
+  Read(&framebuffer_stride, &buf);
+
+  // device_private_size
+  Read(&device_private_size, &buf);
+
+  // device_private
+  device_private.resize(device_private_size);
+  for (auto& device_private_elem : device_private) {
+    // device_private_elem
+    Read(&device_private_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XF86Dri::AuthConnectionReply> XF86Dri::AuthConnection(
+    const XF86Dri::AuthConnectionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& magic = request.magic;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // magic
+  buf.Write(&magic);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86Dri::AuthConnectionReply>(
+      &buf, "XF86Dri::AuthConnection", false);
+}
+
+Future<XF86Dri::AuthConnectionReply> XF86Dri::AuthConnection(
+    const uint32_t& screen,
+    const uint32_t& magic) {
+  return XF86Dri::AuthConnection(XF86Dri::AuthConnectionRequest{screen, magic});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86Dri::AuthConnectionReply> detail::ReadReply<
+    XF86Dri::AuthConnectionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86Dri::AuthConnectionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& authenticated = (*reply).authenticated;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // authenticated
+  Read(&authenticated, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xf86dri.h b/ui/gfx/x/generated_protos/xf86dri.h
new file mode 100644
index 0000000..42cbd47
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xf86dri.h
@@ -0,0 +1,304 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XF86DRI_H_
+#define UI_GFX_X_GENERATED_PROTOS_XF86DRI_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) XF86Dri {
+ public:
+  static constexpr unsigned major_version = 4;
+  static constexpr unsigned minor_version = 1;
+
+  XF86Dri(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  struct DrmClipRect {
+    int16_t x1{};
+    int16_t y1{};
+    int16_t x2{};
+    int16_t x3{};
+  };
+
+  struct QueryVersionRequest {};
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t dri_major_version{};
+    uint16_t dri_minor_version{};
+    uint32_t dri_minor_patch{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion();
+
+  struct QueryDirectRenderingCapableRequest {
+    uint32_t screen{};
+  };
+
+  struct QueryDirectRenderingCapableReply {
+    uint16_t sequence{};
+    uint8_t is_capable{};
+  };
+
+  using QueryDirectRenderingCapableResponse =
+      Response<QueryDirectRenderingCapableReply>;
+
+  Future<QueryDirectRenderingCapableReply> QueryDirectRenderingCapable(
+      const QueryDirectRenderingCapableRequest& request);
+
+  Future<QueryDirectRenderingCapableReply> QueryDirectRenderingCapable(
+      const uint32_t& screen = {});
+
+  struct OpenConnectionRequest {
+    uint32_t screen{};
+  };
+
+  struct OpenConnectionReply {
+    uint16_t sequence{};
+    uint32_t sarea_handle_low{};
+    uint32_t sarea_handle_high{};
+    std::string bus_id{};
+  };
+
+  using OpenConnectionResponse = Response<OpenConnectionReply>;
+
+  Future<OpenConnectionReply> OpenConnection(
+      const OpenConnectionRequest& request);
+
+  Future<OpenConnectionReply> OpenConnection(const uint32_t& screen = {});
+
+  struct CloseConnectionRequest {
+    uint32_t screen{};
+  };
+
+  using CloseConnectionResponse = Response<void>;
+
+  Future<void> CloseConnection(const CloseConnectionRequest& request);
+
+  Future<void> CloseConnection(const uint32_t& screen = {});
+
+  struct GetClientDriverNameRequest {
+    uint32_t screen{};
+  };
+
+  struct GetClientDriverNameReply {
+    uint16_t sequence{};
+    uint32_t client_driver_major_version{};
+    uint32_t client_driver_minor_version{};
+    uint32_t client_driver_patch_version{};
+    std::string client_driver_name{};
+  };
+
+  using GetClientDriverNameResponse = Response<GetClientDriverNameReply>;
+
+  Future<GetClientDriverNameReply> GetClientDriverName(
+      const GetClientDriverNameRequest& request);
+
+  Future<GetClientDriverNameReply> GetClientDriverName(
+      const uint32_t& screen = {});
+
+  struct CreateContextRequest {
+    uint32_t screen{};
+    uint32_t visual{};
+    uint32_t context{};
+  };
+
+  struct CreateContextReply {
+    uint16_t sequence{};
+    uint32_t hw_context{};
+  };
+
+  using CreateContextResponse = Response<CreateContextReply>;
+
+  Future<CreateContextReply> CreateContext(const CreateContextRequest& request);
+
+  Future<CreateContextReply> CreateContext(const uint32_t& screen = {},
+                                           const uint32_t& visual = {},
+                                           const uint32_t& context = {});
+
+  struct DestroyContextRequest {
+    uint32_t screen{};
+    uint32_t context{};
+  };
+
+  using DestroyContextResponse = Response<void>;
+
+  Future<void> DestroyContext(const DestroyContextRequest& request);
+
+  Future<void> DestroyContext(const uint32_t& screen = {},
+                              const uint32_t& context = {});
+
+  struct CreateDrawableRequest {
+    uint32_t screen{};
+    uint32_t drawable{};
+  };
+
+  struct CreateDrawableReply {
+    uint16_t sequence{};
+    uint32_t hw_drawable_handle{};
+  };
+
+  using CreateDrawableResponse = Response<CreateDrawableReply>;
+
+  Future<CreateDrawableReply> CreateDrawable(
+      const CreateDrawableRequest& request);
+
+  Future<CreateDrawableReply> CreateDrawable(const uint32_t& screen = {},
+                                             const uint32_t& drawable = {});
+
+  struct DestroyDrawableRequest {
+    uint32_t screen{};
+    uint32_t drawable{};
+  };
+
+  using DestroyDrawableResponse = Response<void>;
+
+  Future<void> DestroyDrawable(const DestroyDrawableRequest& request);
+
+  Future<void> DestroyDrawable(const uint32_t& screen = {},
+                               const uint32_t& drawable = {});
+
+  struct GetDrawableInfoRequest {
+    uint32_t screen{};
+    uint32_t drawable{};
+  };
+
+  struct GetDrawableInfoReply {
+    uint16_t sequence{};
+    uint32_t drawable_table_index{};
+    uint32_t drawable_table_stamp{};
+    int16_t drawable_origin_X{};
+    int16_t drawable_origin_Y{};
+    int16_t drawable_size_W{};
+    int16_t drawable_size_H{};
+    int16_t back_x{};
+    int16_t back_y{};
+    std::vector<DrmClipRect> clip_rects{};
+    std::vector<DrmClipRect> back_clip_rects{};
+  };
+
+  using GetDrawableInfoResponse = Response<GetDrawableInfoReply>;
+
+  Future<GetDrawableInfoReply> GetDrawableInfo(
+      const GetDrawableInfoRequest& request);
+
+  Future<GetDrawableInfoReply> GetDrawableInfo(const uint32_t& screen = {},
+                                               const uint32_t& drawable = {});
+
+  struct GetDeviceInfoRequest {
+    uint32_t screen{};
+  };
+
+  struct GetDeviceInfoReply {
+    uint16_t sequence{};
+    uint32_t framebuffer_handle_low{};
+    uint32_t framebuffer_handle_high{};
+    uint32_t framebuffer_origin_offset{};
+    uint32_t framebuffer_size{};
+    uint32_t framebuffer_stride{};
+    std::vector<uint32_t> device_private{};
+  };
+
+  using GetDeviceInfoResponse = Response<GetDeviceInfoReply>;
+
+  Future<GetDeviceInfoReply> GetDeviceInfo(const GetDeviceInfoRequest& request);
+
+  Future<GetDeviceInfoReply> GetDeviceInfo(const uint32_t& screen = {});
+
+  struct AuthConnectionRequest {
+    uint32_t screen{};
+    uint32_t magic{};
+  };
+
+  struct AuthConnectionReply {
+    uint16_t sequence{};
+    uint32_t authenticated{};
+  };
+
+  using AuthConnectionResponse = Response<AuthConnectionReply>;
+
+  Future<AuthConnectionReply> AuthConnection(
+      const AuthConnectionRequest& request);
+
+  Future<AuthConnectionReply> AuthConnection(const uint32_t& screen = {},
+                                             const uint32_t& magic = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XF86DRI_H_
diff --git a/ui/gfx/x/generated_protos/xf86vidmode.cc b/ui/gfx/x/generated_protos/xf86vidmode.cc
new file mode 100644
index 0000000..c08c336
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xf86vidmode.cc
@@ -0,0 +1,2197 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xf86vidmode.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+XF86VidMode::XF86VidMode(Connection* connection,
+                         const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string XF86VidMode::BadClockError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XF86VidMode::BadClockError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XF86VidMode::BadClockError>(XF86VidMode::BadClockError* error_,
+                                           ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string XF86VidMode::BadHTimingsError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XF86VidMode::BadHTimingsError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XF86VidMode::BadHTimingsError>(
+    XF86VidMode::BadHTimingsError* error_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string XF86VidMode::BadVTimingsError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XF86VidMode::BadVTimingsError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XF86VidMode::BadVTimingsError>(
+    XF86VidMode::BadVTimingsError* error_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string XF86VidMode::ModeUnsuitableError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XF86VidMode::ModeUnsuitableError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XF86VidMode::ModeUnsuitableError>(
+    XF86VidMode::ModeUnsuitableError* error_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string XF86VidMode::ExtensionDisabledError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XF86VidMode::ExtensionDisabledError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XF86VidMode::ExtensionDisabledError>(
+    XF86VidMode::ExtensionDisabledError* error_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string XF86VidMode::ClientNotLocalError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XF86VidMode::ClientNotLocalError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XF86VidMode::ClientNotLocalError>(
+    XF86VidMode::ClientNotLocalError* error_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string XF86VidMode::ZoomLockedError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XF86VidMode::ZoomLockedError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XF86VidMode::ZoomLockedError>(
+    XF86VidMode::ZoomLockedError* error_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+Future<XF86VidMode::QueryVersionReply> XF86VidMode::QueryVersion(
+    const XF86VidMode::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::QueryVersionReply>(
+      &buf, "XF86VidMode::QueryVersion", false);
+}
+
+Future<XF86VidMode::QueryVersionReply> XF86VidMode::QueryVersion() {
+  return XF86VidMode::QueryVersion(XF86VidMode::QueryVersionRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::QueryVersionReply> detail::ReadReply<
+    XF86VidMode::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XF86VidMode::GetModeLineReply> XF86VidMode::GetModeLine(
+    const XF86VidMode::GetModeLineRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetModeLineReply>(
+      &buf, "XF86VidMode::GetModeLine", false);
+}
+
+Future<XF86VidMode::GetModeLineReply> XF86VidMode::GetModeLine(
+    const uint16_t& screen) {
+  return XF86VidMode::GetModeLine(XF86VidMode::GetModeLineRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetModeLineReply> detail::ReadReply<
+    XF86VidMode::GetModeLineReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetModeLineReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& dotclock = (*reply).dotclock;
+  auto& hdisplay = (*reply).hdisplay;
+  auto& hsyncstart = (*reply).hsyncstart;
+  auto& hsyncend = (*reply).hsyncend;
+  auto& htotal = (*reply).htotal;
+  auto& hskew = (*reply).hskew;
+  auto& vdisplay = (*reply).vdisplay;
+  auto& vsyncstart = (*reply).vsyncstart;
+  auto& vsyncend = (*reply).vsyncend;
+  auto& vtotal = (*reply).vtotal;
+  auto& flags = (*reply).flags;
+  uint32_t privsize{};
+  auto& c_private = (*reply).c_private;
+  size_t c_private_len = c_private.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // dotclock
+  Read(&dotclock, &buf);
+
+  // hdisplay
+  Read(&hdisplay, &buf);
+
+  // hsyncstart
+  Read(&hsyncstart, &buf);
+
+  // hsyncend
+  Read(&hsyncend, &buf);
+
+  // htotal
+  Read(&htotal, &buf);
+
+  // hskew
+  Read(&hskew, &buf);
+
+  // vdisplay
+  Read(&vdisplay, &buf);
+
+  // vsyncstart
+  Read(&vsyncstart, &buf);
+
+  // vsyncend
+  Read(&vsyncend, &buf);
+
+  // vtotal
+  Read(&vtotal, &buf);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // flags
+  uint32_t tmp0;
+  Read(&tmp0, &buf);
+  flags = static_cast<XF86VidMode::ModeFlag>(tmp0);
+
+  // pad2
+  Pad(&buf, 12);
+
+  // privsize
+  Read(&privsize, &buf);
+
+  // c_private
+  c_private.resize(privsize);
+  for (auto& c_private_elem : c_private) {
+    // c_private_elem
+    Read(&c_private_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86VidMode::ModModeLine(
+    const XF86VidMode::ModModeLineRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& hdisplay = request.hdisplay;
+  auto& hsyncstart = request.hsyncstart;
+  auto& hsyncend = request.hsyncend;
+  auto& htotal = request.htotal;
+  auto& hskew = request.hskew;
+  auto& vdisplay = request.vdisplay;
+  auto& vsyncstart = request.vsyncstart;
+  auto& vsyncend = request.vsyncend;
+  auto& vtotal = request.vtotal;
+  auto& flags = request.flags;
+  uint32_t privsize{};
+  auto& c_private = request.c_private;
+  size_t c_private_len = c_private.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // hdisplay
+  buf.Write(&hdisplay);
+
+  // hsyncstart
+  buf.Write(&hsyncstart);
+
+  // hsyncend
+  buf.Write(&hsyncend);
+
+  // htotal
+  buf.Write(&htotal);
+
+  // hskew
+  buf.Write(&hskew);
+
+  // vdisplay
+  buf.Write(&vdisplay);
+
+  // vsyncstart
+  buf.Write(&vsyncstart);
+
+  // vsyncend
+  buf.Write(&vsyncend);
+
+  // vtotal
+  buf.Write(&vtotal);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // flags
+  uint32_t tmp1;
+  tmp1 = static_cast<uint32_t>(flags);
+  buf.Write(&tmp1);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // privsize
+  privsize = c_private.size();
+  buf.Write(&privsize);
+
+  // c_private
+  DCHECK_EQ(static_cast<size_t>(privsize), c_private.size());
+  for (auto& c_private_elem : c_private) {
+    // c_private_elem
+    buf.Write(&c_private_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::ModModeLine",
+                                        false);
+}
+
+Future<void> XF86VidMode::ModModeLine(const uint32_t& screen,
+                                      const uint16_t& hdisplay,
+                                      const uint16_t& hsyncstart,
+                                      const uint16_t& hsyncend,
+                                      const uint16_t& htotal,
+                                      const uint16_t& hskew,
+                                      const uint16_t& vdisplay,
+                                      const uint16_t& vsyncstart,
+                                      const uint16_t& vsyncend,
+                                      const uint16_t& vtotal,
+                                      const ModeFlag& flags,
+                                      const std::vector<uint8_t>& c_private) {
+  return XF86VidMode::ModModeLine(XF86VidMode::ModModeLineRequest{
+      screen, hdisplay, hsyncstart, hsyncend, htotal, hskew, vdisplay,
+      vsyncstart, vsyncend, vtotal, flags, c_private});
+}
+
+Future<void> XF86VidMode::SwitchMode(
+    const XF86VidMode::SwitchModeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& zoom = request.zoom;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // zoom
+  buf.Write(&zoom);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::SwitchMode", false);
+}
+
+Future<void> XF86VidMode::SwitchMode(const uint16_t& screen,
+                                     const uint16_t& zoom) {
+  return XF86VidMode::SwitchMode(XF86VidMode::SwitchModeRequest{screen, zoom});
+}
+
+Future<XF86VidMode::GetMonitorReply> XF86VidMode::GetMonitor(
+    const XF86VidMode::GetMonitorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetMonitorReply>(
+      &buf, "XF86VidMode::GetMonitor", false);
+}
+
+Future<XF86VidMode::GetMonitorReply> XF86VidMode::GetMonitor(
+    const uint16_t& screen) {
+  return XF86VidMode::GetMonitor(XF86VidMode::GetMonitorRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetMonitorReply> detail::ReadReply<
+    XF86VidMode::GetMonitorReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetMonitorReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint8_t vendor_length{};
+  uint8_t model_length{};
+  uint8_t num_hsync{};
+  uint8_t num_vsync{};
+  auto& hsync = (*reply).hsync;
+  size_t hsync_len = hsync.size();
+  auto& vsync = (*reply).vsync;
+  size_t vsync_len = vsync.size();
+  auto& vendor = (*reply).vendor;
+  size_t vendor_len = vendor.size();
+  auto& alignment_pad = (*reply).alignment_pad;
+  size_t alignment_pad_len = alignment_pad ? alignment_pad->size() : 0;
+  auto& model = (*reply).model;
+  size_t model_len = model.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // vendor_length
+  Read(&vendor_length, &buf);
+
+  // model_length
+  Read(&model_length, &buf);
+
+  // num_hsync
+  Read(&num_hsync, &buf);
+
+  // num_vsync
+  Read(&num_vsync, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // hsync
+  hsync.resize(num_hsync);
+  for (auto& hsync_elem : hsync) {
+    // hsync_elem
+    Read(&hsync_elem, &buf);
+  }
+
+  // vsync
+  vsync.resize(num_vsync);
+  for (auto& vsync_elem : vsync) {
+    // vsync_elem
+    Read(&vsync_elem, &buf);
+  }
+
+  // vendor
+  vendor.resize(vendor_length);
+  for (auto& vendor_elem : vendor) {
+    // vendor_elem
+    Read(&vendor_elem, &buf);
+  }
+
+  // alignment_pad
+  alignment_pad = buffer->ReadAndAdvance(
+      (BitAnd((vendor_length) + (3), BitNot(3))) - (vendor_length));
+
+  // model
+  model.resize(model_length);
+  for (auto& model_elem : model) {
+    // model_elem
+    Read(&model_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86VidMode::LockModeSwitch(
+    const XF86VidMode::LockModeSwitchRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& lock = request.lock;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // lock
+  buf.Write(&lock);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::LockModeSwitch",
+                                        false);
+}
+
+Future<void> XF86VidMode::LockModeSwitch(const uint16_t& screen,
+                                         const uint16_t& lock) {
+  return XF86VidMode::LockModeSwitch(
+      XF86VidMode::LockModeSwitchRequest{screen, lock});
+}
+
+Future<XF86VidMode::GetAllModeLinesReply> XF86VidMode::GetAllModeLines(
+    const XF86VidMode::GetAllModeLinesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetAllModeLinesReply>(
+      &buf, "XF86VidMode::GetAllModeLines", false);
+}
+
+Future<XF86VidMode::GetAllModeLinesReply> XF86VidMode::GetAllModeLines(
+    const uint16_t& screen) {
+  return XF86VidMode::GetAllModeLines(
+      XF86VidMode::GetAllModeLinesRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetAllModeLinesReply> detail::ReadReply<
+    XF86VidMode::GetAllModeLinesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetAllModeLinesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t modecount{};
+  auto& modeinfo = (*reply).modeinfo;
+  size_t modeinfo_len = modeinfo.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // modecount
+  Read(&modecount, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // modeinfo
+  modeinfo.resize(modecount);
+  for (auto& modeinfo_elem : modeinfo) {
+    // modeinfo_elem
+    {
+      auto& dotclock = modeinfo_elem.dotclock;
+      auto& hdisplay = modeinfo_elem.hdisplay;
+      auto& hsyncstart = modeinfo_elem.hsyncstart;
+      auto& hsyncend = modeinfo_elem.hsyncend;
+      auto& htotal = modeinfo_elem.htotal;
+      auto& hskew = modeinfo_elem.hskew;
+      auto& vdisplay = modeinfo_elem.vdisplay;
+      auto& vsyncstart = modeinfo_elem.vsyncstart;
+      auto& vsyncend = modeinfo_elem.vsyncend;
+      auto& vtotal = modeinfo_elem.vtotal;
+      auto& flags = modeinfo_elem.flags;
+      auto& privsize = modeinfo_elem.privsize;
+
+      // dotclock
+      Read(&dotclock, &buf);
+
+      // hdisplay
+      Read(&hdisplay, &buf);
+
+      // hsyncstart
+      Read(&hsyncstart, &buf);
+
+      // hsyncend
+      Read(&hsyncend, &buf);
+
+      // htotal
+      Read(&htotal, &buf);
+
+      // hskew
+      Read(&hskew, &buf);
+
+      // vdisplay
+      Read(&vdisplay, &buf);
+
+      // vsyncstart
+      Read(&vsyncstart, &buf);
+
+      // vsyncend
+      Read(&vsyncend, &buf);
+
+      // vtotal
+      Read(&vtotal, &buf);
+
+      // pad0
+      Pad(&buf, 4);
+
+      // flags
+      uint32_t tmp2;
+      Read(&tmp2, &buf);
+      flags = static_cast<XF86VidMode::ModeFlag>(tmp2);
+
+      // pad1
+      Pad(&buf, 12);
+
+      // privsize
+      Read(&privsize, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86VidMode::AddModeLine(
+    const XF86VidMode::AddModeLineRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& dotclock = request.dotclock;
+  auto& hdisplay = request.hdisplay;
+  auto& hsyncstart = request.hsyncstart;
+  auto& hsyncend = request.hsyncend;
+  auto& htotal = request.htotal;
+  auto& hskew = request.hskew;
+  auto& vdisplay = request.vdisplay;
+  auto& vsyncstart = request.vsyncstart;
+  auto& vsyncend = request.vsyncend;
+  auto& vtotal = request.vtotal;
+  auto& flags = request.flags;
+  uint32_t privsize{};
+  auto& after_dotclock = request.after_dotclock;
+  auto& after_hdisplay = request.after_hdisplay;
+  auto& after_hsyncstart = request.after_hsyncstart;
+  auto& after_hsyncend = request.after_hsyncend;
+  auto& after_htotal = request.after_htotal;
+  auto& after_hskew = request.after_hskew;
+  auto& after_vdisplay = request.after_vdisplay;
+  auto& after_vsyncstart = request.after_vsyncstart;
+  auto& after_vsyncend = request.after_vsyncend;
+  auto& after_vtotal = request.after_vtotal;
+  auto& after_flags = request.after_flags;
+  auto& c_private = request.c_private;
+  size_t c_private_len = c_private.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // dotclock
+  buf.Write(&dotclock);
+
+  // hdisplay
+  buf.Write(&hdisplay);
+
+  // hsyncstart
+  buf.Write(&hsyncstart);
+
+  // hsyncend
+  buf.Write(&hsyncend);
+
+  // htotal
+  buf.Write(&htotal);
+
+  // hskew
+  buf.Write(&hskew);
+
+  // vdisplay
+  buf.Write(&vdisplay);
+
+  // vsyncstart
+  buf.Write(&vsyncstart);
+
+  // vsyncend
+  buf.Write(&vsyncend);
+
+  // vtotal
+  buf.Write(&vtotal);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // flags
+  uint32_t tmp3;
+  tmp3 = static_cast<uint32_t>(flags);
+  buf.Write(&tmp3);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // privsize
+  privsize = c_private.size();
+  buf.Write(&privsize);
+
+  // after_dotclock
+  buf.Write(&after_dotclock);
+
+  // after_hdisplay
+  buf.Write(&after_hdisplay);
+
+  // after_hsyncstart
+  buf.Write(&after_hsyncstart);
+
+  // after_hsyncend
+  buf.Write(&after_hsyncend);
+
+  // after_htotal
+  buf.Write(&after_htotal);
+
+  // after_hskew
+  buf.Write(&after_hskew);
+
+  // after_vdisplay
+  buf.Write(&after_vdisplay);
+
+  // after_vsyncstart
+  buf.Write(&after_vsyncstart);
+
+  // after_vsyncend
+  buf.Write(&after_vsyncend);
+
+  // after_vtotal
+  buf.Write(&after_vtotal);
+
+  // pad2
+  Pad(&buf, 2);
+
+  // after_flags
+  uint32_t tmp4;
+  tmp4 = static_cast<uint32_t>(after_flags);
+  buf.Write(&tmp4);
+
+  // pad3
+  Pad(&buf, 12);
+
+  // c_private
+  DCHECK_EQ(static_cast<size_t>(privsize), c_private.size());
+  for (auto& c_private_elem : c_private) {
+    // c_private_elem
+    buf.Write(&c_private_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::AddModeLine",
+                                        false);
+}
+
+Future<void> XF86VidMode::AddModeLine(const uint32_t& screen,
+                                      const DotClock& dotclock,
+                                      const uint16_t& hdisplay,
+                                      const uint16_t& hsyncstart,
+                                      const uint16_t& hsyncend,
+                                      const uint16_t& htotal,
+                                      const uint16_t& hskew,
+                                      const uint16_t& vdisplay,
+                                      const uint16_t& vsyncstart,
+                                      const uint16_t& vsyncend,
+                                      const uint16_t& vtotal,
+                                      const ModeFlag& flags,
+                                      const DotClock& after_dotclock,
+                                      const uint16_t& after_hdisplay,
+                                      const uint16_t& after_hsyncstart,
+                                      const uint16_t& after_hsyncend,
+                                      const uint16_t& after_htotal,
+                                      const uint16_t& after_hskew,
+                                      const uint16_t& after_vdisplay,
+                                      const uint16_t& after_vsyncstart,
+                                      const uint16_t& after_vsyncend,
+                                      const uint16_t& after_vtotal,
+                                      const ModeFlag& after_flags,
+                                      const std::vector<uint8_t>& c_private) {
+  return XF86VidMode::AddModeLine(XF86VidMode::AddModeLineRequest{
+      screen,         dotclock,         hdisplay,
+      hsyncstart,     hsyncend,         htotal,
+      hskew,          vdisplay,         vsyncstart,
+      vsyncend,       vtotal,           flags,
+      after_dotclock, after_hdisplay,   after_hsyncstart,
+      after_hsyncend, after_htotal,     after_hskew,
+      after_vdisplay, after_vsyncstart, after_vsyncend,
+      after_vtotal,   after_flags,      c_private});
+}
+
+Future<void> XF86VidMode::DeleteModeLine(
+    const XF86VidMode::DeleteModeLineRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& dotclock = request.dotclock;
+  auto& hdisplay = request.hdisplay;
+  auto& hsyncstart = request.hsyncstart;
+  auto& hsyncend = request.hsyncend;
+  auto& htotal = request.htotal;
+  auto& hskew = request.hskew;
+  auto& vdisplay = request.vdisplay;
+  auto& vsyncstart = request.vsyncstart;
+  auto& vsyncend = request.vsyncend;
+  auto& vtotal = request.vtotal;
+  auto& flags = request.flags;
+  uint32_t privsize{};
+  auto& c_private = request.c_private;
+  size_t c_private_len = c_private.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // dotclock
+  buf.Write(&dotclock);
+
+  // hdisplay
+  buf.Write(&hdisplay);
+
+  // hsyncstart
+  buf.Write(&hsyncstart);
+
+  // hsyncend
+  buf.Write(&hsyncend);
+
+  // htotal
+  buf.Write(&htotal);
+
+  // hskew
+  buf.Write(&hskew);
+
+  // vdisplay
+  buf.Write(&vdisplay);
+
+  // vsyncstart
+  buf.Write(&vsyncstart);
+
+  // vsyncend
+  buf.Write(&vsyncend);
+
+  // vtotal
+  buf.Write(&vtotal);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // flags
+  uint32_t tmp5;
+  tmp5 = static_cast<uint32_t>(flags);
+  buf.Write(&tmp5);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // privsize
+  privsize = c_private.size();
+  buf.Write(&privsize);
+
+  // c_private
+  DCHECK_EQ(static_cast<size_t>(privsize), c_private.size());
+  for (auto& c_private_elem : c_private) {
+    // c_private_elem
+    buf.Write(&c_private_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::DeleteModeLine",
+                                        false);
+}
+
+Future<void> XF86VidMode::DeleteModeLine(
+    const uint32_t& screen,
+    const DotClock& dotclock,
+    const uint16_t& hdisplay,
+    const uint16_t& hsyncstart,
+    const uint16_t& hsyncend,
+    const uint16_t& htotal,
+    const uint16_t& hskew,
+    const uint16_t& vdisplay,
+    const uint16_t& vsyncstart,
+    const uint16_t& vsyncend,
+    const uint16_t& vtotal,
+    const ModeFlag& flags,
+    const std::vector<uint8_t>& c_private) {
+  return XF86VidMode::DeleteModeLine(XF86VidMode::DeleteModeLineRequest{
+      screen, dotclock, hdisplay, hsyncstart, hsyncend, htotal, hskew, vdisplay,
+      vsyncstart, vsyncend, vtotal, flags, c_private});
+}
+
+Future<XF86VidMode::ValidateModeLineReply> XF86VidMode::ValidateModeLine(
+    const XF86VidMode::ValidateModeLineRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& dotclock = request.dotclock;
+  auto& hdisplay = request.hdisplay;
+  auto& hsyncstart = request.hsyncstart;
+  auto& hsyncend = request.hsyncend;
+  auto& htotal = request.htotal;
+  auto& hskew = request.hskew;
+  auto& vdisplay = request.vdisplay;
+  auto& vsyncstart = request.vsyncstart;
+  auto& vsyncend = request.vsyncend;
+  auto& vtotal = request.vtotal;
+  auto& flags = request.flags;
+  uint32_t privsize{};
+  auto& c_private = request.c_private;
+  size_t c_private_len = c_private.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // dotclock
+  buf.Write(&dotclock);
+
+  // hdisplay
+  buf.Write(&hdisplay);
+
+  // hsyncstart
+  buf.Write(&hsyncstart);
+
+  // hsyncend
+  buf.Write(&hsyncend);
+
+  // htotal
+  buf.Write(&htotal);
+
+  // hskew
+  buf.Write(&hskew);
+
+  // vdisplay
+  buf.Write(&vdisplay);
+
+  // vsyncstart
+  buf.Write(&vsyncstart);
+
+  // vsyncend
+  buf.Write(&vsyncend);
+
+  // vtotal
+  buf.Write(&vtotal);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // flags
+  uint32_t tmp6;
+  tmp6 = static_cast<uint32_t>(flags);
+  buf.Write(&tmp6);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // privsize
+  privsize = c_private.size();
+  buf.Write(&privsize);
+
+  // c_private
+  DCHECK_EQ(static_cast<size_t>(privsize), c_private.size());
+  for (auto& c_private_elem : c_private) {
+    // c_private_elem
+    buf.Write(&c_private_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::ValidateModeLineReply>(
+      &buf, "XF86VidMode::ValidateModeLine", false);
+}
+
+Future<XF86VidMode::ValidateModeLineReply> XF86VidMode::ValidateModeLine(
+    const uint32_t& screen,
+    const DotClock& dotclock,
+    const uint16_t& hdisplay,
+    const uint16_t& hsyncstart,
+    const uint16_t& hsyncend,
+    const uint16_t& htotal,
+    const uint16_t& hskew,
+    const uint16_t& vdisplay,
+    const uint16_t& vsyncstart,
+    const uint16_t& vsyncend,
+    const uint16_t& vtotal,
+    const ModeFlag& flags,
+    const std::vector<uint8_t>& c_private) {
+  return XF86VidMode::ValidateModeLine(XF86VidMode::ValidateModeLineRequest{
+      screen, dotclock, hdisplay, hsyncstart, hsyncend, htotal, hskew, vdisplay,
+      vsyncstart, vsyncend, vtotal, flags, c_private});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::ValidateModeLineReply> detail::ReadReply<
+    XF86VidMode::ValidateModeLineReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::ValidateModeLineReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  Read(&status, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86VidMode::SwitchToMode(
+    const XF86VidMode::SwitchToModeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& dotclock = request.dotclock;
+  auto& hdisplay = request.hdisplay;
+  auto& hsyncstart = request.hsyncstart;
+  auto& hsyncend = request.hsyncend;
+  auto& htotal = request.htotal;
+  auto& hskew = request.hskew;
+  auto& vdisplay = request.vdisplay;
+  auto& vsyncstart = request.vsyncstart;
+  auto& vsyncend = request.vsyncend;
+  auto& vtotal = request.vtotal;
+  auto& flags = request.flags;
+  uint32_t privsize{};
+  auto& c_private = request.c_private;
+  size_t c_private_len = c_private.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // dotclock
+  buf.Write(&dotclock);
+
+  // hdisplay
+  buf.Write(&hdisplay);
+
+  // hsyncstart
+  buf.Write(&hsyncstart);
+
+  // hsyncend
+  buf.Write(&hsyncend);
+
+  // htotal
+  buf.Write(&htotal);
+
+  // hskew
+  buf.Write(&hskew);
+
+  // vdisplay
+  buf.Write(&vdisplay);
+
+  // vsyncstart
+  buf.Write(&vsyncstart);
+
+  // vsyncend
+  buf.Write(&vsyncend);
+
+  // vtotal
+  buf.Write(&vtotal);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // flags
+  uint32_t tmp7;
+  tmp7 = static_cast<uint32_t>(flags);
+  buf.Write(&tmp7);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // privsize
+  privsize = c_private.size();
+  buf.Write(&privsize);
+
+  // c_private
+  DCHECK_EQ(static_cast<size_t>(privsize), c_private.size());
+  for (auto& c_private_elem : c_private) {
+    // c_private_elem
+    buf.Write(&c_private_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::SwitchToMode",
+                                        false);
+}
+
+Future<void> XF86VidMode::SwitchToMode(const uint32_t& screen,
+                                       const DotClock& dotclock,
+                                       const uint16_t& hdisplay,
+                                       const uint16_t& hsyncstart,
+                                       const uint16_t& hsyncend,
+                                       const uint16_t& htotal,
+                                       const uint16_t& hskew,
+                                       const uint16_t& vdisplay,
+                                       const uint16_t& vsyncstart,
+                                       const uint16_t& vsyncend,
+                                       const uint16_t& vtotal,
+                                       const ModeFlag& flags,
+                                       const std::vector<uint8_t>& c_private) {
+  return XF86VidMode::SwitchToMode(XF86VidMode::SwitchToModeRequest{
+      screen, dotclock, hdisplay, hsyncstart, hsyncend, htotal, hskew, vdisplay,
+      vsyncstart, vsyncend, vtotal, flags, c_private});
+}
+
+Future<XF86VidMode::GetViewPortReply> XF86VidMode::GetViewPort(
+    const XF86VidMode::GetViewPortRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetViewPortReply>(
+      &buf, "XF86VidMode::GetViewPort", false);
+}
+
+Future<XF86VidMode::GetViewPortReply> XF86VidMode::GetViewPort(
+    const uint16_t& screen) {
+  return XF86VidMode::GetViewPort(XF86VidMode::GetViewPortRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetViewPortReply> detail::ReadReply<
+    XF86VidMode::GetViewPortReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetViewPortReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& x = (*reply).x;
+  auto& y = (*reply).y;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86VidMode::SetViewPort(
+    const XF86VidMode::SetViewPortRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& x = request.x;
+  auto& y = request.y;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::SetViewPort",
+                                        false);
+}
+
+Future<void> XF86VidMode::SetViewPort(const uint16_t& screen,
+                                      const uint32_t& x,
+                                      const uint32_t& y) {
+  return XF86VidMode::SetViewPort(
+      XF86VidMode::SetViewPortRequest{screen, x, y});
+}
+
+Future<XF86VidMode::GetDotClocksReply> XF86VidMode::GetDotClocks(
+    const XF86VidMode::GetDotClocksRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetDotClocksReply>(
+      &buf, "XF86VidMode::GetDotClocks", false);
+}
+
+Future<XF86VidMode::GetDotClocksReply> XF86VidMode::GetDotClocks(
+    const uint16_t& screen) {
+  return XF86VidMode::GetDotClocks(XF86VidMode::GetDotClocksRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetDotClocksReply> detail::ReadReply<
+    XF86VidMode::GetDotClocksReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetDotClocksReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& flags = (*reply).flags;
+  auto& clocks = (*reply).clocks;
+  auto& maxclocks = (*reply).maxclocks;
+  auto& clock = (*reply).clock;
+  size_t clock_len = clock.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // flags
+  uint32_t tmp8;
+  Read(&tmp8, &buf);
+  flags = static_cast<XF86VidMode::ClockFlag>(tmp8);
+
+  // clocks
+  Read(&clocks, &buf);
+
+  // maxclocks
+  Read(&maxclocks, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // clock
+  clock.resize(((1) - (BitAnd(flags, 1))) * (clocks));
+  for (auto& clock_elem : clock) {
+    // clock_elem
+    Read(&clock_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86VidMode::SetClientVersion(
+    const XF86VidMode::SetClientVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major = request.major;
+  auto& minor = request.minor;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major
+  buf.Write(&major);
+
+  // minor
+  buf.Write(&minor);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::SetClientVersion",
+                                        false);
+}
+
+Future<void> XF86VidMode::SetClientVersion(const uint16_t& major,
+                                           const uint16_t& minor) {
+  return XF86VidMode::SetClientVersion(
+      XF86VidMode::SetClientVersionRequest{major, minor});
+}
+
+Future<void> XF86VidMode::SetGamma(
+    const XF86VidMode::SetGammaRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& red = request.red;
+  auto& green = request.green;
+  auto& blue = request.blue;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // red
+  buf.Write(&red);
+
+  // green
+  buf.Write(&green);
+
+  // blue
+  buf.Write(&blue);
+
+  // pad1
+  Pad(&buf, 12);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::SetGamma", false);
+}
+
+Future<void> XF86VidMode::SetGamma(const uint16_t& screen,
+                                   const uint32_t& red,
+                                   const uint32_t& green,
+                                   const uint32_t& blue) {
+  return XF86VidMode::SetGamma(
+      XF86VidMode::SetGammaRequest{screen, red, green, blue});
+}
+
+Future<XF86VidMode::GetGammaReply> XF86VidMode::GetGamma(
+    const XF86VidMode::GetGammaRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 26);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetGammaReply>(
+      &buf, "XF86VidMode::GetGamma", false);
+}
+
+Future<XF86VidMode::GetGammaReply> XF86VidMode::GetGamma(
+    const uint16_t& screen) {
+  return XF86VidMode::GetGamma(XF86VidMode::GetGammaRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetGammaReply> detail::ReadReply<
+    XF86VidMode::GetGammaReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetGammaReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& red = (*reply).red;
+  auto& green = (*reply).green;
+  auto& blue = (*reply).blue;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // red
+  Read(&red, &buf);
+
+  // green
+  Read(&green, &buf);
+
+  // blue
+  Read(&blue, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XF86VidMode::GetGammaRampReply> XF86VidMode::GetGammaRamp(
+    const XF86VidMode::GetGammaRampRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& size = request.size;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // size
+  buf.Write(&size);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetGammaRampReply>(
+      &buf, "XF86VidMode::GetGammaRamp", false);
+}
+
+Future<XF86VidMode::GetGammaRampReply> XF86VidMode::GetGammaRamp(
+    const uint16_t& screen,
+    const uint16_t& size) {
+  return XF86VidMode::GetGammaRamp(
+      XF86VidMode::GetGammaRampRequest{screen, size});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetGammaRampReply> detail::ReadReply<
+    XF86VidMode::GetGammaRampReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetGammaRampReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& size = (*reply).size;
+  auto& red = (*reply).red;
+  size_t red_len = red.size();
+  auto& green = (*reply).green;
+  size_t green_len = green.size();
+  auto& blue = (*reply).blue;
+  size_t blue_len = blue.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // size
+  Read(&size, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // red
+  red.resize(BitAnd((size) + (1), BitNot(1)));
+  for (auto& red_elem : red) {
+    // red_elem
+    Read(&red_elem, &buf);
+  }
+
+  // green
+  green.resize(BitAnd((size) + (1), BitNot(1)));
+  for (auto& green_elem : green) {
+    // green_elem
+    Read(&green_elem, &buf);
+  }
+
+  // blue
+  blue.resize(BitAnd((size) + (1), BitNot(1)));
+  for (auto& blue_elem : blue) {
+    // blue_elem
+    Read(&blue_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XF86VidMode::SetGammaRamp(
+    const XF86VidMode::SetGammaRampRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+  auto& size = request.size;
+  auto& red = request.red;
+  size_t red_len = red.size();
+  auto& green = request.green;
+  size_t green_len = green.size();
+  auto& blue = request.blue;
+  size_t blue_len = blue.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // size
+  buf.Write(&size);
+
+  // red
+  DCHECK_EQ(static_cast<size_t>(BitAnd((size) + (1), BitNot(1))), red.size());
+  for (auto& red_elem : red) {
+    // red_elem
+    buf.Write(&red_elem);
+  }
+
+  // green
+  DCHECK_EQ(static_cast<size_t>(BitAnd((size) + (1), BitNot(1))), green.size());
+  for (auto& green_elem : green) {
+    // green_elem
+    buf.Write(&green_elem);
+  }
+
+  // blue
+  DCHECK_EQ(static_cast<size_t>(BitAnd((size) + (1), BitNot(1))), blue.size());
+  for (auto& blue_elem : blue) {
+    // blue_elem
+    buf.Write(&blue_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XF86VidMode::SetGammaRamp",
+                                        false);
+}
+
+Future<void> XF86VidMode::SetGammaRamp(const uint16_t& screen,
+                                       const uint16_t& size,
+                                       const std::vector<uint16_t>& red,
+                                       const std::vector<uint16_t>& green,
+                                       const std::vector<uint16_t>& blue) {
+  return XF86VidMode::SetGammaRamp(
+      XF86VidMode::SetGammaRampRequest{screen, size, red, green, blue});
+}
+
+Future<XF86VidMode::GetGammaRampSizeReply> XF86VidMode::GetGammaRampSize(
+    const XF86VidMode::GetGammaRampSizeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetGammaRampSizeReply>(
+      &buf, "XF86VidMode::GetGammaRampSize", false);
+}
+
+Future<XF86VidMode::GetGammaRampSizeReply> XF86VidMode::GetGammaRampSize(
+    const uint16_t& screen) {
+  return XF86VidMode::GetGammaRampSize(
+      XF86VidMode::GetGammaRampSizeRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetGammaRampSizeReply> detail::ReadReply<
+    XF86VidMode::GetGammaRampSizeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetGammaRampSizeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& size = (*reply).size;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // size
+  Read(&size, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XF86VidMode::GetPermissionsReply> XF86VidMode::GetPermissions(
+    const XF86VidMode::GetPermissionsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 20;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // screen
+  buf.Write(&screen);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XF86VidMode::GetPermissionsReply>(
+      &buf, "XF86VidMode::GetPermissions", false);
+}
+
+Future<XF86VidMode::GetPermissionsReply> XF86VidMode::GetPermissions(
+    const uint16_t& screen) {
+  return XF86VidMode::GetPermissions(
+      XF86VidMode::GetPermissionsRequest{screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XF86VidMode::GetPermissionsReply> detail::ReadReply<
+    XF86VidMode::GetPermissionsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XF86VidMode::GetPermissionsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& permissions = (*reply).permissions;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // permissions
+  uint32_t tmp9;
+  Read(&tmp9, &buf);
+  permissions = static_cast<XF86VidMode::Permission>(tmp9);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xf86vidmode.h b/ui/gfx/x/generated_protos/xf86vidmode.h
new file mode 100644
index 0000000..fa451a2
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xf86vidmode.h
@@ -0,0 +1,683 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XF86VIDMODE_H_
+#define UI_GFX_X_GENERATED_PROTOS_XF86VIDMODE_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) XF86VidMode {
+ public:
+  static constexpr unsigned major_version = 2;
+  static constexpr unsigned minor_version = 2;
+
+  XF86VidMode(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Syncrange : uint32_t {};
+
+  enum class DotClock : uint32_t {};
+
+  enum class ModeFlag : int {
+    Positive_HSync = 1 << 0,
+    Negative_HSync = 1 << 1,
+    Positive_VSync = 1 << 2,
+    Negative_VSync = 1 << 3,
+    Interlace = 1 << 4,
+    Composite_Sync = 1 << 5,
+    Positive_CSync = 1 << 6,
+    Negative_CSync = 1 << 7,
+    HSkew = 1 << 8,
+    Broadcast = 1 << 9,
+    Pixmux = 1 << 10,
+    Double_Clock = 1 << 11,
+    Half_Clock = 1 << 12,
+  };
+
+  enum class ClockFlag : int {
+    Programable = 1 << 0,
+  };
+
+  enum class Permission : int {
+    Read = 1 << 0,
+    Write = 1 << 1,
+  };
+
+  struct ModeInfo {
+    DotClock dotclock{};
+    uint16_t hdisplay{};
+    uint16_t hsyncstart{};
+    uint16_t hsyncend{};
+    uint16_t htotal{};
+    uint32_t hskew{};
+    uint16_t vdisplay{};
+    uint16_t vsyncstart{};
+    uint16_t vsyncend{};
+    uint16_t vtotal{};
+    ModeFlag flags{};
+    uint32_t privsize{};
+  };
+
+  struct BadClockError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadHTimingsError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadVTimingsError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct ModeUnsuitableError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct ExtensionDisabledError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct ClientNotLocalError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct ZoomLockedError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct QueryVersionRequest {};
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion();
+
+  struct GetModeLineRequest {
+    uint16_t screen{};
+  };
+
+  struct GetModeLineReply {
+    uint16_t sequence{};
+    DotClock dotclock{};
+    uint16_t hdisplay{};
+    uint16_t hsyncstart{};
+    uint16_t hsyncend{};
+    uint16_t htotal{};
+    uint16_t hskew{};
+    uint16_t vdisplay{};
+    uint16_t vsyncstart{};
+    uint16_t vsyncend{};
+    uint16_t vtotal{};
+    ModeFlag flags{};
+    std::vector<uint8_t> c_private{};
+  };
+
+  using GetModeLineResponse = Response<GetModeLineReply>;
+
+  Future<GetModeLineReply> GetModeLine(const GetModeLineRequest& request);
+
+  Future<GetModeLineReply> GetModeLine(const uint16_t& screen = {});
+
+  struct ModModeLineRequest {
+    uint32_t screen{};
+    uint16_t hdisplay{};
+    uint16_t hsyncstart{};
+    uint16_t hsyncend{};
+    uint16_t htotal{};
+    uint16_t hskew{};
+    uint16_t vdisplay{};
+    uint16_t vsyncstart{};
+    uint16_t vsyncend{};
+    uint16_t vtotal{};
+    ModeFlag flags{};
+    std::vector<uint8_t> c_private{};
+  };
+
+  using ModModeLineResponse = Response<void>;
+
+  Future<void> ModModeLine(const ModModeLineRequest& request);
+
+  Future<void> ModModeLine(const uint32_t& screen = {},
+                           const uint16_t& hdisplay = {},
+                           const uint16_t& hsyncstart = {},
+                           const uint16_t& hsyncend = {},
+                           const uint16_t& htotal = {},
+                           const uint16_t& hskew = {},
+                           const uint16_t& vdisplay = {},
+                           const uint16_t& vsyncstart = {},
+                           const uint16_t& vsyncend = {},
+                           const uint16_t& vtotal = {},
+                           const ModeFlag& flags = {},
+                           const std::vector<uint8_t>& c_private = {});
+
+  struct SwitchModeRequest {
+    uint16_t screen{};
+    uint16_t zoom{};
+  };
+
+  using SwitchModeResponse = Response<void>;
+
+  Future<void> SwitchMode(const SwitchModeRequest& request);
+
+  Future<void> SwitchMode(const uint16_t& screen = {},
+                          const uint16_t& zoom = {});
+
+  struct GetMonitorRequest {
+    uint16_t screen{};
+  };
+
+  struct GetMonitorReply {
+    uint16_t sequence{};
+    std::vector<Syncrange> hsync{};
+    std::vector<Syncrange> vsync{};
+    std::string vendor{};
+    scoped_refptr<base::RefCountedMemory> alignment_pad{};
+    std::string model{};
+  };
+
+  using GetMonitorResponse = Response<GetMonitorReply>;
+
+  Future<GetMonitorReply> GetMonitor(const GetMonitorRequest& request);
+
+  Future<GetMonitorReply> GetMonitor(const uint16_t& screen = {});
+
+  struct LockModeSwitchRequest {
+    uint16_t screen{};
+    uint16_t lock{};
+  };
+
+  using LockModeSwitchResponse = Response<void>;
+
+  Future<void> LockModeSwitch(const LockModeSwitchRequest& request);
+
+  Future<void> LockModeSwitch(const uint16_t& screen = {},
+                              const uint16_t& lock = {});
+
+  struct GetAllModeLinesRequest {
+    uint16_t screen{};
+  };
+
+  struct GetAllModeLinesReply {
+    uint16_t sequence{};
+    std::vector<ModeInfo> modeinfo{};
+  };
+
+  using GetAllModeLinesResponse = Response<GetAllModeLinesReply>;
+
+  Future<GetAllModeLinesReply> GetAllModeLines(
+      const GetAllModeLinesRequest& request);
+
+  Future<GetAllModeLinesReply> GetAllModeLines(const uint16_t& screen = {});
+
+  struct AddModeLineRequest {
+    uint32_t screen{};
+    DotClock dotclock{};
+    uint16_t hdisplay{};
+    uint16_t hsyncstart{};
+    uint16_t hsyncend{};
+    uint16_t htotal{};
+    uint16_t hskew{};
+    uint16_t vdisplay{};
+    uint16_t vsyncstart{};
+    uint16_t vsyncend{};
+    uint16_t vtotal{};
+    ModeFlag flags{};
+    DotClock after_dotclock{};
+    uint16_t after_hdisplay{};
+    uint16_t after_hsyncstart{};
+    uint16_t after_hsyncend{};
+    uint16_t after_htotal{};
+    uint16_t after_hskew{};
+    uint16_t after_vdisplay{};
+    uint16_t after_vsyncstart{};
+    uint16_t after_vsyncend{};
+    uint16_t after_vtotal{};
+    ModeFlag after_flags{};
+    std::vector<uint8_t> c_private{};
+  };
+
+  using AddModeLineResponse = Response<void>;
+
+  Future<void> AddModeLine(const AddModeLineRequest& request);
+
+  Future<void> AddModeLine(const uint32_t& screen = {},
+                           const DotClock& dotclock = {},
+                           const uint16_t& hdisplay = {},
+                           const uint16_t& hsyncstart = {},
+                           const uint16_t& hsyncend = {},
+                           const uint16_t& htotal = {},
+                           const uint16_t& hskew = {},
+                           const uint16_t& vdisplay = {},
+                           const uint16_t& vsyncstart = {},
+                           const uint16_t& vsyncend = {},
+                           const uint16_t& vtotal = {},
+                           const ModeFlag& flags = {},
+                           const DotClock& after_dotclock = {},
+                           const uint16_t& after_hdisplay = {},
+                           const uint16_t& after_hsyncstart = {},
+                           const uint16_t& after_hsyncend = {},
+                           const uint16_t& after_htotal = {},
+                           const uint16_t& after_hskew = {},
+                           const uint16_t& after_vdisplay = {},
+                           const uint16_t& after_vsyncstart = {},
+                           const uint16_t& after_vsyncend = {},
+                           const uint16_t& after_vtotal = {},
+                           const ModeFlag& after_flags = {},
+                           const std::vector<uint8_t>& c_private = {});
+
+  struct DeleteModeLineRequest {
+    uint32_t screen{};
+    DotClock dotclock{};
+    uint16_t hdisplay{};
+    uint16_t hsyncstart{};
+    uint16_t hsyncend{};
+    uint16_t htotal{};
+    uint16_t hskew{};
+    uint16_t vdisplay{};
+    uint16_t vsyncstart{};
+    uint16_t vsyncend{};
+    uint16_t vtotal{};
+    ModeFlag flags{};
+    std::vector<uint8_t> c_private{};
+  };
+
+  using DeleteModeLineResponse = Response<void>;
+
+  Future<void> DeleteModeLine(const DeleteModeLineRequest& request);
+
+  Future<void> DeleteModeLine(const uint32_t& screen = {},
+                              const DotClock& dotclock = {},
+                              const uint16_t& hdisplay = {},
+                              const uint16_t& hsyncstart = {},
+                              const uint16_t& hsyncend = {},
+                              const uint16_t& htotal = {},
+                              const uint16_t& hskew = {},
+                              const uint16_t& vdisplay = {},
+                              const uint16_t& vsyncstart = {},
+                              const uint16_t& vsyncend = {},
+                              const uint16_t& vtotal = {},
+                              const ModeFlag& flags = {},
+                              const std::vector<uint8_t>& c_private = {});
+
+  struct ValidateModeLineRequest {
+    uint32_t screen{};
+    DotClock dotclock{};
+    uint16_t hdisplay{};
+    uint16_t hsyncstart{};
+    uint16_t hsyncend{};
+    uint16_t htotal{};
+    uint16_t hskew{};
+    uint16_t vdisplay{};
+    uint16_t vsyncstart{};
+    uint16_t vsyncend{};
+    uint16_t vtotal{};
+    ModeFlag flags{};
+    std::vector<uint8_t> c_private{};
+  };
+
+  struct ValidateModeLineReply {
+    uint16_t sequence{};
+    uint32_t status{};
+  };
+
+  using ValidateModeLineResponse = Response<ValidateModeLineReply>;
+
+  Future<ValidateModeLineReply> ValidateModeLine(
+      const ValidateModeLineRequest& request);
+
+  Future<ValidateModeLineReply> ValidateModeLine(
+      const uint32_t& screen = {},
+      const DotClock& dotclock = {},
+      const uint16_t& hdisplay = {},
+      const uint16_t& hsyncstart = {},
+      const uint16_t& hsyncend = {},
+      const uint16_t& htotal = {},
+      const uint16_t& hskew = {},
+      const uint16_t& vdisplay = {},
+      const uint16_t& vsyncstart = {},
+      const uint16_t& vsyncend = {},
+      const uint16_t& vtotal = {},
+      const ModeFlag& flags = {},
+      const std::vector<uint8_t>& c_private = {});
+
+  struct SwitchToModeRequest {
+    uint32_t screen{};
+    DotClock dotclock{};
+    uint16_t hdisplay{};
+    uint16_t hsyncstart{};
+    uint16_t hsyncend{};
+    uint16_t htotal{};
+    uint16_t hskew{};
+    uint16_t vdisplay{};
+    uint16_t vsyncstart{};
+    uint16_t vsyncend{};
+    uint16_t vtotal{};
+    ModeFlag flags{};
+    std::vector<uint8_t> c_private{};
+  };
+
+  using SwitchToModeResponse = Response<void>;
+
+  Future<void> SwitchToMode(const SwitchToModeRequest& request);
+
+  Future<void> SwitchToMode(const uint32_t& screen = {},
+                            const DotClock& dotclock = {},
+                            const uint16_t& hdisplay = {},
+                            const uint16_t& hsyncstart = {},
+                            const uint16_t& hsyncend = {},
+                            const uint16_t& htotal = {},
+                            const uint16_t& hskew = {},
+                            const uint16_t& vdisplay = {},
+                            const uint16_t& vsyncstart = {},
+                            const uint16_t& vsyncend = {},
+                            const uint16_t& vtotal = {},
+                            const ModeFlag& flags = {},
+                            const std::vector<uint8_t>& c_private = {});
+
+  struct GetViewPortRequest {
+    uint16_t screen{};
+  };
+
+  struct GetViewPortReply {
+    uint16_t sequence{};
+    uint32_t x{};
+    uint32_t y{};
+  };
+
+  using GetViewPortResponse = Response<GetViewPortReply>;
+
+  Future<GetViewPortReply> GetViewPort(const GetViewPortRequest& request);
+
+  Future<GetViewPortReply> GetViewPort(const uint16_t& screen = {});
+
+  struct SetViewPortRequest {
+    uint16_t screen{};
+    uint32_t x{};
+    uint32_t y{};
+  };
+
+  using SetViewPortResponse = Response<void>;
+
+  Future<void> SetViewPort(const SetViewPortRequest& request);
+
+  Future<void> SetViewPort(const uint16_t& screen = {},
+                           const uint32_t& x = {},
+                           const uint32_t& y = {});
+
+  struct GetDotClocksRequest {
+    uint16_t screen{};
+  };
+
+  struct GetDotClocksReply {
+    uint16_t sequence{};
+    ClockFlag flags{};
+    uint32_t clocks{};
+    uint32_t maxclocks{};
+    std::vector<uint32_t> clock{};
+  };
+
+  using GetDotClocksResponse = Response<GetDotClocksReply>;
+
+  Future<GetDotClocksReply> GetDotClocks(const GetDotClocksRequest& request);
+
+  Future<GetDotClocksReply> GetDotClocks(const uint16_t& screen = {});
+
+  struct SetClientVersionRequest {
+    uint16_t major{};
+    uint16_t minor{};
+  };
+
+  using SetClientVersionResponse = Response<void>;
+
+  Future<void> SetClientVersion(const SetClientVersionRequest& request);
+
+  Future<void> SetClientVersion(const uint16_t& major = {},
+                                const uint16_t& minor = {});
+
+  struct SetGammaRequest {
+    uint16_t screen{};
+    uint32_t red{};
+    uint32_t green{};
+    uint32_t blue{};
+  };
+
+  using SetGammaResponse = Response<void>;
+
+  Future<void> SetGamma(const SetGammaRequest& request);
+
+  Future<void> SetGamma(const uint16_t& screen = {},
+                        const uint32_t& red = {},
+                        const uint32_t& green = {},
+                        const uint32_t& blue = {});
+
+  struct GetGammaRequest {
+    uint16_t screen{};
+  };
+
+  struct GetGammaReply {
+    uint16_t sequence{};
+    uint32_t red{};
+    uint32_t green{};
+    uint32_t blue{};
+  };
+
+  using GetGammaResponse = Response<GetGammaReply>;
+
+  Future<GetGammaReply> GetGamma(const GetGammaRequest& request);
+
+  Future<GetGammaReply> GetGamma(const uint16_t& screen = {});
+
+  struct GetGammaRampRequest {
+    uint16_t screen{};
+    uint16_t size{};
+  };
+
+  struct GetGammaRampReply {
+    uint16_t sequence{};
+    uint16_t size{};
+    std::vector<uint16_t> red{};
+    std::vector<uint16_t> green{};
+    std::vector<uint16_t> blue{};
+  };
+
+  using GetGammaRampResponse = Response<GetGammaRampReply>;
+
+  Future<GetGammaRampReply> GetGammaRamp(const GetGammaRampRequest& request);
+
+  Future<GetGammaRampReply> GetGammaRamp(const uint16_t& screen = {},
+                                         const uint16_t& size = {});
+
+  struct SetGammaRampRequest {
+    uint16_t screen{};
+    uint16_t size{};
+    std::vector<uint16_t> red{};
+    std::vector<uint16_t> green{};
+    std::vector<uint16_t> blue{};
+  };
+
+  using SetGammaRampResponse = Response<void>;
+
+  Future<void> SetGammaRamp(const SetGammaRampRequest& request);
+
+  Future<void> SetGammaRamp(const uint16_t& screen = {},
+                            const uint16_t& size = {},
+                            const std::vector<uint16_t>& red = {},
+                            const std::vector<uint16_t>& green = {},
+                            const std::vector<uint16_t>& blue = {});
+
+  struct GetGammaRampSizeRequest {
+    uint16_t screen{};
+  };
+
+  struct GetGammaRampSizeReply {
+    uint16_t sequence{};
+    uint16_t size{};
+  };
+
+  using GetGammaRampSizeResponse = Response<GetGammaRampSizeReply>;
+
+  Future<GetGammaRampSizeReply> GetGammaRampSize(
+      const GetGammaRampSizeRequest& request);
+
+  Future<GetGammaRampSizeReply> GetGammaRampSize(const uint16_t& screen = {});
+
+  struct GetPermissionsRequest {
+    uint16_t screen{};
+  };
+
+  struct GetPermissionsReply {
+    uint16_t sequence{};
+    Permission permissions{};
+  };
+
+  using GetPermissionsResponse = Response<GetPermissionsReply>;
+
+  Future<GetPermissionsReply> GetPermissions(
+      const GetPermissionsRequest& request);
+
+  Future<GetPermissionsReply> GetPermissions(const uint16_t& screen = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::XF86VidMode::ModeFlag operator|(
+    x11::XF86VidMode::ModeFlag l,
+    x11::XF86VidMode::ModeFlag r) {
+  using T = std::underlying_type_t<x11::XF86VidMode::ModeFlag>;
+  return static_cast<x11::XF86VidMode::ModeFlag>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::XF86VidMode::ModeFlag operator&(
+    x11::XF86VidMode::ModeFlag l,
+    x11::XF86VidMode::ModeFlag r) {
+  using T = std::underlying_type_t<x11::XF86VidMode::ModeFlag>;
+  return static_cast<x11::XF86VidMode::ModeFlag>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::XF86VidMode::ClockFlag operator|(
+    x11::XF86VidMode::ClockFlag l,
+    x11::XF86VidMode::ClockFlag r) {
+  using T = std::underlying_type_t<x11::XF86VidMode::ClockFlag>;
+  return static_cast<x11::XF86VidMode::ClockFlag>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::XF86VidMode::ClockFlag operator&(
+    x11::XF86VidMode::ClockFlag l,
+    x11::XF86VidMode::ClockFlag r) {
+  using T = std::underlying_type_t<x11::XF86VidMode::ClockFlag>;
+  return static_cast<x11::XF86VidMode::ClockFlag>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::XF86VidMode::Permission operator|(
+    x11::XF86VidMode::Permission l,
+    x11::XF86VidMode::Permission r) {
+  using T = std::underlying_type_t<x11::XF86VidMode::Permission>;
+  return static_cast<x11::XF86VidMode::Permission>(static_cast<T>(l) |
+                                                   static_cast<T>(r));
+}
+
+inline constexpr x11::XF86VidMode::Permission operator&(
+    x11::XF86VidMode::Permission l,
+    x11::XF86VidMode::Permission r) {
+  using T = std::underlying_type_t<x11::XF86VidMode::Permission>;
+  return static_cast<x11::XF86VidMode::Permission>(static_cast<T>(l) &
+                                                   static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XF86VIDMODE_H_
diff --git a/ui/gfx/x/generated_protos/xfixes.cc b/ui/gfx/x/generated_protos/xfixes.cc
new file mode 100644
index 0000000..88cc351
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xfixes.cc
@@ -0,0 +1,1987 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xfixes.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+XFixes::XFixes(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<XFixes::SelectionNotifyEvent>(
+    XFixes::SelectionNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& subtype = (*event_).subtype;
+  auto& sequence = (*event_).sequence;
+  auto& window = (*event_).window;
+  auto& owner = (*event_).owner;
+  auto& selection = (*event_).selection;
+  auto& timestamp = (*event_).timestamp;
+  auto& selection_timestamp = (*event_).selection_timestamp;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // subtype
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  subtype = static_cast<XFixes::SelectionEvent>(tmp0);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // owner
+  Read(&owner, &buf);
+
+  // selection
+  Read(&selection, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // selection_timestamp
+  Read(&selection_timestamp, &buf);
+
+  // pad0
+  Pad(&buf, 8);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<XFixes::CursorNotifyEvent>(XFixes::CursorNotifyEvent* event_,
+                                          ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& subtype = (*event_).subtype;
+  auto& sequence = (*event_).sequence;
+  auto& window = (*event_).window;
+  auto& cursor_serial = (*event_).cursor_serial;
+  auto& timestamp = (*event_).timestamp;
+  auto& name = (*event_).name;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // subtype
+  uint8_t tmp1;
+  Read(&tmp1, &buf);
+  subtype = static_cast<XFixes::CursorNotify>(tmp1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // cursor_serial
+  Read(&cursor_serial, &buf);
+
+  // timestamp
+  Read(&timestamp, &buf);
+
+  // name
+  Read(&name, &buf);
+
+  // pad0
+  Pad(&buf, 12);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+std::string XFixes::BadRegionError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XFixes::BadRegionError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XFixes::BadRegionError>(XFixes::BadRegionError* error_,
+                                       ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+Future<XFixes::QueryVersionReply> XFixes::QueryVersion(
+    const XFixes::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major_version = request.client_major_version;
+  auto& client_minor_version = request.client_minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major_version
+  buf.Write(&client_major_version);
+
+  // client_minor_version
+  buf.Write(&client_minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XFixes::QueryVersionReply>(
+      &buf, "XFixes::QueryVersion", false);
+}
+
+Future<XFixes::QueryVersionReply> XFixes::QueryVersion(
+    const uint32_t& client_major_version,
+    const uint32_t& client_minor_version) {
+  return XFixes::QueryVersion(
+      XFixes::QueryVersionRequest{client_major_version, client_minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XFixes::QueryVersionReply> detail::ReadReply<
+    XFixes::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XFixes::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XFixes::ChangeSaveSet(
+    const XFixes::ChangeSaveSetRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+  auto& target = request.target;
+  auto& map = request.map;
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // mode
+  uint8_t tmp2;
+  tmp2 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp2);
+
+  // target
+  uint8_t tmp3;
+  tmp3 = static_cast<uint8_t>(target);
+  buf.Write(&tmp3);
+
+  // map
+  uint8_t tmp4;
+  tmp4 = static_cast<uint8_t>(map);
+  buf.Write(&tmp4);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::ChangeSaveSet", false);
+}
+
+Future<void> XFixes::ChangeSaveSet(const SaveSetMode& mode,
+                                   const SaveSetTarget& target,
+                                   const SaveSetMapping& map,
+                                   const Window& window) {
+  return XFixes::ChangeSaveSet(
+      XFixes::ChangeSaveSetRequest{mode, target, map, window});
+}
+
+Future<void> XFixes::SelectSelectionInput(
+    const XFixes::SelectSelectionInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& selection = request.selection;
+  auto& event_mask = request.event_mask;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // selection
+  buf.Write(&selection);
+
+  // event_mask
+  uint32_t tmp5;
+  tmp5 = static_cast<uint32_t>(event_mask);
+  buf.Write(&tmp5);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::SelectSelectionInput",
+                                        false);
+}
+
+Future<void> XFixes::SelectSelectionInput(
+    const Window& window,
+    const Atom& selection,
+    const SelectionEventMask& event_mask) {
+  return XFixes::SelectSelectionInput(
+      XFixes::SelectSelectionInputRequest{window, selection, event_mask});
+}
+
+Future<void> XFixes::SelectCursorInput(
+    const XFixes::SelectCursorInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& event_mask = request.event_mask;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // event_mask
+  uint32_t tmp6;
+  tmp6 = static_cast<uint32_t>(event_mask);
+  buf.Write(&tmp6);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::SelectCursorInput",
+                                        false);
+}
+
+Future<void> XFixes::SelectCursorInput(const Window& window,
+                                       const CursorNotifyMask& event_mask) {
+  return XFixes::SelectCursorInput(
+      XFixes::SelectCursorInputRequest{window, event_mask});
+}
+
+Future<XFixes::GetCursorImageReply> XFixes::GetCursorImage(
+    const XFixes::GetCursorImageRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XFixes::GetCursorImageReply>(
+      &buf, "XFixes::GetCursorImage", false);
+}
+
+Future<XFixes::GetCursorImageReply> XFixes::GetCursorImage() {
+  return XFixes::GetCursorImage(XFixes::GetCursorImageRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XFixes::GetCursorImageReply> detail::ReadReply<
+    XFixes::GetCursorImageReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XFixes::GetCursorImageReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& x = (*reply).x;
+  auto& y = (*reply).y;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& xhot = (*reply).xhot;
+  auto& yhot = (*reply).yhot;
+  auto& cursor_serial = (*reply).cursor_serial;
+  auto& cursor_image = (*reply).cursor_image;
+  size_t cursor_image_len = cursor_image.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // xhot
+  Read(&xhot, &buf);
+
+  // yhot
+  Read(&yhot, &buf);
+
+  // cursor_serial
+  Read(&cursor_serial, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // cursor_image
+  cursor_image.resize((width) * (height));
+  for (auto& cursor_image_elem : cursor_image) {
+    // cursor_image_elem
+    Read(&cursor_image_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XFixes::CreateRegion(const XFixes::CreateRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+  auto& rectangles = request.rectangles;
+  size_t rectangles_len = rectangles.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  // rectangles
+  DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size());
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::CreateRegion", false);
+}
+
+Future<void> XFixes::CreateRegion(const Region& region,
+                                  const std::vector<Rectangle>& rectangles) {
+  return XFixes::CreateRegion(XFixes::CreateRegionRequest{region, rectangles});
+}
+
+Future<void> XFixes::CreateRegionFromBitmap(
+    const XFixes::CreateRegionFromBitmapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+  auto& bitmap = request.bitmap;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  // bitmap
+  buf.Write(&bitmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::CreateRegionFromBitmap",
+                                        false);
+}
+
+Future<void> XFixes::CreateRegionFromBitmap(const Region& region,
+                                            const Pixmap& bitmap) {
+  return XFixes::CreateRegionFromBitmap(
+      XFixes::CreateRegionFromBitmapRequest{region, bitmap});
+}
+
+Future<void> XFixes::CreateRegionFromWindow(
+    const XFixes::CreateRegionFromWindowRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+  auto& window = request.window;
+  auto& kind = request.kind;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  // window
+  buf.Write(&window);
+
+  // kind
+  uint8_t tmp7;
+  tmp7 = static_cast<uint8_t>(kind);
+  buf.Write(&tmp7);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::CreateRegionFromWindow",
+                                        false);
+}
+
+Future<void> XFixes::CreateRegionFromWindow(const Region& region,
+                                            const Window& window,
+                                            const Shape::Sk& kind) {
+  return XFixes::CreateRegionFromWindow(
+      XFixes::CreateRegionFromWindowRequest{region, window, kind});
+}
+
+Future<void> XFixes::CreateRegionFromGC(
+    const XFixes::CreateRegionFromGCRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+  auto& gc = request.gc;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  // gc
+  buf.Write(&gc);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::CreateRegionFromGC",
+                                        false);
+}
+
+Future<void> XFixes::CreateRegionFromGC(const Region& region,
+                                        const GraphicsContext& gc) {
+  return XFixes::CreateRegionFromGC(
+      XFixes::CreateRegionFromGCRequest{region, gc});
+}
+
+Future<void> XFixes::CreateRegionFromPicture(
+    const XFixes::CreateRegionFromPictureRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+  auto& picture = request.picture;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  // picture
+  buf.Write(&picture);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::CreateRegionFromPicture",
+                                        false);
+}
+
+Future<void> XFixes::CreateRegionFromPicture(const Region& region,
+                                             const Render::Picture& picture) {
+  return XFixes::CreateRegionFromPicture(
+      XFixes::CreateRegionFromPictureRequest{region, picture});
+}
+
+Future<void> XFixes::DestroyRegion(
+    const XFixes::DestroyRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::DestroyRegion", false);
+}
+
+Future<void> XFixes::DestroyRegion(const Region& region) {
+  return XFixes::DestroyRegion(XFixes::DestroyRegionRequest{region});
+}
+
+Future<void> XFixes::SetRegion(const XFixes::SetRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+  auto& rectangles = request.rectangles;
+  size_t rectangles_len = rectangles.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  // rectangles
+  DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size());
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::SetRegion", false);
+}
+
+Future<void> XFixes::SetRegion(const Region& region,
+                               const std::vector<Rectangle>& rectangles) {
+  return XFixes::SetRegion(XFixes::SetRegionRequest{region, rectangles});
+}
+
+Future<void> XFixes::CopyRegion(const XFixes::CopyRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& source = request.source;
+  auto& destination = request.destination;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // source
+  buf.Write(&source);
+
+  // destination
+  buf.Write(&destination);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::CopyRegion", false);
+}
+
+Future<void> XFixes::CopyRegion(const Region& source,
+                                const Region& destination) {
+  return XFixes::CopyRegion(XFixes::CopyRegionRequest{source, destination});
+}
+
+Future<void> XFixes::UnionRegion(const XFixes::UnionRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& source1 = request.source1;
+  auto& source2 = request.source2;
+  auto& destination = request.destination;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // source1
+  buf.Write(&source1);
+
+  // source2
+  buf.Write(&source2);
+
+  // destination
+  buf.Write(&destination);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::UnionRegion", false);
+}
+
+Future<void> XFixes::UnionRegion(const Region& source1,
+                                 const Region& source2,
+                                 const Region& destination) {
+  return XFixes::UnionRegion(
+      XFixes::UnionRegionRequest{source1, source2, destination});
+}
+
+Future<void> XFixes::IntersectRegion(
+    const XFixes::IntersectRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& source1 = request.source1;
+  auto& source2 = request.source2;
+  auto& destination = request.destination;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // source1
+  buf.Write(&source1);
+
+  // source2
+  buf.Write(&source2);
+
+  // destination
+  buf.Write(&destination);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::IntersectRegion", false);
+}
+
+Future<void> XFixes::IntersectRegion(const Region& source1,
+                                     const Region& source2,
+                                     const Region& destination) {
+  return XFixes::IntersectRegion(
+      XFixes::IntersectRegionRequest{source1, source2, destination});
+}
+
+Future<void> XFixes::SubtractRegion(
+    const XFixes::SubtractRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& source1 = request.source1;
+  auto& source2 = request.source2;
+  auto& destination = request.destination;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // source1
+  buf.Write(&source1);
+
+  // source2
+  buf.Write(&source2);
+
+  // destination
+  buf.Write(&destination);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::SubtractRegion", false);
+}
+
+Future<void> XFixes::SubtractRegion(const Region& source1,
+                                    const Region& source2,
+                                    const Region& destination) {
+  return XFixes::SubtractRegion(
+      XFixes::SubtractRegionRequest{source1, source2, destination});
+}
+
+Future<void> XFixes::InvertRegion(const XFixes::InvertRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& source = request.source;
+  auto& bounds = request.bounds;
+  auto& destination = request.destination;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // source
+  buf.Write(&source);
+
+  // bounds
+  {
+    auto& x = bounds.x;
+    auto& y = bounds.y;
+    auto& width = bounds.width;
+    auto& height = bounds.height;
+
+    // x
+    buf.Write(&x);
+
+    // y
+    buf.Write(&y);
+
+    // width
+    buf.Write(&width);
+
+    // height
+    buf.Write(&height);
+  }
+
+  // destination
+  buf.Write(&destination);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::InvertRegion", false);
+}
+
+Future<void> XFixes::InvertRegion(const Region& source,
+                                  const Rectangle& bounds,
+                                  const Region& destination) {
+  return XFixes::InvertRegion(
+      XFixes::InvertRegionRequest{source, bounds, destination});
+}
+
+Future<void> XFixes::TranslateRegion(
+    const XFixes::TranslateRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+  auto& dx = request.dx;
+  auto& dy = request.dy;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  // dx
+  buf.Write(&dx);
+
+  // dy
+  buf.Write(&dy);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::TranslateRegion", false);
+}
+
+Future<void> XFixes::TranslateRegion(const Region& region,
+                                     const int16_t& dx,
+                                     const int16_t& dy) {
+  return XFixes::TranslateRegion(
+      XFixes::TranslateRegionRequest{region, dx, dy});
+}
+
+Future<void> XFixes::RegionExtents(
+    const XFixes::RegionExtentsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& source = request.source;
+  auto& destination = request.destination;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // source
+  buf.Write(&source);
+
+  // destination
+  buf.Write(&destination);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::RegionExtents", false);
+}
+
+Future<void> XFixes::RegionExtents(const Region& source,
+                                   const Region& destination) {
+  return XFixes::RegionExtents(
+      XFixes::RegionExtentsRequest{source, destination});
+}
+
+Future<XFixes::FetchRegionReply> XFixes::FetchRegion(
+    const XFixes::FetchRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& region = request.region;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // region
+  buf.Write(&region);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XFixes::FetchRegionReply>(
+      &buf, "XFixes::FetchRegion", false);
+}
+
+Future<XFixes::FetchRegionReply> XFixes::FetchRegion(const Region& region) {
+  return XFixes::FetchRegion(XFixes::FetchRegionRequest{region});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XFixes::FetchRegionReply> detail::ReadReply<
+    XFixes::FetchRegionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XFixes::FetchRegionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& extents = (*reply).extents;
+  auto& rectangles = (*reply).rectangles;
+  size_t rectangles_len = rectangles.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // extents
+  {
+    auto& x = extents.x;
+    auto& y = extents.y;
+    auto& width = extents.width;
+    auto& height = extents.height;
+
+    // x
+    Read(&x, &buf);
+
+    // y
+    Read(&y, &buf);
+
+    // width
+    Read(&width, &buf);
+
+    // height
+    Read(&height, &buf);
+  }
+
+  // pad1
+  Pad(&buf, 16);
+
+  // rectangles
+  rectangles.resize((length) / (2));
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      Read(&x, &buf);
+
+      // y
+      Read(&y, &buf);
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XFixes::SetGCClipRegion(
+    const XFixes::SetGCClipRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& gc = request.gc;
+  auto& region = request.region;
+  auto& x_origin = request.x_origin;
+  auto& y_origin = request.y_origin;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 20;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // gc
+  buf.Write(&gc);
+
+  // region
+  buf.Write(&region);
+
+  // x_origin
+  buf.Write(&x_origin);
+
+  // y_origin
+  buf.Write(&y_origin);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::SetGCClipRegion", false);
+}
+
+Future<void> XFixes::SetGCClipRegion(const GraphicsContext& gc,
+                                     const Region& region,
+                                     const int16_t& x_origin,
+                                     const int16_t& y_origin) {
+  return XFixes::SetGCClipRegion(
+      XFixes::SetGCClipRegionRequest{gc, region, x_origin, y_origin});
+}
+
+Future<void> XFixes::SetWindowShapeRegion(
+    const XFixes::SetWindowShapeRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& dest = request.dest;
+  auto& dest_kind = request.dest_kind;
+  auto& x_offset = request.x_offset;
+  auto& y_offset = request.y_offset;
+  auto& region = request.region;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 21;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // dest
+  buf.Write(&dest);
+
+  // dest_kind
+  uint8_t tmp8;
+  tmp8 = static_cast<uint8_t>(dest_kind);
+  buf.Write(&tmp8);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // x_offset
+  buf.Write(&x_offset);
+
+  // y_offset
+  buf.Write(&y_offset);
+
+  // region
+  buf.Write(&region);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::SetWindowShapeRegion",
+                                        false);
+}
+
+Future<void> XFixes::SetWindowShapeRegion(const Window& dest,
+                                          const Shape::Sk& dest_kind,
+                                          const int16_t& x_offset,
+                                          const int16_t& y_offset,
+                                          const Region& region) {
+  return XFixes::SetWindowShapeRegion(XFixes::SetWindowShapeRegionRequest{
+      dest, dest_kind, x_offset, y_offset, region});
+}
+
+Future<void> XFixes::SetPictureClipRegion(
+    const XFixes::SetPictureClipRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& picture = request.picture;
+  auto& region = request.region;
+  auto& x_origin = request.x_origin;
+  auto& y_origin = request.y_origin;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 22;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // picture
+  buf.Write(&picture);
+
+  // region
+  buf.Write(&region);
+
+  // x_origin
+  buf.Write(&x_origin);
+
+  // y_origin
+  buf.Write(&y_origin);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::SetPictureClipRegion",
+                                        false);
+}
+
+Future<void> XFixes::SetPictureClipRegion(const Render::Picture& picture,
+                                          const Region& region,
+                                          const int16_t& x_origin,
+                                          const int16_t& y_origin) {
+  return XFixes::SetPictureClipRegion(
+      XFixes::SetPictureClipRegionRequest{picture, region, x_origin, y_origin});
+}
+
+Future<void> XFixes::SetCursorName(
+    const XFixes::SetCursorNameRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cursor = request.cursor;
+  uint16_t nbytes{};
+  auto& name = request.name;
+  size_t name_len = name.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 23;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cursor
+  buf.Write(&cursor);
+
+  // nbytes
+  nbytes = name.size();
+  buf.Write(&nbytes);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(nbytes), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::SetCursorName", false);
+}
+
+Future<void> XFixes::SetCursorName(const Cursor& cursor,
+                                   const std::string& name) {
+  return XFixes::SetCursorName(XFixes::SetCursorNameRequest{cursor, name});
+}
+
+Future<XFixes::GetCursorNameReply> XFixes::GetCursorName(
+    const XFixes::GetCursorNameRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cursor = request.cursor;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 24;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cursor
+  buf.Write(&cursor);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XFixes::GetCursorNameReply>(
+      &buf, "XFixes::GetCursorName", false);
+}
+
+Future<XFixes::GetCursorNameReply> XFixes::GetCursorName(const Cursor& cursor) {
+  return XFixes::GetCursorName(XFixes::GetCursorNameRequest{cursor});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XFixes::GetCursorNameReply> detail::ReadReply<
+    XFixes::GetCursorNameReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XFixes::GetCursorNameReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& atom = (*reply).atom;
+  uint16_t nbytes{};
+  auto& name = (*reply).name;
+  size_t name_len = name.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // atom
+  Read(&atom, &buf);
+
+  // nbytes
+  Read(&nbytes, &buf);
+
+  // pad1
+  Pad(&buf, 18);
+
+  // name
+  name.resize(nbytes);
+  for (auto& name_elem : name) {
+    // name_elem
+    Read(&name_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XFixes::GetCursorImageAndNameReply> XFixes::GetCursorImageAndName(
+    const XFixes::GetCursorImageAndNameRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 25;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XFixes::GetCursorImageAndNameReply>(
+      &buf, "XFixes::GetCursorImageAndName", false);
+}
+
+Future<XFixes::GetCursorImageAndNameReply> XFixes::GetCursorImageAndName() {
+  return XFixes::GetCursorImageAndName(XFixes::GetCursorImageAndNameRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XFixes::GetCursorImageAndNameReply> detail::ReadReply<
+    XFixes::GetCursorImageAndNameReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XFixes::GetCursorImageAndNameReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& x = (*reply).x;
+  auto& y = (*reply).y;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& xhot = (*reply).xhot;
+  auto& yhot = (*reply).yhot;
+  auto& cursor_serial = (*reply).cursor_serial;
+  auto& cursor_atom = (*reply).cursor_atom;
+  uint16_t nbytes{};
+  auto& cursor_image = (*reply).cursor_image;
+  size_t cursor_image_len = cursor_image.size();
+  auto& name = (*reply).name;
+  size_t name_len = name.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // xhot
+  Read(&xhot, &buf);
+
+  // yhot
+  Read(&yhot, &buf);
+
+  // cursor_serial
+  Read(&cursor_serial, &buf);
+
+  // cursor_atom
+  Read(&cursor_atom, &buf);
+
+  // nbytes
+  Read(&nbytes, &buf);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // cursor_image
+  cursor_image.resize((width) * (height));
+  for (auto& cursor_image_elem : cursor_image) {
+    // cursor_image_elem
+    Read(&cursor_image_elem, &buf);
+  }
+
+  // name
+  name.resize(nbytes);
+  for (auto& name_elem : name) {
+    // name_elem
+    Read(&name_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XFixes::ChangeCursor(const XFixes::ChangeCursorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& source = request.source;
+  auto& destination = request.destination;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 26;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // source
+  buf.Write(&source);
+
+  // destination
+  buf.Write(&destination);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::ChangeCursor", false);
+}
+
+Future<void> XFixes::ChangeCursor(const Cursor& source,
+                                  const Cursor& destination) {
+  return XFixes::ChangeCursor(XFixes::ChangeCursorRequest{source, destination});
+}
+
+Future<void> XFixes::ChangeCursorByName(
+    const XFixes::ChangeCursorByNameRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& src = request.src;
+  uint16_t nbytes{};
+  auto& name = request.name;
+  size_t name_len = name.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 27;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // src
+  buf.Write(&src);
+
+  // nbytes
+  nbytes = name.size();
+  buf.Write(&nbytes);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(nbytes), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::ChangeCursorByName",
+                                        false);
+}
+
+Future<void> XFixes::ChangeCursorByName(const Cursor& src,
+                                        const std::string& name) {
+  return XFixes::ChangeCursorByName(
+      XFixes::ChangeCursorByNameRequest{src, name});
+}
+
+Future<void> XFixes::ExpandRegion(const XFixes::ExpandRegionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& source = request.source;
+  auto& destination = request.destination;
+  auto& left = request.left;
+  auto& right = request.right;
+  auto& top = request.top;
+  auto& bottom = request.bottom;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 28;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // source
+  buf.Write(&source);
+
+  // destination
+  buf.Write(&destination);
+
+  // left
+  buf.Write(&left);
+
+  // right
+  buf.Write(&right);
+
+  // top
+  buf.Write(&top);
+
+  // bottom
+  buf.Write(&bottom);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::ExpandRegion", false);
+}
+
+Future<void> XFixes::ExpandRegion(const Region& source,
+                                  const Region& destination,
+                                  const uint16_t& left,
+                                  const uint16_t& right,
+                                  const uint16_t& top,
+                                  const uint16_t& bottom) {
+  return XFixes::ExpandRegion(XFixes::ExpandRegionRequest{
+      source, destination, left, right, top, bottom});
+}
+
+Future<void> XFixes::HideCursor(const XFixes::HideCursorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 29;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::HideCursor", false);
+}
+
+Future<void> XFixes::HideCursor(const Window& window) {
+  return XFixes::HideCursor(XFixes::HideCursorRequest{window});
+}
+
+Future<void> XFixes::ShowCursor(const XFixes::ShowCursorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 30;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::ShowCursor", false);
+}
+
+Future<void> XFixes::ShowCursor(const Window& window) {
+  return XFixes::ShowCursor(XFixes::ShowCursorRequest{window});
+}
+
+Future<void> XFixes::CreatePointerBarrier(
+    const XFixes::CreatePointerBarrierRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& barrier = request.barrier;
+  auto& window = request.window;
+  auto& x1 = request.x1;
+  auto& y1 = request.y1;
+  auto& x2 = request.x2;
+  auto& y2 = request.y2;
+  auto& directions = request.directions;
+  uint16_t num_devices{};
+  auto& devices = request.devices;
+  size_t devices_len = devices.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 31;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // barrier
+  buf.Write(&barrier);
+
+  // window
+  buf.Write(&window);
+
+  // x1
+  buf.Write(&x1);
+
+  // y1
+  buf.Write(&y1);
+
+  // x2
+  buf.Write(&x2);
+
+  // y2
+  buf.Write(&y2);
+
+  // directions
+  uint32_t tmp9;
+  tmp9 = static_cast<uint32_t>(directions);
+  buf.Write(&tmp9);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // num_devices
+  num_devices = devices.size();
+  buf.Write(&num_devices);
+
+  // devices
+  DCHECK_EQ(static_cast<size_t>(num_devices), devices.size());
+  for (auto& devices_elem : devices) {
+    // devices_elem
+    buf.Write(&devices_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::CreatePointerBarrier",
+                                        false);
+}
+
+Future<void> XFixes::CreatePointerBarrier(
+    const Barrier& barrier,
+    const Window& window,
+    const uint16_t& x1,
+    const uint16_t& y1,
+    const uint16_t& x2,
+    const uint16_t& y2,
+    const BarrierDirections& directions,
+    const std::vector<uint16_t>& devices) {
+  return XFixes::CreatePointerBarrier(XFixes::CreatePointerBarrierRequest{
+      barrier, window, x1, y1, x2, y2, directions, devices});
+}
+
+Future<void> XFixes::DeletePointerBarrier(
+    const XFixes::DeletePointerBarrierRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& barrier = request.barrier;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 32;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // barrier
+  buf.Write(&barrier);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XFixes::DeletePointerBarrier",
+                                        false);
+}
+
+Future<void> XFixes::DeletePointerBarrier(const Barrier& barrier) {
+  return XFixes::DeletePointerBarrier(
+      XFixes::DeletePointerBarrierRequest{barrier});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xfixes.h b/ui/gfx/x/generated_protos/xfixes.h
new file mode 100644
index 0000000..b880acd
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xfixes.h
@@ -0,0 +1,795 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XFIXES_H_
+#define UI_GFX_X_GENERATED_PROTOS_XFIXES_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "render.h"
+#include "shape.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) XFixes {
+ public:
+  static constexpr unsigned major_version = 5;
+  static constexpr unsigned minor_version = 0;
+
+  XFixes(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class SaveSetMode : int {
+    Insert = 0,
+    Delete = 1,
+  };
+
+  enum class SaveSetTarget : int {
+    Nearest = 0,
+    Root = 1,
+  };
+
+  enum class SaveSetMapping : int {
+    Map = 0,
+    Unmap = 1,
+  };
+
+  enum class SelectionEvent : int {
+    SetSelectionOwner = 0,
+    SelectionWindowDestroy = 1,
+    SelectionClientClose = 2,
+  };
+
+  enum class SelectionEventMask : int {
+    SetSelectionOwner = 1 << 0,
+    SelectionWindowDestroy = 1 << 1,
+    SelectionClientClose = 1 << 2,
+  };
+
+  enum class CursorNotify : int {
+    DisplayCursor = 0,
+  };
+
+  enum class CursorNotifyMask : int {
+    DisplayCursor = 1 << 0,
+  };
+
+  enum class Region : uint32_t {
+    None = 0,
+  };
+
+  enum class Barrier : uint32_t {};
+
+  enum class BarrierDirections : int {
+    PositiveX = 1 << 0,
+    PositiveY = 1 << 1,
+    NegativeX = 1 << 2,
+    NegativeY = 1 << 3,
+  };
+
+  struct SelectionNotifyEvent {
+    static constexpr int type_id = 18;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    SelectionEvent subtype{};
+    uint16_t sequence{};
+    Window window{};
+    Window owner{};
+    Atom selection{};
+    Time timestamp{};
+    Time selection_timestamp{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct CursorNotifyEvent {
+    static constexpr int type_id = 19;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    CursorNotify subtype{};
+    uint16_t sequence{};
+    Window window{};
+    uint32_t cursor_serial{};
+    Time timestamp{};
+    Atom name{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct BadRegionError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct QueryVersionRequest {
+    uint32_t client_major_version{};
+    uint32_t client_minor_version{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major_version{};
+    uint32_t minor_version{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(
+      const uint32_t& client_major_version = {},
+      const uint32_t& client_minor_version = {});
+
+  struct ChangeSaveSetRequest {
+    SaveSetMode mode{};
+    SaveSetTarget target{};
+    SaveSetMapping map{};
+    Window window{};
+  };
+
+  using ChangeSaveSetResponse = Response<void>;
+
+  Future<void> ChangeSaveSet(const ChangeSaveSetRequest& request);
+
+  Future<void> ChangeSaveSet(const SaveSetMode& mode = {},
+                             const SaveSetTarget& target = {},
+                             const SaveSetMapping& map = {},
+                             const Window& window = {});
+
+  struct SelectSelectionInputRequest {
+    Window window{};
+    Atom selection{};
+    SelectionEventMask event_mask{};
+  };
+
+  using SelectSelectionInputResponse = Response<void>;
+
+  Future<void> SelectSelectionInput(const SelectSelectionInputRequest& request);
+
+  Future<void> SelectSelectionInput(const Window& window = {},
+                                    const Atom& selection = {},
+                                    const SelectionEventMask& event_mask = {});
+
+  struct SelectCursorInputRequest {
+    Window window{};
+    CursorNotifyMask event_mask{};
+  };
+
+  using SelectCursorInputResponse = Response<void>;
+
+  Future<void> SelectCursorInput(const SelectCursorInputRequest& request);
+
+  Future<void> SelectCursorInput(const Window& window = {},
+                                 const CursorNotifyMask& event_mask = {});
+
+  struct GetCursorImageRequest {};
+
+  struct GetCursorImageReply {
+    uint16_t sequence{};
+    int16_t x{};
+    int16_t y{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t xhot{};
+    uint16_t yhot{};
+    uint32_t cursor_serial{};
+    std::vector<uint32_t> cursor_image{};
+  };
+
+  using GetCursorImageResponse = Response<GetCursorImageReply>;
+
+  Future<GetCursorImageReply> GetCursorImage(
+      const GetCursorImageRequest& request);
+
+  Future<GetCursorImageReply> GetCursorImage();
+
+  struct CreateRegionRequest {
+    Region region{};
+    std::vector<Rectangle> rectangles{};
+  };
+
+  using CreateRegionResponse = Response<void>;
+
+  Future<void> CreateRegion(const CreateRegionRequest& request);
+
+  Future<void> CreateRegion(const Region& region = {},
+                            const std::vector<Rectangle>& rectangles = {});
+
+  struct CreateRegionFromBitmapRequest {
+    Region region{};
+    Pixmap bitmap{};
+  };
+
+  using CreateRegionFromBitmapResponse = Response<void>;
+
+  Future<void> CreateRegionFromBitmap(
+      const CreateRegionFromBitmapRequest& request);
+
+  Future<void> CreateRegionFromBitmap(const Region& region = {},
+                                      const Pixmap& bitmap = {});
+
+  struct CreateRegionFromWindowRequest {
+    Region region{};
+    Window window{};
+    Shape::Sk kind{};
+  };
+
+  using CreateRegionFromWindowResponse = Response<void>;
+
+  Future<void> CreateRegionFromWindow(
+      const CreateRegionFromWindowRequest& request);
+
+  Future<void> CreateRegionFromWindow(const Region& region = {},
+                                      const Window& window = {},
+                                      const Shape::Sk& kind = {});
+
+  struct CreateRegionFromGCRequest {
+    Region region{};
+    GraphicsContext gc{};
+  };
+
+  using CreateRegionFromGCResponse = Response<void>;
+
+  Future<void> CreateRegionFromGC(const CreateRegionFromGCRequest& request);
+
+  Future<void> CreateRegionFromGC(const Region& region = {},
+                                  const GraphicsContext& gc = {});
+
+  struct CreateRegionFromPictureRequest {
+    Region region{};
+    Render::Picture picture{};
+  };
+
+  using CreateRegionFromPictureResponse = Response<void>;
+
+  Future<void> CreateRegionFromPicture(
+      const CreateRegionFromPictureRequest& request);
+
+  Future<void> CreateRegionFromPicture(const Region& region = {},
+                                       const Render::Picture& picture = {});
+
+  struct DestroyRegionRequest {
+    Region region{};
+  };
+
+  using DestroyRegionResponse = Response<void>;
+
+  Future<void> DestroyRegion(const DestroyRegionRequest& request);
+
+  Future<void> DestroyRegion(const Region& region = {});
+
+  struct SetRegionRequest {
+    Region region{};
+    std::vector<Rectangle> rectangles{};
+  };
+
+  using SetRegionResponse = Response<void>;
+
+  Future<void> SetRegion(const SetRegionRequest& request);
+
+  Future<void> SetRegion(const Region& region = {},
+                         const std::vector<Rectangle>& rectangles = {});
+
+  struct CopyRegionRequest {
+    Region source{};
+    Region destination{};
+  };
+
+  using CopyRegionResponse = Response<void>;
+
+  Future<void> CopyRegion(const CopyRegionRequest& request);
+
+  Future<void> CopyRegion(const Region& source = {},
+                          const Region& destination = {});
+
+  struct UnionRegionRequest {
+    Region source1{};
+    Region source2{};
+    Region destination{};
+  };
+
+  using UnionRegionResponse = Response<void>;
+
+  Future<void> UnionRegion(const UnionRegionRequest& request);
+
+  Future<void> UnionRegion(const Region& source1 = {},
+                           const Region& source2 = {},
+                           const Region& destination = {});
+
+  struct IntersectRegionRequest {
+    Region source1{};
+    Region source2{};
+    Region destination{};
+  };
+
+  using IntersectRegionResponse = Response<void>;
+
+  Future<void> IntersectRegion(const IntersectRegionRequest& request);
+
+  Future<void> IntersectRegion(const Region& source1 = {},
+                               const Region& source2 = {},
+                               const Region& destination = {});
+
+  struct SubtractRegionRequest {
+    Region source1{};
+    Region source2{};
+    Region destination{};
+  };
+
+  using SubtractRegionResponse = Response<void>;
+
+  Future<void> SubtractRegion(const SubtractRegionRequest& request);
+
+  Future<void> SubtractRegion(const Region& source1 = {},
+                              const Region& source2 = {},
+                              const Region& destination = {});
+
+  struct InvertRegionRequest {
+    Region source{};
+    Rectangle bounds{};
+    Region destination{};
+  };
+
+  using InvertRegionResponse = Response<void>;
+
+  Future<void> InvertRegion(const InvertRegionRequest& request);
+
+  Future<void> InvertRegion(const Region& source = {},
+                            const Rectangle& bounds = {{}, {}, {}, {}},
+                            const Region& destination = {});
+
+  struct TranslateRegionRequest {
+    Region region{};
+    int16_t dx{};
+    int16_t dy{};
+  };
+
+  using TranslateRegionResponse = Response<void>;
+
+  Future<void> TranslateRegion(const TranslateRegionRequest& request);
+
+  Future<void> TranslateRegion(const Region& region = {},
+                               const int16_t& dx = {},
+                               const int16_t& dy = {});
+
+  struct RegionExtentsRequest {
+    Region source{};
+    Region destination{};
+  };
+
+  using RegionExtentsResponse = Response<void>;
+
+  Future<void> RegionExtents(const RegionExtentsRequest& request);
+
+  Future<void> RegionExtents(const Region& source = {},
+                             const Region& destination = {});
+
+  struct FetchRegionRequest {
+    Region region{};
+  };
+
+  struct FetchRegionReply {
+    uint16_t sequence{};
+    Rectangle extents{};
+    std::vector<Rectangle> rectangles{};
+  };
+
+  using FetchRegionResponse = Response<FetchRegionReply>;
+
+  Future<FetchRegionReply> FetchRegion(const FetchRegionRequest& request);
+
+  Future<FetchRegionReply> FetchRegion(const Region& region = {});
+
+  struct SetGCClipRegionRequest {
+    GraphicsContext gc{};
+    Region region{};
+    int16_t x_origin{};
+    int16_t y_origin{};
+  };
+
+  using SetGCClipRegionResponse = Response<void>;
+
+  Future<void> SetGCClipRegion(const SetGCClipRegionRequest& request);
+
+  Future<void> SetGCClipRegion(const GraphicsContext& gc = {},
+                               const Region& region = {},
+                               const int16_t& x_origin = {},
+                               const int16_t& y_origin = {});
+
+  struct SetWindowShapeRegionRequest {
+    Window dest{};
+    Shape::Sk dest_kind{};
+    int16_t x_offset{};
+    int16_t y_offset{};
+    Region region{};
+  };
+
+  using SetWindowShapeRegionResponse = Response<void>;
+
+  Future<void> SetWindowShapeRegion(const SetWindowShapeRegionRequest& request);
+
+  Future<void> SetWindowShapeRegion(const Window& dest = {},
+                                    const Shape::Sk& dest_kind = {},
+                                    const int16_t& x_offset = {},
+                                    const int16_t& y_offset = {},
+                                    const Region& region = {});
+
+  struct SetPictureClipRegionRequest {
+    Render::Picture picture{};
+    Region region{};
+    int16_t x_origin{};
+    int16_t y_origin{};
+  };
+
+  using SetPictureClipRegionResponse = Response<void>;
+
+  Future<void> SetPictureClipRegion(const SetPictureClipRegionRequest& request);
+
+  Future<void> SetPictureClipRegion(const Render::Picture& picture = {},
+                                    const Region& region = {},
+                                    const int16_t& x_origin = {},
+                                    const int16_t& y_origin = {});
+
+  struct SetCursorNameRequest {
+    Cursor cursor{};
+    std::string name{};
+  };
+
+  using SetCursorNameResponse = Response<void>;
+
+  Future<void> SetCursorName(const SetCursorNameRequest& request);
+
+  Future<void> SetCursorName(const Cursor& cursor = {},
+                             const std::string& name = {});
+
+  struct GetCursorNameRequest {
+    Cursor cursor{};
+  };
+
+  struct GetCursorNameReply {
+    uint16_t sequence{};
+    Atom atom{};
+    std::string name{};
+  };
+
+  using GetCursorNameResponse = Response<GetCursorNameReply>;
+
+  Future<GetCursorNameReply> GetCursorName(const GetCursorNameRequest& request);
+
+  Future<GetCursorNameReply> GetCursorName(const Cursor& cursor = {});
+
+  struct GetCursorImageAndNameRequest {};
+
+  struct GetCursorImageAndNameReply {
+    uint16_t sequence{};
+    int16_t x{};
+    int16_t y{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t xhot{};
+    uint16_t yhot{};
+    uint32_t cursor_serial{};
+    Atom cursor_atom{};
+    std::vector<uint32_t> cursor_image{};
+    std::string name{};
+  };
+
+  using GetCursorImageAndNameResponse = Response<GetCursorImageAndNameReply>;
+
+  Future<GetCursorImageAndNameReply> GetCursorImageAndName(
+      const GetCursorImageAndNameRequest& request);
+
+  Future<GetCursorImageAndNameReply> GetCursorImageAndName();
+
+  struct ChangeCursorRequest {
+    Cursor source{};
+    Cursor destination{};
+  };
+
+  using ChangeCursorResponse = Response<void>;
+
+  Future<void> ChangeCursor(const ChangeCursorRequest& request);
+
+  Future<void> ChangeCursor(const Cursor& source = {},
+                            const Cursor& destination = {});
+
+  struct ChangeCursorByNameRequest {
+    Cursor src{};
+    std::string name{};
+  };
+
+  using ChangeCursorByNameResponse = Response<void>;
+
+  Future<void> ChangeCursorByName(const ChangeCursorByNameRequest& request);
+
+  Future<void> ChangeCursorByName(const Cursor& src = {},
+                                  const std::string& name = {});
+
+  struct ExpandRegionRequest {
+    Region source{};
+    Region destination{};
+    uint16_t left{};
+    uint16_t right{};
+    uint16_t top{};
+    uint16_t bottom{};
+  };
+
+  using ExpandRegionResponse = Response<void>;
+
+  Future<void> ExpandRegion(const ExpandRegionRequest& request);
+
+  Future<void> ExpandRegion(const Region& source = {},
+                            const Region& destination = {},
+                            const uint16_t& left = {},
+                            const uint16_t& right = {},
+                            const uint16_t& top = {},
+                            const uint16_t& bottom = {});
+
+  struct HideCursorRequest {
+    Window window{};
+  };
+
+  using HideCursorResponse = Response<void>;
+
+  Future<void> HideCursor(const HideCursorRequest& request);
+
+  Future<void> HideCursor(const Window& window = {});
+
+  struct ShowCursorRequest {
+    Window window{};
+  };
+
+  using ShowCursorResponse = Response<void>;
+
+  Future<void> ShowCursor(const ShowCursorRequest& request);
+
+  Future<void> ShowCursor(const Window& window = {});
+
+  struct CreatePointerBarrierRequest {
+    Barrier barrier{};
+    Window window{};
+    uint16_t x1{};
+    uint16_t y1{};
+    uint16_t x2{};
+    uint16_t y2{};
+    BarrierDirections directions{};
+    std::vector<uint16_t> devices{};
+  };
+
+  using CreatePointerBarrierResponse = Response<void>;
+
+  Future<void> CreatePointerBarrier(const CreatePointerBarrierRequest& request);
+
+  Future<void> CreatePointerBarrier(const Barrier& barrier = {},
+                                    const Window& window = {},
+                                    const uint16_t& x1 = {},
+                                    const uint16_t& y1 = {},
+                                    const uint16_t& x2 = {},
+                                    const uint16_t& y2 = {},
+                                    const BarrierDirections& directions = {},
+                                    const std::vector<uint16_t>& devices = {});
+
+  struct DeletePointerBarrierRequest {
+    Barrier barrier{};
+  };
+
+  using DeletePointerBarrierResponse = Response<void>;
+
+  Future<void> DeletePointerBarrier(const DeletePointerBarrierRequest& request);
+
+  Future<void> DeletePointerBarrier(const Barrier& barrier = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::XFixes::SaveSetMode operator|(
+    x11::XFixes::SaveSetMode l,
+    x11::XFixes::SaveSetMode r) {
+  using T = std::underlying_type_t<x11::XFixes::SaveSetMode>;
+  return static_cast<x11::XFixes::SaveSetMode>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SaveSetMode operator&(
+    x11::XFixes::SaveSetMode l,
+    x11::XFixes::SaveSetMode r) {
+  using T = std::underlying_type_t<x11::XFixes::SaveSetMode>;
+  return static_cast<x11::XFixes::SaveSetMode>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SaveSetTarget operator|(
+    x11::XFixes::SaveSetTarget l,
+    x11::XFixes::SaveSetTarget r) {
+  using T = std::underlying_type_t<x11::XFixes::SaveSetTarget>;
+  return static_cast<x11::XFixes::SaveSetTarget>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SaveSetTarget operator&(
+    x11::XFixes::SaveSetTarget l,
+    x11::XFixes::SaveSetTarget r) {
+  using T = std::underlying_type_t<x11::XFixes::SaveSetTarget>;
+  return static_cast<x11::XFixes::SaveSetTarget>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SaveSetMapping operator|(
+    x11::XFixes::SaveSetMapping l,
+    x11::XFixes::SaveSetMapping r) {
+  using T = std::underlying_type_t<x11::XFixes::SaveSetMapping>;
+  return static_cast<x11::XFixes::SaveSetMapping>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SaveSetMapping operator&(
+    x11::XFixes::SaveSetMapping l,
+    x11::XFixes::SaveSetMapping r) {
+  using T = std::underlying_type_t<x11::XFixes::SaveSetMapping>;
+  return static_cast<x11::XFixes::SaveSetMapping>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SelectionEvent operator|(
+    x11::XFixes::SelectionEvent l,
+    x11::XFixes::SelectionEvent r) {
+  using T = std::underlying_type_t<x11::XFixes::SelectionEvent>;
+  return static_cast<x11::XFixes::SelectionEvent>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SelectionEvent operator&(
+    x11::XFixes::SelectionEvent l,
+    x11::XFixes::SelectionEvent r) {
+  using T = std::underlying_type_t<x11::XFixes::SelectionEvent>;
+  return static_cast<x11::XFixes::SelectionEvent>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SelectionEventMask operator|(
+    x11::XFixes::SelectionEventMask l,
+    x11::XFixes::SelectionEventMask r) {
+  using T = std::underlying_type_t<x11::XFixes::SelectionEventMask>;
+  return static_cast<x11::XFixes::SelectionEventMask>(static_cast<T>(l) |
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::SelectionEventMask operator&(
+    x11::XFixes::SelectionEventMask l,
+    x11::XFixes::SelectionEventMask r) {
+  using T = std::underlying_type_t<x11::XFixes::SelectionEventMask>;
+  return static_cast<x11::XFixes::SelectionEventMask>(static_cast<T>(l) &
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::CursorNotify operator|(
+    x11::XFixes::CursorNotify l,
+    x11::XFixes::CursorNotify r) {
+  using T = std::underlying_type_t<x11::XFixes::CursorNotify>;
+  return static_cast<x11::XFixes::CursorNotify>(static_cast<T>(l) |
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::CursorNotify operator&(
+    x11::XFixes::CursorNotify l,
+    x11::XFixes::CursorNotify r) {
+  using T = std::underlying_type_t<x11::XFixes::CursorNotify>;
+  return static_cast<x11::XFixes::CursorNotify>(static_cast<T>(l) &
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::CursorNotifyMask operator|(
+    x11::XFixes::CursorNotifyMask l,
+    x11::XFixes::CursorNotifyMask r) {
+  using T = std::underlying_type_t<x11::XFixes::CursorNotifyMask>;
+  return static_cast<x11::XFixes::CursorNotifyMask>(static_cast<T>(l) |
+                                                    static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::CursorNotifyMask operator&(
+    x11::XFixes::CursorNotifyMask l,
+    x11::XFixes::CursorNotifyMask r) {
+  using T = std::underlying_type_t<x11::XFixes::CursorNotifyMask>;
+  return static_cast<x11::XFixes::CursorNotifyMask>(static_cast<T>(l) &
+                                                    static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::Region operator|(x11::XFixes::Region l,
+                                               x11::XFixes::Region r) {
+  using T = std::underlying_type_t<x11::XFixes::Region>;
+  return static_cast<x11::XFixes::Region>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::Region operator&(x11::XFixes::Region l,
+                                               x11::XFixes::Region r) {
+  using T = std::underlying_type_t<x11::XFixes::Region>;
+  return static_cast<x11::XFixes::Region>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::BarrierDirections operator|(
+    x11::XFixes::BarrierDirections l,
+    x11::XFixes::BarrierDirections r) {
+  using T = std::underlying_type_t<x11::XFixes::BarrierDirections>;
+  return static_cast<x11::XFixes::BarrierDirections>(static_cast<T>(l) |
+                                                     static_cast<T>(r));
+}
+
+inline constexpr x11::XFixes::BarrierDirections operator&(
+    x11::XFixes::BarrierDirections l,
+    x11::XFixes::BarrierDirections r) {
+  using T = std::underlying_type_t<x11::XFixes::BarrierDirections>;
+  return static_cast<x11::XFixes::BarrierDirections>(static_cast<T>(l) &
+                                                     static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XFIXES_H_
diff --git a/ui/gfx/x/generated_protos/xinerama.cc b/ui/gfx/x/generated_protos/xinerama.cc
new file mode 100644
index 0000000..e184714
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xinerama.cc
@@ -0,0 +1,508 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xinerama.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Xinerama::Xinerama(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<Xinerama::QueryVersionReply> Xinerama::QueryVersion(
+    const Xinerama::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major = request.major;
+  auto& minor = request.minor;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major
+  buf.Write(&major);
+
+  // minor
+  buf.Write(&minor);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xinerama::QueryVersionReply>(
+      &buf, "Xinerama::QueryVersion", false);
+}
+
+Future<Xinerama::QueryVersionReply> Xinerama::QueryVersion(
+    const uint8_t& major,
+    const uint8_t& minor) {
+  return Xinerama::QueryVersion(Xinerama::QueryVersionRequest{major, minor});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xinerama::QueryVersionReply> detail::ReadReply<
+    Xinerama::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xinerama::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major = (*reply).major;
+  auto& minor = (*reply).minor;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major
+  Read(&major, &buf);
+
+  // minor
+  Read(&minor, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xinerama::GetStateReply> Xinerama::GetState(
+    const Xinerama::GetStateRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xinerama::GetStateReply>(
+      &buf, "Xinerama::GetState", false);
+}
+
+Future<Xinerama::GetStateReply> Xinerama::GetState(const Window& window) {
+  return Xinerama::GetState(Xinerama::GetStateRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xinerama::GetStateReply> detail::ReadReply<
+    Xinerama::GetStateReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xinerama::GetStateReply>();
+
+  auto& state = (*reply).state;
+  auto& sequence = (*reply).sequence;
+  auto& window = (*reply).window;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // state
+  Read(&state, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xinerama::GetScreenCountReply> Xinerama::GetScreenCount(
+    const Xinerama::GetScreenCountRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xinerama::GetScreenCountReply>(
+      &buf, "Xinerama::GetScreenCount", false);
+}
+
+Future<Xinerama::GetScreenCountReply> Xinerama::GetScreenCount(
+    const Window& window) {
+  return Xinerama::GetScreenCount(Xinerama::GetScreenCountRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xinerama::GetScreenCountReply> detail::ReadReply<
+    Xinerama::GetScreenCountReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xinerama::GetScreenCountReply>();
+
+  auto& screen_count = (*reply).screen_count;
+  auto& sequence = (*reply).sequence;
+  auto& window = (*reply).window;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // screen_count
+  Read(&screen_count, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xinerama::GetScreenSizeReply> Xinerama::GetScreenSize(
+    const Xinerama::GetScreenSizeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& screen = request.screen;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // screen
+  buf.Write(&screen);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xinerama::GetScreenSizeReply>(
+      &buf, "Xinerama::GetScreenSize", false);
+}
+
+Future<Xinerama::GetScreenSizeReply> Xinerama::GetScreenSize(
+    const Window& window,
+    const uint32_t& screen) {
+  return Xinerama::GetScreenSize(
+      Xinerama::GetScreenSizeRequest{window, screen});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xinerama::GetScreenSizeReply> detail::ReadReply<
+    Xinerama::GetScreenSizeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xinerama::GetScreenSizeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& window = (*reply).window;
+  auto& screen = (*reply).screen;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // screen
+  Read(&screen, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xinerama::IsActiveReply> Xinerama::IsActive(
+    const Xinerama::IsActiveRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xinerama::IsActiveReply>(
+      &buf, "Xinerama::IsActive", false);
+}
+
+Future<Xinerama::IsActiveReply> Xinerama::IsActive() {
+  return Xinerama::IsActive(Xinerama::IsActiveRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xinerama::IsActiveReply> detail::ReadReply<
+    Xinerama::IsActiveReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xinerama::IsActiveReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& state = (*reply).state;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // state
+  Read(&state, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xinerama::QueryScreensReply> Xinerama::QueryScreens(
+    const Xinerama::QueryScreensRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xinerama::QueryScreensReply>(
+      &buf, "Xinerama::QueryScreens", false);
+}
+
+Future<Xinerama::QueryScreensReply> Xinerama::QueryScreens() {
+  return Xinerama::QueryScreens(Xinerama::QueryScreensRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xinerama::QueryScreensReply> detail::ReadReply<
+    Xinerama::QueryScreensReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xinerama::QueryScreensReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t number{};
+  auto& screen_info = (*reply).screen_info;
+  size_t screen_info_len = screen_info.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // number
+  Read(&number, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // screen_info
+  screen_info.resize(number);
+  for (auto& screen_info_elem : screen_info) {
+    // screen_info_elem
+    {
+      auto& x_org = screen_info_elem.x_org;
+      auto& y_org = screen_info_elem.y_org;
+      auto& width = screen_info_elem.width;
+      auto& height = screen_info_elem.height;
+
+      // x_org
+      Read(&x_org, &buf);
+
+      // y_org
+      Read(&y_org, &buf);
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xinerama.h b/ui/gfx/x/generated_protos/xinerama.h
new file mode 100644
index 0000000..367d70c
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xinerama.h
@@ -0,0 +1,194 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XINERAMA_H_
+#define UI_GFX_X_GENERATED_PROTOS_XINERAMA_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Xinerama {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 1;
+
+  Xinerama(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  struct ScreenInfo {
+    int16_t x_org{};
+    int16_t y_org{};
+    uint16_t width{};
+    uint16_t height{};
+  };
+
+  struct QueryVersionRequest {
+    uint8_t major{};
+    uint8_t minor{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t major{};
+    uint16_t minor{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint8_t& major = {},
+                                         const uint8_t& minor = {});
+
+  struct GetStateRequest {
+    Window window{};
+  };
+
+  struct GetStateReply {
+    uint8_t state{};
+    uint16_t sequence{};
+    Window window{};
+  };
+
+  using GetStateResponse = Response<GetStateReply>;
+
+  Future<GetStateReply> GetState(const GetStateRequest& request);
+
+  Future<GetStateReply> GetState(const Window& window = {});
+
+  struct GetScreenCountRequest {
+    Window window{};
+  };
+
+  struct GetScreenCountReply {
+    uint8_t screen_count{};
+    uint16_t sequence{};
+    Window window{};
+  };
+
+  using GetScreenCountResponse = Response<GetScreenCountReply>;
+
+  Future<GetScreenCountReply> GetScreenCount(
+      const GetScreenCountRequest& request);
+
+  Future<GetScreenCountReply> GetScreenCount(const Window& window = {});
+
+  struct GetScreenSizeRequest {
+    Window window{};
+    uint32_t screen{};
+  };
+
+  struct GetScreenSizeReply {
+    uint16_t sequence{};
+    uint32_t width{};
+    uint32_t height{};
+    Window window{};
+    uint32_t screen{};
+  };
+
+  using GetScreenSizeResponse = Response<GetScreenSizeReply>;
+
+  Future<GetScreenSizeReply> GetScreenSize(const GetScreenSizeRequest& request);
+
+  Future<GetScreenSizeReply> GetScreenSize(const Window& window = {},
+                                           const uint32_t& screen = {});
+
+  struct IsActiveRequest {};
+
+  struct IsActiveReply {
+    uint16_t sequence{};
+    uint32_t state{};
+  };
+
+  using IsActiveResponse = Response<IsActiveReply>;
+
+  Future<IsActiveReply> IsActive(const IsActiveRequest& request);
+
+  Future<IsActiveReply> IsActive();
+
+  struct QueryScreensRequest {};
+
+  struct QueryScreensReply {
+    uint16_t sequence{};
+    std::vector<ScreenInfo> screen_info{};
+  };
+
+  using QueryScreensResponse = Response<QueryScreensReply>;
+
+  Future<QueryScreensReply> QueryScreens(const QueryScreensRequest& request);
+
+  Future<QueryScreensReply> QueryScreens();
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XINERAMA_H_
diff --git a/ui/gfx/x/generated_protos/xinput.cc b/ui/gfx/x/generated_protos/xinput.cc
new file mode 100644
index 0000000..f98f5b2
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xinput.cc
@@ -0,0 +1,7683 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xinput.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Input::Input(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DeviceValuatorEvent>(Input::DeviceValuatorEvent* event_,
+                                           ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& device_id = (*event_).device_id;
+  auto& sequence = (*event_).sequence;
+  auto& device_state = (*event_).device_state;
+  auto& num_valuators = (*event_).num_valuators;
+  auto& first_valuator = (*event_).first_valuator;
+  auto& valuators = (*event_).valuators;
+  size_t valuators_len = valuators.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // device_state
+  Read(&device_state, &buf);
+
+  // num_valuators
+  Read(&num_valuators, &buf);
+
+  // first_valuator
+  Read(&first_valuator, &buf);
+
+  // valuators
+  for (auto& valuators_elem : valuators) {
+    // valuators_elem
+    Read(&valuators_elem, &buf);
+  }
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::LegacyDeviceEvent>(Input::LegacyDeviceEvent* event_,
+                                         ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& child = (*event_).child;
+  auto& root_x = (*event_).root_x;
+  auto& root_y = (*event_).root_y;
+  auto& event_x = (*event_).event_x;
+  auto& event_y = (*event_).event_y;
+  auto& state = (*event_).state;
+  auto& same_screen = (*event_).same_screen;
+  auto& device_id = (*event_).device_id;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  Read(&detail, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // event_x
+  Read(&event_x, &buf);
+
+  // event_y
+  Read(&event_y, &buf);
+
+  // state
+  uint16_t tmp0;
+  Read(&tmp0, &buf);
+  state = static_cast<KeyButMask>(tmp0);
+
+  // same_screen
+  Read(&same_screen, &buf);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DeviceFocusEvent>(Input::DeviceFocusEvent* event_,
+                                        ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& window = (*event_).window;
+  auto& mode = (*event_).mode;
+  auto& device_id = (*event_).device_id;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  uint8_t tmp1;
+  Read(&tmp1, &buf);
+  detail = static_cast<NotifyDetail>(tmp1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // mode
+  uint8_t tmp2;
+  Read(&tmp2, &buf);
+  mode = static_cast<NotifyMode>(tmp2);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // pad0
+  Pad(&buf, 18);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DeviceStateNotifyEvent>(
+    Input::DeviceStateNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& device_id = (*event_).device_id;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& num_keys = (*event_).num_keys;
+  auto& num_buttons = (*event_).num_buttons;
+  auto& num_valuators = (*event_).num_valuators;
+  auto& classes_reported = (*event_).classes_reported;
+  auto& buttons = (*event_).buttons;
+  size_t buttons_len = buttons.size();
+  auto& keys = (*event_).keys;
+  size_t keys_len = keys.size();
+  auto& valuators = (*event_).valuators;
+  size_t valuators_len = valuators.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // num_keys
+  Read(&num_keys, &buf);
+
+  // num_buttons
+  Read(&num_buttons, &buf);
+
+  // num_valuators
+  Read(&num_valuators, &buf);
+
+  // classes_reported
+  uint8_t tmp3;
+  Read(&tmp3, &buf);
+  classes_reported = static_cast<Input::ClassesReportedMask>(tmp3);
+
+  // buttons
+  for (auto& buttons_elem : buttons) {
+    // buttons_elem
+    Read(&buttons_elem, &buf);
+  }
+
+  // keys
+  for (auto& keys_elem : keys) {
+    // keys_elem
+    Read(&keys_elem, &buf);
+  }
+
+  // valuators
+  for (auto& valuators_elem : valuators) {
+    // valuators_elem
+    Read(&valuators_elem, &buf);
+  }
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DeviceMappingNotifyEvent>(
+    Input::DeviceMappingNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& device_id = (*event_).device_id;
+  auto& sequence = (*event_).sequence;
+  auto& request = (*event_).request;
+  auto& first_keycode = (*event_).first_keycode;
+  auto& count = (*event_).count;
+  auto& time = (*event_).time;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // request
+  uint8_t tmp4;
+  Read(&tmp4, &buf);
+  request = static_cast<Mapping>(tmp4);
+
+  // first_keycode
+  Read(&first_keycode, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // time
+  Read(&time, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::ChangeDeviceNotifyEvent>(
+    Input::ChangeDeviceNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& device_id = (*event_).device_id;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& request = (*event_).request;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // request
+  uint8_t tmp5;
+  Read(&tmp5, &buf);
+  request = static_cast<Input::ChangeDevice>(tmp5);
+
+  // pad0
+  Pad(&buf, 23);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DeviceKeyStateNotifyEvent>(
+    Input::DeviceKeyStateNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& device_id = (*event_).device_id;
+  auto& sequence = (*event_).sequence;
+  auto& keys = (*event_).keys;
+  size_t keys_len = keys.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // keys
+  for (auto& keys_elem : keys) {
+    // keys_elem
+    Read(&keys_elem, &buf);
+  }
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DeviceButtonStateNotifyEvent>(
+    Input::DeviceButtonStateNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& device_id = (*event_).device_id;
+  auto& sequence = (*event_).sequence;
+  auto& buttons = (*event_).buttons;
+  size_t buttons_len = buttons.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // buttons
+  for (auto& buttons_elem : buttons) {
+    // buttons_elem
+    Read(&buttons_elem, &buf);
+  }
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DevicePresenceNotifyEvent>(
+    Input::DevicePresenceNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& devchange = (*event_).devchange;
+  auto& device_id = (*event_).device_id;
+  auto& control = (*event_).control;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // devchange
+  uint8_t tmp6;
+  Read(&tmp6, &buf);
+  devchange = static_cast<Input::DeviceChange>(tmp6);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // control
+  Read(&control, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DevicePropertyNotifyEvent>(
+    Input::DevicePropertyNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& state = (*event_).state;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& property = (*event_).property;
+  auto& device_id = (*event_).device_id;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // state
+  uint8_t tmp7;
+  Read(&tmp7, &buf);
+  state = static_cast<Property>(tmp7);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // property
+  Read(&property, &buf);
+
+  // pad0
+  Pad(&buf, 19);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DeviceChangedEvent>(Input::DeviceChangedEvent* event_,
+                                          ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& deviceid = (*event_).deviceid;
+  auto& time = (*event_).time;
+  uint16_t num_classes{};
+  auto& sourceid = (*event_).sourceid;
+  auto& reason = (*event_).reason;
+  auto& classes = (*event_).classes;
+  size_t classes_len = classes.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // num_classes
+  Read(&num_classes, &buf);
+
+  // sourceid
+  Read(&sourceid, &buf);
+
+  // reason
+  uint8_t tmp8;
+  Read(&tmp8, &buf);
+  reason = static_cast<Input::ChangeReason>(tmp8);
+
+  // pad0
+  Pad(&buf, 11);
+
+  // classes
+  classes.resize(num_classes);
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    {
+      Input::DeviceClassType type{};
+      auto& len = classes_elem.len;
+      auto& sourceid = classes_elem.sourceid;
+      auto& data = classes_elem;
+
+      // type
+      uint16_t tmp9;
+      Read(&tmp9, &buf);
+      type = static_cast<Input::DeviceClassType>(tmp9);
+
+      // len
+      Read(&len, &buf);
+
+      // sourceid
+      Read(&sourceid, &buf);
+
+      // data
+      auto data_expr = type;
+      if (CaseEq(data_expr, Input::DeviceClassType::Key)) {
+        data.key.emplace();
+        uint16_t num_keys{};
+        auto& keys = (*data.key).keys;
+        size_t keys_len = keys.size();
+
+        // num_keys
+        Read(&num_keys, &buf);
+
+        // keys
+        keys.resize(num_keys);
+        for (auto& keys_elem : keys) {
+          // keys_elem
+          Read(&keys_elem, &buf);
+        }
+      }
+      if (CaseEq(data_expr, Input::DeviceClassType::Button)) {
+        data.button.emplace();
+        uint16_t num_buttons{};
+        auto& state = (*data.button).state;
+        size_t state_len = state.size();
+        auto& labels = (*data.button).labels;
+        size_t labels_len = labels.size();
+
+        // num_buttons
+        Read(&num_buttons, &buf);
+
+        // state
+        state.resize(((num_buttons) + (31)) / (32));
+        for (auto& state_elem : state) {
+          // state_elem
+          Read(&state_elem, &buf);
+        }
+
+        // labels
+        labels.resize(num_buttons);
+        for (auto& labels_elem : labels) {
+          // labels_elem
+          Read(&labels_elem, &buf);
+        }
+      }
+      if (CaseEq(data_expr, Input::DeviceClassType::Valuator)) {
+        data.valuator.emplace();
+        auto& number = (*data.valuator).number;
+        auto& label = (*data.valuator).label;
+        auto& min = (*data.valuator).min;
+        auto& max = (*data.valuator).max;
+        auto& value = (*data.valuator).value;
+        auto& resolution = (*data.valuator).resolution;
+        auto& mode = (*data.valuator).mode;
+
+        // number
+        Read(&number, &buf);
+
+        // label
+        Read(&label, &buf);
+
+        // min
+        {
+          auto& integral = min.integral;
+          auto& frac = min.frac;
+
+          // integral
+          Read(&integral, &buf);
+
+          // frac
+          Read(&frac, &buf);
+        }
+
+        // max
+        {
+          auto& integral = max.integral;
+          auto& frac = max.frac;
+
+          // integral
+          Read(&integral, &buf);
+
+          // frac
+          Read(&frac, &buf);
+        }
+
+        // value
+        {
+          auto& integral = value.integral;
+          auto& frac = value.frac;
+
+          // integral
+          Read(&integral, &buf);
+
+          // frac
+          Read(&frac, &buf);
+        }
+
+        // resolution
+        Read(&resolution, &buf);
+
+        // mode
+        uint8_t tmp10;
+        Read(&tmp10, &buf);
+        mode = static_cast<Input::ValuatorMode>(tmp10);
+
+        // pad0
+        Pad(&buf, 3);
+      }
+      if (CaseEq(data_expr, Input::DeviceClassType::Scroll)) {
+        data.scroll.emplace();
+        auto& number = (*data.scroll).number;
+        auto& scroll_type = (*data.scroll).scroll_type;
+        auto& flags = (*data.scroll).flags;
+        auto& increment = (*data.scroll).increment;
+
+        // number
+        Read(&number, &buf);
+
+        // scroll_type
+        uint16_t tmp11;
+        Read(&tmp11, &buf);
+        scroll_type = static_cast<Input::ScrollType>(tmp11);
+
+        // pad1
+        Pad(&buf, 2);
+
+        // flags
+        uint32_t tmp12;
+        Read(&tmp12, &buf);
+        flags = static_cast<Input::ScrollFlags>(tmp12);
+
+        // increment
+        {
+          auto& integral = increment.integral;
+          auto& frac = increment.frac;
+
+          // integral
+          Read(&integral, &buf);
+
+          // frac
+          Read(&frac, &buf);
+        }
+      }
+      if (CaseEq(data_expr, Input::DeviceClassType::Touch)) {
+        data.touch.emplace();
+        auto& mode = (*data.touch).mode;
+        auto& num_touches = (*data.touch).num_touches;
+
+        // mode
+        uint8_t tmp13;
+        Read(&tmp13, &buf);
+        mode = static_cast<Input::TouchMode>(tmp13);
+
+        // num_touches
+        Read(&num_touches, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::DeviceEvent>(Input::DeviceEvent* event_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& deviceid = (*event_).deviceid;
+  auto& time = (*event_).time;
+  auto& detail = (*event_).detail;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& child = (*event_).child;
+  auto& root_x = (*event_).root_x;
+  auto& root_y = (*event_).root_y;
+  auto& event_x = (*event_).event_x;
+  auto& event_y = (*event_).event_y;
+  uint16_t buttons_len{};
+  uint16_t valuators_len{};
+  auto& sourceid = (*event_).sourceid;
+  auto& flags = (*event_).flags;
+  auto& mods = (*event_).mods;
+  auto& group = (*event_).group;
+  auto& button_mask = (*event_).button_mask;
+  size_t button_mask_len = button_mask.size();
+  auto& valuator_mask = (*event_).valuator_mask;
+  size_t valuator_mask_len = valuator_mask.size();
+  auto& axisvalues = (*event_).axisvalues;
+  size_t axisvalues_len = axisvalues.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // detail
+  Read(&detail, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // event_x
+  Read(&event_x, &buf);
+
+  // event_y
+  Read(&event_y, &buf);
+
+  // buttons_len
+  Read(&buttons_len, &buf);
+
+  // valuators_len
+  Read(&valuators_len, &buf);
+
+  // sourceid
+  Read(&sourceid, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // flags
+  uint32_t tmp14;
+  Read(&tmp14, &buf);
+  flags = static_cast<Input::KeyEventFlags>(tmp14);
+
+  // mods
+  {
+    auto& base = mods.base;
+    auto& latched = mods.latched;
+    auto& locked = mods.locked;
+    auto& effective = mods.effective;
+
+    // base
+    Read(&base, &buf);
+
+    // latched
+    Read(&latched, &buf);
+
+    // locked
+    Read(&locked, &buf);
+
+    // effective
+    Read(&effective, &buf);
+  }
+
+  // group
+  {
+    auto& base = group.base;
+    auto& latched = group.latched;
+    auto& locked = group.locked;
+    auto& effective = group.effective;
+
+    // base
+    Read(&base, &buf);
+
+    // latched
+    Read(&latched, &buf);
+
+    // locked
+    Read(&locked, &buf);
+
+    // effective
+    Read(&effective, &buf);
+  }
+
+  // button_mask
+  button_mask.resize(buttons_len);
+  for (auto& button_mask_elem : button_mask) {
+    // button_mask_elem
+    Read(&button_mask_elem, &buf);
+  }
+
+  // valuator_mask
+  valuator_mask.resize(valuators_len);
+  for (auto& valuator_mask_elem : valuator_mask) {
+    // valuator_mask_elem
+    Read(&valuator_mask_elem, &buf);
+  }
+
+  // axisvalues
+  auto sum15_ = SumOf([](auto& listelem_ref) { return PopCount(listelem_ref); },
+                      valuator_mask);
+  axisvalues.resize(sum15_);
+  for (auto& axisvalues_elem : axisvalues) {
+    // axisvalues_elem
+    {
+      auto& integral = axisvalues_elem.integral;
+      auto& frac = axisvalues_elem.frac;
+
+      // integral
+      Read(&integral, &buf);
+
+      // frac
+      Read(&frac, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::CrossingEvent>(Input::CrossingEvent* event_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& deviceid = (*event_).deviceid;
+  auto& time = (*event_).time;
+  auto& sourceid = (*event_).sourceid;
+  auto& mode = (*event_).mode;
+  auto& detail = (*event_).detail;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& child = (*event_).child;
+  auto& root_x = (*event_).root_x;
+  auto& root_y = (*event_).root_y;
+  auto& event_x = (*event_).event_x;
+  auto& event_y = (*event_).event_y;
+  auto& same_screen = (*event_).same_screen;
+  auto& focus = (*event_).focus;
+  uint16_t buttons_len{};
+  auto& mods = (*event_).mods;
+  auto& group = (*event_).group;
+  auto& buttons = (*event_).buttons;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // sourceid
+  Read(&sourceid, &buf);
+
+  // mode
+  uint8_t tmp16;
+  Read(&tmp16, &buf);
+  mode = static_cast<Input::NotifyMode>(tmp16);
+
+  // detail
+  uint8_t tmp17;
+  Read(&tmp17, &buf);
+  detail = static_cast<Input::NotifyDetail>(tmp17);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // event_x
+  Read(&event_x, &buf);
+
+  // event_y
+  Read(&event_y, &buf);
+
+  // same_screen
+  Read(&same_screen, &buf);
+
+  // focus
+  Read(&focus, &buf);
+
+  // buttons_len
+  Read(&buttons_len, &buf);
+
+  // mods
+  {
+    auto& base = mods.base;
+    auto& latched = mods.latched;
+    auto& locked = mods.locked;
+    auto& effective = mods.effective;
+
+    // base
+    Read(&base, &buf);
+
+    // latched
+    Read(&latched, &buf);
+
+    // locked
+    Read(&locked, &buf);
+
+    // effective
+    Read(&effective, &buf);
+  }
+
+  // group
+  {
+    auto& base = group.base;
+    auto& latched = group.latched;
+    auto& locked = group.locked;
+    auto& effective = group.effective;
+
+    // base
+    Read(&base, &buf);
+
+    // latched
+    Read(&latched, &buf);
+
+    // locked
+    Read(&locked, &buf);
+
+    // effective
+    Read(&effective, &buf);
+  }
+
+  // buttons
+  buttons.resize(buttons_len);
+  for (auto& buttons_elem : buttons) {
+    // buttons_elem
+    Read(&buttons_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::HierarchyEvent>(Input::HierarchyEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& deviceid = (*event_).deviceid;
+  auto& time = (*event_).time;
+  auto& flags = (*event_).flags;
+  uint16_t num_infos{};
+  auto& infos = (*event_).infos;
+  size_t infos_len = infos.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // flags
+  uint32_t tmp18;
+  Read(&tmp18, &buf);
+  flags = static_cast<Input::HierarchyMask>(tmp18);
+
+  // num_infos
+  Read(&num_infos, &buf);
+
+  // pad0
+  Pad(&buf, 10);
+
+  // infos
+  infos.resize(num_infos);
+  for (auto& infos_elem : infos) {
+    // infos_elem
+    {
+      auto& deviceid = infos_elem.deviceid;
+      auto& attachment = infos_elem.attachment;
+      auto& type = infos_elem.type;
+      auto& enabled = infos_elem.enabled;
+      auto& flags = infos_elem.flags;
+
+      // deviceid
+      Read(&deviceid, &buf);
+
+      // attachment
+      Read(&attachment, &buf);
+
+      // type
+      uint8_t tmp19;
+      Read(&tmp19, &buf);
+      type = static_cast<Input::DeviceType>(tmp19);
+
+      // enabled
+      Read(&enabled, &buf);
+
+      // pad0
+      Pad(&buf, 2);
+
+      // flags
+      uint32_t tmp20;
+      Read(&tmp20, &buf);
+      flags = static_cast<Input::HierarchyMask>(tmp20);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::PropertyEvent>(Input::PropertyEvent* event_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& deviceid = (*event_).deviceid;
+  auto& time = (*event_).time;
+  auto& property = (*event_).property;
+  auto& what = (*event_).what;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // property
+  Read(&property, &buf);
+
+  // what
+  uint8_t tmp21;
+  Read(&tmp21, &buf);
+  what = static_cast<Input::PropertyFlag>(tmp21);
+
+  // pad0
+  Pad(&buf, 11);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::RawDeviceEvent>(Input::RawDeviceEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& deviceid = (*event_).deviceid;
+  auto& time = (*event_).time;
+  auto& detail = (*event_).detail;
+  auto& sourceid = (*event_).sourceid;
+  uint16_t valuators_len{};
+  auto& flags = (*event_).flags;
+  auto& valuator_mask = (*event_).valuator_mask;
+  size_t valuator_mask_len = valuator_mask.size();
+  auto& axisvalues = (*event_).axisvalues;
+  size_t axisvalues_len = axisvalues.size();
+  auto& axisvalues_raw = (*event_).axisvalues_raw;
+  size_t axisvalues_raw_len = axisvalues_raw.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // detail
+  Read(&detail, &buf);
+
+  // sourceid
+  Read(&sourceid, &buf);
+
+  // valuators_len
+  Read(&valuators_len, &buf);
+
+  // flags
+  uint32_t tmp22;
+  Read(&tmp22, &buf);
+  flags = static_cast<Input::KeyEventFlags>(tmp22);
+
+  // pad0
+  Pad(&buf, 4);
+
+  // valuator_mask
+  valuator_mask.resize(valuators_len);
+  for (auto& valuator_mask_elem : valuator_mask) {
+    // valuator_mask_elem
+    Read(&valuator_mask_elem, &buf);
+  }
+
+  // axisvalues
+  auto sum23_ = SumOf([](auto& listelem_ref) { return PopCount(listelem_ref); },
+                      valuator_mask);
+  axisvalues.resize(sum23_);
+  for (auto& axisvalues_elem : axisvalues) {
+    // axisvalues_elem
+    {
+      auto& integral = axisvalues_elem.integral;
+      auto& frac = axisvalues_elem.frac;
+
+      // integral
+      Read(&integral, &buf);
+
+      // frac
+      Read(&frac, &buf);
+    }
+  }
+
+  // axisvalues_raw
+  auto sum24_ = SumOf([](auto& listelem_ref) { return PopCount(listelem_ref); },
+                      valuator_mask);
+  axisvalues_raw.resize(sum24_);
+  for (auto& axisvalues_raw_elem : axisvalues_raw) {
+    // axisvalues_raw_elem
+    {
+      auto& integral = axisvalues_raw_elem.integral;
+      auto& frac = axisvalues_raw_elem.frac;
+
+      // integral
+      Read(&integral, &buf);
+
+      // frac
+      Read(&frac, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::TouchOwnershipEvent>(Input::TouchOwnershipEvent* event_,
+                                           ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& deviceid = (*event_).deviceid;
+  auto& time = (*event_).time;
+  auto& touchid = (*event_).touchid;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& child = (*event_).child;
+  auto& sourceid = (*event_).sourceid;
+  auto& flags = (*event_).flags;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // touchid
+  Read(&touchid, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // sourceid
+  Read(&sourceid, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // flags
+  uint32_t tmp25;
+  Read(&tmp25, &buf);
+  flags = static_cast<Input::TouchOwnershipFlags>(tmp25);
+
+  // pad1
+  Pad(&buf, 8);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Input::BarrierEvent>(Input::BarrierEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& deviceid = (*event_).deviceid;
+  auto& time = (*event_).time;
+  auto& eventid = (*event_).eventid;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& barrier = (*event_).barrier;
+  auto& dtime = (*event_).dtime;
+  auto& flags = (*event_).flags;
+  auto& sourceid = (*event_).sourceid;
+  auto& root_x = (*event_).root_x;
+  auto& root_y = (*event_).root_y;
+  auto& dx = (*event_).dx;
+  auto& dy = (*event_).dy;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // eventid
+  Read(&eventid, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // barrier
+  Read(&barrier, &buf);
+
+  // dtime
+  Read(&dtime, &buf);
+
+  // flags
+  uint32_t tmp26;
+  Read(&tmp26, &buf);
+  flags = static_cast<Input::BarrierFlags>(tmp26);
+
+  // sourceid
+  Read(&sourceid, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // dx
+  {
+    auto& integral = dx.integral;
+    auto& frac = dx.frac;
+
+    // integral
+    Read(&integral, &buf);
+
+    // frac
+    Read(&frac, &buf);
+  }
+
+  // dy
+  {
+    auto& integral = dy.integral;
+    auto& frac = dy.frac;
+
+    // integral
+    Read(&integral, &buf);
+
+    // frac
+    Read(&frac, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+std::string Input::DeviceError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Input::DeviceError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Input::DeviceError>(Input::DeviceError* error_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Input::EventError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Input::EventError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Input::EventError>(Input::EventError* error_,
+                                  ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Input::ModeError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Input::ModeError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Input::ModeError>(Input::ModeError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Input::DeviceBusyError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Input::DeviceBusyError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Input::DeviceBusyError>(Input::DeviceBusyError* error_,
+                                       ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Input::ClassError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Input::ClassError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Input::ClassError>(Input::ClassError* error_,
+                                  ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+Future<Input::GetExtensionVersionReply> Input::GetExtensionVersion(
+    const Input::GetExtensionVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint16_t name_len{};
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // name_len
+  name_len = name.size();
+  buf.Write(&name_len);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetExtensionVersionReply>(
+      &buf, "Input::GetExtensionVersion", false);
+}
+
+Future<Input::GetExtensionVersionReply> Input::GetExtensionVersion(
+    const std::string& name) {
+  return Input::GetExtensionVersion(Input::GetExtensionVersionRequest{name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetExtensionVersionReply> detail::ReadReply<
+    Input::GetExtensionVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetExtensionVersionReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& server_major = (*reply).server_major;
+  auto& server_minor = (*reply).server_minor;
+  auto& present = (*reply).present;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // server_major
+  Read(&server_major, &buf);
+
+  // server_minor
+  Read(&server_minor, &buf);
+
+  // present
+  Read(&present, &buf);
+
+  // pad0
+  Pad(&buf, 19);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::ListInputDevicesReply> Input::ListInputDevices(
+    const Input::ListInputDevicesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::ListInputDevicesReply>(
+      &buf, "Input::ListInputDevices", false);
+}
+
+Future<Input::ListInputDevicesReply> Input::ListInputDevices() {
+  return Input::ListInputDevices(Input::ListInputDevicesRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::ListInputDevicesReply> detail::ReadReply<
+    Input::ListInputDevicesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::ListInputDevicesReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint8_t devices_len{};
+  auto& devices = (*reply).devices;
+  auto& infos = (*reply).infos;
+  size_t infos_len = infos.size();
+  auto& names = (*reply).names;
+  size_t names_len = names.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // devices_len
+  Read(&devices_len, &buf);
+
+  // pad0
+  Pad(&buf, 23);
+
+  // devices
+  devices.resize(devices_len);
+  for (auto& devices_elem : devices) {
+    // devices_elem
+    {
+      auto& device_type = devices_elem.device_type;
+      auto& device_id = devices_elem.device_id;
+      auto& num_class_info = devices_elem.num_class_info;
+      auto& device_use = devices_elem.device_use;
+
+      // device_type
+      Read(&device_type, &buf);
+
+      // device_id
+      Read(&device_id, &buf);
+
+      // num_class_info
+      Read(&num_class_info, &buf);
+
+      // device_use
+      uint8_t tmp27;
+      Read(&tmp27, &buf);
+      device_use = static_cast<Input::DeviceUse>(tmp27);
+
+      // pad0
+      Pad(&buf, 1);
+    }
+  }
+
+  // infos
+  auto sum28_ = SumOf(
+      [](auto& listelem_ref) {
+        auto& device_type = listelem_ref.device_type;
+        auto& device_id = listelem_ref.device_id;
+        auto& num_class_info = listelem_ref.num_class_info;
+        auto& device_use = listelem_ref.device_use;
+
+        return num_class_info;
+      },
+      devices);
+  infos.resize(sum28_);
+  for (auto& infos_elem : infos) {
+    // infos_elem
+    {
+      Input::InputClass class_id{};
+      auto& len = infos_elem.len;
+      auto& info = infos_elem;
+
+      // class_id
+      uint8_t tmp29;
+      Read(&tmp29, &buf);
+      class_id = static_cast<Input::InputClass>(tmp29);
+
+      // len
+      Read(&len, &buf);
+
+      // info
+      auto info_expr = class_id;
+      if (CaseEq(info_expr, Input::InputClass::Key)) {
+        info.key.emplace();
+        auto& min_keycode = (*info.key).min_keycode;
+        auto& max_keycode = (*info.key).max_keycode;
+        auto& num_keys = (*info.key).num_keys;
+
+        // min_keycode
+        Read(&min_keycode, &buf);
+
+        // max_keycode
+        Read(&max_keycode, &buf);
+
+        // num_keys
+        Read(&num_keys, &buf);
+
+        // pad0
+        Pad(&buf, 2);
+      }
+      if (CaseEq(info_expr, Input::InputClass::Button)) {
+        info.button.emplace();
+        auto& num_buttons = (*info.button).num_buttons;
+
+        // num_buttons
+        Read(&num_buttons, &buf);
+      }
+      if (CaseEq(info_expr, Input::InputClass::Valuator)) {
+        info.valuator.emplace();
+        uint8_t axes_len{};
+        auto& mode = (*info.valuator).mode;
+        auto& motion_size = (*info.valuator).motion_size;
+        auto& axes = (*info.valuator).axes;
+
+        // axes_len
+        Read(&axes_len, &buf);
+
+        // mode
+        uint8_t tmp30;
+        Read(&tmp30, &buf);
+        mode = static_cast<Input::ValuatorMode>(tmp30);
+
+        // motion_size
+        Read(&motion_size, &buf);
+
+        // axes
+        axes.resize(axes_len);
+        for (auto& axes_elem : axes) {
+          // axes_elem
+          {
+            auto& resolution = axes_elem.resolution;
+            auto& minimum = axes_elem.minimum;
+            auto& maximum = axes_elem.maximum;
+
+            // resolution
+            Read(&resolution, &buf);
+
+            // minimum
+            Read(&minimum, &buf);
+
+            // maximum
+            Read(&maximum, &buf);
+          }
+        }
+      }
+    }
+  }
+
+  // names
+  names.resize(devices_len);
+  for (auto& names_elem : names) {
+    // names_elem
+    {
+      uint8_t name_len{};
+      auto& name = names_elem.name;
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // name
+      name.resize(name_len);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+    }
+  }
+
+  // pad1
+  Pad(&buf, 1);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::OpenDeviceReply> Input::OpenDevice(
+    const Input::OpenDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::OpenDeviceReply>(
+      &buf, "Input::OpenDevice", false);
+}
+
+Future<Input::OpenDeviceReply> Input::OpenDevice(const uint8_t& device_id) {
+  return Input::OpenDevice(Input::OpenDeviceRequest{device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::OpenDeviceReply> detail::ReadReply<
+    Input::OpenDeviceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::OpenDeviceReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint8_t num_classes{};
+  auto& class_info = (*reply).class_info;
+  size_t class_info_len = class_info.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_classes
+  Read(&num_classes, &buf);
+
+  // pad0
+  Pad(&buf, 23);
+
+  // class_info
+  class_info.resize(num_classes);
+  for (auto& class_info_elem : class_info) {
+    // class_info_elem
+    {
+      auto& class_id = class_info_elem.class_id;
+      auto& event_type_base = class_info_elem.event_type_base;
+
+      // class_id
+      uint8_t tmp31;
+      Read(&tmp31, &buf);
+      class_id = static_cast<Input::InputClass>(tmp31);
+
+      // event_type_base
+      Read(&event_type_base, &buf);
+    }
+  }
+
+  // pad1
+  Align(&buf, 4);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::CloseDevice(const Input::CloseDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::CloseDevice", false);
+}
+
+Future<void> Input::CloseDevice(const uint8_t& device_id) {
+  return Input::CloseDevice(Input::CloseDeviceRequest{device_id});
+}
+
+Future<Input::SetDeviceModeReply> Input::SetDeviceMode(
+    const Input::SetDeviceModeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // mode
+  uint8_t tmp32;
+  tmp32 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp32);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::SetDeviceModeReply>(
+      &buf, "Input::SetDeviceMode", false);
+}
+
+Future<Input::SetDeviceModeReply> Input::SetDeviceMode(
+    const uint8_t& device_id,
+    const ValuatorMode& mode) {
+  return Input::SetDeviceMode(Input::SetDeviceModeRequest{device_id, mode});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::SetDeviceModeReply> detail::ReadReply<
+    Input::SetDeviceModeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::SetDeviceModeReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  uint8_t tmp33;
+  Read(&tmp33, &buf);
+  status = static_cast<GrabStatus>(tmp33);
+
+  // pad0
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::SelectExtensionEvent(
+    const Input::SelectExtensionEventRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  uint16_t num_classes{};
+  auto& classes = request.classes;
+  size_t classes_len = classes.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // num_classes
+  num_classes = classes.size();
+  buf.Write(&num_classes);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // classes
+  DCHECK_EQ(static_cast<size_t>(num_classes), classes.size());
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    buf.Write(&classes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::SelectExtensionEvent",
+                                        false);
+}
+
+Future<void> Input::SelectExtensionEvent(
+    const Window& window,
+    const std::vector<EventClass>& classes) {
+  return Input::SelectExtensionEvent(
+      Input::SelectExtensionEventRequest{window, classes});
+}
+
+Future<Input::GetSelectedExtensionEventsReply>
+Input::GetSelectedExtensionEvents(
+    const Input::GetSelectedExtensionEventsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetSelectedExtensionEventsReply>(
+      &buf, "Input::GetSelectedExtensionEvents", false);
+}
+
+Future<Input::GetSelectedExtensionEventsReply>
+Input::GetSelectedExtensionEvents(const Window& window) {
+  return Input::GetSelectedExtensionEvents(
+      Input::GetSelectedExtensionEventsRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetSelectedExtensionEventsReply> detail::ReadReply<
+    Input::GetSelectedExtensionEventsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetSelectedExtensionEventsReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint16_t num_this_classes{};
+  uint16_t num_all_classes{};
+  auto& this_classes = (*reply).this_classes;
+  size_t this_classes_len = this_classes.size();
+  auto& all_classes = (*reply).all_classes;
+  size_t all_classes_len = all_classes.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_this_classes
+  Read(&num_this_classes, &buf);
+
+  // num_all_classes
+  Read(&num_all_classes, &buf);
+
+  // pad0
+  Pad(&buf, 20);
+
+  // this_classes
+  this_classes.resize(num_this_classes);
+  for (auto& this_classes_elem : this_classes) {
+    // this_classes_elem
+    Read(&this_classes_elem, &buf);
+  }
+
+  // all_classes
+  all_classes.resize(num_all_classes);
+  for (auto& all_classes_elem : all_classes) {
+    // all_classes_elem
+    Read(&all_classes_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::ChangeDeviceDontPropagateList(
+    const Input::ChangeDeviceDontPropagateListRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  uint16_t num_classes{};
+  auto& mode = request.mode;
+  auto& classes = request.classes;
+  size_t classes_len = classes.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // num_classes
+  num_classes = classes.size();
+  buf.Write(&num_classes);
+
+  // mode
+  uint8_t tmp34;
+  tmp34 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp34);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // classes
+  DCHECK_EQ(static_cast<size_t>(num_classes), classes.size());
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    buf.Write(&classes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(
+      &buf, "Input::ChangeDeviceDontPropagateList", false);
+}
+
+Future<void> Input::ChangeDeviceDontPropagateList(
+    const Window& window,
+    const PropagateMode& mode,
+    const std::vector<EventClass>& classes) {
+  return Input::ChangeDeviceDontPropagateList(
+      Input::ChangeDeviceDontPropagateListRequest{window, mode, classes});
+}
+
+Future<Input::GetDeviceDontPropagateListReply>
+Input::GetDeviceDontPropagateList(
+    const Input::GetDeviceDontPropagateListRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetDeviceDontPropagateListReply>(
+      &buf, "Input::GetDeviceDontPropagateList", false);
+}
+
+Future<Input::GetDeviceDontPropagateListReply>
+Input::GetDeviceDontPropagateList(const Window& window) {
+  return Input::GetDeviceDontPropagateList(
+      Input::GetDeviceDontPropagateListRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetDeviceDontPropagateListReply> detail::ReadReply<
+    Input::GetDeviceDontPropagateListReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetDeviceDontPropagateListReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint16_t num_classes{};
+  auto& classes = (*reply).classes;
+  size_t classes_len = classes.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_classes
+  Read(&num_classes, &buf);
+
+  // pad0
+  Pad(&buf, 22);
+
+  // classes
+  classes.resize(num_classes);
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    Read(&classes_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::GetDeviceMotionEventsReply> Input::GetDeviceMotionEvents(
+    const Input::GetDeviceMotionEventsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& start = request.start;
+  auto& stop = request.stop;
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // start
+  buf.Write(&start);
+
+  // stop
+  buf.Write(&stop);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetDeviceMotionEventsReply>(
+      &buf, "Input::GetDeviceMotionEvents", false);
+}
+
+Future<Input::GetDeviceMotionEventsReply> Input::GetDeviceMotionEvents(
+    const Time& start,
+    const Time& stop,
+    const uint8_t& device_id) {
+  return Input::GetDeviceMotionEvents(
+      Input::GetDeviceMotionEventsRequest{start, stop, device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetDeviceMotionEventsReply> detail::ReadReply<
+    Input::GetDeviceMotionEventsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetDeviceMotionEventsReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint32_t num_events{};
+  auto& num_axes = (*reply).num_axes;
+  auto& device_mode = (*reply).device_mode;
+  auto& events = (*reply).events;
+  size_t events_len = events.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_events
+  Read(&num_events, &buf);
+
+  // num_axes
+  Read(&num_axes, &buf);
+
+  // device_mode
+  uint8_t tmp35;
+  Read(&tmp35, &buf);
+  device_mode = static_cast<Input::ValuatorMode>(tmp35);
+
+  // pad0
+  Pad(&buf, 18);
+
+  // events
+  events.resize(num_events);
+  for (auto& events_elem : events) {
+    // events_elem
+    {
+      auto& time = events_elem.time;
+      auto& axisvalues = events_elem.axisvalues;
+      size_t axisvalues_len = axisvalues.size();
+
+      // time
+      Read(&time, &buf);
+
+      // axisvalues
+      axisvalues.resize(num_axes);
+      for (auto& axisvalues_elem : axisvalues) {
+        // axisvalues_elem
+        Read(&axisvalues_elem, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::ChangeKeyboardDeviceReply> Input::ChangeKeyboardDevice(
+    const Input::ChangeKeyboardDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::ChangeKeyboardDeviceReply>(
+      &buf, "Input::ChangeKeyboardDevice", false);
+}
+
+Future<Input::ChangeKeyboardDeviceReply> Input::ChangeKeyboardDevice(
+    const uint8_t& device_id) {
+  return Input::ChangeKeyboardDevice(
+      Input::ChangeKeyboardDeviceRequest{device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::ChangeKeyboardDeviceReply> detail::ReadReply<
+    Input::ChangeKeyboardDeviceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::ChangeKeyboardDeviceReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  uint8_t tmp36;
+  Read(&tmp36, &buf);
+  status = static_cast<GrabStatus>(tmp36);
+
+  // pad0
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::ChangePointerDeviceReply> Input::ChangePointerDevice(
+    const Input::ChangePointerDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& x_axis = request.x_axis;
+  auto& y_axis = request.y_axis;
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // x_axis
+  buf.Write(&x_axis);
+
+  // y_axis
+  buf.Write(&y_axis);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 1);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::ChangePointerDeviceReply>(
+      &buf, "Input::ChangePointerDevice", false);
+}
+
+Future<Input::ChangePointerDeviceReply> Input::ChangePointerDevice(
+    const uint8_t& x_axis,
+    const uint8_t& y_axis,
+    const uint8_t& device_id) {
+  return Input::ChangePointerDevice(
+      Input::ChangePointerDeviceRequest{x_axis, y_axis, device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::ChangePointerDeviceReply> detail::ReadReply<
+    Input::ChangePointerDeviceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::ChangePointerDeviceReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  uint8_t tmp37;
+  Read(&tmp37, &buf);
+  status = static_cast<GrabStatus>(tmp37);
+
+  // pad0
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::GrabDeviceReply> Input::GrabDevice(
+    const Input::GrabDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& grab_window = request.grab_window;
+  auto& time = request.time;
+  uint16_t num_classes{};
+  auto& this_device_mode = request.this_device_mode;
+  auto& other_device_mode = request.other_device_mode;
+  auto& owner_events = request.owner_events;
+  auto& device_id = request.device_id;
+  auto& classes = request.classes;
+  size_t classes_len = classes.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // time
+  buf.Write(&time);
+
+  // num_classes
+  num_classes = classes.size();
+  buf.Write(&num_classes);
+
+  // this_device_mode
+  uint8_t tmp38;
+  tmp38 = static_cast<uint8_t>(this_device_mode);
+  buf.Write(&tmp38);
+
+  // other_device_mode
+  uint8_t tmp39;
+  tmp39 = static_cast<uint8_t>(other_device_mode);
+  buf.Write(&tmp39);
+
+  // owner_events
+  buf.Write(&owner_events);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // classes
+  DCHECK_EQ(static_cast<size_t>(num_classes), classes.size());
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    buf.Write(&classes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GrabDeviceReply>(
+      &buf, "Input::GrabDevice", false);
+}
+
+Future<Input::GrabDeviceReply> Input::GrabDevice(
+    const Window& grab_window,
+    const Time& time,
+    const GrabMode& this_device_mode,
+    const GrabMode& other_device_mode,
+    const uint8_t& owner_events,
+    const uint8_t& device_id,
+    const std::vector<EventClass>& classes) {
+  return Input::GrabDevice(Input::GrabDeviceRequest{
+      grab_window, time, this_device_mode, other_device_mode, owner_events,
+      device_id, classes});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GrabDeviceReply> detail::ReadReply<
+    Input::GrabDeviceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GrabDeviceReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  uint8_t tmp40;
+  Read(&tmp40, &buf);
+  status = static_cast<GrabStatus>(tmp40);
+
+  // pad0
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::UngrabDevice(const Input::UngrabDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& time = request.time;
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // time
+  buf.Write(&time);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::UngrabDevice", false);
+}
+
+Future<void> Input::UngrabDevice(const Time& time, const uint8_t& device_id) {
+  return Input::UngrabDevice(Input::UngrabDeviceRequest{time, device_id});
+}
+
+Future<void> Input::GrabDeviceKey(const Input::GrabDeviceKeyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& grab_window = request.grab_window;
+  uint16_t num_classes{};
+  auto& modifiers = request.modifiers;
+  auto& modifier_device = request.modifier_device;
+  auto& grabbed_device = request.grabbed_device;
+  auto& key = request.key;
+  auto& this_device_mode = request.this_device_mode;
+  auto& other_device_mode = request.other_device_mode;
+  auto& owner_events = request.owner_events;
+  auto& classes = request.classes;
+  size_t classes_len = classes.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // num_classes
+  num_classes = classes.size();
+  buf.Write(&num_classes);
+
+  // modifiers
+  uint16_t tmp41;
+  tmp41 = static_cast<uint16_t>(modifiers);
+  buf.Write(&tmp41);
+
+  // modifier_device
+  buf.Write(&modifier_device);
+
+  // grabbed_device
+  buf.Write(&grabbed_device);
+
+  // key
+  buf.Write(&key);
+
+  // this_device_mode
+  uint8_t tmp42;
+  tmp42 = static_cast<uint8_t>(this_device_mode);
+  buf.Write(&tmp42);
+
+  // other_device_mode
+  uint8_t tmp43;
+  tmp43 = static_cast<uint8_t>(other_device_mode);
+  buf.Write(&tmp43);
+
+  // owner_events
+  buf.Write(&owner_events);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // classes
+  DCHECK_EQ(static_cast<size_t>(num_classes), classes.size());
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    buf.Write(&classes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::GrabDeviceKey", false);
+}
+
+Future<void> Input::GrabDeviceKey(const Window& grab_window,
+                                  const ModMask& modifiers,
+                                  const uint8_t& modifier_device,
+                                  const uint8_t& grabbed_device,
+                                  const uint8_t& key,
+                                  const GrabMode& this_device_mode,
+                                  const GrabMode& other_device_mode,
+                                  const uint8_t& owner_events,
+                                  const std::vector<EventClass>& classes) {
+  return Input::GrabDeviceKey(Input::GrabDeviceKeyRequest{
+      grab_window, modifiers, modifier_device, grabbed_device, key,
+      this_device_mode, other_device_mode, owner_events, classes});
+}
+
+Future<void> Input::UngrabDeviceKey(
+    const Input::UngrabDeviceKeyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& grabWindow = request.grabWindow;
+  auto& modifiers = request.modifiers;
+  auto& modifier_device = request.modifier_device;
+  auto& key = request.key;
+  auto& grabbed_device = request.grabbed_device;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grabWindow
+  buf.Write(&grabWindow);
+
+  // modifiers
+  uint16_t tmp44;
+  tmp44 = static_cast<uint16_t>(modifiers);
+  buf.Write(&tmp44);
+
+  // modifier_device
+  buf.Write(&modifier_device);
+
+  // key
+  buf.Write(&key);
+
+  // grabbed_device
+  buf.Write(&grabbed_device);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::UngrabDeviceKey", false);
+}
+
+Future<void> Input::UngrabDeviceKey(const Window& grabWindow,
+                                    const ModMask& modifiers,
+                                    const uint8_t& modifier_device,
+                                    const uint8_t& key,
+                                    const uint8_t& grabbed_device) {
+  return Input::UngrabDeviceKey(Input::UngrabDeviceKeyRequest{
+      grabWindow, modifiers, modifier_device, key, grabbed_device});
+}
+
+Future<void> Input::GrabDeviceButton(
+    const Input::GrabDeviceButtonRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& grab_window = request.grab_window;
+  auto& grabbed_device = request.grabbed_device;
+  auto& modifier_device = request.modifier_device;
+  uint16_t num_classes{};
+  auto& modifiers = request.modifiers;
+  auto& this_device_mode = request.this_device_mode;
+  auto& other_device_mode = request.other_device_mode;
+  auto& button = request.button;
+  auto& owner_events = request.owner_events;
+  auto& classes = request.classes;
+  size_t classes_len = classes.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // grabbed_device
+  buf.Write(&grabbed_device);
+
+  // modifier_device
+  buf.Write(&modifier_device);
+
+  // num_classes
+  num_classes = classes.size();
+  buf.Write(&num_classes);
+
+  // modifiers
+  uint16_t tmp45;
+  tmp45 = static_cast<uint16_t>(modifiers);
+  buf.Write(&tmp45);
+
+  // this_device_mode
+  uint8_t tmp46;
+  tmp46 = static_cast<uint8_t>(this_device_mode);
+  buf.Write(&tmp46);
+
+  // other_device_mode
+  uint8_t tmp47;
+  tmp47 = static_cast<uint8_t>(other_device_mode);
+  buf.Write(&tmp47);
+
+  // button
+  buf.Write(&button);
+
+  // owner_events
+  buf.Write(&owner_events);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // classes
+  DCHECK_EQ(static_cast<size_t>(num_classes), classes.size());
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    buf.Write(&classes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::GrabDeviceButton", false);
+}
+
+Future<void> Input::GrabDeviceButton(const Window& grab_window,
+                                     const uint8_t& grabbed_device,
+                                     const uint8_t& modifier_device,
+                                     const ModMask& modifiers,
+                                     const GrabMode& this_device_mode,
+                                     const GrabMode& other_device_mode,
+                                     const uint8_t& button,
+                                     const uint8_t& owner_events,
+                                     const std::vector<EventClass>& classes) {
+  return Input::GrabDeviceButton(Input::GrabDeviceButtonRequest{
+      grab_window, grabbed_device, modifier_device, modifiers, this_device_mode,
+      other_device_mode, button, owner_events, classes});
+}
+
+Future<void> Input::UngrabDeviceButton(
+    const Input::UngrabDeviceButtonRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& grab_window = request.grab_window;
+  auto& modifiers = request.modifiers;
+  auto& modifier_device = request.modifier_device;
+  auto& button = request.button;
+  auto& grabbed_device = request.grabbed_device;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // modifiers
+  uint16_t tmp48;
+  tmp48 = static_cast<uint16_t>(modifiers);
+  buf.Write(&tmp48);
+
+  // modifier_device
+  buf.Write(&modifier_device);
+
+  // button
+  buf.Write(&button);
+
+  // grabbed_device
+  buf.Write(&grabbed_device);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::UngrabDeviceButton",
+                                        false);
+}
+
+Future<void> Input::UngrabDeviceButton(const Window& grab_window,
+                                       const ModMask& modifiers,
+                                       const uint8_t& modifier_device,
+                                       const uint8_t& button,
+                                       const uint8_t& grabbed_device) {
+  return Input::UngrabDeviceButton(Input::UngrabDeviceButtonRequest{
+      grab_window, modifiers, modifier_device, button, grabbed_device});
+}
+
+Future<void> Input::AllowDeviceEvents(
+    const Input::AllowDeviceEventsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& time = request.time;
+  auto& mode = request.mode;
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // time
+  buf.Write(&time);
+
+  // mode
+  uint8_t tmp49;
+  tmp49 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp49);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::AllowDeviceEvents",
+                                        false);
+}
+
+Future<void> Input::AllowDeviceEvents(const Time& time,
+                                      const DeviceInputMode& mode,
+                                      const uint8_t& device_id) {
+  return Input::AllowDeviceEvents(
+      Input::AllowDeviceEventsRequest{time, mode, device_id});
+}
+
+Future<Input::GetDeviceFocusReply> Input::GetDeviceFocus(
+    const Input::GetDeviceFocusRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 20;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetDeviceFocusReply>(
+      &buf, "Input::GetDeviceFocus", false);
+}
+
+Future<Input::GetDeviceFocusReply> Input::GetDeviceFocus(
+    const uint8_t& device_id) {
+  return Input::GetDeviceFocus(Input::GetDeviceFocusRequest{device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetDeviceFocusReply> detail::ReadReply<
+    Input::GetDeviceFocusReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetDeviceFocusReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& focus = (*reply).focus;
+  auto& time = (*reply).time;
+  auto& revert_to = (*reply).revert_to;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // focus
+  Read(&focus, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // revert_to
+  uint8_t tmp50;
+  Read(&tmp50, &buf);
+  revert_to = static_cast<InputFocus>(tmp50);
+
+  // pad0
+  Pad(&buf, 15);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::SetDeviceFocus(
+    const Input::SetDeviceFocusRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& focus = request.focus;
+  auto& time = request.time;
+  auto& revert_to = request.revert_to;
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 21;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // focus
+  buf.Write(&focus);
+
+  // time
+  buf.Write(&time);
+
+  // revert_to
+  uint8_t tmp51;
+  tmp51 = static_cast<uint8_t>(revert_to);
+  buf.Write(&tmp51);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::SetDeviceFocus", false);
+}
+
+Future<void> Input::SetDeviceFocus(const Window& focus,
+                                   const Time& time,
+                                   const InputFocus& revert_to,
+                                   const uint8_t& device_id) {
+  return Input::SetDeviceFocus(
+      Input::SetDeviceFocusRequest{focus, time, revert_to, device_id});
+}
+
+Future<Input::GetFeedbackControlReply> Input::GetFeedbackControl(
+    const Input::GetFeedbackControlRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 22;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetFeedbackControlReply>(
+      &buf, "Input::GetFeedbackControl", false);
+}
+
+Future<Input::GetFeedbackControlReply> Input::GetFeedbackControl(
+    const uint8_t& device_id) {
+  return Input::GetFeedbackControl(Input::GetFeedbackControlRequest{device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetFeedbackControlReply> detail::ReadReply<
+    Input::GetFeedbackControlReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetFeedbackControlReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint16_t num_feedbacks{};
+  auto& feedbacks = (*reply).feedbacks;
+  size_t feedbacks_len = feedbacks.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_feedbacks
+  Read(&num_feedbacks, &buf);
+
+  // pad0
+  Pad(&buf, 22);
+
+  // feedbacks
+  feedbacks.resize(num_feedbacks);
+  for (auto& feedbacks_elem : feedbacks) {
+    // feedbacks_elem
+    {
+      Input::FeedbackClass class_id{};
+      auto& feedback_id = feedbacks_elem.feedback_id;
+      auto& len = feedbacks_elem.len;
+      auto& data = feedbacks_elem;
+
+      // class_id
+      uint8_t tmp52;
+      Read(&tmp52, &buf);
+      class_id = static_cast<Input::FeedbackClass>(tmp52);
+
+      // feedback_id
+      Read(&feedback_id, &buf);
+
+      // len
+      Read(&len, &buf);
+
+      // data
+      auto data_expr = class_id;
+      if (CaseEq(data_expr, Input::FeedbackClass::Keyboard)) {
+        data.keyboard.emplace();
+        auto& pitch = (*data.keyboard).pitch;
+        auto& duration = (*data.keyboard).duration;
+        auto& led_mask = (*data.keyboard).led_mask;
+        auto& led_values = (*data.keyboard).led_values;
+        auto& global_auto_repeat = (*data.keyboard).global_auto_repeat;
+        auto& click = (*data.keyboard).click;
+        auto& percent = (*data.keyboard).percent;
+        auto& auto_repeats = (*data.keyboard).auto_repeats;
+        size_t auto_repeats_len = auto_repeats.size();
+
+        // pitch
+        Read(&pitch, &buf);
+
+        // duration
+        Read(&duration, &buf);
+
+        // led_mask
+        Read(&led_mask, &buf);
+
+        // led_values
+        Read(&led_values, &buf);
+
+        // global_auto_repeat
+        Read(&global_auto_repeat, &buf);
+
+        // click
+        Read(&click, &buf);
+
+        // percent
+        Read(&percent, &buf);
+
+        // pad0
+        Pad(&buf, 1);
+
+        // auto_repeats
+        for (auto& auto_repeats_elem : auto_repeats) {
+          // auto_repeats_elem
+          Read(&auto_repeats_elem, &buf);
+        }
+      }
+      if (CaseEq(data_expr, Input::FeedbackClass::Pointer)) {
+        data.pointer.emplace();
+        auto& accel_num = (*data.pointer).accel_num;
+        auto& accel_denom = (*data.pointer).accel_denom;
+        auto& threshold = (*data.pointer).threshold;
+
+        // pad1
+        Pad(&buf, 2);
+
+        // accel_num
+        Read(&accel_num, &buf);
+
+        // accel_denom
+        Read(&accel_denom, &buf);
+
+        // threshold
+        Read(&threshold, &buf);
+      }
+      if (CaseEq(data_expr, Input::FeedbackClass::String)) {
+        data.string.emplace();
+        auto& max_symbols = (*data.string).max_symbols;
+        uint16_t num_keysyms{};
+        auto& keysyms = (*data.string).keysyms;
+        size_t keysyms_len = keysyms.size();
+
+        // max_symbols
+        Read(&max_symbols, &buf);
+
+        // num_keysyms
+        Read(&num_keysyms, &buf);
+
+        // keysyms
+        keysyms.resize(num_keysyms);
+        for (auto& keysyms_elem : keysyms) {
+          // keysyms_elem
+          Read(&keysyms_elem, &buf);
+        }
+      }
+      if (CaseEq(data_expr, Input::FeedbackClass::Integer)) {
+        data.integer.emplace();
+        auto& resolution = (*data.integer).resolution;
+        auto& min_value = (*data.integer).min_value;
+        auto& max_value = (*data.integer).max_value;
+
+        // resolution
+        Read(&resolution, &buf);
+
+        // min_value
+        Read(&min_value, &buf);
+
+        // max_value
+        Read(&max_value, &buf);
+      }
+      if (CaseEq(data_expr, Input::FeedbackClass::Led)) {
+        data.led.emplace();
+        auto& led_mask = (*data.led).led_mask;
+        auto& led_values = (*data.led).led_values;
+
+        // led_mask
+        Read(&led_mask, &buf);
+
+        // led_values
+        Read(&led_values, &buf);
+      }
+      if (CaseEq(data_expr, Input::FeedbackClass::Bell)) {
+        data.bell.emplace();
+        auto& percent = (*data.bell).percent;
+        auto& pitch = (*data.bell).pitch;
+        auto& duration = (*data.bell).duration;
+
+        // percent
+        Read(&percent, &buf);
+
+        // pad2
+        Pad(&buf, 3);
+
+        // pitch
+        Read(&pitch, &buf);
+
+        // duration
+        Read(&duration, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::ChangeFeedbackControl(
+    const Input::ChangeFeedbackControlRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mask = request.mask;
+  auto& device_id = request.device_id;
+  auto& feedback_id = request.feedback_id;
+  auto& feedback = request.feedback;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 23;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // mask
+  uint32_t tmp53;
+  tmp53 = static_cast<uint32_t>(mask);
+  buf.Write(&tmp53);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // feedback_id
+  buf.Write(&feedback_id);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // feedback
+  {
+    FeedbackClass class_id{};
+    auto& feedback_id = feedback.feedback_id;
+    auto& len = feedback.len;
+    auto& data = feedback;
+
+    // class_id
+    SwitchVar(FeedbackClass::Keyboard, data.keyboard.has_value(), false,
+              &class_id);
+    SwitchVar(FeedbackClass::Pointer, data.pointer.has_value(), false,
+              &class_id);
+    SwitchVar(FeedbackClass::String, data.string.has_value(), false, &class_id);
+    SwitchVar(FeedbackClass::Integer, data.integer.has_value(), false,
+              &class_id);
+    SwitchVar(FeedbackClass::Led, data.led.has_value(), false, &class_id);
+    SwitchVar(FeedbackClass::Bell, data.bell.has_value(), false, &class_id);
+    uint8_t tmp54;
+    tmp54 = static_cast<uint8_t>(class_id);
+    buf.Write(&tmp54);
+
+    // feedback_id
+    buf.Write(&feedback_id);
+
+    // len
+    buf.Write(&len);
+
+    // data
+    auto data_expr = class_id;
+    if (CaseEq(data_expr, FeedbackClass::Keyboard)) {
+      auto& key = (*data.keyboard).key;
+      auto& auto_repeat_mode = (*data.keyboard).auto_repeat_mode;
+      auto& key_click_percent = (*data.keyboard).key_click_percent;
+      auto& bell_percent = (*data.keyboard).bell_percent;
+      auto& bell_pitch = (*data.keyboard).bell_pitch;
+      auto& bell_duration = (*data.keyboard).bell_duration;
+      auto& led_mask = (*data.keyboard).led_mask;
+      auto& led_values = (*data.keyboard).led_values;
+
+      // key
+      buf.Write(&key);
+
+      // auto_repeat_mode
+      buf.Write(&auto_repeat_mode);
+
+      // key_click_percent
+      buf.Write(&key_click_percent);
+
+      // bell_percent
+      buf.Write(&bell_percent);
+
+      // bell_pitch
+      buf.Write(&bell_pitch);
+
+      // bell_duration
+      buf.Write(&bell_duration);
+
+      // led_mask
+      buf.Write(&led_mask);
+
+      // led_values
+      buf.Write(&led_values);
+    }
+    if (CaseEq(data_expr, FeedbackClass::Pointer)) {
+      auto& num = (*data.pointer).num;
+      auto& denom = (*data.pointer).denom;
+      auto& threshold = (*data.pointer).threshold;
+
+      // pad0
+      Pad(&buf, 2);
+
+      // num
+      buf.Write(&num);
+
+      // denom
+      buf.Write(&denom);
+
+      // threshold
+      buf.Write(&threshold);
+    }
+    if (CaseEq(data_expr, FeedbackClass::String)) {
+      uint16_t num_keysyms{};
+      auto& keysyms = (*data.string).keysyms;
+      size_t keysyms_len = keysyms.size();
+
+      // pad1
+      Pad(&buf, 2);
+
+      // num_keysyms
+      num_keysyms = keysyms.size();
+      buf.Write(&num_keysyms);
+
+      // keysyms
+      DCHECK_EQ(static_cast<size_t>(num_keysyms), keysyms.size());
+      for (auto& keysyms_elem : keysyms) {
+        // keysyms_elem
+        buf.Write(&keysyms_elem);
+      }
+    }
+    if (CaseEq(data_expr, FeedbackClass::Integer)) {
+      auto& int_to_display = (*data.integer).int_to_display;
+
+      // int_to_display
+      buf.Write(&int_to_display);
+    }
+    if (CaseEq(data_expr, FeedbackClass::Led)) {
+      auto& led_mask = (*data.led).led_mask;
+      auto& led_values = (*data.led).led_values;
+
+      // led_mask
+      buf.Write(&led_mask);
+
+      // led_values
+      buf.Write(&led_values);
+    }
+    if (CaseEq(data_expr, FeedbackClass::Bell)) {
+      auto& percent = (*data.bell).percent;
+      auto& pitch = (*data.bell).pitch;
+      auto& duration = (*data.bell).duration;
+
+      // percent
+      buf.Write(&percent);
+
+      // pad2
+      Pad(&buf, 3);
+
+      // pitch
+      buf.Write(&pitch);
+
+      // duration
+      buf.Write(&duration);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::ChangeFeedbackControl",
+                                        false);
+}
+
+Future<void> Input::ChangeFeedbackControl(const ChangeFeedbackControlMask& mask,
+                                          const uint8_t& device_id,
+                                          const uint8_t& feedback_id,
+                                          const FeedbackCtl& feedback) {
+  return Input::ChangeFeedbackControl(Input::ChangeFeedbackControlRequest{
+      mask, device_id, feedback_id, feedback});
+}
+
+Future<Input::GetDeviceKeyMappingReply> Input::GetDeviceKeyMapping(
+    const Input::GetDeviceKeyMappingRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+  auto& first_keycode = request.first_keycode;
+  auto& count = request.count;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 24;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // first_keycode
+  buf.Write(&first_keycode);
+
+  // count
+  buf.Write(&count);
+
+  // pad0
+  Pad(&buf, 1);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetDeviceKeyMappingReply>(
+      &buf, "Input::GetDeviceKeyMapping", false);
+}
+
+Future<Input::GetDeviceKeyMappingReply> Input::GetDeviceKeyMapping(
+    const uint8_t& device_id,
+    const KeyCode& first_keycode,
+    const uint8_t& count) {
+  return Input::GetDeviceKeyMapping(
+      Input::GetDeviceKeyMappingRequest{device_id, first_keycode, count});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetDeviceKeyMappingReply> detail::ReadReply<
+    Input::GetDeviceKeyMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetDeviceKeyMappingReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& keysyms_per_keycode = (*reply).keysyms_per_keycode;
+  auto& keysyms = (*reply).keysyms;
+  size_t keysyms_len = keysyms.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // keysyms_per_keycode
+  Read(&keysyms_per_keycode, &buf);
+
+  // pad0
+  Pad(&buf, 23);
+
+  // keysyms
+  keysyms.resize(length);
+  for (auto& keysyms_elem : keysyms) {
+    // keysyms_elem
+    Read(&keysyms_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::ChangeDeviceKeyMapping(
+    const Input::ChangeDeviceKeyMappingRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+  auto& first_keycode = request.first_keycode;
+  auto& keysyms_per_keycode = request.keysyms_per_keycode;
+  auto& keycode_count = request.keycode_count;
+  auto& keysyms = request.keysyms;
+  size_t keysyms_len = keysyms.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 25;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // first_keycode
+  buf.Write(&first_keycode);
+
+  // keysyms_per_keycode
+  buf.Write(&keysyms_per_keycode);
+
+  // keycode_count
+  buf.Write(&keycode_count);
+
+  // keysyms
+  DCHECK_EQ(static_cast<size_t>((keycode_count) * (keysyms_per_keycode)),
+            keysyms.size());
+  for (auto& keysyms_elem : keysyms) {
+    // keysyms_elem
+    buf.Write(&keysyms_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::ChangeDeviceKeyMapping",
+                                        false);
+}
+
+Future<void> Input::ChangeDeviceKeyMapping(const uint8_t& device_id,
+                                           const KeyCode& first_keycode,
+                                           const uint8_t& keysyms_per_keycode,
+                                           const uint8_t& keycode_count,
+                                           const std::vector<KeySym>& keysyms) {
+  return Input::ChangeDeviceKeyMapping(Input::ChangeDeviceKeyMappingRequest{
+      device_id, first_keycode, keysyms_per_keycode, keycode_count, keysyms});
+}
+
+Future<Input::GetDeviceModifierMappingReply> Input::GetDeviceModifierMapping(
+    const Input::GetDeviceModifierMappingRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 26;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetDeviceModifierMappingReply>(
+      &buf, "Input::GetDeviceModifierMapping", false);
+}
+
+Future<Input::GetDeviceModifierMappingReply> Input::GetDeviceModifierMapping(
+    const uint8_t& device_id) {
+  return Input::GetDeviceModifierMapping(
+      Input::GetDeviceModifierMappingRequest{device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetDeviceModifierMappingReply> detail::ReadReply<
+    Input::GetDeviceModifierMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetDeviceModifierMappingReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& keycodes_per_modifier = (*reply).keycodes_per_modifier;
+  auto& keymaps = (*reply).keymaps;
+  size_t keymaps_len = keymaps.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // keycodes_per_modifier
+  Read(&keycodes_per_modifier, &buf);
+
+  // pad0
+  Pad(&buf, 23);
+
+  // keymaps
+  keymaps.resize((keycodes_per_modifier) * (8));
+  for (auto& keymaps_elem : keymaps) {
+    // keymaps_elem
+    Read(&keymaps_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::SetDeviceModifierMappingReply> Input::SetDeviceModifierMapping(
+    const Input::SetDeviceModifierMappingRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+  auto& keycodes_per_modifier = request.keycodes_per_modifier;
+  auto& keymaps = request.keymaps;
+  size_t keymaps_len = keymaps.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 27;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // keycodes_per_modifier
+  buf.Write(&keycodes_per_modifier);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // keymaps
+  DCHECK_EQ(static_cast<size_t>((keycodes_per_modifier) * (8)), keymaps.size());
+  for (auto& keymaps_elem : keymaps) {
+    // keymaps_elem
+    buf.Write(&keymaps_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::SetDeviceModifierMappingReply>(
+      &buf, "Input::SetDeviceModifierMapping", false);
+}
+
+Future<Input::SetDeviceModifierMappingReply> Input::SetDeviceModifierMapping(
+    const uint8_t& device_id,
+    const uint8_t& keycodes_per_modifier,
+    const std::vector<uint8_t>& keymaps) {
+  return Input::SetDeviceModifierMapping(Input::SetDeviceModifierMappingRequest{
+      device_id, keycodes_per_modifier, keymaps});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::SetDeviceModifierMappingReply> detail::ReadReply<
+    Input::SetDeviceModifierMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::SetDeviceModifierMappingReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  uint8_t tmp55;
+  Read(&tmp55, &buf);
+  status = static_cast<MappingStatus>(tmp55);
+
+  // pad0
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::GetDeviceButtonMappingReply> Input::GetDeviceButtonMapping(
+    const Input::GetDeviceButtonMappingRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 28;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetDeviceButtonMappingReply>(
+      &buf, "Input::GetDeviceButtonMapping", false);
+}
+
+Future<Input::GetDeviceButtonMappingReply> Input::GetDeviceButtonMapping(
+    const uint8_t& device_id) {
+  return Input::GetDeviceButtonMapping(
+      Input::GetDeviceButtonMappingRequest{device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetDeviceButtonMappingReply> detail::ReadReply<
+    Input::GetDeviceButtonMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetDeviceButtonMappingReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint8_t map_size{};
+  auto& map = (*reply).map;
+  size_t map_len = map.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // map_size
+  Read(&map_size, &buf);
+
+  // pad0
+  Pad(&buf, 23);
+
+  // map
+  map.resize(map_size);
+  for (auto& map_elem : map) {
+    // map_elem
+    Read(&map_elem, &buf);
+  }
+
+  // pad1
+  Align(&buf, 4);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::SetDeviceButtonMappingReply> Input::SetDeviceButtonMapping(
+    const Input::SetDeviceButtonMappingRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+  uint8_t map_size{};
+  auto& map = request.map;
+  size_t map_len = map.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 29;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // map_size
+  map_size = map.size();
+  buf.Write(&map_size);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // map
+  DCHECK_EQ(static_cast<size_t>(map_size), map.size());
+  for (auto& map_elem : map) {
+    // map_elem
+    buf.Write(&map_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::SetDeviceButtonMappingReply>(
+      &buf, "Input::SetDeviceButtonMapping", false);
+}
+
+Future<Input::SetDeviceButtonMappingReply> Input::SetDeviceButtonMapping(
+    const uint8_t& device_id,
+    const std::vector<uint8_t>& map) {
+  return Input::SetDeviceButtonMapping(
+      Input::SetDeviceButtonMappingRequest{device_id, map});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::SetDeviceButtonMappingReply> detail::ReadReply<
+    Input::SetDeviceButtonMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::SetDeviceButtonMappingReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  uint8_t tmp56;
+  Read(&tmp56, &buf);
+  status = static_cast<MappingStatus>(tmp56);
+
+  // pad0
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::QueryDeviceStateReply> Input::QueryDeviceState(
+    const Input::QueryDeviceStateRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 30;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::QueryDeviceStateReply>(
+      &buf, "Input::QueryDeviceState", false);
+}
+
+Future<Input::QueryDeviceStateReply> Input::QueryDeviceState(
+    const uint8_t& device_id) {
+  return Input::QueryDeviceState(Input::QueryDeviceStateRequest{device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::QueryDeviceStateReply> detail::ReadReply<
+    Input::QueryDeviceStateReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::QueryDeviceStateReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint8_t num_classes{};
+  auto& classes = (*reply).classes;
+  size_t classes_len = classes.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_classes
+  Read(&num_classes, &buf);
+
+  // pad0
+  Pad(&buf, 23);
+
+  // classes
+  classes.resize(num_classes);
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    {
+      Input::InputClass class_id{};
+      auto& len = classes_elem.len;
+      auto& data = classes_elem;
+
+      // class_id
+      uint8_t tmp57;
+      Read(&tmp57, &buf);
+      class_id = static_cast<Input::InputClass>(tmp57);
+
+      // len
+      Read(&len, &buf);
+
+      // data
+      auto data_expr = class_id;
+      if (CaseEq(data_expr, Input::InputClass::Key)) {
+        data.key.emplace();
+        auto& num_keys = (*data.key).num_keys;
+        auto& keys = (*data.key).keys;
+        size_t keys_len = keys.size();
+
+        // num_keys
+        Read(&num_keys, &buf);
+
+        // pad0
+        Pad(&buf, 1);
+
+        // keys
+        for (auto& keys_elem : keys) {
+          // keys_elem
+          Read(&keys_elem, &buf);
+        }
+      }
+      if (CaseEq(data_expr, Input::InputClass::Button)) {
+        data.button.emplace();
+        auto& num_buttons = (*data.button).num_buttons;
+        auto& buttons = (*data.button).buttons;
+        size_t buttons_len = buttons.size();
+
+        // num_buttons
+        Read(&num_buttons, &buf);
+
+        // pad1
+        Pad(&buf, 1);
+
+        // buttons
+        for (auto& buttons_elem : buttons) {
+          // buttons_elem
+          Read(&buttons_elem, &buf);
+        }
+      }
+      if (CaseEq(data_expr, Input::InputClass::Valuator)) {
+        data.valuator.emplace();
+        uint8_t num_valuators{};
+        auto& mode = (*data.valuator).mode;
+        auto& valuators = (*data.valuator).valuators;
+        size_t valuators_len = valuators.size();
+
+        // num_valuators
+        Read(&num_valuators, &buf);
+
+        // mode
+        uint8_t tmp58;
+        Read(&tmp58, &buf);
+        mode = static_cast<Input::ValuatorStateModeMask>(tmp58);
+
+        // valuators
+        valuators.resize(num_valuators);
+        for (auto& valuators_elem : valuators) {
+          // valuators_elem
+          Read(&valuators_elem, &buf);
+        }
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::DeviceBell(const Input::DeviceBellRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+  auto& feedback_id = request.feedback_id;
+  auto& feedback_class = request.feedback_class;
+  auto& percent = request.percent;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 32;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // feedback_id
+  buf.Write(&feedback_id);
+
+  // feedback_class
+  buf.Write(&feedback_class);
+
+  // percent
+  buf.Write(&percent);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::DeviceBell", false);
+}
+
+Future<void> Input::DeviceBell(const uint8_t& device_id,
+                               const uint8_t& feedback_id,
+                               const uint8_t& feedback_class,
+                               const int8_t& percent) {
+  return Input::DeviceBell(Input::DeviceBellRequest{device_id, feedback_id,
+                                                    feedback_class, percent});
+}
+
+Future<Input::SetDeviceValuatorsReply> Input::SetDeviceValuators(
+    const Input::SetDeviceValuatorsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+  auto& first_valuator = request.first_valuator;
+  uint8_t num_valuators{};
+  auto& valuators = request.valuators;
+  size_t valuators_len = valuators.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 33;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // first_valuator
+  buf.Write(&first_valuator);
+
+  // num_valuators
+  num_valuators = valuators.size();
+  buf.Write(&num_valuators);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // valuators
+  DCHECK_EQ(static_cast<size_t>(num_valuators), valuators.size());
+  for (auto& valuators_elem : valuators) {
+    // valuators_elem
+    buf.Write(&valuators_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::SetDeviceValuatorsReply>(
+      &buf, "Input::SetDeviceValuators", false);
+}
+
+Future<Input::SetDeviceValuatorsReply> Input::SetDeviceValuators(
+    const uint8_t& device_id,
+    const uint8_t& first_valuator,
+    const std::vector<int32_t>& valuators) {
+  return Input::SetDeviceValuators(
+      Input::SetDeviceValuatorsRequest{device_id, first_valuator, valuators});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::SetDeviceValuatorsReply> detail::ReadReply<
+    Input::SetDeviceValuatorsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::SetDeviceValuatorsReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  uint8_t tmp59;
+  Read(&tmp59, &buf);
+  status = static_cast<GrabStatus>(tmp59);
+
+  // pad0
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::GetDeviceControlReply> Input::GetDeviceControl(
+    const Input::GetDeviceControlRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& control_id = request.control_id;
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 34;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // control_id
+  uint16_t tmp60;
+  tmp60 = static_cast<uint16_t>(control_id);
+  buf.Write(&tmp60);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 1);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetDeviceControlReply>(
+      &buf, "Input::GetDeviceControl", false);
+}
+
+Future<Input::GetDeviceControlReply> Input::GetDeviceControl(
+    const DeviceControl& control_id,
+    const uint8_t& device_id) {
+  return Input::GetDeviceControl(
+      Input::GetDeviceControlRequest{control_id, device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetDeviceControlReply> detail::ReadReply<
+    Input::GetDeviceControlReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetDeviceControlReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+  auto& control = (*reply).control;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  Read(&status, &buf);
+
+  // pad0
+  Pad(&buf, 23);
+
+  // control
+  {
+    Input::DeviceControl control_id{};
+    auto& len = control.len;
+    auto& data = control;
+
+    // control_id
+    uint16_t tmp61;
+    Read(&tmp61, &buf);
+    control_id = static_cast<Input::DeviceControl>(tmp61);
+
+    // len
+    Read(&len, &buf);
+
+    // data
+    auto data_expr = control_id;
+    if (CaseEq(data_expr, Input::DeviceControl::resolution)) {
+      data.resolution.emplace();
+      uint32_t num_valuators{};
+      auto& resolution_values = (*data.resolution).resolution_values;
+      size_t resolution_values_len = resolution_values.size();
+      auto& resolution_min = (*data.resolution).resolution_min;
+      size_t resolution_min_len = resolution_min.size();
+      auto& resolution_max = (*data.resolution).resolution_max;
+      size_t resolution_max_len = resolution_max.size();
+
+      // num_valuators
+      Read(&num_valuators, &buf);
+
+      // resolution_values
+      resolution_values.resize(num_valuators);
+      for (auto& resolution_values_elem : resolution_values) {
+        // resolution_values_elem
+        Read(&resolution_values_elem, &buf);
+      }
+
+      // resolution_min
+      resolution_min.resize(num_valuators);
+      for (auto& resolution_min_elem : resolution_min) {
+        // resolution_min_elem
+        Read(&resolution_min_elem, &buf);
+      }
+
+      // resolution_max
+      resolution_max.resize(num_valuators);
+      for (auto& resolution_max_elem : resolution_max) {
+        // resolution_max_elem
+        Read(&resolution_max_elem, &buf);
+      }
+    }
+    if (CaseEq(data_expr, Input::DeviceControl::abs_calib)) {
+      data.abs_calib.emplace();
+      auto& min_x = (*data.abs_calib).min_x;
+      auto& max_x = (*data.abs_calib).max_x;
+      auto& min_y = (*data.abs_calib).min_y;
+      auto& max_y = (*data.abs_calib).max_y;
+      auto& flip_x = (*data.abs_calib).flip_x;
+      auto& flip_y = (*data.abs_calib).flip_y;
+      auto& rotation = (*data.abs_calib).rotation;
+      auto& button_threshold = (*data.abs_calib).button_threshold;
+
+      // min_x
+      Read(&min_x, &buf);
+
+      // max_x
+      Read(&max_x, &buf);
+
+      // min_y
+      Read(&min_y, &buf);
+
+      // max_y
+      Read(&max_y, &buf);
+
+      // flip_x
+      Read(&flip_x, &buf);
+
+      // flip_y
+      Read(&flip_y, &buf);
+
+      // rotation
+      Read(&rotation, &buf);
+
+      // button_threshold
+      Read(&button_threshold, &buf);
+    }
+    if (CaseEq(data_expr, Input::DeviceControl::core)) {
+      data.core.emplace();
+      auto& status = (*data.core).status;
+      auto& iscore = (*data.core).iscore;
+
+      // status
+      Read(&status, &buf);
+
+      // iscore
+      Read(&iscore, &buf);
+
+      // pad0
+      Pad(&buf, 2);
+    }
+    if (CaseEq(data_expr, Input::DeviceControl::enable)) {
+      data.enable.emplace();
+      auto& enable = (*data.enable).enable;
+
+      // enable
+      Read(&enable, &buf);
+
+      // pad1
+      Pad(&buf, 3);
+    }
+    if (CaseEq(data_expr, Input::DeviceControl::abs_area)) {
+      data.abs_area.emplace();
+      auto& offset_x = (*data.abs_area).offset_x;
+      auto& offset_y = (*data.abs_area).offset_y;
+      auto& width = (*data.abs_area).width;
+      auto& height = (*data.abs_area).height;
+      auto& screen = (*data.abs_area).screen;
+      auto& following = (*data.abs_area).following;
+
+      // offset_x
+      Read(&offset_x, &buf);
+
+      // offset_y
+      Read(&offset_y, &buf);
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+
+      // screen
+      Read(&screen, &buf);
+
+      // following
+      Read(&following, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::ChangeDeviceControlReply> Input::ChangeDeviceControl(
+    const Input::ChangeDeviceControlRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& control_id = request.control_id;
+  auto& device_id = request.device_id;
+  auto& control = request.control;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 35;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // control_id
+  uint16_t tmp62;
+  tmp62 = static_cast<uint16_t>(control_id);
+  buf.Write(&tmp62);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // control
+  {
+    DeviceControl control_id{};
+    auto& len = control.len;
+    auto& data = control;
+
+    // control_id
+    SwitchVar(DeviceControl::resolution, data.resolution.has_value(), false,
+              &control_id);
+    SwitchVar(DeviceControl::abs_calib, data.abs_calib.has_value(), false,
+              &control_id);
+    SwitchVar(DeviceControl::core, data.core.has_value(), false, &control_id);
+    SwitchVar(DeviceControl::enable, data.enable.has_value(), false,
+              &control_id);
+    SwitchVar(DeviceControl::abs_area, data.abs_area.has_value(), false,
+              &control_id);
+    uint16_t tmp63;
+    tmp63 = static_cast<uint16_t>(control_id);
+    buf.Write(&tmp63);
+
+    // len
+    buf.Write(&len);
+
+    // data
+    auto data_expr = control_id;
+    if (CaseEq(data_expr, DeviceControl::resolution)) {
+      auto& first_valuator = (*data.resolution).first_valuator;
+      uint8_t num_valuators{};
+      auto& resolution_values = (*data.resolution).resolution_values;
+      size_t resolution_values_len = resolution_values.size();
+
+      // first_valuator
+      buf.Write(&first_valuator);
+
+      // num_valuators
+      num_valuators = resolution_values.size();
+      buf.Write(&num_valuators);
+
+      // pad0
+      Pad(&buf, 2);
+
+      // resolution_values
+      DCHECK_EQ(static_cast<size_t>(num_valuators), resolution_values.size());
+      for (auto& resolution_values_elem : resolution_values) {
+        // resolution_values_elem
+        buf.Write(&resolution_values_elem);
+      }
+    }
+    if (CaseEq(data_expr, DeviceControl::abs_calib)) {
+      auto& min_x = (*data.abs_calib).min_x;
+      auto& max_x = (*data.abs_calib).max_x;
+      auto& min_y = (*data.abs_calib).min_y;
+      auto& max_y = (*data.abs_calib).max_y;
+      auto& flip_x = (*data.abs_calib).flip_x;
+      auto& flip_y = (*data.abs_calib).flip_y;
+      auto& rotation = (*data.abs_calib).rotation;
+      auto& button_threshold = (*data.abs_calib).button_threshold;
+
+      // min_x
+      buf.Write(&min_x);
+
+      // max_x
+      buf.Write(&max_x);
+
+      // min_y
+      buf.Write(&min_y);
+
+      // max_y
+      buf.Write(&max_y);
+
+      // flip_x
+      buf.Write(&flip_x);
+
+      // flip_y
+      buf.Write(&flip_y);
+
+      // rotation
+      buf.Write(&rotation);
+
+      // button_threshold
+      buf.Write(&button_threshold);
+    }
+    if (CaseEq(data_expr, DeviceControl::core)) {
+      auto& status = (*data.core).status;
+
+      // status
+      buf.Write(&status);
+
+      // pad1
+      Pad(&buf, 3);
+    }
+    if (CaseEq(data_expr, DeviceControl::enable)) {
+      auto& enable = (*data.enable).enable;
+
+      // enable
+      buf.Write(&enable);
+
+      // pad2
+      Pad(&buf, 3);
+    }
+    if (CaseEq(data_expr, DeviceControl::abs_area)) {
+      auto& offset_x = (*data.abs_area).offset_x;
+      auto& offset_y = (*data.abs_area).offset_y;
+      auto& width = (*data.abs_area).width;
+      auto& height = (*data.abs_area).height;
+      auto& screen = (*data.abs_area).screen;
+      auto& following = (*data.abs_area).following;
+
+      // offset_x
+      buf.Write(&offset_x);
+
+      // offset_y
+      buf.Write(&offset_y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+
+      // screen
+      buf.Write(&screen);
+
+      // following
+      buf.Write(&following);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::ChangeDeviceControlReply>(
+      &buf, "Input::ChangeDeviceControl", false);
+}
+
+Future<Input::ChangeDeviceControlReply> Input::ChangeDeviceControl(
+    const DeviceControl& control_id,
+    const uint8_t& device_id,
+    const DeviceCtl& control) {
+  return Input::ChangeDeviceControl(
+      Input::ChangeDeviceControlRequest{control_id, device_id, control});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::ChangeDeviceControlReply> detail::ReadReply<
+    Input::ChangeDeviceControlReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::ChangeDeviceControlReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  Read(&status, &buf);
+
+  // pad0
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::ListDevicePropertiesReply> Input::ListDeviceProperties(
+    const Input::ListDevicePropertiesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 36;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::ListDevicePropertiesReply>(
+      &buf, "Input::ListDeviceProperties", false);
+}
+
+Future<Input::ListDevicePropertiesReply> Input::ListDeviceProperties(
+    const uint8_t& device_id) {
+  return Input::ListDeviceProperties(
+      Input::ListDevicePropertiesRequest{device_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::ListDevicePropertiesReply> detail::ReadReply<
+    Input::ListDevicePropertiesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::ListDevicePropertiesReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  uint16_t num_atoms{};
+  auto& atoms = (*reply).atoms;
+  size_t atoms_len = atoms.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_atoms
+  Read(&num_atoms, &buf);
+
+  // pad0
+  Pad(&buf, 22);
+
+  // atoms
+  atoms.resize(num_atoms);
+  for (auto& atoms_elem : atoms) {
+    // atoms_elem
+    Read(&atoms_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::ChangeDeviceProperty(
+    const Input::ChangeDevicePropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& device_id = request.device_id;
+  PropertyFormat format{};
+  auto& mode = request.mode;
+  auto& num_items = request.num_items;
+  auto& items = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 37;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // format
+  SwitchVar(PropertyFormat::c_8Bits, items.data8.has_value(), false, &format);
+  SwitchVar(PropertyFormat::c_16Bits, items.data16.has_value(), false, &format);
+  SwitchVar(PropertyFormat::c_32Bits, items.data32.has_value(), false, &format);
+  uint8_t tmp64;
+  tmp64 = static_cast<uint8_t>(format);
+  buf.Write(&tmp64);
+
+  // mode
+  uint8_t tmp65;
+  tmp65 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp65);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // num_items
+  buf.Write(&num_items);
+
+  // items
+  auto items_expr = format;
+  if (CaseEq(items_expr, PropertyFormat::c_8Bits)) {
+    auto& data8 = *items.data8;
+    size_t data8_len = data8.size();
+
+    // data8
+    DCHECK_EQ(static_cast<size_t>(num_items), data8.size());
+    for (auto& data8_elem : data8) {
+      // data8_elem
+      buf.Write(&data8_elem);
+    }
+
+    // pad1
+    Align(&buf, 4);
+  }
+  if (CaseEq(items_expr, PropertyFormat::c_16Bits)) {
+    auto& data16 = *items.data16;
+    size_t data16_len = data16.size();
+
+    // data16
+    DCHECK_EQ(static_cast<size_t>(num_items), data16.size());
+    for (auto& data16_elem : data16) {
+      // data16_elem
+      buf.Write(&data16_elem);
+    }
+
+    // pad2
+    Align(&buf, 4);
+  }
+  if (CaseEq(items_expr, PropertyFormat::c_32Bits)) {
+    auto& data32 = *items.data32;
+    size_t data32_len = data32.size();
+
+    // data32
+    DCHECK_EQ(static_cast<size_t>(num_items), data32.size());
+    for (auto& data32_elem : data32) {
+      // data32_elem
+      buf.Write(&data32_elem);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::ChangeDeviceProperty",
+                                        false);
+}
+
+Future<void> Input::ChangeDeviceProperty(
+    const Atom& property,
+    const Atom& type,
+    const uint8_t& device_id,
+    const PropMode& mode,
+    const uint32_t& num_items,
+    const absl::optional<std::vector<uint8_t>>& data8,
+    const absl::optional<std::vector<uint16_t>>& data16,
+    const absl::optional<std::vector<uint32_t>>& data32) {
+  return Input::ChangeDeviceProperty(Input::ChangeDevicePropertyRequest{
+      property, type, device_id, mode, num_items, data8, data16, data32});
+}
+
+Future<void> Input::DeleteDeviceProperty(
+    const Input::DeleteDevicePropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& property = request.property;
+  auto& device_id = request.device_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 38;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // property
+  buf.Write(&property);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::DeleteDeviceProperty",
+                                        false);
+}
+
+Future<void> Input::DeleteDeviceProperty(const Atom& property,
+                                         const uint8_t& device_id) {
+  return Input::DeleteDeviceProperty(
+      Input::DeleteDevicePropertyRequest{property, device_id});
+}
+
+Future<Input::GetDevicePropertyReply> Input::GetDeviceProperty(
+    const Input::GetDevicePropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& offset = request.offset;
+  auto& len = request.len;
+  auto& device_id = request.device_id;
+  auto& c_delete = request.c_delete;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 39;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // offset
+  buf.Write(&offset);
+
+  // len
+  buf.Write(&len);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // c_delete
+  buf.Write(&c_delete);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::GetDevicePropertyReply>(
+      &buf, "Input::GetDeviceProperty", false);
+}
+
+Future<Input::GetDevicePropertyReply> Input::GetDeviceProperty(
+    const Atom& property,
+    const Atom& type,
+    const uint32_t& offset,
+    const uint32_t& len,
+    const uint8_t& device_id,
+    const uint8_t& c_delete) {
+  return Input::GetDeviceProperty(Input::GetDevicePropertyRequest{
+      property, type, offset, len, device_id, c_delete});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::GetDevicePropertyReply> detail::ReadReply<
+    Input::GetDevicePropertyReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::GetDevicePropertyReply>();
+
+  auto& xi_reply_type = (*reply).xi_reply_type;
+  auto& sequence = (*reply).sequence;
+  auto& type = (*reply).type;
+  auto& bytes_after = (*reply).bytes_after;
+  auto& num_items = (*reply).num_items;
+  Input::PropertyFormat format{};
+  auto& device_id = (*reply).device_id;
+  auto& items = (*reply);
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xi_reply_type
+  Read(&xi_reply_type, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // type
+  Read(&type, &buf);
+
+  // bytes_after
+  Read(&bytes_after, &buf);
+
+  // num_items
+  Read(&num_items, &buf);
+
+  // format
+  uint8_t tmp66;
+  Read(&tmp66, &buf);
+  format = static_cast<Input::PropertyFormat>(tmp66);
+
+  // device_id
+  Read(&device_id, &buf);
+
+  // pad0
+  Pad(&buf, 10);
+
+  // items
+  auto items_expr = format;
+  if (CaseEq(items_expr, Input::PropertyFormat::c_8Bits)) {
+    items.data8.emplace();
+    auto& data8 = *items.data8;
+    size_t data8_len = data8.size();
+
+    // data8
+    data8.resize(num_items);
+    for (auto& data8_elem : data8) {
+      // data8_elem
+      Read(&data8_elem, &buf);
+    }
+
+    // pad1
+    Align(&buf, 4);
+  }
+  if (CaseEq(items_expr, Input::PropertyFormat::c_16Bits)) {
+    items.data16.emplace();
+    auto& data16 = *items.data16;
+    size_t data16_len = data16.size();
+
+    // data16
+    data16.resize(num_items);
+    for (auto& data16_elem : data16) {
+      // data16_elem
+      Read(&data16_elem, &buf);
+    }
+
+    // pad2
+    Align(&buf, 4);
+  }
+  if (CaseEq(items_expr, Input::PropertyFormat::c_32Bits)) {
+    items.data32.emplace();
+    auto& data32 = *items.data32;
+    size_t data32_len = data32.size();
+
+    // data32
+    data32.resize(num_items);
+    for (auto& data32_elem : data32) {
+      // data32_elem
+      Read(&data32_elem, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::XIQueryPointerReply> Input::XIQueryPointer(
+    const Input::XIQueryPointerRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 40;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIQueryPointerReply>(
+      &buf, "Input::XIQueryPointer", false);
+}
+
+Future<Input::XIQueryPointerReply> Input::XIQueryPointer(
+    const Window& window,
+    const DeviceId& deviceid) {
+  return Input::XIQueryPointer(Input::XIQueryPointerRequest{window, deviceid});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIQueryPointerReply> detail::ReadReply<
+    Input::XIQueryPointerReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIQueryPointerReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& root = (*reply).root;
+  auto& child = (*reply).child;
+  auto& root_x = (*reply).root_x;
+  auto& root_y = (*reply).root_y;
+  auto& win_x = (*reply).win_x;
+  auto& win_y = (*reply).win_y;
+  auto& same_screen = (*reply).same_screen;
+  uint16_t buttons_len{};
+  auto& mods = (*reply).mods;
+  auto& group = (*reply).group;
+  auto& buttons = (*reply).buttons;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // win_x
+  Read(&win_x, &buf);
+
+  // win_y
+  Read(&win_y, &buf);
+
+  // same_screen
+  Read(&same_screen, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  // buttons_len
+  Read(&buttons_len, &buf);
+
+  // mods
+  {
+    auto& base = mods.base;
+    auto& latched = mods.latched;
+    auto& locked = mods.locked;
+    auto& effective = mods.effective;
+
+    // base
+    Read(&base, &buf);
+
+    // latched
+    Read(&latched, &buf);
+
+    // locked
+    Read(&locked, &buf);
+
+    // effective
+    Read(&effective, &buf);
+  }
+
+  // group
+  {
+    auto& base = group.base;
+    auto& latched = group.latched;
+    auto& locked = group.locked;
+    auto& effective = group.effective;
+
+    // base
+    Read(&base, &buf);
+
+    // latched
+    Read(&latched, &buf);
+
+    // locked
+    Read(&locked, &buf);
+
+    // effective
+    Read(&effective, &buf);
+  }
+
+  // buttons
+  buttons.resize(buttons_len);
+  for (auto& buttons_elem : buttons) {
+    // buttons_elem
+    Read(&buttons_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::XIWarpPointer(const Input::XIWarpPointerRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& src_win = request.src_win;
+  auto& dst_win = request.dst_win;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& src_width = request.src_width;
+  auto& src_height = request.src_height;
+  auto& dst_x = request.dst_x;
+  auto& dst_y = request.dst_y;
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 41;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // src_win
+  buf.Write(&src_win);
+
+  // dst_win
+  buf.Write(&dst_win);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // src_width
+  buf.Write(&src_width);
+
+  // src_height
+  buf.Write(&src_height);
+
+  // dst_x
+  buf.Write(&dst_x);
+
+  // dst_y
+  buf.Write(&dst_y);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIWarpPointer", false);
+}
+
+Future<void> Input::XIWarpPointer(const Window& src_win,
+                                  const Window& dst_win,
+                                  const Fp1616& src_x,
+                                  const Fp1616& src_y,
+                                  const uint16_t& src_width,
+                                  const uint16_t& src_height,
+                                  const Fp1616& dst_x,
+                                  const Fp1616& dst_y,
+                                  const DeviceId& deviceid) {
+  return Input::XIWarpPointer(
+      Input::XIWarpPointerRequest{src_win, dst_win, src_x, src_y, src_width,
+                                  src_height, dst_x, dst_y, deviceid});
+}
+
+Future<void> Input::XIChangeCursor(
+    const Input::XIChangeCursorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& cursor = request.cursor;
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 42;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // cursor
+  buf.Write(&cursor);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIChangeCursor", false);
+}
+
+Future<void> Input::XIChangeCursor(const Window& window,
+                                   const Cursor& cursor,
+                                   const DeviceId& deviceid) {
+  return Input::XIChangeCursor(
+      Input::XIChangeCursorRequest{window, cursor, deviceid});
+}
+
+Future<void> Input::XIChangeHierarchy(
+    const Input::XIChangeHierarchyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint8_t num_changes{};
+  auto& changes = request.changes;
+  size_t changes_len = changes.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 43;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // num_changes
+  num_changes = changes.size();
+  buf.Write(&num_changes);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // changes
+  DCHECK_EQ(static_cast<size_t>(num_changes), changes.size());
+  for (auto& changes_elem : changes) {
+    // changes_elem
+    {
+      HierarchyChangeType type{};
+      auto& len = changes_elem.len;
+      auto& data = changes_elem;
+
+      // type
+      SwitchVar(HierarchyChangeType::AddMaster, data.add_master.has_value(),
+                false, &type);
+      SwitchVar(HierarchyChangeType::RemoveMaster,
+                data.remove_master.has_value(), false, &type);
+      SwitchVar(HierarchyChangeType::AttachSlave, data.attach_slave.has_value(),
+                false, &type);
+      SwitchVar(HierarchyChangeType::DetachSlave, data.detach_slave.has_value(),
+                false, &type);
+      uint16_t tmp67;
+      tmp67 = static_cast<uint16_t>(type);
+      buf.Write(&tmp67);
+
+      // len
+      buf.Write(&len);
+
+      // data
+      auto data_expr = type;
+      if (CaseEq(data_expr, HierarchyChangeType::AddMaster)) {
+        uint16_t name_len{};
+        auto& send_core = (*data.add_master).send_core;
+        auto& enable = (*data.add_master).enable;
+        auto& name = (*data.add_master).name;
+
+        // name_len
+        name_len = name.size();
+        buf.Write(&name_len);
+
+        // send_core
+        buf.Write(&send_core);
+
+        // enable
+        buf.Write(&enable);
+
+        // name
+        DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+        for (auto& name_elem : name) {
+          // name_elem
+          buf.Write(&name_elem);
+        }
+
+        // pad0
+        Align(&buf, 4);
+      }
+      if (CaseEq(data_expr, HierarchyChangeType::RemoveMaster)) {
+        auto& deviceid = (*data.remove_master).deviceid;
+        auto& return_mode = (*data.remove_master).return_mode;
+        auto& return_pointer = (*data.remove_master).return_pointer;
+        auto& return_keyboard = (*data.remove_master).return_keyboard;
+
+        // deviceid
+        buf.Write(&deviceid);
+
+        // return_mode
+        uint8_t tmp68;
+        tmp68 = static_cast<uint8_t>(return_mode);
+        buf.Write(&tmp68);
+
+        // pad1
+        Pad(&buf, 1);
+
+        // return_pointer
+        buf.Write(&return_pointer);
+
+        // return_keyboard
+        buf.Write(&return_keyboard);
+      }
+      if (CaseEq(data_expr, HierarchyChangeType::AttachSlave)) {
+        auto& deviceid = (*data.attach_slave).deviceid;
+        auto& master = (*data.attach_slave).master;
+
+        // deviceid
+        buf.Write(&deviceid);
+
+        // master
+        buf.Write(&master);
+      }
+      if (CaseEq(data_expr, HierarchyChangeType::DetachSlave)) {
+        auto& deviceid = (*data.detach_slave).deviceid;
+
+        // deviceid
+        buf.Write(&deviceid);
+
+        // pad2
+        Pad(&buf, 2);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIChangeHierarchy",
+                                        false);
+}
+
+Future<void> Input::XIChangeHierarchy(
+    const std::vector<HierarchyChange>& changes) {
+  return Input::XIChangeHierarchy(Input::XIChangeHierarchyRequest{changes});
+}
+
+Future<void> Input::XISetClientPointer(
+    const Input::XISetClientPointerRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 44;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XISetClientPointer",
+                                        false);
+}
+
+Future<void> Input::XISetClientPointer(const Window& window,
+                                       const DeviceId& deviceid) {
+  return Input::XISetClientPointer(
+      Input::XISetClientPointerRequest{window, deviceid});
+}
+
+Future<Input::XIGetClientPointerReply> Input::XIGetClientPointer(
+    const Input::XIGetClientPointerRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 45;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIGetClientPointerReply>(
+      &buf, "Input::XIGetClientPointer", false);
+}
+
+Future<Input::XIGetClientPointerReply> Input::XIGetClientPointer(
+    const Window& window) {
+  return Input::XIGetClientPointer(Input::XIGetClientPointerRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIGetClientPointerReply> detail::ReadReply<
+    Input::XIGetClientPointerReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIGetClientPointerReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& set = (*reply).set;
+  auto& deviceid = (*reply).deviceid;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // set
+  Read(&set, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  // deviceid
+  Read(&deviceid, &buf);
+
+  // pad2
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::XISelectEvents(
+    const Input::XISelectEventsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  uint16_t num_mask{};
+  auto& masks = request.masks;
+  size_t masks_len = masks.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 46;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // num_mask
+  num_mask = masks.size();
+  buf.Write(&num_mask);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // masks
+  DCHECK_EQ(static_cast<size_t>(num_mask), masks.size());
+  for (auto& masks_elem : masks) {
+    // masks_elem
+    {
+      auto& deviceid = masks_elem.deviceid;
+      uint16_t mask_len{};
+      auto& mask = masks_elem.mask;
+
+      // deviceid
+      buf.Write(&deviceid);
+
+      // mask_len
+      mask_len = mask.size();
+      buf.Write(&mask_len);
+
+      // mask
+      DCHECK_EQ(static_cast<size_t>(mask_len), mask.size());
+      for (auto& mask_elem : mask) {
+        // mask_elem
+        uint32_t tmp69;
+        tmp69 = static_cast<uint32_t>(mask_elem);
+        buf.Write(&tmp69);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XISelectEvents", false);
+}
+
+Future<void> Input::XISelectEvents(const Window& window,
+                                   const std::vector<EventMask>& masks) {
+  return Input::XISelectEvents(Input::XISelectEventsRequest{window, masks});
+}
+
+Future<Input::XIQueryVersionReply> Input::XIQueryVersion(
+    const Input::XIQueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 47;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIQueryVersionReply>(
+      &buf, "Input::XIQueryVersion", false);
+}
+
+Future<Input::XIQueryVersionReply> Input::XIQueryVersion(
+    const uint16_t& major_version,
+    const uint16_t& minor_version) {
+  return Input::XIQueryVersion(
+      Input::XIQueryVersionRequest{major_version, minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIQueryVersionReply> detail::ReadReply<
+    Input::XIQueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIQueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::XIQueryDeviceReply> Input::XIQueryDevice(
+    const Input::XIQueryDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 48;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIQueryDeviceReply>(
+      &buf, "Input::XIQueryDevice", false);
+}
+
+Future<Input::XIQueryDeviceReply> Input::XIQueryDevice(
+    const DeviceId& deviceid) {
+  return Input::XIQueryDevice(Input::XIQueryDeviceRequest{deviceid});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIQueryDeviceReply> detail::ReadReply<
+    Input::XIQueryDeviceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIQueryDeviceReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t num_infos{};
+  auto& infos = (*reply).infos;
+  size_t infos_len = infos.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_infos
+  Read(&num_infos, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // infos
+  infos.resize(num_infos);
+  for (auto& infos_elem : infos) {
+    // infos_elem
+    {
+      auto& deviceid = infos_elem.deviceid;
+      auto& type = infos_elem.type;
+      auto& attachment = infos_elem.attachment;
+      uint16_t num_classes{};
+      uint16_t name_len{};
+      auto& enabled = infos_elem.enabled;
+      auto& name = infos_elem.name;
+      auto& classes = infos_elem.classes;
+      size_t classes_len = classes.size();
+
+      // deviceid
+      Read(&deviceid, &buf);
+
+      // type
+      uint16_t tmp70;
+      Read(&tmp70, &buf);
+      type = static_cast<Input::DeviceType>(tmp70);
+
+      // attachment
+      Read(&attachment, &buf);
+
+      // num_classes
+      Read(&num_classes, &buf);
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // enabled
+      Read(&enabled, &buf);
+
+      // pad0
+      Pad(&buf, 1);
+
+      // name
+      name.resize(name_len);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+
+      // pad1
+      Align(&buf, 4);
+
+      // classes
+      classes.resize(num_classes);
+      for (auto& classes_elem : classes) {
+        // classes_elem
+        {
+          Input::DeviceClassType type{};
+          auto& len = classes_elem.len;
+          auto& sourceid = classes_elem.sourceid;
+          auto& data = classes_elem;
+
+          // type
+          uint16_t tmp71;
+          Read(&tmp71, &buf);
+          type = static_cast<Input::DeviceClassType>(tmp71);
+
+          // len
+          Read(&len, &buf);
+
+          // sourceid
+          Read(&sourceid, &buf);
+
+          // data
+          auto data_expr = type;
+          if (CaseEq(data_expr, Input::DeviceClassType::Key)) {
+            data.key.emplace();
+            uint16_t num_keys{};
+            auto& keys = (*data.key).keys;
+            size_t keys_len = keys.size();
+
+            // num_keys
+            Read(&num_keys, &buf);
+
+            // keys
+            keys.resize(num_keys);
+            for (auto& keys_elem : keys) {
+              // keys_elem
+              Read(&keys_elem, &buf);
+            }
+          }
+          if (CaseEq(data_expr, Input::DeviceClassType::Button)) {
+            data.button.emplace();
+            uint16_t num_buttons{};
+            auto& state = (*data.button).state;
+            size_t state_len = state.size();
+            auto& labels = (*data.button).labels;
+            size_t labels_len = labels.size();
+
+            // num_buttons
+            Read(&num_buttons, &buf);
+
+            // state
+            state.resize(((num_buttons) + (31)) / (32));
+            for (auto& state_elem : state) {
+              // state_elem
+              Read(&state_elem, &buf);
+            }
+
+            // labels
+            labels.resize(num_buttons);
+            for (auto& labels_elem : labels) {
+              // labels_elem
+              Read(&labels_elem, &buf);
+            }
+          }
+          if (CaseEq(data_expr, Input::DeviceClassType::Valuator)) {
+            data.valuator.emplace();
+            auto& number = (*data.valuator).number;
+            auto& label = (*data.valuator).label;
+            auto& min = (*data.valuator).min;
+            auto& max = (*data.valuator).max;
+            auto& value = (*data.valuator).value;
+            auto& resolution = (*data.valuator).resolution;
+            auto& mode = (*data.valuator).mode;
+
+            // number
+            Read(&number, &buf);
+
+            // label
+            Read(&label, &buf);
+
+            // min
+            {
+              auto& integral = min.integral;
+              auto& frac = min.frac;
+
+              // integral
+              Read(&integral, &buf);
+
+              // frac
+              Read(&frac, &buf);
+            }
+
+            // max
+            {
+              auto& integral = max.integral;
+              auto& frac = max.frac;
+
+              // integral
+              Read(&integral, &buf);
+
+              // frac
+              Read(&frac, &buf);
+            }
+
+            // value
+            {
+              auto& integral = value.integral;
+              auto& frac = value.frac;
+
+              // integral
+              Read(&integral, &buf);
+
+              // frac
+              Read(&frac, &buf);
+            }
+
+            // resolution
+            Read(&resolution, &buf);
+
+            // mode
+            uint8_t tmp72;
+            Read(&tmp72, &buf);
+            mode = static_cast<Input::ValuatorMode>(tmp72);
+
+            // pad0
+            Pad(&buf, 3);
+          }
+          if (CaseEq(data_expr, Input::DeviceClassType::Scroll)) {
+            data.scroll.emplace();
+            auto& number = (*data.scroll).number;
+            auto& scroll_type = (*data.scroll).scroll_type;
+            auto& flags = (*data.scroll).flags;
+            auto& increment = (*data.scroll).increment;
+
+            // number
+            Read(&number, &buf);
+
+            // scroll_type
+            uint16_t tmp73;
+            Read(&tmp73, &buf);
+            scroll_type = static_cast<Input::ScrollType>(tmp73);
+
+            // pad1
+            Pad(&buf, 2);
+
+            // flags
+            uint32_t tmp74;
+            Read(&tmp74, &buf);
+            flags = static_cast<Input::ScrollFlags>(tmp74);
+
+            // increment
+            {
+              auto& integral = increment.integral;
+              auto& frac = increment.frac;
+
+              // integral
+              Read(&integral, &buf);
+
+              // frac
+              Read(&frac, &buf);
+            }
+          }
+          if (CaseEq(data_expr, Input::DeviceClassType::Touch)) {
+            data.touch.emplace();
+            auto& mode = (*data.touch).mode;
+            auto& num_touches = (*data.touch).num_touches;
+
+            // mode
+            uint8_t tmp75;
+            Read(&tmp75, &buf);
+            mode = static_cast<Input::TouchMode>(tmp75);
+
+            // num_touches
+            Read(&num_touches, &buf);
+          }
+        }
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::XISetFocus(const Input::XISetFocusRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& time = request.time;
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 49;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // time
+  buf.Write(&time);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XISetFocus", false);
+}
+
+Future<void> Input::XISetFocus(const Window& window,
+                               const Time& time,
+                               const DeviceId& deviceid) {
+  return Input::XISetFocus(Input::XISetFocusRequest{window, time, deviceid});
+}
+
+Future<Input::XIGetFocusReply> Input::XIGetFocus(
+    const Input::XIGetFocusRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 50;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIGetFocusReply>(
+      &buf, "Input::XIGetFocus", false);
+}
+
+Future<Input::XIGetFocusReply> Input::XIGetFocus(const DeviceId& deviceid) {
+  return Input::XIGetFocus(Input::XIGetFocusRequest{deviceid});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIGetFocusReply> detail::ReadReply<
+    Input::XIGetFocusReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIGetFocusReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& focus = (*reply).focus;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // focus
+  Read(&focus, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::XIGrabDeviceReply> Input::XIGrabDevice(
+    const Input::XIGrabDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& time = request.time;
+  auto& cursor = request.cursor;
+  auto& deviceid = request.deviceid;
+  auto& mode = request.mode;
+  auto& paired_device_mode = request.paired_device_mode;
+  auto& owner_events = request.owner_events;
+  uint16_t mask_len{};
+  auto& mask = request.mask;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 51;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // time
+  buf.Write(&time);
+
+  // cursor
+  buf.Write(&cursor);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // mode
+  uint8_t tmp76;
+  tmp76 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp76);
+
+  // paired_device_mode
+  uint8_t tmp77;
+  tmp77 = static_cast<uint8_t>(paired_device_mode);
+  buf.Write(&tmp77);
+
+  // owner_events
+  uint8_t tmp78;
+  tmp78 = static_cast<uint8_t>(owner_events);
+  buf.Write(&tmp78);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // mask_len
+  mask_len = mask.size();
+  buf.Write(&mask_len);
+
+  // mask
+  DCHECK_EQ(static_cast<size_t>(mask_len), mask.size());
+  for (auto& mask_elem : mask) {
+    // mask_elem
+    buf.Write(&mask_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIGrabDeviceReply>(
+      &buf, "Input::XIGrabDevice", false);
+}
+
+Future<Input::XIGrabDeviceReply> Input::XIGrabDevice(
+    const Window& window,
+    const Time& time,
+    const Cursor& cursor,
+    const DeviceId& deviceid,
+    const GrabMode& mode,
+    const GrabMode& paired_device_mode,
+    const GrabOwner& owner_events,
+    const std::vector<uint32_t>& mask) {
+  return Input::XIGrabDevice(
+      Input::XIGrabDeviceRequest{window, time, cursor, deviceid, mode,
+                                 paired_device_mode, owner_events, mask});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIGrabDeviceReply> detail::ReadReply<
+    Input::XIGrabDeviceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIGrabDeviceReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& status = (*reply).status;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status
+  uint8_t tmp79;
+  Read(&tmp79, &buf);
+  status = static_cast<GrabStatus>(tmp79);
+
+  // pad1
+  Pad(&buf, 23);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::XIUngrabDevice(
+    const Input::XIUngrabDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& time = request.time;
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 52;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // time
+  buf.Write(&time);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIUngrabDevice", false);
+}
+
+Future<void> Input::XIUngrabDevice(const Time& time, const DeviceId& deviceid) {
+  return Input::XIUngrabDevice(Input::XIUngrabDeviceRequest{time, deviceid});
+}
+
+Future<void> Input::XIAllowEvents(const Input::XIAllowEventsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& time = request.time;
+  auto& deviceid = request.deviceid;
+  auto& event_mode = request.event_mode;
+  auto& touchid = request.touchid;
+  auto& grab_window = request.grab_window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 53;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // time
+  buf.Write(&time);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // event_mode
+  uint8_t tmp80;
+  tmp80 = static_cast<uint8_t>(event_mode);
+  buf.Write(&tmp80);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // touchid
+  buf.Write(&touchid);
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIAllowEvents", false);
+}
+
+Future<void> Input::XIAllowEvents(const Time& time,
+                                  const DeviceId& deviceid,
+                                  const EventMode& event_mode,
+                                  const uint32_t& touchid,
+                                  const Window& grab_window) {
+  return Input::XIAllowEvents(Input::XIAllowEventsRequest{
+      time, deviceid, event_mode, touchid, grab_window});
+}
+
+Future<Input::XIPassiveGrabDeviceReply> Input::XIPassiveGrabDevice(
+    const Input::XIPassiveGrabDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& time = request.time;
+  auto& grab_window = request.grab_window;
+  auto& cursor = request.cursor;
+  auto& detail = request.detail;
+  auto& deviceid = request.deviceid;
+  uint16_t num_modifiers{};
+  uint16_t mask_len{};
+  auto& grab_type = request.grab_type;
+  auto& grab_mode = request.grab_mode;
+  auto& paired_device_mode = request.paired_device_mode;
+  auto& owner_events = request.owner_events;
+  auto& mask = request.mask;
+  auto& modifiers = request.modifiers;
+  size_t modifiers_len = modifiers.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 54;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // time
+  buf.Write(&time);
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // cursor
+  buf.Write(&cursor);
+
+  // detail
+  buf.Write(&detail);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // num_modifiers
+  num_modifiers = modifiers.size();
+  buf.Write(&num_modifiers);
+
+  // mask_len
+  mask_len = mask.size();
+  buf.Write(&mask_len);
+
+  // grab_type
+  uint8_t tmp81;
+  tmp81 = static_cast<uint8_t>(grab_type);
+  buf.Write(&tmp81);
+
+  // grab_mode
+  uint8_t tmp82;
+  tmp82 = static_cast<uint8_t>(grab_mode);
+  buf.Write(&tmp82);
+
+  // paired_device_mode
+  uint8_t tmp83;
+  tmp83 = static_cast<uint8_t>(paired_device_mode);
+  buf.Write(&tmp83);
+
+  // owner_events
+  uint8_t tmp84;
+  tmp84 = static_cast<uint8_t>(owner_events);
+  buf.Write(&tmp84);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // mask
+  DCHECK_EQ(static_cast<size_t>(mask_len), mask.size());
+  for (auto& mask_elem : mask) {
+    // mask_elem
+    buf.Write(&mask_elem);
+  }
+
+  // modifiers
+  DCHECK_EQ(static_cast<size_t>(num_modifiers), modifiers.size());
+  for (auto& modifiers_elem : modifiers) {
+    // modifiers_elem
+    buf.Write(&modifiers_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIPassiveGrabDeviceReply>(
+      &buf, "Input::XIPassiveGrabDevice", false);
+}
+
+Future<Input::XIPassiveGrabDeviceReply> Input::XIPassiveGrabDevice(
+    const Time& time,
+    const Window& grab_window,
+    const Cursor& cursor,
+    const uint32_t& detail,
+    const DeviceId& deviceid,
+    const GrabType& grab_type,
+    const GrabMode22& grab_mode,
+    const GrabMode& paired_device_mode,
+    const GrabOwner& owner_events,
+    const std::vector<uint32_t>& mask,
+    const std::vector<uint32_t>& modifiers) {
+  return Input::XIPassiveGrabDevice(Input::XIPassiveGrabDeviceRequest{
+      time, grab_window, cursor, detail, deviceid, grab_type, grab_mode,
+      paired_device_mode, owner_events, mask, modifiers});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIPassiveGrabDeviceReply> detail::ReadReply<
+    Input::XIPassiveGrabDeviceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIPassiveGrabDeviceReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t num_modifiers{};
+  auto& modifiers = (*reply).modifiers;
+  size_t modifiers_len = modifiers.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_modifiers
+  Read(&num_modifiers, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // modifiers
+  modifiers.resize(num_modifiers);
+  for (auto& modifiers_elem : modifiers) {
+    // modifiers_elem
+    {
+      auto& modifiers = modifiers_elem.modifiers;
+      auto& status = modifiers_elem.status;
+
+      // modifiers
+      Read(&modifiers, &buf);
+
+      // status
+      uint8_t tmp85;
+      Read(&tmp85, &buf);
+      status = static_cast<GrabStatus>(tmp85);
+
+      // pad0
+      Pad(&buf, 3);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::XIPassiveUngrabDevice(
+    const Input::XIPassiveUngrabDeviceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& grab_window = request.grab_window;
+  auto& detail = request.detail;
+  auto& deviceid = request.deviceid;
+  uint16_t num_modifiers{};
+  auto& grab_type = request.grab_type;
+  auto& modifiers = request.modifiers;
+  size_t modifiers_len = modifiers.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 55;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // detail
+  buf.Write(&detail);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // num_modifiers
+  num_modifiers = modifiers.size();
+  buf.Write(&num_modifiers);
+
+  // grab_type
+  uint8_t tmp86;
+  tmp86 = static_cast<uint8_t>(grab_type);
+  buf.Write(&tmp86);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // modifiers
+  DCHECK_EQ(static_cast<size_t>(num_modifiers), modifiers.size());
+  for (auto& modifiers_elem : modifiers) {
+    // modifiers_elem
+    buf.Write(&modifiers_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIPassiveUngrabDevice",
+                                        false);
+}
+
+Future<void> Input::XIPassiveUngrabDevice(
+    const Window& grab_window,
+    const uint32_t& detail,
+    const DeviceId& deviceid,
+    const GrabType& grab_type,
+    const std::vector<uint32_t>& modifiers) {
+  return Input::XIPassiveUngrabDevice(Input::XIPassiveUngrabDeviceRequest{
+      grab_window, detail, deviceid, grab_type, modifiers});
+}
+
+Future<Input::XIListPropertiesReply> Input::XIListProperties(
+    const Input::XIListPropertiesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 56;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIListPropertiesReply>(
+      &buf, "Input::XIListProperties", false);
+}
+
+Future<Input::XIListPropertiesReply> Input::XIListProperties(
+    const DeviceId& deviceid) {
+  return Input::XIListProperties(Input::XIListPropertiesRequest{deviceid});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIListPropertiesReply> detail::ReadReply<
+    Input::XIListPropertiesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIListPropertiesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t num_properties{};
+  auto& properties = (*reply).properties;
+  size_t properties_len = properties.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_properties
+  Read(&num_properties, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // properties
+  properties.resize(num_properties);
+  for (auto& properties_elem : properties) {
+    // properties_elem
+    Read(&properties_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::XIChangeProperty(
+    const Input::XIChangePropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceid = request.deviceid;
+  auto& mode = request.mode;
+  PropertyFormat format{};
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& num_items = request.num_items;
+  auto& items = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 57;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // mode
+  uint8_t tmp87;
+  tmp87 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp87);
+
+  // format
+  SwitchVar(PropertyFormat::c_8Bits, items.data8.has_value(), false, &format);
+  SwitchVar(PropertyFormat::c_16Bits, items.data16.has_value(), false, &format);
+  SwitchVar(PropertyFormat::c_32Bits, items.data32.has_value(), false, &format);
+  uint8_t tmp88;
+  tmp88 = static_cast<uint8_t>(format);
+  buf.Write(&tmp88);
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // num_items
+  buf.Write(&num_items);
+
+  // items
+  auto items_expr = format;
+  if (CaseEq(items_expr, PropertyFormat::c_8Bits)) {
+    auto& data8 = *items.data8;
+    size_t data8_len = data8.size();
+
+    // data8
+    DCHECK_EQ(static_cast<size_t>(num_items), data8.size());
+    for (auto& data8_elem : data8) {
+      // data8_elem
+      buf.Write(&data8_elem);
+    }
+
+    // pad0
+    Align(&buf, 4);
+  }
+  if (CaseEq(items_expr, PropertyFormat::c_16Bits)) {
+    auto& data16 = *items.data16;
+    size_t data16_len = data16.size();
+
+    // data16
+    DCHECK_EQ(static_cast<size_t>(num_items), data16.size());
+    for (auto& data16_elem : data16) {
+      // data16_elem
+      buf.Write(&data16_elem);
+    }
+
+    // pad1
+    Align(&buf, 4);
+  }
+  if (CaseEq(items_expr, PropertyFormat::c_32Bits)) {
+    auto& data32 = *items.data32;
+    size_t data32_len = data32.size();
+
+    // data32
+    DCHECK_EQ(static_cast<size_t>(num_items), data32.size());
+    for (auto& data32_elem : data32) {
+      // data32_elem
+      buf.Write(&data32_elem);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIChangeProperty", false);
+}
+
+Future<void> Input::XIChangeProperty(
+    const DeviceId& deviceid,
+    const PropMode& mode,
+    const Atom& property,
+    const Atom& type,
+    const uint32_t& num_items,
+    const absl::optional<std::vector<uint8_t>>& data8,
+    const absl::optional<std::vector<uint16_t>>& data16,
+    const absl::optional<std::vector<uint32_t>>& data32) {
+  return Input::XIChangeProperty(Input::XIChangePropertyRequest{
+      deviceid, mode, property, type, num_items, data8, data16, data32});
+}
+
+Future<void> Input::XIDeleteProperty(
+    const Input::XIDeletePropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceid = request.deviceid;
+  auto& property = request.property;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 58;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // property
+  buf.Write(&property);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIDeleteProperty", false);
+}
+
+Future<void> Input::XIDeleteProperty(const DeviceId& deviceid,
+                                     const Atom& property) {
+  return Input::XIDeleteProperty(
+      Input::XIDeletePropertyRequest{deviceid, property});
+}
+
+Future<Input::XIGetPropertyReply> Input::XIGetProperty(
+    const Input::XIGetPropertyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceid = request.deviceid;
+  auto& c_delete = request.c_delete;
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& offset = request.offset;
+  auto& len = request.len;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 59;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  // c_delete
+  buf.Write(&c_delete);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // offset
+  buf.Write(&offset);
+
+  // len
+  buf.Write(&len);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIGetPropertyReply>(
+      &buf, "Input::XIGetProperty", false);
+}
+
+Future<Input::XIGetPropertyReply> Input::XIGetProperty(const DeviceId& deviceid,
+                                                       const uint8_t& c_delete,
+                                                       const Atom& property,
+                                                       const Atom& type,
+                                                       const uint32_t& offset,
+                                                       const uint32_t& len) {
+  return Input::XIGetProperty(Input::XIGetPropertyRequest{
+      deviceid, c_delete, property, type, offset, len});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIGetPropertyReply> detail::ReadReply<
+    Input::XIGetPropertyReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIGetPropertyReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& type = (*reply).type;
+  auto& bytes_after = (*reply).bytes_after;
+  auto& num_items = (*reply).num_items;
+  Input::PropertyFormat format{};
+  auto& items = (*reply);
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // type
+  Read(&type, &buf);
+
+  // bytes_after
+  Read(&bytes_after, &buf);
+
+  // num_items
+  Read(&num_items, &buf);
+
+  // format
+  uint8_t tmp89;
+  Read(&tmp89, &buf);
+  format = static_cast<Input::PropertyFormat>(tmp89);
+
+  // pad1
+  Pad(&buf, 11);
+
+  // items
+  auto items_expr = format;
+  if (CaseEq(items_expr, Input::PropertyFormat::c_8Bits)) {
+    items.data8.emplace();
+    auto& data8 = *items.data8;
+    size_t data8_len = data8.size();
+
+    // data8
+    data8.resize(num_items);
+    for (auto& data8_elem : data8) {
+      // data8_elem
+      Read(&data8_elem, &buf);
+    }
+
+    // pad2
+    Align(&buf, 4);
+  }
+  if (CaseEq(items_expr, Input::PropertyFormat::c_16Bits)) {
+    items.data16.emplace();
+    auto& data16 = *items.data16;
+    size_t data16_len = data16.size();
+
+    // data16
+    data16.resize(num_items);
+    for (auto& data16_elem : data16) {
+      // data16_elem
+      Read(&data16_elem, &buf);
+    }
+
+    // pad3
+    Align(&buf, 4);
+  }
+  if (CaseEq(items_expr, Input::PropertyFormat::c_32Bits)) {
+    items.data32.emplace();
+    auto& data32 = *items.data32;
+    size_t data32_len = data32.size();
+
+    // data32
+    data32.resize(num_items);
+    for (auto& data32_elem : data32) {
+      // data32_elem
+      Read(&data32_elem, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Input::XIGetSelectedEventsReply> Input::XIGetSelectedEvents(
+    const Input::XIGetSelectedEventsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 60;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Input::XIGetSelectedEventsReply>(
+      &buf, "Input::XIGetSelectedEvents", false);
+}
+
+Future<Input::XIGetSelectedEventsReply> Input::XIGetSelectedEvents(
+    const Window& window) {
+  return Input::XIGetSelectedEvents(Input::XIGetSelectedEventsRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Input::XIGetSelectedEventsReply> detail::ReadReply<
+    Input::XIGetSelectedEventsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Input::XIGetSelectedEventsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t num_masks{};
+  auto& masks = (*reply).masks;
+  size_t masks_len = masks.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_masks
+  Read(&num_masks, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // masks
+  masks.resize(num_masks);
+  for (auto& masks_elem : masks) {
+    // masks_elem
+    {
+      auto& deviceid = masks_elem.deviceid;
+      uint16_t mask_len{};
+      auto& mask = masks_elem.mask;
+
+      // deviceid
+      Read(&deviceid, &buf);
+
+      // mask_len
+      Read(&mask_len, &buf);
+
+      // mask
+      mask.resize(mask_len);
+      for (auto& mask_elem : mask) {
+        // mask_elem
+        uint32_t tmp90;
+        Read(&tmp90, &buf);
+        mask_elem = static_cast<Input::XIEventMask>(tmp90);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Input::XIBarrierReleasePointer(
+    const Input::XIBarrierReleasePointerRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t num_barriers{};
+  auto& barriers = request.barriers;
+  size_t barriers_len = barriers.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 61;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // num_barriers
+  num_barriers = barriers.size();
+  buf.Write(&num_barriers);
+
+  // barriers
+  DCHECK_EQ(static_cast<size_t>(num_barriers), barriers.size());
+  for (auto& barriers_elem : barriers) {
+    // barriers_elem
+    {
+      auto& deviceid = barriers_elem.deviceid;
+      auto& barrier = barriers_elem.barrier;
+      auto& eventid = barriers_elem.eventid;
+
+      // deviceid
+      buf.Write(&deviceid);
+
+      // pad0
+      Pad(&buf, 2);
+
+      // barrier
+      buf.Write(&barrier);
+
+      // eventid
+      buf.Write(&eventid);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::XIBarrierReleasePointer",
+                                        false);
+}
+
+Future<void> Input::XIBarrierReleasePointer(
+    const std::vector<BarrierReleasePointerInfo>& barriers) {
+  return Input::XIBarrierReleasePointer(
+      Input::XIBarrierReleasePointerRequest{barriers});
+}
+
+Future<void> Input::SendExtensionEvent(
+    const Input::SendExtensionEventRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& destination = request.destination;
+  auto& device_id = request.device_id;
+  auto& propagate = request.propagate;
+  uint16_t num_classes{};
+  uint8_t num_events{};
+  auto& events = request.events;
+  size_t events_len = events.size();
+  auto& classes = request.classes;
+  size_t classes_len = classes.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 31;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // destination
+  buf.Write(&destination);
+
+  // device_id
+  buf.Write(&device_id);
+
+  // propagate
+  buf.Write(&propagate);
+
+  // num_classes
+  num_classes = classes.size();
+  buf.Write(&num_classes);
+
+  // num_events
+  num_events = events.size();
+  buf.Write(&num_events);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // events
+  DCHECK_EQ(static_cast<size_t>(num_events), events.size());
+  for (auto& events_elem : events) {
+    // events_elem
+    buf.Write(&events_elem);
+  }
+
+  // classes
+  DCHECK_EQ(static_cast<size_t>(num_classes), classes.size());
+  for (auto& classes_elem : classes) {
+    // classes_elem
+    buf.Write(&classes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Input::SendExtensionEvent",
+                                        false);
+}
+
+Future<void> Input::SendExtensionEvent(const Window& destination,
+                                       const uint8_t& device_id,
+                                       const uint8_t& propagate,
+                                       const std::vector<EventForSend>& events,
+                                       const std::vector<EventClass>& classes) {
+  return Input::SendExtensionEvent(Input::SendExtensionEventRequest{
+      destination, device_id, propagate, events, classes});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xinput.h b/ui/gfx/x/generated_protos/xinput.h
new file mode 100644
index 0000000..e522384
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xinput.h
@@ -0,0 +1,3234 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XINPUT_H_
+#define UI_GFX_X_GENERATED_PROTOS_XINPUT_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xfixes.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Input {
+ public:
+  static constexpr unsigned major_version = 2;
+  static constexpr unsigned minor_version = 3;
+
+  Input(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class EventClass : uint32_t {};
+
+  enum class KeyCode : uint8_t {};
+
+  enum class Fp1616 : int32_t {};
+
+  enum class DeviceUse : int {
+    IsXPointer = 0,
+    IsXKeyboard = 1,
+    IsXExtensionDevice = 2,
+    IsXExtensionKeyboard = 3,
+    IsXExtensionPointer = 4,
+  };
+
+  enum class InputClass : int {
+    Key = 0,
+    Button = 1,
+    Valuator = 2,
+    Feedback = 3,
+    Proximity = 4,
+    Focus = 5,
+    Other = 6,
+  };
+
+  enum class ValuatorMode : int {
+    Relative = 0,
+    Absolute = 1,
+  };
+
+  enum class EventTypeBase : uint8_t {};
+
+  enum class PropagateMode : int {
+    AddToList = 0,
+    DeleteFromList = 1,
+  };
+
+  enum class ModifierDevice : int {
+    UseXKeyboard = 255,
+  };
+
+  enum class DeviceInputMode : int {
+    AsyncThisDevice = 0,
+    SyncThisDevice = 1,
+    ReplayThisDevice = 2,
+    AsyncOtherDevices = 3,
+    AsyncAll = 4,
+    SyncAll = 5,
+  };
+
+  enum class FeedbackClass : int {
+    Keyboard = 0,
+    Pointer = 1,
+    String = 2,
+    Integer = 3,
+    Led = 4,
+    Bell = 5,
+  };
+
+  enum class ChangeFeedbackControlMask : int {
+    KeyClickPercent = 1 << 0,
+    Percent = 1 << 1,
+    Pitch = 1 << 2,
+    Duration = 1 << 3,
+    Led = 1 << 4,
+    LedMode = 1 << 5,
+    Key = 1 << 6,
+    AutoRepeatMode = 1 << 7,
+    String = 1 << 0,
+    Integer = 1 << 0,
+    AccelNum = 1 << 0,
+    AccelDenom = 1 << 1,
+    Threshold = 1 << 2,
+  };
+
+  enum class ValuatorStateModeMask : int {
+    DeviceModeAbsolute = 1 << 0,
+    OutOfProximity = 1 << 1,
+  };
+
+  enum class DeviceControl : int {
+    resolution = 1,
+    abs_calib = 2,
+    core = 3,
+    enable = 4,
+    abs_area = 5,
+  };
+
+  enum class PropertyFormat : int {
+    c_8Bits = 8,
+    c_16Bits = 16,
+    c_32Bits = 32,
+  };
+
+  enum class DeviceId : uint16_t {
+    All = 0,
+    AllMaster = 1,
+  };
+
+  enum class HierarchyChangeType : int {
+    AddMaster = 1,
+    RemoveMaster = 2,
+    AttachSlave = 3,
+    DetachSlave = 4,
+  };
+
+  enum class ChangeMode : int {
+    Attach = 1,
+    Float = 2,
+  };
+
+  enum class XIEventMask : int {
+    DeviceChanged = 1 << 1,
+    KeyPress = 1 << 2,
+    KeyRelease = 1 << 3,
+    ButtonPress = 1 << 4,
+    ButtonRelease = 1 << 5,
+    Motion = 1 << 6,
+    Enter = 1 << 7,
+    Leave = 1 << 8,
+    FocusIn = 1 << 9,
+    FocusOut = 1 << 10,
+    Hierarchy = 1 << 11,
+    Property = 1 << 12,
+    RawKeyPress = 1 << 13,
+    RawKeyRelease = 1 << 14,
+    RawButtonPress = 1 << 15,
+    RawButtonRelease = 1 << 16,
+    RawMotion = 1 << 17,
+    TouchBegin = 1 << 18,
+    TouchUpdate = 1 << 19,
+    TouchEnd = 1 << 20,
+    TouchOwnership = 1 << 21,
+    RawTouchBegin = 1 << 22,
+    RawTouchUpdate = 1 << 23,
+    RawTouchEnd = 1 << 24,
+    BarrierHit = 1 << 25,
+    BarrierLeave = 1 << 26,
+  };
+
+  enum class DeviceClassType : int {
+    Key = 0,
+    Button = 1,
+    Valuator = 2,
+    Scroll = 3,
+    Touch = 8,
+  };
+
+  enum class DeviceType : int {
+    MasterPointer = 1,
+    MasterKeyboard = 2,
+    SlavePointer = 3,
+    SlaveKeyboard = 4,
+    FloatingSlave = 5,
+  };
+
+  enum class ScrollFlags : int {
+    NoEmulation = 1 << 0,
+    Preferred = 1 << 1,
+  };
+
+  enum class ScrollType : int {
+    Vertical = 1,
+    Horizontal = 2,
+  };
+
+  enum class TouchMode : int {
+    Direct = 1,
+    Dependent = 2,
+  };
+
+  enum class GrabOwner : int {
+    NoOwner = 0,
+    Owner = 1,
+  };
+
+  enum class EventMode : int {
+    AsyncDevice = 0,
+    SyncDevice = 1,
+    ReplayDevice = 2,
+    AsyncPairedDevice = 3,
+    AsyncPair = 4,
+    SyncPair = 5,
+    AcceptTouch = 6,
+    RejectTouch = 7,
+  };
+
+  enum class GrabMode22 : int {
+    Sync = 0,
+    Async = 1,
+    Touch = 2,
+  };
+
+  enum class GrabType : int {
+    Button = 0,
+    Keycode = 1,
+    Enter = 2,
+    FocusIn = 3,
+    TouchBegin = 4,
+  };
+
+  enum class ModifierMask : int {
+    Any = 1 << 31,
+  };
+
+  enum class MoreEventsMask : int {
+    MoreEvents = 1 << 7,
+  };
+
+  enum class ClassesReportedMask : int {
+    OutOfProximity = 1 << 7,
+    DeviceModeAbsolute = 1 << 6,
+    ReportingValuators = 1 << 2,
+    ReportingButtons = 1 << 1,
+    ReportingKeys = 1 << 0,
+  };
+
+  enum class ChangeDevice : int {
+    NewPointer = 0,
+    NewKeyboard = 1,
+  };
+
+  enum class DeviceChange : int {
+    Added = 0,
+    Removed = 1,
+    Enabled = 2,
+    Disabled = 3,
+    Unrecoverable = 4,
+    ControlChanged = 5,
+  };
+
+  enum class ChangeReason : int {
+    SlaveSwitch = 1,
+    DeviceChange = 2,
+  };
+
+  enum class KeyEventFlags : int {
+    KeyRepeat = 1 << 16,
+  };
+
+  enum class PointerEventFlags : int {
+    PointerEmulated = 1 << 16,
+  };
+
+  enum class NotifyMode : int {
+    Normal = 0,
+    Grab = 1,
+    Ungrab = 2,
+    WhileGrabbed = 3,
+    PassiveGrab = 4,
+    PassiveUngrab = 5,
+  };
+
+  enum class NotifyDetail : int {
+    Ancestor = 0,
+    Virtual = 1,
+    Inferior = 2,
+    Nonlinear = 3,
+    NonlinearVirtual = 4,
+    Pointer = 5,
+    PointerRoot = 6,
+    None = 7,
+  };
+
+  enum class HierarchyMask : int {
+    MasterAdded = 1 << 0,
+    MasterRemoved = 1 << 1,
+    SlaveAdded = 1 << 2,
+    SlaveRemoved = 1 << 3,
+    SlaveAttached = 1 << 4,
+    SlaveDetached = 1 << 5,
+    DeviceEnabled = 1 << 6,
+    DeviceDisabled = 1 << 7,
+  };
+
+  enum class PropertyFlag : int {
+    Deleted = 0,
+    Created = 1,
+    Modified = 2,
+  };
+
+  enum class TouchEventFlags : int {
+    TouchPendingEnd = 1 << 16,
+    TouchEmulatingPointer = 1 << 17,
+  };
+
+  enum class TouchOwnershipFlags : int {
+    None = 0,
+  };
+
+  enum class BarrierFlags : int {
+    PointerReleased = 1 << 0,
+    DeviceIsGrabbed = 1 << 1,
+  };
+
+  struct Fp3232 {
+    int32_t integral{};
+    uint32_t frac{};
+  };
+
+  struct DeviceInfo {
+    Atom device_type{};
+    uint8_t device_id{};
+    uint8_t num_class_info{};
+    DeviceUse device_use{};
+  };
+
+  struct KeyInfo {
+    InputClass class_id{};
+    uint8_t len{};
+    KeyCode min_keycode{};
+    KeyCode max_keycode{};
+    uint16_t num_keys{};
+  };
+
+  struct ButtonInfo {
+    InputClass class_id{};
+    uint8_t len{};
+    uint16_t num_buttons{};
+  };
+
+  struct AxisInfo {
+    uint32_t resolution{};
+    int32_t minimum{};
+    int32_t maximum{};
+  };
+
+  struct ValuatorInfo {
+    InputClass class_id{};
+    uint8_t len{};
+    ValuatorMode mode{};
+    uint32_t motion_size{};
+    std::vector<AxisInfo> axes{};
+  };
+
+  struct InputInfo {
+    uint8_t len{};
+    struct Key {
+      KeyCode min_keycode{};
+      KeyCode max_keycode{};
+      uint16_t num_keys{};
+    };
+    struct Button {
+      uint16_t num_buttons{};
+    };
+    struct Valuator {
+      ValuatorMode mode{};
+      uint32_t motion_size{};
+      std::vector<AxisInfo> axes{};
+    };
+    absl::optional<Key> key{};
+    absl::optional<Button> button{};
+    absl::optional<Valuator> valuator{};
+  };
+
+  struct DeviceName {
+    std::string string{};
+  };
+
+  struct InputClassInfo {
+    InputClass class_id{};
+    EventTypeBase event_type_base{};
+  };
+
+  struct DeviceTimeCoord {
+    Time time{};
+    std::vector<int32_t> axisvalues{};
+  };
+
+  struct KbdFeedbackState {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    uint16_t pitch{};
+    uint16_t duration{};
+    uint32_t led_mask{};
+    uint32_t led_values{};
+    uint8_t global_auto_repeat{};
+    uint8_t click{};
+    uint8_t percent{};
+    std::array<uint8_t, 32> auto_repeats{};
+  };
+
+  struct PtrFeedbackState {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    uint16_t accel_num{};
+    uint16_t accel_denom{};
+    uint16_t threshold{};
+  };
+
+  struct IntegerFeedbackState {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    uint32_t resolution{};
+    int32_t min_value{};
+    int32_t max_value{};
+  };
+
+  struct StringFeedbackState {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    uint16_t max_symbols{};
+    std::vector<KeySym> keysyms{};
+  };
+
+  struct BellFeedbackState {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    uint8_t percent{};
+    uint16_t pitch{};
+    uint16_t duration{};
+  };
+
+  struct LedFeedbackState {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    uint32_t led_mask{};
+    uint32_t led_values{};
+  };
+
+  struct FeedbackState {
+    uint8_t feedback_id{};
+    uint16_t len{};
+    struct Keyboard {
+      uint16_t pitch{};
+      uint16_t duration{};
+      uint32_t led_mask{};
+      uint32_t led_values{};
+      uint8_t global_auto_repeat{};
+      uint8_t click{};
+      uint8_t percent{};
+      std::array<uint8_t, 32> auto_repeats{};
+    };
+    struct Pointer {
+      uint16_t accel_num{};
+      uint16_t accel_denom{};
+      uint16_t threshold{};
+    };
+    struct String {
+      uint16_t max_symbols{};
+      std::vector<KeySym> keysyms{};
+    };
+    struct Integer {
+      uint32_t resolution{};
+      int32_t min_value{};
+      int32_t max_value{};
+    };
+    struct Led {
+      uint32_t led_mask{};
+      uint32_t led_values{};
+    };
+    struct Bell {
+      uint8_t percent{};
+      uint16_t pitch{};
+      uint16_t duration{};
+    };
+    absl::optional<Keyboard> keyboard{};
+    absl::optional<Pointer> pointer{};
+    absl::optional<String> string{};
+    absl::optional<Integer> integer{};
+    absl::optional<Led> led{};
+    absl::optional<Bell> bell{};
+  };
+
+  struct KbdFeedbackCtl {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    KeyCode key{};
+    uint8_t auto_repeat_mode{};
+    int8_t key_click_percent{};
+    int8_t bell_percent{};
+    int16_t bell_pitch{};
+    int16_t bell_duration{};
+    uint32_t led_mask{};
+    uint32_t led_values{};
+  };
+
+  struct PtrFeedbackCtl {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    int16_t num{};
+    int16_t denom{};
+    int16_t threshold{};
+  };
+
+  struct IntegerFeedbackCtl {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    int32_t int_to_display{};
+  };
+
+  struct StringFeedbackCtl {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    std::vector<KeySym> keysyms{};
+  };
+
+  struct BellFeedbackCtl {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    int8_t percent{};
+    int16_t pitch{};
+    int16_t duration{};
+  };
+
+  struct LedFeedbackCtl {
+    FeedbackClass class_id{};
+    uint8_t feedback_id{};
+    uint16_t len{};
+    uint32_t led_mask{};
+    uint32_t led_values{};
+  };
+
+  struct FeedbackCtl {
+    uint8_t feedback_id{};
+    uint16_t len{};
+    struct Keyboard {
+      KeyCode key{};
+      uint8_t auto_repeat_mode{};
+      int8_t key_click_percent{};
+      int8_t bell_percent{};
+      int16_t bell_pitch{};
+      int16_t bell_duration{};
+      uint32_t led_mask{};
+      uint32_t led_values{};
+    };
+    struct Pointer {
+      int16_t num{};
+      int16_t denom{};
+      int16_t threshold{};
+    };
+    struct String {
+      std::vector<KeySym> keysyms{};
+    };
+    struct Integer {
+      int32_t int_to_display{};
+    };
+    struct Led {
+      uint32_t led_mask{};
+      uint32_t led_values{};
+    };
+    struct Bell {
+      int8_t percent{};
+      int16_t pitch{};
+      int16_t duration{};
+    };
+    absl::optional<Keyboard> keyboard{};
+    absl::optional<Pointer> pointer{};
+    absl::optional<String> string{};
+    absl::optional<Integer> integer{};
+    absl::optional<Led> led{};
+    absl::optional<Bell> bell{};
+  };
+
+  struct KeyState {
+    InputClass class_id{};
+    uint8_t len{};
+    uint8_t num_keys{};
+    std::array<uint8_t, 32> keys{};
+  };
+
+  struct ButtonState {
+    InputClass class_id{};
+    uint8_t len{};
+    uint8_t num_buttons{};
+    std::array<uint8_t, 32> buttons{};
+  };
+
+  struct ValuatorState {
+    InputClass class_id{};
+    uint8_t len{};
+    ValuatorStateModeMask mode{};
+    std::vector<int32_t> valuators{};
+  };
+
+  struct InputState {
+    uint8_t len{};
+    struct Key {
+      uint8_t num_keys{};
+      std::array<uint8_t, 32> keys{};
+    };
+    struct Button {
+      uint8_t num_buttons{};
+      std::array<uint8_t, 32> buttons{};
+    };
+    struct Valuator {
+      ValuatorStateModeMask mode{};
+      std::vector<int32_t> valuators{};
+    };
+    absl::optional<Key> key{};
+    absl::optional<Button> button{};
+    absl::optional<Valuator> valuator{};
+  };
+
+  struct DeviceResolutionState {
+    DeviceControl control_id{};
+    uint16_t len{};
+    std::vector<uint32_t> resolution_values{};
+    std::vector<uint32_t> resolution_min{};
+    std::vector<uint32_t> resolution_max{};
+  };
+
+  struct DeviceAbsCalibState {
+    DeviceControl control_id{};
+    uint16_t len{};
+    int32_t min_x{};
+    int32_t max_x{};
+    int32_t min_y{};
+    int32_t max_y{};
+    uint32_t flip_x{};
+    uint32_t flip_y{};
+    uint32_t rotation{};
+    uint32_t button_threshold{};
+  };
+
+  struct DeviceAbsAreaState {
+    DeviceControl control_id{};
+    uint16_t len{};
+    uint32_t offset_x{};
+    uint32_t offset_y{};
+    uint32_t width{};
+    uint32_t height{};
+    uint32_t screen{};
+    uint32_t following{};
+  };
+
+  struct DeviceCoreState {
+    DeviceControl control_id{};
+    uint16_t len{};
+    uint8_t status{};
+    uint8_t iscore{};
+  };
+
+  struct DeviceEnableState {
+    DeviceControl control_id{};
+    uint16_t len{};
+    uint8_t enable{};
+  };
+
+  struct DeviceState {
+    uint16_t len{};
+    struct Resolution {
+      std::vector<uint32_t> resolution_values{};
+      std::vector<uint32_t> resolution_min{};
+      std::vector<uint32_t> resolution_max{};
+    };
+    struct AbsCalib {
+      int32_t min_x{};
+      int32_t max_x{};
+      int32_t min_y{};
+      int32_t max_y{};
+      uint32_t flip_x{};
+      uint32_t flip_y{};
+      uint32_t rotation{};
+      uint32_t button_threshold{};
+    };
+    struct Core {
+      uint8_t status{};
+      uint8_t iscore{};
+    };
+    struct Enable {
+      uint8_t enable{};
+    };
+    struct AbsArea {
+      uint32_t offset_x{};
+      uint32_t offset_y{};
+      uint32_t width{};
+      uint32_t height{};
+      uint32_t screen{};
+      uint32_t following{};
+    };
+    absl::optional<Resolution> resolution{};
+    absl::optional<AbsCalib> abs_calib{};
+    absl::optional<Core> core{};
+    absl::optional<Enable> enable{};
+    absl::optional<AbsArea> abs_area{};
+  };
+
+  struct DeviceResolutionCtl {
+    DeviceControl control_id{};
+    uint16_t len{};
+    uint8_t first_valuator{};
+    std::vector<uint32_t> resolution_values{};
+  };
+
+  struct DeviceAbsCalibCtl {
+    DeviceControl control_id{};
+    uint16_t len{};
+    int32_t min_x{};
+    int32_t max_x{};
+    int32_t min_y{};
+    int32_t max_y{};
+    uint32_t flip_x{};
+    uint32_t flip_y{};
+    uint32_t rotation{};
+    uint32_t button_threshold{};
+  };
+
+  struct DeviceAbsAreaCtrl {
+    DeviceControl control_id{};
+    uint16_t len{};
+    uint32_t offset_x{};
+    uint32_t offset_y{};
+    int32_t width{};
+    int32_t height{};
+    int32_t screen{};
+    uint32_t following{};
+  };
+
+  struct DeviceCoreCtrl {
+    DeviceControl control_id{};
+    uint16_t len{};
+    uint8_t status{};
+  };
+
+  struct DeviceEnableCtrl {
+    DeviceControl control_id{};
+    uint16_t len{};
+    uint8_t enable{};
+  };
+
+  struct DeviceCtl {
+    uint16_t len{};
+    struct Resolution {
+      uint8_t first_valuator{};
+      std::vector<uint32_t> resolution_values{};
+    };
+    struct AbsCalib {
+      int32_t min_x{};
+      int32_t max_x{};
+      int32_t min_y{};
+      int32_t max_y{};
+      uint32_t flip_x{};
+      uint32_t flip_y{};
+      uint32_t rotation{};
+      uint32_t button_threshold{};
+    };
+    struct Core {
+      uint8_t status{};
+    };
+    struct Enable {
+      uint8_t enable{};
+    };
+    struct AbsArea {
+      uint32_t offset_x{};
+      uint32_t offset_y{};
+      int32_t width{};
+      int32_t height{};
+      int32_t screen{};
+      uint32_t following{};
+    };
+    absl::optional<Resolution> resolution{};
+    absl::optional<AbsCalib> abs_calib{};
+    absl::optional<Core> core{};
+    absl::optional<Enable> enable{};
+    absl::optional<AbsArea> abs_area{};
+  };
+
+  struct GroupInfo {
+    uint8_t base{};
+    uint8_t latched{};
+    uint8_t locked{};
+    uint8_t effective{};
+  };
+
+  struct ModifierInfo {
+    uint32_t base{};
+    uint32_t latched{};
+    uint32_t locked{};
+    uint32_t effective{};
+  };
+
+  struct AddMaster {
+    HierarchyChangeType type{};
+    uint16_t len{};
+    uint8_t send_core{};
+    uint8_t enable{};
+    std::string name{};
+  };
+
+  struct RemoveMaster {
+    HierarchyChangeType type{};
+    uint16_t len{};
+    DeviceId deviceid{};
+    ChangeMode return_mode{};
+    DeviceId return_pointer{};
+    DeviceId return_keyboard{};
+  };
+
+  struct AttachSlave {
+    HierarchyChangeType type{};
+    uint16_t len{};
+    DeviceId deviceid{};
+    DeviceId master{};
+  };
+
+  struct DetachSlave {
+    HierarchyChangeType type{};
+    uint16_t len{};
+    DeviceId deviceid{};
+  };
+
+  struct HierarchyChange {
+    uint16_t len{};
+    struct AddMaster {
+      uint8_t send_core{};
+      uint8_t enable{};
+      std::string name{};
+    };
+    struct RemoveMaster {
+      DeviceId deviceid{};
+      ChangeMode return_mode{};
+      DeviceId return_pointer{};
+      DeviceId return_keyboard{};
+    };
+    struct AttachSlave {
+      DeviceId deviceid{};
+      DeviceId master{};
+    };
+    struct DetachSlave {
+      DeviceId deviceid{};
+    };
+    absl::optional<AddMaster> add_master{};
+    absl::optional<RemoveMaster> remove_master{};
+    absl::optional<AttachSlave> attach_slave{};
+    absl::optional<DetachSlave> detach_slave{};
+  };
+
+  struct EventMask {
+    DeviceId deviceid{};
+    std::vector<XIEventMask> mask{};
+  };
+
+  struct ButtonClass {
+    DeviceClassType type{};
+    uint16_t len{};
+    DeviceId sourceid{};
+    std::vector<uint32_t> state{};
+    std::vector<Atom> labels{};
+  };
+
+  struct KeyClass {
+    DeviceClassType type{};
+    uint16_t len{};
+    DeviceId sourceid{};
+    std::vector<uint32_t> keys{};
+  };
+
+  struct ScrollClass {
+    DeviceClassType type{};
+    uint16_t len{};
+    DeviceId sourceid{};
+    uint16_t number{};
+    ScrollType scroll_type{};
+    ScrollFlags flags{};
+    Fp3232 increment{};
+  };
+
+  struct TouchClass {
+    DeviceClassType type{};
+    uint16_t len{};
+    DeviceId sourceid{};
+    TouchMode mode{};
+    uint8_t num_touches{};
+  };
+
+  struct ValuatorClass {
+    DeviceClassType type{};
+    uint16_t len{};
+    DeviceId sourceid{};
+    uint16_t number{};
+    Atom label{};
+    Fp3232 min{};
+    Fp3232 max{};
+    Fp3232 value{};
+    uint32_t resolution{};
+    ValuatorMode mode{};
+  };
+
+  struct DeviceClass {
+    uint16_t len{};
+    DeviceId sourceid{};
+    struct Key {
+      std::vector<uint32_t> keys{};
+    };
+    struct Button {
+      std::vector<uint32_t> state{};
+      std::vector<Atom> labels{};
+    };
+    struct Valuator {
+      uint16_t number{};
+      Atom label{};
+      Fp3232 min{};
+      Fp3232 max{};
+      Fp3232 value{};
+      uint32_t resolution{};
+      ValuatorMode mode{};
+    };
+    struct Scroll {
+      uint16_t number{};
+      ScrollType scroll_type{};
+      ScrollFlags flags{};
+      Fp3232 increment{};
+    };
+    struct Touch {
+      TouchMode mode{};
+      uint8_t num_touches{};
+    };
+    absl::optional<Key> key{};
+    absl::optional<Button> button{};
+    absl::optional<Valuator> valuator{};
+    absl::optional<Scroll> scroll{};
+    absl::optional<Touch> touch{};
+  };
+
+  struct XIDeviceInfo {
+    DeviceId deviceid{};
+    DeviceType type{};
+    DeviceId attachment{};
+    uint8_t enabled{};
+    std::string name{};
+    std::vector<DeviceClass> classes{};
+  };
+
+  struct GrabModifierInfo {
+    uint32_t modifiers{};
+    GrabStatus status{};
+  };
+
+  struct BarrierReleasePointerInfo {
+    DeviceId deviceid{};
+    XFixes::Barrier barrier{};
+    uint32_t eventid{};
+  };
+
+  struct DeviceValuatorEvent {
+    static constexpr int type_id = 20;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint8_t device_id{};
+    uint16_t sequence{};
+    uint16_t device_state{};
+    uint8_t num_valuators{};
+    uint8_t first_valuator{};
+    std::array<int32_t, 6> valuators{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct LegacyDeviceEvent {
+    static constexpr int type_id = 21;
+    enum Opcode {
+      DeviceKeyPress = 1,
+      DeviceKeyRelease = 2,
+      DeviceButtonPress = 3,
+      DeviceButtonRelease = 4,
+      DeviceMotionNotify = 5,
+      ProximityIn = 8,
+      ProximityOut = 9,
+    } opcode{};
+    bool send_event{};
+    uint8_t detail{};
+    uint16_t sequence{};
+    Time time{};
+    Window root{};
+    Window event{};
+    Window child{};
+    int16_t root_x{};
+    int16_t root_y{};
+    int16_t event_x{};
+    int16_t event_y{};
+    KeyButMask state{};
+    uint8_t same_screen{};
+    uint8_t device_id{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+  };
+
+  struct DeviceFocusEvent {
+    static constexpr int type_id = 22;
+    enum Opcode {
+      In = 6,
+      Out = 7,
+    } opcode{};
+    bool send_event{};
+    x11::NotifyDetail detail{};
+    uint16_t sequence{};
+    Time time{};
+    Window window{};
+    x11::NotifyMode mode{};
+    uint8_t device_id{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct DeviceStateNotifyEvent {
+    static constexpr int type_id = 23;
+    static constexpr uint8_t opcode = 10;
+    bool send_event{};
+    uint8_t device_id{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t num_keys{};
+    uint8_t num_buttons{};
+    uint8_t num_valuators{};
+    ClassesReportedMask classes_reported{};
+    std::array<uint8_t, 4> buttons{};
+    std::array<uint8_t, 4> keys{};
+    std::array<uint32_t, 3> valuators{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct DeviceMappingNotifyEvent {
+    static constexpr int type_id = 24;
+    static constexpr uint8_t opcode = 11;
+    bool send_event{};
+    uint8_t device_id{};
+    uint16_t sequence{};
+    Mapping request{};
+    KeyCode first_keycode{};
+    uint8_t count{};
+    Time time{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct ChangeDeviceNotifyEvent {
+    static constexpr int type_id = 25;
+    static constexpr uint8_t opcode = 12;
+    bool send_event{};
+    uint8_t device_id{};
+    uint16_t sequence{};
+    Time time{};
+    ChangeDevice request{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct DeviceKeyStateNotifyEvent {
+    static constexpr int type_id = 26;
+    static constexpr uint8_t opcode = 13;
+    bool send_event{};
+    uint8_t device_id{};
+    uint16_t sequence{};
+    std::array<uint8_t, 28> keys{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct DeviceButtonStateNotifyEvent {
+    static constexpr int type_id = 27;
+    static constexpr uint8_t opcode = 14;
+    bool send_event{};
+    uint8_t device_id{};
+    uint16_t sequence{};
+    std::array<uint8_t, 28> buttons{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct DevicePresenceNotifyEvent {
+    static constexpr int type_id = 28;
+    static constexpr uint8_t opcode = 15;
+    bool send_event{};
+    uint16_t sequence{};
+    Time time{};
+    DeviceChange devchange{};
+    uint8_t device_id{};
+    uint16_t control{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct DevicePropertyNotifyEvent {
+    static constexpr int type_id = 29;
+    static constexpr uint8_t opcode = 16;
+    bool send_event{};
+    Property state{};
+    uint16_t sequence{};
+    Time time{};
+    Atom property{};
+    uint8_t device_id{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct DeviceChangedEvent {
+    static constexpr int type_id = 30;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint16_t sequence{};
+    DeviceId deviceid{};
+    Time time{};
+    DeviceId sourceid{};
+    ChangeReason reason{};
+    std::vector<DeviceClass> classes{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct DeviceEvent {
+    static constexpr int type_id = 31;
+    enum Opcode {
+      KeyPress = 2,
+      KeyRelease = 3,
+      ButtonPress = 4,
+      ButtonRelease = 5,
+      Motion = 6,
+      TouchBegin = 18,
+      TouchUpdate = 19,
+      TouchEnd = 20,
+    } opcode{};
+    bool send_event{};
+    uint16_t sequence{};
+    DeviceId deviceid{};
+    Time time{};
+    uint32_t detail{};
+    Window root{};
+    Window event{};
+    Window child{};
+    Fp1616 root_x{};
+    Fp1616 root_y{};
+    Fp1616 event_x{};
+    Fp1616 event_y{};
+    DeviceId sourceid{};
+    KeyEventFlags flags{};
+    ModifierInfo mods{};
+    GroupInfo group{};
+    std::vector<uint32_t> button_mask{};
+    std::vector<uint32_t> valuator_mask{};
+    std::vector<Fp3232> axisvalues{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+  };
+
+  struct CrossingEvent {
+    static constexpr int type_id = 32;
+    enum Opcode {
+      Enter = 7,
+      Leave = 8,
+      FocusIn = 9,
+      FocusOut = 10,
+    } opcode{};
+    bool send_event{};
+    uint16_t sequence{};
+    DeviceId deviceid{};
+    Time time{};
+    DeviceId sourceid{};
+    NotifyMode mode{};
+    NotifyDetail detail{};
+    Window root{};
+    Window event{};
+    Window child{};
+    Fp1616 root_x{};
+    Fp1616 root_y{};
+    Fp1616 event_x{};
+    Fp1616 event_y{};
+    uint8_t same_screen{};
+    uint8_t focus{};
+    ModifierInfo mods{};
+    GroupInfo group{};
+    std::vector<uint32_t> buttons{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+  };
+
+  struct HierarchyInfo {
+    DeviceId deviceid{};
+    DeviceId attachment{};
+    DeviceType type{};
+    uint8_t enabled{};
+    HierarchyMask flags{};
+  };
+
+  struct HierarchyEvent {
+    static constexpr int type_id = 33;
+    static constexpr uint8_t opcode = 11;
+    bool send_event{};
+    uint16_t sequence{};
+    DeviceId deviceid{};
+    Time time{};
+    HierarchyMask flags{};
+    std::vector<HierarchyInfo> infos{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct PropertyEvent {
+    static constexpr int type_id = 34;
+    static constexpr uint8_t opcode = 12;
+    bool send_event{};
+    uint16_t sequence{};
+    DeviceId deviceid{};
+    Time time{};
+    Atom property{};
+    PropertyFlag what{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct RawDeviceEvent {
+    static constexpr int type_id = 35;
+    enum Opcode {
+      RawKeyPress = 13,
+      RawKeyRelease = 14,
+      RawButtonPress = 15,
+      RawButtonRelease = 16,
+      RawMotion = 17,
+      RawTouchBegin = 22,
+      RawTouchUpdate = 23,
+      RawTouchEnd = 24,
+    } opcode{};
+    bool send_event{};
+    uint16_t sequence{};
+    DeviceId deviceid{};
+    Time time{};
+    uint32_t detail{};
+    DeviceId sourceid{};
+    KeyEventFlags flags{};
+    std::vector<uint32_t> valuator_mask{};
+    std::vector<Fp3232> axisvalues{};
+    std::vector<Fp3232> axisvalues_raw{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct TouchOwnershipEvent {
+    static constexpr int type_id = 36;
+    static constexpr uint8_t opcode = 21;
+    bool send_event{};
+    uint16_t sequence{};
+    DeviceId deviceid{};
+    Time time{};
+    uint32_t touchid{};
+    Window root{};
+    Window event{};
+    Window child{};
+    DeviceId sourceid{};
+    TouchOwnershipFlags flags{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+  };
+
+  struct BarrierEvent {
+    static constexpr int type_id = 37;
+    enum Opcode {
+      Hit = 25,
+      Leave = 26,
+    } opcode{};
+    bool send_event{};
+    uint16_t sequence{};
+    DeviceId deviceid{};
+    Time time{};
+    uint32_t eventid{};
+    Window root{};
+    Window event{};
+    XFixes::Barrier barrier{};
+    uint32_t dtime{};
+    BarrierFlags flags{};
+    DeviceId sourceid{};
+    Fp1616 root_x{};
+    Fp1616 root_y{};
+    Fp3232 dx{};
+    Fp3232 dy{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+  };
+
+  using EventForSend = std::array<uint8_t, 32>;
+  struct DeviceError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct EventError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct ModeError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct DeviceBusyError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct ClassError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct GetExtensionVersionRequest {
+    std::string name{};
+  };
+
+  struct GetExtensionVersionReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    uint16_t server_major{};
+    uint16_t server_minor{};
+    uint8_t present{};
+  };
+
+  using GetExtensionVersionResponse = Response<GetExtensionVersionReply>;
+
+  Future<GetExtensionVersionReply> GetExtensionVersion(
+      const GetExtensionVersionRequest& request);
+
+  Future<GetExtensionVersionReply> GetExtensionVersion(
+      const std::string& name = {});
+
+  struct ListInputDevicesRequest {};
+
+  struct ListInputDevicesReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    std::vector<DeviceInfo> devices{};
+    std::vector<InputInfo> infos{};
+    std::vector<Str> names{};
+  };
+
+  using ListInputDevicesResponse = Response<ListInputDevicesReply>;
+
+  Future<ListInputDevicesReply> ListInputDevices(
+      const ListInputDevicesRequest& request);
+
+  Future<ListInputDevicesReply> ListInputDevices();
+
+  struct OpenDeviceRequest {
+    uint8_t device_id{};
+  };
+
+  struct OpenDeviceReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    std::vector<InputClassInfo> class_info{};
+  };
+
+  using OpenDeviceResponse = Response<OpenDeviceReply>;
+
+  Future<OpenDeviceReply> OpenDevice(const OpenDeviceRequest& request);
+
+  Future<OpenDeviceReply> OpenDevice(const uint8_t& device_id = {});
+
+  struct CloseDeviceRequest {
+    uint8_t device_id{};
+  };
+
+  using CloseDeviceResponse = Response<void>;
+
+  Future<void> CloseDevice(const CloseDeviceRequest& request);
+
+  Future<void> CloseDevice(const uint8_t& device_id = {});
+
+  struct SetDeviceModeRequest {
+    uint8_t device_id{};
+    ValuatorMode mode{};
+  };
+
+  struct SetDeviceModeReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    GrabStatus status{};
+  };
+
+  using SetDeviceModeResponse = Response<SetDeviceModeReply>;
+
+  Future<SetDeviceModeReply> SetDeviceMode(const SetDeviceModeRequest& request);
+
+  Future<SetDeviceModeReply> SetDeviceMode(const uint8_t& device_id = {},
+                                           const ValuatorMode& mode = {});
+
+  struct SelectExtensionEventRequest {
+    Window window{};
+    std::vector<EventClass> classes{};
+  };
+
+  using SelectExtensionEventResponse = Response<void>;
+
+  Future<void> SelectExtensionEvent(const SelectExtensionEventRequest& request);
+
+  Future<void> SelectExtensionEvent(
+      const Window& window = {},
+      const std::vector<EventClass>& classes = {});
+
+  struct GetSelectedExtensionEventsRequest {
+    Window window{};
+  };
+
+  struct GetSelectedExtensionEventsReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    std::vector<EventClass> this_classes{};
+    std::vector<EventClass> all_classes{};
+  };
+
+  using GetSelectedExtensionEventsResponse =
+      Response<GetSelectedExtensionEventsReply>;
+
+  Future<GetSelectedExtensionEventsReply> GetSelectedExtensionEvents(
+      const GetSelectedExtensionEventsRequest& request);
+
+  Future<GetSelectedExtensionEventsReply> GetSelectedExtensionEvents(
+      const Window& window = {});
+
+  struct ChangeDeviceDontPropagateListRequest {
+    Window window{};
+    PropagateMode mode{};
+    std::vector<EventClass> classes{};
+  };
+
+  using ChangeDeviceDontPropagateListResponse = Response<void>;
+
+  Future<void> ChangeDeviceDontPropagateList(
+      const ChangeDeviceDontPropagateListRequest& request);
+
+  Future<void> ChangeDeviceDontPropagateList(
+      const Window& window = {},
+      const PropagateMode& mode = {},
+      const std::vector<EventClass>& classes = {});
+
+  struct GetDeviceDontPropagateListRequest {
+    Window window{};
+  };
+
+  struct GetDeviceDontPropagateListReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    std::vector<EventClass> classes{};
+  };
+
+  using GetDeviceDontPropagateListResponse =
+      Response<GetDeviceDontPropagateListReply>;
+
+  Future<GetDeviceDontPropagateListReply> GetDeviceDontPropagateList(
+      const GetDeviceDontPropagateListRequest& request);
+
+  Future<GetDeviceDontPropagateListReply> GetDeviceDontPropagateList(
+      const Window& window = {});
+
+  struct GetDeviceMotionEventsRequest {
+    Time start{};
+    Time stop{};
+    uint8_t device_id{};
+  };
+
+  struct GetDeviceMotionEventsReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    uint8_t num_axes{};
+    ValuatorMode device_mode{};
+    std::vector<DeviceTimeCoord> events{};
+  };
+
+  using GetDeviceMotionEventsResponse = Response<GetDeviceMotionEventsReply>;
+
+  Future<GetDeviceMotionEventsReply> GetDeviceMotionEvents(
+      const GetDeviceMotionEventsRequest& request);
+
+  Future<GetDeviceMotionEventsReply> GetDeviceMotionEvents(
+      const Time& start = {},
+      const Time& stop = {},
+      const uint8_t& device_id = {});
+
+  struct ChangeKeyboardDeviceRequest {
+    uint8_t device_id{};
+  };
+
+  struct ChangeKeyboardDeviceReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    GrabStatus status{};
+  };
+
+  using ChangeKeyboardDeviceResponse = Response<ChangeKeyboardDeviceReply>;
+
+  Future<ChangeKeyboardDeviceReply> ChangeKeyboardDevice(
+      const ChangeKeyboardDeviceRequest& request);
+
+  Future<ChangeKeyboardDeviceReply> ChangeKeyboardDevice(
+      const uint8_t& device_id = {});
+
+  struct ChangePointerDeviceRequest {
+    uint8_t x_axis{};
+    uint8_t y_axis{};
+    uint8_t device_id{};
+  };
+
+  struct ChangePointerDeviceReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    GrabStatus status{};
+  };
+
+  using ChangePointerDeviceResponse = Response<ChangePointerDeviceReply>;
+
+  Future<ChangePointerDeviceReply> ChangePointerDevice(
+      const ChangePointerDeviceRequest& request);
+
+  Future<ChangePointerDeviceReply> ChangePointerDevice(
+      const uint8_t& x_axis = {},
+      const uint8_t& y_axis = {},
+      const uint8_t& device_id = {});
+
+  struct GrabDeviceRequest {
+    Window grab_window{};
+    Time time{};
+    GrabMode this_device_mode{};
+    GrabMode other_device_mode{};
+    uint8_t owner_events{};
+    uint8_t device_id{};
+    std::vector<EventClass> classes{};
+  };
+
+  struct GrabDeviceReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    GrabStatus status{};
+  };
+
+  using GrabDeviceResponse = Response<GrabDeviceReply>;
+
+  Future<GrabDeviceReply> GrabDevice(const GrabDeviceRequest& request);
+
+  Future<GrabDeviceReply> GrabDevice(
+      const Window& grab_window = {},
+      const Time& time = {},
+      const GrabMode& this_device_mode = {},
+      const GrabMode& other_device_mode = {},
+      const uint8_t& owner_events = {},
+      const uint8_t& device_id = {},
+      const std::vector<EventClass>& classes = {});
+
+  struct UngrabDeviceRequest {
+    Time time{};
+    uint8_t device_id{};
+  };
+
+  using UngrabDeviceResponse = Response<void>;
+
+  Future<void> UngrabDevice(const UngrabDeviceRequest& request);
+
+  Future<void> UngrabDevice(const Time& time = {},
+                            const uint8_t& device_id = {});
+
+  struct GrabDeviceKeyRequest {
+    Window grab_window{};
+    ModMask modifiers{};
+    uint8_t modifier_device{};
+    uint8_t grabbed_device{};
+    uint8_t key{};
+    GrabMode this_device_mode{};
+    GrabMode other_device_mode{};
+    uint8_t owner_events{};
+    std::vector<EventClass> classes{};
+  };
+
+  using GrabDeviceKeyResponse = Response<void>;
+
+  Future<void> GrabDeviceKey(const GrabDeviceKeyRequest& request);
+
+  Future<void> GrabDeviceKey(const Window& grab_window = {},
+                             const ModMask& modifiers = {},
+                             const uint8_t& modifier_device = {},
+                             const uint8_t& grabbed_device = {},
+                             const uint8_t& key = {},
+                             const GrabMode& this_device_mode = {},
+                             const GrabMode& other_device_mode = {},
+                             const uint8_t& owner_events = {},
+                             const std::vector<EventClass>& classes = {});
+
+  struct UngrabDeviceKeyRequest {
+    Window grabWindow{};
+    ModMask modifiers{};
+    uint8_t modifier_device{};
+    uint8_t key{};
+    uint8_t grabbed_device{};
+  };
+
+  using UngrabDeviceKeyResponse = Response<void>;
+
+  Future<void> UngrabDeviceKey(const UngrabDeviceKeyRequest& request);
+
+  Future<void> UngrabDeviceKey(const Window& grabWindow = {},
+                               const ModMask& modifiers = {},
+                               const uint8_t& modifier_device = {},
+                               const uint8_t& key = {},
+                               const uint8_t& grabbed_device = {});
+
+  struct GrabDeviceButtonRequest {
+    Window grab_window{};
+    uint8_t grabbed_device{};
+    uint8_t modifier_device{};
+    ModMask modifiers{};
+    GrabMode this_device_mode{};
+    GrabMode other_device_mode{};
+    uint8_t button{};
+    uint8_t owner_events{};
+    std::vector<EventClass> classes{};
+  };
+
+  using GrabDeviceButtonResponse = Response<void>;
+
+  Future<void> GrabDeviceButton(const GrabDeviceButtonRequest& request);
+
+  Future<void> GrabDeviceButton(const Window& grab_window = {},
+                                const uint8_t& grabbed_device = {},
+                                const uint8_t& modifier_device = {},
+                                const ModMask& modifiers = {},
+                                const GrabMode& this_device_mode = {},
+                                const GrabMode& other_device_mode = {},
+                                const uint8_t& button = {},
+                                const uint8_t& owner_events = {},
+                                const std::vector<EventClass>& classes = {});
+
+  struct UngrabDeviceButtonRequest {
+    Window grab_window{};
+    ModMask modifiers{};
+    uint8_t modifier_device{};
+    uint8_t button{};
+    uint8_t grabbed_device{};
+  };
+
+  using UngrabDeviceButtonResponse = Response<void>;
+
+  Future<void> UngrabDeviceButton(const UngrabDeviceButtonRequest& request);
+
+  Future<void> UngrabDeviceButton(const Window& grab_window = {},
+                                  const ModMask& modifiers = {},
+                                  const uint8_t& modifier_device = {},
+                                  const uint8_t& button = {},
+                                  const uint8_t& grabbed_device = {});
+
+  struct AllowDeviceEventsRequest {
+    Time time{};
+    DeviceInputMode mode{};
+    uint8_t device_id{};
+  };
+
+  using AllowDeviceEventsResponse = Response<void>;
+
+  Future<void> AllowDeviceEvents(const AllowDeviceEventsRequest& request);
+
+  Future<void> AllowDeviceEvents(const Time& time = {},
+                                 const DeviceInputMode& mode = {},
+                                 const uint8_t& device_id = {});
+
+  struct GetDeviceFocusRequest {
+    uint8_t device_id{};
+  };
+
+  struct GetDeviceFocusReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    Window focus{};
+    Time time{};
+    InputFocus revert_to{};
+  };
+
+  using GetDeviceFocusResponse = Response<GetDeviceFocusReply>;
+
+  Future<GetDeviceFocusReply> GetDeviceFocus(
+      const GetDeviceFocusRequest& request);
+
+  Future<GetDeviceFocusReply> GetDeviceFocus(const uint8_t& device_id = {});
+
+  struct SetDeviceFocusRequest {
+    Window focus{};
+    Time time{};
+    InputFocus revert_to{};
+    uint8_t device_id{};
+  };
+
+  using SetDeviceFocusResponse = Response<void>;
+
+  Future<void> SetDeviceFocus(const SetDeviceFocusRequest& request);
+
+  Future<void> SetDeviceFocus(const Window& focus = {},
+                              const Time& time = {},
+                              const InputFocus& revert_to = {},
+                              const uint8_t& device_id = {});
+
+  struct GetFeedbackControlRequest {
+    uint8_t device_id{};
+  };
+
+  struct GetFeedbackControlReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    std::vector<FeedbackState> feedbacks{};
+  };
+
+  using GetFeedbackControlResponse = Response<GetFeedbackControlReply>;
+
+  Future<GetFeedbackControlReply> GetFeedbackControl(
+      const GetFeedbackControlRequest& request);
+
+  Future<GetFeedbackControlReply> GetFeedbackControl(
+      const uint8_t& device_id = {});
+
+  struct ChangeFeedbackControlRequest {
+    ChangeFeedbackControlMask mask{};
+    uint8_t device_id{};
+    uint8_t feedback_id{};
+    FeedbackCtl feedback{};
+  };
+
+  using ChangeFeedbackControlResponse = Response<void>;
+
+  Future<void> ChangeFeedbackControl(
+      const ChangeFeedbackControlRequest& request);
+
+  struct Keyboard {
+    KeyCode key{};
+    uint8_t auto_repeat_mode{};
+    int8_t key_click_percent{};
+    int8_t bell_percent{};
+    int16_t bell_pitch{};
+    int16_t bell_duration{};
+    uint32_t led_mask{};
+    uint32_t led_values{};
+  };
+  struct Pointer {
+    int16_t num{};
+    int16_t denom{};
+    int16_t threshold{};
+  };
+  struct String {
+    std::vector<KeySym> keysyms{};
+  };
+  struct Integer {
+    int32_t int_to_display{};
+  };
+  struct Led {
+    uint32_t led_mask{};
+    uint32_t led_values{};
+  };
+  struct Bell {
+    int8_t percent{};
+    int16_t pitch{};
+    int16_t duration{};
+  };
+  Future<void> ChangeFeedbackControl(const ChangeFeedbackControlMask& mask = {},
+                                     const uint8_t& device_id = {},
+                                     const uint8_t& feedback_id = {},
+                                     const FeedbackCtl& feedback = {
+                                         {},
+                                         {},
+                                         absl::nullopt,
+                                         absl::nullopt,
+                                         absl::nullopt,
+                                         absl::nullopt,
+                                         absl::nullopt,
+                                         absl::nullopt});
+
+  struct GetDeviceKeyMappingRequest {
+    uint8_t device_id{};
+    KeyCode first_keycode{};
+    uint8_t count{};
+  };
+
+  struct GetDeviceKeyMappingReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    uint8_t keysyms_per_keycode{};
+    std::vector<KeySym> keysyms{};
+  };
+
+  using GetDeviceKeyMappingResponse = Response<GetDeviceKeyMappingReply>;
+
+  Future<GetDeviceKeyMappingReply> GetDeviceKeyMapping(
+      const GetDeviceKeyMappingRequest& request);
+
+  Future<GetDeviceKeyMappingReply> GetDeviceKeyMapping(
+      const uint8_t& device_id = {},
+      const KeyCode& first_keycode = {},
+      const uint8_t& count = {});
+
+  struct ChangeDeviceKeyMappingRequest {
+    uint8_t device_id{};
+    KeyCode first_keycode{};
+    uint8_t keysyms_per_keycode{};
+    uint8_t keycode_count{};
+    std::vector<KeySym> keysyms{};
+  };
+
+  using ChangeDeviceKeyMappingResponse = Response<void>;
+
+  Future<void> ChangeDeviceKeyMapping(
+      const ChangeDeviceKeyMappingRequest& request);
+
+  Future<void> ChangeDeviceKeyMapping(const uint8_t& device_id = {},
+                                      const KeyCode& first_keycode = {},
+                                      const uint8_t& keysyms_per_keycode = {},
+                                      const uint8_t& keycode_count = {},
+                                      const std::vector<KeySym>& keysyms = {});
+
+  struct GetDeviceModifierMappingRequest {
+    uint8_t device_id{};
+  };
+
+  struct GetDeviceModifierMappingReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    uint8_t keycodes_per_modifier{};
+    std::vector<uint8_t> keymaps{};
+  };
+
+  using GetDeviceModifierMappingResponse =
+      Response<GetDeviceModifierMappingReply>;
+
+  Future<GetDeviceModifierMappingReply> GetDeviceModifierMapping(
+      const GetDeviceModifierMappingRequest& request);
+
+  Future<GetDeviceModifierMappingReply> GetDeviceModifierMapping(
+      const uint8_t& device_id = {});
+
+  struct SetDeviceModifierMappingRequest {
+    uint8_t device_id{};
+    uint8_t keycodes_per_modifier{};
+    std::vector<uint8_t> keymaps{};
+  };
+
+  struct SetDeviceModifierMappingReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    MappingStatus status{};
+  };
+
+  using SetDeviceModifierMappingResponse =
+      Response<SetDeviceModifierMappingReply>;
+
+  Future<SetDeviceModifierMappingReply> SetDeviceModifierMapping(
+      const SetDeviceModifierMappingRequest& request);
+
+  Future<SetDeviceModifierMappingReply> SetDeviceModifierMapping(
+      const uint8_t& device_id = {},
+      const uint8_t& keycodes_per_modifier = {},
+      const std::vector<uint8_t>& keymaps = {});
+
+  struct GetDeviceButtonMappingRequest {
+    uint8_t device_id{};
+  };
+
+  struct GetDeviceButtonMappingReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    std::vector<uint8_t> map{};
+  };
+
+  using GetDeviceButtonMappingResponse = Response<GetDeviceButtonMappingReply>;
+
+  Future<GetDeviceButtonMappingReply> GetDeviceButtonMapping(
+      const GetDeviceButtonMappingRequest& request);
+
+  Future<GetDeviceButtonMappingReply> GetDeviceButtonMapping(
+      const uint8_t& device_id = {});
+
+  struct SetDeviceButtonMappingRequest {
+    uint8_t device_id{};
+    std::vector<uint8_t> map{};
+  };
+
+  struct SetDeviceButtonMappingReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    MappingStatus status{};
+  };
+
+  using SetDeviceButtonMappingResponse = Response<SetDeviceButtonMappingReply>;
+
+  Future<SetDeviceButtonMappingReply> SetDeviceButtonMapping(
+      const SetDeviceButtonMappingRequest& request);
+
+  Future<SetDeviceButtonMappingReply> SetDeviceButtonMapping(
+      const uint8_t& device_id = {},
+      const std::vector<uint8_t>& map = {});
+
+  struct QueryDeviceStateRequest {
+    uint8_t device_id{};
+  };
+
+  struct QueryDeviceStateReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    std::vector<InputState> classes{};
+  };
+
+  using QueryDeviceStateResponse = Response<QueryDeviceStateReply>;
+
+  Future<QueryDeviceStateReply> QueryDeviceState(
+      const QueryDeviceStateRequest& request);
+
+  Future<QueryDeviceStateReply> QueryDeviceState(const uint8_t& device_id = {});
+
+  struct DeviceBellRequest {
+    uint8_t device_id{};
+    uint8_t feedback_id{};
+    uint8_t feedback_class{};
+    int8_t percent{};
+  };
+
+  using DeviceBellResponse = Response<void>;
+
+  Future<void> DeviceBell(const DeviceBellRequest& request);
+
+  Future<void> DeviceBell(const uint8_t& device_id = {},
+                          const uint8_t& feedback_id = {},
+                          const uint8_t& feedback_class = {},
+                          const int8_t& percent = {});
+
+  struct SetDeviceValuatorsRequest {
+    uint8_t device_id{};
+    uint8_t first_valuator{};
+    std::vector<int32_t> valuators{};
+  };
+
+  struct SetDeviceValuatorsReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    GrabStatus status{};
+  };
+
+  using SetDeviceValuatorsResponse = Response<SetDeviceValuatorsReply>;
+
+  Future<SetDeviceValuatorsReply> SetDeviceValuators(
+      const SetDeviceValuatorsRequest& request);
+
+  Future<SetDeviceValuatorsReply> SetDeviceValuators(
+      const uint8_t& device_id = {},
+      const uint8_t& first_valuator = {},
+      const std::vector<int32_t>& valuators = {});
+
+  struct GetDeviceControlRequest {
+    DeviceControl control_id{};
+    uint8_t device_id{};
+  };
+
+  struct GetDeviceControlReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    uint8_t status{};
+    DeviceState control{};
+  };
+
+  using GetDeviceControlResponse = Response<GetDeviceControlReply>;
+
+  Future<GetDeviceControlReply> GetDeviceControl(
+      const GetDeviceControlRequest& request);
+
+  Future<GetDeviceControlReply> GetDeviceControl(
+      const DeviceControl& control_id = {},
+      const uint8_t& device_id = {});
+
+  struct ChangeDeviceControlRequest {
+    DeviceControl control_id{};
+    uint8_t device_id{};
+    DeviceCtl control{};
+  };
+
+  struct ChangeDeviceControlReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    uint8_t status{};
+  };
+
+  using ChangeDeviceControlResponse = Response<ChangeDeviceControlReply>;
+
+  Future<ChangeDeviceControlReply> ChangeDeviceControl(
+      const ChangeDeviceControlRequest& request);
+
+  struct Resolution {
+    uint8_t first_valuator{};
+    std::vector<uint32_t> resolution_values{};
+  };
+  struct AbsCalib {
+    int32_t min_x{};
+    int32_t max_x{};
+    int32_t min_y{};
+    int32_t max_y{};
+    uint32_t flip_x{};
+    uint32_t flip_y{};
+    uint32_t rotation{};
+    uint32_t button_threshold{};
+  };
+  struct Core {
+    uint8_t status{};
+  };
+  struct Enable {
+    uint8_t enable{};
+  };
+  struct AbsArea {
+    uint32_t offset_x{};
+    uint32_t offset_y{};
+    int32_t width{};
+    int32_t height{};
+    int32_t screen{};
+    uint32_t following{};
+  };
+  Future<ChangeDeviceControlReply> ChangeDeviceControl(
+      const DeviceControl& control_id = {},
+      const uint8_t& device_id = {},
+      const DeviceCtl& control = {{},
+                                  absl::nullopt,
+                                  absl::nullopt,
+                                  absl::nullopt,
+                                  absl::nullopt,
+                                  absl::nullopt});
+
+  struct ListDevicePropertiesRequest {
+    uint8_t device_id{};
+  };
+
+  struct ListDevicePropertiesReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    std::vector<Atom> atoms{};
+  };
+
+  using ListDevicePropertiesResponse = Response<ListDevicePropertiesReply>;
+
+  Future<ListDevicePropertiesReply> ListDeviceProperties(
+      const ListDevicePropertiesRequest& request);
+
+  Future<ListDevicePropertiesReply> ListDeviceProperties(
+      const uint8_t& device_id = {});
+
+  struct ChangeDevicePropertyRequest {
+    Atom property{};
+    Atom type{};
+    uint8_t device_id{};
+    PropMode mode{};
+    uint32_t num_items{};
+    absl::optional<std::vector<uint8_t>> data8{};
+    absl::optional<std::vector<uint16_t>> data16{};
+    absl::optional<std::vector<uint32_t>> data32{};
+  };
+
+  using ChangeDevicePropertyResponse = Response<void>;
+
+  Future<void> ChangeDeviceProperty(const ChangeDevicePropertyRequest& request);
+
+  Future<void> ChangeDeviceProperty(
+      const Atom& property = {},
+      const Atom& type = {},
+      const uint8_t& device_id = {},
+      const PropMode& mode = {},
+      const uint32_t& num_items = {},
+      const absl::optional<std::vector<uint8_t>>& data8 = absl::nullopt,
+      const absl::optional<std::vector<uint16_t>>& data16 = absl::nullopt,
+      const absl::optional<std::vector<uint32_t>>& data32 = absl::nullopt);
+
+  struct DeleteDevicePropertyRequest {
+    Atom property{};
+    uint8_t device_id{};
+  };
+
+  using DeleteDevicePropertyResponse = Response<void>;
+
+  Future<void> DeleteDeviceProperty(const DeleteDevicePropertyRequest& request);
+
+  Future<void> DeleteDeviceProperty(const Atom& property = {},
+                                    const uint8_t& device_id = {});
+
+  struct GetDevicePropertyRequest {
+    Atom property{};
+    Atom type{};
+    uint32_t offset{};
+    uint32_t len{};
+    uint8_t device_id{};
+    uint8_t c_delete{};
+  };
+
+  struct GetDevicePropertyReply {
+    uint8_t xi_reply_type{};
+    uint16_t sequence{};
+    Atom type{};
+    uint32_t bytes_after{};
+    uint32_t num_items{};
+    uint8_t device_id{};
+    absl::optional<std::vector<uint8_t>> data8{};
+    absl::optional<std::vector<uint16_t>> data16{};
+    absl::optional<std::vector<uint32_t>> data32{};
+  };
+
+  using GetDevicePropertyResponse = Response<GetDevicePropertyReply>;
+
+  Future<GetDevicePropertyReply> GetDeviceProperty(
+      const GetDevicePropertyRequest& request);
+
+  Future<GetDevicePropertyReply> GetDeviceProperty(
+      const Atom& property = {},
+      const Atom& type = {},
+      const uint32_t& offset = {},
+      const uint32_t& len = {},
+      const uint8_t& device_id = {},
+      const uint8_t& c_delete = {});
+
+  struct XIQueryPointerRequest {
+    Window window{};
+    DeviceId deviceid{};
+  };
+
+  struct XIQueryPointerReply {
+    uint16_t sequence{};
+    Window root{};
+    Window child{};
+    Fp1616 root_x{};
+    Fp1616 root_y{};
+    Fp1616 win_x{};
+    Fp1616 win_y{};
+    uint8_t same_screen{};
+    ModifierInfo mods{};
+    GroupInfo group{};
+    std::vector<uint32_t> buttons{};
+  };
+
+  using XIQueryPointerResponse = Response<XIQueryPointerReply>;
+
+  Future<XIQueryPointerReply> XIQueryPointer(
+      const XIQueryPointerRequest& request);
+
+  Future<XIQueryPointerReply> XIQueryPointer(const Window& window = {},
+                                             const DeviceId& deviceid = {});
+
+  struct XIWarpPointerRequest {
+    Window src_win{};
+    Window dst_win{};
+    Fp1616 src_x{};
+    Fp1616 src_y{};
+    uint16_t src_width{};
+    uint16_t src_height{};
+    Fp1616 dst_x{};
+    Fp1616 dst_y{};
+    DeviceId deviceid{};
+  };
+
+  using XIWarpPointerResponse = Response<void>;
+
+  Future<void> XIWarpPointer(const XIWarpPointerRequest& request);
+
+  Future<void> XIWarpPointer(const Window& src_win = {},
+                             const Window& dst_win = {},
+                             const Fp1616& src_x = {},
+                             const Fp1616& src_y = {},
+                             const uint16_t& src_width = {},
+                             const uint16_t& src_height = {},
+                             const Fp1616& dst_x = {},
+                             const Fp1616& dst_y = {},
+                             const DeviceId& deviceid = {});
+
+  struct XIChangeCursorRequest {
+    Window window{};
+    Cursor cursor{};
+    DeviceId deviceid{};
+  };
+
+  using XIChangeCursorResponse = Response<void>;
+
+  Future<void> XIChangeCursor(const XIChangeCursorRequest& request);
+
+  Future<void> XIChangeCursor(const Window& window = {},
+                              const Cursor& cursor = {},
+                              const DeviceId& deviceid = {});
+
+  struct XIChangeHierarchyRequest {
+    std::vector<HierarchyChange> changes{};
+  };
+
+  using XIChangeHierarchyResponse = Response<void>;
+
+  Future<void> XIChangeHierarchy(const XIChangeHierarchyRequest& request);
+
+  Future<void> XIChangeHierarchy(
+      const std::vector<HierarchyChange>& changes = {});
+
+  struct XISetClientPointerRequest {
+    Window window{};
+    DeviceId deviceid{};
+  };
+
+  using XISetClientPointerResponse = Response<void>;
+
+  Future<void> XISetClientPointer(const XISetClientPointerRequest& request);
+
+  Future<void> XISetClientPointer(const Window& window = {},
+                                  const DeviceId& deviceid = {});
+
+  struct XIGetClientPointerRequest {
+    Window window{};
+  };
+
+  struct XIGetClientPointerReply {
+    uint16_t sequence{};
+    uint8_t set{};
+    DeviceId deviceid{};
+  };
+
+  using XIGetClientPointerResponse = Response<XIGetClientPointerReply>;
+
+  Future<XIGetClientPointerReply> XIGetClientPointer(
+      const XIGetClientPointerRequest& request);
+
+  Future<XIGetClientPointerReply> XIGetClientPointer(const Window& window = {});
+
+  struct XISelectEventsRequest {
+    Window window{};
+    std::vector<EventMask> masks{};
+  };
+
+  using XISelectEventsResponse = Response<void>;
+
+  Future<void> XISelectEvents(const XISelectEventsRequest& request);
+
+  Future<void> XISelectEvents(const Window& window = {},
+                              const std::vector<EventMask>& masks = {});
+
+  struct XIQueryVersionRequest {
+    uint16_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  struct XIQueryVersionReply {
+    uint16_t sequence{};
+    uint16_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  using XIQueryVersionResponse = Response<XIQueryVersionReply>;
+
+  Future<XIQueryVersionReply> XIQueryVersion(
+      const XIQueryVersionRequest& request);
+
+  Future<XIQueryVersionReply> XIQueryVersion(
+      const uint16_t& major_version = {},
+      const uint16_t& minor_version = {});
+
+  struct XIQueryDeviceRequest {
+    DeviceId deviceid{};
+  };
+
+  struct XIQueryDeviceReply {
+    uint16_t sequence{};
+    std::vector<XIDeviceInfo> infos{};
+  };
+
+  using XIQueryDeviceResponse = Response<XIQueryDeviceReply>;
+
+  Future<XIQueryDeviceReply> XIQueryDevice(const XIQueryDeviceRequest& request);
+
+  Future<XIQueryDeviceReply> XIQueryDevice(const DeviceId& deviceid = {});
+
+  struct XISetFocusRequest {
+    Window window{};
+    Time time{};
+    DeviceId deviceid{};
+  };
+
+  using XISetFocusResponse = Response<void>;
+
+  Future<void> XISetFocus(const XISetFocusRequest& request);
+
+  Future<void> XISetFocus(const Window& window = {},
+                          const Time& time = {},
+                          const DeviceId& deviceid = {});
+
+  struct XIGetFocusRequest {
+    DeviceId deviceid{};
+  };
+
+  struct XIGetFocusReply {
+    uint16_t sequence{};
+    Window focus{};
+  };
+
+  using XIGetFocusResponse = Response<XIGetFocusReply>;
+
+  Future<XIGetFocusReply> XIGetFocus(const XIGetFocusRequest& request);
+
+  Future<XIGetFocusReply> XIGetFocus(const DeviceId& deviceid = {});
+
+  struct XIGrabDeviceRequest {
+    Window window{};
+    Time time{};
+    Cursor cursor{};
+    DeviceId deviceid{};
+    GrabMode mode{};
+    GrabMode paired_device_mode{};
+    GrabOwner owner_events{};
+    std::vector<uint32_t> mask{};
+  };
+
+  struct XIGrabDeviceReply {
+    uint16_t sequence{};
+    GrabStatus status{};
+  };
+
+  using XIGrabDeviceResponse = Response<XIGrabDeviceReply>;
+
+  Future<XIGrabDeviceReply> XIGrabDevice(const XIGrabDeviceRequest& request);
+
+  Future<XIGrabDeviceReply> XIGrabDevice(
+      const Window& window = {},
+      const Time& time = {},
+      const Cursor& cursor = {},
+      const DeviceId& deviceid = {},
+      const GrabMode& mode = {},
+      const GrabMode& paired_device_mode = {},
+      const GrabOwner& owner_events = {},
+      const std::vector<uint32_t>& mask = {});
+
+  struct XIUngrabDeviceRequest {
+    Time time{};
+    DeviceId deviceid{};
+  };
+
+  using XIUngrabDeviceResponse = Response<void>;
+
+  Future<void> XIUngrabDevice(const XIUngrabDeviceRequest& request);
+
+  Future<void> XIUngrabDevice(const Time& time = {},
+                              const DeviceId& deviceid = {});
+
+  struct XIAllowEventsRequest {
+    Time time{};
+    DeviceId deviceid{};
+    EventMode event_mode{};
+    uint32_t touchid{};
+    Window grab_window{};
+  };
+
+  using XIAllowEventsResponse = Response<void>;
+
+  Future<void> XIAllowEvents(const XIAllowEventsRequest& request);
+
+  Future<void> XIAllowEvents(const Time& time = {},
+                             const DeviceId& deviceid = {},
+                             const EventMode& event_mode = {},
+                             const uint32_t& touchid = {},
+                             const Window& grab_window = {});
+
+  struct XIPassiveGrabDeviceRequest {
+    Time time{};
+    Window grab_window{};
+    Cursor cursor{};
+    uint32_t detail{};
+    DeviceId deviceid{};
+    GrabType grab_type{};
+    GrabMode22 grab_mode{};
+    GrabMode paired_device_mode{};
+    GrabOwner owner_events{};
+    std::vector<uint32_t> mask{};
+    std::vector<uint32_t> modifiers{};
+  };
+
+  struct XIPassiveGrabDeviceReply {
+    uint16_t sequence{};
+    std::vector<GrabModifierInfo> modifiers{};
+  };
+
+  using XIPassiveGrabDeviceResponse = Response<XIPassiveGrabDeviceReply>;
+
+  Future<XIPassiveGrabDeviceReply> XIPassiveGrabDevice(
+      const XIPassiveGrabDeviceRequest& request);
+
+  Future<XIPassiveGrabDeviceReply> XIPassiveGrabDevice(
+      const Time& time = {},
+      const Window& grab_window = {},
+      const Cursor& cursor = {},
+      const uint32_t& detail = {},
+      const DeviceId& deviceid = {},
+      const GrabType& grab_type = {},
+      const GrabMode22& grab_mode = {},
+      const GrabMode& paired_device_mode = {},
+      const GrabOwner& owner_events = {},
+      const std::vector<uint32_t>& mask = {},
+      const std::vector<uint32_t>& modifiers = {});
+
+  struct XIPassiveUngrabDeviceRequest {
+    Window grab_window{};
+    uint32_t detail{};
+    DeviceId deviceid{};
+    GrabType grab_type{};
+    std::vector<uint32_t> modifiers{};
+  };
+
+  using XIPassiveUngrabDeviceResponse = Response<void>;
+
+  Future<void> XIPassiveUngrabDevice(
+      const XIPassiveUngrabDeviceRequest& request);
+
+  Future<void> XIPassiveUngrabDevice(
+      const Window& grab_window = {},
+      const uint32_t& detail = {},
+      const DeviceId& deviceid = {},
+      const GrabType& grab_type = {},
+      const std::vector<uint32_t>& modifiers = {});
+
+  struct XIListPropertiesRequest {
+    DeviceId deviceid{};
+  };
+
+  struct XIListPropertiesReply {
+    uint16_t sequence{};
+    std::vector<Atom> properties{};
+  };
+
+  using XIListPropertiesResponse = Response<XIListPropertiesReply>;
+
+  Future<XIListPropertiesReply> XIListProperties(
+      const XIListPropertiesRequest& request);
+
+  Future<XIListPropertiesReply> XIListProperties(const DeviceId& deviceid = {});
+
+  struct XIChangePropertyRequest {
+    DeviceId deviceid{};
+    PropMode mode{};
+    Atom property{};
+    Atom type{};
+    uint32_t num_items{};
+    absl::optional<std::vector<uint8_t>> data8{};
+    absl::optional<std::vector<uint16_t>> data16{};
+    absl::optional<std::vector<uint32_t>> data32{};
+  };
+
+  using XIChangePropertyResponse = Response<void>;
+
+  Future<void> XIChangeProperty(const XIChangePropertyRequest& request);
+
+  Future<void> XIChangeProperty(
+      const DeviceId& deviceid = {},
+      const PropMode& mode = {},
+      const Atom& property = {},
+      const Atom& type = {},
+      const uint32_t& num_items = {},
+      const absl::optional<std::vector<uint8_t>>& data8 = absl::nullopt,
+      const absl::optional<std::vector<uint16_t>>& data16 = absl::nullopt,
+      const absl::optional<std::vector<uint32_t>>& data32 = absl::nullopt);
+
+  struct XIDeletePropertyRequest {
+    DeviceId deviceid{};
+    Atom property{};
+  };
+
+  using XIDeletePropertyResponse = Response<void>;
+
+  Future<void> XIDeleteProperty(const XIDeletePropertyRequest& request);
+
+  Future<void> XIDeleteProperty(const DeviceId& deviceid = {},
+                                const Atom& property = {});
+
+  struct XIGetPropertyRequest {
+    DeviceId deviceid{};
+    uint8_t c_delete{};
+    Atom property{};
+    Atom type{};
+    uint32_t offset{};
+    uint32_t len{};
+  };
+
+  struct XIGetPropertyReply {
+    uint16_t sequence{};
+    Atom type{};
+    uint32_t bytes_after{};
+    uint32_t num_items{};
+    absl::optional<std::vector<uint8_t>> data8{};
+    absl::optional<std::vector<uint16_t>> data16{};
+    absl::optional<std::vector<uint32_t>> data32{};
+  };
+
+  using XIGetPropertyResponse = Response<XIGetPropertyReply>;
+
+  Future<XIGetPropertyReply> XIGetProperty(const XIGetPropertyRequest& request);
+
+  Future<XIGetPropertyReply> XIGetProperty(const DeviceId& deviceid = {},
+                                           const uint8_t& c_delete = {},
+                                           const Atom& property = {},
+                                           const Atom& type = {},
+                                           const uint32_t& offset = {},
+                                           const uint32_t& len = {});
+
+  struct XIGetSelectedEventsRequest {
+    Window window{};
+  };
+
+  struct XIGetSelectedEventsReply {
+    uint16_t sequence{};
+    std::vector<EventMask> masks{};
+  };
+
+  using XIGetSelectedEventsResponse = Response<XIGetSelectedEventsReply>;
+
+  Future<XIGetSelectedEventsReply> XIGetSelectedEvents(
+      const XIGetSelectedEventsRequest& request);
+
+  Future<XIGetSelectedEventsReply> XIGetSelectedEvents(
+      const Window& window = {});
+
+  struct XIBarrierReleasePointerRequest {
+    std::vector<BarrierReleasePointerInfo> barriers{};
+  };
+
+  using XIBarrierReleasePointerResponse = Response<void>;
+
+  Future<void> XIBarrierReleasePointer(
+      const XIBarrierReleasePointerRequest& request);
+
+  Future<void> XIBarrierReleasePointer(
+      const std::vector<BarrierReleasePointerInfo>& barriers = {});
+
+  struct SendExtensionEventRequest {
+    Window destination{};
+    uint8_t device_id{};
+    uint8_t propagate{};
+    std::vector<EventForSend> events{};
+    std::vector<EventClass> classes{};
+  };
+
+  using SendExtensionEventResponse = Response<void>;
+
+  Future<void> SendExtensionEvent(const SendExtensionEventRequest& request);
+
+  Future<void> SendExtensionEvent(const Window& destination = {},
+                                  const uint8_t& device_id = {},
+                                  const uint8_t& propagate = {},
+                                  const std::vector<EventForSend>& events = {},
+                                  const std::vector<EventClass>& classes = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Input::DeviceUse operator|(x11::Input::DeviceUse l,
+                                                 x11::Input::DeviceUse r) {
+  using T = std::underlying_type_t<x11::Input::DeviceUse>;
+  return static_cast<x11::Input::DeviceUse>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceUse operator&(x11::Input::DeviceUse l,
+                                                 x11::Input::DeviceUse r) {
+  using T = std::underlying_type_t<x11::Input::DeviceUse>;
+  return static_cast<x11::Input::DeviceUse>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::InputClass operator|(x11::Input::InputClass l,
+                                                  x11::Input::InputClass r) {
+  using T = std::underlying_type_t<x11::Input::InputClass>;
+  return static_cast<x11::Input::InputClass>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::InputClass operator&(x11::Input::InputClass l,
+                                                  x11::Input::InputClass r) {
+  using T = std::underlying_type_t<x11::Input::InputClass>;
+  return static_cast<x11::Input::InputClass>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ValuatorMode operator|(
+    x11::Input::ValuatorMode l,
+    x11::Input::ValuatorMode r) {
+  using T = std::underlying_type_t<x11::Input::ValuatorMode>;
+  return static_cast<x11::Input::ValuatorMode>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ValuatorMode operator&(
+    x11::Input::ValuatorMode l,
+    x11::Input::ValuatorMode r) {
+  using T = std::underlying_type_t<x11::Input::ValuatorMode>;
+  return static_cast<x11::Input::ValuatorMode>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::PropagateMode operator|(
+    x11::Input::PropagateMode l,
+    x11::Input::PropagateMode r) {
+  using T = std::underlying_type_t<x11::Input::PropagateMode>;
+  return static_cast<x11::Input::PropagateMode>(static_cast<T>(l) |
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::PropagateMode operator&(
+    x11::Input::PropagateMode l,
+    x11::Input::PropagateMode r) {
+  using T = std::underlying_type_t<x11::Input::PropagateMode>;
+  return static_cast<x11::Input::PropagateMode>(static_cast<T>(l) &
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ModifierDevice operator|(
+    x11::Input::ModifierDevice l,
+    x11::Input::ModifierDevice r) {
+  using T = std::underlying_type_t<x11::Input::ModifierDevice>;
+  return static_cast<x11::Input::ModifierDevice>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ModifierDevice operator&(
+    x11::Input::ModifierDevice l,
+    x11::Input::ModifierDevice r) {
+  using T = std::underlying_type_t<x11::Input::ModifierDevice>;
+  return static_cast<x11::Input::ModifierDevice>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceInputMode operator|(
+    x11::Input::DeviceInputMode l,
+    x11::Input::DeviceInputMode r) {
+  using T = std::underlying_type_t<x11::Input::DeviceInputMode>;
+  return static_cast<x11::Input::DeviceInputMode>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceInputMode operator&(
+    x11::Input::DeviceInputMode l,
+    x11::Input::DeviceInputMode r) {
+  using T = std::underlying_type_t<x11::Input::DeviceInputMode>;
+  return static_cast<x11::Input::DeviceInputMode>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Input::FeedbackClass operator|(
+    x11::Input::FeedbackClass l,
+    x11::Input::FeedbackClass r) {
+  using T = std::underlying_type_t<x11::Input::FeedbackClass>;
+  return static_cast<x11::Input::FeedbackClass>(static_cast<T>(l) |
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::FeedbackClass operator&(
+    x11::Input::FeedbackClass l,
+    x11::Input::FeedbackClass r) {
+  using T = std::underlying_type_t<x11::Input::FeedbackClass>;
+  return static_cast<x11::Input::FeedbackClass>(static_cast<T>(l) &
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ChangeFeedbackControlMask operator|(
+    x11::Input::ChangeFeedbackControlMask l,
+    x11::Input::ChangeFeedbackControlMask r) {
+  using T = std::underlying_type_t<x11::Input::ChangeFeedbackControlMask>;
+  return static_cast<x11::Input::ChangeFeedbackControlMask>(static_cast<T>(l) |
+                                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ChangeFeedbackControlMask operator&(
+    x11::Input::ChangeFeedbackControlMask l,
+    x11::Input::ChangeFeedbackControlMask r) {
+  using T = std::underlying_type_t<x11::Input::ChangeFeedbackControlMask>;
+  return static_cast<x11::Input::ChangeFeedbackControlMask>(static_cast<T>(l) &
+                                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ValuatorStateModeMask operator|(
+    x11::Input::ValuatorStateModeMask l,
+    x11::Input::ValuatorStateModeMask r) {
+  using T = std::underlying_type_t<x11::Input::ValuatorStateModeMask>;
+  return static_cast<x11::Input::ValuatorStateModeMask>(static_cast<T>(l) |
+                                                        static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ValuatorStateModeMask operator&(
+    x11::Input::ValuatorStateModeMask l,
+    x11::Input::ValuatorStateModeMask r) {
+  using T = std::underlying_type_t<x11::Input::ValuatorStateModeMask>;
+  return static_cast<x11::Input::ValuatorStateModeMask>(static_cast<T>(l) &
+                                                        static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceControl operator|(
+    x11::Input::DeviceControl l,
+    x11::Input::DeviceControl r) {
+  using T = std::underlying_type_t<x11::Input::DeviceControl>;
+  return static_cast<x11::Input::DeviceControl>(static_cast<T>(l) |
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceControl operator&(
+    x11::Input::DeviceControl l,
+    x11::Input::DeviceControl r) {
+  using T = std::underlying_type_t<x11::Input::DeviceControl>;
+  return static_cast<x11::Input::DeviceControl>(static_cast<T>(l) &
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::PropertyFormat operator|(
+    x11::Input::PropertyFormat l,
+    x11::Input::PropertyFormat r) {
+  using T = std::underlying_type_t<x11::Input::PropertyFormat>;
+  return static_cast<x11::Input::PropertyFormat>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Input::PropertyFormat operator&(
+    x11::Input::PropertyFormat l,
+    x11::Input::PropertyFormat r) {
+  using T = std::underlying_type_t<x11::Input::PropertyFormat>;
+  return static_cast<x11::Input::PropertyFormat>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceId operator|(x11::Input::DeviceId l,
+                                                x11::Input::DeviceId r) {
+  using T = std::underlying_type_t<x11::Input::DeviceId>;
+  return static_cast<x11::Input::DeviceId>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceId operator&(x11::Input::DeviceId l,
+                                                x11::Input::DeviceId r) {
+  using T = std::underlying_type_t<x11::Input::DeviceId>;
+  return static_cast<x11::Input::DeviceId>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Input::HierarchyChangeType operator|(
+    x11::Input::HierarchyChangeType l,
+    x11::Input::HierarchyChangeType r) {
+  using T = std::underlying_type_t<x11::Input::HierarchyChangeType>;
+  return static_cast<x11::Input::HierarchyChangeType>(static_cast<T>(l) |
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::Input::HierarchyChangeType operator&(
+    x11::Input::HierarchyChangeType l,
+    x11::Input::HierarchyChangeType r) {
+  using T = std::underlying_type_t<x11::Input::HierarchyChangeType>;
+  return static_cast<x11::Input::HierarchyChangeType>(static_cast<T>(l) &
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ChangeMode operator|(x11::Input::ChangeMode l,
+                                                  x11::Input::ChangeMode r) {
+  using T = std::underlying_type_t<x11::Input::ChangeMode>;
+  return static_cast<x11::Input::ChangeMode>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ChangeMode operator&(x11::Input::ChangeMode l,
+                                                  x11::Input::ChangeMode r) {
+  using T = std::underlying_type_t<x11::Input::ChangeMode>;
+  return static_cast<x11::Input::ChangeMode>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::XIEventMask operator|(x11::Input::XIEventMask l,
+                                                   x11::Input::XIEventMask r) {
+  using T = std::underlying_type_t<x11::Input::XIEventMask>;
+  return static_cast<x11::Input::XIEventMask>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Input::XIEventMask operator&(x11::Input::XIEventMask l,
+                                                   x11::Input::XIEventMask r) {
+  using T = std::underlying_type_t<x11::Input::XIEventMask>;
+  return static_cast<x11::Input::XIEventMask>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceClassType operator|(
+    x11::Input::DeviceClassType l,
+    x11::Input::DeviceClassType r) {
+  using T = std::underlying_type_t<x11::Input::DeviceClassType>;
+  return static_cast<x11::Input::DeviceClassType>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceClassType operator&(
+    x11::Input::DeviceClassType l,
+    x11::Input::DeviceClassType r) {
+  using T = std::underlying_type_t<x11::Input::DeviceClassType>;
+  return static_cast<x11::Input::DeviceClassType>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceType operator|(x11::Input::DeviceType l,
+                                                  x11::Input::DeviceType r) {
+  using T = std::underlying_type_t<x11::Input::DeviceType>;
+  return static_cast<x11::Input::DeviceType>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceType operator&(x11::Input::DeviceType l,
+                                                  x11::Input::DeviceType r) {
+  using T = std::underlying_type_t<x11::Input::DeviceType>;
+  return static_cast<x11::Input::DeviceType>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ScrollFlags operator|(x11::Input::ScrollFlags l,
+                                                   x11::Input::ScrollFlags r) {
+  using T = std::underlying_type_t<x11::Input::ScrollFlags>;
+  return static_cast<x11::Input::ScrollFlags>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ScrollFlags operator&(x11::Input::ScrollFlags l,
+                                                   x11::Input::ScrollFlags r) {
+  using T = std::underlying_type_t<x11::Input::ScrollFlags>;
+  return static_cast<x11::Input::ScrollFlags>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ScrollType operator|(x11::Input::ScrollType l,
+                                                  x11::Input::ScrollType r) {
+  using T = std::underlying_type_t<x11::Input::ScrollType>;
+  return static_cast<x11::Input::ScrollType>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ScrollType operator&(x11::Input::ScrollType l,
+                                                  x11::Input::ScrollType r) {
+  using T = std::underlying_type_t<x11::Input::ScrollType>;
+  return static_cast<x11::Input::ScrollType>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::TouchMode operator|(x11::Input::TouchMode l,
+                                                 x11::Input::TouchMode r) {
+  using T = std::underlying_type_t<x11::Input::TouchMode>;
+  return static_cast<x11::Input::TouchMode>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::TouchMode operator&(x11::Input::TouchMode l,
+                                                 x11::Input::TouchMode r) {
+  using T = std::underlying_type_t<x11::Input::TouchMode>;
+  return static_cast<x11::Input::TouchMode>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::GrabOwner operator|(x11::Input::GrabOwner l,
+                                                 x11::Input::GrabOwner r) {
+  using T = std::underlying_type_t<x11::Input::GrabOwner>;
+  return static_cast<x11::Input::GrabOwner>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::GrabOwner operator&(x11::Input::GrabOwner l,
+                                                 x11::Input::GrabOwner r) {
+  using T = std::underlying_type_t<x11::Input::GrabOwner>;
+  return static_cast<x11::Input::GrabOwner>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::EventMode operator|(x11::Input::EventMode l,
+                                                 x11::Input::EventMode r) {
+  using T = std::underlying_type_t<x11::Input::EventMode>;
+  return static_cast<x11::Input::EventMode>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::EventMode operator&(x11::Input::EventMode l,
+                                                 x11::Input::EventMode r) {
+  using T = std::underlying_type_t<x11::Input::EventMode>;
+  return static_cast<x11::Input::EventMode>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Input::GrabMode22 operator|(x11::Input::GrabMode22 l,
+                                                  x11::Input::GrabMode22 r) {
+  using T = std::underlying_type_t<x11::Input::GrabMode22>;
+  return static_cast<x11::Input::GrabMode22>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::GrabMode22 operator&(x11::Input::GrabMode22 l,
+                                                  x11::Input::GrabMode22 r) {
+  using T = std::underlying_type_t<x11::Input::GrabMode22>;
+  return static_cast<x11::Input::GrabMode22>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::GrabType operator|(x11::Input::GrabType l,
+                                                x11::Input::GrabType r) {
+  using T = std::underlying_type_t<x11::Input::GrabType>;
+  return static_cast<x11::Input::GrabType>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Input::GrabType operator&(x11::Input::GrabType l,
+                                                x11::Input::GrabType r) {
+  using T = std::underlying_type_t<x11::Input::GrabType>;
+  return static_cast<x11::Input::GrabType>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ModifierMask operator|(
+    x11::Input::ModifierMask l,
+    x11::Input::ModifierMask r) {
+  using T = std::underlying_type_t<x11::Input::ModifierMask>;
+  return static_cast<x11::Input::ModifierMask>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ModifierMask operator&(
+    x11::Input::ModifierMask l,
+    x11::Input::ModifierMask r) {
+  using T = std::underlying_type_t<x11::Input::ModifierMask>;
+  return static_cast<x11::Input::ModifierMask>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::MoreEventsMask operator|(
+    x11::Input::MoreEventsMask l,
+    x11::Input::MoreEventsMask r) {
+  using T = std::underlying_type_t<x11::Input::MoreEventsMask>;
+  return static_cast<x11::Input::MoreEventsMask>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Input::MoreEventsMask operator&(
+    x11::Input::MoreEventsMask l,
+    x11::Input::MoreEventsMask r) {
+  using T = std::underlying_type_t<x11::Input::MoreEventsMask>;
+  return static_cast<x11::Input::MoreEventsMask>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ClassesReportedMask operator|(
+    x11::Input::ClassesReportedMask l,
+    x11::Input::ClassesReportedMask r) {
+  using T = std::underlying_type_t<x11::Input::ClassesReportedMask>;
+  return static_cast<x11::Input::ClassesReportedMask>(static_cast<T>(l) |
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ClassesReportedMask operator&(
+    x11::Input::ClassesReportedMask l,
+    x11::Input::ClassesReportedMask r) {
+  using T = std::underlying_type_t<x11::Input::ClassesReportedMask>;
+  return static_cast<x11::Input::ClassesReportedMask>(static_cast<T>(l) &
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ChangeDevice operator|(
+    x11::Input::ChangeDevice l,
+    x11::Input::ChangeDevice r) {
+  using T = std::underlying_type_t<x11::Input::ChangeDevice>;
+  return static_cast<x11::Input::ChangeDevice>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ChangeDevice operator&(
+    x11::Input::ChangeDevice l,
+    x11::Input::ChangeDevice r) {
+  using T = std::underlying_type_t<x11::Input::ChangeDevice>;
+  return static_cast<x11::Input::ChangeDevice>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceChange operator|(
+    x11::Input::DeviceChange l,
+    x11::Input::DeviceChange r) {
+  using T = std::underlying_type_t<x11::Input::DeviceChange>;
+  return static_cast<x11::Input::DeviceChange>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::DeviceChange operator&(
+    x11::Input::DeviceChange l,
+    x11::Input::DeviceChange r) {
+  using T = std::underlying_type_t<x11::Input::DeviceChange>;
+  return static_cast<x11::Input::DeviceChange>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ChangeReason operator|(
+    x11::Input::ChangeReason l,
+    x11::Input::ChangeReason r) {
+  using T = std::underlying_type_t<x11::Input::ChangeReason>;
+  return static_cast<x11::Input::ChangeReason>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::ChangeReason operator&(
+    x11::Input::ChangeReason l,
+    x11::Input::ChangeReason r) {
+  using T = std::underlying_type_t<x11::Input::ChangeReason>;
+  return static_cast<x11::Input::ChangeReason>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::KeyEventFlags operator|(
+    x11::Input::KeyEventFlags l,
+    x11::Input::KeyEventFlags r) {
+  using T = std::underlying_type_t<x11::Input::KeyEventFlags>;
+  return static_cast<x11::Input::KeyEventFlags>(static_cast<T>(l) |
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::KeyEventFlags operator&(
+    x11::Input::KeyEventFlags l,
+    x11::Input::KeyEventFlags r) {
+  using T = std::underlying_type_t<x11::Input::KeyEventFlags>;
+  return static_cast<x11::Input::KeyEventFlags>(static_cast<T>(l) &
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::PointerEventFlags operator|(
+    x11::Input::PointerEventFlags l,
+    x11::Input::PointerEventFlags r) {
+  using T = std::underlying_type_t<x11::Input::PointerEventFlags>;
+  return static_cast<x11::Input::PointerEventFlags>(static_cast<T>(l) |
+                                                    static_cast<T>(r));
+}
+
+inline constexpr x11::Input::PointerEventFlags operator&(
+    x11::Input::PointerEventFlags l,
+    x11::Input::PointerEventFlags r) {
+  using T = std::underlying_type_t<x11::Input::PointerEventFlags>;
+  return static_cast<x11::Input::PointerEventFlags>(static_cast<T>(l) &
+                                                    static_cast<T>(r));
+}
+
+inline constexpr x11::Input::NotifyMode operator|(x11::Input::NotifyMode l,
+                                                  x11::Input::NotifyMode r) {
+  using T = std::underlying_type_t<x11::Input::NotifyMode>;
+  return static_cast<x11::Input::NotifyMode>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::NotifyMode operator&(x11::Input::NotifyMode l,
+                                                  x11::Input::NotifyMode r) {
+  using T = std::underlying_type_t<x11::Input::NotifyMode>;
+  return static_cast<x11::Input::NotifyMode>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Input::NotifyDetail operator|(
+    x11::Input::NotifyDetail l,
+    x11::Input::NotifyDetail r) {
+  using T = std::underlying_type_t<x11::Input::NotifyDetail>;
+  return static_cast<x11::Input::NotifyDetail>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::NotifyDetail operator&(
+    x11::Input::NotifyDetail l,
+    x11::Input::NotifyDetail r) {
+  using T = std::underlying_type_t<x11::Input::NotifyDetail>;
+  return static_cast<x11::Input::NotifyDetail>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::HierarchyMask operator|(
+    x11::Input::HierarchyMask l,
+    x11::Input::HierarchyMask r) {
+  using T = std::underlying_type_t<x11::Input::HierarchyMask>;
+  return static_cast<x11::Input::HierarchyMask>(static_cast<T>(l) |
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::HierarchyMask operator&(
+    x11::Input::HierarchyMask l,
+    x11::Input::HierarchyMask r) {
+  using T = std::underlying_type_t<x11::Input::HierarchyMask>;
+  return static_cast<x11::Input::HierarchyMask>(static_cast<T>(l) &
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Input::PropertyFlag operator|(
+    x11::Input::PropertyFlag l,
+    x11::Input::PropertyFlag r) {
+  using T = std::underlying_type_t<x11::Input::PropertyFlag>;
+  return static_cast<x11::Input::PropertyFlag>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::PropertyFlag operator&(
+    x11::Input::PropertyFlag l,
+    x11::Input::PropertyFlag r) {
+  using T = std::underlying_type_t<x11::Input::PropertyFlag>;
+  return static_cast<x11::Input::PropertyFlag>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::TouchEventFlags operator|(
+    x11::Input::TouchEventFlags l,
+    x11::Input::TouchEventFlags r) {
+  using T = std::underlying_type_t<x11::Input::TouchEventFlags>;
+  return static_cast<x11::Input::TouchEventFlags>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Input::TouchEventFlags operator&(
+    x11::Input::TouchEventFlags l,
+    x11::Input::TouchEventFlags r) {
+  using T = std::underlying_type_t<x11::Input::TouchEventFlags>;
+  return static_cast<x11::Input::TouchEventFlags>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Input::TouchOwnershipFlags operator|(
+    x11::Input::TouchOwnershipFlags l,
+    x11::Input::TouchOwnershipFlags r) {
+  using T = std::underlying_type_t<x11::Input::TouchOwnershipFlags>;
+  return static_cast<x11::Input::TouchOwnershipFlags>(static_cast<T>(l) |
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::Input::TouchOwnershipFlags operator&(
+    x11::Input::TouchOwnershipFlags l,
+    x11::Input::TouchOwnershipFlags r) {
+  using T = std::underlying_type_t<x11::Input::TouchOwnershipFlags>;
+  return static_cast<x11::Input::TouchOwnershipFlags>(static_cast<T>(l) &
+                                                      static_cast<T>(r));
+}
+
+inline constexpr x11::Input::BarrierFlags operator|(
+    x11::Input::BarrierFlags l,
+    x11::Input::BarrierFlags r) {
+  using T = std::underlying_type_t<x11::Input::BarrierFlags>;
+  return static_cast<x11::Input::BarrierFlags>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Input::BarrierFlags operator&(
+    x11::Input::BarrierFlags l,
+    x11::Input::BarrierFlags r) {
+  using T = std::underlying_type_t<x11::Input::BarrierFlags>;
+  return static_cast<x11::Input::BarrierFlags>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XINPUT_H_
diff --git a/ui/gfx/x/generated_protos/xkb.cc b/ui/gfx/x/generated_protos/xkb.cc
new file mode 100644
index 0000000..e623c97
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xkb.cc
@@ -0,0 +1,6879 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xkb.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Xkb::Xkb(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string Xkb::KeyboardError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Xkb::KeyboardError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".value = " << static_cast<uint64_t>(value) << ", ";
+  ss_ << ".minorOpcode = " << static_cast<uint64_t>(minorOpcode) << ", ";
+  ss_ << ".majorOpcode = " << static_cast<uint64_t>(majorOpcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Xkb::KeyboardError>(Xkb::KeyboardError* error_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& value = (*error_).value;
+  auto& minorOpcode = (*error_).minorOpcode;
+  auto& majorOpcode = (*error_).majorOpcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // value
+  Read(&value, &buf);
+
+  // minorOpcode
+  Read(&minorOpcode, &buf);
+
+  // majorOpcode
+  Read(&majorOpcode, &buf);
+
+  // pad0
+  Pad(&buf, 21);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::NewKeyboardNotifyEvent>(Xkb::NewKeyboardNotifyEvent* event_,
+                                            ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& oldDeviceID = (*event_).oldDeviceID;
+  auto& minKeyCode = (*event_).minKeyCode;
+  auto& maxKeyCode = (*event_).maxKeyCode;
+  auto& oldMinKeyCode = (*event_).oldMinKeyCode;
+  auto& oldMaxKeyCode = (*event_).oldMaxKeyCode;
+  auto& requestMajor = (*event_).requestMajor;
+  auto& requestMinor = (*event_).requestMinor;
+  auto& changed = (*event_).changed;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // oldDeviceID
+  Read(&oldDeviceID, &buf);
+
+  // minKeyCode
+  Read(&minKeyCode, &buf);
+
+  // maxKeyCode
+  Read(&maxKeyCode, &buf);
+
+  // oldMinKeyCode
+  Read(&oldMinKeyCode, &buf);
+
+  // oldMaxKeyCode
+  Read(&oldMaxKeyCode, &buf);
+
+  // requestMajor
+  Read(&requestMajor, &buf);
+
+  // requestMinor
+  Read(&requestMinor, &buf);
+
+  // changed
+  uint16_t tmp0;
+  Read(&tmp0, &buf);
+  changed = static_cast<Xkb::NKNDetail>(tmp0);
+
+  // pad0
+  Pad(&buf, 14);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::MapNotifyEvent>(Xkb::MapNotifyEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& ptrBtnActions = (*event_).ptrBtnActions;
+  auto& changed = (*event_).changed;
+  auto& minKeyCode = (*event_).minKeyCode;
+  auto& maxKeyCode = (*event_).maxKeyCode;
+  auto& firstType = (*event_).firstType;
+  auto& nTypes = (*event_).nTypes;
+  auto& firstKeySym = (*event_).firstKeySym;
+  auto& nKeySyms = (*event_).nKeySyms;
+  auto& firstKeyAct = (*event_).firstKeyAct;
+  auto& nKeyActs = (*event_).nKeyActs;
+  auto& firstKeyBehavior = (*event_).firstKeyBehavior;
+  auto& nKeyBehavior = (*event_).nKeyBehavior;
+  auto& firstKeyExplicit = (*event_).firstKeyExplicit;
+  auto& nKeyExplicit = (*event_).nKeyExplicit;
+  auto& firstModMapKey = (*event_).firstModMapKey;
+  auto& nModMapKeys = (*event_).nModMapKeys;
+  auto& firstVModMapKey = (*event_).firstVModMapKey;
+  auto& nVModMapKeys = (*event_).nVModMapKeys;
+  auto& virtualMods = (*event_).virtualMods;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // ptrBtnActions
+  Read(&ptrBtnActions, &buf);
+
+  // changed
+  uint16_t tmp1;
+  Read(&tmp1, &buf);
+  changed = static_cast<Xkb::MapPart>(tmp1);
+
+  // minKeyCode
+  Read(&minKeyCode, &buf);
+
+  // maxKeyCode
+  Read(&maxKeyCode, &buf);
+
+  // firstType
+  Read(&firstType, &buf);
+
+  // nTypes
+  Read(&nTypes, &buf);
+
+  // firstKeySym
+  Read(&firstKeySym, &buf);
+
+  // nKeySyms
+  Read(&nKeySyms, &buf);
+
+  // firstKeyAct
+  Read(&firstKeyAct, &buf);
+
+  // nKeyActs
+  Read(&nKeyActs, &buf);
+
+  // firstKeyBehavior
+  Read(&firstKeyBehavior, &buf);
+
+  // nKeyBehavior
+  Read(&nKeyBehavior, &buf);
+
+  // firstKeyExplicit
+  Read(&firstKeyExplicit, &buf);
+
+  // nKeyExplicit
+  Read(&nKeyExplicit, &buf);
+
+  // firstModMapKey
+  Read(&firstModMapKey, &buf);
+
+  // nModMapKeys
+  Read(&nModMapKeys, &buf);
+
+  // firstVModMapKey
+  Read(&firstVModMapKey, &buf);
+
+  // nVModMapKeys
+  Read(&nVModMapKeys, &buf);
+
+  // virtualMods
+  uint16_t tmp2;
+  Read(&tmp2, &buf);
+  virtualMods = static_cast<Xkb::VMod>(tmp2);
+
+  // pad0
+  Pad(&buf, 2);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::StateNotifyEvent>(Xkb::StateNotifyEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& mods = (*event_).mods;
+  auto& baseMods = (*event_).baseMods;
+  auto& latchedMods = (*event_).latchedMods;
+  auto& lockedMods = (*event_).lockedMods;
+  auto& group = (*event_).group;
+  auto& baseGroup = (*event_).baseGroup;
+  auto& latchedGroup = (*event_).latchedGroup;
+  auto& lockedGroup = (*event_).lockedGroup;
+  auto& compatState = (*event_).compatState;
+  auto& grabMods = (*event_).grabMods;
+  auto& compatGrabMods = (*event_).compatGrabMods;
+  auto& lookupMods = (*event_).lookupMods;
+  auto& compatLoockupMods = (*event_).compatLoockupMods;
+  auto& ptrBtnState = (*event_).ptrBtnState;
+  auto& changed = (*event_).changed;
+  auto& keycode = (*event_).keycode;
+  auto& eventType = (*event_).eventType;
+  auto& requestMajor = (*event_).requestMajor;
+  auto& requestMinor = (*event_).requestMinor;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // mods
+  uint8_t tmp3;
+  Read(&tmp3, &buf);
+  mods = static_cast<ModMask>(tmp3);
+
+  // baseMods
+  uint8_t tmp4;
+  Read(&tmp4, &buf);
+  baseMods = static_cast<ModMask>(tmp4);
+
+  // latchedMods
+  uint8_t tmp5;
+  Read(&tmp5, &buf);
+  latchedMods = static_cast<ModMask>(tmp5);
+
+  // lockedMods
+  uint8_t tmp6;
+  Read(&tmp6, &buf);
+  lockedMods = static_cast<ModMask>(tmp6);
+
+  // group
+  uint8_t tmp7;
+  Read(&tmp7, &buf);
+  group = static_cast<Xkb::Group>(tmp7);
+
+  // baseGroup
+  Read(&baseGroup, &buf);
+
+  // latchedGroup
+  Read(&latchedGroup, &buf);
+
+  // lockedGroup
+  uint8_t tmp8;
+  Read(&tmp8, &buf);
+  lockedGroup = static_cast<Xkb::Group>(tmp8);
+
+  // compatState
+  uint8_t tmp9;
+  Read(&tmp9, &buf);
+  compatState = static_cast<ModMask>(tmp9);
+
+  // grabMods
+  uint8_t tmp10;
+  Read(&tmp10, &buf);
+  grabMods = static_cast<ModMask>(tmp10);
+
+  // compatGrabMods
+  uint8_t tmp11;
+  Read(&tmp11, &buf);
+  compatGrabMods = static_cast<ModMask>(tmp11);
+
+  // lookupMods
+  uint8_t tmp12;
+  Read(&tmp12, &buf);
+  lookupMods = static_cast<ModMask>(tmp12);
+
+  // compatLoockupMods
+  uint8_t tmp13;
+  Read(&tmp13, &buf);
+  compatLoockupMods = static_cast<ModMask>(tmp13);
+
+  // ptrBtnState
+  uint16_t tmp14;
+  Read(&tmp14, &buf);
+  ptrBtnState = static_cast<KeyButMask>(tmp14);
+
+  // changed
+  uint16_t tmp15;
+  Read(&tmp15, &buf);
+  changed = static_cast<Xkb::StatePart>(tmp15);
+
+  // keycode
+  Read(&keycode, &buf);
+
+  // eventType
+  Read(&eventType, &buf);
+
+  // requestMajor
+  Read(&requestMajor, &buf);
+
+  // requestMinor
+  Read(&requestMinor, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::ControlsNotifyEvent>(Xkb::ControlsNotifyEvent* event_,
+                                         ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& numGroups = (*event_).numGroups;
+  auto& changedControls = (*event_).changedControls;
+  auto& enabledControls = (*event_).enabledControls;
+  auto& enabledControlChanges = (*event_).enabledControlChanges;
+  auto& keycode = (*event_).keycode;
+  auto& eventType = (*event_).eventType;
+  auto& requestMajor = (*event_).requestMajor;
+  auto& requestMinor = (*event_).requestMinor;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // numGroups
+  Read(&numGroups, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // changedControls
+  uint32_t tmp16;
+  Read(&tmp16, &buf);
+  changedControls = static_cast<Xkb::Control>(tmp16);
+
+  // enabledControls
+  uint32_t tmp17;
+  Read(&tmp17, &buf);
+  enabledControls = static_cast<Xkb::BoolCtrl>(tmp17);
+
+  // enabledControlChanges
+  uint32_t tmp18;
+  Read(&tmp18, &buf);
+  enabledControlChanges = static_cast<Xkb::BoolCtrl>(tmp18);
+
+  // keycode
+  Read(&keycode, &buf);
+
+  // eventType
+  Read(&eventType, &buf);
+
+  // requestMajor
+  Read(&requestMajor, &buf);
+
+  // requestMinor
+  Read(&requestMinor, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::IndicatorStateNotifyEvent>(
+    Xkb::IndicatorStateNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& state = (*event_).state;
+  auto& stateChanged = (*event_).stateChanged;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // state
+  Read(&state, &buf);
+
+  // stateChanged
+  Read(&stateChanged, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::IndicatorMapNotifyEvent>(
+    Xkb::IndicatorMapNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& state = (*event_).state;
+  auto& mapChanged = (*event_).mapChanged;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // state
+  Read(&state, &buf);
+
+  // mapChanged
+  Read(&mapChanged, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::NamesNotifyEvent>(Xkb::NamesNotifyEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& changed = (*event_).changed;
+  auto& firstType = (*event_).firstType;
+  auto& nTypes = (*event_).nTypes;
+  auto& firstLevelName = (*event_).firstLevelName;
+  auto& nLevelNames = (*event_).nLevelNames;
+  auto& nRadioGroups = (*event_).nRadioGroups;
+  auto& nKeyAliases = (*event_).nKeyAliases;
+  auto& changedGroupNames = (*event_).changedGroupNames;
+  auto& changedVirtualMods = (*event_).changedVirtualMods;
+  auto& firstKey = (*event_).firstKey;
+  auto& nKeys = (*event_).nKeys;
+  auto& changedIndicators = (*event_).changedIndicators;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // changed
+  uint16_t tmp19;
+  Read(&tmp19, &buf);
+  changed = static_cast<Xkb::NameDetail>(tmp19);
+
+  // firstType
+  Read(&firstType, &buf);
+
+  // nTypes
+  Read(&nTypes, &buf);
+
+  // firstLevelName
+  Read(&firstLevelName, &buf);
+
+  // nLevelNames
+  Read(&nLevelNames, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  // nRadioGroups
+  Read(&nRadioGroups, &buf);
+
+  // nKeyAliases
+  Read(&nKeyAliases, &buf);
+
+  // changedGroupNames
+  uint8_t tmp20;
+  Read(&tmp20, &buf);
+  changedGroupNames = static_cast<Xkb::SetOfGroup>(tmp20);
+
+  // changedVirtualMods
+  uint16_t tmp21;
+  Read(&tmp21, &buf);
+  changedVirtualMods = static_cast<Xkb::VMod>(tmp21);
+
+  // firstKey
+  Read(&firstKey, &buf);
+
+  // nKeys
+  Read(&nKeys, &buf);
+
+  // changedIndicators
+  Read(&changedIndicators, &buf);
+
+  // pad2
+  Pad(&buf, 4);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::CompatMapNotifyEvent>(Xkb::CompatMapNotifyEvent* event_,
+                                          ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& changedGroups = (*event_).changedGroups;
+  auto& firstSI = (*event_).firstSI;
+  auto& nSI = (*event_).nSI;
+  auto& nTotalSI = (*event_).nTotalSI;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // changedGroups
+  uint8_t tmp22;
+  Read(&tmp22, &buf);
+  changedGroups = static_cast<Xkb::SetOfGroup>(tmp22);
+
+  // firstSI
+  Read(&firstSI, &buf);
+
+  // nSI
+  Read(&nSI, &buf);
+
+  // nTotalSI
+  Read(&nTotalSI, &buf);
+
+  // pad0
+  Pad(&buf, 16);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::BellNotifyEvent>(Xkb::BellNotifyEvent* event_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& bellClass = (*event_).bellClass;
+  auto& bellID = (*event_).bellID;
+  auto& percent = (*event_).percent;
+  auto& pitch = (*event_).pitch;
+  auto& duration = (*event_).duration;
+  auto& name = (*event_).name;
+  auto& window = (*event_).window;
+  auto& eventOnly = (*event_).eventOnly;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // bellClass
+  uint8_t tmp23;
+  Read(&tmp23, &buf);
+  bellClass = static_cast<Xkb::BellClassResult>(tmp23);
+
+  // bellID
+  Read(&bellID, &buf);
+
+  // percent
+  Read(&percent, &buf);
+
+  // pitch
+  Read(&pitch, &buf);
+
+  // duration
+  Read(&duration, &buf);
+
+  // name
+  Read(&name, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // eventOnly
+  Read(&eventOnly, &buf);
+
+  // pad0
+  Pad(&buf, 7);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::ActionMessageEvent>(Xkb::ActionMessageEvent* event_,
+                                        ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& keycode = (*event_).keycode;
+  auto& press = (*event_).press;
+  auto& keyEventFollows = (*event_).keyEventFollows;
+  auto& mods = (*event_).mods;
+  auto& group = (*event_).group;
+  auto& message = (*event_).message;
+  size_t message_len = message.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // keycode
+  Read(&keycode, &buf);
+
+  // press
+  Read(&press, &buf);
+
+  // keyEventFollows
+  Read(&keyEventFollows, &buf);
+
+  // mods
+  uint8_t tmp24;
+  Read(&tmp24, &buf);
+  mods = static_cast<ModMask>(tmp24);
+
+  // group
+  uint8_t tmp25;
+  Read(&tmp25, &buf);
+  group = static_cast<Xkb::Group>(tmp25);
+
+  // message
+  for (auto& message_elem : message) {
+    // message_elem
+    Read(&message_elem, &buf);
+  }
+
+  // pad0
+  Pad(&buf, 10);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::AccessXNotifyEvent>(Xkb::AccessXNotifyEvent* event_,
+                                        ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& keycode = (*event_).keycode;
+  auto& detailt = (*event_).detailt;
+  auto& slowKeysDelay = (*event_).slowKeysDelay;
+  auto& debounceDelay = (*event_).debounceDelay;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // keycode
+  Read(&keycode, &buf);
+
+  // detailt
+  uint16_t tmp26;
+  Read(&tmp26, &buf);
+  detailt = static_cast<Xkb::AXNDetail>(tmp26);
+
+  // slowKeysDelay
+  Read(&slowKeysDelay, &buf);
+
+  // debounceDelay
+  Read(&debounceDelay, &buf);
+
+  // pad0
+  Pad(&buf, 16);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xkb::ExtensionDeviceNotifyEvent>(
+    Xkb::ExtensionDeviceNotifyEvent* event_,
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& xkbType = (*event_).xkbType;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& deviceID = (*event_).deviceID;
+  auto& reason = (*event_).reason;
+  auto& ledClass = (*event_).ledClass;
+  auto& ledID = (*event_).ledID;
+  auto& ledsDefined = (*event_).ledsDefined;
+  auto& ledState = (*event_).ledState;
+  auto& firstButton = (*event_).firstButton;
+  auto& nButtons = (*event_).nButtons;
+  auto& supported = (*event_).supported;
+  auto& unsupported = (*event_).unsupported;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // xkbType
+  Read(&xkbType, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // reason
+  uint16_t tmp27;
+  Read(&tmp27, &buf);
+  reason = static_cast<Xkb::XIFeature>(tmp27);
+
+  // ledClass
+  uint16_t tmp28;
+  Read(&tmp28, &buf);
+  ledClass = static_cast<Xkb::LedClassResult>(tmp28);
+
+  // ledID
+  Read(&ledID, &buf);
+
+  // ledsDefined
+  Read(&ledsDefined, &buf);
+
+  // ledState
+  Read(&ledState, &buf);
+
+  // firstButton
+  Read(&firstButton, &buf);
+
+  // nButtons
+  Read(&nButtons, &buf);
+
+  // supported
+  uint16_t tmp29;
+  Read(&tmp29, &buf);
+  supported = static_cast<Xkb::XIFeature>(tmp29);
+
+  // unsupported
+  uint16_t tmp30;
+  Read(&tmp30, &buf);
+  unsupported = static_cast<Xkb::XIFeature>(tmp30);
+
+  // pad1
+  Pad(&buf, 2);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<Xkb::UseExtensionReply> Xkb::UseExtension(
+    const Xkb::UseExtensionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& wantedMajor = request.wantedMajor;
+  auto& wantedMinor = request.wantedMinor;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // wantedMajor
+  buf.Write(&wantedMajor);
+
+  // wantedMinor
+  buf.Write(&wantedMinor);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::UseExtensionReply>(
+      &buf, "Xkb::UseExtension", false);
+}
+
+Future<Xkb::UseExtensionReply> Xkb::UseExtension(const uint16_t& wantedMajor,
+                                                 const uint16_t& wantedMinor) {
+  return Xkb::UseExtension(Xkb::UseExtensionRequest{wantedMajor, wantedMinor});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::UseExtensionReply> detail::ReadReply<
+    Xkb::UseExtensionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::UseExtensionReply>();
+
+  auto& supported = (*reply).supported;
+  auto& sequence = (*reply).sequence;
+  auto& serverMajor = (*reply).serverMajor;
+  auto& serverMinor = (*reply).serverMinor;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // supported
+  Read(&supported, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // serverMajor
+  Read(&serverMajor, &buf);
+
+  // serverMinor
+  Read(&serverMinor, &buf);
+
+  // pad0
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::SelectEvents(const Xkb::SelectEventsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& affectWhich = request.affectWhich;
+  auto& clear = request.clear;
+  auto& selectAll = request.selectAll;
+  auto& affectMap = request.affectMap;
+  auto& map = request.map;
+  auto& details = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // affectWhich
+  uint16_t tmp31;
+  tmp31 = static_cast<uint16_t>(affectWhich);
+  buf.Write(&tmp31);
+
+  // clear
+  uint16_t tmp32;
+  tmp32 = static_cast<uint16_t>(clear);
+  buf.Write(&tmp32);
+
+  // selectAll
+  uint16_t tmp33;
+  tmp33 = static_cast<uint16_t>(selectAll);
+  buf.Write(&tmp33);
+
+  // affectMap
+  uint16_t tmp34;
+  tmp34 = static_cast<uint16_t>(affectMap);
+  buf.Write(&tmp34);
+
+  // map
+  uint16_t tmp35;
+  tmp35 = static_cast<uint16_t>(map);
+  buf.Write(&tmp35);
+
+  // details
+  auto details_expr =
+      BitAnd(affectWhich, BitAnd(BitNot(clear), BitNot(selectAll)));
+  if (CaseAnd(details_expr, EventType::NewKeyboardNotify)) {
+    auto& affectNewKeyboard = *details.affectNewKeyboard;
+    auto& newKeyboardDetails = *details.newKeyboardDetails;
+
+    // affectNewKeyboard
+    uint16_t tmp36;
+    tmp36 = static_cast<uint16_t>(affectNewKeyboard);
+    buf.Write(&tmp36);
+
+    // newKeyboardDetails
+    uint16_t tmp37;
+    tmp37 = static_cast<uint16_t>(newKeyboardDetails);
+    buf.Write(&tmp37);
+  }
+  if (CaseAnd(details_expr, EventType::StateNotify)) {
+    auto& affectState = *details.affectState;
+    auto& stateDetails = *details.stateDetails;
+
+    // affectState
+    uint16_t tmp38;
+    tmp38 = static_cast<uint16_t>(affectState);
+    buf.Write(&tmp38);
+
+    // stateDetails
+    uint16_t tmp39;
+    tmp39 = static_cast<uint16_t>(stateDetails);
+    buf.Write(&tmp39);
+  }
+  if (CaseAnd(details_expr, EventType::ControlsNotify)) {
+    auto& affectCtrls = *details.affectCtrls;
+    auto& ctrlDetails = *details.ctrlDetails;
+
+    // affectCtrls
+    uint32_t tmp40;
+    tmp40 = static_cast<uint32_t>(affectCtrls);
+    buf.Write(&tmp40);
+
+    // ctrlDetails
+    uint32_t tmp41;
+    tmp41 = static_cast<uint32_t>(ctrlDetails);
+    buf.Write(&tmp41);
+  }
+  if (CaseAnd(details_expr, EventType::IndicatorStateNotify)) {
+    auto& affectIndicatorState = *details.affectIndicatorState;
+    auto& indicatorStateDetails = *details.indicatorStateDetails;
+
+    // affectIndicatorState
+    buf.Write(&affectIndicatorState);
+
+    // indicatorStateDetails
+    buf.Write(&indicatorStateDetails);
+  }
+  if (CaseAnd(details_expr, EventType::IndicatorMapNotify)) {
+    auto& affectIndicatorMap = *details.affectIndicatorMap;
+    auto& indicatorMapDetails = *details.indicatorMapDetails;
+
+    // affectIndicatorMap
+    buf.Write(&affectIndicatorMap);
+
+    // indicatorMapDetails
+    buf.Write(&indicatorMapDetails);
+  }
+  if (CaseAnd(details_expr, EventType::NamesNotify)) {
+    auto& affectNames = *details.affectNames;
+    auto& namesDetails = *details.namesDetails;
+
+    // affectNames
+    uint16_t tmp42;
+    tmp42 = static_cast<uint16_t>(affectNames);
+    buf.Write(&tmp42);
+
+    // namesDetails
+    uint16_t tmp43;
+    tmp43 = static_cast<uint16_t>(namesDetails);
+    buf.Write(&tmp43);
+  }
+  if (CaseAnd(details_expr, EventType::CompatMapNotify)) {
+    auto& affectCompat = *details.affectCompat;
+    auto& compatDetails = *details.compatDetails;
+
+    // affectCompat
+    uint8_t tmp44;
+    tmp44 = static_cast<uint8_t>(affectCompat);
+    buf.Write(&tmp44);
+
+    // compatDetails
+    uint8_t tmp45;
+    tmp45 = static_cast<uint8_t>(compatDetails);
+    buf.Write(&tmp45);
+  }
+  if (CaseAnd(details_expr, EventType::BellNotify)) {
+    auto& affectBell = *details.affectBell;
+    auto& bellDetails = *details.bellDetails;
+
+    // affectBell
+    buf.Write(&affectBell);
+
+    // bellDetails
+    buf.Write(&bellDetails);
+  }
+  if (CaseAnd(details_expr, EventType::ActionMessage)) {
+    auto& affectMsgDetails = *details.affectMsgDetails;
+    auto& msgDetails = *details.msgDetails;
+
+    // affectMsgDetails
+    buf.Write(&affectMsgDetails);
+
+    // msgDetails
+    buf.Write(&msgDetails);
+  }
+  if (CaseAnd(details_expr, EventType::AccessXNotify)) {
+    auto& affectAccessX = *details.affectAccessX;
+    auto& accessXDetails = *details.accessXDetails;
+
+    // affectAccessX
+    uint16_t tmp46;
+    tmp46 = static_cast<uint16_t>(affectAccessX);
+    buf.Write(&tmp46);
+
+    // accessXDetails
+    uint16_t tmp47;
+    tmp47 = static_cast<uint16_t>(accessXDetails);
+    buf.Write(&tmp47);
+  }
+  if (CaseAnd(details_expr, EventType::ExtensionDeviceNotify)) {
+    auto& affectExtDev = *details.affectExtDev;
+    auto& extdevDetails = *details.extdevDetails;
+
+    // affectExtDev
+    uint16_t tmp48;
+    tmp48 = static_cast<uint16_t>(affectExtDev);
+    buf.Write(&tmp48);
+
+    // extdevDetails
+    uint16_t tmp49;
+    tmp49 = static_cast<uint16_t>(extdevDetails);
+    buf.Write(&tmp49);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::SelectEvents", false);
+}
+
+Future<void> Xkb::SelectEvents(
+    const DeviceSpec& deviceSpec,
+    const EventType& affectWhich,
+    const EventType& clear,
+    const EventType& selectAll,
+    const MapPart& affectMap,
+    const MapPart& map,
+    const absl::optional<NKNDetail>& affectNewKeyboard,
+    const absl::optional<NKNDetail>& newKeyboardDetails,
+    const absl::optional<StatePart>& affectState,
+    const absl::optional<StatePart>& stateDetails,
+    const absl::optional<Control>& affectCtrls,
+    const absl::optional<Control>& ctrlDetails,
+    const absl::optional<uint32_t>& affectIndicatorState,
+    const absl::optional<uint32_t>& indicatorStateDetails,
+    const absl::optional<uint32_t>& affectIndicatorMap,
+    const absl::optional<uint32_t>& indicatorMapDetails,
+    const absl::optional<NameDetail>& affectNames,
+    const absl::optional<NameDetail>& namesDetails,
+    const absl::optional<CMDetail>& affectCompat,
+    const absl::optional<CMDetail>& compatDetails,
+    const absl::optional<uint8_t>& affectBell,
+    const absl::optional<uint8_t>& bellDetails,
+    const absl::optional<uint8_t>& affectMsgDetails,
+    const absl::optional<uint8_t>& msgDetails,
+    const absl::optional<AXNDetail>& affectAccessX,
+    const absl::optional<AXNDetail>& accessXDetails,
+    const absl::optional<XIFeature>& affectExtDev,
+    const absl::optional<XIFeature>& extdevDetails) {
+  return Xkb::SelectEvents(Xkb::SelectEventsRequest{deviceSpec,
+                                                    affectWhich,
+                                                    clear,
+                                                    selectAll,
+                                                    affectMap,
+                                                    map,
+                                                    affectNewKeyboard,
+                                                    newKeyboardDetails,
+                                                    affectState,
+                                                    stateDetails,
+                                                    affectCtrls,
+                                                    ctrlDetails,
+                                                    affectIndicatorState,
+                                                    indicatorStateDetails,
+                                                    affectIndicatorMap,
+                                                    indicatorMapDetails,
+                                                    affectNames,
+                                                    namesDetails,
+                                                    affectCompat,
+                                                    compatDetails,
+                                                    affectBell,
+                                                    bellDetails,
+                                                    affectMsgDetails,
+                                                    msgDetails,
+                                                    affectAccessX,
+                                                    accessXDetails,
+                                                    affectExtDev,
+                                                    extdevDetails});
+}
+
+Future<void> Xkb::Bell(const Xkb::BellRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& bellClass = request.bellClass;
+  auto& bellID = request.bellID;
+  auto& percent = request.percent;
+  auto& forceSound = request.forceSound;
+  auto& eventOnly = request.eventOnly;
+  auto& pitch = request.pitch;
+  auto& duration = request.duration;
+  auto& name = request.name;
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // bellClass
+  buf.Write(&bellClass);
+
+  // bellID
+  buf.Write(&bellID);
+
+  // percent
+  buf.Write(&percent);
+
+  // forceSound
+  buf.Write(&forceSound);
+
+  // eventOnly
+  buf.Write(&eventOnly);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // pitch
+  buf.Write(&pitch);
+
+  // duration
+  buf.Write(&duration);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // name
+  buf.Write(&name);
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::Bell", false);
+}
+
+Future<void> Xkb::Bell(const DeviceSpec& deviceSpec,
+                       const BellClassSpec& bellClass,
+                       const IDSpec& bellID,
+                       const int8_t& percent,
+                       const uint8_t& forceSound,
+                       const uint8_t& eventOnly,
+                       const int16_t& pitch,
+                       const int16_t& duration,
+                       const Atom& name,
+                       const Window& window) {
+  return Xkb::Bell(Xkb::BellRequest{deviceSpec, bellClass, bellID, percent,
+                                    forceSound, eventOnly, pitch, duration,
+                                    name, window});
+}
+
+Future<Xkb::GetStateReply> Xkb::GetState(const Xkb::GetStateRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetStateReply>(&buf, "Xkb::GetState",
+                                                      false);
+}
+
+Future<Xkb::GetStateReply> Xkb::GetState(const DeviceSpec& deviceSpec) {
+  return Xkb::GetState(Xkb::GetStateRequest{deviceSpec});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetStateReply> detail::ReadReply<Xkb::GetStateReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetStateReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& mods = (*reply).mods;
+  auto& baseMods = (*reply).baseMods;
+  auto& latchedMods = (*reply).latchedMods;
+  auto& lockedMods = (*reply).lockedMods;
+  auto& group = (*reply).group;
+  auto& lockedGroup = (*reply).lockedGroup;
+  auto& baseGroup = (*reply).baseGroup;
+  auto& latchedGroup = (*reply).latchedGroup;
+  auto& compatState = (*reply).compatState;
+  auto& grabMods = (*reply).grabMods;
+  auto& compatGrabMods = (*reply).compatGrabMods;
+  auto& lookupMods = (*reply).lookupMods;
+  auto& compatLookupMods = (*reply).compatLookupMods;
+  auto& ptrBtnState = (*reply).ptrBtnState;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // mods
+  uint8_t tmp50;
+  Read(&tmp50, &buf);
+  mods = static_cast<ModMask>(tmp50);
+
+  // baseMods
+  uint8_t tmp51;
+  Read(&tmp51, &buf);
+  baseMods = static_cast<ModMask>(tmp51);
+
+  // latchedMods
+  uint8_t tmp52;
+  Read(&tmp52, &buf);
+  latchedMods = static_cast<ModMask>(tmp52);
+
+  // lockedMods
+  uint8_t tmp53;
+  Read(&tmp53, &buf);
+  lockedMods = static_cast<ModMask>(tmp53);
+
+  // group
+  uint8_t tmp54;
+  Read(&tmp54, &buf);
+  group = static_cast<Xkb::Group>(tmp54);
+
+  // lockedGroup
+  uint8_t tmp55;
+  Read(&tmp55, &buf);
+  lockedGroup = static_cast<Xkb::Group>(tmp55);
+
+  // baseGroup
+  Read(&baseGroup, &buf);
+
+  // latchedGroup
+  Read(&latchedGroup, &buf);
+
+  // compatState
+  uint8_t tmp56;
+  Read(&tmp56, &buf);
+  compatState = static_cast<ModMask>(tmp56);
+
+  // grabMods
+  uint8_t tmp57;
+  Read(&tmp57, &buf);
+  grabMods = static_cast<ModMask>(tmp57);
+
+  // compatGrabMods
+  uint8_t tmp58;
+  Read(&tmp58, &buf);
+  compatGrabMods = static_cast<ModMask>(tmp58);
+
+  // lookupMods
+  uint8_t tmp59;
+  Read(&tmp59, &buf);
+  lookupMods = static_cast<ModMask>(tmp59);
+
+  // compatLookupMods
+  uint8_t tmp60;
+  Read(&tmp60, &buf);
+  compatLookupMods = static_cast<ModMask>(tmp60);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // ptrBtnState
+  uint16_t tmp61;
+  Read(&tmp61, &buf);
+  ptrBtnState = static_cast<KeyButMask>(tmp61);
+
+  // pad1
+  Pad(&buf, 6);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::LatchLockState(const Xkb::LatchLockStateRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& affectModLocks = request.affectModLocks;
+  auto& modLocks = request.modLocks;
+  auto& lockGroup = request.lockGroup;
+  auto& groupLock = request.groupLock;
+  auto& affectModLatches = request.affectModLatches;
+  auto& latchGroup = request.latchGroup;
+  auto& groupLatch = request.groupLatch;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // affectModLocks
+  uint8_t tmp62;
+  tmp62 = static_cast<uint8_t>(affectModLocks);
+  buf.Write(&tmp62);
+
+  // modLocks
+  uint8_t tmp63;
+  tmp63 = static_cast<uint8_t>(modLocks);
+  buf.Write(&tmp63);
+
+  // lockGroup
+  buf.Write(&lockGroup);
+
+  // groupLock
+  uint8_t tmp64;
+  tmp64 = static_cast<uint8_t>(groupLock);
+  buf.Write(&tmp64);
+
+  // affectModLatches
+  uint8_t tmp65;
+  tmp65 = static_cast<uint8_t>(affectModLatches);
+  buf.Write(&tmp65);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // pad1
+  Pad(&buf, 1);
+
+  // latchGroup
+  buf.Write(&latchGroup);
+
+  // groupLatch
+  buf.Write(&groupLatch);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::LatchLockState", false);
+}
+
+Future<void> Xkb::LatchLockState(const DeviceSpec& deviceSpec,
+                                 const ModMask& affectModLocks,
+                                 const ModMask& modLocks,
+                                 const uint8_t& lockGroup,
+                                 const Group& groupLock,
+                                 const ModMask& affectModLatches,
+                                 const uint8_t& latchGroup,
+                                 const uint16_t& groupLatch) {
+  return Xkb::LatchLockState(Xkb::LatchLockStateRequest{
+      deviceSpec, affectModLocks, modLocks, lockGroup, groupLock,
+      affectModLatches, latchGroup, groupLatch});
+}
+
+Future<Xkb::GetControlsReply> Xkb::GetControls(
+    const Xkb::GetControlsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetControlsReply>(
+      &buf, "Xkb::GetControls", false);
+}
+
+Future<Xkb::GetControlsReply> Xkb::GetControls(const DeviceSpec& deviceSpec) {
+  return Xkb::GetControls(Xkb::GetControlsRequest{deviceSpec});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetControlsReply> detail::ReadReply<Xkb::GetControlsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetControlsReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& mouseKeysDfltBtn = (*reply).mouseKeysDfltBtn;
+  auto& numGroups = (*reply).numGroups;
+  auto& groupsWrap = (*reply).groupsWrap;
+  auto& internalModsMask = (*reply).internalModsMask;
+  auto& ignoreLockModsMask = (*reply).ignoreLockModsMask;
+  auto& internalModsRealMods = (*reply).internalModsRealMods;
+  auto& ignoreLockModsRealMods = (*reply).ignoreLockModsRealMods;
+  auto& internalModsVmods = (*reply).internalModsVmods;
+  auto& ignoreLockModsVmods = (*reply).ignoreLockModsVmods;
+  auto& repeatDelay = (*reply).repeatDelay;
+  auto& repeatInterval = (*reply).repeatInterval;
+  auto& slowKeysDelay = (*reply).slowKeysDelay;
+  auto& debounceDelay = (*reply).debounceDelay;
+  auto& mouseKeysDelay = (*reply).mouseKeysDelay;
+  auto& mouseKeysInterval = (*reply).mouseKeysInterval;
+  auto& mouseKeysTimeToMax = (*reply).mouseKeysTimeToMax;
+  auto& mouseKeysMaxSpeed = (*reply).mouseKeysMaxSpeed;
+  auto& mouseKeysCurve = (*reply).mouseKeysCurve;
+  auto& accessXOption = (*reply).accessXOption;
+  auto& accessXTimeout = (*reply).accessXTimeout;
+  auto& accessXTimeoutOptionsMask = (*reply).accessXTimeoutOptionsMask;
+  auto& accessXTimeoutOptionsValues = (*reply).accessXTimeoutOptionsValues;
+  auto& accessXTimeoutMask = (*reply).accessXTimeoutMask;
+  auto& accessXTimeoutValues = (*reply).accessXTimeoutValues;
+  auto& enabledControls = (*reply).enabledControls;
+  auto& perKeyRepeat = (*reply).perKeyRepeat;
+  size_t perKeyRepeat_len = perKeyRepeat.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // mouseKeysDfltBtn
+  Read(&mouseKeysDfltBtn, &buf);
+
+  // numGroups
+  Read(&numGroups, &buf);
+
+  // groupsWrap
+  Read(&groupsWrap, &buf);
+
+  // internalModsMask
+  uint8_t tmp66;
+  Read(&tmp66, &buf);
+  internalModsMask = static_cast<ModMask>(tmp66);
+
+  // ignoreLockModsMask
+  uint8_t tmp67;
+  Read(&tmp67, &buf);
+  ignoreLockModsMask = static_cast<ModMask>(tmp67);
+
+  // internalModsRealMods
+  uint8_t tmp68;
+  Read(&tmp68, &buf);
+  internalModsRealMods = static_cast<ModMask>(tmp68);
+
+  // ignoreLockModsRealMods
+  uint8_t tmp69;
+  Read(&tmp69, &buf);
+  ignoreLockModsRealMods = static_cast<ModMask>(tmp69);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // internalModsVmods
+  uint16_t tmp70;
+  Read(&tmp70, &buf);
+  internalModsVmods = static_cast<Xkb::VMod>(tmp70);
+
+  // ignoreLockModsVmods
+  uint16_t tmp71;
+  Read(&tmp71, &buf);
+  ignoreLockModsVmods = static_cast<Xkb::VMod>(tmp71);
+
+  // repeatDelay
+  Read(&repeatDelay, &buf);
+
+  // repeatInterval
+  Read(&repeatInterval, &buf);
+
+  // slowKeysDelay
+  Read(&slowKeysDelay, &buf);
+
+  // debounceDelay
+  Read(&debounceDelay, &buf);
+
+  // mouseKeysDelay
+  Read(&mouseKeysDelay, &buf);
+
+  // mouseKeysInterval
+  Read(&mouseKeysInterval, &buf);
+
+  // mouseKeysTimeToMax
+  Read(&mouseKeysTimeToMax, &buf);
+
+  // mouseKeysMaxSpeed
+  Read(&mouseKeysMaxSpeed, &buf);
+
+  // mouseKeysCurve
+  Read(&mouseKeysCurve, &buf);
+
+  // accessXOption
+  uint16_t tmp72;
+  Read(&tmp72, &buf);
+  accessXOption = static_cast<Xkb::AXOption>(tmp72);
+
+  // accessXTimeout
+  Read(&accessXTimeout, &buf);
+
+  // accessXTimeoutOptionsMask
+  uint16_t tmp73;
+  Read(&tmp73, &buf);
+  accessXTimeoutOptionsMask = static_cast<Xkb::AXOption>(tmp73);
+
+  // accessXTimeoutOptionsValues
+  uint16_t tmp74;
+  Read(&tmp74, &buf);
+  accessXTimeoutOptionsValues = static_cast<Xkb::AXOption>(tmp74);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // accessXTimeoutMask
+  uint32_t tmp75;
+  Read(&tmp75, &buf);
+  accessXTimeoutMask = static_cast<Xkb::BoolCtrl>(tmp75);
+
+  // accessXTimeoutValues
+  uint32_t tmp76;
+  Read(&tmp76, &buf);
+  accessXTimeoutValues = static_cast<Xkb::BoolCtrl>(tmp76);
+
+  // enabledControls
+  uint32_t tmp77;
+  Read(&tmp77, &buf);
+  enabledControls = static_cast<Xkb::BoolCtrl>(tmp77);
+
+  // perKeyRepeat
+  for (auto& perKeyRepeat_elem : perKeyRepeat) {
+    // perKeyRepeat_elem
+    Read(&perKeyRepeat_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::SetControls(const Xkb::SetControlsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& affectInternalRealMods = request.affectInternalRealMods;
+  auto& internalRealMods = request.internalRealMods;
+  auto& affectIgnoreLockRealMods = request.affectIgnoreLockRealMods;
+  auto& ignoreLockRealMods = request.ignoreLockRealMods;
+  auto& affectInternalVirtualMods = request.affectInternalVirtualMods;
+  auto& internalVirtualMods = request.internalVirtualMods;
+  auto& affectIgnoreLockVirtualMods = request.affectIgnoreLockVirtualMods;
+  auto& ignoreLockVirtualMods = request.ignoreLockVirtualMods;
+  auto& mouseKeysDfltBtn = request.mouseKeysDfltBtn;
+  auto& groupsWrap = request.groupsWrap;
+  auto& accessXOptions = request.accessXOptions;
+  auto& affectEnabledControls = request.affectEnabledControls;
+  auto& enabledControls = request.enabledControls;
+  auto& changeControls = request.changeControls;
+  auto& repeatDelay = request.repeatDelay;
+  auto& repeatInterval = request.repeatInterval;
+  auto& slowKeysDelay = request.slowKeysDelay;
+  auto& debounceDelay = request.debounceDelay;
+  auto& mouseKeysDelay = request.mouseKeysDelay;
+  auto& mouseKeysInterval = request.mouseKeysInterval;
+  auto& mouseKeysTimeToMax = request.mouseKeysTimeToMax;
+  auto& mouseKeysMaxSpeed = request.mouseKeysMaxSpeed;
+  auto& mouseKeysCurve = request.mouseKeysCurve;
+  auto& accessXTimeout = request.accessXTimeout;
+  auto& accessXTimeoutMask = request.accessXTimeoutMask;
+  auto& accessXTimeoutValues = request.accessXTimeoutValues;
+  auto& accessXTimeoutOptionsMask = request.accessXTimeoutOptionsMask;
+  auto& accessXTimeoutOptionsValues = request.accessXTimeoutOptionsValues;
+  auto& perKeyRepeat = request.perKeyRepeat;
+  size_t perKeyRepeat_len = perKeyRepeat.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // affectInternalRealMods
+  uint8_t tmp78;
+  tmp78 = static_cast<uint8_t>(affectInternalRealMods);
+  buf.Write(&tmp78);
+
+  // internalRealMods
+  uint8_t tmp79;
+  tmp79 = static_cast<uint8_t>(internalRealMods);
+  buf.Write(&tmp79);
+
+  // affectIgnoreLockRealMods
+  uint8_t tmp80;
+  tmp80 = static_cast<uint8_t>(affectIgnoreLockRealMods);
+  buf.Write(&tmp80);
+
+  // ignoreLockRealMods
+  uint8_t tmp81;
+  tmp81 = static_cast<uint8_t>(ignoreLockRealMods);
+  buf.Write(&tmp81);
+
+  // affectInternalVirtualMods
+  uint16_t tmp82;
+  tmp82 = static_cast<uint16_t>(affectInternalVirtualMods);
+  buf.Write(&tmp82);
+
+  // internalVirtualMods
+  uint16_t tmp83;
+  tmp83 = static_cast<uint16_t>(internalVirtualMods);
+  buf.Write(&tmp83);
+
+  // affectIgnoreLockVirtualMods
+  uint16_t tmp84;
+  tmp84 = static_cast<uint16_t>(affectIgnoreLockVirtualMods);
+  buf.Write(&tmp84);
+
+  // ignoreLockVirtualMods
+  uint16_t tmp85;
+  tmp85 = static_cast<uint16_t>(ignoreLockVirtualMods);
+  buf.Write(&tmp85);
+
+  // mouseKeysDfltBtn
+  buf.Write(&mouseKeysDfltBtn);
+
+  // groupsWrap
+  buf.Write(&groupsWrap);
+
+  // accessXOptions
+  uint16_t tmp86;
+  tmp86 = static_cast<uint16_t>(accessXOptions);
+  buf.Write(&tmp86);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // affectEnabledControls
+  uint32_t tmp87;
+  tmp87 = static_cast<uint32_t>(affectEnabledControls);
+  buf.Write(&tmp87);
+
+  // enabledControls
+  uint32_t tmp88;
+  tmp88 = static_cast<uint32_t>(enabledControls);
+  buf.Write(&tmp88);
+
+  // changeControls
+  uint32_t tmp89;
+  tmp89 = static_cast<uint32_t>(changeControls);
+  buf.Write(&tmp89);
+
+  // repeatDelay
+  buf.Write(&repeatDelay);
+
+  // repeatInterval
+  buf.Write(&repeatInterval);
+
+  // slowKeysDelay
+  buf.Write(&slowKeysDelay);
+
+  // debounceDelay
+  buf.Write(&debounceDelay);
+
+  // mouseKeysDelay
+  buf.Write(&mouseKeysDelay);
+
+  // mouseKeysInterval
+  buf.Write(&mouseKeysInterval);
+
+  // mouseKeysTimeToMax
+  buf.Write(&mouseKeysTimeToMax);
+
+  // mouseKeysMaxSpeed
+  buf.Write(&mouseKeysMaxSpeed);
+
+  // mouseKeysCurve
+  buf.Write(&mouseKeysCurve);
+
+  // accessXTimeout
+  buf.Write(&accessXTimeout);
+
+  // accessXTimeoutMask
+  uint32_t tmp90;
+  tmp90 = static_cast<uint32_t>(accessXTimeoutMask);
+  buf.Write(&tmp90);
+
+  // accessXTimeoutValues
+  uint32_t tmp91;
+  tmp91 = static_cast<uint32_t>(accessXTimeoutValues);
+  buf.Write(&tmp91);
+
+  // accessXTimeoutOptionsMask
+  uint16_t tmp92;
+  tmp92 = static_cast<uint16_t>(accessXTimeoutOptionsMask);
+  buf.Write(&tmp92);
+
+  // accessXTimeoutOptionsValues
+  uint16_t tmp93;
+  tmp93 = static_cast<uint16_t>(accessXTimeoutOptionsValues);
+  buf.Write(&tmp93);
+
+  // perKeyRepeat
+  for (auto& perKeyRepeat_elem : perKeyRepeat) {
+    // perKeyRepeat_elem
+    buf.Write(&perKeyRepeat_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::SetControls", false);
+}
+
+Future<void> Xkb::SetControls(const DeviceSpec& deviceSpec,
+                              const ModMask& affectInternalRealMods,
+                              const ModMask& internalRealMods,
+                              const ModMask& affectIgnoreLockRealMods,
+                              const ModMask& ignoreLockRealMods,
+                              const VMod& affectInternalVirtualMods,
+                              const VMod& internalVirtualMods,
+                              const VMod& affectIgnoreLockVirtualMods,
+                              const VMod& ignoreLockVirtualMods,
+                              const uint8_t& mouseKeysDfltBtn,
+                              const uint8_t& groupsWrap,
+                              const AXOption& accessXOptions,
+                              const BoolCtrl& affectEnabledControls,
+                              const BoolCtrl& enabledControls,
+                              const Control& changeControls,
+                              const uint16_t& repeatDelay,
+                              const uint16_t& repeatInterval,
+                              const uint16_t& slowKeysDelay,
+                              const uint16_t& debounceDelay,
+                              const uint16_t& mouseKeysDelay,
+                              const uint16_t& mouseKeysInterval,
+                              const uint16_t& mouseKeysTimeToMax,
+                              const uint16_t& mouseKeysMaxSpeed,
+                              const int16_t& mouseKeysCurve,
+                              const uint16_t& accessXTimeout,
+                              const BoolCtrl& accessXTimeoutMask,
+                              const BoolCtrl& accessXTimeoutValues,
+                              const AXOption& accessXTimeoutOptionsMask,
+                              const AXOption& accessXTimeoutOptionsValues,
+                              const std::array<uint8_t, 32>& perKeyRepeat) {
+  return Xkb::SetControls(Xkb::SetControlsRequest{deviceSpec,
+                                                  affectInternalRealMods,
+                                                  internalRealMods,
+                                                  affectIgnoreLockRealMods,
+                                                  ignoreLockRealMods,
+                                                  affectInternalVirtualMods,
+                                                  internalVirtualMods,
+                                                  affectIgnoreLockVirtualMods,
+                                                  ignoreLockVirtualMods,
+                                                  mouseKeysDfltBtn,
+                                                  groupsWrap,
+                                                  accessXOptions,
+                                                  affectEnabledControls,
+                                                  enabledControls,
+                                                  changeControls,
+                                                  repeatDelay,
+                                                  repeatInterval,
+                                                  slowKeysDelay,
+                                                  debounceDelay,
+                                                  mouseKeysDelay,
+                                                  mouseKeysInterval,
+                                                  mouseKeysTimeToMax,
+                                                  mouseKeysMaxSpeed,
+                                                  mouseKeysCurve,
+                                                  accessXTimeout,
+                                                  accessXTimeoutMask,
+                                                  accessXTimeoutValues,
+                                                  accessXTimeoutOptionsMask,
+                                                  accessXTimeoutOptionsValues,
+                                                  perKeyRepeat});
+}
+
+Future<Xkb::GetMapReply> Xkb::GetMap(const Xkb::GetMapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& full = request.full;
+  auto& partial = request.partial;
+  auto& firstType = request.firstType;
+  auto& nTypes = request.nTypes;
+  auto& firstKeySym = request.firstKeySym;
+  auto& nKeySyms = request.nKeySyms;
+  auto& firstKeyAction = request.firstKeyAction;
+  auto& nKeyActions = request.nKeyActions;
+  auto& firstKeyBehavior = request.firstKeyBehavior;
+  auto& nKeyBehaviors = request.nKeyBehaviors;
+  auto& virtualMods = request.virtualMods;
+  auto& firstKeyExplicit = request.firstKeyExplicit;
+  auto& nKeyExplicit = request.nKeyExplicit;
+  auto& firstModMapKey = request.firstModMapKey;
+  auto& nModMapKeys = request.nModMapKeys;
+  auto& firstVModMapKey = request.firstVModMapKey;
+  auto& nVModMapKeys = request.nVModMapKeys;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // full
+  uint16_t tmp94;
+  tmp94 = static_cast<uint16_t>(full);
+  buf.Write(&tmp94);
+
+  // partial
+  uint16_t tmp95;
+  tmp95 = static_cast<uint16_t>(partial);
+  buf.Write(&tmp95);
+
+  // firstType
+  buf.Write(&firstType);
+
+  // nTypes
+  buf.Write(&nTypes);
+
+  // firstKeySym
+  buf.Write(&firstKeySym);
+
+  // nKeySyms
+  buf.Write(&nKeySyms);
+
+  // firstKeyAction
+  buf.Write(&firstKeyAction);
+
+  // nKeyActions
+  buf.Write(&nKeyActions);
+
+  // firstKeyBehavior
+  buf.Write(&firstKeyBehavior);
+
+  // nKeyBehaviors
+  buf.Write(&nKeyBehaviors);
+
+  // virtualMods
+  uint16_t tmp96;
+  tmp96 = static_cast<uint16_t>(virtualMods);
+  buf.Write(&tmp96);
+
+  // firstKeyExplicit
+  buf.Write(&firstKeyExplicit);
+
+  // nKeyExplicit
+  buf.Write(&nKeyExplicit);
+
+  // firstModMapKey
+  buf.Write(&firstModMapKey);
+
+  // nModMapKeys
+  buf.Write(&nModMapKeys);
+
+  // firstVModMapKey
+  buf.Write(&firstVModMapKey);
+
+  // nVModMapKeys
+  buf.Write(&nVModMapKeys);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetMapReply>(&buf, "Xkb::GetMap", false);
+}
+
+Future<Xkb::GetMapReply> Xkb::GetMap(const DeviceSpec& deviceSpec,
+                                     const MapPart& full,
+                                     const MapPart& partial,
+                                     const uint8_t& firstType,
+                                     const uint8_t& nTypes,
+                                     const KeyCode& firstKeySym,
+                                     const uint8_t& nKeySyms,
+                                     const KeyCode& firstKeyAction,
+                                     const uint8_t& nKeyActions,
+                                     const KeyCode& firstKeyBehavior,
+                                     const uint8_t& nKeyBehaviors,
+                                     const VMod& virtualMods,
+                                     const KeyCode& firstKeyExplicit,
+                                     const uint8_t& nKeyExplicit,
+                                     const KeyCode& firstModMapKey,
+                                     const uint8_t& nModMapKeys,
+                                     const KeyCode& firstVModMapKey,
+                                     const uint8_t& nVModMapKeys) {
+  return Xkb::GetMap(Xkb::GetMapRequest{
+      deviceSpec, full, partial, firstType, nTypes, firstKeySym, nKeySyms,
+      firstKeyAction, nKeyActions, firstKeyBehavior, nKeyBehaviors, virtualMods,
+      firstKeyExplicit, nKeyExplicit, firstModMapKey, nModMapKeys,
+      firstVModMapKey, nVModMapKeys});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetMapReply> detail::ReadReply<Xkb::GetMapReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetMapReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& minKeyCode = (*reply).minKeyCode;
+  auto& maxKeyCode = (*reply).maxKeyCode;
+  Xkb::MapPart present{};
+  auto& firstType = (*reply).firstType;
+  auto& nTypes = (*reply).nTypes;
+  auto& totalTypes = (*reply).totalTypes;
+  auto& firstKeySym = (*reply).firstKeySym;
+  auto& totalSyms = (*reply).totalSyms;
+  auto& nKeySyms = (*reply).nKeySyms;
+  auto& firstKeyAction = (*reply).firstKeyAction;
+  auto& totalActions = (*reply).totalActions;
+  auto& nKeyActions = (*reply).nKeyActions;
+  auto& firstKeyBehavior = (*reply).firstKeyBehavior;
+  auto& nKeyBehaviors = (*reply).nKeyBehaviors;
+  auto& totalKeyBehaviors = (*reply).totalKeyBehaviors;
+  auto& firstKeyExplicit = (*reply).firstKeyExplicit;
+  auto& nKeyExplicit = (*reply).nKeyExplicit;
+  auto& totalKeyExplicit = (*reply).totalKeyExplicit;
+  auto& firstModMapKey = (*reply).firstModMapKey;
+  auto& nModMapKeys = (*reply).nModMapKeys;
+  auto& totalModMapKeys = (*reply).totalModMapKeys;
+  auto& firstVModMapKey = (*reply).firstVModMapKey;
+  auto& nVModMapKeys = (*reply).nVModMapKeys;
+  auto& totalVModMapKeys = (*reply).totalVModMapKeys;
+  auto& virtualMods = (*reply).virtualMods;
+  auto& map = (*reply);
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // minKeyCode
+  Read(&minKeyCode, &buf);
+
+  // maxKeyCode
+  Read(&maxKeyCode, &buf);
+
+  // present
+  uint16_t tmp97;
+  Read(&tmp97, &buf);
+  present = static_cast<Xkb::MapPart>(tmp97);
+
+  // firstType
+  Read(&firstType, &buf);
+
+  // nTypes
+  Read(&nTypes, &buf);
+
+  // totalTypes
+  Read(&totalTypes, &buf);
+
+  // firstKeySym
+  Read(&firstKeySym, &buf);
+
+  // totalSyms
+  Read(&totalSyms, &buf);
+
+  // nKeySyms
+  Read(&nKeySyms, &buf);
+
+  // firstKeyAction
+  Read(&firstKeyAction, &buf);
+
+  // totalActions
+  Read(&totalActions, &buf);
+
+  // nKeyActions
+  Read(&nKeyActions, &buf);
+
+  // firstKeyBehavior
+  Read(&firstKeyBehavior, &buf);
+
+  // nKeyBehaviors
+  Read(&nKeyBehaviors, &buf);
+
+  // totalKeyBehaviors
+  Read(&totalKeyBehaviors, &buf);
+
+  // firstKeyExplicit
+  Read(&firstKeyExplicit, &buf);
+
+  // nKeyExplicit
+  Read(&nKeyExplicit, &buf);
+
+  // totalKeyExplicit
+  Read(&totalKeyExplicit, &buf);
+
+  // firstModMapKey
+  Read(&firstModMapKey, &buf);
+
+  // nModMapKeys
+  Read(&nModMapKeys, &buf);
+
+  // totalModMapKeys
+  Read(&totalModMapKeys, &buf);
+
+  // firstVModMapKey
+  Read(&firstVModMapKey, &buf);
+
+  // nVModMapKeys
+  Read(&nVModMapKeys, &buf);
+
+  // totalVModMapKeys
+  Read(&totalVModMapKeys, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  // virtualMods
+  uint16_t tmp98;
+  Read(&tmp98, &buf);
+  virtualMods = static_cast<Xkb::VMod>(tmp98);
+
+  // map
+  auto map_expr = present;
+  if (CaseAnd(map_expr, Xkb::MapPart::KeyTypes)) {
+    map.types_rtrn.emplace();
+    auto& types_rtrn = *map.types_rtrn;
+    size_t types_rtrn_len = types_rtrn.size();
+
+    // types_rtrn
+    types_rtrn.resize(nTypes);
+    for (auto& types_rtrn_elem : types_rtrn) {
+      // types_rtrn_elem
+      {
+        auto& mods_mask = types_rtrn_elem.mods_mask;
+        auto& mods_mods = types_rtrn_elem.mods_mods;
+        auto& mods_vmods = types_rtrn_elem.mods_vmods;
+        auto& numLevels = types_rtrn_elem.numLevels;
+        uint8_t nMapEntries{};
+        auto& hasPreserve = types_rtrn_elem.hasPreserve;
+        auto& map = types_rtrn_elem.map;
+        size_t map_len = map.size();
+        auto& preserve = types_rtrn_elem.preserve;
+        size_t preserve_len = preserve.size();
+
+        // mods_mask
+        uint8_t tmp99;
+        Read(&tmp99, &buf);
+        mods_mask = static_cast<ModMask>(tmp99);
+
+        // mods_mods
+        uint8_t tmp100;
+        Read(&tmp100, &buf);
+        mods_mods = static_cast<ModMask>(tmp100);
+
+        // mods_vmods
+        uint16_t tmp101;
+        Read(&tmp101, &buf);
+        mods_vmods = static_cast<Xkb::VMod>(tmp101);
+
+        // numLevels
+        Read(&numLevels, &buf);
+
+        // nMapEntries
+        Read(&nMapEntries, &buf);
+
+        // hasPreserve
+        Read(&hasPreserve, &buf);
+
+        // pad0
+        Pad(&buf, 1);
+
+        // map
+        map.resize(nMapEntries);
+        for (auto& map_elem : map) {
+          // map_elem
+          {
+            auto& active = map_elem.active;
+            auto& mods_mask = map_elem.mods_mask;
+            auto& level = map_elem.level;
+            auto& mods_mods = map_elem.mods_mods;
+            auto& mods_vmods = map_elem.mods_vmods;
+
+            // active
+            Read(&active, &buf);
+
+            // mods_mask
+            uint8_t tmp102;
+            Read(&tmp102, &buf);
+            mods_mask = static_cast<ModMask>(tmp102);
+
+            // level
+            Read(&level, &buf);
+
+            // mods_mods
+            uint8_t tmp103;
+            Read(&tmp103, &buf);
+            mods_mods = static_cast<ModMask>(tmp103);
+
+            // mods_vmods
+            uint16_t tmp104;
+            Read(&tmp104, &buf);
+            mods_vmods = static_cast<Xkb::VMod>(tmp104);
+
+            // pad0
+            Pad(&buf, 2);
+          }
+        }
+
+        // preserve
+        preserve.resize((hasPreserve) * (nMapEntries));
+        for (auto& preserve_elem : preserve) {
+          // preserve_elem
+          {
+            auto& mask = preserve_elem.mask;
+            auto& realMods = preserve_elem.realMods;
+            auto& vmods = preserve_elem.vmods;
+
+            // mask
+            uint8_t tmp105;
+            Read(&tmp105, &buf);
+            mask = static_cast<ModMask>(tmp105);
+
+            // realMods
+            uint8_t tmp106;
+            Read(&tmp106, &buf);
+            realMods = static_cast<ModMask>(tmp106);
+
+            // vmods
+            uint16_t tmp107;
+            Read(&tmp107, &buf);
+            vmods = static_cast<Xkb::VMod>(tmp107);
+          }
+        }
+      }
+    }
+  }
+  if (CaseAnd(map_expr, Xkb::MapPart::KeySyms)) {
+    map.syms_rtrn.emplace();
+    auto& syms_rtrn = *map.syms_rtrn;
+    size_t syms_rtrn_len = syms_rtrn.size();
+
+    // syms_rtrn
+    syms_rtrn.resize(nKeySyms);
+    for (auto& syms_rtrn_elem : syms_rtrn) {
+      // syms_rtrn_elem
+      {
+        auto& kt_index = syms_rtrn_elem.kt_index;
+        size_t kt_index_len = kt_index.size();
+        auto& groupInfo = syms_rtrn_elem.groupInfo;
+        auto& width = syms_rtrn_elem.width;
+        uint16_t nSyms{};
+        auto& syms = syms_rtrn_elem.syms;
+        size_t syms_len = syms.size();
+
+        // kt_index
+        for (auto& kt_index_elem : kt_index) {
+          // kt_index_elem
+          Read(&kt_index_elem, &buf);
+        }
+
+        // groupInfo
+        Read(&groupInfo, &buf);
+
+        // width
+        Read(&width, &buf);
+
+        // nSyms
+        Read(&nSyms, &buf);
+
+        // syms
+        syms.resize(nSyms);
+        for (auto& syms_elem : syms) {
+          // syms_elem
+          Read(&syms_elem, &buf);
+        }
+      }
+    }
+  }
+  if (CaseAnd(map_expr, Xkb::MapPart::KeyActions)) {
+    map.acts_rtrn_count.emplace();
+    map.acts_rtrn_acts.emplace();
+    auto& acts_rtrn_count = *map.acts_rtrn_count;
+    size_t acts_rtrn_count_len = acts_rtrn_count.size();
+    auto& acts_rtrn_acts = *map.acts_rtrn_acts;
+    size_t acts_rtrn_acts_len = acts_rtrn_acts.size();
+
+    // acts_rtrn_count
+    acts_rtrn_count.resize(nKeyActions);
+    for (auto& acts_rtrn_count_elem : acts_rtrn_count) {
+      // acts_rtrn_count_elem
+      Read(&acts_rtrn_count_elem, &buf);
+    }
+
+    // pad2
+    Align(&buf, 4);
+
+    // acts_rtrn_acts
+    acts_rtrn_acts.resize(totalActions);
+    for (auto& acts_rtrn_acts_elem : acts_rtrn_acts) {
+      // acts_rtrn_acts_elem
+      Read(&acts_rtrn_acts_elem, &buf);
+    }
+  }
+  if (CaseAnd(map_expr, Xkb::MapPart::KeyBehaviors)) {
+    map.behaviors_rtrn.emplace();
+    auto& behaviors_rtrn = *map.behaviors_rtrn;
+    size_t behaviors_rtrn_len = behaviors_rtrn.size();
+
+    // behaviors_rtrn
+    behaviors_rtrn.resize(totalKeyBehaviors);
+    for (auto& behaviors_rtrn_elem : behaviors_rtrn) {
+      // behaviors_rtrn_elem
+      {
+        auto& keycode = behaviors_rtrn_elem.keycode;
+        auto& behavior = behaviors_rtrn_elem.behavior;
+
+        // keycode
+        Read(&keycode, &buf);
+
+        // behavior
+        Read(&behavior, &buf);
+
+        // pad0
+        Pad(&buf, 1);
+      }
+    }
+  }
+  if (CaseAnd(map_expr, Xkb::MapPart::VirtualMods)) {
+    map.vmods_rtrn.emplace();
+    auto& vmods_rtrn = *map.vmods_rtrn;
+    size_t vmods_rtrn_len = vmods_rtrn.size();
+
+    // vmods_rtrn
+    vmods_rtrn.resize(PopCount(virtualMods));
+    for (auto& vmods_rtrn_elem : vmods_rtrn) {
+      // vmods_rtrn_elem
+      uint8_t tmp108;
+      Read(&tmp108, &buf);
+      vmods_rtrn_elem = static_cast<ModMask>(tmp108);
+    }
+
+    // pad3
+    Align(&buf, 4);
+  }
+  if (CaseAnd(map_expr, Xkb::MapPart::ExplicitComponents)) {
+    map.explicit_rtrn.emplace();
+    auto& explicit_rtrn = *map.explicit_rtrn;
+    size_t explicit_rtrn_len = explicit_rtrn.size();
+
+    // explicit_rtrn
+    explicit_rtrn.resize(totalKeyExplicit);
+    for (auto& explicit_rtrn_elem : explicit_rtrn) {
+      // explicit_rtrn_elem
+      {
+        auto& keycode = explicit_rtrn_elem.keycode;
+        auto& c_explicit = explicit_rtrn_elem.c_explicit;
+
+        // keycode
+        Read(&keycode, &buf);
+
+        // c_explicit
+        uint8_t tmp109;
+        Read(&tmp109, &buf);
+        c_explicit = static_cast<Xkb::Explicit>(tmp109);
+      }
+    }
+
+    // pad4
+    Align(&buf, 4);
+  }
+  if (CaseAnd(map_expr, Xkb::MapPart::ModifierMap)) {
+    map.modmap_rtrn.emplace();
+    auto& modmap_rtrn = *map.modmap_rtrn;
+    size_t modmap_rtrn_len = modmap_rtrn.size();
+
+    // modmap_rtrn
+    modmap_rtrn.resize(totalModMapKeys);
+    for (auto& modmap_rtrn_elem : modmap_rtrn) {
+      // modmap_rtrn_elem
+      {
+        auto& keycode = modmap_rtrn_elem.keycode;
+        auto& mods = modmap_rtrn_elem.mods;
+
+        // keycode
+        Read(&keycode, &buf);
+
+        // mods
+        uint8_t tmp110;
+        Read(&tmp110, &buf);
+        mods = static_cast<ModMask>(tmp110);
+      }
+    }
+
+    // pad5
+    Align(&buf, 4);
+  }
+  if (CaseAnd(map_expr, Xkb::MapPart::VirtualModMap)) {
+    map.vmodmap_rtrn.emplace();
+    auto& vmodmap_rtrn = *map.vmodmap_rtrn;
+    size_t vmodmap_rtrn_len = vmodmap_rtrn.size();
+
+    // vmodmap_rtrn
+    vmodmap_rtrn.resize(totalVModMapKeys);
+    for (auto& vmodmap_rtrn_elem : vmodmap_rtrn) {
+      // vmodmap_rtrn_elem
+      {
+        auto& keycode = vmodmap_rtrn_elem.keycode;
+        auto& vmods = vmodmap_rtrn_elem.vmods;
+
+        // keycode
+        Read(&keycode, &buf);
+
+        // pad0
+        Pad(&buf, 1);
+
+        // vmods
+        uint16_t tmp111;
+        Read(&tmp111, &buf);
+        vmods = static_cast<Xkb::VMod>(tmp111);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::SetMap(const Xkb::SetMapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  MapPart present{};
+  auto& flags = request.flags;
+  auto& minKeyCode = request.minKeyCode;
+  auto& maxKeyCode = request.maxKeyCode;
+  auto& firstType = request.firstType;
+  auto& nTypes = request.nTypes;
+  auto& firstKeySym = request.firstKeySym;
+  auto& nKeySyms = request.nKeySyms;
+  auto& totalSyms = request.totalSyms;
+  auto& firstKeyAction = request.firstKeyAction;
+  auto& nKeyActions = request.nKeyActions;
+  auto& totalActions = request.totalActions;
+  auto& firstKeyBehavior = request.firstKeyBehavior;
+  auto& nKeyBehaviors = request.nKeyBehaviors;
+  auto& totalKeyBehaviors = request.totalKeyBehaviors;
+  auto& firstKeyExplicit = request.firstKeyExplicit;
+  auto& nKeyExplicit = request.nKeyExplicit;
+  auto& totalKeyExplicit = request.totalKeyExplicit;
+  auto& firstModMapKey = request.firstModMapKey;
+  auto& nModMapKeys = request.nModMapKeys;
+  auto& totalModMapKeys = request.totalModMapKeys;
+  auto& firstVModMapKey = request.firstVModMapKey;
+  auto& nVModMapKeys = request.nVModMapKeys;
+  auto& totalVModMapKeys = request.totalVModMapKeys;
+  auto& virtualMods = request.virtualMods;
+  auto& values = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // present
+  SwitchVar(MapPart::KeyTypes, values.types.has_value(), true, &present);
+  SwitchVar(MapPart::KeySyms, values.syms.has_value(), true, &present);
+  SwitchVar(MapPart::KeyActions, values.actionsCount.has_value(), true,
+            &present);
+  SwitchVar(MapPart::KeyBehaviors, values.behaviors.has_value(), true,
+            &present);
+  SwitchVar(MapPart::VirtualMods, values.vmods.has_value(), true, &present);
+  SwitchVar(MapPart::ExplicitComponents, values.c_explicit.has_value(), true,
+            &present);
+  SwitchVar(MapPart::ModifierMap, values.modmap.has_value(), true, &present);
+  SwitchVar(MapPart::VirtualModMap, values.vmodmap.has_value(), true, &present);
+  uint16_t tmp112;
+  tmp112 = static_cast<uint16_t>(present);
+  buf.Write(&tmp112);
+
+  // flags
+  uint16_t tmp113;
+  tmp113 = static_cast<uint16_t>(flags);
+  buf.Write(&tmp113);
+
+  // minKeyCode
+  buf.Write(&minKeyCode);
+
+  // maxKeyCode
+  buf.Write(&maxKeyCode);
+
+  // firstType
+  buf.Write(&firstType);
+
+  // nTypes
+  buf.Write(&nTypes);
+
+  // firstKeySym
+  buf.Write(&firstKeySym);
+
+  // nKeySyms
+  buf.Write(&nKeySyms);
+
+  // totalSyms
+  buf.Write(&totalSyms);
+
+  // firstKeyAction
+  buf.Write(&firstKeyAction);
+
+  // nKeyActions
+  buf.Write(&nKeyActions);
+
+  // totalActions
+  buf.Write(&totalActions);
+
+  // firstKeyBehavior
+  buf.Write(&firstKeyBehavior);
+
+  // nKeyBehaviors
+  buf.Write(&nKeyBehaviors);
+
+  // totalKeyBehaviors
+  buf.Write(&totalKeyBehaviors);
+
+  // firstKeyExplicit
+  buf.Write(&firstKeyExplicit);
+
+  // nKeyExplicit
+  buf.Write(&nKeyExplicit);
+
+  // totalKeyExplicit
+  buf.Write(&totalKeyExplicit);
+
+  // firstModMapKey
+  buf.Write(&firstModMapKey);
+
+  // nModMapKeys
+  buf.Write(&nModMapKeys);
+
+  // totalModMapKeys
+  buf.Write(&totalModMapKeys);
+
+  // firstVModMapKey
+  buf.Write(&firstVModMapKey);
+
+  // nVModMapKeys
+  buf.Write(&nVModMapKeys);
+
+  // totalVModMapKeys
+  buf.Write(&totalVModMapKeys);
+
+  // virtualMods
+  uint16_t tmp114;
+  tmp114 = static_cast<uint16_t>(virtualMods);
+  buf.Write(&tmp114);
+
+  // values
+  auto values_expr = present;
+  if (CaseAnd(values_expr, MapPart::KeyTypes)) {
+    auto& types = *values.types;
+    size_t types_len = types.size();
+
+    // types
+    DCHECK_EQ(static_cast<size_t>(nTypes), types.size());
+    for (auto& types_elem : types) {
+      // types_elem
+      {
+        auto& mask = types_elem.mask;
+        auto& realMods = types_elem.realMods;
+        auto& virtualMods = types_elem.virtualMods;
+        auto& numLevels = types_elem.numLevels;
+        uint8_t nMapEntries{};
+        auto& preserve = types_elem.preserve;
+        auto& entries = types_elem.entries;
+        size_t entries_len = entries.size();
+        auto& preserve_entries = types_elem.preserve_entries;
+        size_t preserve_entries_len = preserve_entries.size();
+
+        // mask
+        uint8_t tmp115;
+        tmp115 = static_cast<uint8_t>(mask);
+        buf.Write(&tmp115);
+
+        // realMods
+        uint8_t tmp116;
+        tmp116 = static_cast<uint8_t>(realMods);
+        buf.Write(&tmp116);
+
+        // virtualMods
+        uint16_t tmp117;
+        tmp117 = static_cast<uint16_t>(virtualMods);
+        buf.Write(&tmp117);
+
+        // numLevels
+        buf.Write(&numLevels);
+
+        // nMapEntries
+        nMapEntries = entries.size();
+        buf.Write(&nMapEntries);
+
+        // preserve
+        buf.Write(&preserve);
+
+        // pad0
+        Pad(&buf, 1);
+
+        // entries
+        DCHECK_EQ(static_cast<size_t>(nMapEntries), entries.size());
+        for (auto& entries_elem : entries) {
+          // entries_elem
+          {
+            auto& level = entries_elem.level;
+            auto& realMods = entries_elem.realMods;
+            auto& virtualMods = entries_elem.virtualMods;
+
+            // level
+            buf.Write(&level);
+
+            // realMods
+            uint8_t tmp118;
+            tmp118 = static_cast<uint8_t>(realMods);
+            buf.Write(&tmp118);
+
+            // virtualMods
+            uint16_t tmp119;
+            tmp119 = static_cast<uint16_t>(virtualMods);
+            buf.Write(&tmp119);
+          }
+        }
+
+        // preserve_entries
+        DCHECK_EQ(static_cast<size_t>((preserve) * (nMapEntries)),
+                  preserve_entries.size());
+        for (auto& preserve_entries_elem : preserve_entries) {
+          // preserve_entries_elem
+          {
+            auto& level = preserve_entries_elem.level;
+            auto& realMods = preserve_entries_elem.realMods;
+            auto& virtualMods = preserve_entries_elem.virtualMods;
+
+            // level
+            buf.Write(&level);
+
+            // realMods
+            uint8_t tmp120;
+            tmp120 = static_cast<uint8_t>(realMods);
+            buf.Write(&tmp120);
+
+            // virtualMods
+            uint16_t tmp121;
+            tmp121 = static_cast<uint16_t>(virtualMods);
+            buf.Write(&tmp121);
+          }
+        }
+      }
+    }
+  }
+  if (CaseAnd(values_expr, MapPart::KeySyms)) {
+    auto& syms = *values.syms;
+    size_t syms_len = syms.size();
+
+    // syms
+    DCHECK_EQ(static_cast<size_t>(nKeySyms), syms.size());
+    for (auto& syms_elem : syms) {
+      // syms_elem
+      {
+        auto& kt_index = syms_elem.kt_index;
+        size_t kt_index_len = kt_index.size();
+        auto& groupInfo = syms_elem.groupInfo;
+        auto& width = syms_elem.width;
+        uint16_t nSyms{};
+        auto& syms = syms_elem.syms;
+        size_t syms_len = syms.size();
+
+        // kt_index
+        for (auto& kt_index_elem : kt_index) {
+          // kt_index_elem
+          buf.Write(&kt_index_elem);
+        }
+
+        // groupInfo
+        buf.Write(&groupInfo);
+
+        // width
+        buf.Write(&width);
+
+        // nSyms
+        nSyms = syms.size();
+        buf.Write(&nSyms);
+
+        // syms
+        DCHECK_EQ(static_cast<size_t>(nSyms), syms.size());
+        for (auto& syms_elem : syms) {
+          // syms_elem
+          buf.Write(&syms_elem);
+        }
+      }
+    }
+  }
+  if (CaseAnd(values_expr, MapPart::KeyActions)) {
+    auto& actionsCount = *values.actionsCount;
+    size_t actionsCount_len = actionsCount.size();
+    auto& actions = *values.actions;
+    size_t actions_len = actions.size();
+
+    // actionsCount
+    DCHECK_EQ(static_cast<size_t>(nKeyActions), actionsCount.size());
+    for (auto& actionsCount_elem : actionsCount) {
+      // actionsCount_elem
+      buf.Write(&actionsCount_elem);
+    }
+
+    // pad0
+    Align(&buf, 4);
+
+    // actions
+    DCHECK_EQ(static_cast<size_t>(totalActions), actions.size());
+    for (auto& actions_elem : actions) {
+      // actions_elem
+      buf.Write(&actions_elem);
+    }
+  }
+  if (CaseAnd(values_expr, MapPart::KeyBehaviors)) {
+    auto& behaviors = *values.behaviors;
+    size_t behaviors_len = behaviors.size();
+
+    // behaviors
+    DCHECK_EQ(static_cast<size_t>(totalKeyBehaviors), behaviors.size());
+    for (auto& behaviors_elem : behaviors) {
+      // behaviors_elem
+      {
+        auto& keycode = behaviors_elem.keycode;
+        auto& behavior = behaviors_elem.behavior;
+
+        // keycode
+        buf.Write(&keycode);
+
+        // behavior
+        buf.Write(&behavior);
+
+        // pad0
+        Pad(&buf, 1);
+      }
+    }
+  }
+  if (CaseAnd(values_expr, MapPart::VirtualMods)) {
+    auto& vmods = *values.vmods;
+    size_t vmods_len = vmods.size();
+
+    // vmods
+    DCHECK_EQ(static_cast<size_t>(PopCount(virtualMods)), vmods.size());
+    for (auto& vmods_elem : vmods) {
+      // vmods_elem
+      buf.Write(&vmods_elem);
+    }
+
+    // pad1
+    Align(&buf, 4);
+  }
+  if (CaseAnd(values_expr, MapPart::ExplicitComponents)) {
+    auto& c_explicit = *values.c_explicit;
+    size_t c_explicit_len = c_explicit.size();
+
+    // c_explicit
+    DCHECK_EQ(static_cast<size_t>(totalKeyExplicit), c_explicit.size());
+    for (auto& c_explicit_elem : c_explicit) {
+      // c_explicit_elem
+      {
+        auto& keycode = c_explicit_elem.keycode;
+        auto& c_explicit = c_explicit_elem.c_explicit;
+
+        // keycode
+        buf.Write(&keycode);
+
+        // c_explicit
+        uint8_t tmp122;
+        tmp122 = static_cast<uint8_t>(c_explicit);
+        buf.Write(&tmp122);
+      }
+    }
+  }
+  if (CaseAnd(values_expr, MapPart::ModifierMap)) {
+    auto& modmap = *values.modmap;
+    size_t modmap_len = modmap.size();
+
+    // modmap
+    DCHECK_EQ(static_cast<size_t>(totalModMapKeys), modmap.size());
+    for (auto& modmap_elem : modmap) {
+      // modmap_elem
+      {
+        auto& keycode = modmap_elem.keycode;
+        auto& mods = modmap_elem.mods;
+
+        // keycode
+        buf.Write(&keycode);
+
+        // mods
+        uint8_t tmp123;
+        tmp123 = static_cast<uint8_t>(mods);
+        buf.Write(&tmp123);
+      }
+    }
+  }
+  if (CaseAnd(values_expr, MapPart::VirtualModMap)) {
+    auto& vmodmap = *values.vmodmap;
+    size_t vmodmap_len = vmodmap.size();
+
+    // vmodmap
+    DCHECK_EQ(static_cast<size_t>(totalVModMapKeys), vmodmap.size());
+    for (auto& vmodmap_elem : vmodmap) {
+      // vmodmap_elem
+      {
+        auto& keycode = vmodmap_elem.keycode;
+        auto& vmods = vmodmap_elem.vmods;
+
+        // keycode
+        buf.Write(&keycode);
+
+        // pad0
+        Pad(&buf, 1);
+
+        // vmods
+        uint16_t tmp124;
+        tmp124 = static_cast<uint16_t>(vmods);
+        buf.Write(&tmp124);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::SetMap", false);
+}
+
+Future<void> Xkb::SetMap(
+    const DeviceSpec& deviceSpec,
+    const SetMapFlags& flags,
+    const KeyCode& minKeyCode,
+    const KeyCode& maxKeyCode,
+    const uint8_t& firstType,
+    const uint8_t& nTypes,
+    const KeyCode& firstKeySym,
+    const uint8_t& nKeySyms,
+    const uint16_t& totalSyms,
+    const KeyCode& firstKeyAction,
+    const uint8_t& nKeyActions,
+    const uint16_t& totalActions,
+    const KeyCode& firstKeyBehavior,
+    const uint8_t& nKeyBehaviors,
+    const uint8_t& totalKeyBehaviors,
+    const KeyCode& firstKeyExplicit,
+    const uint8_t& nKeyExplicit,
+    const uint8_t& totalKeyExplicit,
+    const KeyCode& firstModMapKey,
+    const uint8_t& nModMapKeys,
+    const uint8_t& totalModMapKeys,
+    const KeyCode& firstVModMapKey,
+    const uint8_t& nVModMapKeys,
+    const uint8_t& totalVModMapKeys,
+    const VMod& virtualMods,
+    const absl::optional<std::vector<SetKeyType>>& types,
+    const absl::optional<std::vector<KeySymMap>>& syms,
+    const absl::optional<std::vector<uint8_t>>& actionsCount,
+    const absl::optional<std::vector<Action>>& actions,
+    const absl::optional<std::vector<SetBehavior>>& behaviors,
+    const absl::optional<std::vector<uint8_t>>& vmods,
+    const absl::optional<std::vector<SetExplicit>>& c_explicit,
+    const absl::optional<std::vector<KeyModMap>>& modmap,
+    const absl::optional<std::vector<KeyVModMap>>& vmodmap) {
+  return Xkb::SetMap(Xkb::SetMapRequest{deviceSpec,
+                                        flags,
+                                        minKeyCode,
+                                        maxKeyCode,
+                                        firstType,
+                                        nTypes,
+                                        firstKeySym,
+                                        nKeySyms,
+                                        totalSyms,
+                                        firstKeyAction,
+                                        nKeyActions,
+                                        totalActions,
+                                        firstKeyBehavior,
+                                        nKeyBehaviors,
+                                        totalKeyBehaviors,
+                                        firstKeyExplicit,
+                                        nKeyExplicit,
+                                        totalKeyExplicit,
+                                        firstModMapKey,
+                                        nModMapKeys,
+                                        totalModMapKeys,
+                                        firstVModMapKey,
+                                        nVModMapKeys,
+                                        totalVModMapKeys,
+                                        virtualMods,
+                                        types,
+                                        syms,
+                                        actionsCount,
+                                        actions,
+                                        behaviors,
+                                        vmods,
+                                        c_explicit,
+                                        modmap,
+                                        vmodmap});
+}
+
+Future<Xkb::GetCompatMapReply> Xkb::GetCompatMap(
+    const Xkb::GetCompatMapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& groups = request.groups;
+  auto& getAllSI = request.getAllSI;
+  auto& firstSI = request.firstSI;
+  auto& nSI = request.nSI;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // groups
+  uint8_t tmp125;
+  tmp125 = static_cast<uint8_t>(groups);
+  buf.Write(&tmp125);
+
+  // getAllSI
+  buf.Write(&getAllSI);
+
+  // firstSI
+  buf.Write(&firstSI);
+
+  // nSI
+  buf.Write(&nSI);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetCompatMapReply>(
+      &buf, "Xkb::GetCompatMap", false);
+}
+
+Future<Xkb::GetCompatMapReply> Xkb::GetCompatMap(const DeviceSpec& deviceSpec,
+                                                 const SetOfGroup& groups,
+                                                 const uint8_t& getAllSI,
+                                                 const uint16_t& firstSI,
+                                                 const uint16_t& nSI) {
+  return Xkb::GetCompatMap(
+      Xkb::GetCompatMapRequest{deviceSpec, groups, getAllSI, firstSI, nSI});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetCompatMapReply> detail::ReadReply<
+    Xkb::GetCompatMapReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetCompatMapReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& groupsRtrn = (*reply).groupsRtrn;
+  auto& firstSIRtrn = (*reply).firstSIRtrn;
+  uint16_t nSIRtrn{};
+  auto& nTotalSI = (*reply).nTotalSI;
+  auto& si_rtrn = (*reply).si_rtrn;
+  size_t si_rtrn_len = si_rtrn.size();
+  auto& group_rtrn = (*reply).group_rtrn;
+  size_t group_rtrn_len = group_rtrn.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // groupsRtrn
+  uint8_t tmp126;
+  Read(&tmp126, &buf);
+  groupsRtrn = static_cast<Xkb::SetOfGroup>(tmp126);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // firstSIRtrn
+  Read(&firstSIRtrn, &buf);
+
+  // nSIRtrn
+  Read(&nSIRtrn, &buf);
+
+  // nTotalSI
+  Read(&nTotalSI, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  // si_rtrn
+  si_rtrn.resize(nSIRtrn);
+  for (auto& si_rtrn_elem : si_rtrn) {
+    // si_rtrn_elem
+    {
+      auto& sym = si_rtrn_elem.sym;
+      auto& mods = si_rtrn_elem.mods;
+      auto& match = si_rtrn_elem.match;
+      auto& virtualMod = si_rtrn_elem.virtualMod;
+      auto& flags = si_rtrn_elem.flags;
+      auto& action = si_rtrn_elem.action;
+
+      // sym
+      Read(&sym, &buf);
+
+      // mods
+      uint8_t tmp127;
+      Read(&tmp127, &buf);
+      mods = static_cast<ModMask>(tmp127);
+
+      // match
+      Read(&match, &buf);
+
+      // virtualMod
+      uint8_t tmp128;
+      Read(&tmp128, &buf);
+      virtualMod = static_cast<Xkb::VModsLow>(tmp128);
+
+      // flags
+      Read(&flags, &buf);
+
+      // action
+      {
+        auto& type = action.type;
+        auto& data = action.data;
+        size_t data_len = data.size();
+
+        // type
+        uint8_t tmp129;
+        Read(&tmp129, &buf);
+        type = static_cast<Xkb::SAType>(tmp129);
+
+        // data
+        for (auto& data_elem : data) {
+          // data_elem
+          Read(&data_elem, &buf);
+        }
+      }
+    }
+  }
+
+  // group_rtrn
+  group_rtrn.resize(PopCount(groupsRtrn));
+  for (auto& group_rtrn_elem : group_rtrn) {
+    // group_rtrn_elem
+    {
+      auto& mask = group_rtrn_elem.mask;
+      auto& realMods = group_rtrn_elem.realMods;
+      auto& vmods = group_rtrn_elem.vmods;
+
+      // mask
+      uint8_t tmp130;
+      Read(&tmp130, &buf);
+      mask = static_cast<ModMask>(tmp130);
+
+      // realMods
+      uint8_t tmp131;
+      Read(&tmp131, &buf);
+      realMods = static_cast<ModMask>(tmp131);
+
+      // vmods
+      uint16_t tmp132;
+      Read(&tmp132, &buf);
+      vmods = static_cast<Xkb::VMod>(tmp132);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::SetCompatMap(const Xkb::SetCompatMapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& recomputeActions = request.recomputeActions;
+  auto& truncateSI = request.truncateSI;
+  auto& groups = request.groups;
+  auto& firstSI = request.firstSI;
+  uint16_t nSI{};
+  auto& si = request.si;
+  size_t si_len = si.size();
+  auto& groupMaps = request.groupMaps;
+  size_t groupMaps_len = groupMaps.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // recomputeActions
+  buf.Write(&recomputeActions);
+
+  // truncateSI
+  buf.Write(&truncateSI);
+
+  // groups
+  uint8_t tmp133;
+  tmp133 = static_cast<uint8_t>(groups);
+  buf.Write(&tmp133);
+
+  // firstSI
+  buf.Write(&firstSI);
+
+  // nSI
+  nSI = si.size();
+  buf.Write(&nSI);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // si
+  DCHECK_EQ(static_cast<size_t>(nSI), si.size());
+  for (auto& si_elem : si) {
+    // si_elem
+    {
+      auto& sym = si_elem.sym;
+      auto& mods = si_elem.mods;
+      auto& match = si_elem.match;
+      auto& virtualMod = si_elem.virtualMod;
+      auto& flags = si_elem.flags;
+      auto& action = si_elem.action;
+
+      // sym
+      buf.Write(&sym);
+
+      // mods
+      uint8_t tmp134;
+      tmp134 = static_cast<uint8_t>(mods);
+      buf.Write(&tmp134);
+
+      // match
+      buf.Write(&match);
+
+      // virtualMod
+      uint8_t tmp135;
+      tmp135 = static_cast<uint8_t>(virtualMod);
+      buf.Write(&tmp135);
+
+      // flags
+      buf.Write(&flags);
+
+      // action
+      {
+        auto& type = action.type;
+        auto& data = action.data;
+        size_t data_len = data.size();
+
+        // type
+        uint8_t tmp136;
+        tmp136 = static_cast<uint8_t>(type);
+        buf.Write(&tmp136);
+
+        // data
+        for (auto& data_elem : data) {
+          // data_elem
+          buf.Write(&data_elem);
+        }
+      }
+    }
+  }
+
+  // groupMaps
+  DCHECK_EQ(static_cast<size_t>(PopCount(groups)), groupMaps.size());
+  for (auto& groupMaps_elem : groupMaps) {
+    // groupMaps_elem
+    {
+      auto& mask = groupMaps_elem.mask;
+      auto& realMods = groupMaps_elem.realMods;
+      auto& vmods = groupMaps_elem.vmods;
+
+      // mask
+      uint8_t tmp137;
+      tmp137 = static_cast<uint8_t>(mask);
+      buf.Write(&tmp137);
+
+      // realMods
+      uint8_t tmp138;
+      tmp138 = static_cast<uint8_t>(realMods);
+      buf.Write(&tmp138);
+
+      // vmods
+      uint16_t tmp139;
+      tmp139 = static_cast<uint16_t>(vmods);
+      buf.Write(&tmp139);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::SetCompatMap", false);
+}
+
+Future<void> Xkb::SetCompatMap(const DeviceSpec& deviceSpec,
+                               const uint8_t& recomputeActions,
+                               const uint8_t& truncateSI,
+                               const SetOfGroup& groups,
+                               const uint16_t& firstSI,
+                               const std::vector<SymInterpret>& si,
+                               const std::vector<ModDef>& groupMaps) {
+  return Xkb::SetCompatMap(
+      Xkb::SetCompatMapRequest{deviceSpec, recomputeActions, truncateSI, groups,
+                               firstSI, si, groupMaps});
+}
+
+Future<Xkb::GetIndicatorStateReply> Xkb::GetIndicatorState(
+    const Xkb::GetIndicatorStateRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetIndicatorStateReply>(
+      &buf, "Xkb::GetIndicatorState", false);
+}
+
+Future<Xkb::GetIndicatorStateReply> Xkb::GetIndicatorState(
+    const DeviceSpec& deviceSpec) {
+  return Xkb::GetIndicatorState(Xkb::GetIndicatorStateRequest{deviceSpec});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetIndicatorStateReply> detail::ReadReply<
+    Xkb::GetIndicatorStateReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetIndicatorStateReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& state = (*reply).state;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // state
+  Read(&state, &buf);
+
+  // pad0
+  Pad(&buf, 20);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xkb::GetIndicatorMapReply> Xkb::GetIndicatorMap(
+    const Xkb::GetIndicatorMapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& which = request.which;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // which
+  buf.Write(&which);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetIndicatorMapReply>(
+      &buf, "Xkb::GetIndicatorMap", false);
+}
+
+Future<Xkb::GetIndicatorMapReply> Xkb::GetIndicatorMap(
+    const DeviceSpec& deviceSpec,
+    const uint32_t& which) {
+  return Xkb::GetIndicatorMap(Xkb::GetIndicatorMapRequest{deviceSpec, which});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetIndicatorMapReply> detail::ReadReply<
+    Xkb::GetIndicatorMapReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetIndicatorMapReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& which = (*reply).which;
+  auto& realIndicators = (*reply).realIndicators;
+  auto& nIndicators = (*reply).nIndicators;
+  auto& maps = (*reply).maps;
+  size_t maps_len = maps.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // which
+  Read(&which, &buf);
+
+  // realIndicators
+  Read(&realIndicators, &buf);
+
+  // nIndicators
+  Read(&nIndicators, &buf);
+
+  // pad0
+  Pad(&buf, 15);
+
+  // maps
+  maps.resize(PopCount(which));
+  for (auto& maps_elem : maps) {
+    // maps_elem
+    {
+      auto& flags = maps_elem.flags;
+      auto& whichGroups = maps_elem.whichGroups;
+      auto& groups = maps_elem.groups;
+      auto& whichMods = maps_elem.whichMods;
+      auto& mods = maps_elem.mods;
+      auto& realMods = maps_elem.realMods;
+      auto& vmods = maps_elem.vmods;
+      auto& ctrls = maps_elem.ctrls;
+
+      // flags
+      uint8_t tmp140;
+      Read(&tmp140, &buf);
+      flags = static_cast<Xkb::IMFlag>(tmp140);
+
+      // whichGroups
+      uint8_t tmp141;
+      Read(&tmp141, &buf);
+      whichGroups = static_cast<Xkb::IMGroupsWhich>(tmp141);
+
+      // groups
+      uint8_t tmp142;
+      Read(&tmp142, &buf);
+      groups = static_cast<Xkb::SetOfGroup>(tmp142);
+
+      // whichMods
+      uint8_t tmp143;
+      Read(&tmp143, &buf);
+      whichMods = static_cast<Xkb::IMModsWhich>(tmp143);
+
+      // mods
+      uint8_t tmp144;
+      Read(&tmp144, &buf);
+      mods = static_cast<ModMask>(tmp144);
+
+      // realMods
+      uint8_t tmp145;
+      Read(&tmp145, &buf);
+      realMods = static_cast<ModMask>(tmp145);
+
+      // vmods
+      uint16_t tmp146;
+      Read(&tmp146, &buf);
+      vmods = static_cast<Xkb::VMod>(tmp146);
+
+      // ctrls
+      uint32_t tmp147;
+      Read(&tmp147, &buf);
+      ctrls = static_cast<Xkb::BoolCtrl>(tmp147);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::SetIndicatorMap(const Xkb::SetIndicatorMapRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& which = request.which;
+  auto& maps = request.maps;
+  size_t maps_len = maps.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // which
+  buf.Write(&which);
+
+  // maps
+  DCHECK_EQ(static_cast<size_t>(PopCount(which)), maps.size());
+  for (auto& maps_elem : maps) {
+    // maps_elem
+    {
+      auto& flags = maps_elem.flags;
+      auto& whichGroups = maps_elem.whichGroups;
+      auto& groups = maps_elem.groups;
+      auto& whichMods = maps_elem.whichMods;
+      auto& mods = maps_elem.mods;
+      auto& realMods = maps_elem.realMods;
+      auto& vmods = maps_elem.vmods;
+      auto& ctrls = maps_elem.ctrls;
+
+      // flags
+      uint8_t tmp148;
+      tmp148 = static_cast<uint8_t>(flags);
+      buf.Write(&tmp148);
+
+      // whichGroups
+      uint8_t tmp149;
+      tmp149 = static_cast<uint8_t>(whichGroups);
+      buf.Write(&tmp149);
+
+      // groups
+      uint8_t tmp150;
+      tmp150 = static_cast<uint8_t>(groups);
+      buf.Write(&tmp150);
+
+      // whichMods
+      uint8_t tmp151;
+      tmp151 = static_cast<uint8_t>(whichMods);
+      buf.Write(&tmp151);
+
+      // mods
+      uint8_t tmp152;
+      tmp152 = static_cast<uint8_t>(mods);
+      buf.Write(&tmp152);
+
+      // realMods
+      uint8_t tmp153;
+      tmp153 = static_cast<uint8_t>(realMods);
+      buf.Write(&tmp153);
+
+      // vmods
+      uint16_t tmp154;
+      tmp154 = static_cast<uint16_t>(vmods);
+      buf.Write(&tmp154);
+
+      // ctrls
+      uint32_t tmp155;
+      tmp155 = static_cast<uint32_t>(ctrls);
+      buf.Write(&tmp155);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::SetIndicatorMap", false);
+}
+
+Future<void> Xkb::SetIndicatorMap(const DeviceSpec& deviceSpec,
+                                  const uint32_t& which,
+                                  const std::vector<IndicatorMap>& maps) {
+  return Xkb::SetIndicatorMap(
+      Xkb::SetIndicatorMapRequest{deviceSpec, which, maps});
+}
+
+Future<Xkb::GetNamedIndicatorReply> Xkb::GetNamedIndicator(
+    const Xkb::GetNamedIndicatorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& ledClass = request.ledClass;
+  auto& ledID = request.ledID;
+  auto& indicator = request.indicator;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // ledClass
+  uint16_t tmp156;
+  tmp156 = static_cast<uint16_t>(ledClass);
+  buf.Write(&tmp156);
+
+  // ledID
+  buf.Write(&ledID);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // indicator
+  buf.Write(&indicator);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetNamedIndicatorReply>(
+      &buf, "Xkb::GetNamedIndicator", false);
+}
+
+Future<Xkb::GetNamedIndicatorReply> Xkb::GetNamedIndicator(
+    const DeviceSpec& deviceSpec,
+    const LedClass& ledClass,
+    const IDSpec& ledID,
+    const Atom& indicator) {
+  return Xkb::GetNamedIndicator(
+      Xkb::GetNamedIndicatorRequest{deviceSpec, ledClass, ledID, indicator});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetNamedIndicatorReply> detail::ReadReply<
+    Xkb::GetNamedIndicatorReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetNamedIndicatorReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& indicator = (*reply).indicator;
+  auto& found = (*reply).found;
+  auto& on = (*reply).on;
+  auto& realIndicator = (*reply).realIndicator;
+  auto& ndx = (*reply).ndx;
+  auto& map_flags = (*reply).map_flags;
+  auto& map_whichGroups = (*reply).map_whichGroups;
+  auto& map_groups = (*reply).map_groups;
+  auto& map_whichMods = (*reply).map_whichMods;
+  auto& map_mods = (*reply).map_mods;
+  auto& map_realMods = (*reply).map_realMods;
+  auto& map_vmod = (*reply).map_vmod;
+  auto& map_ctrls = (*reply).map_ctrls;
+  auto& supported = (*reply).supported;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // indicator
+  Read(&indicator, &buf);
+
+  // found
+  Read(&found, &buf);
+
+  // on
+  Read(&on, &buf);
+
+  // realIndicator
+  Read(&realIndicator, &buf);
+
+  // ndx
+  Read(&ndx, &buf);
+
+  // map_flags
+  uint8_t tmp157;
+  Read(&tmp157, &buf);
+  map_flags = static_cast<Xkb::IMFlag>(tmp157);
+
+  // map_whichGroups
+  uint8_t tmp158;
+  Read(&tmp158, &buf);
+  map_whichGroups = static_cast<Xkb::IMGroupsWhich>(tmp158);
+
+  // map_groups
+  uint8_t tmp159;
+  Read(&tmp159, &buf);
+  map_groups = static_cast<Xkb::SetOfGroups>(tmp159);
+
+  // map_whichMods
+  uint8_t tmp160;
+  Read(&tmp160, &buf);
+  map_whichMods = static_cast<Xkb::IMModsWhich>(tmp160);
+
+  // map_mods
+  uint8_t tmp161;
+  Read(&tmp161, &buf);
+  map_mods = static_cast<ModMask>(tmp161);
+
+  // map_realMods
+  uint8_t tmp162;
+  Read(&tmp162, &buf);
+  map_realMods = static_cast<ModMask>(tmp162);
+
+  // map_vmod
+  uint16_t tmp163;
+  Read(&tmp163, &buf);
+  map_vmod = static_cast<Xkb::VMod>(tmp163);
+
+  // map_ctrls
+  uint32_t tmp164;
+  Read(&tmp164, &buf);
+  map_ctrls = static_cast<Xkb::BoolCtrl>(tmp164);
+
+  // supported
+  Read(&supported, &buf);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::SetNamedIndicator(
+    const Xkb::SetNamedIndicatorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& ledClass = request.ledClass;
+  auto& ledID = request.ledID;
+  auto& indicator = request.indicator;
+  auto& setState = request.setState;
+  auto& on = request.on;
+  auto& setMap = request.setMap;
+  auto& createMap = request.createMap;
+  auto& map_flags = request.map_flags;
+  auto& map_whichGroups = request.map_whichGroups;
+  auto& map_groups = request.map_groups;
+  auto& map_whichMods = request.map_whichMods;
+  auto& map_realMods = request.map_realMods;
+  auto& map_vmods = request.map_vmods;
+  auto& map_ctrls = request.map_ctrls;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // ledClass
+  uint16_t tmp165;
+  tmp165 = static_cast<uint16_t>(ledClass);
+  buf.Write(&tmp165);
+
+  // ledID
+  buf.Write(&ledID);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // indicator
+  buf.Write(&indicator);
+
+  // setState
+  buf.Write(&setState);
+
+  // on
+  buf.Write(&on);
+
+  // setMap
+  buf.Write(&setMap);
+
+  // createMap
+  buf.Write(&createMap);
+
+  // pad1
+  Pad(&buf, 1);
+
+  // map_flags
+  uint8_t tmp166;
+  tmp166 = static_cast<uint8_t>(map_flags);
+  buf.Write(&tmp166);
+
+  // map_whichGroups
+  uint8_t tmp167;
+  tmp167 = static_cast<uint8_t>(map_whichGroups);
+  buf.Write(&tmp167);
+
+  // map_groups
+  uint8_t tmp168;
+  tmp168 = static_cast<uint8_t>(map_groups);
+  buf.Write(&tmp168);
+
+  // map_whichMods
+  uint8_t tmp169;
+  tmp169 = static_cast<uint8_t>(map_whichMods);
+  buf.Write(&tmp169);
+
+  // map_realMods
+  uint8_t tmp170;
+  tmp170 = static_cast<uint8_t>(map_realMods);
+  buf.Write(&tmp170);
+
+  // map_vmods
+  uint16_t tmp171;
+  tmp171 = static_cast<uint16_t>(map_vmods);
+  buf.Write(&tmp171);
+
+  // map_ctrls
+  uint32_t tmp172;
+  tmp172 = static_cast<uint32_t>(map_ctrls);
+  buf.Write(&tmp172);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::SetNamedIndicator", false);
+}
+
+Future<void> Xkb::SetNamedIndicator(const DeviceSpec& deviceSpec,
+                                    const LedClass& ledClass,
+                                    const IDSpec& ledID,
+                                    const Atom& indicator,
+                                    const uint8_t& setState,
+                                    const uint8_t& on,
+                                    const uint8_t& setMap,
+                                    const uint8_t& createMap,
+                                    const IMFlag& map_flags,
+                                    const IMGroupsWhich& map_whichGroups,
+                                    const SetOfGroups& map_groups,
+                                    const IMModsWhich& map_whichMods,
+                                    const ModMask& map_realMods,
+                                    const VMod& map_vmods,
+                                    const BoolCtrl& map_ctrls) {
+  return Xkb::SetNamedIndicator(Xkb::SetNamedIndicatorRequest{
+      deviceSpec, ledClass, ledID, indicator, setState, on, setMap, createMap,
+      map_flags, map_whichGroups, map_groups, map_whichMods, map_realMods,
+      map_vmods, map_ctrls});
+}
+
+Future<Xkb::GetNamesReply> Xkb::GetNames(const Xkb::GetNamesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& which = request.which;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // which
+  uint32_t tmp173;
+  tmp173 = static_cast<uint32_t>(which);
+  buf.Write(&tmp173);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetNamesReply>(&buf, "Xkb::GetNames",
+                                                      false);
+}
+
+Future<Xkb::GetNamesReply> Xkb::GetNames(const DeviceSpec& deviceSpec,
+                                         const NameDetail& which) {
+  return Xkb::GetNames(Xkb::GetNamesRequest{deviceSpec, which});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetNamesReply> detail::ReadReply<Xkb::GetNamesReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetNamesReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  Xkb::NameDetail which{};
+  auto& minKeyCode = (*reply).minKeyCode;
+  auto& maxKeyCode = (*reply).maxKeyCode;
+  auto& nTypes = (*reply).nTypes;
+  auto& groupNames = (*reply).groupNames;
+  auto& virtualMods = (*reply).virtualMods;
+  auto& firstKey = (*reply).firstKey;
+  auto& nKeys = (*reply).nKeys;
+  auto& indicators = (*reply).indicators;
+  auto& nRadioGroups = (*reply).nRadioGroups;
+  auto& nKeyAliases = (*reply).nKeyAliases;
+  auto& nKTLevels = (*reply).nKTLevels;
+  auto& valueList = (*reply);
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // which
+  uint32_t tmp174;
+  Read(&tmp174, &buf);
+  which = static_cast<Xkb::NameDetail>(tmp174);
+
+  // minKeyCode
+  Read(&minKeyCode, &buf);
+
+  // maxKeyCode
+  Read(&maxKeyCode, &buf);
+
+  // nTypes
+  Read(&nTypes, &buf);
+
+  // groupNames
+  uint8_t tmp175;
+  Read(&tmp175, &buf);
+  groupNames = static_cast<Xkb::SetOfGroup>(tmp175);
+
+  // virtualMods
+  uint16_t tmp176;
+  Read(&tmp176, &buf);
+  virtualMods = static_cast<Xkb::VMod>(tmp176);
+
+  // firstKey
+  Read(&firstKey, &buf);
+
+  // nKeys
+  Read(&nKeys, &buf);
+
+  // indicators
+  Read(&indicators, &buf);
+
+  // nRadioGroups
+  Read(&nRadioGroups, &buf);
+
+  // nKeyAliases
+  Read(&nKeyAliases, &buf);
+
+  // nKTLevels
+  Read(&nKTLevels, &buf);
+
+  // pad0
+  Pad(&buf, 4);
+
+  // valueList
+  auto valueList_expr = which;
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::Keycodes)) {
+    valueList.keycodesName.emplace();
+    auto& keycodesName = *valueList.keycodesName;
+
+    // keycodesName
+    Read(&keycodesName, &buf);
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::Geometry)) {
+    valueList.geometryName.emplace();
+    auto& geometryName = *valueList.geometryName;
+
+    // geometryName
+    Read(&geometryName, &buf);
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::Symbols)) {
+    valueList.symbolsName.emplace();
+    auto& symbolsName = *valueList.symbolsName;
+
+    // symbolsName
+    Read(&symbolsName, &buf);
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::PhysSymbols)) {
+    valueList.physSymbolsName.emplace();
+    auto& physSymbolsName = *valueList.physSymbolsName;
+
+    // physSymbolsName
+    Read(&physSymbolsName, &buf);
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::Types)) {
+    valueList.typesName.emplace();
+    auto& typesName = *valueList.typesName;
+
+    // typesName
+    Read(&typesName, &buf);
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::Compat)) {
+    valueList.compatName.emplace();
+    auto& compatName = *valueList.compatName;
+
+    // compatName
+    Read(&compatName, &buf);
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::KeyTypeNames)) {
+    valueList.typeNames.emplace();
+    auto& typeNames = *valueList.typeNames;
+    size_t typeNames_len = typeNames.size();
+
+    // typeNames
+    typeNames.resize(nTypes);
+    for (auto& typeNames_elem : typeNames) {
+      // typeNames_elem
+      Read(&typeNames_elem, &buf);
+    }
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::KTLevelNames)) {
+    valueList.nLevelsPerType.emplace();
+    valueList.ktLevelNames.emplace();
+    auto& nLevelsPerType = *valueList.nLevelsPerType;
+    size_t nLevelsPerType_len = nLevelsPerType.size();
+    auto& ktLevelNames = *valueList.ktLevelNames;
+    size_t ktLevelNames_len = ktLevelNames.size();
+
+    // nLevelsPerType
+    nLevelsPerType.resize(nTypes);
+    for (auto& nLevelsPerType_elem : nLevelsPerType) {
+      // nLevelsPerType_elem
+      Read(&nLevelsPerType_elem, &buf);
+    }
+
+    // pad1
+    Align(&buf, 4);
+
+    // ktLevelNames
+    auto sum177_ =
+        SumOf([](auto& listelem_ref) { return listelem_ref; }, nLevelsPerType);
+    ktLevelNames.resize(sum177_);
+    for (auto& ktLevelNames_elem : ktLevelNames) {
+      // ktLevelNames_elem
+      Read(&ktLevelNames_elem, &buf);
+    }
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::IndicatorNames)) {
+    valueList.indicatorNames.emplace();
+    auto& indicatorNames = *valueList.indicatorNames;
+    size_t indicatorNames_len = indicatorNames.size();
+
+    // indicatorNames
+    indicatorNames.resize(PopCount(indicators));
+    for (auto& indicatorNames_elem : indicatorNames) {
+      // indicatorNames_elem
+      Read(&indicatorNames_elem, &buf);
+    }
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::VirtualModNames)) {
+    valueList.virtualModNames.emplace();
+    auto& virtualModNames = *valueList.virtualModNames;
+    size_t virtualModNames_len = virtualModNames.size();
+
+    // virtualModNames
+    virtualModNames.resize(PopCount(virtualMods));
+    for (auto& virtualModNames_elem : virtualModNames) {
+      // virtualModNames_elem
+      Read(&virtualModNames_elem, &buf);
+    }
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::GroupNames)) {
+    valueList.groups.emplace();
+    auto& groups = *valueList.groups;
+    size_t groups_len = groups.size();
+
+    // groups
+    groups.resize(PopCount(groupNames));
+    for (auto& groups_elem : groups) {
+      // groups_elem
+      Read(&groups_elem, &buf);
+    }
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::KeyNames)) {
+    valueList.keyNames.emplace();
+    auto& keyNames = *valueList.keyNames;
+    size_t keyNames_len = keyNames.size();
+
+    // keyNames
+    keyNames.resize(nKeys);
+    for (auto& keyNames_elem : keyNames) {
+      // keyNames_elem
+      {
+        auto& name = keyNames_elem.name;
+        size_t name_len = name.size();
+
+        // name
+        for (auto& name_elem : name) {
+          // name_elem
+          Read(&name_elem, &buf);
+        }
+      }
+    }
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::KeyAliases)) {
+    valueList.keyAliases.emplace();
+    auto& keyAliases = *valueList.keyAliases;
+    size_t keyAliases_len = keyAliases.size();
+
+    // keyAliases
+    keyAliases.resize(nKeyAliases);
+    for (auto& keyAliases_elem : keyAliases) {
+      // keyAliases_elem
+      {
+        auto& real = keyAliases_elem.real;
+        size_t real_len = real.size();
+        auto& alias = keyAliases_elem.alias;
+        size_t alias_len = alias.size();
+
+        // real
+        for (auto& real_elem : real) {
+          // real_elem
+          Read(&real_elem, &buf);
+        }
+
+        // alias
+        for (auto& alias_elem : alias) {
+          // alias_elem
+          Read(&alias_elem, &buf);
+        }
+      }
+    }
+  }
+  if (CaseAnd(valueList_expr, Xkb::NameDetail::RGNames)) {
+    valueList.radioGroupNames.emplace();
+    auto& radioGroupNames = *valueList.radioGroupNames;
+    size_t radioGroupNames_len = radioGroupNames.size();
+
+    // radioGroupNames
+    radioGroupNames.resize(nRadioGroups);
+    for (auto& radioGroupNames_elem : radioGroupNames) {
+      // radioGroupNames_elem
+      Read(&radioGroupNames_elem, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::SetNames(const Xkb::SetNamesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& virtualMods = request.virtualMods;
+  NameDetail which{};
+  auto& firstType = request.firstType;
+  auto& nTypes = request.nTypes;
+  auto& firstKTLevelt = request.firstKTLevelt;
+  auto& nKTLevels = request.nKTLevels;
+  auto& indicators = request.indicators;
+  auto& groupNames = request.groupNames;
+  auto& nRadioGroups = request.nRadioGroups;
+  auto& firstKey = request.firstKey;
+  auto& nKeys = request.nKeys;
+  auto& nKeyAliases = request.nKeyAliases;
+  auto& totalKTLevelNames = request.totalKTLevelNames;
+  auto& values = request;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // virtualMods
+  uint16_t tmp178;
+  tmp178 = static_cast<uint16_t>(virtualMods);
+  buf.Write(&tmp178);
+
+  // which
+  SwitchVar(NameDetail::Keycodes, values.keycodesName.has_value(), true,
+            &which);
+  SwitchVar(NameDetail::Geometry, values.geometryName.has_value(), true,
+            &which);
+  SwitchVar(NameDetail::Symbols, values.symbolsName.has_value(), true, &which);
+  SwitchVar(NameDetail::PhysSymbols, values.physSymbolsName.has_value(), true,
+            &which);
+  SwitchVar(NameDetail::Types, values.typesName.has_value(), true, &which);
+  SwitchVar(NameDetail::Compat, values.compatName.has_value(), true, &which);
+  SwitchVar(NameDetail::KeyTypeNames, values.typeNames.has_value(), true,
+            &which);
+  SwitchVar(NameDetail::KTLevelNames, values.nLevelsPerType.has_value(), true,
+            &which);
+  SwitchVar(NameDetail::IndicatorNames, values.indicatorNames.has_value(), true,
+            &which);
+  SwitchVar(NameDetail::VirtualModNames, values.virtualModNames.has_value(),
+            true, &which);
+  SwitchVar(NameDetail::GroupNames, values.groups.has_value(), true, &which);
+  SwitchVar(NameDetail::KeyNames, values.keyNames.has_value(), true, &which);
+  SwitchVar(NameDetail::KeyAliases, values.keyAliases.has_value(), true,
+            &which);
+  SwitchVar(NameDetail::RGNames, values.radioGroupNames.has_value(), true,
+            &which);
+  uint32_t tmp179;
+  tmp179 = static_cast<uint32_t>(which);
+  buf.Write(&tmp179);
+
+  // firstType
+  buf.Write(&firstType);
+
+  // nTypes
+  buf.Write(&nTypes);
+
+  // firstKTLevelt
+  buf.Write(&firstKTLevelt);
+
+  // nKTLevels
+  buf.Write(&nKTLevels);
+
+  // indicators
+  buf.Write(&indicators);
+
+  // groupNames
+  uint8_t tmp180;
+  tmp180 = static_cast<uint8_t>(groupNames);
+  buf.Write(&tmp180);
+
+  // nRadioGroups
+  buf.Write(&nRadioGroups);
+
+  // firstKey
+  buf.Write(&firstKey);
+
+  // nKeys
+  buf.Write(&nKeys);
+
+  // nKeyAliases
+  buf.Write(&nKeyAliases);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // totalKTLevelNames
+  buf.Write(&totalKTLevelNames);
+
+  // values
+  auto values_expr = which;
+  if (CaseAnd(values_expr, NameDetail::Keycodes)) {
+    auto& keycodesName = *values.keycodesName;
+
+    // keycodesName
+    buf.Write(&keycodesName);
+  }
+  if (CaseAnd(values_expr, NameDetail::Geometry)) {
+    auto& geometryName = *values.geometryName;
+
+    // geometryName
+    buf.Write(&geometryName);
+  }
+  if (CaseAnd(values_expr, NameDetail::Symbols)) {
+    auto& symbolsName = *values.symbolsName;
+
+    // symbolsName
+    buf.Write(&symbolsName);
+  }
+  if (CaseAnd(values_expr, NameDetail::PhysSymbols)) {
+    auto& physSymbolsName = *values.physSymbolsName;
+
+    // physSymbolsName
+    buf.Write(&physSymbolsName);
+  }
+  if (CaseAnd(values_expr, NameDetail::Types)) {
+    auto& typesName = *values.typesName;
+
+    // typesName
+    buf.Write(&typesName);
+  }
+  if (CaseAnd(values_expr, NameDetail::Compat)) {
+    auto& compatName = *values.compatName;
+
+    // compatName
+    buf.Write(&compatName);
+  }
+  if (CaseAnd(values_expr, NameDetail::KeyTypeNames)) {
+    auto& typeNames = *values.typeNames;
+    size_t typeNames_len = typeNames.size();
+
+    // typeNames
+    DCHECK_EQ(static_cast<size_t>(nTypes), typeNames.size());
+    for (auto& typeNames_elem : typeNames) {
+      // typeNames_elem
+      buf.Write(&typeNames_elem);
+    }
+  }
+  if (CaseAnd(values_expr, NameDetail::KTLevelNames)) {
+    auto& nLevelsPerType = *values.nLevelsPerType;
+    size_t nLevelsPerType_len = nLevelsPerType.size();
+    auto& ktLevelNames = *values.ktLevelNames;
+    size_t ktLevelNames_len = ktLevelNames.size();
+
+    // nLevelsPerType
+    DCHECK_EQ(static_cast<size_t>(nTypes), nLevelsPerType.size());
+    for (auto& nLevelsPerType_elem : nLevelsPerType) {
+      // nLevelsPerType_elem
+      buf.Write(&nLevelsPerType_elem);
+    }
+
+    // pad1
+    Align(&buf, 4);
+
+    // ktLevelNames
+    auto sum181_ = SumOf([](const auto& listelem_ref) { return listelem_ref; },
+                         nLevelsPerType);
+    DCHECK_EQ(static_cast<size_t>(sum181_), ktLevelNames.size());
+    for (auto& ktLevelNames_elem : ktLevelNames) {
+      // ktLevelNames_elem
+      buf.Write(&ktLevelNames_elem);
+    }
+  }
+  if (CaseAnd(values_expr, NameDetail::IndicatorNames)) {
+    auto& indicatorNames = *values.indicatorNames;
+    size_t indicatorNames_len = indicatorNames.size();
+
+    // indicatorNames
+    DCHECK_EQ(static_cast<size_t>(PopCount(indicators)), indicatorNames.size());
+    for (auto& indicatorNames_elem : indicatorNames) {
+      // indicatorNames_elem
+      buf.Write(&indicatorNames_elem);
+    }
+  }
+  if (CaseAnd(values_expr, NameDetail::VirtualModNames)) {
+    auto& virtualModNames = *values.virtualModNames;
+    size_t virtualModNames_len = virtualModNames.size();
+
+    // virtualModNames
+    DCHECK_EQ(static_cast<size_t>(PopCount(virtualMods)),
+              virtualModNames.size());
+    for (auto& virtualModNames_elem : virtualModNames) {
+      // virtualModNames_elem
+      buf.Write(&virtualModNames_elem);
+    }
+  }
+  if (CaseAnd(values_expr, NameDetail::GroupNames)) {
+    auto& groups = *values.groups;
+    size_t groups_len = groups.size();
+
+    // groups
+    DCHECK_EQ(static_cast<size_t>(PopCount(groupNames)), groups.size());
+    for (auto& groups_elem : groups) {
+      // groups_elem
+      buf.Write(&groups_elem);
+    }
+  }
+  if (CaseAnd(values_expr, NameDetail::KeyNames)) {
+    auto& keyNames = *values.keyNames;
+    size_t keyNames_len = keyNames.size();
+
+    // keyNames
+    DCHECK_EQ(static_cast<size_t>(nKeys), keyNames.size());
+    for (auto& keyNames_elem : keyNames) {
+      // keyNames_elem
+      {
+        auto& name = keyNames_elem.name;
+        size_t name_len = name.size();
+
+        // name
+        for (auto& name_elem : name) {
+          // name_elem
+          buf.Write(&name_elem);
+        }
+      }
+    }
+  }
+  if (CaseAnd(values_expr, NameDetail::KeyAliases)) {
+    auto& keyAliases = *values.keyAliases;
+    size_t keyAliases_len = keyAliases.size();
+
+    // keyAliases
+    DCHECK_EQ(static_cast<size_t>(nKeyAliases), keyAliases.size());
+    for (auto& keyAliases_elem : keyAliases) {
+      // keyAliases_elem
+      {
+        auto& real = keyAliases_elem.real;
+        size_t real_len = real.size();
+        auto& alias = keyAliases_elem.alias;
+        size_t alias_len = alias.size();
+
+        // real
+        for (auto& real_elem : real) {
+          // real_elem
+          buf.Write(&real_elem);
+        }
+
+        // alias
+        for (auto& alias_elem : alias) {
+          // alias_elem
+          buf.Write(&alias_elem);
+        }
+      }
+    }
+  }
+  if (CaseAnd(values_expr, NameDetail::RGNames)) {
+    auto& radioGroupNames = *values.radioGroupNames;
+    size_t radioGroupNames_len = radioGroupNames.size();
+
+    // radioGroupNames
+    DCHECK_EQ(static_cast<size_t>(nRadioGroups), radioGroupNames.size());
+    for (auto& radioGroupNames_elem : radioGroupNames) {
+      // radioGroupNames_elem
+      buf.Write(&radioGroupNames_elem);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::SetNames", false);
+}
+
+Future<void> Xkb::SetNames(
+    const DeviceSpec& deviceSpec,
+    const VMod& virtualMods,
+    const uint8_t& firstType,
+    const uint8_t& nTypes,
+    const uint8_t& firstKTLevelt,
+    const uint8_t& nKTLevels,
+    const uint32_t& indicators,
+    const SetOfGroup& groupNames,
+    const uint8_t& nRadioGroups,
+    const KeyCode& firstKey,
+    const uint8_t& nKeys,
+    const uint8_t& nKeyAliases,
+    const uint16_t& totalKTLevelNames,
+    const absl::optional<Atom>& keycodesName,
+    const absl::optional<Atom>& geometryName,
+    const absl::optional<Atom>& symbolsName,
+    const absl::optional<Atom>& physSymbolsName,
+    const absl::optional<Atom>& typesName,
+    const absl::optional<Atom>& compatName,
+    const absl::optional<std::vector<Atom>>& typeNames,
+    const absl::optional<std::vector<uint8_t>>& nLevelsPerType,
+    const absl::optional<std::vector<Atom>>& ktLevelNames,
+    const absl::optional<std::vector<Atom>>& indicatorNames,
+    const absl::optional<std::vector<Atom>>& virtualModNames,
+    const absl::optional<std::vector<Atom>>& groups,
+    const absl::optional<std::vector<KeyName>>& keyNames,
+    const absl::optional<std::vector<KeyAlias>>& keyAliases,
+    const absl::optional<std::vector<Atom>>& radioGroupNames) {
+  return Xkb::SetNames(Xkb::SetNamesRequest{deviceSpec,
+                                            virtualMods,
+                                            firstType,
+                                            nTypes,
+                                            firstKTLevelt,
+                                            nKTLevels,
+                                            indicators,
+                                            groupNames,
+                                            nRadioGroups,
+                                            firstKey,
+                                            nKeys,
+                                            nKeyAliases,
+                                            totalKTLevelNames,
+                                            keycodesName,
+                                            geometryName,
+                                            symbolsName,
+                                            physSymbolsName,
+                                            typesName,
+                                            compatName,
+                                            typeNames,
+                                            nLevelsPerType,
+                                            ktLevelNames,
+                                            indicatorNames,
+                                            virtualModNames,
+                                            groups,
+                                            keyNames,
+                                            keyAliases,
+                                            radioGroupNames});
+}
+
+Future<Xkb::PerClientFlagsReply> Xkb::PerClientFlags(
+    const Xkb::PerClientFlagsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& change = request.change;
+  auto& value = request.value;
+  auto& ctrlsToChange = request.ctrlsToChange;
+  auto& autoCtrls = request.autoCtrls;
+  auto& autoCtrlsValues = request.autoCtrlsValues;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 21;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // change
+  uint32_t tmp182;
+  tmp182 = static_cast<uint32_t>(change);
+  buf.Write(&tmp182);
+
+  // value
+  uint32_t tmp183;
+  tmp183 = static_cast<uint32_t>(value);
+  buf.Write(&tmp183);
+
+  // ctrlsToChange
+  uint32_t tmp184;
+  tmp184 = static_cast<uint32_t>(ctrlsToChange);
+  buf.Write(&tmp184);
+
+  // autoCtrls
+  uint32_t tmp185;
+  tmp185 = static_cast<uint32_t>(autoCtrls);
+  buf.Write(&tmp185);
+
+  // autoCtrlsValues
+  uint32_t tmp186;
+  tmp186 = static_cast<uint32_t>(autoCtrlsValues);
+  buf.Write(&tmp186);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::PerClientFlagsReply>(
+      &buf, "Xkb::PerClientFlags", false);
+}
+
+Future<Xkb::PerClientFlagsReply> Xkb::PerClientFlags(
+    const DeviceSpec& deviceSpec,
+    const PerClientFlag& change,
+    const PerClientFlag& value,
+    const BoolCtrl& ctrlsToChange,
+    const BoolCtrl& autoCtrls,
+    const BoolCtrl& autoCtrlsValues) {
+  return Xkb::PerClientFlags(Xkb::PerClientFlagsRequest{
+      deviceSpec, change, value, ctrlsToChange, autoCtrls, autoCtrlsValues});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::PerClientFlagsReply> detail::ReadReply<
+    Xkb::PerClientFlagsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::PerClientFlagsReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& supported = (*reply).supported;
+  auto& value = (*reply).value;
+  auto& autoCtrls = (*reply).autoCtrls;
+  auto& autoCtrlsValues = (*reply).autoCtrlsValues;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // supported
+  uint32_t tmp187;
+  Read(&tmp187, &buf);
+  supported = static_cast<Xkb::PerClientFlag>(tmp187);
+
+  // value
+  uint32_t tmp188;
+  Read(&tmp188, &buf);
+  value = static_cast<Xkb::PerClientFlag>(tmp188);
+
+  // autoCtrls
+  uint32_t tmp189;
+  Read(&tmp189, &buf);
+  autoCtrls = static_cast<Xkb::BoolCtrl>(tmp189);
+
+  // autoCtrlsValues
+  uint32_t tmp190;
+  Read(&tmp190, &buf);
+  autoCtrlsValues = static_cast<Xkb::BoolCtrl>(tmp190);
+
+  // pad0
+  Pad(&buf, 8);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xkb::ListComponentsReply> Xkb::ListComponents(
+    const Xkb::ListComponentsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& maxNames = request.maxNames;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 22;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // maxNames
+  buf.Write(&maxNames);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::ListComponentsReply>(
+      &buf, "Xkb::ListComponents", false);
+}
+
+Future<Xkb::ListComponentsReply> Xkb::ListComponents(
+    const DeviceSpec& deviceSpec,
+    const uint16_t& maxNames) {
+  return Xkb::ListComponents(Xkb::ListComponentsRequest{deviceSpec, maxNames});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::ListComponentsReply> detail::ReadReply<
+    Xkb::ListComponentsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::ListComponentsReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  uint16_t nKeymaps{};
+  uint16_t nKeycodes{};
+  uint16_t nTypes{};
+  uint16_t nCompatMaps{};
+  uint16_t nSymbols{};
+  uint16_t nGeometries{};
+  auto& extra = (*reply).extra;
+  auto& keymaps = (*reply).keymaps;
+  size_t keymaps_len = keymaps.size();
+  auto& keycodes = (*reply).keycodes;
+  size_t keycodes_len = keycodes.size();
+  auto& types = (*reply).types;
+  size_t types_len = types.size();
+  auto& compatMaps = (*reply).compatMaps;
+  size_t compatMaps_len = compatMaps.size();
+  auto& symbols = (*reply).symbols;
+  size_t symbols_len = symbols.size();
+  auto& geometries = (*reply).geometries;
+  size_t geometries_len = geometries.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // nKeymaps
+  Read(&nKeymaps, &buf);
+
+  // nKeycodes
+  Read(&nKeycodes, &buf);
+
+  // nTypes
+  Read(&nTypes, &buf);
+
+  // nCompatMaps
+  Read(&nCompatMaps, &buf);
+
+  // nSymbols
+  Read(&nSymbols, &buf);
+
+  // nGeometries
+  Read(&nGeometries, &buf);
+
+  // extra
+  Read(&extra, &buf);
+
+  // pad0
+  Pad(&buf, 10);
+
+  // keymaps
+  keymaps.resize(nKeymaps);
+  for (auto& keymaps_elem : keymaps) {
+    // keymaps_elem
+    {
+      auto& flags = keymaps_elem.flags;
+      uint16_t length{};
+      auto& string = keymaps_elem.string;
+      size_t string_len = string.size();
+
+      // flags
+      Read(&flags, &buf);
+
+      // length
+      Read(&length, &buf);
+
+      // string
+      string.resize(length);
+      for (auto& string_elem : string) {
+        // string_elem
+        Read(&string_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 2);
+    }
+  }
+
+  // keycodes
+  keycodes.resize(nKeycodes);
+  for (auto& keycodes_elem : keycodes) {
+    // keycodes_elem
+    {
+      auto& flags = keycodes_elem.flags;
+      uint16_t length{};
+      auto& string = keycodes_elem.string;
+      size_t string_len = string.size();
+
+      // flags
+      Read(&flags, &buf);
+
+      // length
+      Read(&length, &buf);
+
+      // string
+      string.resize(length);
+      for (auto& string_elem : string) {
+        // string_elem
+        Read(&string_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 2);
+    }
+  }
+
+  // types
+  types.resize(nTypes);
+  for (auto& types_elem : types) {
+    // types_elem
+    {
+      auto& flags = types_elem.flags;
+      uint16_t length{};
+      auto& string = types_elem.string;
+      size_t string_len = string.size();
+
+      // flags
+      Read(&flags, &buf);
+
+      // length
+      Read(&length, &buf);
+
+      // string
+      string.resize(length);
+      for (auto& string_elem : string) {
+        // string_elem
+        Read(&string_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 2);
+    }
+  }
+
+  // compatMaps
+  compatMaps.resize(nCompatMaps);
+  for (auto& compatMaps_elem : compatMaps) {
+    // compatMaps_elem
+    {
+      auto& flags = compatMaps_elem.flags;
+      uint16_t length{};
+      auto& string = compatMaps_elem.string;
+      size_t string_len = string.size();
+
+      // flags
+      Read(&flags, &buf);
+
+      // length
+      Read(&length, &buf);
+
+      // string
+      string.resize(length);
+      for (auto& string_elem : string) {
+        // string_elem
+        Read(&string_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 2);
+    }
+  }
+
+  // symbols
+  symbols.resize(nSymbols);
+  for (auto& symbols_elem : symbols) {
+    // symbols_elem
+    {
+      auto& flags = symbols_elem.flags;
+      uint16_t length{};
+      auto& string = symbols_elem.string;
+      size_t string_len = string.size();
+
+      // flags
+      Read(&flags, &buf);
+
+      // length
+      Read(&length, &buf);
+
+      // string
+      string.resize(length);
+      for (auto& string_elem : string) {
+        // string_elem
+        Read(&string_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 2);
+    }
+  }
+
+  // geometries
+  geometries.resize(nGeometries);
+  for (auto& geometries_elem : geometries) {
+    // geometries_elem
+    {
+      auto& flags = geometries_elem.flags;
+      uint16_t length{};
+      auto& string = geometries_elem.string;
+      size_t string_len = string.size();
+
+      // flags
+      Read(&flags, &buf);
+
+      // length
+      Read(&length, &buf);
+
+      // string
+      string.resize(length);
+      for (auto& string_elem : string) {
+        // string_elem
+        Read(&string_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 2);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xkb::GetKbdByNameReply> Xkb::GetKbdByName(
+    const Xkb::GetKbdByNameRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& need = request.need;
+  auto& want = request.want;
+  auto& load = request.load;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 23;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // need
+  uint16_t tmp191;
+  tmp191 = static_cast<uint16_t>(need);
+  buf.Write(&tmp191);
+
+  // want
+  uint16_t tmp192;
+  tmp192 = static_cast<uint16_t>(want);
+  buf.Write(&tmp192);
+
+  // load
+  buf.Write(&load);
+
+  // pad0
+  Pad(&buf, 1);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetKbdByNameReply>(
+      &buf, "Xkb::GetKbdByName", false);
+}
+
+Future<Xkb::GetKbdByNameReply> Xkb::GetKbdByName(const DeviceSpec& deviceSpec,
+                                                 const GBNDetail& need,
+                                                 const GBNDetail& want,
+                                                 const uint8_t& load) {
+  return Xkb::GetKbdByName(
+      Xkb::GetKbdByNameRequest{deviceSpec, need, want, load});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetKbdByNameReply> detail::ReadReply<
+    Xkb::GetKbdByNameReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetKbdByNameReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& minKeyCode = (*reply).minKeyCode;
+  auto& maxKeyCode = (*reply).maxKeyCode;
+  auto& loaded = (*reply).loaded;
+  auto& newKeyboard = (*reply).newKeyboard;
+  auto& found = (*reply).found;
+  Xkb::GBNDetail reported{};
+  auto& replies = (*reply);
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // minKeyCode
+  Read(&minKeyCode, &buf);
+
+  // maxKeyCode
+  Read(&maxKeyCode, &buf);
+
+  // loaded
+  Read(&loaded, &buf);
+
+  // newKeyboard
+  Read(&newKeyboard, &buf);
+
+  // found
+  uint16_t tmp193;
+  Read(&tmp193, &buf);
+  found = static_cast<Xkb::GBNDetail>(tmp193);
+
+  // reported
+  uint16_t tmp194;
+  Read(&tmp194, &buf);
+  reported = static_cast<Xkb::GBNDetail>(tmp194);
+
+  // pad0
+  Pad(&buf, 16);
+
+  // replies
+  auto replies_expr = reported;
+  if (CaseAnd(replies_expr, Xkb::GBNDetail::Types) ||
+      CaseAnd(replies_expr, Xkb::GBNDetail::ClientSymbols) ||
+      CaseAnd(replies_expr, Xkb::GBNDetail::ServerSymbols)) {
+    replies.types.emplace();
+    auto& getmap_type = (*replies.types).getmap_type;
+    auto& typeDeviceID = (*replies.types).typeDeviceID;
+    auto& getmap_sequence = (*replies.types).getmap_sequence;
+    auto& getmap_length = (*replies.types).getmap_length;
+    auto& typeMinKeyCode = (*replies.types).typeMinKeyCode;
+    auto& typeMaxKeyCode = (*replies.types).typeMaxKeyCode;
+    Xkb::MapPart present{};
+    auto& firstType = (*replies.types).firstType;
+    auto& nTypes = (*replies.types).nTypes;
+    auto& totalTypes = (*replies.types).totalTypes;
+    auto& firstKeySym = (*replies.types).firstKeySym;
+    auto& totalSyms = (*replies.types).totalSyms;
+    auto& nKeySyms = (*replies.types).nKeySyms;
+    auto& firstKeyAction = (*replies.types).firstKeyAction;
+    auto& totalActions = (*replies.types).totalActions;
+    auto& nKeyActions = (*replies.types).nKeyActions;
+    auto& firstKeyBehavior = (*replies.types).firstKeyBehavior;
+    auto& nKeyBehaviors = (*replies.types).nKeyBehaviors;
+    auto& totalKeyBehaviors = (*replies.types).totalKeyBehaviors;
+    auto& firstKeyExplicit = (*replies.types).firstKeyExplicit;
+    auto& nKeyExplicit = (*replies.types).nKeyExplicit;
+    auto& totalKeyExplicit = (*replies.types).totalKeyExplicit;
+    auto& firstModMapKey = (*replies.types).firstModMapKey;
+    auto& nModMapKeys = (*replies.types).nModMapKeys;
+    auto& totalModMapKeys = (*replies.types).totalModMapKeys;
+    auto& firstVModMapKey = (*replies.types).firstVModMapKey;
+    auto& nVModMapKeys = (*replies.types).nVModMapKeys;
+    auto& totalVModMapKeys = (*replies.types).totalVModMapKeys;
+    auto& virtualMods = (*replies.types).virtualMods;
+    auto& map = (*replies.types);
+
+    // getmap_type
+    Read(&getmap_type, &buf);
+
+    // typeDeviceID
+    Read(&typeDeviceID, &buf);
+
+    // getmap_sequence
+    Read(&getmap_sequence, &buf);
+
+    // getmap_length
+    Read(&getmap_length, &buf);
+
+    // pad1
+    Pad(&buf, 2);
+
+    // typeMinKeyCode
+    Read(&typeMinKeyCode, &buf);
+
+    // typeMaxKeyCode
+    Read(&typeMaxKeyCode, &buf);
+
+    // present
+    uint16_t tmp195;
+    Read(&tmp195, &buf);
+    present = static_cast<Xkb::MapPart>(tmp195);
+
+    // firstType
+    Read(&firstType, &buf);
+
+    // nTypes
+    Read(&nTypes, &buf);
+
+    // totalTypes
+    Read(&totalTypes, &buf);
+
+    // firstKeySym
+    Read(&firstKeySym, &buf);
+
+    // totalSyms
+    Read(&totalSyms, &buf);
+
+    // nKeySyms
+    Read(&nKeySyms, &buf);
+
+    // firstKeyAction
+    Read(&firstKeyAction, &buf);
+
+    // totalActions
+    Read(&totalActions, &buf);
+
+    // nKeyActions
+    Read(&nKeyActions, &buf);
+
+    // firstKeyBehavior
+    Read(&firstKeyBehavior, &buf);
+
+    // nKeyBehaviors
+    Read(&nKeyBehaviors, &buf);
+
+    // totalKeyBehaviors
+    Read(&totalKeyBehaviors, &buf);
+
+    // firstKeyExplicit
+    Read(&firstKeyExplicit, &buf);
+
+    // nKeyExplicit
+    Read(&nKeyExplicit, &buf);
+
+    // totalKeyExplicit
+    Read(&totalKeyExplicit, &buf);
+
+    // firstModMapKey
+    Read(&firstModMapKey, &buf);
+
+    // nModMapKeys
+    Read(&nModMapKeys, &buf);
+
+    // totalModMapKeys
+    Read(&totalModMapKeys, &buf);
+
+    // firstVModMapKey
+    Read(&firstVModMapKey, &buf);
+
+    // nVModMapKeys
+    Read(&nVModMapKeys, &buf);
+
+    // totalVModMapKeys
+    Read(&totalVModMapKeys, &buf);
+
+    // pad2
+    Pad(&buf, 1);
+
+    // virtualMods
+    uint16_t tmp196;
+    Read(&tmp196, &buf);
+    virtualMods = static_cast<Xkb::VMod>(tmp196);
+
+    // map
+    auto map_expr = present;
+    if (CaseAnd(map_expr, Xkb::MapPart::KeyTypes)) {
+      map.types_rtrn.emplace();
+      auto& types_rtrn = *map.types_rtrn;
+      size_t types_rtrn_len = types_rtrn.size();
+
+      // types_rtrn
+      types_rtrn.resize(nTypes);
+      for (auto& types_rtrn_elem : types_rtrn) {
+        // types_rtrn_elem
+        {
+          auto& mods_mask = types_rtrn_elem.mods_mask;
+          auto& mods_mods = types_rtrn_elem.mods_mods;
+          auto& mods_vmods = types_rtrn_elem.mods_vmods;
+          auto& numLevels = types_rtrn_elem.numLevels;
+          uint8_t nMapEntries{};
+          auto& hasPreserve = types_rtrn_elem.hasPreserve;
+          auto& map = types_rtrn_elem.map;
+          size_t map_len = map.size();
+          auto& preserve = types_rtrn_elem.preserve;
+          size_t preserve_len = preserve.size();
+
+          // mods_mask
+          uint8_t tmp197;
+          Read(&tmp197, &buf);
+          mods_mask = static_cast<ModMask>(tmp197);
+
+          // mods_mods
+          uint8_t tmp198;
+          Read(&tmp198, &buf);
+          mods_mods = static_cast<ModMask>(tmp198);
+
+          // mods_vmods
+          uint16_t tmp199;
+          Read(&tmp199, &buf);
+          mods_vmods = static_cast<Xkb::VMod>(tmp199);
+
+          // numLevels
+          Read(&numLevels, &buf);
+
+          // nMapEntries
+          Read(&nMapEntries, &buf);
+
+          // hasPreserve
+          Read(&hasPreserve, &buf);
+
+          // pad0
+          Pad(&buf, 1);
+
+          // map
+          map.resize(nMapEntries);
+          for (auto& map_elem : map) {
+            // map_elem
+            {
+              auto& active = map_elem.active;
+              auto& mods_mask = map_elem.mods_mask;
+              auto& level = map_elem.level;
+              auto& mods_mods = map_elem.mods_mods;
+              auto& mods_vmods = map_elem.mods_vmods;
+
+              // active
+              Read(&active, &buf);
+
+              // mods_mask
+              uint8_t tmp200;
+              Read(&tmp200, &buf);
+              mods_mask = static_cast<ModMask>(tmp200);
+
+              // level
+              Read(&level, &buf);
+
+              // mods_mods
+              uint8_t tmp201;
+              Read(&tmp201, &buf);
+              mods_mods = static_cast<ModMask>(tmp201);
+
+              // mods_vmods
+              uint16_t tmp202;
+              Read(&tmp202, &buf);
+              mods_vmods = static_cast<Xkb::VMod>(tmp202);
+
+              // pad0
+              Pad(&buf, 2);
+            }
+          }
+
+          // preserve
+          preserve.resize((hasPreserve) * (nMapEntries));
+          for (auto& preserve_elem : preserve) {
+            // preserve_elem
+            {
+              auto& mask = preserve_elem.mask;
+              auto& realMods = preserve_elem.realMods;
+              auto& vmods = preserve_elem.vmods;
+
+              // mask
+              uint8_t tmp203;
+              Read(&tmp203, &buf);
+              mask = static_cast<ModMask>(tmp203);
+
+              // realMods
+              uint8_t tmp204;
+              Read(&tmp204, &buf);
+              realMods = static_cast<ModMask>(tmp204);
+
+              // vmods
+              uint16_t tmp205;
+              Read(&tmp205, &buf);
+              vmods = static_cast<Xkb::VMod>(tmp205);
+            }
+          }
+        }
+      }
+    }
+    if (CaseAnd(map_expr, Xkb::MapPart::KeySyms)) {
+      map.syms_rtrn.emplace();
+      auto& syms_rtrn = *map.syms_rtrn;
+      size_t syms_rtrn_len = syms_rtrn.size();
+
+      // syms_rtrn
+      syms_rtrn.resize(nKeySyms);
+      for (auto& syms_rtrn_elem : syms_rtrn) {
+        // syms_rtrn_elem
+        {
+          auto& kt_index = syms_rtrn_elem.kt_index;
+          size_t kt_index_len = kt_index.size();
+          auto& groupInfo = syms_rtrn_elem.groupInfo;
+          auto& width = syms_rtrn_elem.width;
+          uint16_t nSyms{};
+          auto& syms = syms_rtrn_elem.syms;
+          size_t syms_len = syms.size();
+
+          // kt_index
+          for (auto& kt_index_elem : kt_index) {
+            // kt_index_elem
+            Read(&kt_index_elem, &buf);
+          }
+
+          // groupInfo
+          Read(&groupInfo, &buf);
+
+          // width
+          Read(&width, &buf);
+
+          // nSyms
+          Read(&nSyms, &buf);
+
+          // syms
+          syms.resize(nSyms);
+          for (auto& syms_elem : syms) {
+            // syms_elem
+            Read(&syms_elem, &buf);
+          }
+        }
+      }
+    }
+    if (CaseAnd(map_expr, Xkb::MapPart::KeyActions)) {
+      map.acts_rtrn_count.emplace();
+      map.acts_rtrn_acts.emplace();
+      auto& acts_rtrn_count = *map.acts_rtrn_count;
+      size_t acts_rtrn_count_len = acts_rtrn_count.size();
+      auto& acts_rtrn_acts = *map.acts_rtrn_acts;
+      size_t acts_rtrn_acts_len = acts_rtrn_acts.size();
+
+      // acts_rtrn_count
+      acts_rtrn_count.resize(nKeyActions);
+      for (auto& acts_rtrn_count_elem : acts_rtrn_count) {
+        // acts_rtrn_count_elem
+        Read(&acts_rtrn_count_elem, &buf);
+      }
+
+      // pad3
+      Align(&buf, 4);
+
+      // acts_rtrn_acts
+      acts_rtrn_acts.resize(totalActions);
+      for (auto& acts_rtrn_acts_elem : acts_rtrn_acts) {
+        // acts_rtrn_acts_elem
+        Read(&acts_rtrn_acts_elem, &buf);
+      }
+    }
+    if (CaseAnd(map_expr, Xkb::MapPart::KeyBehaviors)) {
+      map.behaviors_rtrn.emplace();
+      auto& behaviors_rtrn = *map.behaviors_rtrn;
+      size_t behaviors_rtrn_len = behaviors_rtrn.size();
+
+      // behaviors_rtrn
+      behaviors_rtrn.resize(totalKeyBehaviors);
+      for (auto& behaviors_rtrn_elem : behaviors_rtrn) {
+        // behaviors_rtrn_elem
+        {
+          auto& keycode = behaviors_rtrn_elem.keycode;
+          auto& behavior = behaviors_rtrn_elem.behavior;
+
+          // keycode
+          Read(&keycode, &buf);
+
+          // behavior
+          Read(&behavior, &buf);
+
+          // pad0
+          Pad(&buf, 1);
+        }
+      }
+    }
+    if (CaseAnd(map_expr, Xkb::MapPart::VirtualMods)) {
+      map.vmods_rtrn.emplace();
+      auto& vmods_rtrn = *map.vmods_rtrn;
+      size_t vmods_rtrn_len = vmods_rtrn.size();
+
+      // vmods_rtrn
+      vmods_rtrn.resize(PopCount(virtualMods));
+      for (auto& vmods_rtrn_elem : vmods_rtrn) {
+        // vmods_rtrn_elem
+        uint8_t tmp206;
+        Read(&tmp206, &buf);
+        vmods_rtrn_elem = static_cast<ModMask>(tmp206);
+      }
+
+      // pad4
+      Align(&buf, 4);
+    }
+    if (CaseAnd(map_expr, Xkb::MapPart::ExplicitComponents)) {
+      map.explicit_rtrn.emplace();
+      auto& explicit_rtrn = *map.explicit_rtrn;
+      size_t explicit_rtrn_len = explicit_rtrn.size();
+
+      // explicit_rtrn
+      explicit_rtrn.resize(totalKeyExplicit);
+      for (auto& explicit_rtrn_elem : explicit_rtrn) {
+        // explicit_rtrn_elem
+        {
+          auto& keycode = explicit_rtrn_elem.keycode;
+          auto& c_explicit = explicit_rtrn_elem.c_explicit;
+
+          // keycode
+          Read(&keycode, &buf);
+
+          // c_explicit
+          uint8_t tmp207;
+          Read(&tmp207, &buf);
+          c_explicit = static_cast<Xkb::Explicit>(tmp207);
+        }
+      }
+
+      // pad5
+      Align(&buf, 4);
+    }
+    if (CaseAnd(map_expr, Xkb::MapPart::ModifierMap)) {
+      map.modmap_rtrn.emplace();
+      auto& modmap_rtrn = *map.modmap_rtrn;
+      size_t modmap_rtrn_len = modmap_rtrn.size();
+
+      // modmap_rtrn
+      modmap_rtrn.resize(totalModMapKeys);
+      for (auto& modmap_rtrn_elem : modmap_rtrn) {
+        // modmap_rtrn_elem
+        {
+          auto& keycode = modmap_rtrn_elem.keycode;
+          auto& mods = modmap_rtrn_elem.mods;
+
+          // keycode
+          Read(&keycode, &buf);
+
+          // mods
+          uint8_t tmp208;
+          Read(&tmp208, &buf);
+          mods = static_cast<ModMask>(tmp208);
+        }
+      }
+
+      // pad6
+      Align(&buf, 4);
+    }
+    if (CaseAnd(map_expr, Xkb::MapPart::VirtualModMap)) {
+      map.vmodmap_rtrn.emplace();
+      auto& vmodmap_rtrn = *map.vmodmap_rtrn;
+      size_t vmodmap_rtrn_len = vmodmap_rtrn.size();
+
+      // vmodmap_rtrn
+      vmodmap_rtrn.resize(totalVModMapKeys);
+      for (auto& vmodmap_rtrn_elem : vmodmap_rtrn) {
+        // vmodmap_rtrn_elem
+        {
+          auto& keycode = vmodmap_rtrn_elem.keycode;
+          auto& vmods = vmodmap_rtrn_elem.vmods;
+
+          // keycode
+          Read(&keycode, &buf);
+
+          // pad0
+          Pad(&buf, 1);
+
+          // vmods
+          uint16_t tmp209;
+          Read(&tmp209, &buf);
+          vmods = static_cast<Xkb::VMod>(tmp209);
+        }
+      }
+    }
+  }
+  if (CaseAnd(replies_expr, Xkb::GBNDetail::CompatMap)) {
+    replies.compat_map.emplace();
+    auto& compatmap_type = (*replies.compat_map).compatmap_type;
+    auto& compatDeviceID = (*replies.compat_map).compatDeviceID;
+    auto& compatmap_sequence = (*replies.compat_map).compatmap_sequence;
+    auto& compatmap_length = (*replies.compat_map).compatmap_length;
+    auto& groupsRtrn = (*replies.compat_map).groupsRtrn;
+    auto& firstSIRtrn = (*replies.compat_map).firstSIRtrn;
+    uint16_t nSIRtrn{};
+    auto& nTotalSI = (*replies.compat_map).nTotalSI;
+    auto& si_rtrn = (*replies.compat_map).si_rtrn;
+    size_t si_rtrn_len = si_rtrn.size();
+    auto& group_rtrn = (*replies.compat_map).group_rtrn;
+    size_t group_rtrn_len = group_rtrn.size();
+
+    // compatmap_type
+    Read(&compatmap_type, &buf);
+
+    // compatDeviceID
+    Read(&compatDeviceID, &buf);
+
+    // compatmap_sequence
+    Read(&compatmap_sequence, &buf);
+
+    // compatmap_length
+    Read(&compatmap_length, &buf);
+
+    // groupsRtrn
+    uint8_t tmp210;
+    Read(&tmp210, &buf);
+    groupsRtrn = static_cast<Xkb::SetOfGroup>(tmp210);
+
+    // pad7
+    Pad(&buf, 1);
+
+    // firstSIRtrn
+    Read(&firstSIRtrn, &buf);
+
+    // nSIRtrn
+    Read(&nSIRtrn, &buf);
+
+    // nTotalSI
+    Read(&nTotalSI, &buf);
+
+    // pad8
+    Pad(&buf, 16);
+
+    // si_rtrn
+    si_rtrn.resize(nSIRtrn);
+    for (auto& si_rtrn_elem : si_rtrn) {
+      // si_rtrn_elem
+      {
+        auto& sym = si_rtrn_elem.sym;
+        auto& mods = si_rtrn_elem.mods;
+        auto& match = si_rtrn_elem.match;
+        auto& virtualMod = si_rtrn_elem.virtualMod;
+        auto& flags = si_rtrn_elem.flags;
+        auto& action = si_rtrn_elem.action;
+
+        // sym
+        Read(&sym, &buf);
+
+        // mods
+        uint8_t tmp211;
+        Read(&tmp211, &buf);
+        mods = static_cast<ModMask>(tmp211);
+
+        // match
+        Read(&match, &buf);
+
+        // virtualMod
+        uint8_t tmp212;
+        Read(&tmp212, &buf);
+        virtualMod = static_cast<Xkb::VModsLow>(tmp212);
+
+        // flags
+        Read(&flags, &buf);
+
+        // action
+        {
+          auto& type = action.type;
+          auto& data = action.data;
+          size_t data_len = data.size();
+
+          // type
+          uint8_t tmp213;
+          Read(&tmp213, &buf);
+          type = static_cast<Xkb::SAType>(tmp213);
+
+          // data
+          for (auto& data_elem : data) {
+            // data_elem
+            Read(&data_elem, &buf);
+          }
+        }
+      }
+    }
+
+    // group_rtrn
+    group_rtrn.resize(PopCount(groupsRtrn));
+    for (auto& group_rtrn_elem : group_rtrn) {
+      // group_rtrn_elem
+      {
+        auto& mask = group_rtrn_elem.mask;
+        auto& realMods = group_rtrn_elem.realMods;
+        auto& vmods = group_rtrn_elem.vmods;
+
+        // mask
+        uint8_t tmp214;
+        Read(&tmp214, &buf);
+        mask = static_cast<ModMask>(tmp214);
+
+        // realMods
+        uint8_t tmp215;
+        Read(&tmp215, &buf);
+        realMods = static_cast<ModMask>(tmp215);
+
+        // vmods
+        uint16_t tmp216;
+        Read(&tmp216, &buf);
+        vmods = static_cast<Xkb::VMod>(tmp216);
+      }
+    }
+  }
+  if (CaseAnd(replies_expr, Xkb::GBNDetail::IndicatorMaps)) {
+    replies.indicator_maps.emplace();
+    auto& indicatormap_type = (*replies.indicator_maps).indicatormap_type;
+    auto& indicatorDeviceID = (*replies.indicator_maps).indicatorDeviceID;
+    auto& indicatormap_sequence =
+        (*replies.indicator_maps).indicatormap_sequence;
+    auto& indicatormap_length = (*replies.indicator_maps).indicatormap_length;
+    auto& which = (*replies.indicator_maps).which;
+    auto& realIndicators = (*replies.indicator_maps).realIndicators;
+    uint8_t nIndicators{};
+    auto& maps = (*replies.indicator_maps).maps;
+    size_t maps_len = maps.size();
+
+    // indicatormap_type
+    Read(&indicatormap_type, &buf);
+
+    // indicatorDeviceID
+    Read(&indicatorDeviceID, &buf);
+
+    // indicatormap_sequence
+    Read(&indicatormap_sequence, &buf);
+
+    // indicatormap_length
+    Read(&indicatormap_length, &buf);
+
+    // which
+    Read(&which, &buf);
+
+    // realIndicators
+    Read(&realIndicators, &buf);
+
+    // nIndicators
+    Read(&nIndicators, &buf);
+
+    // pad9
+    Pad(&buf, 15);
+
+    // maps
+    maps.resize(nIndicators);
+    for (auto& maps_elem : maps) {
+      // maps_elem
+      {
+        auto& flags = maps_elem.flags;
+        auto& whichGroups = maps_elem.whichGroups;
+        auto& groups = maps_elem.groups;
+        auto& whichMods = maps_elem.whichMods;
+        auto& mods = maps_elem.mods;
+        auto& realMods = maps_elem.realMods;
+        auto& vmods = maps_elem.vmods;
+        auto& ctrls = maps_elem.ctrls;
+
+        // flags
+        uint8_t tmp217;
+        Read(&tmp217, &buf);
+        flags = static_cast<Xkb::IMFlag>(tmp217);
+
+        // whichGroups
+        uint8_t tmp218;
+        Read(&tmp218, &buf);
+        whichGroups = static_cast<Xkb::IMGroupsWhich>(tmp218);
+
+        // groups
+        uint8_t tmp219;
+        Read(&tmp219, &buf);
+        groups = static_cast<Xkb::SetOfGroup>(tmp219);
+
+        // whichMods
+        uint8_t tmp220;
+        Read(&tmp220, &buf);
+        whichMods = static_cast<Xkb::IMModsWhich>(tmp220);
+
+        // mods
+        uint8_t tmp221;
+        Read(&tmp221, &buf);
+        mods = static_cast<ModMask>(tmp221);
+
+        // realMods
+        uint8_t tmp222;
+        Read(&tmp222, &buf);
+        realMods = static_cast<ModMask>(tmp222);
+
+        // vmods
+        uint16_t tmp223;
+        Read(&tmp223, &buf);
+        vmods = static_cast<Xkb::VMod>(tmp223);
+
+        // ctrls
+        uint32_t tmp224;
+        Read(&tmp224, &buf);
+        ctrls = static_cast<Xkb::BoolCtrl>(tmp224);
+      }
+    }
+  }
+  if (CaseAnd(replies_expr, Xkb::GBNDetail::KeyNames) ||
+      CaseAnd(replies_expr, Xkb::GBNDetail::OtherNames)) {
+    replies.key_names.emplace();
+    auto& keyname_type = (*replies.key_names).keyname_type;
+    auto& keyDeviceID = (*replies.key_names).keyDeviceID;
+    auto& keyname_sequence = (*replies.key_names).keyname_sequence;
+    auto& keyname_length = (*replies.key_names).keyname_length;
+    Xkb::NameDetail which{};
+    auto& keyMinKeyCode = (*replies.key_names).keyMinKeyCode;
+    auto& keyMaxKeyCode = (*replies.key_names).keyMaxKeyCode;
+    auto& nTypes = (*replies.key_names).nTypes;
+    auto& groupNames = (*replies.key_names).groupNames;
+    auto& virtualMods = (*replies.key_names).virtualMods;
+    auto& firstKey = (*replies.key_names).firstKey;
+    auto& nKeys = (*replies.key_names).nKeys;
+    auto& indicators = (*replies.key_names).indicators;
+    auto& nRadioGroups = (*replies.key_names).nRadioGroups;
+    auto& nKeyAliases = (*replies.key_names).nKeyAliases;
+    auto& nKTLevels = (*replies.key_names).nKTLevels;
+    auto& valueList = (*replies.key_names);
+
+    // keyname_type
+    Read(&keyname_type, &buf);
+
+    // keyDeviceID
+    Read(&keyDeviceID, &buf);
+
+    // keyname_sequence
+    Read(&keyname_sequence, &buf);
+
+    // keyname_length
+    Read(&keyname_length, &buf);
+
+    // which
+    uint32_t tmp225;
+    Read(&tmp225, &buf);
+    which = static_cast<Xkb::NameDetail>(tmp225);
+
+    // keyMinKeyCode
+    Read(&keyMinKeyCode, &buf);
+
+    // keyMaxKeyCode
+    Read(&keyMaxKeyCode, &buf);
+
+    // nTypes
+    Read(&nTypes, &buf);
+
+    // groupNames
+    uint8_t tmp226;
+    Read(&tmp226, &buf);
+    groupNames = static_cast<Xkb::SetOfGroup>(tmp226);
+
+    // virtualMods
+    uint16_t tmp227;
+    Read(&tmp227, &buf);
+    virtualMods = static_cast<Xkb::VMod>(tmp227);
+
+    // firstKey
+    Read(&firstKey, &buf);
+
+    // nKeys
+    Read(&nKeys, &buf);
+
+    // indicators
+    Read(&indicators, &buf);
+
+    // nRadioGroups
+    Read(&nRadioGroups, &buf);
+
+    // nKeyAliases
+    Read(&nKeyAliases, &buf);
+
+    // nKTLevels
+    Read(&nKTLevels, &buf);
+
+    // pad10
+    Pad(&buf, 4);
+
+    // valueList
+    auto valueList_expr = which;
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::Keycodes)) {
+      valueList.keycodesName.emplace();
+      auto& keycodesName = *valueList.keycodesName;
+
+      // keycodesName
+      Read(&keycodesName, &buf);
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::Geometry)) {
+      valueList.geometryName.emplace();
+      auto& geometryName = *valueList.geometryName;
+
+      // geometryName
+      Read(&geometryName, &buf);
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::Symbols)) {
+      valueList.symbolsName.emplace();
+      auto& symbolsName = *valueList.symbolsName;
+
+      // symbolsName
+      Read(&symbolsName, &buf);
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::PhysSymbols)) {
+      valueList.physSymbolsName.emplace();
+      auto& physSymbolsName = *valueList.physSymbolsName;
+
+      // physSymbolsName
+      Read(&physSymbolsName, &buf);
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::Types)) {
+      valueList.typesName.emplace();
+      auto& typesName = *valueList.typesName;
+
+      // typesName
+      Read(&typesName, &buf);
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::Compat)) {
+      valueList.compatName.emplace();
+      auto& compatName = *valueList.compatName;
+
+      // compatName
+      Read(&compatName, &buf);
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::KeyTypeNames)) {
+      valueList.typeNames.emplace();
+      auto& typeNames = *valueList.typeNames;
+      size_t typeNames_len = typeNames.size();
+
+      // typeNames
+      typeNames.resize(nTypes);
+      for (auto& typeNames_elem : typeNames) {
+        // typeNames_elem
+        Read(&typeNames_elem, &buf);
+      }
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::KTLevelNames)) {
+      valueList.nLevelsPerType.emplace();
+      valueList.ktLevelNames.emplace();
+      auto& nLevelsPerType = *valueList.nLevelsPerType;
+      size_t nLevelsPerType_len = nLevelsPerType.size();
+      auto& ktLevelNames = *valueList.ktLevelNames;
+      size_t ktLevelNames_len = ktLevelNames.size();
+
+      // nLevelsPerType
+      nLevelsPerType.resize(nTypes);
+      for (auto& nLevelsPerType_elem : nLevelsPerType) {
+        // nLevelsPerType_elem
+        Read(&nLevelsPerType_elem, &buf);
+      }
+
+      // pad11
+      Align(&buf, 4);
+
+      // ktLevelNames
+      auto sum228_ = SumOf([](auto& listelem_ref) { return listelem_ref; },
+                           nLevelsPerType);
+      ktLevelNames.resize(sum228_);
+      for (auto& ktLevelNames_elem : ktLevelNames) {
+        // ktLevelNames_elem
+        Read(&ktLevelNames_elem, &buf);
+      }
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::IndicatorNames)) {
+      valueList.indicatorNames.emplace();
+      auto& indicatorNames = *valueList.indicatorNames;
+      size_t indicatorNames_len = indicatorNames.size();
+
+      // indicatorNames
+      indicatorNames.resize(PopCount(indicators));
+      for (auto& indicatorNames_elem : indicatorNames) {
+        // indicatorNames_elem
+        Read(&indicatorNames_elem, &buf);
+      }
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::VirtualModNames)) {
+      valueList.virtualModNames.emplace();
+      auto& virtualModNames = *valueList.virtualModNames;
+      size_t virtualModNames_len = virtualModNames.size();
+
+      // virtualModNames
+      virtualModNames.resize(PopCount(virtualMods));
+      for (auto& virtualModNames_elem : virtualModNames) {
+        // virtualModNames_elem
+        Read(&virtualModNames_elem, &buf);
+      }
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::GroupNames)) {
+      valueList.groups.emplace();
+      auto& groups = *valueList.groups;
+      size_t groups_len = groups.size();
+
+      // groups
+      groups.resize(PopCount(groupNames));
+      for (auto& groups_elem : groups) {
+        // groups_elem
+        Read(&groups_elem, &buf);
+      }
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::KeyNames)) {
+      valueList.keyNames.emplace();
+      auto& keyNames = *valueList.keyNames;
+      size_t keyNames_len = keyNames.size();
+
+      // keyNames
+      keyNames.resize(nKeys);
+      for (auto& keyNames_elem : keyNames) {
+        // keyNames_elem
+        {
+          auto& name = keyNames_elem.name;
+          size_t name_len = name.size();
+
+          // name
+          for (auto& name_elem : name) {
+            // name_elem
+            Read(&name_elem, &buf);
+          }
+        }
+      }
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::KeyAliases)) {
+      valueList.keyAliases.emplace();
+      auto& keyAliases = *valueList.keyAliases;
+      size_t keyAliases_len = keyAliases.size();
+
+      // keyAliases
+      keyAliases.resize(nKeyAliases);
+      for (auto& keyAliases_elem : keyAliases) {
+        // keyAliases_elem
+        {
+          auto& real = keyAliases_elem.real;
+          size_t real_len = real.size();
+          auto& alias = keyAliases_elem.alias;
+          size_t alias_len = alias.size();
+
+          // real
+          for (auto& real_elem : real) {
+            // real_elem
+            Read(&real_elem, &buf);
+          }
+
+          // alias
+          for (auto& alias_elem : alias) {
+            // alias_elem
+            Read(&alias_elem, &buf);
+          }
+        }
+      }
+    }
+    if (CaseAnd(valueList_expr, Xkb::NameDetail::RGNames)) {
+      valueList.radioGroupNames.emplace();
+      auto& radioGroupNames = *valueList.radioGroupNames;
+      size_t radioGroupNames_len = radioGroupNames.size();
+
+      // radioGroupNames
+      radioGroupNames.resize(nRadioGroups);
+      for (auto& radioGroupNames_elem : radioGroupNames) {
+        // radioGroupNames_elem
+        Read(&radioGroupNames_elem, &buf);
+      }
+    }
+  }
+  if (CaseAnd(replies_expr, Xkb::GBNDetail::Geometry)) {
+    replies.geometry.emplace();
+    auto& geometry_type = (*replies.geometry).geometry_type;
+    auto& geometryDeviceID = (*replies.geometry).geometryDeviceID;
+    auto& geometry_sequence = (*replies.geometry).geometry_sequence;
+    auto& geometry_length = (*replies.geometry).geometry_length;
+    auto& name = (*replies.geometry).name;
+    auto& geometryFound = (*replies.geometry).geometryFound;
+    auto& widthMM = (*replies.geometry).widthMM;
+    auto& heightMM = (*replies.geometry).heightMM;
+    auto& nProperties = (*replies.geometry).nProperties;
+    auto& nColors = (*replies.geometry).nColors;
+    auto& nShapes = (*replies.geometry).nShapes;
+    auto& nSections = (*replies.geometry).nSections;
+    auto& nDoodads = (*replies.geometry).nDoodads;
+    auto& nKeyAliases = (*replies.geometry).nKeyAliases;
+    auto& baseColorNdx = (*replies.geometry).baseColorNdx;
+    auto& labelColorNdx = (*replies.geometry).labelColorNdx;
+    auto& labelFont = (*replies.geometry).labelFont;
+
+    // geometry_type
+    Read(&geometry_type, &buf);
+
+    // geometryDeviceID
+    Read(&geometryDeviceID, &buf);
+
+    // geometry_sequence
+    Read(&geometry_sequence, &buf);
+
+    // geometry_length
+    Read(&geometry_length, &buf);
+
+    // name
+    Read(&name, &buf);
+
+    // geometryFound
+    Read(&geometryFound, &buf);
+
+    // pad12
+    Pad(&buf, 1);
+
+    // widthMM
+    Read(&widthMM, &buf);
+
+    // heightMM
+    Read(&heightMM, &buf);
+
+    // nProperties
+    Read(&nProperties, &buf);
+
+    // nColors
+    Read(&nColors, &buf);
+
+    // nShapes
+    Read(&nShapes, &buf);
+
+    // nSections
+    Read(&nSections, &buf);
+
+    // nDoodads
+    Read(&nDoodads, &buf);
+
+    // nKeyAliases
+    Read(&nKeyAliases, &buf);
+
+    // baseColorNdx
+    Read(&baseColorNdx, &buf);
+
+    // labelColorNdx
+    Read(&labelColorNdx, &buf);
+
+    // labelFont
+    {
+      uint16_t length{};
+      auto& string = labelFont.string;
+      size_t string_len = string.size();
+      auto& alignment_pad = labelFont.alignment_pad;
+      size_t alignment_pad_len = alignment_pad ? alignment_pad->size() : 0;
+
+      // length
+      Read(&length, &buf);
+
+      // string
+      string.resize(length);
+      for (auto& string_elem : string) {
+        // string_elem
+        Read(&string_elem, &buf);
+      }
+
+      // alignment_pad
+      alignment_pad = buffer->ReadAndAdvance(
+          (BitAnd((length) + (5), BitNot(3))) - ((length) + (2)));
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xkb::GetDeviceInfoReply> Xkb::GetDeviceInfo(
+    const Xkb::GetDeviceInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& wanted = request.wanted;
+  auto& allButtons = request.allButtons;
+  auto& firstButton = request.firstButton;
+  auto& nButtons = request.nButtons;
+  auto& ledClass = request.ledClass;
+  auto& ledID = request.ledID;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 24;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // wanted
+  uint16_t tmp229;
+  tmp229 = static_cast<uint16_t>(wanted);
+  buf.Write(&tmp229);
+
+  // allButtons
+  buf.Write(&allButtons);
+
+  // firstButton
+  buf.Write(&firstButton);
+
+  // nButtons
+  buf.Write(&nButtons);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // ledClass
+  uint16_t tmp230;
+  tmp230 = static_cast<uint16_t>(ledClass);
+  buf.Write(&tmp230);
+
+  // ledID
+  buf.Write(&ledID);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::GetDeviceInfoReply>(
+      &buf, "Xkb::GetDeviceInfo", false);
+}
+
+Future<Xkb::GetDeviceInfoReply> Xkb::GetDeviceInfo(const DeviceSpec& deviceSpec,
+                                                   const XIFeature& wanted,
+                                                   const uint8_t& allButtons,
+                                                   const uint8_t& firstButton,
+                                                   const uint8_t& nButtons,
+                                                   const LedClass& ledClass,
+                                                   const IDSpec& ledID) {
+  return Xkb::GetDeviceInfo(Xkb::GetDeviceInfoRequest{
+      deviceSpec, wanted, allButtons, firstButton, nButtons, ledClass, ledID});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::GetDeviceInfoReply> detail::ReadReply<
+    Xkb::GetDeviceInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::GetDeviceInfoReply>();
+
+  auto& deviceID = (*reply).deviceID;
+  auto& sequence = (*reply).sequence;
+  auto& present = (*reply).present;
+  auto& supported = (*reply).supported;
+  auto& unsupported = (*reply).unsupported;
+  uint16_t nDeviceLedFBs{};
+  auto& firstBtnWanted = (*reply).firstBtnWanted;
+  auto& nBtnsWanted = (*reply).nBtnsWanted;
+  auto& firstBtnRtrn = (*reply).firstBtnRtrn;
+  uint8_t nBtnsRtrn{};
+  auto& totalBtns = (*reply).totalBtns;
+  auto& hasOwnState = (*reply).hasOwnState;
+  auto& dfltKbdFB = (*reply).dfltKbdFB;
+  auto& dfltLedFB = (*reply).dfltLedFB;
+  auto& devType = (*reply).devType;
+  uint16_t nameLen{};
+  auto& name = (*reply).name;
+  size_t name_len = name.size();
+  auto& btnActions = (*reply).btnActions;
+  size_t btnActions_len = btnActions.size();
+  auto& leds = (*reply).leds;
+  size_t leds_len = leds.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // deviceID
+  Read(&deviceID, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // present
+  uint16_t tmp231;
+  Read(&tmp231, &buf);
+  present = static_cast<Xkb::XIFeature>(tmp231);
+
+  // supported
+  uint16_t tmp232;
+  Read(&tmp232, &buf);
+  supported = static_cast<Xkb::XIFeature>(tmp232);
+
+  // unsupported
+  uint16_t tmp233;
+  Read(&tmp233, &buf);
+  unsupported = static_cast<Xkb::XIFeature>(tmp233);
+
+  // nDeviceLedFBs
+  Read(&nDeviceLedFBs, &buf);
+
+  // firstBtnWanted
+  Read(&firstBtnWanted, &buf);
+
+  // nBtnsWanted
+  Read(&nBtnsWanted, &buf);
+
+  // firstBtnRtrn
+  Read(&firstBtnRtrn, &buf);
+
+  // nBtnsRtrn
+  Read(&nBtnsRtrn, &buf);
+
+  // totalBtns
+  Read(&totalBtns, &buf);
+
+  // hasOwnState
+  Read(&hasOwnState, &buf);
+
+  // dfltKbdFB
+  Read(&dfltKbdFB, &buf);
+
+  // dfltLedFB
+  Read(&dfltLedFB, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // devType
+  Read(&devType, &buf);
+
+  // nameLen
+  Read(&nameLen, &buf);
+
+  // name
+  name.resize(nameLen);
+  for (auto& name_elem : name) {
+    // name_elem
+    Read(&name_elem, &buf);
+  }
+
+  // pad1
+  Align(&buf, 4);
+
+  // btnActions
+  btnActions.resize(nBtnsRtrn);
+  for (auto& btnActions_elem : btnActions) {
+    // btnActions_elem
+    Read(&btnActions_elem, &buf);
+  }
+
+  // leds
+  leds.resize(nDeviceLedFBs);
+  for (auto& leds_elem : leds) {
+    // leds_elem
+    {
+      auto& ledClass = leds_elem.ledClass;
+      auto& ledID = leds_elem.ledID;
+      auto& namesPresent = leds_elem.namesPresent;
+      auto& mapsPresent = leds_elem.mapsPresent;
+      auto& physIndicators = leds_elem.physIndicators;
+      auto& state = leds_elem.state;
+      auto& names = leds_elem.names;
+      size_t names_len = names.size();
+      auto& maps = leds_elem.maps;
+      size_t maps_len = maps.size();
+
+      // ledClass
+      uint16_t tmp234;
+      Read(&tmp234, &buf);
+      ledClass = static_cast<Xkb::LedClass>(tmp234);
+
+      // ledID
+      Read(&ledID, &buf);
+
+      // namesPresent
+      Read(&namesPresent, &buf);
+
+      // mapsPresent
+      Read(&mapsPresent, &buf);
+
+      // physIndicators
+      Read(&physIndicators, &buf);
+
+      // state
+      Read(&state, &buf);
+
+      // names
+      names.resize(PopCount(namesPresent));
+      for (auto& names_elem : names) {
+        // names_elem
+        Read(&names_elem, &buf);
+      }
+
+      // maps
+      maps.resize(PopCount(mapsPresent));
+      for (auto& maps_elem : maps) {
+        // maps_elem
+        {
+          auto& flags = maps_elem.flags;
+          auto& whichGroups = maps_elem.whichGroups;
+          auto& groups = maps_elem.groups;
+          auto& whichMods = maps_elem.whichMods;
+          auto& mods = maps_elem.mods;
+          auto& realMods = maps_elem.realMods;
+          auto& vmods = maps_elem.vmods;
+          auto& ctrls = maps_elem.ctrls;
+
+          // flags
+          uint8_t tmp235;
+          Read(&tmp235, &buf);
+          flags = static_cast<Xkb::IMFlag>(tmp235);
+
+          // whichGroups
+          uint8_t tmp236;
+          Read(&tmp236, &buf);
+          whichGroups = static_cast<Xkb::IMGroupsWhich>(tmp236);
+
+          // groups
+          uint8_t tmp237;
+          Read(&tmp237, &buf);
+          groups = static_cast<Xkb::SetOfGroup>(tmp237);
+
+          // whichMods
+          uint8_t tmp238;
+          Read(&tmp238, &buf);
+          whichMods = static_cast<Xkb::IMModsWhich>(tmp238);
+
+          // mods
+          uint8_t tmp239;
+          Read(&tmp239, &buf);
+          mods = static_cast<ModMask>(tmp239);
+
+          // realMods
+          uint8_t tmp240;
+          Read(&tmp240, &buf);
+          realMods = static_cast<ModMask>(tmp240);
+
+          // vmods
+          uint16_t tmp241;
+          Read(&tmp241, &buf);
+          vmods = static_cast<Xkb::VMod>(tmp241);
+
+          // ctrls
+          uint32_t tmp242;
+          Read(&tmp242, &buf);
+          ctrls = static_cast<Xkb::BoolCtrl>(tmp242);
+        }
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xkb::SetDeviceInfo(const Xkb::SetDeviceInfoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& deviceSpec = request.deviceSpec;
+  auto& firstBtn = request.firstBtn;
+  uint8_t nBtns{};
+  auto& change = request.change;
+  uint16_t nDeviceLedFBs{};
+  auto& btnActions = request.btnActions;
+  size_t btnActions_len = btnActions.size();
+  auto& leds = request.leds;
+  size_t leds_len = leds.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 25;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // deviceSpec
+  buf.Write(&deviceSpec);
+
+  // firstBtn
+  buf.Write(&firstBtn);
+
+  // nBtns
+  nBtns = btnActions.size();
+  buf.Write(&nBtns);
+
+  // change
+  uint16_t tmp243;
+  tmp243 = static_cast<uint16_t>(change);
+  buf.Write(&tmp243);
+
+  // nDeviceLedFBs
+  nDeviceLedFBs = leds.size();
+  buf.Write(&nDeviceLedFBs);
+
+  // btnActions
+  DCHECK_EQ(static_cast<size_t>(nBtns), btnActions.size());
+  for (auto& btnActions_elem : btnActions) {
+    // btnActions_elem
+    buf.Write(&btnActions_elem);
+  }
+
+  // leds
+  DCHECK_EQ(static_cast<size_t>(nDeviceLedFBs), leds.size());
+  for (auto& leds_elem : leds) {
+    // leds_elem
+    {
+      auto& ledClass = leds_elem.ledClass;
+      auto& ledID = leds_elem.ledID;
+      auto& namesPresent = leds_elem.namesPresent;
+      auto& mapsPresent = leds_elem.mapsPresent;
+      auto& physIndicators = leds_elem.physIndicators;
+      auto& state = leds_elem.state;
+      auto& names = leds_elem.names;
+      size_t names_len = names.size();
+      auto& maps = leds_elem.maps;
+      size_t maps_len = maps.size();
+
+      // ledClass
+      uint16_t tmp244;
+      tmp244 = static_cast<uint16_t>(ledClass);
+      buf.Write(&tmp244);
+
+      // ledID
+      buf.Write(&ledID);
+
+      // namesPresent
+      buf.Write(&namesPresent);
+
+      // mapsPresent
+      buf.Write(&mapsPresent);
+
+      // physIndicators
+      buf.Write(&physIndicators);
+
+      // state
+      buf.Write(&state);
+
+      // names
+      DCHECK_EQ(static_cast<size_t>(PopCount(namesPresent)), names.size());
+      for (auto& names_elem : names) {
+        // names_elem
+        buf.Write(&names_elem);
+      }
+
+      // maps
+      DCHECK_EQ(static_cast<size_t>(PopCount(mapsPresent)), maps.size());
+      for (auto& maps_elem : maps) {
+        // maps_elem
+        {
+          auto& flags = maps_elem.flags;
+          auto& whichGroups = maps_elem.whichGroups;
+          auto& groups = maps_elem.groups;
+          auto& whichMods = maps_elem.whichMods;
+          auto& mods = maps_elem.mods;
+          auto& realMods = maps_elem.realMods;
+          auto& vmods = maps_elem.vmods;
+          auto& ctrls = maps_elem.ctrls;
+
+          // flags
+          uint8_t tmp245;
+          tmp245 = static_cast<uint8_t>(flags);
+          buf.Write(&tmp245);
+
+          // whichGroups
+          uint8_t tmp246;
+          tmp246 = static_cast<uint8_t>(whichGroups);
+          buf.Write(&tmp246);
+
+          // groups
+          uint8_t tmp247;
+          tmp247 = static_cast<uint8_t>(groups);
+          buf.Write(&tmp247);
+
+          // whichMods
+          uint8_t tmp248;
+          tmp248 = static_cast<uint8_t>(whichMods);
+          buf.Write(&tmp248);
+
+          // mods
+          uint8_t tmp249;
+          tmp249 = static_cast<uint8_t>(mods);
+          buf.Write(&tmp249);
+
+          // realMods
+          uint8_t tmp250;
+          tmp250 = static_cast<uint8_t>(realMods);
+          buf.Write(&tmp250);
+
+          // vmods
+          uint16_t tmp251;
+          tmp251 = static_cast<uint16_t>(vmods);
+          buf.Write(&tmp251);
+
+          // ctrls
+          uint32_t tmp252;
+          tmp252 = static_cast<uint32_t>(ctrls);
+          buf.Write(&tmp252);
+        }
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xkb::SetDeviceInfo", false);
+}
+
+Future<void> Xkb::SetDeviceInfo(const DeviceSpec& deviceSpec,
+                                const uint8_t& firstBtn,
+                                const XIFeature& change,
+                                const std::vector<Action>& btnActions,
+                                const std::vector<DeviceLedInfo>& leds) {
+  return Xkb::SetDeviceInfo(Xkb::SetDeviceInfoRequest{
+      deviceSpec, firstBtn, change, btnActions, leds});
+}
+
+Future<Xkb::SetDebuggingFlagsReply> Xkb::SetDebuggingFlags(
+    const Xkb::SetDebuggingFlagsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint16_t msgLength{};
+  auto& affectFlags = request.affectFlags;
+  auto& flags = request.flags;
+  auto& affectCtrls = request.affectCtrls;
+  auto& ctrls = request.ctrls;
+  auto& message = request.message;
+  size_t message_len = message.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 101;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // msgLength
+  msgLength = message.size();
+  buf.Write(&msgLength);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // affectFlags
+  buf.Write(&affectFlags);
+
+  // flags
+  buf.Write(&flags);
+
+  // affectCtrls
+  buf.Write(&affectCtrls);
+
+  // ctrls
+  buf.Write(&ctrls);
+
+  // message
+  DCHECK_EQ(static_cast<size_t>(msgLength), message.size());
+  for (auto& message_elem : message) {
+    // message_elem
+    buf.Write(&message_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xkb::SetDebuggingFlagsReply>(
+      &buf, "Xkb::SetDebuggingFlags", false);
+}
+
+Future<Xkb::SetDebuggingFlagsReply> Xkb::SetDebuggingFlags(
+    const uint32_t& affectFlags,
+    const uint32_t& flags,
+    const uint32_t& affectCtrls,
+    const uint32_t& ctrls,
+    const std::vector<String8>& message) {
+  return Xkb::SetDebuggingFlags(Xkb::SetDebuggingFlagsRequest{
+      affectFlags, flags, affectCtrls, ctrls, message});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xkb::SetDebuggingFlagsReply> detail::ReadReply<
+    Xkb::SetDebuggingFlagsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xkb::SetDebuggingFlagsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& currentFlags = (*reply).currentFlags;
+  auto& currentCtrls = (*reply).currentCtrls;
+  auto& supportedFlags = (*reply).supportedFlags;
+  auto& supportedCtrls = (*reply).supportedCtrls;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // currentFlags
+  Read(&currentFlags, &buf);
+
+  // currentCtrls
+  Read(&currentCtrls, &buf);
+
+  // supportedFlags
+  Read(&supportedFlags, &buf);
+
+  // supportedCtrls
+  Read(&supportedCtrls, &buf);
+
+  // pad1
+  Pad(&buf, 8);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xkb.h b/ui/gfx/x/generated_protos/xkb.h
new file mode 100644
index 0000000..7346ca1
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xkb.h
@@ -0,0 +1,2858 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XKB_H_
+#define UI_GFX_X_GENERATED_PROTOS_XKB_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Xkb {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 0;
+
+  Xkb(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Const : int {
+    MaxLegalKeyCode = 255,
+    PerKeyBitArraySize = 32,
+    KeyNameLength = 4,
+  };
+
+  enum class EventType : int {
+    NewKeyboardNotify = 1 << 0,
+    MapNotify = 1 << 1,
+    StateNotify = 1 << 2,
+    ControlsNotify = 1 << 3,
+    IndicatorStateNotify = 1 << 4,
+    IndicatorMapNotify = 1 << 5,
+    NamesNotify = 1 << 6,
+    CompatMapNotify = 1 << 7,
+    BellNotify = 1 << 8,
+    ActionMessage = 1 << 9,
+    AccessXNotify = 1 << 10,
+    ExtensionDeviceNotify = 1 << 11,
+  };
+
+  enum class NKNDetail : int {
+    Keycodes = 1 << 0,
+    Geometry = 1 << 1,
+    DeviceID = 1 << 2,
+  };
+
+  enum class AXNDetail : int {
+    SKPress = 1 << 0,
+    SKAccept = 1 << 1,
+    SKReject = 1 << 2,
+    SKRelease = 1 << 3,
+    BKAccept = 1 << 4,
+    BKReject = 1 << 5,
+    AXKWarning = 1 << 6,
+  };
+
+  enum class MapPart : int {
+    KeyTypes = 1 << 0,
+    KeySyms = 1 << 1,
+    ModifierMap = 1 << 2,
+    ExplicitComponents = 1 << 3,
+    KeyActions = 1 << 4,
+    KeyBehaviors = 1 << 5,
+    VirtualMods = 1 << 6,
+    VirtualModMap = 1 << 7,
+  };
+
+  enum class SetMapFlags : int {
+    ResizeTypes = 1 << 0,
+    RecomputeActions = 1 << 1,
+  };
+
+  enum class StatePart : int {
+    ModifierState = 1 << 0,
+    ModifierBase = 1 << 1,
+    ModifierLatch = 1 << 2,
+    ModifierLock = 1 << 3,
+    GroupState = 1 << 4,
+    GroupBase = 1 << 5,
+    GroupLatch = 1 << 6,
+    GroupLock = 1 << 7,
+    CompatState = 1 << 8,
+    GrabMods = 1 << 9,
+    CompatGrabMods = 1 << 10,
+    LookupMods = 1 << 11,
+    CompatLookupMods = 1 << 12,
+    PointerButtons = 1 << 13,
+  };
+
+  enum class BoolCtrl : int {
+    RepeatKeys = 1 << 0,
+    SlowKeys = 1 << 1,
+    BounceKeys = 1 << 2,
+    StickyKeys = 1 << 3,
+    MouseKeys = 1 << 4,
+    MouseKeysAccel = 1 << 5,
+    AccessXKeys = 1 << 6,
+    AccessXTimeoutMask = 1 << 7,
+    AccessXFeedbackMask = 1 << 8,
+    AudibleBellMask = 1 << 9,
+    Overlay1Mask = 1 << 10,
+    Overlay2Mask = 1 << 11,
+    IgnoreGroupLockMask = 1 << 12,
+  };
+
+  enum class Control : int {
+    GroupsWrap = 1 << 27,
+    InternalMods = 1 << 28,
+    IgnoreLockMods = 1 << 29,
+    PerKeyRepeat = 1 << 30,
+    ControlsEnabled = 1 << 31,
+  };
+
+  enum class AXOption : int {
+    SKPressFB = 1 << 0,
+    SKAcceptFB = 1 << 1,
+    FeatureFB = 1 << 2,
+    SlowWarnFB = 1 << 3,
+    IndicatorFB = 1 << 4,
+    StickyKeysFB = 1 << 5,
+    TwoKeys = 1 << 6,
+    LatchToLock = 1 << 7,
+    SKReleaseFB = 1 << 8,
+    SKRejectFB = 1 << 9,
+    BKRejectFB = 1 << 10,
+    DumbBell = 1 << 11,
+  };
+
+  enum class DeviceSpec : uint16_t {};
+
+  enum class LedClassResult : int {
+    KbdFeedbackClass = 0,
+    LedFeedbackClass = 4,
+  };
+
+  enum class LedClass : int {
+    KbdFeedbackClass = 0,
+    LedFeedbackClass = 4,
+    DfltXIClass = 768,
+    AllXIClasses = 1280,
+  };
+
+  enum class LedClassSpec : uint16_t {};
+
+  enum class BellClassResult : int {
+    KbdFeedbackClass = 0,
+    BellFeedbackClass = 5,
+  };
+
+  enum class BellClass : int {
+    KbdFeedbackClass = 0,
+    BellFeedbackClass = 5,
+    DfltXIClass = 768,
+  };
+
+  enum class BellClassSpec : uint16_t {};
+
+  enum class Id : int {
+    UseCoreKbd = 256,
+    UseCorePtr = 512,
+    DfltXIClass = 768,
+    DfltXIId = 1024,
+    AllXIClass = 1280,
+    AllXIId = 1536,
+    XINone = 65280,
+  };
+
+  enum class IDSpec : uint16_t {};
+
+  enum class Group : int {
+    c_1 = 0,
+    c_2 = 1,
+    c_3 = 2,
+    c_4 = 3,
+  };
+
+  enum class Groups : int {
+    Any = 254,
+    All = 255,
+  };
+
+  enum class SetOfGroup : int {
+    Group1 = 1 << 0,
+    Group2 = 1 << 1,
+    Group3 = 1 << 2,
+    Group4 = 1 << 3,
+  };
+
+  enum class SetOfGroups : int {
+    Any = 1 << 7,
+  };
+
+  enum class GroupsWrap : int {
+    WrapIntoRange = 0,
+    ClampIntoRange = 1 << 6,
+    RedirectIntoRange = 1 << 7,
+  };
+
+  enum class VModsHigh : int {
+    c_15 = 1 << 7,
+    c_14 = 1 << 6,
+    c_13 = 1 << 5,
+    c_12 = 1 << 4,
+    c_11 = 1 << 3,
+    c_10 = 1 << 2,
+    c_9 = 1 << 1,
+    c_8 = 1 << 0,
+  };
+
+  enum class VModsLow : int {
+    c_7 = 1 << 7,
+    c_6 = 1 << 6,
+    c_5 = 1 << 5,
+    c_4 = 1 << 4,
+    c_3 = 1 << 3,
+    c_2 = 1 << 2,
+    c_1 = 1 << 1,
+    c_0 = 1 << 0,
+  };
+
+  enum class VMod : int {
+    c_15 = 1 << 15,
+    c_14 = 1 << 14,
+    c_13 = 1 << 13,
+    c_12 = 1 << 12,
+    c_11 = 1 << 11,
+    c_10 = 1 << 10,
+    c_9 = 1 << 9,
+    c_8 = 1 << 8,
+    c_7 = 1 << 7,
+    c_6 = 1 << 6,
+    c_5 = 1 << 5,
+    c_4 = 1 << 4,
+    c_3 = 1 << 3,
+    c_2 = 1 << 2,
+    c_1 = 1 << 1,
+    c_0 = 1 << 0,
+  };
+
+  enum class Explicit : int {
+    VModMap = 1 << 7,
+    Behavior = 1 << 6,
+    AutoRepeat = 1 << 5,
+    Interpret = 1 << 4,
+    KeyType4 = 1 << 3,
+    KeyType3 = 1 << 2,
+    KeyType2 = 1 << 1,
+    KeyType1 = 1 << 0,
+  };
+
+  enum class SymInterpretMatch : int {
+    NoneOf = 0,
+    AnyOfOrNone = 1,
+    AnyOf = 2,
+    AllOf = 3,
+    Exactly = 4,
+  };
+
+  enum class SymInterpMatch : int {
+    OpMask = 127,
+    LevelOneOnly = 1 << 7,
+  };
+
+  enum class IMFlag : int {
+    NoExplicit = 1 << 7,
+    NoAutomatic = 1 << 6,
+    LEDDrivesKB = 1 << 5,
+  };
+
+  enum class IMModsWhich : int {
+    UseCompat = 1 << 4,
+    UseEffective = 1 << 3,
+    UseLocked = 1 << 2,
+    UseLatched = 1 << 1,
+    UseBase = 1 << 0,
+  };
+
+  enum class IMGroupsWhich : int {
+    UseCompat = 1 << 4,
+    UseEffective = 1 << 3,
+    UseLocked = 1 << 2,
+    UseLatched = 1 << 1,
+    UseBase = 1 << 0,
+  };
+
+  enum class CMDetail : int {
+    SymInterp = 1 << 0,
+    GroupCompat = 1 << 1,
+  };
+
+  enum class NameDetail : int {
+    Keycodes = 1 << 0,
+    Geometry = 1 << 1,
+    Symbols = 1 << 2,
+    PhysSymbols = 1 << 3,
+    Types = 1 << 4,
+    Compat = 1 << 5,
+    KeyTypeNames = 1 << 6,
+    KTLevelNames = 1 << 7,
+    IndicatorNames = 1 << 8,
+    KeyNames = 1 << 9,
+    KeyAliases = 1 << 10,
+    VirtualModNames = 1 << 11,
+    GroupNames = 1 << 12,
+    RGNames = 1 << 13,
+  };
+
+  enum class GBNDetail : int {
+    Types = 1 << 0,
+    CompatMap = 1 << 1,
+    ClientSymbols = 1 << 2,
+    ServerSymbols = 1 << 3,
+    IndicatorMaps = 1 << 4,
+    KeyNames = 1 << 5,
+    Geometry = 1 << 6,
+    OtherNames = 1 << 7,
+  };
+
+  enum class XIFeature : int {
+    Keyboards = 1 << 0,
+    ButtonActions = 1 << 1,
+    IndicatorNames = 1 << 2,
+    IndicatorMaps = 1 << 3,
+    IndicatorState = 1 << 4,
+  };
+
+  enum class PerClientFlag : int {
+    DetectableAutoRepeat = 1 << 0,
+    GrabsUseXKBState = 1 << 1,
+    AutoResetControls = 1 << 2,
+    LookupStateWhenGrabbed = 1 << 3,
+    SendEventUsesXKBState = 1 << 4,
+  };
+
+  enum class BehaviorType : int {
+    Default = 0,
+    Lock = 1,
+    RadioGroup = 2,
+    Overlay1 = 3,
+    Overlay2 = 4,
+    PermamentLock = 129,
+    PermamentRadioGroup = 130,
+    PermamentOverlay1 = 131,
+    PermamentOverlay2 = 132,
+  };
+
+  enum class String8 : char {};
+
+  enum class DoodadType : int {
+    Outline = 1,
+    Solid = 2,
+    Text = 3,
+    Indicator = 4,
+    Logo = 5,
+  };
+
+  enum class Error : int {
+    BadDevice = 255,
+    BadClass = 254,
+    BadId = 253,
+  };
+
+  enum class Sa : int {
+    ClearLocks = 1 << 0,
+    LatchToLock = 1 << 1,
+    UseModMapMods = 1 << 2,
+    GroupAbsolute = 1 << 2,
+  };
+
+  enum class SAType : int {
+    NoAction = 0,
+    SetMods = 1,
+    LatchMods = 2,
+    LockMods = 3,
+    SetGroup = 4,
+    LatchGroup = 5,
+    LockGroup = 6,
+    MovePtr = 7,
+    PtrBtn = 8,
+    LockPtrBtn = 9,
+    SetPtrDflt = 10,
+    ISOLock = 11,
+    Terminate = 12,
+    SwitchScreen = 13,
+    SetControls = 14,
+    LockControls = 15,
+    ActionMessage = 16,
+    RedirectKey = 17,
+    DeviceBtn = 18,
+    LockDeviceBtn = 19,
+    DeviceValuator = 20,
+  };
+
+  enum class SAMovePtrFlag : int {
+    NoAcceleration = 1 << 0,
+    MoveAbsoluteX = 1 << 1,
+    MoveAbsoluteY = 1 << 2,
+  };
+
+  enum class SASetPtrDfltFlag : int {
+    DfltBtnAbsolute = 1 << 2,
+    AffectDfltButton = 1 << 0,
+  };
+
+  enum class SAIsoLockFlag : int {
+    NoLock = 1 << 0,
+    NoUnlock = 1 << 1,
+    UseModMapMods = 1 << 2,
+    GroupAbsolute = 1 << 2,
+    ISODfltIsGroup = 1 << 3,
+  };
+
+  enum class SAIsoLockNoAffect : int {
+    Ctrls = 1 << 3,
+    Ptr = 1 << 4,
+    Group = 1 << 5,
+    Mods = 1 << 6,
+  };
+
+  enum class SwitchScreenFlag : int {
+    Application = 1 << 0,
+    Absolute = 1 << 2,
+  };
+
+  enum class BoolCtrlsHigh : int {
+    AccessXFeedback = 1 << 0,
+    AudibleBell = 1 << 1,
+    Overlay1 = 1 << 2,
+    Overlay2 = 1 << 3,
+    IgnoreGroupLock = 1 << 4,
+  };
+
+  enum class BoolCtrlsLow : int {
+    RepeatKeys = 1 << 0,
+    SlowKeys = 1 << 1,
+    BounceKeys = 1 << 2,
+    StickyKeys = 1 << 3,
+    MouseKeys = 1 << 4,
+    MouseKeysAccel = 1 << 5,
+    AccessXKeys = 1 << 6,
+    AccessXTimeout = 1 << 7,
+  };
+
+  enum class ActionMessageFlag : int {
+    OnPress = 1 << 0,
+    OnRelease = 1 << 1,
+    GenKeyEvent = 1 << 2,
+  };
+
+  enum class LockDeviceFlags : int {
+    NoLock = 1 << 0,
+    NoUnlock = 1 << 1,
+  };
+
+  enum class SAValWhat : int {
+    IgnoreVal = 0,
+    SetValMin = 1,
+    SetValCenter = 2,
+    SetValMax = 3,
+    SetValRelative = 4,
+    SetValAbsolute = 5,
+  };
+
+  struct IndicatorMap {
+    IMFlag flags{};
+    IMGroupsWhich whichGroups{};
+    SetOfGroup groups{};
+    IMModsWhich whichMods{};
+    ModMask mods{};
+    ModMask realMods{};
+    VMod vmods{};
+    BoolCtrl ctrls{};
+  };
+
+  struct ModDef {
+    ModMask mask{};
+    ModMask realMods{};
+    VMod vmods{};
+  };
+
+  struct KeyName {
+    std::array<char, 4> name{};
+  };
+
+  struct KeyAlias {
+    std::array<char, 4> real{};
+    std::array<char, 4> alias{};
+  };
+
+  struct CountedString16 {
+    std::string string{};
+    scoped_refptr<base::RefCountedMemory> alignment_pad{};
+  };
+
+  struct KTMapEntry {
+    uint8_t active{};
+    ModMask mods_mask{};
+    uint8_t level{};
+    ModMask mods_mods{};
+    VMod mods_vmods{};
+  };
+
+  struct KeyType {
+    ModMask mods_mask{};
+    ModMask mods_mods{};
+    VMod mods_vmods{};
+    uint8_t numLevels{};
+    uint8_t hasPreserve{};
+    std::vector<KTMapEntry> map{};
+    std::vector<ModDef> preserve{};
+  };
+
+  struct KeySymMap {
+    std::array<uint8_t, 4> kt_index{};
+    uint8_t groupInfo{};
+    uint8_t width{};
+    std::vector<KeySym> syms{};
+  };
+
+  struct CommonBehavior {
+    uint8_t type{};
+    uint8_t data{};
+  };
+
+  struct DefaultBehavior {
+    uint8_t type{};
+  };
+
+  struct LockBehavior {
+    uint8_t type{};
+  };
+
+  struct RadioGroupBehavior {
+    uint8_t type{};
+    uint8_t group{};
+  };
+
+  struct OverlayBehavior {
+    uint8_t type{};
+    KeyCode key{};
+  };
+
+  struct PermamentLockBehavior {
+    uint8_t type{};
+  };
+
+  struct PermamentRadioGroupBehavior {
+    uint8_t type{};
+    uint8_t group{};
+  };
+
+  struct PermamentOverlayBehavior {
+    uint8_t type{};
+    KeyCode key{};
+  };
+
+  union Behavior {
+    Behavior() { memset(this, 0, sizeof(*this)); }
+
+    CommonBehavior common;
+    DefaultBehavior c_default;
+    LockBehavior lock;
+    RadioGroupBehavior radioGroup;
+    OverlayBehavior overlay1;
+    OverlayBehavior overlay2;
+    PermamentLockBehavior permamentLock;
+    PermamentRadioGroupBehavior permamentRadioGroup;
+    PermamentOverlayBehavior permamentOverlay1;
+    PermamentOverlayBehavior permamentOverlay2;
+    uint8_t type;
+  };
+  static_assert(std::is_trivially_copyable<Behavior>::value, "");
+
+  struct SetBehavior {
+    KeyCode keycode{};
+    Behavior behavior{};
+  };
+
+  struct SetExplicit {
+    KeyCode keycode{};
+    Explicit c_explicit{};
+  };
+
+  struct KeyModMap {
+    KeyCode keycode{};
+    ModMask mods{};
+  };
+
+  struct KeyVModMap {
+    KeyCode keycode{};
+    VMod vmods{};
+  };
+
+  struct KTSetMapEntry {
+    uint8_t level{};
+    ModMask realMods{};
+    VMod virtualMods{};
+  };
+
+  struct SetKeyType {
+    ModMask mask{};
+    ModMask realMods{};
+    VMod virtualMods{};
+    uint8_t numLevels{};
+    uint8_t preserve{};
+    std::vector<KTSetMapEntry> entries{};
+    std::vector<KTSetMapEntry> preserve_entries{};
+  };
+
+  struct Outline {
+    uint8_t cornerRadius{};
+    std::vector<Point> points{};
+  };
+
+  struct Shape {
+    Atom name{};
+    uint8_t primaryNdx{};
+    uint8_t approxNdx{};
+    std::vector<Outline> outlines{};
+  };
+
+  struct Key {
+    std::array<String8, 4> name{};
+    int16_t gap{};
+    uint8_t shapeNdx{};
+    uint8_t colorNdx{};
+  };
+
+  struct OverlayKey {
+    std::array<String8, 4> over{};
+    std::array<String8, 4> under{};
+  };
+
+  struct OverlayRow {
+    uint8_t rowUnder{};
+    std::vector<OverlayKey> keys{};
+  };
+
+  struct Overlay {
+    Atom name{};
+    std::vector<OverlayRow> rows{};
+  };
+
+  struct Row {
+    int16_t top{};
+    int16_t left{};
+    uint8_t vertical{};
+    std::vector<Key> keys{};
+  };
+
+  struct Listing {
+    uint16_t flags{};
+    std::vector<String8> string{};
+  };
+
+  struct DeviceLedInfo {
+    LedClass ledClass{};
+    IDSpec ledID{};
+    uint32_t namesPresent{};
+    uint32_t mapsPresent{};
+    uint32_t physIndicators{};
+    uint32_t state{};
+    std::vector<Atom> names{};
+    std::vector<IndicatorMap> maps{};
+  };
+
+  struct KeyboardError : public x11::Error {
+    uint16_t sequence{};
+    uint32_t value{};
+    uint16_t minorOpcode{};
+    uint8_t majorOpcode{};
+
+    std::string ToString() const override;
+  };
+
+  struct SANoAction {
+    SAType type{};
+  };
+
+  struct SASetMods {
+    SAType type{};
+    Sa flags{};
+    ModMask mask{};
+    ModMask realMods{};
+    VModsHigh vmodsHigh{};
+    VModsLow vmodsLow{};
+  };
+
+  struct SALatchMods {
+    SAType type{};
+    Sa flags{};
+    ModMask mask{};
+    ModMask realMods{};
+    VModsHigh vmodsHigh{};
+    VModsLow vmodsLow{};
+  };
+
+  struct SALockMods {
+    SAType type{};
+    Sa flags{};
+    ModMask mask{};
+    ModMask realMods{};
+    VModsHigh vmodsHigh{};
+    VModsLow vmodsLow{};
+  };
+
+  struct SASetGroup {
+    SAType type{};
+    Sa flags{};
+    int8_t group{};
+  };
+
+  struct SALatchGroup {
+    SAType type{};
+    Sa flags{};
+    int8_t group{};
+  };
+
+  struct SALockGroup {
+    SAType type{};
+    Sa flags{};
+    int8_t group{};
+  };
+
+  struct SAMovePtr {
+    SAType type{};
+    SAMovePtrFlag flags{};
+    int8_t xHigh{};
+    uint8_t xLow{};
+    int8_t yHigh{};
+    uint8_t yLow{};
+  };
+
+  struct SAPtrBtn {
+    SAType type{};
+    uint8_t flags{};
+    uint8_t count{};
+    uint8_t button{};
+  };
+
+  struct SALockPtrBtn {
+    SAType type{};
+    uint8_t flags{};
+    uint8_t button{};
+  };
+
+  struct SASetPtrDflt {
+    SAType type{};
+    SASetPtrDfltFlag flags{};
+    SASetPtrDfltFlag affect{};
+    int8_t value{};
+  };
+
+  struct SAIsoLock {
+    SAType type{};
+    SAIsoLockFlag flags{};
+    ModMask mask{};
+    ModMask realMods{};
+    int8_t group{};
+    SAIsoLockNoAffect affect{};
+    VModsHigh vmodsHigh{};
+    VModsLow vmodsLow{};
+  };
+
+  struct SATerminate {
+    SAType type{};
+  };
+
+  struct SASwitchScreen {
+    SAType type{};
+    uint8_t flags{};
+    int8_t newScreen{};
+  };
+
+  struct SASetControls {
+    SAType type{};
+    BoolCtrlsHigh boolCtrlsHigh{};
+    BoolCtrlsLow boolCtrlsLow{};
+  };
+
+  struct SALockControls {
+    SAType type{};
+    BoolCtrlsHigh boolCtrlsHigh{};
+    BoolCtrlsLow boolCtrlsLow{};
+  };
+
+  struct SAActionMessage {
+    SAType type{};
+    ActionMessageFlag flags{};
+    std::array<uint8_t, 6> message{};
+  };
+
+  struct SARedirectKey {
+    SAType type{};
+    KeyCode newkey{};
+    ModMask mask{};
+    ModMask realModifiers{};
+    VModsHigh vmodsMaskHigh{};
+    VModsLow vmodsMaskLow{};
+    VModsHigh vmodsHigh{};
+    VModsLow vmodsLow{};
+  };
+
+  struct SADeviceBtn {
+    SAType type{};
+    uint8_t flags{};
+    uint8_t count{};
+    uint8_t button{};
+    uint8_t device{};
+  };
+
+  struct SALockDeviceBtn {
+    SAType type{};
+    LockDeviceFlags flags{};
+    uint8_t button{};
+    uint8_t device{};
+  };
+
+  struct SADeviceValuator {
+    SAType type{};
+    uint8_t device{};
+    SAValWhat val1what{};
+    uint8_t val1index{};
+    uint8_t val1value{};
+    SAValWhat val2what{};
+    uint8_t val2index{};
+    uint8_t val2value{};
+  };
+
+  struct SIAction {
+    SAType type{};
+    std::array<uint8_t, 7> data{};
+  };
+
+  struct SymInterpret {
+    KeySym sym{};
+    ModMask mods{};
+    uint8_t match{};
+    VModsLow virtualMod{};
+    uint8_t flags{};
+    SIAction action{};
+  };
+
+  union Action {
+    Action() { memset(this, 0, sizeof(*this)); }
+
+    SANoAction noaction;
+    SASetMods setmods;
+    SALatchMods latchmods;
+    SALockMods lockmods;
+    SASetGroup setgroup;
+    SALatchGroup latchgroup;
+    SALockGroup lockgroup;
+    SAMovePtr moveptr;
+    SAPtrBtn ptrbtn;
+    SALockPtrBtn lockptrbtn;
+    SASetPtrDflt setptrdflt;
+    SAIsoLock isolock;
+    SATerminate terminate;
+    SASwitchScreen switchscreen;
+    SASetControls setcontrols;
+    SALockControls lockcontrols;
+    SAActionMessage message;
+    SARedirectKey redirect;
+    SADeviceBtn devbtn;
+    SALockDeviceBtn lockdevbtn;
+    SADeviceValuator devval;
+    SAType type;
+  };
+  static_assert(std::is_trivially_copyable<Action>::value, "");
+
+  struct NewKeyboardNotifyEvent {
+    static constexpr int type_id = 38;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    uint8_t oldDeviceID{};
+    KeyCode minKeyCode{};
+    KeyCode maxKeyCode{};
+    KeyCode oldMinKeyCode{};
+    KeyCode oldMaxKeyCode{};
+    uint8_t requestMajor{};
+    uint8_t requestMinor{};
+    NKNDetail changed{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct MapNotifyEvent {
+    static constexpr int type_id = 39;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    uint8_t ptrBtnActions{};
+    MapPart changed{};
+    KeyCode minKeyCode{};
+    KeyCode maxKeyCode{};
+    uint8_t firstType{};
+    uint8_t nTypes{};
+    KeyCode firstKeySym{};
+    uint8_t nKeySyms{};
+    KeyCode firstKeyAct{};
+    uint8_t nKeyActs{};
+    KeyCode firstKeyBehavior{};
+    uint8_t nKeyBehavior{};
+    KeyCode firstKeyExplicit{};
+    uint8_t nKeyExplicit{};
+    KeyCode firstModMapKey{};
+    uint8_t nModMapKeys{};
+    KeyCode firstVModMapKey{};
+    uint8_t nVModMapKeys{};
+    VMod virtualMods{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct StateNotifyEvent {
+    static constexpr int type_id = 40;
+    static constexpr uint8_t opcode = 2;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    ModMask mods{};
+    ModMask baseMods{};
+    ModMask latchedMods{};
+    ModMask lockedMods{};
+    Group group{};
+    int16_t baseGroup{};
+    int16_t latchedGroup{};
+    Group lockedGroup{};
+    ModMask compatState{};
+    ModMask grabMods{};
+    ModMask compatGrabMods{};
+    ModMask lookupMods{};
+    ModMask compatLoockupMods{};
+    KeyButMask ptrBtnState{};
+    StatePart changed{};
+    KeyCode keycode{};
+    uint8_t eventType{};
+    uint8_t requestMajor{};
+    uint8_t requestMinor{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct ControlsNotifyEvent {
+    static constexpr int type_id = 41;
+    static constexpr uint8_t opcode = 3;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    uint8_t numGroups{};
+    Control changedControls{};
+    BoolCtrl enabledControls{};
+    BoolCtrl enabledControlChanges{};
+    KeyCode keycode{};
+    uint8_t eventType{};
+    uint8_t requestMajor{};
+    uint8_t requestMinor{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct IndicatorStateNotifyEvent {
+    static constexpr int type_id = 42;
+    static constexpr uint8_t opcode = 4;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    uint32_t state{};
+    uint32_t stateChanged{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct IndicatorMapNotifyEvent {
+    static constexpr int type_id = 43;
+    static constexpr uint8_t opcode = 5;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    uint32_t state{};
+    uint32_t mapChanged{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct NamesNotifyEvent {
+    static constexpr int type_id = 44;
+    static constexpr uint8_t opcode = 6;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    NameDetail changed{};
+    uint8_t firstType{};
+    uint8_t nTypes{};
+    uint8_t firstLevelName{};
+    uint8_t nLevelNames{};
+    uint8_t nRadioGroups{};
+    uint8_t nKeyAliases{};
+    SetOfGroup changedGroupNames{};
+    VMod changedVirtualMods{};
+    KeyCode firstKey{};
+    uint8_t nKeys{};
+    uint32_t changedIndicators{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct CompatMapNotifyEvent {
+    static constexpr int type_id = 45;
+    static constexpr uint8_t opcode = 7;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    SetOfGroup changedGroups{};
+    uint16_t firstSI{};
+    uint16_t nSI{};
+    uint16_t nTotalSI{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct BellNotifyEvent {
+    static constexpr int type_id = 46;
+    static constexpr uint8_t opcode = 8;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    BellClassResult bellClass{};
+    uint8_t bellID{};
+    uint8_t percent{};
+    uint16_t pitch{};
+    uint16_t duration{};
+    Atom name{};
+    Window window{};
+    uint8_t eventOnly{};
+
+    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+  };
+
+  struct ActionMessageEvent {
+    static constexpr int type_id = 47;
+    static constexpr uint8_t opcode = 9;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    KeyCode keycode{};
+    uint8_t press{};
+    uint8_t keyEventFollows{};
+    ModMask mods{};
+    Group group{};
+    std::array<String8, 8> message{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct AccessXNotifyEvent {
+    static constexpr int type_id = 48;
+    static constexpr uint8_t opcode = 10;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    KeyCode keycode{};
+    AXNDetail detailt{};
+    uint16_t slowKeysDelay{};
+    uint16_t debounceDelay{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct ExtensionDeviceNotifyEvent {
+    static constexpr int type_id = 49;
+    static constexpr uint8_t opcode = 11;
+    bool send_event{};
+    uint8_t xkbType{};
+    uint16_t sequence{};
+    Time time{};
+    uint8_t deviceID{};
+    XIFeature reason{};
+    LedClassResult ledClass{};
+    uint16_t ledID{};
+    uint32_t ledsDefined{};
+    uint32_t ledState{};
+    uint8_t firstButton{};
+    uint8_t nButtons{};
+    XIFeature supported{};
+    XIFeature unsupported{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct UseExtensionRequest {
+    uint16_t wantedMajor{};
+    uint16_t wantedMinor{};
+  };
+
+  struct UseExtensionReply {
+    uint8_t supported{};
+    uint16_t sequence{};
+    uint16_t serverMajor{};
+    uint16_t serverMinor{};
+  };
+
+  using UseExtensionResponse = Response<UseExtensionReply>;
+
+  Future<UseExtensionReply> UseExtension(const UseExtensionRequest& request);
+
+  Future<UseExtensionReply> UseExtension(const uint16_t& wantedMajor = {},
+                                         const uint16_t& wantedMinor = {});
+
+  struct SelectEventsRequest {
+    DeviceSpec deviceSpec{};
+    EventType affectWhich{};
+    EventType clear{};
+    EventType selectAll{};
+    MapPart affectMap{};
+    MapPart map{};
+    absl::optional<NKNDetail> affectNewKeyboard{};
+    absl::optional<NKNDetail> newKeyboardDetails{};
+    absl::optional<StatePart> affectState{};
+    absl::optional<StatePart> stateDetails{};
+    absl::optional<Control> affectCtrls{};
+    absl::optional<Control> ctrlDetails{};
+    absl::optional<uint32_t> affectIndicatorState{};
+    absl::optional<uint32_t> indicatorStateDetails{};
+    absl::optional<uint32_t> affectIndicatorMap{};
+    absl::optional<uint32_t> indicatorMapDetails{};
+    absl::optional<NameDetail> affectNames{};
+    absl::optional<NameDetail> namesDetails{};
+    absl::optional<CMDetail> affectCompat{};
+    absl::optional<CMDetail> compatDetails{};
+    absl::optional<uint8_t> affectBell{};
+    absl::optional<uint8_t> bellDetails{};
+    absl::optional<uint8_t> affectMsgDetails{};
+    absl::optional<uint8_t> msgDetails{};
+    absl::optional<AXNDetail> affectAccessX{};
+    absl::optional<AXNDetail> accessXDetails{};
+    absl::optional<XIFeature> affectExtDev{};
+    absl::optional<XIFeature> extdevDetails{};
+  };
+
+  using SelectEventsResponse = Response<void>;
+
+  Future<void> SelectEvents(const SelectEventsRequest& request);
+
+  Future<void> SelectEvents(
+      const DeviceSpec& deviceSpec = {},
+      const EventType& affectWhich = {},
+      const EventType& clear = {},
+      const EventType& selectAll = {},
+      const MapPart& affectMap = {},
+      const MapPart& map = {},
+      const absl::optional<NKNDetail>& affectNewKeyboard = absl::nullopt,
+      const absl::optional<NKNDetail>& newKeyboardDetails = absl::nullopt,
+      const absl::optional<StatePart>& affectState = absl::nullopt,
+      const absl::optional<StatePart>& stateDetails = absl::nullopt,
+      const absl::optional<Control>& affectCtrls = absl::nullopt,
+      const absl::optional<Control>& ctrlDetails = absl::nullopt,
+      const absl::optional<uint32_t>& affectIndicatorState = absl::nullopt,
+      const absl::optional<uint32_t>& indicatorStateDetails = absl::nullopt,
+      const absl::optional<uint32_t>& affectIndicatorMap = absl::nullopt,
+      const absl::optional<uint32_t>& indicatorMapDetails = absl::nullopt,
+      const absl::optional<NameDetail>& affectNames = absl::nullopt,
+      const absl::optional<NameDetail>& namesDetails = absl::nullopt,
+      const absl::optional<CMDetail>& affectCompat = absl::nullopt,
+      const absl::optional<CMDetail>& compatDetails = absl::nullopt,
+      const absl::optional<uint8_t>& affectBell = absl::nullopt,
+      const absl::optional<uint8_t>& bellDetails = absl::nullopt,
+      const absl::optional<uint8_t>& affectMsgDetails = absl::nullopt,
+      const absl::optional<uint8_t>& msgDetails = absl::nullopt,
+      const absl::optional<AXNDetail>& affectAccessX = absl::nullopt,
+      const absl::optional<AXNDetail>& accessXDetails = absl::nullopt,
+      const absl::optional<XIFeature>& affectExtDev = absl::nullopt,
+      const absl::optional<XIFeature>& extdevDetails = absl::nullopt);
+
+  struct BellRequest {
+    DeviceSpec deviceSpec{};
+    BellClassSpec bellClass{};
+    IDSpec bellID{};
+    int8_t percent{};
+    uint8_t forceSound{};
+    uint8_t eventOnly{};
+    int16_t pitch{};
+    int16_t duration{};
+    Atom name{};
+    Window window{};
+  };
+
+  using BellResponse = Response<void>;
+
+  Future<void> Bell(const BellRequest& request);
+
+  Future<void> Bell(const DeviceSpec& deviceSpec = {},
+                    const BellClassSpec& bellClass = {},
+                    const IDSpec& bellID = {},
+                    const int8_t& percent = {},
+                    const uint8_t& forceSound = {},
+                    const uint8_t& eventOnly = {},
+                    const int16_t& pitch = {},
+                    const int16_t& duration = {},
+                    const Atom& name = {},
+                    const Window& window = {});
+
+  struct GetStateRequest {
+    DeviceSpec deviceSpec{};
+  };
+
+  struct GetStateReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    ModMask mods{};
+    ModMask baseMods{};
+    ModMask latchedMods{};
+    ModMask lockedMods{};
+    Group group{};
+    Group lockedGroup{};
+    int16_t baseGroup{};
+    int16_t latchedGroup{};
+    ModMask compatState{};
+    ModMask grabMods{};
+    ModMask compatGrabMods{};
+    ModMask lookupMods{};
+    ModMask compatLookupMods{};
+    KeyButMask ptrBtnState{};
+  };
+
+  using GetStateResponse = Response<GetStateReply>;
+
+  Future<GetStateReply> GetState(const GetStateRequest& request);
+
+  Future<GetStateReply> GetState(const DeviceSpec& deviceSpec = {});
+
+  struct LatchLockStateRequest {
+    DeviceSpec deviceSpec{};
+    ModMask affectModLocks{};
+    ModMask modLocks{};
+    uint8_t lockGroup{};
+    Group groupLock{};
+    ModMask affectModLatches{};
+    uint8_t latchGroup{};
+    uint16_t groupLatch{};
+  };
+
+  using LatchLockStateResponse = Response<void>;
+
+  Future<void> LatchLockState(const LatchLockStateRequest& request);
+
+  Future<void> LatchLockState(const DeviceSpec& deviceSpec = {},
+                              const ModMask& affectModLocks = {},
+                              const ModMask& modLocks = {},
+                              const uint8_t& lockGroup = {},
+                              const Group& groupLock = {},
+                              const ModMask& affectModLatches = {},
+                              const uint8_t& latchGroup = {},
+                              const uint16_t& groupLatch = {});
+
+  struct GetControlsRequest {
+    DeviceSpec deviceSpec{};
+  };
+
+  struct GetControlsReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    uint8_t mouseKeysDfltBtn{};
+    uint8_t numGroups{};
+    uint8_t groupsWrap{};
+    ModMask internalModsMask{};
+    ModMask ignoreLockModsMask{};
+    ModMask internalModsRealMods{};
+    ModMask ignoreLockModsRealMods{};
+    VMod internalModsVmods{};
+    VMod ignoreLockModsVmods{};
+    uint16_t repeatDelay{};
+    uint16_t repeatInterval{};
+    uint16_t slowKeysDelay{};
+    uint16_t debounceDelay{};
+    uint16_t mouseKeysDelay{};
+    uint16_t mouseKeysInterval{};
+    uint16_t mouseKeysTimeToMax{};
+    uint16_t mouseKeysMaxSpeed{};
+    int16_t mouseKeysCurve{};
+    AXOption accessXOption{};
+    uint16_t accessXTimeout{};
+    AXOption accessXTimeoutOptionsMask{};
+    AXOption accessXTimeoutOptionsValues{};
+    BoolCtrl accessXTimeoutMask{};
+    BoolCtrl accessXTimeoutValues{};
+    BoolCtrl enabledControls{};
+    std::array<uint8_t, 32> perKeyRepeat{};
+  };
+
+  using GetControlsResponse = Response<GetControlsReply>;
+
+  Future<GetControlsReply> GetControls(const GetControlsRequest& request);
+
+  Future<GetControlsReply> GetControls(const DeviceSpec& deviceSpec = {});
+
+  struct SetControlsRequest {
+    DeviceSpec deviceSpec{};
+    ModMask affectInternalRealMods{};
+    ModMask internalRealMods{};
+    ModMask affectIgnoreLockRealMods{};
+    ModMask ignoreLockRealMods{};
+    VMod affectInternalVirtualMods{};
+    VMod internalVirtualMods{};
+    VMod affectIgnoreLockVirtualMods{};
+    VMod ignoreLockVirtualMods{};
+    uint8_t mouseKeysDfltBtn{};
+    uint8_t groupsWrap{};
+    AXOption accessXOptions{};
+    BoolCtrl affectEnabledControls{};
+    BoolCtrl enabledControls{};
+    Control changeControls{};
+    uint16_t repeatDelay{};
+    uint16_t repeatInterval{};
+    uint16_t slowKeysDelay{};
+    uint16_t debounceDelay{};
+    uint16_t mouseKeysDelay{};
+    uint16_t mouseKeysInterval{};
+    uint16_t mouseKeysTimeToMax{};
+    uint16_t mouseKeysMaxSpeed{};
+    int16_t mouseKeysCurve{};
+    uint16_t accessXTimeout{};
+    BoolCtrl accessXTimeoutMask{};
+    BoolCtrl accessXTimeoutValues{};
+    AXOption accessXTimeoutOptionsMask{};
+    AXOption accessXTimeoutOptionsValues{};
+    std::array<uint8_t, 32> perKeyRepeat{};
+  };
+
+  using SetControlsResponse = Response<void>;
+
+  Future<void> SetControls(const SetControlsRequest& request);
+
+  Future<void> SetControls(const DeviceSpec& deviceSpec = {},
+                           const ModMask& affectInternalRealMods = {},
+                           const ModMask& internalRealMods = {},
+                           const ModMask& affectIgnoreLockRealMods = {},
+                           const ModMask& ignoreLockRealMods = {},
+                           const VMod& affectInternalVirtualMods = {},
+                           const VMod& internalVirtualMods = {},
+                           const VMod& affectIgnoreLockVirtualMods = {},
+                           const VMod& ignoreLockVirtualMods = {},
+                           const uint8_t& mouseKeysDfltBtn = {},
+                           const uint8_t& groupsWrap = {},
+                           const AXOption& accessXOptions = {},
+                           const BoolCtrl& affectEnabledControls = {},
+                           const BoolCtrl& enabledControls = {},
+                           const Control& changeControls = {},
+                           const uint16_t& repeatDelay = {},
+                           const uint16_t& repeatInterval = {},
+                           const uint16_t& slowKeysDelay = {},
+                           const uint16_t& debounceDelay = {},
+                           const uint16_t& mouseKeysDelay = {},
+                           const uint16_t& mouseKeysInterval = {},
+                           const uint16_t& mouseKeysTimeToMax = {},
+                           const uint16_t& mouseKeysMaxSpeed = {},
+                           const int16_t& mouseKeysCurve = {},
+                           const uint16_t& accessXTimeout = {},
+                           const BoolCtrl& accessXTimeoutMask = {},
+                           const BoolCtrl& accessXTimeoutValues = {},
+                           const AXOption& accessXTimeoutOptionsMask = {},
+                           const AXOption& accessXTimeoutOptionsValues = {},
+                           const std::array<uint8_t, 32>& perKeyRepeat = {});
+
+  struct GetMapRequest {
+    DeviceSpec deviceSpec{};
+    MapPart full{};
+    MapPart partial{};
+    uint8_t firstType{};
+    uint8_t nTypes{};
+    KeyCode firstKeySym{};
+    uint8_t nKeySyms{};
+    KeyCode firstKeyAction{};
+    uint8_t nKeyActions{};
+    KeyCode firstKeyBehavior{};
+    uint8_t nKeyBehaviors{};
+    VMod virtualMods{};
+    KeyCode firstKeyExplicit{};
+    uint8_t nKeyExplicit{};
+    KeyCode firstModMapKey{};
+    uint8_t nModMapKeys{};
+    KeyCode firstVModMapKey{};
+    uint8_t nVModMapKeys{};
+  };
+
+  struct GetMapReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    KeyCode minKeyCode{};
+    KeyCode maxKeyCode{};
+    uint8_t firstType{};
+    uint8_t nTypes{};
+    uint8_t totalTypes{};
+    KeyCode firstKeySym{};
+    uint16_t totalSyms{};
+    uint8_t nKeySyms{};
+    KeyCode firstKeyAction{};
+    uint16_t totalActions{};
+    uint8_t nKeyActions{};
+    KeyCode firstKeyBehavior{};
+    uint8_t nKeyBehaviors{};
+    uint8_t totalKeyBehaviors{};
+    KeyCode firstKeyExplicit{};
+    uint8_t nKeyExplicit{};
+    uint8_t totalKeyExplicit{};
+    KeyCode firstModMapKey{};
+    uint8_t nModMapKeys{};
+    uint8_t totalModMapKeys{};
+    KeyCode firstVModMapKey{};
+    uint8_t nVModMapKeys{};
+    uint8_t totalVModMapKeys{};
+    VMod virtualMods{};
+    absl::optional<std::vector<KeyType>> types_rtrn{};
+    absl::optional<std::vector<KeySymMap>> syms_rtrn{};
+    absl::optional<std::vector<uint8_t>> acts_rtrn_count{};
+    absl::optional<std::vector<Action>> acts_rtrn_acts{};
+    absl::optional<std::vector<SetBehavior>> behaviors_rtrn{};
+    absl::optional<std::vector<ModMask>> vmods_rtrn{};
+    absl::optional<std::vector<SetExplicit>> explicit_rtrn{};
+    absl::optional<std::vector<KeyModMap>> modmap_rtrn{};
+    absl::optional<std::vector<KeyVModMap>> vmodmap_rtrn{};
+  };
+
+  using GetMapResponse = Response<GetMapReply>;
+
+  Future<GetMapReply> GetMap(const GetMapRequest& request);
+
+  Future<GetMapReply> GetMap(const DeviceSpec& deviceSpec = {},
+                             const MapPart& full = {},
+                             const MapPart& partial = {},
+                             const uint8_t& firstType = {},
+                             const uint8_t& nTypes = {},
+                             const KeyCode& firstKeySym = {},
+                             const uint8_t& nKeySyms = {},
+                             const KeyCode& firstKeyAction = {},
+                             const uint8_t& nKeyActions = {},
+                             const KeyCode& firstKeyBehavior = {},
+                             const uint8_t& nKeyBehaviors = {},
+                             const VMod& virtualMods = {},
+                             const KeyCode& firstKeyExplicit = {},
+                             const uint8_t& nKeyExplicit = {},
+                             const KeyCode& firstModMapKey = {},
+                             const uint8_t& nModMapKeys = {},
+                             const KeyCode& firstVModMapKey = {},
+                             const uint8_t& nVModMapKeys = {});
+
+  struct SetMapRequest {
+    DeviceSpec deviceSpec{};
+    SetMapFlags flags{};
+    KeyCode minKeyCode{};
+    KeyCode maxKeyCode{};
+    uint8_t firstType{};
+    uint8_t nTypes{};
+    KeyCode firstKeySym{};
+    uint8_t nKeySyms{};
+    uint16_t totalSyms{};
+    KeyCode firstKeyAction{};
+    uint8_t nKeyActions{};
+    uint16_t totalActions{};
+    KeyCode firstKeyBehavior{};
+    uint8_t nKeyBehaviors{};
+    uint8_t totalKeyBehaviors{};
+    KeyCode firstKeyExplicit{};
+    uint8_t nKeyExplicit{};
+    uint8_t totalKeyExplicit{};
+    KeyCode firstModMapKey{};
+    uint8_t nModMapKeys{};
+    uint8_t totalModMapKeys{};
+    KeyCode firstVModMapKey{};
+    uint8_t nVModMapKeys{};
+    uint8_t totalVModMapKeys{};
+    VMod virtualMods{};
+    absl::optional<std::vector<SetKeyType>> types{};
+    absl::optional<std::vector<KeySymMap>> syms{};
+    absl::optional<std::vector<uint8_t>> actionsCount{};
+    absl::optional<std::vector<Action>> actions{};
+    absl::optional<std::vector<SetBehavior>> behaviors{};
+    absl::optional<std::vector<uint8_t>> vmods{};
+    absl::optional<std::vector<SetExplicit>> c_explicit{};
+    absl::optional<std::vector<KeyModMap>> modmap{};
+    absl::optional<std::vector<KeyVModMap>> vmodmap{};
+  };
+
+  using SetMapResponse = Response<void>;
+
+  Future<void> SetMap(const SetMapRequest& request);
+
+  Future<void> SetMap(
+      const DeviceSpec& deviceSpec = {},
+      const SetMapFlags& flags = {},
+      const KeyCode& minKeyCode = {},
+      const KeyCode& maxKeyCode = {},
+      const uint8_t& firstType = {},
+      const uint8_t& nTypes = {},
+      const KeyCode& firstKeySym = {},
+      const uint8_t& nKeySyms = {},
+      const uint16_t& totalSyms = {},
+      const KeyCode& firstKeyAction = {},
+      const uint8_t& nKeyActions = {},
+      const uint16_t& totalActions = {},
+      const KeyCode& firstKeyBehavior = {},
+      const uint8_t& nKeyBehaviors = {},
+      const uint8_t& totalKeyBehaviors = {},
+      const KeyCode& firstKeyExplicit = {},
+      const uint8_t& nKeyExplicit = {},
+      const uint8_t& totalKeyExplicit = {},
+      const KeyCode& firstModMapKey = {},
+      const uint8_t& nModMapKeys = {},
+      const uint8_t& totalModMapKeys = {},
+      const KeyCode& firstVModMapKey = {},
+      const uint8_t& nVModMapKeys = {},
+      const uint8_t& totalVModMapKeys = {},
+      const VMod& virtualMods = {},
+      const absl::optional<std::vector<SetKeyType>>& types = absl::nullopt,
+      const absl::optional<std::vector<KeySymMap>>& syms = absl::nullopt,
+      const absl::optional<std::vector<uint8_t>>& actionsCount = absl::nullopt,
+      const absl::optional<std::vector<Action>>& actions = absl::nullopt,
+      const absl::optional<std::vector<SetBehavior>>& behaviors = absl::nullopt,
+      const absl::optional<std::vector<uint8_t>>& vmods = absl::nullopt,
+      const absl::optional<std::vector<SetExplicit>>& c_explicit =
+          absl::nullopt,
+      const absl::optional<std::vector<KeyModMap>>& modmap = absl::nullopt,
+      const absl::optional<std::vector<KeyVModMap>>& vmodmap = absl::nullopt);
+
+  struct GetCompatMapRequest {
+    DeviceSpec deviceSpec{};
+    SetOfGroup groups{};
+    uint8_t getAllSI{};
+    uint16_t firstSI{};
+    uint16_t nSI{};
+  };
+
+  struct GetCompatMapReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    SetOfGroup groupsRtrn{};
+    uint16_t firstSIRtrn{};
+    uint16_t nTotalSI{};
+    std::vector<SymInterpret> si_rtrn{};
+    std::vector<ModDef> group_rtrn{};
+  };
+
+  using GetCompatMapResponse = Response<GetCompatMapReply>;
+
+  Future<GetCompatMapReply> GetCompatMap(const GetCompatMapRequest& request);
+
+  Future<GetCompatMapReply> GetCompatMap(const DeviceSpec& deviceSpec = {},
+                                         const SetOfGroup& groups = {},
+                                         const uint8_t& getAllSI = {},
+                                         const uint16_t& firstSI = {},
+                                         const uint16_t& nSI = {});
+
+  struct SetCompatMapRequest {
+    DeviceSpec deviceSpec{};
+    uint8_t recomputeActions{};
+    uint8_t truncateSI{};
+    SetOfGroup groups{};
+    uint16_t firstSI{};
+    std::vector<SymInterpret> si{};
+    std::vector<ModDef> groupMaps{};
+  };
+
+  using SetCompatMapResponse = Response<void>;
+
+  Future<void> SetCompatMap(const SetCompatMapRequest& request);
+
+  Future<void> SetCompatMap(const DeviceSpec& deviceSpec = {},
+                            const uint8_t& recomputeActions = {},
+                            const uint8_t& truncateSI = {},
+                            const SetOfGroup& groups = {},
+                            const uint16_t& firstSI = {},
+                            const std::vector<SymInterpret>& si = {},
+                            const std::vector<ModDef>& groupMaps = {});
+
+  struct GetIndicatorStateRequest {
+    DeviceSpec deviceSpec{};
+  };
+
+  struct GetIndicatorStateReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    uint32_t state{};
+  };
+
+  using GetIndicatorStateResponse = Response<GetIndicatorStateReply>;
+
+  Future<GetIndicatorStateReply> GetIndicatorState(
+      const GetIndicatorStateRequest& request);
+
+  Future<GetIndicatorStateReply> GetIndicatorState(
+      const DeviceSpec& deviceSpec = {});
+
+  struct GetIndicatorMapRequest {
+    DeviceSpec deviceSpec{};
+    uint32_t which{};
+  };
+
+  struct GetIndicatorMapReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    uint32_t which{};
+    uint32_t realIndicators{};
+    uint8_t nIndicators{};
+    std::vector<IndicatorMap> maps{};
+  };
+
+  using GetIndicatorMapResponse = Response<GetIndicatorMapReply>;
+
+  Future<GetIndicatorMapReply> GetIndicatorMap(
+      const GetIndicatorMapRequest& request);
+
+  Future<GetIndicatorMapReply> GetIndicatorMap(
+      const DeviceSpec& deviceSpec = {},
+      const uint32_t& which = {});
+
+  struct SetIndicatorMapRequest {
+    DeviceSpec deviceSpec{};
+    uint32_t which{};
+    std::vector<IndicatorMap> maps{};
+  };
+
+  using SetIndicatorMapResponse = Response<void>;
+
+  Future<void> SetIndicatorMap(const SetIndicatorMapRequest& request);
+
+  Future<void> SetIndicatorMap(const DeviceSpec& deviceSpec = {},
+                               const uint32_t& which = {},
+                               const std::vector<IndicatorMap>& maps = {});
+
+  struct GetNamedIndicatorRequest {
+    DeviceSpec deviceSpec{};
+    LedClass ledClass{};
+    IDSpec ledID{};
+    Atom indicator{};
+  };
+
+  struct GetNamedIndicatorReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    Atom indicator{};
+    uint8_t found{};
+    uint8_t on{};
+    uint8_t realIndicator{};
+    uint8_t ndx{};
+    IMFlag map_flags{};
+    IMGroupsWhich map_whichGroups{};
+    SetOfGroups map_groups{};
+    IMModsWhich map_whichMods{};
+    ModMask map_mods{};
+    ModMask map_realMods{};
+    VMod map_vmod{};
+    BoolCtrl map_ctrls{};
+    uint8_t supported{};
+  };
+
+  using GetNamedIndicatorResponse = Response<GetNamedIndicatorReply>;
+
+  Future<GetNamedIndicatorReply> GetNamedIndicator(
+      const GetNamedIndicatorRequest& request);
+
+  Future<GetNamedIndicatorReply> GetNamedIndicator(
+      const DeviceSpec& deviceSpec = {},
+      const LedClass& ledClass = {},
+      const IDSpec& ledID = {},
+      const Atom& indicator = {});
+
+  struct SetNamedIndicatorRequest {
+    DeviceSpec deviceSpec{};
+    LedClass ledClass{};
+    IDSpec ledID{};
+    Atom indicator{};
+    uint8_t setState{};
+    uint8_t on{};
+    uint8_t setMap{};
+    uint8_t createMap{};
+    IMFlag map_flags{};
+    IMGroupsWhich map_whichGroups{};
+    SetOfGroups map_groups{};
+    IMModsWhich map_whichMods{};
+    ModMask map_realMods{};
+    VMod map_vmods{};
+    BoolCtrl map_ctrls{};
+  };
+
+  using SetNamedIndicatorResponse = Response<void>;
+
+  Future<void> SetNamedIndicator(const SetNamedIndicatorRequest& request);
+
+  Future<void> SetNamedIndicator(const DeviceSpec& deviceSpec = {},
+                                 const LedClass& ledClass = {},
+                                 const IDSpec& ledID = {},
+                                 const Atom& indicator = {},
+                                 const uint8_t& setState = {},
+                                 const uint8_t& on = {},
+                                 const uint8_t& setMap = {},
+                                 const uint8_t& createMap = {},
+                                 const IMFlag& map_flags = {},
+                                 const IMGroupsWhich& map_whichGroups = {},
+                                 const SetOfGroups& map_groups = {},
+                                 const IMModsWhich& map_whichMods = {},
+                                 const ModMask& map_realMods = {},
+                                 const VMod& map_vmods = {},
+                                 const BoolCtrl& map_ctrls = {});
+
+  struct GetNamesRequest {
+    DeviceSpec deviceSpec{};
+    NameDetail which{};
+  };
+
+  struct GetNamesReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    KeyCode minKeyCode{};
+    KeyCode maxKeyCode{};
+    uint8_t nTypes{};
+    SetOfGroup groupNames{};
+    VMod virtualMods{};
+    KeyCode firstKey{};
+    uint8_t nKeys{};
+    uint32_t indicators{};
+    uint8_t nRadioGroups{};
+    uint8_t nKeyAliases{};
+    uint16_t nKTLevels{};
+    absl::optional<Atom> keycodesName{};
+    absl::optional<Atom> geometryName{};
+    absl::optional<Atom> symbolsName{};
+    absl::optional<Atom> physSymbolsName{};
+    absl::optional<Atom> typesName{};
+    absl::optional<Atom> compatName{};
+    absl::optional<std::vector<Atom>> typeNames{};
+    absl::optional<std::vector<uint8_t>> nLevelsPerType{};
+    absl::optional<std::vector<Atom>> ktLevelNames{};
+    absl::optional<std::vector<Atom>> indicatorNames{};
+    absl::optional<std::vector<Atom>> virtualModNames{};
+    absl::optional<std::vector<Atom>> groups{};
+    absl::optional<std::vector<KeyName>> keyNames{};
+    absl::optional<std::vector<KeyAlias>> keyAliases{};
+    absl::optional<std::vector<Atom>> radioGroupNames{};
+  };
+
+  using GetNamesResponse = Response<GetNamesReply>;
+
+  Future<GetNamesReply> GetNames(const GetNamesRequest& request);
+
+  Future<GetNamesReply> GetNames(const DeviceSpec& deviceSpec = {},
+                                 const NameDetail& which = {});
+
+  struct SetNamesRequest {
+    DeviceSpec deviceSpec{};
+    VMod virtualMods{};
+    uint8_t firstType{};
+    uint8_t nTypes{};
+    uint8_t firstKTLevelt{};
+    uint8_t nKTLevels{};
+    uint32_t indicators{};
+    SetOfGroup groupNames{};
+    uint8_t nRadioGroups{};
+    KeyCode firstKey{};
+    uint8_t nKeys{};
+    uint8_t nKeyAliases{};
+    uint16_t totalKTLevelNames{};
+    absl::optional<Atom> keycodesName{};
+    absl::optional<Atom> geometryName{};
+    absl::optional<Atom> symbolsName{};
+    absl::optional<Atom> physSymbolsName{};
+    absl::optional<Atom> typesName{};
+    absl::optional<Atom> compatName{};
+    absl::optional<std::vector<Atom>> typeNames{};
+    absl::optional<std::vector<uint8_t>> nLevelsPerType{};
+    absl::optional<std::vector<Atom>> ktLevelNames{};
+    absl::optional<std::vector<Atom>> indicatorNames{};
+    absl::optional<std::vector<Atom>> virtualModNames{};
+    absl::optional<std::vector<Atom>> groups{};
+    absl::optional<std::vector<KeyName>> keyNames{};
+    absl::optional<std::vector<KeyAlias>> keyAliases{};
+    absl::optional<std::vector<Atom>> radioGroupNames{};
+  };
+
+  using SetNamesResponse = Response<void>;
+
+  Future<void> SetNames(const SetNamesRequest& request);
+
+  Future<void> SetNames(
+      const DeviceSpec& deviceSpec = {},
+      const VMod& virtualMods = {},
+      const uint8_t& firstType = {},
+      const uint8_t& nTypes = {},
+      const uint8_t& firstKTLevelt = {},
+      const uint8_t& nKTLevels = {},
+      const uint32_t& indicators = {},
+      const SetOfGroup& groupNames = {},
+      const uint8_t& nRadioGroups = {},
+      const KeyCode& firstKey = {},
+      const uint8_t& nKeys = {},
+      const uint8_t& nKeyAliases = {},
+      const uint16_t& totalKTLevelNames = {},
+      const absl::optional<Atom>& keycodesName = absl::nullopt,
+      const absl::optional<Atom>& geometryName = absl::nullopt,
+      const absl::optional<Atom>& symbolsName = absl::nullopt,
+      const absl::optional<Atom>& physSymbolsName = absl::nullopt,
+      const absl::optional<Atom>& typesName = absl::nullopt,
+      const absl::optional<Atom>& compatName = absl::nullopt,
+      const absl::optional<std::vector<Atom>>& typeNames = absl::nullopt,
+      const absl::optional<std::vector<uint8_t>>& nLevelsPerType =
+          absl::nullopt,
+      const absl::optional<std::vector<Atom>>& ktLevelNames = absl::nullopt,
+      const absl::optional<std::vector<Atom>>& indicatorNames = absl::nullopt,
+      const absl::optional<std::vector<Atom>>& virtualModNames = absl::nullopt,
+      const absl::optional<std::vector<Atom>>& groups = absl::nullopt,
+      const absl::optional<std::vector<KeyName>>& keyNames = absl::nullopt,
+      const absl::optional<std::vector<KeyAlias>>& keyAliases = absl::nullopt,
+      const absl::optional<std::vector<Atom>>& radioGroupNames = absl::nullopt);
+
+  struct PerClientFlagsRequest {
+    DeviceSpec deviceSpec{};
+    PerClientFlag change{};
+    PerClientFlag value{};
+    BoolCtrl ctrlsToChange{};
+    BoolCtrl autoCtrls{};
+    BoolCtrl autoCtrlsValues{};
+  };
+
+  struct PerClientFlagsReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    PerClientFlag supported{};
+    PerClientFlag value{};
+    BoolCtrl autoCtrls{};
+    BoolCtrl autoCtrlsValues{};
+  };
+
+  using PerClientFlagsResponse = Response<PerClientFlagsReply>;
+
+  Future<PerClientFlagsReply> PerClientFlags(
+      const PerClientFlagsRequest& request);
+
+  Future<PerClientFlagsReply> PerClientFlags(
+      const DeviceSpec& deviceSpec = {},
+      const PerClientFlag& change = {},
+      const PerClientFlag& value = {},
+      const BoolCtrl& ctrlsToChange = {},
+      const BoolCtrl& autoCtrls = {},
+      const BoolCtrl& autoCtrlsValues = {});
+
+  struct ListComponentsRequest {
+    DeviceSpec deviceSpec{};
+    uint16_t maxNames{};
+  };
+
+  struct ListComponentsReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    uint16_t extra{};
+    std::vector<Listing> keymaps{};
+    std::vector<Listing> keycodes{};
+    std::vector<Listing> types{};
+    std::vector<Listing> compatMaps{};
+    std::vector<Listing> symbols{};
+    std::vector<Listing> geometries{};
+  };
+
+  using ListComponentsResponse = Response<ListComponentsReply>;
+
+  Future<ListComponentsReply> ListComponents(
+      const ListComponentsRequest& request);
+
+  Future<ListComponentsReply> ListComponents(const DeviceSpec& deviceSpec = {},
+                                             const uint16_t& maxNames = {});
+
+  struct GetKbdByNameRequest {
+    DeviceSpec deviceSpec{};
+    GBNDetail need{};
+    GBNDetail want{};
+    uint8_t load{};
+  };
+
+  struct GetKbdByNameReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    KeyCode minKeyCode{};
+    KeyCode maxKeyCode{};
+    uint8_t loaded{};
+    uint8_t newKeyboard{};
+    GBNDetail found{};
+    struct Types {
+      uint8_t getmap_type{};
+      uint8_t typeDeviceID{};
+      uint16_t getmap_sequence{};
+      uint32_t getmap_length{};
+      KeyCode typeMinKeyCode{};
+      KeyCode typeMaxKeyCode{};
+      uint8_t firstType{};
+      uint8_t nTypes{};
+      uint8_t totalTypes{};
+      KeyCode firstKeySym{};
+      uint16_t totalSyms{};
+      uint8_t nKeySyms{};
+      KeyCode firstKeyAction{};
+      uint16_t totalActions{};
+      uint8_t nKeyActions{};
+      KeyCode firstKeyBehavior{};
+      uint8_t nKeyBehaviors{};
+      uint8_t totalKeyBehaviors{};
+      KeyCode firstKeyExplicit{};
+      uint8_t nKeyExplicit{};
+      uint8_t totalKeyExplicit{};
+      KeyCode firstModMapKey{};
+      uint8_t nModMapKeys{};
+      uint8_t totalModMapKeys{};
+      KeyCode firstVModMapKey{};
+      uint8_t nVModMapKeys{};
+      uint8_t totalVModMapKeys{};
+      VMod virtualMods{};
+      absl::optional<std::vector<KeyType>> types_rtrn{};
+      absl::optional<std::vector<KeySymMap>> syms_rtrn{};
+      absl::optional<std::vector<uint8_t>> acts_rtrn_count{};
+      absl::optional<std::vector<Action>> acts_rtrn_acts{};
+      absl::optional<std::vector<SetBehavior>> behaviors_rtrn{};
+      absl::optional<std::vector<ModMask>> vmods_rtrn{};
+      absl::optional<std::vector<SetExplicit>> explicit_rtrn{};
+      absl::optional<std::vector<KeyModMap>> modmap_rtrn{};
+      absl::optional<std::vector<KeyVModMap>> vmodmap_rtrn{};
+    };
+    struct CompatMap {
+      uint8_t compatmap_type{};
+      uint8_t compatDeviceID{};
+      uint16_t compatmap_sequence{};
+      uint32_t compatmap_length{};
+      SetOfGroup groupsRtrn{};
+      uint16_t firstSIRtrn{};
+      uint16_t nTotalSI{};
+      std::vector<SymInterpret> si_rtrn{};
+      std::vector<ModDef> group_rtrn{};
+    };
+    struct IndicatorMaps {
+      uint8_t indicatormap_type{};
+      uint8_t indicatorDeviceID{};
+      uint16_t indicatormap_sequence{};
+      uint32_t indicatormap_length{};
+      uint32_t which{};
+      uint32_t realIndicators{};
+      std::vector<IndicatorMap> maps{};
+    };
+    struct KeyNames {
+      uint8_t keyname_type{};
+      uint8_t keyDeviceID{};
+      uint16_t keyname_sequence{};
+      uint32_t keyname_length{};
+      KeyCode keyMinKeyCode{};
+      KeyCode keyMaxKeyCode{};
+      uint8_t nTypes{};
+      SetOfGroup groupNames{};
+      VMod virtualMods{};
+      KeyCode firstKey{};
+      uint8_t nKeys{};
+      uint32_t indicators{};
+      uint8_t nRadioGroups{};
+      uint8_t nKeyAliases{};
+      uint16_t nKTLevels{};
+      absl::optional<Atom> keycodesName{};
+      absl::optional<Atom> geometryName{};
+      absl::optional<Atom> symbolsName{};
+      absl::optional<Atom> physSymbolsName{};
+      absl::optional<Atom> typesName{};
+      absl::optional<Atom> compatName{};
+      absl::optional<std::vector<Atom>> typeNames{};
+      absl::optional<std::vector<uint8_t>> nLevelsPerType{};
+      absl::optional<std::vector<Atom>> ktLevelNames{};
+      absl::optional<std::vector<Atom>> indicatorNames{};
+      absl::optional<std::vector<Atom>> virtualModNames{};
+      absl::optional<std::vector<Atom>> groups{};
+      absl::optional<std::vector<KeyName>> keyNames{};
+      absl::optional<std::vector<KeyAlias>> keyAliases{};
+      absl::optional<std::vector<Atom>> radioGroupNames{};
+    };
+    struct Geometry {
+      uint8_t geometry_type{};
+      uint8_t geometryDeviceID{};
+      uint16_t geometry_sequence{};
+      uint32_t geometry_length{};
+      Atom name{};
+      uint8_t geometryFound{};
+      uint16_t widthMM{};
+      uint16_t heightMM{};
+      uint16_t nProperties{};
+      uint16_t nColors{};
+      uint16_t nShapes{};
+      uint16_t nSections{};
+      uint16_t nDoodads{};
+      uint16_t nKeyAliases{};
+      uint8_t baseColorNdx{};
+      uint8_t labelColorNdx{};
+      CountedString16 labelFont{};
+    };
+    absl::optional<Types> types{};
+    absl::optional<CompatMap> compat_map{};
+    absl::optional<IndicatorMaps> indicator_maps{};
+    absl::optional<KeyNames> key_names{};
+    absl::optional<Geometry> geometry{};
+  };
+
+  using GetKbdByNameResponse = Response<GetKbdByNameReply>;
+
+  Future<GetKbdByNameReply> GetKbdByName(const GetKbdByNameRequest& request);
+
+  Future<GetKbdByNameReply> GetKbdByName(const DeviceSpec& deviceSpec = {},
+                                         const GBNDetail& need = {},
+                                         const GBNDetail& want = {},
+                                         const uint8_t& load = {});
+
+  struct GetDeviceInfoRequest {
+    DeviceSpec deviceSpec{};
+    XIFeature wanted{};
+    uint8_t allButtons{};
+    uint8_t firstButton{};
+    uint8_t nButtons{};
+    LedClass ledClass{};
+    IDSpec ledID{};
+  };
+
+  struct GetDeviceInfoReply {
+    uint8_t deviceID{};
+    uint16_t sequence{};
+    XIFeature present{};
+    XIFeature supported{};
+    XIFeature unsupported{};
+    uint8_t firstBtnWanted{};
+    uint8_t nBtnsWanted{};
+    uint8_t firstBtnRtrn{};
+    uint8_t totalBtns{};
+    uint8_t hasOwnState{};
+    uint16_t dfltKbdFB{};
+    uint16_t dfltLedFB{};
+    Atom devType{};
+    std::vector<String8> name{};
+    std::vector<Action> btnActions{};
+    std::vector<DeviceLedInfo> leds{};
+  };
+
+  using GetDeviceInfoResponse = Response<GetDeviceInfoReply>;
+
+  Future<GetDeviceInfoReply> GetDeviceInfo(const GetDeviceInfoRequest& request);
+
+  Future<GetDeviceInfoReply> GetDeviceInfo(const DeviceSpec& deviceSpec = {},
+                                           const XIFeature& wanted = {},
+                                           const uint8_t& allButtons = {},
+                                           const uint8_t& firstButton = {},
+                                           const uint8_t& nButtons = {},
+                                           const LedClass& ledClass = {},
+                                           const IDSpec& ledID = {});
+
+  struct SetDeviceInfoRequest {
+    DeviceSpec deviceSpec{};
+    uint8_t firstBtn{};
+    XIFeature change{};
+    std::vector<Action> btnActions{};
+    std::vector<DeviceLedInfo> leds{};
+  };
+
+  using SetDeviceInfoResponse = Response<void>;
+
+  Future<void> SetDeviceInfo(const SetDeviceInfoRequest& request);
+
+  Future<void> SetDeviceInfo(const DeviceSpec& deviceSpec = {},
+                             const uint8_t& firstBtn = {},
+                             const XIFeature& change = {},
+                             const std::vector<Action>& btnActions = {},
+                             const std::vector<DeviceLedInfo>& leds = {});
+
+  struct SetDebuggingFlagsRequest {
+    uint32_t affectFlags{};
+    uint32_t flags{};
+    uint32_t affectCtrls{};
+    uint32_t ctrls{};
+    std::vector<String8> message{};
+  };
+
+  struct SetDebuggingFlagsReply {
+    uint16_t sequence{};
+    uint32_t currentFlags{};
+    uint32_t currentCtrls{};
+    uint32_t supportedFlags{};
+    uint32_t supportedCtrls{};
+  };
+
+  using SetDebuggingFlagsResponse = Response<SetDebuggingFlagsReply>;
+
+  Future<SetDebuggingFlagsReply> SetDebuggingFlags(
+      const SetDebuggingFlagsRequest& request);
+
+  Future<SetDebuggingFlagsReply> SetDebuggingFlags(
+      const uint32_t& affectFlags = {},
+      const uint32_t& flags = {},
+      const uint32_t& affectCtrls = {},
+      const uint32_t& ctrls = {},
+      const std::vector<String8>& message = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Xkb::Const operator|(x11::Xkb::Const l,
+                                           x11::Xkb::Const r) {
+  using T = std::underlying_type_t<x11::Xkb::Const>;
+  return static_cast<x11::Xkb::Const>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Const operator&(x11::Xkb::Const l,
+                                           x11::Xkb::Const r) {
+  using T = std::underlying_type_t<x11::Xkb::Const>;
+  return static_cast<x11::Xkb::Const>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::EventType operator|(x11::Xkb::EventType l,
+                                               x11::Xkb::EventType r) {
+  using T = std::underlying_type_t<x11::Xkb::EventType>;
+  return static_cast<x11::Xkb::EventType>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::EventType operator&(x11::Xkb::EventType l,
+                                               x11::Xkb::EventType r) {
+  using T = std::underlying_type_t<x11::Xkb::EventType>;
+  return static_cast<x11::Xkb::EventType>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::NKNDetail operator|(x11::Xkb::NKNDetail l,
+                                               x11::Xkb::NKNDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::NKNDetail>;
+  return static_cast<x11::Xkb::NKNDetail>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::NKNDetail operator&(x11::Xkb::NKNDetail l,
+                                               x11::Xkb::NKNDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::NKNDetail>;
+  return static_cast<x11::Xkb::NKNDetail>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::AXNDetail operator|(x11::Xkb::AXNDetail l,
+                                               x11::Xkb::AXNDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::AXNDetail>;
+  return static_cast<x11::Xkb::AXNDetail>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::AXNDetail operator&(x11::Xkb::AXNDetail l,
+                                               x11::Xkb::AXNDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::AXNDetail>;
+  return static_cast<x11::Xkb::AXNDetail>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::MapPart operator|(x11::Xkb::MapPart l,
+                                             x11::Xkb::MapPart r) {
+  using T = std::underlying_type_t<x11::Xkb::MapPart>;
+  return static_cast<x11::Xkb::MapPart>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::MapPart operator&(x11::Xkb::MapPart l,
+                                             x11::Xkb::MapPart r) {
+  using T = std::underlying_type_t<x11::Xkb::MapPart>;
+  return static_cast<x11::Xkb::MapPart>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SetMapFlags operator|(x11::Xkb::SetMapFlags l,
+                                                 x11::Xkb::SetMapFlags r) {
+  using T = std::underlying_type_t<x11::Xkb::SetMapFlags>;
+  return static_cast<x11::Xkb::SetMapFlags>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SetMapFlags operator&(x11::Xkb::SetMapFlags l,
+                                                 x11::Xkb::SetMapFlags r) {
+  using T = std::underlying_type_t<x11::Xkb::SetMapFlags>;
+  return static_cast<x11::Xkb::SetMapFlags>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::StatePart operator|(x11::Xkb::StatePart l,
+                                               x11::Xkb::StatePart r) {
+  using T = std::underlying_type_t<x11::Xkb::StatePart>;
+  return static_cast<x11::Xkb::StatePart>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::StatePart operator&(x11::Xkb::StatePart l,
+                                               x11::Xkb::StatePart r) {
+  using T = std::underlying_type_t<x11::Xkb::StatePart>;
+  return static_cast<x11::Xkb::StatePart>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BoolCtrl operator|(x11::Xkb::BoolCtrl l,
+                                              x11::Xkb::BoolCtrl r) {
+  using T = std::underlying_type_t<x11::Xkb::BoolCtrl>;
+  return static_cast<x11::Xkb::BoolCtrl>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BoolCtrl operator&(x11::Xkb::BoolCtrl l,
+                                              x11::Xkb::BoolCtrl r) {
+  using T = std::underlying_type_t<x11::Xkb::BoolCtrl>;
+  return static_cast<x11::Xkb::BoolCtrl>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Control operator|(x11::Xkb::Control l,
+                                             x11::Xkb::Control r) {
+  using T = std::underlying_type_t<x11::Xkb::Control>;
+  return static_cast<x11::Xkb::Control>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Control operator&(x11::Xkb::Control l,
+                                             x11::Xkb::Control r) {
+  using T = std::underlying_type_t<x11::Xkb::Control>;
+  return static_cast<x11::Xkb::Control>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::AXOption operator|(x11::Xkb::AXOption l,
+                                              x11::Xkb::AXOption r) {
+  using T = std::underlying_type_t<x11::Xkb::AXOption>;
+  return static_cast<x11::Xkb::AXOption>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::AXOption operator&(x11::Xkb::AXOption l,
+                                              x11::Xkb::AXOption r) {
+  using T = std::underlying_type_t<x11::Xkb::AXOption>;
+  return static_cast<x11::Xkb::AXOption>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::LedClassResult operator|(
+    x11::Xkb::LedClassResult l,
+    x11::Xkb::LedClassResult r) {
+  using T = std::underlying_type_t<x11::Xkb::LedClassResult>;
+  return static_cast<x11::Xkb::LedClassResult>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::LedClassResult operator&(
+    x11::Xkb::LedClassResult l,
+    x11::Xkb::LedClassResult r) {
+  using T = std::underlying_type_t<x11::Xkb::LedClassResult>;
+  return static_cast<x11::Xkb::LedClassResult>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::LedClass operator|(x11::Xkb::LedClass l,
+                                              x11::Xkb::LedClass r) {
+  using T = std::underlying_type_t<x11::Xkb::LedClass>;
+  return static_cast<x11::Xkb::LedClass>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::LedClass operator&(x11::Xkb::LedClass l,
+                                              x11::Xkb::LedClass r) {
+  using T = std::underlying_type_t<x11::Xkb::LedClass>;
+  return static_cast<x11::Xkb::LedClass>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BellClassResult operator|(
+    x11::Xkb::BellClassResult l,
+    x11::Xkb::BellClassResult r) {
+  using T = std::underlying_type_t<x11::Xkb::BellClassResult>;
+  return static_cast<x11::Xkb::BellClassResult>(static_cast<T>(l) |
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BellClassResult operator&(
+    x11::Xkb::BellClassResult l,
+    x11::Xkb::BellClassResult r) {
+  using T = std::underlying_type_t<x11::Xkb::BellClassResult>;
+  return static_cast<x11::Xkb::BellClassResult>(static_cast<T>(l) &
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BellClass operator|(x11::Xkb::BellClass l,
+                                               x11::Xkb::BellClass r) {
+  using T = std::underlying_type_t<x11::Xkb::BellClass>;
+  return static_cast<x11::Xkb::BellClass>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BellClass operator&(x11::Xkb::BellClass l,
+                                               x11::Xkb::BellClass r) {
+  using T = std::underlying_type_t<x11::Xkb::BellClass>;
+  return static_cast<x11::Xkb::BellClass>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Id operator|(x11::Xkb::Id l, x11::Xkb::Id r) {
+  using T = std::underlying_type_t<x11::Xkb::Id>;
+  return static_cast<x11::Xkb::Id>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Id operator&(x11::Xkb::Id l, x11::Xkb::Id r) {
+  using T = std::underlying_type_t<x11::Xkb::Id>;
+  return static_cast<x11::Xkb::Id>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Group operator|(x11::Xkb::Group l,
+                                           x11::Xkb::Group r) {
+  using T = std::underlying_type_t<x11::Xkb::Group>;
+  return static_cast<x11::Xkb::Group>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Group operator&(x11::Xkb::Group l,
+                                           x11::Xkb::Group r) {
+  using T = std::underlying_type_t<x11::Xkb::Group>;
+  return static_cast<x11::Xkb::Group>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Groups operator|(x11::Xkb::Groups l,
+                                            x11::Xkb::Groups r) {
+  using T = std::underlying_type_t<x11::Xkb::Groups>;
+  return static_cast<x11::Xkb::Groups>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Groups operator&(x11::Xkb::Groups l,
+                                            x11::Xkb::Groups r) {
+  using T = std::underlying_type_t<x11::Xkb::Groups>;
+  return static_cast<x11::Xkb::Groups>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SetOfGroup operator|(x11::Xkb::SetOfGroup l,
+                                                x11::Xkb::SetOfGroup r) {
+  using T = std::underlying_type_t<x11::Xkb::SetOfGroup>;
+  return static_cast<x11::Xkb::SetOfGroup>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SetOfGroup operator&(x11::Xkb::SetOfGroup l,
+                                                x11::Xkb::SetOfGroup r) {
+  using T = std::underlying_type_t<x11::Xkb::SetOfGroup>;
+  return static_cast<x11::Xkb::SetOfGroup>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SetOfGroups operator|(x11::Xkb::SetOfGroups l,
+                                                 x11::Xkb::SetOfGroups r) {
+  using T = std::underlying_type_t<x11::Xkb::SetOfGroups>;
+  return static_cast<x11::Xkb::SetOfGroups>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SetOfGroups operator&(x11::Xkb::SetOfGroups l,
+                                                 x11::Xkb::SetOfGroups r) {
+  using T = std::underlying_type_t<x11::Xkb::SetOfGroups>;
+  return static_cast<x11::Xkb::SetOfGroups>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::GroupsWrap operator|(x11::Xkb::GroupsWrap l,
+                                                x11::Xkb::GroupsWrap r) {
+  using T = std::underlying_type_t<x11::Xkb::GroupsWrap>;
+  return static_cast<x11::Xkb::GroupsWrap>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::GroupsWrap operator&(x11::Xkb::GroupsWrap l,
+                                                x11::Xkb::GroupsWrap r) {
+  using T = std::underlying_type_t<x11::Xkb::GroupsWrap>;
+  return static_cast<x11::Xkb::GroupsWrap>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::VModsHigh operator|(x11::Xkb::VModsHigh l,
+                                               x11::Xkb::VModsHigh r) {
+  using T = std::underlying_type_t<x11::Xkb::VModsHigh>;
+  return static_cast<x11::Xkb::VModsHigh>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::VModsHigh operator&(x11::Xkb::VModsHigh l,
+                                               x11::Xkb::VModsHigh r) {
+  using T = std::underlying_type_t<x11::Xkb::VModsHigh>;
+  return static_cast<x11::Xkb::VModsHigh>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::VModsLow operator|(x11::Xkb::VModsLow l,
+                                              x11::Xkb::VModsLow r) {
+  using T = std::underlying_type_t<x11::Xkb::VModsLow>;
+  return static_cast<x11::Xkb::VModsLow>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::VModsLow operator&(x11::Xkb::VModsLow l,
+                                              x11::Xkb::VModsLow r) {
+  using T = std::underlying_type_t<x11::Xkb::VModsLow>;
+  return static_cast<x11::Xkb::VModsLow>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::VMod operator|(x11::Xkb::VMod l, x11::Xkb::VMod r) {
+  using T = std::underlying_type_t<x11::Xkb::VMod>;
+  return static_cast<x11::Xkb::VMod>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::VMod operator&(x11::Xkb::VMod l, x11::Xkb::VMod r) {
+  using T = std::underlying_type_t<x11::Xkb::VMod>;
+  return static_cast<x11::Xkb::VMod>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Explicit operator|(x11::Xkb::Explicit l,
+                                              x11::Xkb::Explicit r) {
+  using T = std::underlying_type_t<x11::Xkb::Explicit>;
+  return static_cast<x11::Xkb::Explicit>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Explicit operator&(x11::Xkb::Explicit l,
+                                              x11::Xkb::Explicit r) {
+  using T = std::underlying_type_t<x11::Xkb::Explicit>;
+  return static_cast<x11::Xkb::Explicit>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SymInterpretMatch operator|(
+    x11::Xkb::SymInterpretMatch l,
+    x11::Xkb::SymInterpretMatch r) {
+  using T = std::underlying_type_t<x11::Xkb::SymInterpretMatch>;
+  return static_cast<x11::Xkb::SymInterpretMatch>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SymInterpretMatch operator&(
+    x11::Xkb::SymInterpretMatch l,
+    x11::Xkb::SymInterpretMatch r) {
+  using T = std::underlying_type_t<x11::Xkb::SymInterpretMatch>;
+  return static_cast<x11::Xkb::SymInterpretMatch>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SymInterpMatch operator|(
+    x11::Xkb::SymInterpMatch l,
+    x11::Xkb::SymInterpMatch r) {
+  using T = std::underlying_type_t<x11::Xkb::SymInterpMatch>;
+  return static_cast<x11::Xkb::SymInterpMatch>(static_cast<T>(l) |
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SymInterpMatch operator&(
+    x11::Xkb::SymInterpMatch l,
+    x11::Xkb::SymInterpMatch r) {
+  using T = std::underlying_type_t<x11::Xkb::SymInterpMatch>;
+  return static_cast<x11::Xkb::SymInterpMatch>(static_cast<T>(l) &
+                                               static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::IMFlag operator|(x11::Xkb::IMFlag l,
+                                            x11::Xkb::IMFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::IMFlag>;
+  return static_cast<x11::Xkb::IMFlag>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::IMFlag operator&(x11::Xkb::IMFlag l,
+                                            x11::Xkb::IMFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::IMFlag>;
+  return static_cast<x11::Xkb::IMFlag>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::IMModsWhich operator|(x11::Xkb::IMModsWhich l,
+                                                 x11::Xkb::IMModsWhich r) {
+  using T = std::underlying_type_t<x11::Xkb::IMModsWhich>;
+  return static_cast<x11::Xkb::IMModsWhich>(static_cast<T>(l) |
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::IMModsWhich operator&(x11::Xkb::IMModsWhich l,
+                                                 x11::Xkb::IMModsWhich r) {
+  using T = std::underlying_type_t<x11::Xkb::IMModsWhich>;
+  return static_cast<x11::Xkb::IMModsWhich>(static_cast<T>(l) &
+                                            static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::IMGroupsWhich operator|(x11::Xkb::IMGroupsWhich l,
+                                                   x11::Xkb::IMGroupsWhich r) {
+  using T = std::underlying_type_t<x11::Xkb::IMGroupsWhich>;
+  return static_cast<x11::Xkb::IMGroupsWhich>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::IMGroupsWhich operator&(x11::Xkb::IMGroupsWhich l,
+                                                   x11::Xkb::IMGroupsWhich r) {
+  using T = std::underlying_type_t<x11::Xkb::IMGroupsWhich>;
+  return static_cast<x11::Xkb::IMGroupsWhich>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::CMDetail operator|(x11::Xkb::CMDetail l,
+                                              x11::Xkb::CMDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::CMDetail>;
+  return static_cast<x11::Xkb::CMDetail>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::CMDetail operator&(x11::Xkb::CMDetail l,
+                                              x11::Xkb::CMDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::CMDetail>;
+  return static_cast<x11::Xkb::CMDetail>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::NameDetail operator|(x11::Xkb::NameDetail l,
+                                                x11::Xkb::NameDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::NameDetail>;
+  return static_cast<x11::Xkb::NameDetail>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::NameDetail operator&(x11::Xkb::NameDetail l,
+                                                x11::Xkb::NameDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::NameDetail>;
+  return static_cast<x11::Xkb::NameDetail>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::GBNDetail operator|(x11::Xkb::GBNDetail l,
+                                               x11::Xkb::GBNDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::GBNDetail>;
+  return static_cast<x11::Xkb::GBNDetail>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::GBNDetail operator&(x11::Xkb::GBNDetail l,
+                                               x11::Xkb::GBNDetail r) {
+  using T = std::underlying_type_t<x11::Xkb::GBNDetail>;
+  return static_cast<x11::Xkb::GBNDetail>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::XIFeature operator|(x11::Xkb::XIFeature l,
+                                               x11::Xkb::XIFeature r) {
+  using T = std::underlying_type_t<x11::Xkb::XIFeature>;
+  return static_cast<x11::Xkb::XIFeature>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::XIFeature operator&(x11::Xkb::XIFeature l,
+                                               x11::Xkb::XIFeature r) {
+  using T = std::underlying_type_t<x11::Xkb::XIFeature>;
+  return static_cast<x11::Xkb::XIFeature>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::PerClientFlag operator|(x11::Xkb::PerClientFlag l,
+                                                   x11::Xkb::PerClientFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::PerClientFlag>;
+  return static_cast<x11::Xkb::PerClientFlag>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::PerClientFlag operator&(x11::Xkb::PerClientFlag l,
+                                                   x11::Xkb::PerClientFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::PerClientFlag>;
+  return static_cast<x11::Xkb::PerClientFlag>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BehaviorType operator|(x11::Xkb::BehaviorType l,
+                                                  x11::Xkb::BehaviorType r) {
+  using T = std::underlying_type_t<x11::Xkb::BehaviorType>;
+  return static_cast<x11::Xkb::BehaviorType>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BehaviorType operator&(x11::Xkb::BehaviorType l,
+                                                  x11::Xkb::BehaviorType r) {
+  using T = std::underlying_type_t<x11::Xkb::BehaviorType>;
+  return static_cast<x11::Xkb::BehaviorType>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::DoodadType operator|(x11::Xkb::DoodadType l,
+                                                x11::Xkb::DoodadType r) {
+  using T = std::underlying_type_t<x11::Xkb::DoodadType>;
+  return static_cast<x11::Xkb::DoodadType>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::DoodadType operator&(x11::Xkb::DoodadType l,
+                                                x11::Xkb::DoodadType r) {
+  using T = std::underlying_type_t<x11::Xkb::DoodadType>;
+  return static_cast<x11::Xkb::DoodadType>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Error operator|(x11::Xkb::Error l,
+                                           x11::Xkb::Error r) {
+  using T = std::underlying_type_t<x11::Xkb::Error>;
+  return static_cast<x11::Xkb::Error>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Error operator&(x11::Xkb::Error l,
+                                           x11::Xkb::Error r) {
+  using T = std::underlying_type_t<x11::Xkb::Error>;
+  return static_cast<x11::Xkb::Error>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Sa operator|(x11::Xkb::Sa l, x11::Xkb::Sa r) {
+  using T = std::underlying_type_t<x11::Xkb::Sa>;
+  return static_cast<x11::Xkb::Sa>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::Sa operator&(x11::Xkb::Sa l, x11::Xkb::Sa r) {
+  using T = std::underlying_type_t<x11::Xkb::Sa>;
+  return static_cast<x11::Xkb::Sa>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAType operator|(x11::Xkb::SAType l,
+                                            x11::Xkb::SAType r) {
+  using T = std::underlying_type_t<x11::Xkb::SAType>;
+  return static_cast<x11::Xkb::SAType>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAType operator&(x11::Xkb::SAType l,
+                                            x11::Xkb::SAType r) {
+  using T = std::underlying_type_t<x11::Xkb::SAType>;
+  return static_cast<x11::Xkb::SAType>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAMovePtrFlag operator|(x11::Xkb::SAMovePtrFlag l,
+                                                   x11::Xkb::SAMovePtrFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::SAMovePtrFlag>;
+  return static_cast<x11::Xkb::SAMovePtrFlag>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAMovePtrFlag operator&(x11::Xkb::SAMovePtrFlag l,
+                                                   x11::Xkb::SAMovePtrFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::SAMovePtrFlag>;
+  return static_cast<x11::Xkb::SAMovePtrFlag>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SASetPtrDfltFlag operator|(
+    x11::Xkb::SASetPtrDfltFlag l,
+    x11::Xkb::SASetPtrDfltFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::SASetPtrDfltFlag>;
+  return static_cast<x11::Xkb::SASetPtrDfltFlag>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SASetPtrDfltFlag operator&(
+    x11::Xkb::SASetPtrDfltFlag l,
+    x11::Xkb::SASetPtrDfltFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::SASetPtrDfltFlag>;
+  return static_cast<x11::Xkb::SASetPtrDfltFlag>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAIsoLockFlag operator|(x11::Xkb::SAIsoLockFlag l,
+                                                   x11::Xkb::SAIsoLockFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::SAIsoLockFlag>;
+  return static_cast<x11::Xkb::SAIsoLockFlag>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAIsoLockFlag operator&(x11::Xkb::SAIsoLockFlag l,
+                                                   x11::Xkb::SAIsoLockFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::SAIsoLockFlag>;
+  return static_cast<x11::Xkb::SAIsoLockFlag>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAIsoLockNoAffect operator|(
+    x11::Xkb::SAIsoLockNoAffect l,
+    x11::Xkb::SAIsoLockNoAffect r) {
+  using T = std::underlying_type_t<x11::Xkb::SAIsoLockNoAffect>;
+  return static_cast<x11::Xkb::SAIsoLockNoAffect>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAIsoLockNoAffect operator&(
+    x11::Xkb::SAIsoLockNoAffect l,
+    x11::Xkb::SAIsoLockNoAffect r) {
+  using T = std::underlying_type_t<x11::Xkb::SAIsoLockNoAffect>;
+  return static_cast<x11::Xkb::SAIsoLockNoAffect>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SwitchScreenFlag operator|(
+    x11::Xkb::SwitchScreenFlag l,
+    x11::Xkb::SwitchScreenFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::SwitchScreenFlag>;
+  return static_cast<x11::Xkb::SwitchScreenFlag>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SwitchScreenFlag operator&(
+    x11::Xkb::SwitchScreenFlag l,
+    x11::Xkb::SwitchScreenFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::SwitchScreenFlag>;
+  return static_cast<x11::Xkb::SwitchScreenFlag>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BoolCtrlsHigh operator|(x11::Xkb::BoolCtrlsHigh l,
+                                                   x11::Xkb::BoolCtrlsHigh r) {
+  using T = std::underlying_type_t<x11::Xkb::BoolCtrlsHigh>;
+  return static_cast<x11::Xkb::BoolCtrlsHigh>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BoolCtrlsHigh operator&(x11::Xkb::BoolCtrlsHigh l,
+                                                   x11::Xkb::BoolCtrlsHigh r) {
+  using T = std::underlying_type_t<x11::Xkb::BoolCtrlsHigh>;
+  return static_cast<x11::Xkb::BoolCtrlsHigh>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BoolCtrlsLow operator|(x11::Xkb::BoolCtrlsLow l,
+                                                  x11::Xkb::BoolCtrlsLow r) {
+  using T = std::underlying_type_t<x11::Xkb::BoolCtrlsLow>;
+  return static_cast<x11::Xkb::BoolCtrlsLow>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::BoolCtrlsLow operator&(x11::Xkb::BoolCtrlsLow l,
+                                                  x11::Xkb::BoolCtrlsLow r) {
+  using T = std::underlying_type_t<x11::Xkb::BoolCtrlsLow>;
+  return static_cast<x11::Xkb::BoolCtrlsLow>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::ActionMessageFlag operator|(
+    x11::Xkb::ActionMessageFlag l,
+    x11::Xkb::ActionMessageFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::ActionMessageFlag>;
+  return static_cast<x11::Xkb::ActionMessageFlag>(static_cast<T>(l) |
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::ActionMessageFlag operator&(
+    x11::Xkb::ActionMessageFlag l,
+    x11::Xkb::ActionMessageFlag r) {
+  using T = std::underlying_type_t<x11::Xkb::ActionMessageFlag>;
+  return static_cast<x11::Xkb::ActionMessageFlag>(static_cast<T>(l) &
+                                                  static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::LockDeviceFlags operator|(
+    x11::Xkb::LockDeviceFlags l,
+    x11::Xkb::LockDeviceFlags r) {
+  using T = std::underlying_type_t<x11::Xkb::LockDeviceFlags>;
+  return static_cast<x11::Xkb::LockDeviceFlags>(static_cast<T>(l) |
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::LockDeviceFlags operator&(
+    x11::Xkb::LockDeviceFlags l,
+    x11::Xkb::LockDeviceFlags r) {
+  using T = std::underlying_type_t<x11::Xkb::LockDeviceFlags>;
+  return static_cast<x11::Xkb::LockDeviceFlags>(static_cast<T>(l) &
+                                                static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAValWhat operator|(x11::Xkb::SAValWhat l,
+                                               x11::Xkb::SAValWhat r) {
+  using T = std::underlying_type_t<x11::Xkb::SAValWhat>;
+  return static_cast<x11::Xkb::SAValWhat>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Xkb::SAValWhat operator&(x11::Xkb::SAValWhat l,
+                                               x11::Xkb::SAValWhat r) {
+  using T = std::underlying_type_t<x11::Xkb::SAValWhat>;
+  return static_cast<x11::Xkb::SAValWhat>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XKB_H_
diff --git a/ui/gfx/x/generated_protos/xprint.cc b/ui/gfx/x/generated_protos/xprint.cc
new file mode 100644
index 0000000..e6d6d84
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xprint.cc
@@ -0,0 +1,1708 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xprint.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+XPrint::XPrint(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<XPrint::NotifyEvent>(XPrint::NotifyEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& context = (*event_).context;
+  auto& cancel = (*event_).cancel;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  Read(&detail, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // context
+  Read(&context, &buf);
+
+  // cancel
+  Read(&cancel, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<XPrint::AttributNotifyEvent>(XPrint::AttributNotifyEvent* event_,
+                                            ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& context = (*event_).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  Read(&detail, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // context
+  Read(&context, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+std::string XPrint::BadContextError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XPrint::BadContextError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XPrint::BadContextError>(XPrint::BadContextError* error_,
+                                        ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string XPrint::BadSequenceError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "XPrint::BadSequenceError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<XPrint::BadSequenceError>(XPrint::BadSequenceError* error_,
+                                         ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+Future<XPrint::PrintQueryVersionReply> XPrint::PrintQueryVersion(
+    const XPrint::PrintQueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintQueryVersionReply>(
+      &buf, "XPrint::PrintQueryVersion", false);
+}
+
+Future<XPrint::PrintQueryVersionReply> XPrint::PrintQueryVersion() {
+  return XPrint::PrintQueryVersion(XPrint::PrintQueryVersionRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintQueryVersionReply> detail::ReadReply<
+    XPrint::PrintQueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintQueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major_version = (*reply).major_version;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XPrint::PrintGetPrinterListReply> XPrint::PrintGetPrinterList(
+    const XPrint::PrintGetPrinterListRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t printerNameLen{};
+  uint32_t localeLen{};
+  auto& printer_name = request.printer_name;
+  size_t printer_name_len = printer_name.size();
+  auto& locale = request.locale;
+  size_t locale_len = locale.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // printerNameLen
+  printerNameLen = printer_name.size();
+  buf.Write(&printerNameLen);
+
+  // localeLen
+  localeLen = locale.size();
+  buf.Write(&localeLen);
+
+  // printer_name
+  DCHECK_EQ(static_cast<size_t>(printerNameLen), printer_name.size());
+  for (auto& printer_name_elem : printer_name) {
+    // printer_name_elem
+    buf.Write(&printer_name_elem);
+  }
+
+  // locale
+  DCHECK_EQ(static_cast<size_t>(localeLen), locale.size());
+  for (auto& locale_elem : locale) {
+    // locale_elem
+    buf.Write(&locale_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintGetPrinterListReply>(
+      &buf, "XPrint::PrintGetPrinterList", false);
+}
+
+Future<XPrint::PrintGetPrinterListReply> XPrint::PrintGetPrinterList(
+    const std::vector<String8>& printer_name,
+    const std::vector<String8>& locale) {
+  return XPrint::PrintGetPrinterList(
+      XPrint::PrintGetPrinterListRequest{printer_name, locale});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintGetPrinterListReply> detail::ReadReply<
+    XPrint::PrintGetPrinterListReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintGetPrinterListReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t listCount{};
+  auto& printers = (*reply).printers;
+  size_t printers_len = printers.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // listCount
+  Read(&listCount, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // printers
+  printers.resize(listCount);
+  for (auto& printers_elem : printers) {
+    // printers_elem
+    {
+      uint32_t nameLen{};
+      auto& name = printers_elem.name;
+      size_t name_len = name.size();
+      uint32_t descLen{};
+      auto& description = printers_elem.description;
+      size_t description_len = description.size();
+
+      // nameLen
+      Read(&nameLen, &buf);
+
+      // name
+      name.resize(nameLen);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 4);
+
+      // descLen
+      Read(&descLen, &buf);
+
+      // description
+      description.resize(descLen);
+      for (auto& description_elem : description) {
+        // description_elem
+        Read(&description_elem, &buf);
+      }
+
+      // pad1
+      Align(&buf, 4);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XPrint::PrintRehashPrinterList(
+    const XPrint::PrintRehashPrinterListRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 20;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintRehashPrinterList",
+                                        false);
+}
+
+Future<void> XPrint::PrintRehashPrinterList() {
+  return XPrint::PrintRehashPrinterList(
+      XPrint::PrintRehashPrinterListRequest{});
+}
+
+Future<void> XPrint::CreateContext(
+    const XPrint::CreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_id = request.context_id;
+  uint32_t printerNameLen{};
+  uint32_t localeLen{};
+  auto& printerName = request.printerName;
+  size_t printerName_len = printerName.size();
+  auto& locale = request.locale;
+  size_t locale_len = locale.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_id
+  buf.Write(&context_id);
+
+  // printerNameLen
+  printerNameLen = printerName.size();
+  buf.Write(&printerNameLen);
+
+  // localeLen
+  localeLen = locale.size();
+  buf.Write(&localeLen);
+
+  // printerName
+  DCHECK_EQ(static_cast<size_t>(printerNameLen), printerName.size());
+  for (auto& printerName_elem : printerName) {
+    // printerName_elem
+    buf.Write(&printerName_elem);
+  }
+
+  // locale
+  DCHECK_EQ(static_cast<size_t>(localeLen), locale.size());
+  for (auto& locale_elem : locale) {
+    // locale_elem
+    buf.Write(&locale_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::CreateContext", false);
+}
+
+Future<void> XPrint::CreateContext(const uint32_t& context_id,
+                                   const std::vector<String8>& printerName,
+                                   const std::vector<String8>& locale) {
+  return XPrint::CreateContext(
+      XPrint::CreateContextRequest{context_id, printerName, locale});
+}
+
+Future<void> XPrint::PrintSetContext(
+    const XPrint::PrintSetContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintSetContext", false);
+}
+
+Future<void> XPrint::PrintSetContext(const uint32_t& context) {
+  return XPrint::PrintSetContext(XPrint::PrintSetContextRequest{context});
+}
+
+Future<XPrint::PrintGetContextReply> XPrint::PrintGetContext(
+    const XPrint::PrintGetContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintGetContextReply>(
+      &buf, "XPrint::PrintGetContext", false);
+}
+
+Future<XPrint::PrintGetContextReply> XPrint::PrintGetContext() {
+  return XPrint::PrintGetContext(XPrint::PrintGetContextRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintGetContextReply> detail::ReadReply<
+    XPrint::PrintGetContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintGetContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context
+  Read(&context, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XPrint::PrintDestroyContext(
+    const XPrint::PrintDestroyContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintDestroyContext",
+                                        false);
+}
+
+Future<void> XPrint::PrintDestroyContext(const uint32_t& context) {
+  return XPrint::PrintDestroyContext(
+      XPrint::PrintDestroyContextRequest{context});
+}
+
+Future<XPrint::PrintGetScreenOfContextReply> XPrint::PrintGetScreenOfContext(
+    const XPrint::PrintGetScreenOfContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintGetScreenOfContextReply>(
+      &buf, "XPrint::PrintGetScreenOfContext", false);
+}
+
+Future<XPrint::PrintGetScreenOfContextReply> XPrint::PrintGetScreenOfContext() {
+  return XPrint::PrintGetScreenOfContext(
+      XPrint::PrintGetScreenOfContextRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintGetScreenOfContextReply> detail::ReadReply<
+    XPrint::PrintGetScreenOfContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintGetScreenOfContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& root = (*reply).root;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XPrint::PrintStartJob(
+    const XPrint::PrintStartJobRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& output_mode = request.output_mode;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // output_mode
+  buf.Write(&output_mode);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintStartJob", false);
+}
+
+Future<void> XPrint::PrintStartJob(const uint8_t& output_mode) {
+  return XPrint::PrintStartJob(XPrint::PrintStartJobRequest{output_mode});
+}
+
+Future<void> XPrint::PrintEndJob(const XPrint::PrintEndJobRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cancel = request.cancel;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cancel
+  buf.Write(&cancel);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintEndJob", false);
+}
+
+Future<void> XPrint::PrintEndJob(const uint8_t& cancel) {
+  return XPrint::PrintEndJob(XPrint::PrintEndJobRequest{cancel});
+}
+
+Future<void> XPrint::PrintStartDoc(
+    const XPrint::PrintStartDocRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& driver_mode = request.driver_mode;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // driver_mode
+  buf.Write(&driver_mode);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintStartDoc", false);
+}
+
+Future<void> XPrint::PrintStartDoc(const uint8_t& driver_mode) {
+  return XPrint::PrintStartDoc(XPrint::PrintStartDocRequest{driver_mode});
+}
+
+Future<void> XPrint::PrintEndDoc(const XPrint::PrintEndDocRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cancel = request.cancel;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cancel
+  buf.Write(&cancel);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintEndDoc", false);
+}
+
+Future<void> XPrint::PrintEndDoc(const uint8_t& cancel) {
+  return XPrint::PrintEndDoc(XPrint::PrintEndDocRequest{cancel});
+}
+
+Future<void> XPrint::PrintPutDocumentData(
+    const XPrint::PrintPutDocumentDataRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  uint32_t len_data{};
+  uint16_t len_fmt{};
+  uint16_t len_options{};
+  auto& data = request.data;
+  size_t data_len = data.size();
+  auto& doc_format = request.doc_format;
+  size_t doc_format_len = doc_format.size();
+  auto& options = request.options;
+  size_t options_len = options.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // len_data
+  len_data = data.size();
+  buf.Write(&len_data);
+
+  // len_fmt
+  len_fmt = doc_format.size();
+  buf.Write(&len_fmt);
+
+  // len_options
+  len_options = options.size();
+  buf.Write(&len_options);
+
+  // data
+  DCHECK_EQ(static_cast<size_t>(len_data), data.size());
+  for (auto& data_elem : data) {
+    // data_elem
+    buf.Write(&data_elem);
+  }
+
+  // doc_format
+  DCHECK_EQ(static_cast<size_t>(len_fmt), doc_format.size());
+  for (auto& doc_format_elem : doc_format) {
+    // doc_format_elem
+    buf.Write(&doc_format_elem);
+  }
+
+  // options
+  DCHECK_EQ(static_cast<size_t>(len_options), options.size());
+  for (auto& options_elem : options) {
+    // options_elem
+    buf.Write(&options_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintPutDocumentData",
+                                        false);
+}
+
+Future<void> XPrint::PrintPutDocumentData(
+    const Drawable& drawable,
+    const std::vector<uint8_t>& data,
+    const std::vector<String8>& doc_format,
+    const std::vector<String8>& options) {
+  return XPrint::PrintPutDocumentData(
+      XPrint::PrintPutDocumentDataRequest{drawable, data, doc_format, options});
+}
+
+Future<XPrint::PrintGetDocumentDataReply> XPrint::PrintGetDocumentData(
+    const XPrint::PrintGetDocumentDataRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& max_bytes = request.max_bytes;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // max_bytes
+  buf.Write(&max_bytes);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintGetDocumentDataReply>(
+      &buf, "XPrint::PrintGetDocumentData", false);
+}
+
+Future<XPrint::PrintGetDocumentDataReply> XPrint::PrintGetDocumentData(
+    const PContext& context,
+    const uint32_t& max_bytes) {
+  return XPrint::PrintGetDocumentData(
+      XPrint::PrintGetDocumentDataRequest{context, max_bytes});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintGetDocumentDataReply> detail::ReadReply<
+    XPrint::PrintGetDocumentDataReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintGetDocumentDataReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& status_code = (*reply).status_code;
+  auto& finished_flag = (*reply).finished_flag;
+  uint32_t dataLen{};
+  auto& data = (*reply).data;
+  size_t data_len = data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // status_code
+  Read(&status_code, &buf);
+
+  // finished_flag
+  Read(&finished_flag, &buf);
+
+  // dataLen
+  Read(&dataLen, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // data
+  data.resize(dataLen);
+  for (auto& data_elem : data) {
+    // data_elem
+    Read(&data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XPrint::PrintStartPage(
+    const XPrint::PrintStartPageRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintStartPage", false);
+}
+
+Future<void> XPrint::PrintStartPage(const Window& window) {
+  return XPrint::PrintStartPage(XPrint::PrintStartPageRequest{window});
+}
+
+Future<void> XPrint::PrintEndPage(const XPrint::PrintEndPageRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cancel = request.cancel;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cancel
+  buf.Write(&cancel);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintEndPage", false);
+}
+
+Future<void> XPrint::PrintEndPage(const uint8_t& cancel) {
+  return XPrint::PrintEndPage(XPrint::PrintEndPageRequest{cancel});
+}
+
+Future<void> XPrint::PrintSelectInput(
+    const XPrint::PrintSelectInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& event_mask = request.event_mask;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // event_mask
+  buf.Write(&event_mask);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintSelectInput",
+                                        false);
+}
+
+Future<void> XPrint::PrintSelectInput(const PContext& context,
+                                      const uint32_t& event_mask) {
+  return XPrint::PrintSelectInput(
+      XPrint::PrintSelectInputRequest{context, event_mask});
+}
+
+Future<XPrint::PrintInputSelectedReply> XPrint::PrintInputSelected(
+    const XPrint::PrintInputSelectedRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintInputSelectedReply>(
+      &buf, "XPrint::PrintInputSelected", false);
+}
+
+Future<XPrint::PrintInputSelectedReply> XPrint::PrintInputSelected(
+    const PContext& context) {
+  return XPrint::PrintInputSelected(XPrint::PrintInputSelectedRequest{context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintInputSelectedReply> detail::ReadReply<
+    XPrint::PrintInputSelectedReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintInputSelectedReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& event_mask = (*reply).event_mask;
+  auto& all_events_mask = (*reply).all_events_mask;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_mask
+  Read(&event_mask, &buf);
+
+  // all_events_mask
+  Read(&all_events_mask, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XPrint::PrintGetAttributesReply> XPrint::PrintGetAttributes(
+    const XPrint::PrintGetAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& pool = request.pool;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // pool
+  buf.Write(&pool);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintGetAttributesReply>(
+      &buf, "XPrint::PrintGetAttributes", false);
+}
+
+Future<XPrint::PrintGetAttributesReply> XPrint::PrintGetAttributes(
+    const PContext& context,
+    const uint8_t& pool) {
+  return XPrint::PrintGetAttributes(
+      XPrint::PrintGetAttributesRequest{context, pool});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintGetAttributesReply> detail::ReadReply<
+    XPrint::PrintGetAttributesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintGetAttributesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t stringLen{};
+  auto& attributes = (*reply).attributes;
+  size_t attributes_len = attributes.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // stringLen
+  Read(&stringLen, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // attributes
+  attributes.resize(stringLen);
+  for (auto& attributes_elem : attributes) {
+    // attributes_elem
+    Read(&attributes_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XPrint::PrintGetOneAttributesReply> XPrint::PrintGetOneAttributes(
+    const XPrint::PrintGetOneAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  uint32_t nameLen{};
+  auto& pool = request.pool;
+  auto& name = request.name;
+  size_t name_len = name.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // nameLen
+  nameLen = name.size();
+  buf.Write(&nameLen);
+
+  // pool
+  buf.Write(&pool);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(nameLen), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintGetOneAttributesReply>(
+      &buf, "XPrint::PrintGetOneAttributes", false);
+}
+
+Future<XPrint::PrintGetOneAttributesReply> XPrint::PrintGetOneAttributes(
+    const PContext& context,
+    const uint8_t& pool,
+    const std::vector<String8>& name) {
+  return XPrint::PrintGetOneAttributes(
+      XPrint::PrintGetOneAttributesRequest{context, pool, name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintGetOneAttributesReply> detail::ReadReply<
+    XPrint::PrintGetOneAttributesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintGetOneAttributesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t valueLen{};
+  auto& value = (*reply).value;
+  size_t value_len = value.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // valueLen
+  Read(&valueLen, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // value
+  value.resize(valueLen);
+  for (auto& value_elem : value) {
+    // value_elem
+    Read(&value_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XPrint::PrintSetAttributes(
+    const XPrint::PrintSetAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& stringLen = request.stringLen;
+  auto& pool = request.pool;
+  auto& rule = request.rule;
+  auto& attributes = request.attributes;
+  size_t attributes_len = attributes.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // stringLen
+  buf.Write(&stringLen);
+
+  // pool
+  buf.Write(&pool);
+
+  // rule
+  buf.Write(&rule);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // attributes
+  DCHECK_EQ(static_cast<size_t>(attributes_len), attributes.size());
+  for (auto& attributes_elem : attributes) {
+    // attributes_elem
+    buf.Write(&attributes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XPrint::PrintSetAttributes",
+                                        false);
+}
+
+Future<void> XPrint::PrintSetAttributes(
+    const PContext& context,
+    const uint32_t& stringLen,
+    const uint8_t& pool,
+    const uint8_t& rule,
+    const std::vector<String8>& attributes) {
+  return XPrint::PrintSetAttributes(XPrint::PrintSetAttributesRequest{
+      context, stringLen, pool, rule, attributes});
+}
+
+Future<XPrint::PrintGetPageDimensionsReply> XPrint::PrintGetPageDimensions(
+    const XPrint::PrintGetPageDimensionsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 21;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintGetPageDimensionsReply>(
+      &buf, "XPrint::PrintGetPageDimensions", false);
+}
+
+Future<XPrint::PrintGetPageDimensionsReply> XPrint::PrintGetPageDimensions(
+    const PContext& context) {
+  return XPrint::PrintGetPageDimensions(
+      XPrint::PrintGetPageDimensionsRequest{context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintGetPageDimensionsReply> detail::ReadReply<
+    XPrint::PrintGetPageDimensionsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintGetPageDimensionsReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& offset_x = (*reply).offset_x;
+  auto& offset_y = (*reply).offset_y;
+  auto& reproducible_width = (*reply).reproducible_width;
+  auto& reproducible_height = (*reply).reproducible_height;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // offset_x
+  Read(&offset_x, &buf);
+
+  // offset_y
+  Read(&offset_y, &buf);
+
+  // reproducible_width
+  Read(&reproducible_width, &buf);
+
+  // reproducible_height
+  Read(&reproducible_height, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XPrint::PrintQueryScreensReply> XPrint::PrintQueryScreens(
+    const XPrint::PrintQueryScreensRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 22;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintQueryScreensReply>(
+      &buf, "XPrint::PrintQueryScreens", false);
+}
+
+Future<XPrint::PrintQueryScreensReply> XPrint::PrintQueryScreens() {
+  return XPrint::PrintQueryScreens(XPrint::PrintQueryScreensRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintQueryScreensReply> detail::ReadReply<
+    XPrint::PrintQueryScreensReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintQueryScreensReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t listCount{};
+  auto& roots = (*reply).roots;
+  size_t roots_len = roots.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // listCount
+  Read(&listCount, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // roots
+  roots.resize(listCount);
+  for (auto& roots_elem : roots) {
+    // roots_elem
+    Read(&roots_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XPrint::PrintSetImageResolutionReply> XPrint::PrintSetImageResolution(
+    const XPrint::PrintSetImageResolutionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+  auto& image_resolution = request.image_resolution;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 23;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  // image_resolution
+  buf.Write(&image_resolution);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintSetImageResolutionReply>(
+      &buf, "XPrint::PrintSetImageResolution", false);
+}
+
+Future<XPrint::PrintSetImageResolutionReply> XPrint::PrintSetImageResolution(
+    const PContext& context,
+    const uint16_t& image_resolution) {
+  return XPrint::PrintSetImageResolution(
+      XPrint::PrintSetImageResolutionRequest{context, image_resolution});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintSetImageResolutionReply> detail::ReadReply<
+    XPrint::PrintSetImageResolutionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintSetImageResolutionReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+  auto& previous_resolutions = (*reply).previous_resolutions;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  Read(&status, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // previous_resolutions
+  Read(&previous_resolutions, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XPrint::PrintGetImageResolutionReply> XPrint::PrintGetImageResolution(
+    const XPrint::PrintGetImageResolutionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 24;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context
+  buf.Write(&context);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XPrint::PrintGetImageResolutionReply>(
+      &buf, "XPrint::PrintGetImageResolution", false);
+}
+
+Future<XPrint::PrintGetImageResolutionReply> XPrint::PrintGetImageResolution(
+    const PContext& context) {
+  return XPrint::PrintGetImageResolution(
+      XPrint::PrintGetImageResolutionRequest{context});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XPrint::PrintGetImageResolutionReply> detail::ReadReply<
+    XPrint::PrintGetImageResolutionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XPrint::PrintGetImageResolutionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& image_resolution = (*reply).image_resolution;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // image_resolution
+  Read(&image_resolution, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xprint.h b/ui/gfx/x/generated_protos/xprint.h
new file mode 100644
index 0000000..0b776ae
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xprint.h
@@ -0,0 +1,584 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XPRINT_H_
+#define UI_GFX_X_GENERATED_PROTOS_XPRINT_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) XPrint {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 0;
+
+  XPrint(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class String8 : char {};
+
+  enum class PContext : uint32_t {};
+
+  enum class GetDoc : int {
+    Finished = 0,
+    SecondConsumer = 1,
+  };
+
+  enum class EvMask : int {
+    NoEventMask = 0,
+    PrintMask = 1 << 0,
+    AttributeMask = 1 << 1,
+  };
+
+  enum class Detail : int {
+    StartJobNotify = 1,
+    EndJobNotify = 2,
+    StartDocNotify = 3,
+    EndDocNotify = 4,
+    StartPageNotify = 5,
+    EndPageNotify = 6,
+  };
+
+  enum class Attr : int {
+    JobAttr = 1,
+    DocAttr = 2,
+    PageAttr = 3,
+    PrinterAttr = 4,
+    ServerAttr = 5,
+    MediumAttr = 6,
+    SpoolerAttr = 7,
+  };
+
+  struct Printer {
+    std::vector<String8> name{};
+    std::vector<String8> description{};
+  };
+
+  struct NotifyEvent {
+    static constexpr int type_id = 50;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    uint8_t detail{};
+    uint16_t sequence{};
+    PContext context{};
+    uint8_t cancel{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct AttributNotifyEvent {
+    static constexpr int type_id = 51;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint8_t detail{};
+    uint16_t sequence{};
+    PContext context{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct BadContextError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadSequenceError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct PrintQueryVersionRequest {};
+
+  struct PrintQueryVersionReply {
+    uint16_t sequence{};
+    uint16_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  using PrintQueryVersionResponse = Response<PrintQueryVersionReply>;
+
+  Future<PrintQueryVersionReply> PrintQueryVersion(
+      const PrintQueryVersionRequest& request);
+
+  Future<PrintQueryVersionReply> PrintQueryVersion();
+
+  struct PrintGetPrinterListRequest {
+    std::vector<String8> printer_name{};
+    std::vector<String8> locale{};
+  };
+
+  struct PrintGetPrinterListReply {
+    uint16_t sequence{};
+    std::vector<Printer> printers{};
+  };
+
+  using PrintGetPrinterListResponse = Response<PrintGetPrinterListReply>;
+
+  Future<PrintGetPrinterListReply> PrintGetPrinterList(
+      const PrintGetPrinterListRequest& request);
+
+  Future<PrintGetPrinterListReply> PrintGetPrinterList(
+      const std::vector<String8>& printer_name = {},
+      const std::vector<String8>& locale = {});
+
+  struct PrintRehashPrinterListRequest {};
+
+  using PrintRehashPrinterListResponse = Response<void>;
+
+  Future<void> PrintRehashPrinterList(
+      const PrintRehashPrinterListRequest& request);
+
+  Future<void> PrintRehashPrinterList();
+
+  struct CreateContextRequest {
+    uint32_t context_id{};
+    std::vector<String8> printerName{};
+    std::vector<String8> locale{};
+  };
+
+  using CreateContextResponse = Response<void>;
+
+  Future<void> CreateContext(const CreateContextRequest& request);
+
+  Future<void> CreateContext(const uint32_t& context_id = {},
+                             const std::vector<String8>& printerName = {},
+                             const std::vector<String8>& locale = {});
+
+  struct PrintSetContextRequest {
+    uint32_t context{};
+  };
+
+  using PrintSetContextResponse = Response<void>;
+
+  Future<void> PrintSetContext(const PrintSetContextRequest& request);
+
+  Future<void> PrintSetContext(const uint32_t& context = {});
+
+  struct PrintGetContextRequest {};
+
+  struct PrintGetContextReply {
+    uint16_t sequence{};
+    uint32_t context{};
+  };
+
+  using PrintGetContextResponse = Response<PrintGetContextReply>;
+
+  Future<PrintGetContextReply> PrintGetContext(
+      const PrintGetContextRequest& request);
+
+  Future<PrintGetContextReply> PrintGetContext();
+
+  struct PrintDestroyContextRequest {
+    uint32_t context{};
+  };
+
+  using PrintDestroyContextResponse = Response<void>;
+
+  Future<void> PrintDestroyContext(const PrintDestroyContextRequest& request);
+
+  Future<void> PrintDestroyContext(const uint32_t& context = {});
+
+  struct PrintGetScreenOfContextRequest {};
+
+  struct PrintGetScreenOfContextReply {
+    uint16_t sequence{};
+    Window root{};
+  };
+
+  using PrintGetScreenOfContextResponse =
+      Response<PrintGetScreenOfContextReply>;
+
+  Future<PrintGetScreenOfContextReply> PrintGetScreenOfContext(
+      const PrintGetScreenOfContextRequest& request);
+
+  Future<PrintGetScreenOfContextReply> PrintGetScreenOfContext();
+
+  struct PrintStartJobRequest {
+    uint8_t output_mode{};
+  };
+
+  using PrintStartJobResponse = Response<void>;
+
+  Future<void> PrintStartJob(const PrintStartJobRequest& request);
+
+  Future<void> PrintStartJob(const uint8_t& output_mode = {});
+
+  struct PrintEndJobRequest {
+    uint8_t cancel{};
+  };
+
+  using PrintEndJobResponse = Response<void>;
+
+  Future<void> PrintEndJob(const PrintEndJobRequest& request);
+
+  Future<void> PrintEndJob(const uint8_t& cancel = {});
+
+  struct PrintStartDocRequest {
+    uint8_t driver_mode{};
+  };
+
+  using PrintStartDocResponse = Response<void>;
+
+  Future<void> PrintStartDoc(const PrintStartDocRequest& request);
+
+  Future<void> PrintStartDoc(const uint8_t& driver_mode = {});
+
+  struct PrintEndDocRequest {
+    uint8_t cancel{};
+  };
+
+  using PrintEndDocResponse = Response<void>;
+
+  Future<void> PrintEndDoc(const PrintEndDocRequest& request);
+
+  Future<void> PrintEndDoc(const uint8_t& cancel = {});
+
+  struct PrintPutDocumentDataRequest {
+    Drawable drawable{};
+    std::vector<uint8_t> data{};
+    std::vector<String8> doc_format{};
+    std::vector<String8> options{};
+  };
+
+  using PrintPutDocumentDataResponse = Response<void>;
+
+  Future<void> PrintPutDocumentData(const PrintPutDocumentDataRequest& request);
+
+  Future<void> PrintPutDocumentData(const Drawable& drawable = {},
+                                    const std::vector<uint8_t>& data = {},
+                                    const std::vector<String8>& doc_format = {},
+                                    const std::vector<String8>& options = {});
+
+  struct PrintGetDocumentDataRequest {
+    PContext context{};
+    uint32_t max_bytes{};
+  };
+
+  struct PrintGetDocumentDataReply {
+    uint16_t sequence{};
+    uint32_t status_code{};
+    uint32_t finished_flag{};
+    std::vector<uint8_t> data{};
+  };
+
+  using PrintGetDocumentDataResponse = Response<PrintGetDocumentDataReply>;
+
+  Future<PrintGetDocumentDataReply> PrintGetDocumentData(
+      const PrintGetDocumentDataRequest& request);
+
+  Future<PrintGetDocumentDataReply> PrintGetDocumentData(
+      const PContext& context = {},
+      const uint32_t& max_bytes = {});
+
+  struct PrintStartPageRequest {
+    Window window{};
+  };
+
+  using PrintStartPageResponse = Response<void>;
+
+  Future<void> PrintStartPage(const PrintStartPageRequest& request);
+
+  Future<void> PrintStartPage(const Window& window = {});
+
+  struct PrintEndPageRequest {
+    uint8_t cancel{};
+  };
+
+  using PrintEndPageResponse = Response<void>;
+
+  Future<void> PrintEndPage(const PrintEndPageRequest& request);
+
+  Future<void> PrintEndPage(const uint8_t& cancel = {});
+
+  struct PrintSelectInputRequest {
+    PContext context{};
+    uint32_t event_mask{};
+  };
+
+  using PrintSelectInputResponse = Response<void>;
+
+  Future<void> PrintSelectInput(const PrintSelectInputRequest& request);
+
+  Future<void> PrintSelectInput(const PContext& context = {},
+                                const uint32_t& event_mask = {});
+
+  struct PrintInputSelectedRequest {
+    PContext context{};
+  };
+
+  struct PrintInputSelectedReply {
+    uint16_t sequence{};
+    uint32_t event_mask{};
+    uint32_t all_events_mask{};
+  };
+
+  using PrintInputSelectedResponse = Response<PrintInputSelectedReply>;
+
+  Future<PrintInputSelectedReply> PrintInputSelected(
+      const PrintInputSelectedRequest& request);
+
+  Future<PrintInputSelectedReply> PrintInputSelected(
+      const PContext& context = {});
+
+  struct PrintGetAttributesRequest {
+    PContext context{};
+    uint8_t pool{};
+  };
+
+  struct PrintGetAttributesReply {
+    uint16_t sequence{};
+    std::vector<String8> attributes{};
+  };
+
+  using PrintGetAttributesResponse = Response<PrintGetAttributesReply>;
+
+  Future<PrintGetAttributesReply> PrintGetAttributes(
+      const PrintGetAttributesRequest& request);
+
+  Future<PrintGetAttributesReply> PrintGetAttributes(
+      const PContext& context = {},
+      const uint8_t& pool = {});
+
+  struct PrintGetOneAttributesRequest {
+    PContext context{};
+    uint8_t pool{};
+    std::vector<String8> name{};
+  };
+
+  struct PrintGetOneAttributesReply {
+    uint16_t sequence{};
+    std::vector<String8> value{};
+  };
+
+  using PrintGetOneAttributesResponse = Response<PrintGetOneAttributesReply>;
+
+  Future<PrintGetOneAttributesReply> PrintGetOneAttributes(
+      const PrintGetOneAttributesRequest& request);
+
+  Future<PrintGetOneAttributesReply> PrintGetOneAttributes(
+      const PContext& context = {},
+      const uint8_t& pool = {},
+      const std::vector<String8>& name = {});
+
+  struct PrintSetAttributesRequest {
+    PContext context{};
+    uint32_t stringLen{};
+    uint8_t pool{};
+    uint8_t rule{};
+    std::vector<String8> attributes{};
+  };
+
+  using PrintSetAttributesResponse = Response<void>;
+
+  Future<void> PrintSetAttributes(const PrintSetAttributesRequest& request);
+
+  Future<void> PrintSetAttributes(const PContext& context = {},
+                                  const uint32_t& stringLen = {},
+                                  const uint8_t& pool = {},
+                                  const uint8_t& rule = {},
+                                  const std::vector<String8>& attributes = {});
+
+  struct PrintGetPageDimensionsRequest {
+    PContext context{};
+  };
+
+  struct PrintGetPageDimensionsReply {
+    uint16_t sequence{};
+    uint16_t width{};
+    uint16_t height{};
+    uint16_t offset_x{};
+    uint16_t offset_y{};
+    uint16_t reproducible_width{};
+    uint16_t reproducible_height{};
+  };
+
+  using PrintGetPageDimensionsResponse = Response<PrintGetPageDimensionsReply>;
+
+  Future<PrintGetPageDimensionsReply> PrintGetPageDimensions(
+      const PrintGetPageDimensionsRequest& request);
+
+  Future<PrintGetPageDimensionsReply> PrintGetPageDimensions(
+      const PContext& context = {});
+
+  struct PrintQueryScreensRequest {};
+
+  struct PrintQueryScreensReply {
+    uint16_t sequence{};
+    std::vector<Window> roots{};
+  };
+
+  using PrintQueryScreensResponse = Response<PrintQueryScreensReply>;
+
+  Future<PrintQueryScreensReply> PrintQueryScreens(
+      const PrintQueryScreensRequest& request);
+
+  Future<PrintQueryScreensReply> PrintQueryScreens();
+
+  struct PrintSetImageResolutionRequest {
+    PContext context{};
+    uint16_t image_resolution{};
+  };
+
+  struct PrintSetImageResolutionReply {
+    uint8_t status{};
+    uint16_t sequence{};
+    uint16_t previous_resolutions{};
+  };
+
+  using PrintSetImageResolutionResponse =
+      Response<PrintSetImageResolutionReply>;
+
+  Future<PrintSetImageResolutionReply> PrintSetImageResolution(
+      const PrintSetImageResolutionRequest& request);
+
+  Future<PrintSetImageResolutionReply> PrintSetImageResolution(
+      const PContext& context = {},
+      const uint16_t& image_resolution = {});
+
+  struct PrintGetImageResolutionRequest {
+    PContext context{};
+  };
+
+  struct PrintGetImageResolutionReply {
+    uint16_t sequence{};
+    uint16_t image_resolution{};
+  };
+
+  using PrintGetImageResolutionResponse =
+      Response<PrintGetImageResolutionReply>;
+
+  Future<PrintGetImageResolutionReply> PrintGetImageResolution(
+      const PrintGetImageResolutionRequest& request);
+
+  Future<PrintGetImageResolutionReply> PrintGetImageResolution(
+      const PContext& context = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::XPrint::GetDoc operator|(x11::XPrint::GetDoc l,
+                                               x11::XPrint::GetDoc r) {
+  using T = std::underlying_type_t<x11::XPrint::GetDoc>;
+  return static_cast<x11::XPrint::GetDoc>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::XPrint::GetDoc operator&(x11::XPrint::GetDoc l,
+                                               x11::XPrint::GetDoc r) {
+  using T = std::underlying_type_t<x11::XPrint::GetDoc>;
+  return static_cast<x11::XPrint::GetDoc>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::XPrint::EvMask operator|(x11::XPrint::EvMask l,
+                                               x11::XPrint::EvMask r) {
+  using T = std::underlying_type_t<x11::XPrint::EvMask>;
+  return static_cast<x11::XPrint::EvMask>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::XPrint::EvMask operator&(x11::XPrint::EvMask l,
+                                               x11::XPrint::EvMask r) {
+  using T = std::underlying_type_t<x11::XPrint::EvMask>;
+  return static_cast<x11::XPrint::EvMask>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::XPrint::Detail operator|(x11::XPrint::Detail l,
+                                               x11::XPrint::Detail r) {
+  using T = std::underlying_type_t<x11::XPrint::Detail>;
+  return static_cast<x11::XPrint::Detail>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::XPrint::Detail operator&(x11::XPrint::Detail l,
+                                               x11::XPrint::Detail r) {
+  using T = std::underlying_type_t<x11::XPrint::Detail>;
+  return static_cast<x11::XPrint::Detail>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::XPrint::Attr operator|(x11::XPrint::Attr l,
+                                             x11::XPrint::Attr r) {
+  using T = std::underlying_type_t<x11::XPrint::Attr>;
+  return static_cast<x11::XPrint::Attr>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::XPrint::Attr operator&(x11::XPrint::Attr l,
+                                             x11::XPrint::Attr r) {
+  using T = std::underlying_type_t<x11::XPrint::Attr>;
+  return static_cast<x11::XPrint::Attr>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XPRINT_H_
diff --git a/ui/gfx/x/generated_protos/xproto.cc b/ui/gfx/x/generated_protos/xproto.cc
new file mode 100644
index 0000000..0d8e008
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xproto.cc
@@ -0,0 +1,11439 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xproto.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+XProto::XProto(Connection* connection) : connection_(connection) {}
+
+template <>
+COMPONENT_EXPORT(X11)
+Setup Read<Setup>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  Setup obj;
+
+  auto& status = obj.status;
+  auto& protocol_major_version = obj.protocol_major_version;
+  auto& protocol_minor_version = obj.protocol_minor_version;
+  auto& length = obj.length;
+  auto& release_number = obj.release_number;
+  auto& resource_id_base = obj.resource_id_base;
+  auto& resource_id_mask = obj.resource_id_mask;
+  auto& motion_buffer_size = obj.motion_buffer_size;
+  uint16_t vendor_len{};
+  auto& maximum_request_length = obj.maximum_request_length;
+  uint8_t roots_len{};
+  uint8_t pixmap_formats_len{};
+  auto& image_byte_order = obj.image_byte_order;
+  auto& bitmap_format_bit_order = obj.bitmap_format_bit_order;
+  auto& bitmap_format_scanline_unit = obj.bitmap_format_scanline_unit;
+  auto& bitmap_format_scanline_pad = obj.bitmap_format_scanline_pad;
+  auto& min_keycode = obj.min_keycode;
+  auto& max_keycode = obj.max_keycode;
+  auto& vendor = obj.vendor;
+  auto& pixmap_formats = obj.pixmap_formats;
+  auto& roots = obj.roots;
+
+  // status
+  Read(&status, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // protocol_major_version
+  Read(&protocol_major_version, &buf);
+
+  // protocol_minor_version
+  Read(&protocol_minor_version, &buf);
+
+  // length
+  Read(&length, &buf);
+
+  // release_number
+  Read(&release_number, &buf);
+
+  // resource_id_base
+  Read(&resource_id_base, &buf);
+
+  // resource_id_mask
+  Read(&resource_id_mask, &buf);
+
+  // motion_buffer_size
+  Read(&motion_buffer_size, &buf);
+
+  // vendor_len
+  Read(&vendor_len, &buf);
+
+  // maximum_request_length
+  Read(&maximum_request_length, &buf);
+
+  // roots_len
+  Read(&roots_len, &buf);
+
+  // pixmap_formats_len
+  Read(&pixmap_formats_len, &buf);
+
+  // image_byte_order
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  image_byte_order = static_cast<ImageOrder>(tmp0);
+
+  // bitmap_format_bit_order
+  uint8_t tmp1;
+  Read(&tmp1, &buf);
+  bitmap_format_bit_order = static_cast<ImageOrder>(tmp1);
+
+  // bitmap_format_scanline_unit
+  Read(&bitmap_format_scanline_unit, &buf);
+
+  // bitmap_format_scanline_pad
+  Read(&bitmap_format_scanline_pad, &buf);
+
+  // min_keycode
+  Read(&min_keycode, &buf);
+
+  // max_keycode
+  Read(&max_keycode, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // vendor
+  vendor.resize(vendor_len);
+  for (auto& vendor_elem : vendor) {
+    // vendor_elem
+    Read(&vendor_elem, &buf);
+  }
+
+  // pad2
+  Align(&buf, 4);
+
+  // pixmap_formats
+  pixmap_formats.resize(pixmap_formats_len);
+  for (auto& pixmap_formats_elem : pixmap_formats) {
+    // pixmap_formats_elem
+    {
+      auto& depth = pixmap_formats_elem.depth;
+      auto& bits_per_pixel = pixmap_formats_elem.bits_per_pixel;
+      auto& scanline_pad = pixmap_formats_elem.scanline_pad;
+
+      // depth
+      Read(&depth, &buf);
+
+      // bits_per_pixel
+      Read(&bits_per_pixel, &buf);
+
+      // scanline_pad
+      Read(&scanline_pad, &buf);
+
+      // pad0
+      Pad(&buf, 5);
+    }
+  }
+
+  // roots
+  roots.resize(roots_len);
+  for (auto& roots_elem : roots) {
+    // roots_elem
+    {
+      auto& root = roots_elem.root;
+      auto& default_colormap = roots_elem.default_colormap;
+      auto& white_pixel = roots_elem.white_pixel;
+      auto& black_pixel = roots_elem.black_pixel;
+      auto& current_input_masks = roots_elem.current_input_masks;
+      auto& width_in_pixels = roots_elem.width_in_pixels;
+      auto& height_in_pixels = roots_elem.height_in_pixels;
+      auto& width_in_millimeters = roots_elem.width_in_millimeters;
+      auto& height_in_millimeters = roots_elem.height_in_millimeters;
+      auto& min_installed_maps = roots_elem.min_installed_maps;
+      auto& max_installed_maps = roots_elem.max_installed_maps;
+      auto& root_visual = roots_elem.root_visual;
+      auto& backing_stores = roots_elem.backing_stores;
+      auto& save_unders = roots_elem.save_unders;
+      auto& root_depth = roots_elem.root_depth;
+      uint8_t allowed_depths_len{};
+      auto& allowed_depths = roots_elem.allowed_depths;
+
+      // root
+      Read(&root, &buf);
+
+      // default_colormap
+      Read(&default_colormap, &buf);
+
+      // white_pixel
+      Read(&white_pixel, &buf);
+
+      // black_pixel
+      Read(&black_pixel, &buf);
+
+      // current_input_masks
+      uint32_t tmp2;
+      Read(&tmp2, &buf);
+      current_input_masks = static_cast<EventMask>(tmp2);
+
+      // width_in_pixels
+      Read(&width_in_pixels, &buf);
+
+      // height_in_pixels
+      Read(&height_in_pixels, &buf);
+
+      // width_in_millimeters
+      Read(&width_in_millimeters, &buf);
+
+      // height_in_millimeters
+      Read(&height_in_millimeters, &buf);
+
+      // min_installed_maps
+      Read(&min_installed_maps, &buf);
+
+      // max_installed_maps
+      Read(&max_installed_maps, &buf);
+
+      // root_visual
+      Read(&root_visual, &buf);
+
+      // backing_stores
+      uint8_t tmp3;
+      Read(&tmp3, &buf);
+      backing_stores = static_cast<BackingStore>(tmp3);
+
+      // save_unders
+      Read(&save_unders, &buf);
+
+      // root_depth
+      Read(&root_depth, &buf);
+
+      // allowed_depths_len
+      Read(&allowed_depths_len, &buf);
+
+      // allowed_depths
+      allowed_depths.resize(allowed_depths_len);
+      for (auto& allowed_depths_elem : allowed_depths) {
+        // allowed_depths_elem
+        {
+          auto& depth = allowed_depths_elem.depth;
+          uint16_t visuals_len{};
+          auto& visuals = allowed_depths_elem.visuals;
+
+          // depth
+          Read(&depth, &buf);
+
+          // pad0
+          Pad(&buf, 1);
+
+          // visuals_len
+          Read(&visuals_len, &buf);
+
+          // pad1
+          Pad(&buf, 4);
+
+          // visuals
+          visuals.resize(visuals_len);
+          for (auto& visuals_elem : visuals) {
+            // visuals_elem
+            {
+              auto& visual_id = visuals_elem.visual_id;
+              auto& c_class = visuals_elem.c_class;
+              auto& bits_per_rgb_value = visuals_elem.bits_per_rgb_value;
+              auto& colormap_entries = visuals_elem.colormap_entries;
+              auto& red_mask = visuals_elem.red_mask;
+              auto& green_mask = visuals_elem.green_mask;
+              auto& blue_mask = visuals_elem.blue_mask;
+
+              // visual_id
+              Read(&visual_id, &buf);
+
+              // c_class
+              uint8_t tmp4;
+              Read(&tmp4, &buf);
+              c_class = static_cast<VisualClass>(tmp4);
+
+              // bits_per_rgb_value
+              Read(&bits_per_rgb_value, &buf);
+
+              // colormap_entries
+              Read(&colormap_entries, &buf);
+
+              // red_mask
+              Read(&red_mask, &buf);
+
+              // green_mask
+              Read(&green_mask, &buf);
+
+              // blue_mask
+              Read(&blue_mask, &buf);
+
+              // pad0
+              Pad(&buf, 4);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return obj;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+WriteBuffer Write<KeyEvent>(const KeyEvent& obj) {
+  WriteBuffer buf;
+
+  auto& detail = obj.detail;
+  auto& sequence = obj.sequence;
+  auto& time = obj.time;
+  auto& root = obj.root;
+  auto& event = obj.event;
+  auto& child = obj.child;
+  auto& root_x = obj.root_x;
+  auto& root_y = obj.root_y;
+  auto& event_x = obj.event_x;
+  auto& event_y = obj.event_y;
+  auto& state = obj.state;
+  auto& same_screen = obj.same_screen;
+
+  // response_type
+  uint8_t response_type = obj.opcode;
+  buf.Write(&response_type);
+
+  // detail
+  buf.Write(&detail);
+
+  // sequence
+  buf.Write(&sequence);
+
+  // time
+  buf.Write(&time);
+
+  // root
+  buf.Write(&root);
+
+  // event
+  buf.Write(&event);
+
+  // child
+  buf.Write(&child);
+
+  // root_x
+  buf.Write(&root_x);
+
+  // root_y
+  buf.Write(&root_y);
+
+  // event_x
+  buf.Write(&event_x);
+
+  // event_y
+  buf.Write(&event_y);
+
+  // state
+  uint16_t tmp5;
+  tmp5 = static_cast<uint16_t>(state);
+  buf.Write(&tmp5);
+
+  // same_screen
+  buf.Write(&same_screen);
+
+  // pad0
+  Pad(&buf, 1);
+
+  return buf;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<KeyEvent>(KeyEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& child = (*event_).child;
+  auto& root_x = (*event_).root_x;
+  auto& root_y = (*event_).root_y;
+  auto& event_x = (*event_).event_x;
+  auto& event_y = (*event_).event_y;
+  auto& state = (*event_).state;
+  auto& same_screen = (*event_).same_screen;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  Read(&detail, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // event_x
+  Read(&event_x, &buf);
+
+  // event_y
+  Read(&event_y, &buf);
+
+  // state
+  uint16_t tmp6;
+  Read(&tmp6, &buf);
+  state = static_cast<KeyButMask>(tmp6);
+
+  // same_screen
+  Read(&same_screen, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+WriteBuffer Write<ButtonEvent>(const ButtonEvent& obj) {
+  WriteBuffer buf;
+
+  auto& detail = obj.detail;
+  auto& sequence = obj.sequence;
+  auto& time = obj.time;
+  auto& root = obj.root;
+  auto& event = obj.event;
+  auto& child = obj.child;
+  auto& root_x = obj.root_x;
+  auto& root_y = obj.root_y;
+  auto& event_x = obj.event_x;
+  auto& event_y = obj.event_y;
+  auto& state = obj.state;
+  auto& same_screen = obj.same_screen;
+
+  // response_type
+  uint8_t response_type = obj.opcode;
+  buf.Write(&response_type);
+
+  // detail
+  buf.Write(&detail);
+
+  // sequence
+  buf.Write(&sequence);
+
+  // time
+  buf.Write(&time);
+
+  // root
+  buf.Write(&root);
+
+  // event
+  buf.Write(&event);
+
+  // child
+  buf.Write(&child);
+
+  // root_x
+  buf.Write(&root_x);
+
+  // root_y
+  buf.Write(&root_y);
+
+  // event_x
+  buf.Write(&event_x);
+
+  // event_y
+  buf.Write(&event_y);
+
+  // state
+  uint16_t tmp7;
+  tmp7 = static_cast<uint16_t>(state);
+  buf.Write(&tmp7);
+
+  // same_screen
+  buf.Write(&same_screen);
+
+  // pad0
+  Pad(&buf, 1);
+
+  return buf;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ButtonEvent>(ButtonEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& child = (*event_).child;
+  auto& root_x = (*event_).root_x;
+  auto& root_y = (*event_).root_y;
+  auto& event_x = (*event_).event_x;
+  auto& event_y = (*event_).event_y;
+  auto& state = (*event_).state;
+  auto& same_screen = (*event_).same_screen;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  Read(&detail, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // event_x
+  Read(&event_x, &buf);
+
+  // event_y
+  Read(&event_y, &buf);
+
+  // state
+  uint16_t tmp8;
+  Read(&tmp8, &buf);
+  state = static_cast<KeyButMask>(tmp8);
+
+  // same_screen
+  Read(&same_screen, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+WriteBuffer Write<MotionNotifyEvent>(const MotionNotifyEvent& obj) {
+  WriteBuffer buf;
+
+  auto& detail = obj.detail;
+  auto& sequence = obj.sequence;
+  auto& time = obj.time;
+  auto& root = obj.root;
+  auto& event = obj.event;
+  auto& child = obj.child;
+  auto& root_x = obj.root_x;
+  auto& root_y = obj.root_y;
+  auto& event_x = obj.event_x;
+  auto& event_y = obj.event_y;
+  auto& state = obj.state;
+  auto& same_screen = obj.same_screen;
+
+  // response_type
+  uint8_t response_type = 6;
+  buf.Write(&response_type);
+
+  // detail
+  uint8_t tmp9;
+  tmp9 = static_cast<uint8_t>(detail);
+  buf.Write(&tmp9);
+
+  // sequence
+  buf.Write(&sequence);
+
+  // time
+  buf.Write(&time);
+
+  // root
+  buf.Write(&root);
+
+  // event
+  buf.Write(&event);
+
+  // child
+  buf.Write(&child);
+
+  // root_x
+  buf.Write(&root_x);
+
+  // root_y
+  buf.Write(&root_y);
+
+  // event_x
+  buf.Write(&event_x);
+
+  // event_y
+  buf.Write(&event_y);
+
+  // state
+  uint16_t tmp10;
+  tmp10 = static_cast<uint16_t>(state);
+  buf.Write(&tmp10);
+
+  // same_screen
+  buf.Write(&same_screen);
+
+  // pad0
+  Pad(&buf, 1);
+
+  return buf;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<MotionNotifyEvent>(MotionNotifyEvent* event_,
+                                  ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& child = (*event_).child;
+  auto& root_x = (*event_).root_x;
+  auto& root_y = (*event_).root_y;
+  auto& event_x = (*event_).event_x;
+  auto& event_y = (*event_).event_y;
+  auto& state = (*event_).state;
+  auto& same_screen = (*event_).same_screen;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  uint8_t tmp11;
+  Read(&tmp11, &buf);
+  detail = static_cast<Motion>(tmp11);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // event_x
+  Read(&event_x, &buf);
+
+  // event_y
+  Read(&event_y, &buf);
+
+  // state
+  uint16_t tmp12;
+  Read(&tmp12, &buf);
+  state = static_cast<KeyButMask>(tmp12);
+
+  // same_screen
+  Read(&same_screen, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<CrossingEvent>(CrossingEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& root = (*event_).root;
+  auto& event = (*event_).event;
+  auto& child = (*event_).child;
+  auto& root_x = (*event_).root_x;
+  auto& root_y = (*event_).root_y;
+  auto& event_x = (*event_).event_x;
+  auto& event_y = (*event_).event_y;
+  auto& state = (*event_).state;
+  auto& mode = (*event_).mode;
+  auto& same_screen_focus = (*event_).same_screen_focus;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  uint8_t tmp13;
+  Read(&tmp13, &buf);
+  detail = static_cast<NotifyDetail>(tmp13);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // event_x
+  Read(&event_x, &buf);
+
+  // event_y
+  Read(&event_y, &buf);
+
+  // state
+  uint16_t tmp14;
+  Read(&tmp14, &buf);
+  state = static_cast<KeyButMask>(tmp14);
+
+  // mode
+  uint8_t tmp15;
+  Read(&tmp15, &buf);
+  mode = static_cast<NotifyMode>(tmp15);
+
+  // same_screen_focus
+  Read(&same_screen_focus, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<FocusEvent>(FocusEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& detail = (*event_).detail;
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& mode = (*event_).mode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // detail
+  uint8_t tmp16;
+  Read(&tmp16, &buf);
+  detail = static_cast<NotifyDetail>(tmp16);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // mode
+  uint8_t tmp17;
+  Read(&tmp17, &buf);
+  mode = static_cast<NotifyMode>(tmp17);
+
+  // pad0
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<KeymapNotifyEvent>(KeymapNotifyEvent* event_,
+                                  ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& keys = (*event_).keys;
+  size_t keys_len = keys.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // keys
+  for (auto& keys_elem : keys) {
+    // keys_elem
+    Read(&keys_elem, &buf);
+  }
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+WriteBuffer Write<ExposeEvent>(const ExposeEvent& obj) {
+  WriteBuffer buf;
+
+  auto& sequence = obj.sequence;
+  auto& window = obj.window;
+  auto& x = obj.x;
+  auto& y = obj.y;
+  auto& width = obj.width;
+  auto& height = obj.height;
+  auto& count = obj.count;
+
+  // response_type
+  uint8_t response_type = 12;
+  buf.Write(&response_type);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  buf.Write(&sequence);
+
+  // window
+  buf.Write(&window);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // count
+  buf.Write(&count);
+
+  // pad1
+  Pad(&buf, 2);
+
+  return buf;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ExposeEvent>(ExposeEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& window = (*event_).window;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+  auto& count = (*event_).count;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  // pad1
+  Pad(&buf, 2);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<GraphicsExposureEvent>(GraphicsExposureEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& drawable = (*event_).drawable;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+  auto& minor_opcode = (*event_).minor_opcode;
+  auto& count = (*event_).count;
+  auto& major_opcode = (*event_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad1
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<NoExposureEvent>(NoExposureEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& drawable = (*event_).drawable;
+  auto& minor_opcode = (*event_).minor_opcode;
+  auto& major_opcode = (*event_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<VisibilityNotifyEvent>(VisibilityNotifyEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& window = (*event_).window;
+  auto& state = (*event_).state;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // state
+  uint8_t tmp18;
+  Read(&tmp18, &buf);
+  state = static_cast<Visibility>(tmp18);
+
+  // pad1
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<CreateNotifyEvent>(CreateNotifyEvent* event_,
+                                  ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& parent = (*event_).parent;
+  auto& window = (*event_).window;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+  auto& border_width = (*event_).border_width;
+  auto& override_redirect = (*event_).override_redirect;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // parent
+  Read(&parent, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // border_width
+  Read(&border_width, &buf);
+
+  // override_redirect
+  Read(&override_redirect, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<DestroyNotifyEvent>(DestroyNotifyEvent* event_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+WriteBuffer Write<UnmapNotifyEvent>(const UnmapNotifyEvent& obj) {
+  WriteBuffer buf;
+
+  auto& sequence = obj.sequence;
+  auto& event = obj.event;
+  auto& window = obj.window;
+  auto& from_configure = obj.from_configure;
+
+  // response_type
+  uint8_t response_type = 18;
+  buf.Write(&response_type);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  buf.Write(&sequence);
+
+  // event
+  buf.Write(&event);
+
+  // window
+  buf.Write(&window);
+
+  // from_configure
+  buf.Write(&from_configure);
+
+  // pad1
+  Pad(&buf, 3);
+
+  return buf;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<UnmapNotifyEvent>(UnmapNotifyEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& from_configure = (*event_).from_configure;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // from_configure
+  Read(&from_configure, &buf);
+
+  // pad1
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<MapNotifyEvent>(MapNotifyEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& override_redirect = (*event_).override_redirect;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // override_redirect
+  Read(&override_redirect, &buf);
+
+  // pad1
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<MapRequestEvent>(MapRequestEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& parent = (*event_).parent;
+  auto& window = (*event_).window;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // parent
+  Read(&parent, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ReparentNotifyEvent>(ReparentNotifyEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& parent = (*event_).parent;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+  auto& override_redirect = (*event_).override_redirect;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // parent
+  Read(&parent, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // override_redirect
+  Read(&override_redirect, &buf);
+
+  // pad1
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ConfigureNotifyEvent>(ConfigureNotifyEvent* event_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& above_sibling = (*event_).above_sibling;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+  auto& border_width = (*event_).border_width;
+  auto& override_redirect = (*event_).override_redirect;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // above_sibling
+  Read(&above_sibling, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // border_width
+  Read(&border_width, &buf);
+
+  // override_redirect
+  Read(&override_redirect, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ConfigureRequestEvent>(ConfigureRequestEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& stack_mode = (*event_).stack_mode;
+  auto& sequence = (*event_).sequence;
+  auto& parent = (*event_).parent;
+  auto& window = (*event_).window;
+  auto& sibling = (*event_).sibling;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+  auto& border_width = (*event_).border_width;
+  auto& value_mask = (*event_).value_mask;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // stack_mode
+  uint8_t tmp19;
+  Read(&tmp19, &buf);
+  stack_mode = static_cast<StackMode>(tmp19);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // parent
+  Read(&parent, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // sibling
+  Read(&sibling, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // border_width
+  Read(&border_width, &buf);
+
+  // value_mask
+  uint16_t tmp20;
+  Read(&tmp20, &buf);
+  value_mask = static_cast<ConfigWindow>(tmp20);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<GravityNotifyEvent>(GravityNotifyEvent* event_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& x = (*event_).x;
+  auto& y = (*event_).y;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ResizeRequestEvent>(ResizeRequestEvent* event_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& window = (*event_).window;
+  auto& width = (*event_).width;
+  auto& height = (*event_).height;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<CirculateEvent>(CirculateEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& event = (*event_).event;
+  auto& window = (*event_).window;
+  auto& place = (*event_).place;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // event
+  Read(&event, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // pad1
+  Pad(&buf, 4);
+
+  // place
+  uint8_t tmp21;
+  Read(&tmp21, &buf);
+  place = static_cast<Place>(tmp21);
+
+  // pad2
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+WriteBuffer Write<PropertyNotifyEvent>(const PropertyNotifyEvent& obj) {
+  WriteBuffer buf;
+
+  auto& sequence = obj.sequence;
+  auto& window = obj.window;
+  auto& atom = obj.atom;
+  auto& time = obj.time;
+  auto& state = obj.state;
+
+  // response_type
+  uint8_t response_type = 28;
+  buf.Write(&response_type);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  buf.Write(&sequence);
+
+  // window
+  buf.Write(&window);
+
+  // atom
+  buf.Write(&atom);
+
+  // time
+  buf.Write(&time);
+
+  // state
+  uint8_t tmp22;
+  tmp22 = static_cast<uint8_t>(state);
+  buf.Write(&tmp22);
+
+  // pad1
+  Pad(&buf, 3);
+
+  return buf;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<PropertyNotifyEvent>(PropertyNotifyEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& window = (*event_).window;
+  auto& atom = (*event_).atom;
+  auto& time = (*event_).time;
+  auto& state = (*event_).state;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // atom
+  Read(&atom, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // state
+  uint8_t tmp23;
+  Read(&tmp23, &buf);
+  state = static_cast<Property>(tmp23);
+
+  // pad1
+  Pad(&buf, 3);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<SelectionClearEvent>(SelectionClearEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& owner = (*event_).owner;
+  auto& selection = (*event_).selection;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // owner
+  Read(&owner, &buf);
+
+  // selection
+  Read(&selection, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<SelectionRequestEvent>(SelectionRequestEvent* event_,
+                                      ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& owner = (*event_).owner;
+  auto& requestor = (*event_).requestor;
+  auto& selection = (*event_).selection;
+  auto& target = (*event_).target;
+  auto& property = (*event_).property;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // owner
+  Read(&owner, &buf);
+
+  // requestor
+  Read(&requestor, &buf);
+
+  // selection
+  Read(&selection, &buf);
+
+  // target
+  Read(&target, &buf);
+
+  // property
+  Read(&property, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+WriteBuffer Write<SelectionNotifyEvent>(const SelectionNotifyEvent& obj) {
+  WriteBuffer buf;
+
+  auto& sequence = obj.sequence;
+  auto& time = obj.time;
+  auto& requestor = obj.requestor;
+  auto& selection = obj.selection;
+  auto& target = obj.target;
+  auto& property = obj.property;
+
+  // response_type
+  uint8_t response_type = 31;
+  buf.Write(&response_type);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  buf.Write(&sequence);
+
+  // time
+  buf.Write(&time);
+
+  // requestor
+  buf.Write(&requestor);
+
+  // selection
+  buf.Write(&selection);
+
+  // target
+  buf.Write(&target);
+
+  // property
+  buf.Write(&property);
+
+  return buf;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<SelectionNotifyEvent>(SelectionNotifyEvent* event_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& requestor = (*event_).requestor;
+  auto& selection = (*event_).selection;
+  auto& target = (*event_).target;
+  auto& property = (*event_).property;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // requestor
+  Read(&requestor, &buf);
+
+  // selection
+  Read(&selection, &buf);
+
+  // target
+  Read(&target, &buf);
+
+  // property
+  Read(&property, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ColormapNotifyEvent>(ColormapNotifyEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& window = (*event_).window;
+  auto& colormap = (*event_).colormap;
+  auto& c_new = (*event_).c_new;
+  auto& state = (*event_).state;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // colormap
+  Read(&colormap, &buf);
+
+  // c_new
+  Read(&c_new, &buf);
+
+  // state
+  uint8_t tmp24;
+  Read(&tmp24, &buf);
+  state = static_cast<ColormapState>(tmp24);
+
+  // pad1
+  Pad(&buf, 2);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+WriteBuffer Write<ClientMessageEvent>(const ClientMessageEvent& obj) {
+  WriteBuffer buf;
+
+  auto& format = obj.format;
+  auto& sequence = obj.sequence;
+  auto& window = obj.window;
+  auto& type = obj.type;
+  auto& data = obj.data;
+
+  // response_type
+  uint8_t response_type = 33;
+  buf.Write(&response_type);
+
+  // format
+  buf.Write(&format);
+
+  // sequence
+  buf.Write(&sequence);
+
+  // window
+  buf.Write(&window);
+
+  // type
+  buf.Write(&type);
+
+  // data
+  buf.Write(&data);
+
+  return buf;
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<ClientMessageEvent>(ClientMessageEvent* event_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& format = (*event_).format;
+  auto& sequence = (*event_).sequence;
+  auto& window = (*event_).window;
+  auto& type = (*event_).type;
+  auto& data = (*event_).data;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // format
+  Read(&format, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // window
+  Read(&window, &buf);
+
+  // type
+  Read(&type, &buf);
+
+  // data
+  Read(&data, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<MappingNotifyEvent>(MappingNotifyEvent* event_,
+                                   ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& request = (*event_).request;
+  auto& first_keycode = (*event_).first_keycode;
+  auto& count = (*event_).count;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // request
+  uint8_t tmp25;
+  Read(&tmp25, &buf);
+  request = static_cast<Mapping>(tmp25);
+
+  // first_keycode
+  Read(&first_keycode, &buf);
+
+  // count
+  Read(&count, &buf);
+
+  // pad1
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<GeGenericEvent>(GeGenericEvent* event_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // extension
+  uint8_t extension;
+  Read(&extension, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // event_type
+  uint16_t event_type;
+  Read(&event_type, &buf);
+
+  // pad0
+  Pad(&buf, 22);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset, 32 + 4 * length);
+}
+
+std::string RequestError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "RequestError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<RequestError>(RequestError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string ValueError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "ValueError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<ValueError>(ValueError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string WindowError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "WindowError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<WindowError>(WindowError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string PixmapError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "PixmapError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<PixmapError>(PixmapError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string AtomError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "AtomError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<AtomError>(AtomError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string CursorError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "CursorError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<CursorError>(CursorError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string FontError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "FontError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<FontError>(FontError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string MatchError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "MatchError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<MatchError>(MatchError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string DrawableError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "DrawableError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<DrawableError>(DrawableError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string AccessError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "AccessError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<AccessError>(AccessError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string AllocError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "AllocError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<AllocError>(AllocError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string ColormapError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "ColormapError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<ColormapError>(ColormapError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string GContextError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "GContextError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<GContextError>(GContextError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string IDChoiceError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "IDChoiceError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<IDChoiceError>(IDChoiceError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string NameError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "NameError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<NameError>(NameError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string LengthError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "LengthError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<LengthError>(LengthError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string ImplementationError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "ImplementationError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", ";
+  ss_ << ".bad_value = " << static_cast<uint64_t>(bad_value) << ", ";
+  ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", ";
+  ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<ImplementationError>(ImplementationError* error_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+  auto& bad_value = (*error_).bad_value;
+  auto& minor_opcode = (*error_).minor_opcode;
+  auto& major_opcode = (*error_).major_opcode;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // bad_value
+  Read(&bad_value, &buf);
+
+  // minor_opcode
+  Read(&minor_opcode, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+Future<void> XProto::CreateWindow(const CreateWindowRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& depth = request.depth;
+  auto& wid = request.wid;
+  auto& parent = request.parent;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& border_width = request.border_width;
+  auto& c_class = request.c_class;
+  auto& visual = request.visual;
+  CreateWindowAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = 1;
+  buf.Write(&major_opcode);
+
+  // depth
+  buf.Write(&depth);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // wid
+  buf.Write(&wid);
+
+  // parent
+  buf.Write(&parent);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // border_width
+  buf.Write(&border_width);
+
+  // c_class
+  uint16_t tmp26;
+  tmp26 = static_cast<uint16_t>(c_class);
+  buf.Write(&tmp26);
+
+  // visual
+  buf.Write(&visual);
+
+  // value_mask
+  SwitchVar(CreateWindowAttribute::BackPixmap,
+            value_list.background_pixmap.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackPixel,
+            value_list.background_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BorderPixmap,
+            value_list.border_pixmap.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BorderPixel,
+            value_list.border_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BitGravity,
+            value_list.bit_gravity.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::WinGravity,
+            value_list.win_gravity.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingStore,
+            value_list.backing_store.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingPlanes,
+            value_list.backing_planes.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingPixel,
+            value_list.backing_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::OverrideRedirect,
+            value_list.override_redirect.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::SaveUnder, value_list.save_under.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::EventMask, value_list.event_mask.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::DontPropagate,
+            value_list.do_not_propogate_mask.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::Colormap, value_list.colormap.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::Cursor, value_list.cursor.has_value(), true,
+            &value_mask);
+  uint32_t tmp27;
+  tmp27 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp27);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackPixmap)) {
+    auto& background_pixmap = *value_list.background_pixmap;
+
+    // background_pixmap
+    buf.Write(&background_pixmap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackPixel)) {
+    auto& background_pixel = *value_list.background_pixel;
+
+    // background_pixel
+    buf.Write(&background_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BorderPixmap)) {
+    auto& border_pixmap = *value_list.border_pixmap;
+
+    // border_pixmap
+    buf.Write(&border_pixmap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BorderPixel)) {
+    auto& border_pixel = *value_list.border_pixel;
+
+    // border_pixel
+    buf.Write(&border_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BitGravity)) {
+    auto& bit_gravity = *value_list.bit_gravity;
+
+    // bit_gravity
+    uint32_t tmp28;
+    tmp28 = static_cast<uint32_t>(bit_gravity);
+    buf.Write(&tmp28);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::WinGravity)) {
+    auto& win_gravity = *value_list.win_gravity;
+
+    // win_gravity
+    uint32_t tmp29;
+    tmp29 = static_cast<uint32_t>(win_gravity);
+    buf.Write(&tmp29);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingStore)) {
+    auto& backing_store = *value_list.backing_store;
+
+    // backing_store
+    uint32_t tmp30;
+    tmp30 = static_cast<uint32_t>(backing_store);
+    buf.Write(&tmp30);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingPlanes)) {
+    auto& backing_planes = *value_list.backing_planes;
+
+    // backing_planes
+    buf.Write(&backing_planes);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingPixel)) {
+    auto& backing_pixel = *value_list.backing_pixel;
+
+    // backing_pixel
+    buf.Write(&backing_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::OverrideRedirect)) {
+    auto& override_redirect = *value_list.override_redirect;
+
+    // override_redirect
+    buf.Write(&override_redirect);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::SaveUnder)) {
+    auto& save_under = *value_list.save_under;
+
+    // save_under
+    buf.Write(&save_under);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::EventMask)) {
+    auto& event_mask = *value_list.event_mask;
+
+    // event_mask
+    uint32_t tmp31;
+    tmp31 = static_cast<uint32_t>(event_mask);
+    buf.Write(&tmp31);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::DontPropagate)) {
+    auto& do_not_propogate_mask = *value_list.do_not_propogate_mask;
+
+    // do_not_propogate_mask
+    uint32_t tmp32;
+    tmp32 = static_cast<uint32_t>(do_not_propogate_mask);
+    buf.Write(&tmp32);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::Colormap)) {
+    auto& colormap = *value_list.colormap;
+
+    // colormap
+    buf.Write(&colormap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::Cursor)) {
+    auto& cursor = *value_list.cursor;
+
+    // cursor
+    buf.Write(&cursor);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CreateWindow", false);
+}
+
+Future<void> XProto::CreateWindow(
+    const uint8_t& depth,
+    const Window& wid,
+    const Window& parent,
+    const int16_t& x,
+    const int16_t& y,
+    const uint16_t& width,
+    const uint16_t& height,
+    const uint16_t& border_width,
+    const WindowClass& c_class,
+    const VisualId& visual,
+    const absl::optional<Pixmap>& background_pixmap,
+    const absl::optional<uint32_t>& background_pixel,
+    const absl::optional<Pixmap>& border_pixmap,
+    const absl::optional<uint32_t>& border_pixel,
+    const absl::optional<Gravity>& bit_gravity,
+    const absl::optional<Gravity>& win_gravity,
+    const absl::optional<BackingStore>& backing_store,
+    const absl::optional<uint32_t>& backing_planes,
+    const absl::optional<uint32_t>& backing_pixel,
+    const absl::optional<Bool32>& override_redirect,
+    const absl::optional<Bool32>& save_under,
+    const absl::optional<EventMask>& event_mask,
+    const absl::optional<EventMask>& do_not_propogate_mask,
+    const absl::optional<ColorMap>& colormap,
+    const absl::optional<Cursor>& cursor) {
+  return XProto::CreateWindow(CreateWindowRequest{depth,
+                                                  wid,
+                                                  parent,
+                                                  x,
+                                                  y,
+                                                  width,
+                                                  height,
+                                                  border_width,
+                                                  c_class,
+                                                  visual,
+                                                  background_pixmap,
+                                                  background_pixel,
+                                                  border_pixmap,
+                                                  border_pixel,
+                                                  bit_gravity,
+                                                  win_gravity,
+                                                  backing_store,
+                                                  backing_planes,
+                                                  backing_pixel,
+                                                  override_redirect,
+                                                  save_under,
+                                                  event_mask,
+                                                  do_not_propogate_mask,
+                                                  colormap,
+                                                  cursor});
+}
+
+Future<void> XProto::ChangeWindowAttributes(
+    const ChangeWindowAttributesRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  CreateWindowAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = 2;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // value_mask
+  SwitchVar(CreateWindowAttribute::BackPixmap,
+            value_list.background_pixmap.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackPixel,
+            value_list.background_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BorderPixmap,
+            value_list.border_pixmap.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BorderPixel,
+            value_list.border_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BitGravity,
+            value_list.bit_gravity.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::WinGravity,
+            value_list.win_gravity.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingStore,
+            value_list.backing_store.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingPlanes,
+            value_list.backing_planes.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::BackingPixel,
+            value_list.backing_pixel.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::OverrideRedirect,
+            value_list.override_redirect.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::SaveUnder, value_list.save_under.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::EventMask, value_list.event_mask.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::DontPropagate,
+            value_list.do_not_propogate_mask.has_value(), true, &value_mask);
+  SwitchVar(CreateWindowAttribute::Colormap, value_list.colormap.has_value(),
+            true, &value_mask);
+  SwitchVar(CreateWindowAttribute::Cursor, value_list.cursor.has_value(), true,
+            &value_mask);
+  uint32_t tmp33;
+  tmp33 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp33);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackPixmap)) {
+    auto& background_pixmap = *value_list.background_pixmap;
+
+    // background_pixmap
+    buf.Write(&background_pixmap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackPixel)) {
+    auto& background_pixel = *value_list.background_pixel;
+
+    // background_pixel
+    buf.Write(&background_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BorderPixmap)) {
+    auto& border_pixmap = *value_list.border_pixmap;
+
+    // border_pixmap
+    buf.Write(&border_pixmap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BorderPixel)) {
+    auto& border_pixel = *value_list.border_pixel;
+
+    // border_pixel
+    buf.Write(&border_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BitGravity)) {
+    auto& bit_gravity = *value_list.bit_gravity;
+
+    // bit_gravity
+    uint32_t tmp34;
+    tmp34 = static_cast<uint32_t>(bit_gravity);
+    buf.Write(&tmp34);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::WinGravity)) {
+    auto& win_gravity = *value_list.win_gravity;
+
+    // win_gravity
+    uint32_t tmp35;
+    tmp35 = static_cast<uint32_t>(win_gravity);
+    buf.Write(&tmp35);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingStore)) {
+    auto& backing_store = *value_list.backing_store;
+
+    // backing_store
+    uint32_t tmp36;
+    tmp36 = static_cast<uint32_t>(backing_store);
+    buf.Write(&tmp36);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingPlanes)) {
+    auto& backing_planes = *value_list.backing_planes;
+
+    // backing_planes
+    buf.Write(&backing_planes);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::BackingPixel)) {
+    auto& backing_pixel = *value_list.backing_pixel;
+
+    // backing_pixel
+    buf.Write(&backing_pixel);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::OverrideRedirect)) {
+    auto& override_redirect = *value_list.override_redirect;
+
+    // override_redirect
+    buf.Write(&override_redirect);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::SaveUnder)) {
+    auto& save_under = *value_list.save_under;
+
+    // save_under
+    buf.Write(&save_under);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::EventMask)) {
+    auto& event_mask = *value_list.event_mask;
+
+    // event_mask
+    uint32_t tmp37;
+    tmp37 = static_cast<uint32_t>(event_mask);
+    buf.Write(&tmp37);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::DontPropagate)) {
+    auto& do_not_propogate_mask = *value_list.do_not_propogate_mask;
+
+    // do_not_propogate_mask
+    uint32_t tmp38;
+    tmp38 = static_cast<uint32_t>(do_not_propogate_mask);
+    buf.Write(&tmp38);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::Colormap)) {
+    auto& colormap = *value_list.colormap;
+
+    // colormap
+    buf.Write(&colormap);
+  }
+  if (CaseAnd(value_list_expr, CreateWindowAttribute::Cursor)) {
+    auto& cursor = *value_list.cursor;
+
+    // cursor
+    buf.Write(&cursor);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangeWindowAttributes", false);
+}
+
+Future<void> XProto::ChangeWindowAttributes(
+    const Window& window,
+    const absl::optional<Pixmap>& background_pixmap,
+    const absl::optional<uint32_t>& background_pixel,
+    const absl::optional<Pixmap>& border_pixmap,
+    const absl::optional<uint32_t>& border_pixel,
+    const absl::optional<Gravity>& bit_gravity,
+    const absl::optional<Gravity>& win_gravity,
+    const absl::optional<BackingStore>& backing_store,
+    const absl::optional<uint32_t>& backing_planes,
+    const absl::optional<uint32_t>& backing_pixel,
+    const absl::optional<Bool32>& override_redirect,
+    const absl::optional<Bool32>& save_under,
+    const absl::optional<EventMask>& event_mask,
+    const absl::optional<EventMask>& do_not_propogate_mask,
+    const absl::optional<ColorMap>& colormap,
+    const absl::optional<Cursor>& cursor) {
+  return XProto::ChangeWindowAttributes(ChangeWindowAttributesRequest{
+      window, background_pixmap, background_pixel, border_pixmap, border_pixel,
+      bit_gravity, win_gravity, backing_store, backing_planes, backing_pixel,
+      override_redirect, save_under, event_mask, do_not_propogate_mask,
+      colormap, cursor});
+}
+
+Future<GetWindowAttributesReply> XProto::GetWindowAttributes(
+    const GetWindowAttributesRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 3;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetWindowAttributesReply>(
+      &buf, "GetWindowAttributes", false);
+}
+
+Future<GetWindowAttributesReply> XProto::GetWindowAttributes(
+    const Window& window) {
+  return XProto::GetWindowAttributes(GetWindowAttributesRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetWindowAttributesReply> detail::ReadReply<
+    GetWindowAttributesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetWindowAttributesReply>();
+
+  auto& backing_store = (*reply).backing_store;
+  auto& sequence = (*reply).sequence;
+  auto& visual = (*reply).visual;
+  auto& c_class = (*reply).c_class;
+  auto& bit_gravity = (*reply).bit_gravity;
+  auto& win_gravity = (*reply).win_gravity;
+  auto& backing_planes = (*reply).backing_planes;
+  auto& backing_pixel = (*reply).backing_pixel;
+  auto& save_under = (*reply).save_under;
+  auto& map_is_installed = (*reply).map_is_installed;
+  auto& map_state = (*reply).map_state;
+  auto& override_redirect = (*reply).override_redirect;
+  auto& colormap = (*reply).colormap;
+  auto& all_event_masks = (*reply).all_event_masks;
+  auto& your_event_mask = (*reply).your_event_mask;
+  auto& do_not_propagate_mask = (*reply).do_not_propagate_mask;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // backing_store
+  uint8_t tmp39;
+  Read(&tmp39, &buf);
+  backing_store = static_cast<BackingStore>(tmp39);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // visual
+  Read(&visual, &buf);
+
+  // c_class
+  uint16_t tmp40;
+  Read(&tmp40, &buf);
+  c_class = static_cast<WindowClass>(tmp40);
+
+  // bit_gravity
+  uint8_t tmp41;
+  Read(&tmp41, &buf);
+  bit_gravity = static_cast<Gravity>(tmp41);
+
+  // win_gravity
+  uint8_t tmp42;
+  Read(&tmp42, &buf);
+  win_gravity = static_cast<Gravity>(tmp42);
+
+  // backing_planes
+  Read(&backing_planes, &buf);
+
+  // backing_pixel
+  Read(&backing_pixel, &buf);
+
+  // save_under
+  Read(&save_under, &buf);
+
+  // map_is_installed
+  Read(&map_is_installed, &buf);
+
+  // map_state
+  uint8_t tmp43;
+  Read(&tmp43, &buf);
+  map_state = static_cast<MapState>(tmp43);
+
+  // override_redirect
+  Read(&override_redirect, &buf);
+
+  // colormap
+  Read(&colormap, &buf);
+
+  // all_event_masks
+  uint32_t tmp44;
+  Read(&tmp44, &buf);
+  all_event_masks = static_cast<EventMask>(tmp44);
+
+  // your_event_mask
+  uint32_t tmp45;
+  Read(&tmp45, &buf);
+  your_event_mask = static_cast<EventMask>(tmp45);
+
+  // do_not_propagate_mask
+  uint16_t tmp46;
+  Read(&tmp46, &buf);
+  do_not_propagate_mask = static_cast<EventMask>(tmp46);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::DestroyWindow(const DestroyWindowRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 4;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "DestroyWindow", false);
+}
+
+Future<void> XProto::DestroyWindow(const Window& window) {
+  return XProto::DestroyWindow(DestroyWindowRequest{window});
+}
+
+Future<void> XProto::DestroySubwindows(
+    const DestroySubwindowsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 5;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "DestroySubwindows", false);
+}
+
+Future<void> XProto::DestroySubwindows(const Window& window) {
+  return XProto::DestroySubwindows(DestroySubwindowsRequest{window});
+}
+
+Future<void> XProto::ChangeSaveSet(const ChangeSaveSetRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 6;
+  buf.Write(&major_opcode);
+
+  // mode
+  uint8_t tmp47;
+  tmp47 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp47);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangeSaveSet", false);
+}
+
+Future<void> XProto::ChangeSaveSet(const SetMode& mode, const Window& window) {
+  return XProto::ChangeSaveSet(ChangeSaveSetRequest{mode, window});
+}
+
+Future<void> XProto::ReparentWindow(const ReparentWindowRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& parent = request.parent;
+  auto& x = request.x;
+  auto& y = request.y;
+
+  // major_opcode
+  uint8_t major_opcode = 7;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // parent
+  buf.Write(&parent);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ReparentWindow", false);
+}
+
+Future<void> XProto::ReparentWindow(const Window& window,
+                                    const Window& parent,
+                                    const int16_t& x,
+                                    const int16_t& y) {
+  return XProto::ReparentWindow(ReparentWindowRequest{window, parent, x, y});
+}
+
+Future<void> XProto::MapWindow(const MapWindowRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 8;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "MapWindow", false);
+}
+
+Future<void> XProto::MapWindow(const Window& window) {
+  return XProto::MapWindow(MapWindowRequest{window});
+}
+
+Future<void> XProto::MapSubwindows(const MapSubwindowsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 9;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "MapSubwindows", false);
+}
+
+Future<void> XProto::MapSubwindows(const Window& window) {
+  return XProto::MapSubwindows(MapSubwindowsRequest{window});
+}
+
+Future<void> XProto::UnmapWindow(const UnmapWindowRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 10;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "UnmapWindow", false);
+}
+
+Future<void> XProto::UnmapWindow(const Window& window) {
+  return XProto::UnmapWindow(UnmapWindowRequest{window});
+}
+
+Future<void> XProto::UnmapSubwindows(const UnmapSubwindowsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 11;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "UnmapSubwindows", false);
+}
+
+Future<void> XProto::UnmapSubwindows(const Window& window) {
+  return XProto::UnmapSubwindows(UnmapSubwindowsRequest{window});
+}
+
+Future<void> XProto::ConfigureWindow(const ConfigureWindowRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  ConfigWindow value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = 12;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // value_mask
+  SwitchVar(ConfigWindow::X, value_list.x.has_value(), true, &value_mask);
+  SwitchVar(ConfigWindow::Y, value_list.y.has_value(), true, &value_mask);
+  SwitchVar(ConfigWindow::Width, value_list.width.has_value(), true,
+            &value_mask);
+  SwitchVar(ConfigWindow::Height, value_list.height.has_value(), true,
+            &value_mask);
+  SwitchVar(ConfigWindow::BorderWidth, value_list.border_width.has_value(),
+            true, &value_mask);
+  SwitchVar(ConfigWindow::Sibling, value_list.sibling.has_value(), true,
+            &value_mask);
+  SwitchVar(ConfigWindow::StackMode, value_list.stack_mode.has_value(), true,
+            &value_mask);
+  uint16_t tmp48;
+  tmp48 = static_cast<uint16_t>(value_mask);
+  buf.Write(&tmp48);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, ConfigWindow::X)) {
+    auto& x = *value_list.x;
+
+    // x
+    buf.Write(&x);
+  }
+  if (CaseAnd(value_list_expr, ConfigWindow::Y)) {
+    auto& y = *value_list.y;
+
+    // y
+    buf.Write(&y);
+  }
+  if (CaseAnd(value_list_expr, ConfigWindow::Width)) {
+    auto& width = *value_list.width;
+
+    // width
+    buf.Write(&width);
+  }
+  if (CaseAnd(value_list_expr, ConfigWindow::Height)) {
+    auto& height = *value_list.height;
+
+    // height
+    buf.Write(&height);
+  }
+  if (CaseAnd(value_list_expr, ConfigWindow::BorderWidth)) {
+    auto& border_width = *value_list.border_width;
+
+    // border_width
+    buf.Write(&border_width);
+  }
+  if (CaseAnd(value_list_expr, ConfigWindow::Sibling)) {
+    auto& sibling = *value_list.sibling;
+
+    // sibling
+    buf.Write(&sibling);
+  }
+  if (CaseAnd(value_list_expr, ConfigWindow::StackMode)) {
+    auto& stack_mode = *value_list.stack_mode;
+
+    // stack_mode
+    uint32_t tmp49;
+    tmp49 = static_cast<uint32_t>(stack_mode);
+    buf.Write(&tmp49);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ConfigureWindow", false);
+}
+
+Future<void> XProto::ConfigureWindow(
+    const Window& window,
+    const absl::optional<int32_t>& x,
+    const absl::optional<int32_t>& y,
+    const absl::optional<uint32_t>& width,
+    const absl::optional<uint32_t>& height,
+    const absl::optional<uint32_t>& border_width,
+    const absl::optional<Window>& sibling,
+    const absl::optional<StackMode>& stack_mode) {
+  return XProto::ConfigureWindow(ConfigureWindowRequest{
+      window, x, y, width, height, border_width, sibling, stack_mode});
+}
+
+Future<void> XProto::CirculateWindow(const CirculateWindowRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& direction = request.direction;
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 13;
+  buf.Write(&major_opcode);
+
+  // direction
+  uint8_t tmp50;
+  tmp50 = static_cast<uint8_t>(direction);
+  buf.Write(&tmp50);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CirculateWindow", false);
+}
+
+Future<void> XProto::CirculateWindow(const Circulate& direction,
+                                     const Window& window) {
+  return XProto::CirculateWindow(CirculateWindowRequest{direction, window});
+}
+
+Future<GetGeometryReply> XProto::GetGeometry(
+    const GetGeometryRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = 14;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetGeometryReply>(&buf, "GetGeometry", false);
+}
+
+Future<GetGeometryReply> XProto::GetGeometry(const Drawable& drawable) {
+  return XProto::GetGeometry(GetGeometryRequest{drawable});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetGeometryReply> detail::ReadReply<GetGeometryReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetGeometryReply>();
+
+  auto& depth = (*reply).depth;
+  auto& sequence = (*reply).sequence;
+  auto& root = (*reply).root;
+  auto& x = (*reply).x;
+  auto& y = (*reply).y;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& border_width = (*reply).border_width;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // depth
+  Read(&depth, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // x
+  Read(&x, &buf);
+
+  // y
+  Read(&y, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // border_width
+  Read(&border_width, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<QueryTreeReply> XProto::QueryTree(const QueryTreeRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 15;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<QueryTreeReply>(&buf, "QueryTree", false);
+}
+
+Future<QueryTreeReply> XProto::QueryTree(const Window& window) {
+  return XProto::QueryTree(QueryTreeRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<QueryTreeReply> detail::ReadReply<QueryTreeReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<QueryTreeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& root = (*reply).root;
+  auto& parent = (*reply).parent;
+  uint16_t children_len{};
+  auto& children = (*reply).children;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // parent
+  Read(&parent, &buf);
+
+  // children_len
+  Read(&children_len, &buf);
+
+  // pad1
+  Pad(&buf, 14);
+
+  // children
+  children.resize(children_len);
+  for (auto& children_elem : children) {
+    // children_elem
+    Read(&children_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<InternAtomReply> XProto::InternAtom(const InternAtomRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& only_if_exists = request.only_if_exists;
+  uint16_t name_len{};
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = 16;
+  buf.Write(&major_opcode);
+
+  // only_if_exists
+  buf.Write(&only_if_exists);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // name_len
+  name_len = name.size();
+  buf.Write(&name_len);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<InternAtomReply>(&buf, "InternAtom", false);
+}
+
+Future<InternAtomReply> XProto::InternAtom(const uint8_t& only_if_exists,
+                                           const std::string& name) {
+  return XProto::InternAtom(InternAtomRequest{only_if_exists, name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<InternAtomReply> detail::ReadReply<InternAtomReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<InternAtomReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& atom = (*reply).atom;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // atom
+  Read(&atom, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<GetAtomNameReply> XProto::GetAtomName(
+    const GetAtomNameRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& atom = request.atom;
+
+  // major_opcode
+  uint8_t major_opcode = 17;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // atom
+  buf.Write(&atom);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetAtomNameReply>(&buf, "GetAtomName", false);
+}
+
+Future<GetAtomNameReply> XProto::GetAtomName(const Atom& atom) {
+  return XProto::GetAtomName(GetAtomNameRequest{atom});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetAtomNameReply> detail::ReadReply<GetAtomNameReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetAtomNameReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t name_len{};
+  auto& name = (*reply).name;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // name_len
+  Read(&name_len, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // name
+  name.resize(name_len);
+  for (auto& name_elem : name) {
+    // name_elem
+    Read(&name_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::ChangeProperty(const ChangePropertyRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+  auto& window = request.window;
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& format = request.format;
+  auto& data_len = request.data_len;
+  auto& data = request.data;
+
+  // major_opcode
+  uint8_t major_opcode = 18;
+  buf.Write(&major_opcode);
+
+  // mode
+  uint8_t tmp51;
+  tmp51 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp51);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // format
+  buf.Write(&format);
+
+  // pad0
+  Pad(&buf, 3);
+
+  // data_len
+  buf.Write(&data_len);
+
+  // data
+  buf.AppendBuffer(data, ((data_len) * (format)) / (8));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangeProperty", false);
+}
+
+Future<void> XProto::ChangeProperty(
+    const PropMode& mode,
+    const Window& window,
+    const Atom& property,
+    const Atom& type,
+    const uint8_t& format,
+    const uint32_t& data_len,
+    const scoped_refptr<base::RefCountedMemory>& data) {
+  return XProto::ChangeProperty(ChangePropertyRequest{
+      mode, window, property, type, format, data_len, data});
+}
+
+Future<void> XProto::DeleteProperty(const DeletePropertyRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& property = request.property;
+
+  // major_opcode
+  uint8_t major_opcode = 19;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // property
+  buf.Write(&property);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "DeleteProperty", false);
+}
+
+Future<void> XProto::DeleteProperty(const Window& window,
+                                    const Atom& property) {
+  return XProto::DeleteProperty(DeletePropertyRequest{window, property});
+}
+
+Future<GetPropertyReply> XProto::GetProperty(
+    const GetPropertyRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& c_delete = request.c_delete;
+  auto& window = request.window;
+  auto& property = request.property;
+  auto& type = request.type;
+  auto& long_offset = request.long_offset;
+  auto& long_length = request.long_length;
+
+  // major_opcode
+  uint8_t major_opcode = 20;
+  buf.Write(&major_opcode);
+
+  // c_delete
+  buf.Write(&c_delete);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // property
+  buf.Write(&property);
+
+  // type
+  buf.Write(&type);
+
+  // long_offset
+  buf.Write(&long_offset);
+
+  // long_length
+  buf.Write(&long_length);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetPropertyReply>(&buf, "GetProperty", false);
+}
+
+Future<GetPropertyReply> XProto::GetProperty(const uint8_t& c_delete,
+                                             const Window& window,
+                                             const Atom& property,
+                                             const Atom& type,
+                                             const uint32_t& long_offset,
+                                             const uint32_t& long_length) {
+  return XProto::GetProperty(GetPropertyRequest{
+      c_delete, window, property, type, long_offset, long_length});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetPropertyReply> detail::ReadReply<GetPropertyReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetPropertyReply>();
+
+  auto& format = (*reply).format;
+  auto& sequence = (*reply).sequence;
+  auto& type = (*reply).type;
+  auto& bytes_after = (*reply).bytes_after;
+  auto& value_len = (*reply).value_len;
+  auto& value = (*reply).value;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // format
+  Read(&format, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // type
+  Read(&type, &buf);
+
+  // bytes_after
+  Read(&bytes_after, &buf);
+
+  // value_len
+  Read(&value_len, &buf);
+
+  // pad0
+  Pad(&buf, 12);
+
+  // value
+  value = buffer->ReadAndAdvance((value_len) * ((format) / (8)));
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<ListPropertiesReply> XProto::ListProperties(
+    const ListPropertiesRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 21;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<ListPropertiesReply>(&buf, "ListProperties",
+                                                       false);
+}
+
+Future<ListPropertiesReply> XProto::ListProperties(const Window& window) {
+  return XProto::ListProperties(ListPropertiesRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<ListPropertiesReply> detail::ReadReply<ListPropertiesReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<ListPropertiesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t atoms_len{};
+  auto& atoms = (*reply).atoms;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // atoms_len
+  Read(&atoms_len, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // atoms
+  atoms.resize(atoms_len);
+  for (auto& atoms_elem : atoms) {
+    // atoms_elem
+    Read(&atoms_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::SetSelectionOwner(
+    const SetSelectionOwnerRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& owner = request.owner;
+  auto& selection = request.selection;
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = 22;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // owner
+  buf.Write(&owner);
+
+  // selection
+  buf.Write(&selection);
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SetSelectionOwner", false);
+}
+
+Future<void> XProto::SetSelectionOwner(const Window& owner,
+                                       const Atom& selection,
+                                       const Time& time) {
+  return XProto::SetSelectionOwner(
+      SetSelectionOwnerRequest{owner, selection, time});
+}
+
+Future<GetSelectionOwnerReply> XProto::GetSelectionOwner(
+    const GetSelectionOwnerRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& selection = request.selection;
+
+  // major_opcode
+  uint8_t major_opcode = 23;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // selection
+  buf.Write(&selection);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetSelectionOwnerReply>(
+      &buf, "GetSelectionOwner", false);
+}
+
+Future<GetSelectionOwnerReply> XProto::GetSelectionOwner(
+    const Atom& selection) {
+  return XProto::GetSelectionOwner(GetSelectionOwnerRequest{selection});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetSelectionOwnerReply> detail::ReadReply<
+    GetSelectionOwnerReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetSelectionOwnerReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& owner = (*reply).owner;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // owner
+  Read(&owner, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::ConvertSelection(const ConvertSelectionRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& requestor = request.requestor;
+  auto& selection = request.selection;
+  auto& target = request.target;
+  auto& property = request.property;
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = 24;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // requestor
+  buf.Write(&requestor);
+
+  // selection
+  buf.Write(&selection);
+
+  // target
+  buf.Write(&target);
+
+  // property
+  buf.Write(&property);
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ConvertSelection", false);
+}
+
+Future<void> XProto::ConvertSelection(const Window& requestor,
+                                      const Atom& selection,
+                                      const Atom& target,
+                                      const Atom& property,
+                                      const Time& time) {
+  return XProto::ConvertSelection(
+      ConvertSelectionRequest{requestor, selection, target, property, time});
+}
+
+Future<void> XProto::SendEvent(const SendEventRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& propagate = request.propagate;
+  auto& destination = request.destination;
+  auto& event_mask = request.event_mask;
+  auto& event = request.event;
+  size_t event_len = event.size();
+
+  // major_opcode
+  uint8_t major_opcode = 25;
+  buf.Write(&major_opcode);
+
+  // propagate
+  buf.Write(&propagate);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // destination
+  buf.Write(&destination);
+
+  // event_mask
+  uint32_t tmp52;
+  tmp52 = static_cast<uint32_t>(event_mask);
+  buf.Write(&tmp52);
+
+  // event
+  for (auto& event_elem : event) {
+    // event_elem
+    buf.Write(&event_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SendEvent", false);
+}
+
+Future<void> XProto::SendEvent(const uint8_t& propagate,
+                               const Window& destination,
+                               const EventMask& event_mask,
+                               const std::array<char, 32>& event) {
+  return XProto::SendEvent(
+      SendEventRequest{propagate, destination, event_mask, event});
+}
+
+Future<GrabPointerReply> XProto::GrabPointer(
+    const GrabPointerRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& owner_events = request.owner_events;
+  auto& grab_window = request.grab_window;
+  auto& event_mask = request.event_mask;
+  auto& pointer_mode = request.pointer_mode;
+  auto& keyboard_mode = request.keyboard_mode;
+  auto& confine_to = request.confine_to;
+  auto& cursor = request.cursor;
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = 26;
+  buf.Write(&major_opcode);
+
+  // owner_events
+  buf.Write(&owner_events);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // event_mask
+  uint16_t tmp53;
+  tmp53 = static_cast<uint16_t>(event_mask);
+  buf.Write(&tmp53);
+
+  // pointer_mode
+  uint8_t tmp54;
+  tmp54 = static_cast<uint8_t>(pointer_mode);
+  buf.Write(&tmp54);
+
+  // keyboard_mode
+  uint8_t tmp55;
+  tmp55 = static_cast<uint8_t>(keyboard_mode);
+  buf.Write(&tmp55);
+
+  // confine_to
+  buf.Write(&confine_to);
+
+  // cursor
+  buf.Write(&cursor);
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GrabPointerReply>(&buf, "GrabPointer", false);
+}
+
+Future<GrabPointerReply> XProto::GrabPointer(const uint8_t& owner_events,
+                                             const Window& grab_window,
+                                             const EventMask& event_mask,
+                                             const GrabMode& pointer_mode,
+                                             const GrabMode& keyboard_mode,
+                                             const Window& confine_to,
+                                             const Cursor& cursor,
+                                             const Time& time) {
+  return XProto::GrabPointer(
+      GrabPointerRequest{owner_events, grab_window, event_mask, pointer_mode,
+                         keyboard_mode, confine_to, cursor, time});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GrabPointerReply> detail::ReadReply<GrabPointerReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GrabPointerReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp56;
+  Read(&tmp56, &buf);
+  status = static_cast<GrabStatus>(tmp56);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::UngrabPointer(const UngrabPointerRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = 27;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "UngrabPointer", false);
+}
+
+Future<void> XProto::UngrabPointer(const Time& time) {
+  return XProto::UngrabPointer(UngrabPointerRequest{time});
+}
+
+Future<void> XProto::GrabButton(const GrabButtonRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& owner_events = request.owner_events;
+  auto& grab_window = request.grab_window;
+  auto& event_mask = request.event_mask;
+  auto& pointer_mode = request.pointer_mode;
+  auto& keyboard_mode = request.keyboard_mode;
+  auto& confine_to = request.confine_to;
+  auto& cursor = request.cursor;
+  auto& button = request.button;
+  auto& modifiers = request.modifiers;
+
+  // major_opcode
+  uint8_t major_opcode = 28;
+  buf.Write(&major_opcode);
+
+  // owner_events
+  buf.Write(&owner_events);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // event_mask
+  uint16_t tmp57;
+  tmp57 = static_cast<uint16_t>(event_mask);
+  buf.Write(&tmp57);
+
+  // pointer_mode
+  uint8_t tmp58;
+  tmp58 = static_cast<uint8_t>(pointer_mode);
+  buf.Write(&tmp58);
+
+  // keyboard_mode
+  uint8_t tmp59;
+  tmp59 = static_cast<uint8_t>(keyboard_mode);
+  buf.Write(&tmp59);
+
+  // confine_to
+  buf.Write(&confine_to);
+
+  // cursor
+  buf.Write(&cursor);
+
+  // button
+  uint8_t tmp60;
+  tmp60 = static_cast<uint8_t>(button);
+  buf.Write(&tmp60);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // modifiers
+  uint16_t tmp61;
+  tmp61 = static_cast<uint16_t>(modifiers);
+  buf.Write(&tmp61);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "GrabButton", false);
+}
+
+Future<void> XProto::GrabButton(const uint8_t& owner_events,
+                                const Window& grab_window,
+                                const EventMask& event_mask,
+                                const GrabMode& pointer_mode,
+                                const GrabMode& keyboard_mode,
+                                const Window& confine_to,
+                                const Cursor& cursor,
+                                const ButtonIndex& button,
+                                const ModMask& modifiers) {
+  return XProto::GrabButton(
+      GrabButtonRequest{owner_events, grab_window, event_mask, pointer_mode,
+                        keyboard_mode, confine_to, cursor, button, modifiers});
+}
+
+Future<void> XProto::UngrabButton(const UngrabButtonRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& button = request.button;
+  auto& grab_window = request.grab_window;
+  auto& modifiers = request.modifiers;
+
+  // major_opcode
+  uint8_t major_opcode = 29;
+  buf.Write(&major_opcode);
+
+  // button
+  uint8_t tmp62;
+  tmp62 = static_cast<uint8_t>(button);
+  buf.Write(&tmp62);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // modifiers
+  uint16_t tmp63;
+  tmp63 = static_cast<uint16_t>(modifiers);
+  buf.Write(&tmp63);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "UngrabButton", false);
+}
+
+Future<void> XProto::UngrabButton(const ButtonIndex& button,
+                                  const Window& grab_window,
+                                  const ModMask& modifiers) {
+  return XProto::UngrabButton(
+      UngrabButtonRequest{button, grab_window, modifiers});
+}
+
+Future<void> XProto::ChangeActivePointerGrab(
+    const ChangeActivePointerGrabRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cursor = request.cursor;
+  auto& time = request.time;
+  auto& event_mask = request.event_mask;
+
+  // major_opcode
+  uint8_t major_opcode = 30;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cursor
+  buf.Write(&cursor);
+
+  // time
+  buf.Write(&time);
+
+  // event_mask
+  uint16_t tmp64;
+  tmp64 = static_cast<uint16_t>(event_mask);
+  buf.Write(&tmp64);
+
+  // pad1
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangeActivePointerGrab", false);
+}
+
+Future<void> XProto::ChangeActivePointerGrab(const Cursor& cursor,
+                                             const Time& time,
+                                             const EventMask& event_mask) {
+  return XProto::ChangeActivePointerGrab(
+      ChangeActivePointerGrabRequest{cursor, time, event_mask});
+}
+
+Future<GrabKeyboardReply> XProto::GrabKeyboard(
+    const GrabKeyboardRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& owner_events = request.owner_events;
+  auto& grab_window = request.grab_window;
+  auto& time = request.time;
+  auto& pointer_mode = request.pointer_mode;
+  auto& keyboard_mode = request.keyboard_mode;
+
+  // major_opcode
+  uint8_t major_opcode = 31;
+  buf.Write(&major_opcode);
+
+  // owner_events
+  buf.Write(&owner_events);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // time
+  buf.Write(&time);
+
+  // pointer_mode
+  uint8_t tmp65;
+  tmp65 = static_cast<uint8_t>(pointer_mode);
+  buf.Write(&tmp65);
+
+  // keyboard_mode
+  uint8_t tmp66;
+  tmp66 = static_cast<uint8_t>(keyboard_mode);
+  buf.Write(&tmp66);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GrabKeyboardReply>(&buf, "GrabKeyboard",
+                                                     false);
+}
+
+Future<GrabKeyboardReply> XProto::GrabKeyboard(const uint8_t& owner_events,
+                                               const Window& grab_window,
+                                               const Time& time,
+                                               const GrabMode& pointer_mode,
+                                               const GrabMode& keyboard_mode) {
+  return XProto::GrabKeyboard(GrabKeyboardRequest{
+      owner_events, grab_window, time, pointer_mode, keyboard_mode});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GrabKeyboardReply> detail::ReadReply<GrabKeyboardReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GrabKeyboardReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp67;
+  Read(&tmp67, &buf);
+  status = static_cast<GrabStatus>(tmp67);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::UngrabKeyboard(const UngrabKeyboardRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = 32;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "UngrabKeyboard", false);
+}
+
+Future<void> XProto::UngrabKeyboard(const Time& time) {
+  return XProto::UngrabKeyboard(UngrabKeyboardRequest{time});
+}
+
+Future<void> XProto::GrabKey(const GrabKeyRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& owner_events = request.owner_events;
+  auto& grab_window = request.grab_window;
+  auto& modifiers = request.modifiers;
+  auto& key = request.key;
+  auto& pointer_mode = request.pointer_mode;
+  auto& keyboard_mode = request.keyboard_mode;
+
+  // major_opcode
+  uint8_t major_opcode = 33;
+  buf.Write(&major_opcode);
+
+  // owner_events
+  buf.Write(&owner_events);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // modifiers
+  uint16_t tmp68;
+  tmp68 = static_cast<uint16_t>(modifiers);
+  buf.Write(&tmp68);
+
+  // key
+  buf.Write(&key);
+
+  // pointer_mode
+  uint8_t tmp69;
+  tmp69 = static_cast<uint8_t>(pointer_mode);
+  buf.Write(&tmp69);
+
+  // keyboard_mode
+  uint8_t tmp70;
+  tmp70 = static_cast<uint8_t>(keyboard_mode);
+  buf.Write(&tmp70);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "GrabKey", false);
+}
+
+Future<void> XProto::GrabKey(const uint8_t& owner_events,
+                             const Window& grab_window,
+                             const ModMask& modifiers,
+                             const KeyCode& key,
+                             const GrabMode& pointer_mode,
+                             const GrabMode& keyboard_mode) {
+  return XProto::GrabKey(GrabKeyRequest{owner_events, grab_window, modifiers,
+                                        key, pointer_mode, keyboard_mode});
+}
+
+Future<void> XProto::UngrabKey(const UngrabKeyRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& key = request.key;
+  auto& grab_window = request.grab_window;
+  auto& modifiers = request.modifiers;
+
+  // major_opcode
+  uint8_t major_opcode = 34;
+  buf.Write(&major_opcode);
+
+  // key
+  buf.Write(&key);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // grab_window
+  buf.Write(&grab_window);
+
+  // modifiers
+  uint16_t tmp71;
+  tmp71 = static_cast<uint16_t>(modifiers);
+  buf.Write(&tmp71);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "UngrabKey", false);
+}
+
+Future<void> XProto::UngrabKey(const KeyCode& key,
+                               const Window& grab_window,
+                               const ModMask& modifiers) {
+  return XProto::UngrabKey(UngrabKeyRequest{key, grab_window, modifiers});
+}
+
+Future<void> XProto::AllowEvents(const AllowEventsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = 35;
+  buf.Write(&major_opcode);
+
+  // mode
+  uint8_t tmp72;
+  tmp72 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp72);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "AllowEvents", false);
+}
+
+Future<void> XProto::AllowEvents(const Allow& mode, const Time& time) {
+  return XProto::AllowEvents(AllowEventsRequest{mode, time});
+}
+
+Future<void> XProto::GrabServer(const GrabServerRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 36;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "GrabServer", false);
+}
+
+Future<void> XProto::GrabServer() {
+  return XProto::GrabServer(GrabServerRequest{});
+}
+
+Future<void> XProto::UngrabServer(const UngrabServerRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 37;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "UngrabServer", false);
+}
+
+Future<void> XProto::UngrabServer() {
+  return XProto::UngrabServer(UngrabServerRequest{});
+}
+
+Future<QueryPointerReply> XProto::QueryPointer(
+    const QueryPointerRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 38;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<QueryPointerReply>(&buf, "QueryPointer",
+                                                     false);
+}
+
+Future<QueryPointerReply> XProto::QueryPointer(const Window& window) {
+  return XProto::QueryPointer(QueryPointerRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<QueryPointerReply> detail::ReadReply<QueryPointerReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<QueryPointerReply>();
+
+  auto& same_screen = (*reply).same_screen;
+  auto& sequence = (*reply).sequence;
+  auto& root = (*reply).root;
+  auto& child = (*reply).child;
+  auto& root_x = (*reply).root_x;
+  auto& root_y = (*reply).root_y;
+  auto& win_x = (*reply).win_x;
+  auto& win_y = (*reply).win_y;
+  auto& mask = (*reply).mask;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // same_screen
+  Read(&same_screen, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // root
+  Read(&root, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // root_x
+  Read(&root_x, &buf);
+
+  // root_y
+  Read(&root_y, &buf);
+
+  // win_x
+  Read(&win_x, &buf);
+
+  // win_y
+  Read(&win_y, &buf);
+
+  // mask
+  uint16_t tmp73;
+  Read(&tmp73, &buf);
+  mask = static_cast<KeyButMask>(tmp73);
+
+  // pad0
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<GetMotionEventsReply> XProto::GetMotionEvents(
+    const GetMotionEventsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& start = request.start;
+  auto& stop = request.stop;
+
+  // major_opcode
+  uint8_t major_opcode = 39;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // start
+  buf.Write(&start);
+
+  // stop
+  buf.Write(&stop);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetMotionEventsReply>(&buf, "GetMotionEvents",
+                                                        false);
+}
+
+Future<GetMotionEventsReply> XProto::GetMotionEvents(const Window& window,
+                                                     const Time& start,
+                                                     const Time& stop) {
+  return XProto::GetMotionEvents(GetMotionEventsRequest{window, start, stop});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetMotionEventsReply> detail::ReadReply<GetMotionEventsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetMotionEventsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t events_len{};
+  auto& events = (*reply).events;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // events_len
+  Read(&events_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // events
+  events.resize(events_len);
+  for (auto& events_elem : events) {
+    // events_elem
+    {
+      auto& time = events_elem.time;
+      auto& x = events_elem.x;
+      auto& y = events_elem.y;
+
+      // time
+      Read(&time, &buf);
+
+      // x
+      Read(&x, &buf);
+
+      // y
+      Read(&y, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<TranslateCoordinatesReply> XProto::TranslateCoordinates(
+    const TranslateCoordinatesRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& src_window = request.src_window;
+  auto& dst_window = request.dst_window;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+
+  // major_opcode
+  uint8_t major_opcode = 40;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // src_window
+  buf.Write(&src_window);
+
+  // dst_window
+  buf.Write(&dst_window);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<TranslateCoordinatesReply>(
+      &buf, "TranslateCoordinates", false);
+}
+
+Future<TranslateCoordinatesReply> XProto::TranslateCoordinates(
+    const Window& src_window,
+    const Window& dst_window,
+    const int16_t& src_x,
+    const int16_t& src_y) {
+  return XProto::TranslateCoordinates(
+      TranslateCoordinatesRequest{src_window, dst_window, src_x, src_y});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<TranslateCoordinatesReply> detail::ReadReply<
+    TranslateCoordinatesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<TranslateCoordinatesReply>();
+
+  auto& same_screen = (*reply).same_screen;
+  auto& sequence = (*reply).sequence;
+  auto& child = (*reply).child;
+  auto& dst_x = (*reply).dst_x;
+  auto& dst_y = (*reply).dst_y;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // same_screen
+  Read(&same_screen, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // child
+  Read(&child, &buf);
+
+  // dst_x
+  Read(&dst_x, &buf);
+
+  // dst_y
+  Read(&dst_y, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::WarpPointer(const WarpPointerRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& src_window = request.src_window;
+  auto& dst_window = request.dst_window;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& src_width = request.src_width;
+  auto& src_height = request.src_height;
+  auto& dst_x = request.dst_x;
+  auto& dst_y = request.dst_y;
+
+  // major_opcode
+  uint8_t major_opcode = 41;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // src_window
+  buf.Write(&src_window);
+
+  // dst_window
+  buf.Write(&dst_window);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // src_width
+  buf.Write(&src_width);
+
+  // src_height
+  buf.Write(&src_height);
+
+  // dst_x
+  buf.Write(&dst_x);
+
+  // dst_y
+  buf.Write(&dst_y);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "WarpPointer", false);
+}
+
+Future<void> XProto::WarpPointer(const Window& src_window,
+                                 const Window& dst_window,
+                                 const int16_t& src_x,
+                                 const int16_t& src_y,
+                                 const uint16_t& src_width,
+                                 const uint16_t& src_height,
+                                 const int16_t& dst_x,
+                                 const int16_t& dst_y) {
+  return XProto::WarpPointer(WarpPointerRequest{src_window, dst_window, src_x,
+                                                src_y, src_width, src_height,
+                                                dst_x, dst_y});
+}
+
+Future<void> XProto::SetInputFocus(const SetInputFocusRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& revert_to = request.revert_to;
+  auto& focus = request.focus;
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = 42;
+  buf.Write(&major_opcode);
+
+  // revert_to
+  uint8_t tmp74;
+  tmp74 = static_cast<uint8_t>(revert_to);
+  buf.Write(&tmp74);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // focus
+  buf.Write(&focus);
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SetInputFocus", false);
+}
+
+Future<void> XProto::SetInputFocus(const InputFocus& revert_to,
+                                   const Window& focus,
+                                   const Time& time) {
+  return XProto::SetInputFocus(SetInputFocusRequest{revert_to, focus, time});
+}
+
+Future<GetInputFocusReply> XProto::GetInputFocus(
+    const GetInputFocusRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 43;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetInputFocusReply>(&buf, "GetInputFocus",
+                                                      false);
+}
+
+Future<GetInputFocusReply> XProto::GetInputFocus() {
+  return XProto::GetInputFocus(GetInputFocusRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetInputFocusReply> detail::ReadReply<GetInputFocusReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetInputFocusReply>();
+
+  auto& revert_to = (*reply).revert_to;
+  auto& sequence = (*reply).sequence;
+  auto& focus = (*reply).focus;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // revert_to
+  uint8_t tmp75;
+  Read(&tmp75, &buf);
+  revert_to = static_cast<InputFocus>(tmp75);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // focus
+  Read(&focus, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<QueryKeymapReply> XProto::QueryKeymap(
+    const QueryKeymapRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 44;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<QueryKeymapReply>(&buf, "QueryKeymap", false);
+}
+
+Future<QueryKeymapReply> XProto::QueryKeymap() {
+  return XProto::QueryKeymap(QueryKeymapRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<QueryKeymapReply> detail::ReadReply<QueryKeymapReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<QueryKeymapReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& keys = (*reply).keys;
+  size_t keys_len = keys.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // keys
+  for (auto& keys_elem : keys) {
+    // keys_elem
+    Read(&keys_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::OpenFont(const OpenFontRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& fid = request.fid;
+  uint16_t name_len{};
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = 45;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // fid
+  buf.Write(&fid);
+
+  // name_len
+  name_len = name.size();
+  buf.Write(&name_len);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "OpenFont", false);
+}
+
+Future<void> XProto::OpenFont(const Font& fid, const std::string& name) {
+  return XProto::OpenFont(OpenFontRequest{fid, name});
+}
+
+Future<void> XProto::CloseFont(const CloseFontRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& font = request.font;
+
+  // major_opcode
+  uint8_t major_opcode = 46;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // font
+  buf.Write(&font);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CloseFont", false);
+}
+
+Future<void> XProto::CloseFont(const Font& font) {
+  return XProto::CloseFont(CloseFontRequest{font});
+}
+
+Future<QueryFontReply> XProto::QueryFont(const QueryFontRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& font = request.font;
+
+  // major_opcode
+  uint8_t major_opcode = 47;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // font
+  buf.Write(&font);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<QueryFontReply>(&buf, "QueryFont", false);
+}
+
+Future<QueryFontReply> XProto::QueryFont(const Fontable& font) {
+  return XProto::QueryFont(QueryFontRequest{font});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<QueryFontReply> detail::ReadReply<QueryFontReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<QueryFontReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& min_bounds = (*reply).min_bounds;
+  auto& max_bounds = (*reply).max_bounds;
+  auto& min_char_or_byte2 = (*reply).min_char_or_byte2;
+  auto& max_char_or_byte2 = (*reply).max_char_or_byte2;
+  auto& default_char = (*reply).default_char;
+  uint16_t properties_len{};
+  auto& draw_direction = (*reply).draw_direction;
+  auto& min_byte1 = (*reply).min_byte1;
+  auto& max_byte1 = (*reply).max_byte1;
+  auto& all_chars_exist = (*reply).all_chars_exist;
+  auto& font_ascent = (*reply).font_ascent;
+  auto& font_descent = (*reply).font_descent;
+  uint32_t char_infos_len{};
+  auto& properties = (*reply).properties;
+  auto& char_infos = (*reply).char_infos;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // min_bounds
+  {
+    auto& left_side_bearing = min_bounds.left_side_bearing;
+    auto& right_side_bearing = min_bounds.right_side_bearing;
+    auto& character_width = min_bounds.character_width;
+    auto& ascent = min_bounds.ascent;
+    auto& descent = min_bounds.descent;
+    auto& attributes = min_bounds.attributes;
+
+    // left_side_bearing
+    Read(&left_side_bearing, &buf);
+
+    // right_side_bearing
+    Read(&right_side_bearing, &buf);
+
+    // character_width
+    Read(&character_width, &buf);
+
+    // ascent
+    Read(&ascent, &buf);
+
+    // descent
+    Read(&descent, &buf);
+
+    // attributes
+    Read(&attributes, &buf);
+  }
+
+  // pad1
+  Pad(&buf, 4);
+
+  // max_bounds
+  {
+    auto& left_side_bearing = max_bounds.left_side_bearing;
+    auto& right_side_bearing = max_bounds.right_side_bearing;
+    auto& character_width = max_bounds.character_width;
+    auto& ascent = max_bounds.ascent;
+    auto& descent = max_bounds.descent;
+    auto& attributes = max_bounds.attributes;
+
+    // left_side_bearing
+    Read(&left_side_bearing, &buf);
+
+    // right_side_bearing
+    Read(&right_side_bearing, &buf);
+
+    // character_width
+    Read(&character_width, &buf);
+
+    // ascent
+    Read(&ascent, &buf);
+
+    // descent
+    Read(&descent, &buf);
+
+    // attributes
+    Read(&attributes, &buf);
+  }
+
+  // pad2
+  Pad(&buf, 4);
+
+  // min_char_or_byte2
+  Read(&min_char_or_byte2, &buf);
+
+  // max_char_or_byte2
+  Read(&max_char_or_byte2, &buf);
+
+  // default_char
+  Read(&default_char, &buf);
+
+  // properties_len
+  Read(&properties_len, &buf);
+
+  // draw_direction
+  uint8_t tmp76;
+  Read(&tmp76, &buf);
+  draw_direction = static_cast<FontDraw>(tmp76);
+
+  // min_byte1
+  Read(&min_byte1, &buf);
+
+  // max_byte1
+  Read(&max_byte1, &buf);
+
+  // all_chars_exist
+  Read(&all_chars_exist, &buf);
+
+  // font_ascent
+  Read(&font_ascent, &buf);
+
+  // font_descent
+  Read(&font_descent, &buf);
+
+  // char_infos_len
+  Read(&char_infos_len, &buf);
+
+  // properties
+  properties.resize(properties_len);
+  for (auto& properties_elem : properties) {
+    // properties_elem
+    {
+      auto& name = properties_elem.name;
+      auto& value = properties_elem.value;
+
+      // name
+      Read(&name, &buf);
+
+      // value
+      Read(&value, &buf);
+    }
+  }
+
+  // char_infos
+  char_infos.resize(char_infos_len);
+  for (auto& char_infos_elem : char_infos) {
+    // char_infos_elem
+    {
+      auto& left_side_bearing = char_infos_elem.left_side_bearing;
+      auto& right_side_bearing = char_infos_elem.right_side_bearing;
+      auto& character_width = char_infos_elem.character_width;
+      auto& ascent = char_infos_elem.ascent;
+      auto& descent = char_infos_elem.descent;
+      auto& attributes = char_infos_elem.attributes;
+
+      // left_side_bearing
+      Read(&left_side_bearing, &buf);
+
+      // right_side_bearing
+      Read(&right_side_bearing, &buf);
+
+      // character_width
+      Read(&character_width, &buf);
+
+      // ascent
+      Read(&ascent, &buf);
+
+      // descent
+      Read(&descent, &buf);
+
+      // attributes
+      Read(&attributes, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<QueryTextExtentsReply> XProto::QueryTextExtents(
+    const QueryTextExtentsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& font = request.font;
+  auto& string = request.string;
+  size_t string_len = string.size();
+
+  // major_opcode
+  uint8_t major_opcode = 48;
+  buf.Write(&major_opcode);
+
+  // odd_length
+  uint8_t odd_length = BitAnd(string_len, 1);
+  buf.Write(&odd_length);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // font
+  buf.Write(&font);
+
+  // string
+  DCHECK_EQ(static_cast<size_t>(string_len), string.size());
+  for (auto& string_elem : string) {
+    // string_elem
+    {
+      auto& byte1 = string_elem.byte1;
+      auto& byte2 = string_elem.byte2;
+
+      // byte1
+      buf.Write(&byte1);
+
+      // byte2
+      buf.Write(&byte2);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<QueryTextExtentsReply>(
+      &buf, "QueryTextExtents", false);
+}
+
+Future<QueryTextExtentsReply> XProto::QueryTextExtents(
+    const Fontable& font,
+    const std::vector<Char16>& string) {
+  return XProto::QueryTextExtents(QueryTextExtentsRequest{font, string});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<QueryTextExtentsReply> detail::ReadReply<QueryTextExtentsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<QueryTextExtentsReply>();
+
+  auto& draw_direction = (*reply).draw_direction;
+  auto& sequence = (*reply).sequence;
+  auto& font_ascent = (*reply).font_ascent;
+  auto& font_descent = (*reply).font_descent;
+  auto& overall_ascent = (*reply).overall_ascent;
+  auto& overall_descent = (*reply).overall_descent;
+  auto& overall_width = (*reply).overall_width;
+  auto& overall_left = (*reply).overall_left;
+  auto& overall_right = (*reply).overall_right;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // draw_direction
+  uint8_t tmp77;
+  Read(&tmp77, &buf);
+  draw_direction = static_cast<FontDraw>(tmp77);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // font_ascent
+  Read(&font_ascent, &buf);
+
+  // font_descent
+  Read(&font_descent, &buf);
+
+  // overall_ascent
+  Read(&overall_ascent, &buf);
+
+  // overall_descent
+  Read(&overall_descent, &buf);
+
+  // overall_width
+  Read(&overall_width, &buf);
+
+  // overall_left
+  Read(&overall_left, &buf);
+
+  // overall_right
+  Read(&overall_right, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<ListFontsReply> XProto::ListFonts(const ListFontsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& max_names = request.max_names;
+  uint16_t pattern_len{};
+  auto& pattern = request.pattern;
+
+  // major_opcode
+  uint8_t major_opcode = 49;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // max_names
+  buf.Write(&max_names);
+
+  // pattern_len
+  pattern_len = pattern.size();
+  buf.Write(&pattern_len);
+
+  // pattern
+  DCHECK_EQ(static_cast<size_t>(pattern_len), pattern.size());
+  for (auto& pattern_elem : pattern) {
+    // pattern_elem
+    buf.Write(&pattern_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<ListFontsReply>(&buf, "ListFonts", false);
+}
+
+Future<ListFontsReply> XProto::ListFonts(const uint16_t& max_names,
+                                         const std::string& pattern) {
+  return XProto::ListFonts(ListFontsRequest{max_names, pattern});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<ListFontsReply> detail::ReadReply<ListFontsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<ListFontsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t names_len{};
+  auto& names = (*reply).names;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // names_len
+  Read(&names_len, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // names
+  names.resize(names_len);
+  for (auto& names_elem : names) {
+    // names_elem
+    {
+      uint8_t name_len{};
+      auto& name = names_elem.name;
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // name
+      name.resize(name_len);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<ListFontsWithInfoReply> XProto::ListFontsWithInfo(
+    const ListFontsWithInfoRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& max_names = request.max_names;
+  uint16_t pattern_len{};
+  auto& pattern = request.pattern;
+
+  // major_opcode
+  uint8_t major_opcode = 50;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // max_names
+  buf.Write(&max_names);
+
+  // pattern_len
+  pattern_len = pattern.size();
+  buf.Write(&pattern_len);
+
+  // pattern
+  DCHECK_EQ(static_cast<size_t>(pattern_len), pattern.size());
+  for (auto& pattern_elem : pattern) {
+    // pattern_elem
+    buf.Write(&pattern_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<ListFontsWithInfoReply>(
+      &buf, "ListFontsWithInfo", false);
+}
+
+Future<ListFontsWithInfoReply> XProto::ListFontsWithInfo(
+    const uint16_t& max_names,
+    const std::string& pattern) {
+  return XProto::ListFontsWithInfo(
+      ListFontsWithInfoRequest{max_names, pattern});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<ListFontsWithInfoReply> detail::ReadReply<
+    ListFontsWithInfoReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<ListFontsWithInfoReply>();
+
+  uint8_t name_len{};
+  auto& sequence = (*reply).sequence;
+  auto& min_bounds = (*reply).min_bounds;
+  auto& max_bounds = (*reply).max_bounds;
+  auto& min_char_or_byte2 = (*reply).min_char_or_byte2;
+  auto& max_char_or_byte2 = (*reply).max_char_or_byte2;
+  auto& default_char = (*reply).default_char;
+  uint16_t properties_len{};
+  auto& draw_direction = (*reply).draw_direction;
+  auto& min_byte1 = (*reply).min_byte1;
+  auto& max_byte1 = (*reply).max_byte1;
+  auto& all_chars_exist = (*reply).all_chars_exist;
+  auto& font_ascent = (*reply).font_ascent;
+  auto& font_descent = (*reply).font_descent;
+  auto& replies_hint = (*reply).replies_hint;
+  auto& properties = (*reply).properties;
+  auto& name = (*reply).name;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // name_len
+  Read(&name_len, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // min_bounds
+  {
+    auto& left_side_bearing = min_bounds.left_side_bearing;
+    auto& right_side_bearing = min_bounds.right_side_bearing;
+    auto& character_width = min_bounds.character_width;
+    auto& ascent = min_bounds.ascent;
+    auto& descent = min_bounds.descent;
+    auto& attributes = min_bounds.attributes;
+
+    // left_side_bearing
+    Read(&left_side_bearing, &buf);
+
+    // right_side_bearing
+    Read(&right_side_bearing, &buf);
+
+    // character_width
+    Read(&character_width, &buf);
+
+    // ascent
+    Read(&ascent, &buf);
+
+    // descent
+    Read(&descent, &buf);
+
+    // attributes
+    Read(&attributes, &buf);
+  }
+
+  // pad0
+  Pad(&buf, 4);
+
+  // max_bounds
+  {
+    auto& left_side_bearing = max_bounds.left_side_bearing;
+    auto& right_side_bearing = max_bounds.right_side_bearing;
+    auto& character_width = max_bounds.character_width;
+    auto& ascent = max_bounds.ascent;
+    auto& descent = max_bounds.descent;
+    auto& attributes = max_bounds.attributes;
+
+    // left_side_bearing
+    Read(&left_side_bearing, &buf);
+
+    // right_side_bearing
+    Read(&right_side_bearing, &buf);
+
+    // character_width
+    Read(&character_width, &buf);
+
+    // ascent
+    Read(&ascent, &buf);
+
+    // descent
+    Read(&descent, &buf);
+
+    // attributes
+    Read(&attributes, &buf);
+  }
+
+  // pad1
+  Pad(&buf, 4);
+
+  // min_char_or_byte2
+  Read(&min_char_or_byte2, &buf);
+
+  // max_char_or_byte2
+  Read(&max_char_or_byte2, &buf);
+
+  // default_char
+  Read(&default_char, &buf);
+
+  // properties_len
+  Read(&properties_len, &buf);
+
+  // draw_direction
+  uint8_t tmp78;
+  Read(&tmp78, &buf);
+  draw_direction = static_cast<FontDraw>(tmp78);
+
+  // min_byte1
+  Read(&min_byte1, &buf);
+
+  // max_byte1
+  Read(&max_byte1, &buf);
+
+  // all_chars_exist
+  Read(&all_chars_exist, &buf);
+
+  // font_ascent
+  Read(&font_ascent, &buf);
+
+  // font_descent
+  Read(&font_descent, &buf);
+
+  // replies_hint
+  Read(&replies_hint, &buf);
+
+  // properties
+  properties.resize(properties_len);
+  for (auto& properties_elem : properties) {
+    // properties_elem
+    {
+      auto& name = properties_elem.name;
+      auto& value = properties_elem.value;
+
+      // name
+      Read(&name, &buf);
+
+      // value
+      Read(&value, &buf);
+    }
+  }
+
+  // name
+  name.resize(name_len);
+  for (auto& name_elem : name) {
+    // name_elem
+    Read(&name_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::SetFontPath(const SetFontPathRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  uint16_t font_qty{};
+  auto& font = request.font;
+  size_t font_len = font.size();
+
+  // major_opcode
+  uint8_t major_opcode = 51;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // font_qty
+  font_qty = font.size();
+  buf.Write(&font_qty);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // font
+  DCHECK_EQ(static_cast<size_t>(font_qty), font.size());
+  for (auto& font_elem : font) {
+    // font_elem
+    {
+      uint8_t name_len{};
+      auto& name = font_elem.name;
+
+      // name_len
+      name_len = name.size();
+      buf.Write(&name_len);
+
+      // name
+      DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+      for (auto& name_elem : name) {
+        // name_elem
+        buf.Write(&name_elem);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SetFontPath", false);
+}
+
+Future<void> XProto::SetFontPath(const std::vector<Str>& font) {
+  return XProto::SetFontPath(SetFontPathRequest{font});
+}
+
+Future<GetFontPathReply> XProto::GetFontPath(
+    const GetFontPathRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 52;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetFontPathReply>(&buf, "GetFontPath", false);
+}
+
+Future<GetFontPathReply> XProto::GetFontPath() {
+  return XProto::GetFontPath(GetFontPathRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetFontPathReply> detail::ReadReply<GetFontPathReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetFontPathReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t path_len{};
+  auto& path = (*reply).path;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // path_len
+  Read(&path_len, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // path
+  path.resize(path_len);
+  for (auto& path_elem : path) {
+    // path_elem
+    {
+      uint8_t name_len{};
+      auto& name = path_elem.name;
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // name
+      name.resize(name_len);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::CreatePixmap(const CreatePixmapRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& depth = request.depth;
+  auto& pid = request.pid;
+  auto& drawable = request.drawable;
+  auto& width = request.width;
+  auto& height = request.height;
+
+  // major_opcode
+  uint8_t major_opcode = 53;
+  buf.Write(&major_opcode);
+
+  // depth
+  buf.Write(&depth);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pid
+  buf.Write(&pid);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CreatePixmap", false);
+}
+
+Future<void> XProto::CreatePixmap(const uint8_t& depth,
+                                  const Pixmap& pid,
+                                  const Drawable& drawable,
+                                  const uint16_t& width,
+                                  const uint16_t& height) {
+  return XProto::CreatePixmap(
+      CreatePixmapRequest{depth, pid, drawable, width, height});
+}
+
+Future<void> XProto::FreePixmap(const FreePixmapRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& pixmap = request.pixmap;
+
+  // major_opcode
+  uint8_t major_opcode = 54;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // pixmap
+  buf.Write(&pixmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "FreePixmap", false);
+}
+
+Future<void> XProto::FreePixmap(const Pixmap& pixmap) {
+  return XProto::FreePixmap(FreePixmapRequest{pixmap});
+}
+
+Future<void> XProto::CreateGC(const CreateGCRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cid = request.cid;
+  auto& drawable = request.drawable;
+  GraphicsContextAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = 55;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cid
+  buf.Write(&cid);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // value_mask
+  SwitchVar(GraphicsContextAttribute::Function, value_list.function.has_value(),
+            true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::PlaneMask,
+            value_list.plane_mask.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::Foreground,
+            value_list.foreground.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::Background,
+            value_list.background.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::LineWidth,
+            value_list.line_width.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::LineStyle,
+            value_list.line_style.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::CapStyle,
+            value_list.cap_style.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::JoinStyle,
+            value_list.join_style.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::FillStyle,
+            value_list.fill_style.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::FillRule,
+            value_list.fill_rule.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::Tile, value_list.tile.has_value(), true,
+            &value_mask);
+  SwitchVar(GraphicsContextAttribute::Stipple, value_list.stipple.has_value(),
+            true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::TileStippleOriginX,
+            value_list.tile_stipple_x_origin.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::TileStippleOriginY,
+            value_list.tile_stipple_y_origin.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::Font, value_list.font.has_value(), true,
+            &value_mask);
+  SwitchVar(GraphicsContextAttribute::SubwindowMode,
+            value_list.subwindow_mode.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::GraphicsExposures,
+            value_list.graphics_exposures.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::ClipOriginX,
+            value_list.clip_x_origin.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::ClipOriginY,
+            value_list.clip_y_origin.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::ClipMask,
+            value_list.clip_mask.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::DashOffset,
+            value_list.dash_offset.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::DashList, value_list.dashes.has_value(),
+            true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::ArcMode, value_list.arc_mode.has_value(),
+            true, &value_mask);
+  uint32_t tmp79;
+  tmp79 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp79);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Function)) {
+    auto& function = *value_list.function;
+
+    // function
+    uint32_t tmp80;
+    tmp80 = static_cast<uint32_t>(function);
+    buf.Write(&tmp80);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::PlaneMask)) {
+    auto& plane_mask = *value_list.plane_mask;
+
+    // plane_mask
+    buf.Write(&plane_mask);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Foreground)) {
+    auto& foreground = *value_list.foreground;
+
+    // foreground
+    buf.Write(&foreground);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Background)) {
+    auto& background = *value_list.background;
+
+    // background
+    buf.Write(&background);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::LineWidth)) {
+    auto& line_width = *value_list.line_width;
+
+    // line_width
+    buf.Write(&line_width);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::LineStyle)) {
+    auto& line_style = *value_list.line_style;
+
+    // line_style
+    uint32_t tmp81;
+    tmp81 = static_cast<uint32_t>(line_style);
+    buf.Write(&tmp81);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::CapStyle)) {
+    auto& cap_style = *value_list.cap_style;
+
+    // cap_style
+    uint32_t tmp82;
+    tmp82 = static_cast<uint32_t>(cap_style);
+    buf.Write(&tmp82);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::JoinStyle)) {
+    auto& join_style = *value_list.join_style;
+
+    // join_style
+    uint32_t tmp83;
+    tmp83 = static_cast<uint32_t>(join_style);
+    buf.Write(&tmp83);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::FillStyle)) {
+    auto& fill_style = *value_list.fill_style;
+
+    // fill_style
+    uint32_t tmp84;
+    tmp84 = static_cast<uint32_t>(fill_style);
+    buf.Write(&tmp84);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::FillRule)) {
+    auto& fill_rule = *value_list.fill_rule;
+
+    // fill_rule
+    uint32_t tmp85;
+    tmp85 = static_cast<uint32_t>(fill_rule);
+    buf.Write(&tmp85);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Tile)) {
+    auto& tile = *value_list.tile;
+
+    // tile
+    buf.Write(&tile);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Stipple)) {
+    auto& stipple = *value_list.stipple;
+
+    // stipple
+    buf.Write(&stipple);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::TileStippleOriginX)) {
+    auto& tile_stipple_x_origin = *value_list.tile_stipple_x_origin;
+
+    // tile_stipple_x_origin
+    buf.Write(&tile_stipple_x_origin);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::TileStippleOriginY)) {
+    auto& tile_stipple_y_origin = *value_list.tile_stipple_y_origin;
+
+    // tile_stipple_y_origin
+    buf.Write(&tile_stipple_y_origin);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Font)) {
+    auto& font = *value_list.font;
+
+    // font
+    buf.Write(&font);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::SubwindowMode)) {
+    auto& subwindow_mode = *value_list.subwindow_mode;
+
+    // subwindow_mode
+    uint32_t tmp86;
+    tmp86 = static_cast<uint32_t>(subwindow_mode);
+    buf.Write(&tmp86);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::GraphicsExposures)) {
+    auto& graphics_exposures = *value_list.graphics_exposures;
+
+    // graphics_exposures
+    buf.Write(&graphics_exposures);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipOriginX)) {
+    auto& clip_x_origin = *value_list.clip_x_origin;
+
+    // clip_x_origin
+    buf.Write(&clip_x_origin);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipOriginY)) {
+    auto& clip_y_origin = *value_list.clip_y_origin;
+
+    // clip_y_origin
+    buf.Write(&clip_y_origin);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipMask)) {
+    auto& clip_mask = *value_list.clip_mask;
+
+    // clip_mask
+    buf.Write(&clip_mask);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::DashOffset)) {
+    auto& dash_offset = *value_list.dash_offset;
+
+    // dash_offset
+    buf.Write(&dash_offset);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::DashList)) {
+    auto& dashes = *value_list.dashes;
+
+    // dashes
+    buf.Write(&dashes);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::ArcMode)) {
+    auto& arc_mode = *value_list.arc_mode;
+
+    // arc_mode
+    uint32_t tmp87;
+    tmp87 = static_cast<uint32_t>(arc_mode);
+    buf.Write(&tmp87);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CreateGC", false);
+}
+
+Future<void> XProto::CreateGC(
+    const GraphicsContext& cid,
+    const Drawable& drawable,
+    const absl::optional<Gx>& function,
+    const absl::optional<uint32_t>& plane_mask,
+    const absl::optional<uint32_t>& foreground,
+    const absl::optional<uint32_t>& background,
+    const absl::optional<uint32_t>& line_width,
+    const absl::optional<LineStyle>& line_style,
+    const absl::optional<CapStyle>& cap_style,
+    const absl::optional<JoinStyle>& join_style,
+    const absl::optional<FillStyle>& fill_style,
+    const absl::optional<FillRule>& fill_rule,
+    const absl::optional<Pixmap>& tile,
+    const absl::optional<Pixmap>& stipple,
+    const absl::optional<int32_t>& tile_stipple_x_origin,
+    const absl::optional<int32_t>& tile_stipple_y_origin,
+    const absl::optional<Font>& font,
+    const absl::optional<SubwindowMode>& subwindow_mode,
+    const absl::optional<Bool32>& graphics_exposures,
+    const absl::optional<int32_t>& clip_x_origin,
+    const absl::optional<int32_t>& clip_y_origin,
+    const absl::optional<Pixmap>& clip_mask,
+    const absl::optional<uint32_t>& dash_offset,
+    const absl::optional<uint32_t>& dashes,
+    const absl::optional<ArcMode>& arc_mode) {
+  return XProto::CreateGC(CreateGCRequest{cid,
+                                          drawable,
+                                          function,
+                                          plane_mask,
+                                          foreground,
+                                          background,
+                                          line_width,
+                                          line_style,
+                                          cap_style,
+                                          join_style,
+                                          fill_style,
+                                          fill_rule,
+                                          tile,
+                                          stipple,
+                                          tile_stipple_x_origin,
+                                          tile_stipple_y_origin,
+                                          font,
+                                          subwindow_mode,
+                                          graphics_exposures,
+                                          clip_x_origin,
+                                          clip_y_origin,
+                                          clip_mask,
+                                          dash_offset,
+                                          dashes,
+                                          arc_mode});
+}
+
+Future<void> XProto::ChangeGC(const ChangeGCRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& gc = request.gc;
+  GraphicsContextAttribute value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = 56;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // gc
+  buf.Write(&gc);
+
+  // value_mask
+  SwitchVar(GraphicsContextAttribute::Function, value_list.function.has_value(),
+            true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::PlaneMask,
+            value_list.plane_mask.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::Foreground,
+            value_list.foreground.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::Background,
+            value_list.background.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::LineWidth,
+            value_list.line_width.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::LineStyle,
+            value_list.line_style.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::CapStyle,
+            value_list.cap_style.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::JoinStyle,
+            value_list.join_style.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::FillStyle,
+            value_list.fill_style.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::FillRule,
+            value_list.fill_rule.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::Tile, value_list.tile.has_value(), true,
+            &value_mask);
+  SwitchVar(GraphicsContextAttribute::Stipple, value_list.stipple.has_value(),
+            true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::TileStippleOriginX,
+            value_list.tile_stipple_x_origin.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::TileStippleOriginY,
+            value_list.tile_stipple_y_origin.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::Font, value_list.font.has_value(), true,
+            &value_mask);
+  SwitchVar(GraphicsContextAttribute::SubwindowMode,
+            value_list.subwindow_mode.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::GraphicsExposures,
+            value_list.graphics_exposures.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::ClipOriginX,
+            value_list.clip_x_origin.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::ClipOriginY,
+            value_list.clip_y_origin.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::ClipMask,
+            value_list.clip_mask.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::DashOffset,
+            value_list.dash_offset.has_value(), true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::DashList, value_list.dashes.has_value(),
+            true, &value_mask);
+  SwitchVar(GraphicsContextAttribute::ArcMode, value_list.arc_mode.has_value(),
+            true, &value_mask);
+  uint32_t tmp88;
+  tmp88 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp88);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Function)) {
+    auto& function = *value_list.function;
+
+    // function
+    uint32_t tmp89;
+    tmp89 = static_cast<uint32_t>(function);
+    buf.Write(&tmp89);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::PlaneMask)) {
+    auto& plane_mask = *value_list.plane_mask;
+
+    // plane_mask
+    buf.Write(&plane_mask);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Foreground)) {
+    auto& foreground = *value_list.foreground;
+
+    // foreground
+    buf.Write(&foreground);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Background)) {
+    auto& background = *value_list.background;
+
+    // background
+    buf.Write(&background);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::LineWidth)) {
+    auto& line_width = *value_list.line_width;
+
+    // line_width
+    buf.Write(&line_width);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::LineStyle)) {
+    auto& line_style = *value_list.line_style;
+
+    // line_style
+    uint32_t tmp90;
+    tmp90 = static_cast<uint32_t>(line_style);
+    buf.Write(&tmp90);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::CapStyle)) {
+    auto& cap_style = *value_list.cap_style;
+
+    // cap_style
+    uint32_t tmp91;
+    tmp91 = static_cast<uint32_t>(cap_style);
+    buf.Write(&tmp91);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::JoinStyle)) {
+    auto& join_style = *value_list.join_style;
+
+    // join_style
+    uint32_t tmp92;
+    tmp92 = static_cast<uint32_t>(join_style);
+    buf.Write(&tmp92);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::FillStyle)) {
+    auto& fill_style = *value_list.fill_style;
+
+    // fill_style
+    uint32_t tmp93;
+    tmp93 = static_cast<uint32_t>(fill_style);
+    buf.Write(&tmp93);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::FillRule)) {
+    auto& fill_rule = *value_list.fill_rule;
+
+    // fill_rule
+    uint32_t tmp94;
+    tmp94 = static_cast<uint32_t>(fill_rule);
+    buf.Write(&tmp94);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Tile)) {
+    auto& tile = *value_list.tile;
+
+    // tile
+    buf.Write(&tile);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Stipple)) {
+    auto& stipple = *value_list.stipple;
+
+    // stipple
+    buf.Write(&stipple);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::TileStippleOriginX)) {
+    auto& tile_stipple_x_origin = *value_list.tile_stipple_x_origin;
+
+    // tile_stipple_x_origin
+    buf.Write(&tile_stipple_x_origin);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::TileStippleOriginY)) {
+    auto& tile_stipple_y_origin = *value_list.tile_stipple_y_origin;
+
+    // tile_stipple_y_origin
+    buf.Write(&tile_stipple_y_origin);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::Font)) {
+    auto& font = *value_list.font;
+
+    // font
+    buf.Write(&font);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::SubwindowMode)) {
+    auto& subwindow_mode = *value_list.subwindow_mode;
+
+    // subwindow_mode
+    uint32_t tmp95;
+    tmp95 = static_cast<uint32_t>(subwindow_mode);
+    buf.Write(&tmp95);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::GraphicsExposures)) {
+    auto& graphics_exposures = *value_list.graphics_exposures;
+
+    // graphics_exposures
+    buf.Write(&graphics_exposures);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipOriginX)) {
+    auto& clip_x_origin = *value_list.clip_x_origin;
+
+    // clip_x_origin
+    buf.Write(&clip_x_origin);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipOriginY)) {
+    auto& clip_y_origin = *value_list.clip_y_origin;
+
+    // clip_y_origin
+    buf.Write(&clip_y_origin);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::ClipMask)) {
+    auto& clip_mask = *value_list.clip_mask;
+
+    // clip_mask
+    buf.Write(&clip_mask);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::DashOffset)) {
+    auto& dash_offset = *value_list.dash_offset;
+
+    // dash_offset
+    buf.Write(&dash_offset);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::DashList)) {
+    auto& dashes = *value_list.dashes;
+
+    // dashes
+    buf.Write(&dashes);
+  }
+  if (CaseAnd(value_list_expr, GraphicsContextAttribute::ArcMode)) {
+    auto& arc_mode = *value_list.arc_mode;
+
+    // arc_mode
+    uint32_t tmp96;
+    tmp96 = static_cast<uint32_t>(arc_mode);
+    buf.Write(&tmp96);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangeGC", false);
+}
+
+Future<void> XProto::ChangeGC(
+    const GraphicsContext& gc,
+    const absl::optional<Gx>& function,
+    const absl::optional<uint32_t>& plane_mask,
+    const absl::optional<uint32_t>& foreground,
+    const absl::optional<uint32_t>& background,
+    const absl::optional<uint32_t>& line_width,
+    const absl::optional<LineStyle>& line_style,
+    const absl::optional<CapStyle>& cap_style,
+    const absl::optional<JoinStyle>& join_style,
+    const absl::optional<FillStyle>& fill_style,
+    const absl::optional<FillRule>& fill_rule,
+    const absl::optional<Pixmap>& tile,
+    const absl::optional<Pixmap>& stipple,
+    const absl::optional<int32_t>& tile_stipple_x_origin,
+    const absl::optional<int32_t>& tile_stipple_y_origin,
+    const absl::optional<Font>& font,
+    const absl::optional<SubwindowMode>& subwindow_mode,
+    const absl::optional<Bool32>& graphics_exposures,
+    const absl::optional<int32_t>& clip_x_origin,
+    const absl::optional<int32_t>& clip_y_origin,
+    const absl::optional<Pixmap>& clip_mask,
+    const absl::optional<uint32_t>& dash_offset,
+    const absl::optional<uint32_t>& dashes,
+    const absl::optional<ArcMode>& arc_mode) {
+  return XProto::ChangeGC(ChangeGCRequest{gc,
+                                          function,
+                                          plane_mask,
+                                          foreground,
+                                          background,
+                                          line_width,
+                                          line_style,
+                                          cap_style,
+                                          join_style,
+                                          fill_style,
+                                          fill_rule,
+                                          tile,
+                                          stipple,
+                                          tile_stipple_x_origin,
+                                          tile_stipple_y_origin,
+                                          font,
+                                          subwindow_mode,
+                                          graphics_exposures,
+                                          clip_x_origin,
+                                          clip_y_origin,
+                                          clip_mask,
+                                          dash_offset,
+                                          dashes,
+                                          arc_mode});
+}
+
+Future<void> XProto::CopyGC(const CopyGCRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& src_gc = request.src_gc;
+  auto& dst_gc = request.dst_gc;
+  auto& value_mask = request.value_mask;
+
+  // major_opcode
+  uint8_t major_opcode = 57;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // src_gc
+  buf.Write(&src_gc);
+
+  // dst_gc
+  buf.Write(&dst_gc);
+
+  // value_mask
+  uint32_t tmp97;
+  tmp97 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp97);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CopyGC", false);
+}
+
+Future<void> XProto::CopyGC(const GraphicsContext& src_gc,
+                            const GraphicsContext& dst_gc,
+                            const GraphicsContextAttribute& value_mask) {
+  return XProto::CopyGC(CopyGCRequest{src_gc, dst_gc, value_mask});
+}
+
+Future<void> XProto::SetDashes(const SetDashesRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& gc = request.gc;
+  auto& dash_offset = request.dash_offset;
+  uint16_t dashes_len{};
+  auto& dashes = request.dashes;
+
+  // major_opcode
+  uint8_t major_opcode = 58;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // gc
+  buf.Write(&gc);
+
+  // dash_offset
+  buf.Write(&dash_offset);
+
+  // dashes_len
+  dashes_len = dashes.size();
+  buf.Write(&dashes_len);
+
+  // dashes
+  DCHECK_EQ(static_cast<size_t>(dashes_len), dashes.size());
+  for (auto& dashes_elem : dashes) {
+    // dashes_elem
+    buf.Write(&dashes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SetDashes", false);
+}
+
+Future<void> XProto::SetDashes(const GraphicsContext& gc,
+                               const uint16_t& dash_offset,
+                               const std::vector<uint8_t>& dashes) {
+  return XProto::SetDashes(SetDashesRequest{gc, dash_offset, dashes});
+}
+
+Future<void> XProto::SetClipRectangles(
+    const SetClipRectanglesRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& ordering = request.ordering;
+  auto& gc = request.gc;
+  auto& clip_x_origin = request.clip_x_origin;
+  auto& clip_y_origin = request.clip_y_origin;
+  auto& rectangles = request.rectangles;
+  size_t rectangles_len = rectangles.size();
+
+  // major_opcode
+  uint8_t major_opcode = 59;
+  buf.Write(&major_opcode);
+
+  // ordering
+  uint8_t tmp98;
+  tmp98 = static_cast<uint8_t>(ordering);
+  buf.Write(&tmp98);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // gc
+  buf.Write(&gc);
+
+  // clip_x_origin
+  buf.Write(&clip_x_origin);
+
+  // clip_y_origin
+  buf.Write(&clip_y_origin);
+
+  // rectangles
+  DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size());
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SetClipRectangles", false);
+}
+
+Future<void> XProto::SetClipRectangles(
+    const ClipOrdering& ordering,
+    const GraphicsContext& gc,
+    const int16_t& clip_x_origin,
+    const int16_t& clip_y_origin,
+    const std::vector<Rectangle>& rectangles) {
+  return XProto::SetClipRectangles(SetClipRectanglesRequest{
+      ordering, gc, clip_x_origin, clip_y_origin, rectangles});
+}
+
+Future<void> XProto::FreeGC(const FreeGCRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& gc = request.gc;
+
+  // major_opcode
+  uint8_t major_opcode = 60;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // gc
+  buf.Write(&gc);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "FreeGC", false);
+}
+
+Future<void> XProto::FreeGC(const GraphicsContext& gc) {
+  return XProto::FreeGC(FreeGCRequest{gc});
+}
+
+Future<void> XProto::ClearArea(const ClearAreaRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& exposures = request.exposures;
+  auto& window = request.window;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& width = request.width;
+  auto& height = request.height;
+
+  // major_opcode
+  uint8_t major_opcode = 61;
+  buf.Write(&major_opcode);
+
+  // exposures
+  buf.Write(&exposures);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ClearArea", false);
+}
+
+Future<void> XProto::ClearArea(const uint8_t& exposures,
+                               const Window& window,
+                               const int16_t& x,
+                               const int16_t& y,
+                               const uint16_t& width,
+                               const uint16_t& height) {
+  return XProto::ClearArea(
+      ClearAreaRequest{exposures, window, x, y, width, height});
+}
+
+Future<void> XProto::CopyArea(const CopyAreaRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& src_drawable = request.src_drawable;
+  auto& dst_drawable = request.dst_drawable;
+  auto& gc = request.gc;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& dst_x = request.dst_x;
+  auto& dst_y = request.dst_y;
+  auto& width = request.width;
+  auto& height = request.height;
+
+  // major_opcode
+  uint8_t major_opcode = 62;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // src_drawable
+  buf.Write(&src_drawable);
+
+  // dst_drawable
+  buf.Write(&dst_drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // dst_x
+  buf.Write(&dst_x);
+
+  // dst_y
+  buf.Write(&dst_y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CopyArea", false);
+}
+
+Future<void> XProto::CopyArea(const Drawable& src_drawable,
+                              const Drawable& dst_drawable,
+                              const GraphicsContext& gc,
+                              const int16_t& src_x,
+                              const int16_t& src_y,
+                              const int16_t& dst_x,
+                              const int16_t& dst_y,
+                              const uint16_t& width,
+                              const uint16_t& height) {
+  return XProto::CopyArea(CopyAreaRequest{src_drawable, dst_drawable, gc, src_x,
+                                          src_y, dst_x, dst_y, width, height});
+}
+
+Future<void> XProto::CopyPlane(const CopyPlaneRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& src_drawable = request.src_drawable;
+  auto& dst_drawable = request.dst_drawable;
+  auto& gc = request.gc;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& dst_x = request.dst_x;
+  auto& dst_y = request.dst_y;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& bit_plane = request.bit_plane;
+
+  // major_opcode
+  uint8_t major_opcode = 63;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // src_drawable
+  buf.Write(&src_drawable);
+
+  // dst_drawable
+  buf.Write(&dst_drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // dst_x
+  buf.Write(&dst_x);
+
+  // dst_y
+  buf.Write(&dst_y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // bit_plane
+  buf.Write(&bit_plane);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CopyPlane", false);
+}
+
+Future<void> XProto::CopyPlane(const Drawable& src_drawable,
+                               const Drawable& dst_drawable,
+                               const GraphicsContext& gc,
+                               const int16_t& src_x,
+                               const int16_t& src_y,
+                               const int16_t& dst_x,
+                               const int16_t& dst_y,
+                               const uint16_t& width,
+                               const uint16_t& height,
+                               const uint32_t& bit_plane) {
+  return XProto::CopyPlane(CopyPlaneRequest{src_drawable, dst_drawable, gc,
+                                            src_x, src_y, dst_x, dst_y, width,
+                                            height, bit_plane});
+}
+
+Future<void> XProto::PolyPoint(const PolyPointRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& coordinate_mode = request.coordinate_mode;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& points = request.points;
+  size_t points_len = points.size();
+
+  // major_opcode
+  uint8_t major_opcode = 64;
+  buf.Write(&major_opcode);
+
+  // coordinate_mode
+  uint8_t tmp99;
+  tmp99 = static_cast<uint8_t>(coordinate_mode);
+  buf.Write(&tmp99);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // points
+  DCHECK_EQ(static_cast<size_t>(points_len), points.size());
+  for (auto& points_elem : points) {
+    // points_elem
+    {
+      auto& x = points_elem.x;
+      auto& y = points_elem.y;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolyPoint", false);
+}
+
+Future<void> XProto::PolyPoint(const CoordMode& coordinate_mode,
+                               const Drawable& drawable,
+                               const GraphicsContext& gc,
+                               const std::vector<Point>& points) {
+  return XProto::PolyPoint(
+      PolyPointRequest{coordinate_mode, drawable, gc, points});
+}
+
+Future<void> XProto::PolyLine(const PolyLineRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& coordinate_mode = request.coordinate_mode;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& points = request.points;
+  size_t points_len = points.size();
+
+  // major_opcode
+  uint8_t major_opcode = 65;
+  buf.Write(&major_opcode);
+
+  // coordinate_mode
+  uint8_t tmp100;
+  tmp100 = static_cast<uint8_t>(coordinate_mode);
+  buf.Write(&tmp100);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // points
+  DCHECK_EQ(static_cast<size_t>(points_len), points.size());
+  for (auto& points_elem : points) {
+    // points_elem
+    {
+      auto& x = points_elem.x;
+      auto& y = points_elem.y;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolyLine", false);
+}
+
+Future<void> XProto::PolyLine(const CoordMode& coordinate_mode,
+                              const Drawable& drawable,
+                              const GraphicsContext& gc,
+                              const std::vector<Point>& points) {
+  return XProto::PolyLine(
+      PolyLineRequest{coordinate_mode, drawable, gc, points});
+}
+
+Future<void> XProto::PolySegment(const PolySegmentRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& segments = request.segments;
+  size_t segments_len = segments.size();
+
+  // major_opcode
+  uint8_t major_opcode = 66;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // segments
+  DCHECK_EQ(static_cast<size_t>(segments_len), segments.size());
+  for (auto& segments_elem : segments) {
+    // segments_elem
+    {
+      auto& x1 = segments_elem.x1;
+      auto& y1 = segments_elem.y1;
+      auto& x2 = segments_elem.x2;
+      auto& y2 = segments_elem.y2;
+
+      // x1
+      buf.Write(&x1);
+
+      // y1
+      buf.Write(&y1);
+
+      // x2
+      buf.Write(&x2);
+
+      // y2
+      buf.Write(&y2);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolySegment", false);
+}
+
+Future<void> XProto::PolySegment(const Drawable& drawable,
+                                 const GraphicsContext& gc,
+                                 const std::vector<Segment>& segments) {
+  return XProto::PolySegment(PolySegmentRequest{drawable, gc, segments});
+}
+
+Future<void> XProto::PolyRectangle(const PolyRectangleRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& rectangles = request.rectangles;
+  size_t rectangles_len = rectangles.size();
+
+  // major_opcode
+  uint8_t major_opcode = 67;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // rectangles
+  DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size());
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolyRectangle", false);
+}
+
+Future<void> XProto::PolyRectangle(const Drawable& drawable,
+                                   const GraphicsContext& gc,
+                                   const std::vector<Rectangle>& rectangles) {
+  return XProto::PolyRectangle(PolyRectangleRequest{drawable, gc, rectangles});
+}
+
+Future<void> XProto::PolyArc(const PolyArcRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& arcs = request.arcs;
+  size_t arcs_len = arcs.size();
+
+  // major_opcode
+  uint8_t major_opcode = 68;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // arcs
+  DCHECK_EQ(static_cast<size_t>(arcs_len), arcs.size());
+  for (auto& arcs_elem : arcs) {
+    // arcs_elem
+    {
+      auto& x = arcs_elem.x;
+      auto& y = arcs_elem.y;
+      auto& width = arcs_elem.width;
+      auto& height = arcs_elem.height;
+      auto& angle1 = arcs_elem.angle1;
+      auto& angle2 = arcs_elem.angle2;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+
+      // angle1
+      buf.Write(&angle1);
+
+      // angle2
+      buf.Write(&angle2);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolyArc", false);
+}
+
+Future<void> XProto::PolyArc(const Drawable& drawable,
+                             const GraphicsContext& gc,
+                             const std::vector<Arc>& arcs) {
+  return XProto::PolyArc(PolyArcRequest{drawable, gc, arcs});
+}
+
+Future<void> XProto::FillPoly(const FillPolyRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& shape = request.shape;
+  auto& coordinate_mode = request.coordinate_mode;
+  auto& points = request.points;
+  size_t points_len = points.size();
+
+  // major_opcode
+  uint8_t major_opcode = 69;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // shape
+  uint8_t tmp101;
+  tmp101 = static_cast<uint8_t>(shape);
+  buf.Write(&tmp101);
+
+  // coordinate_mode
+  uint8_t tmp102;
+  tmp102 = static_cast<uint8_t>(coordinate_mode);
+  buf.Write(&tmp102);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // points
+  DCHECK_EQ(static_cast<size_t>(points_len), points.size());
+  for (auto& points_elem : points) {
+    // points_elem
+    {
+      auto& x = points_elem.x;
+      auto& y = points_elem.y;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "FillPoly", false);
+}
+
+Future<void> XProto::FillPoly(const Drawable& drawable,
+                              const GraphicsContext& gc,
+                              const PolyShape& shape,
+                              const CoordMode& coordinate_mode,
+                              const std::vector<Point>& points) {
+  return XProto::FillPoly(
+      FillPolyRequest{drawable, gc, shape, coordinate_mode, points});
+}
+
+Future<void> XProto::PolyFillRectangle(
+    const PolyFillRectangleRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& rectangles = request.rectangles;
+  size_t rectangles_len = rectangles.size();
+
+  // major_opcode
+  uint8_t major_opcode = 70;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // rectangles
+  DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size());
+  for (auto& rectangles_elem : rectangles) {
+    // rectangles_elem
+    {
+      auto& x = rectangles_elem.x;
+      auto& y = rectangles_elem.y;
+      auto& width = rectangles_elem.width;
+      auto& height = rectangles_elem.height;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolyFillRectangle", false);
+}
+
+Future<void> XProto::PolyFillRectangle(
+    const Drawable& drawable,
+    const GraphicsContext& gc,
+    const std::vector<Rectangle>& rectangles) {
+  return XProto::PolyFillRectangle(
+      PolyFillRectangleRequest{drawable, gc, rectangles});
+}
+
+Future<void> XProto::PolyFillArc(const PolyFillArcRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& arcs = request.arcs;
+  size_t arcs_len = arcs.size();
+
+  // major_opcode
+  uint8_t major_opcode = 71;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // arcs
+  DCHECK_EQ(static_cast<size_t>(arcs_len), arcs.size());
+  for (auto& arcs_elem : arcs) {
+    // arcs_elem
+    {
+      auto& x = arcs_elem.x;
+      auto& y = arcs_elem.y;
+      auto& width = arcs_elem.width;
+      auto& height = arcs_elem.height;
+      auto& angle1 = arcs_elem.angle1;
+      auto& angle2 = arcs_elem.angle2;
+
+      // x
+      buf.Write(&x);
+
+      // y
+      buf.Write(&y);
+
+      // width
+      buf.Write(&width);
+
+      // height
+      buf.Write(&height);
+
+      // angle1
+      buf.Write(&angle1);
+
+      // angle2
+      buf.Write(&angle2);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolyFillArc", false);
+}
+
+Future<void> XProto::PolyFillArc(const Drawable& drawable,
+                                 const GraphicsContext& gc,
+                                 const std::vector<Arc>& arcs) {
+  return XProto::PolyFillArc(PolyFillArcRequest{drawable, gc, arcs});
+}
+
+Future<void> XProto::PutImage(const PutImageRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& format = request.format;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& dst_x = request.dst_x;
+  auto& dst_y = request.dst_y;
+  auto& left_pad = request.left_pad;
+  auto& depth = request.depth;
+  auto& data = request.data;
+  size_t data_len = data ? data->size() : 0;
+
+  // major_opcode
+  uint8_t major_opcode = 72;
+  buf.Write(&major_opcode);
+
+  // format
+  uint8_t tmp103;
+  tmp103 = static_cast<uint8_t>(format);
+  buf.Write(&tmp103);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // dst_x
+  buf.Write(&dst_x);
+
+  // dst_y
+  buf.Write(&dst_y);
+
+  // left_pad
+  buf.Write(&left_pad);
+
+  // depth
+  buf.Write(&depth);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // data
+  buf.AppendBuffer(data, data_len);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PutImage", false);
+}
+
+Future<void> XProto::PutImage(
+    const ImageFormat& format,
+    const Drawable& drawable,
+    const GraphicsContext& gc,
+    const uint16_t& width,
+    const uint16_t& height,
+    const int16_t& dst_x,
+    const int16_t& dst_y,
+    const uint8_t& left_pad,
+    const uint8_t& depth,
+    const scoped_refptr<base::RefCountedMemory>& data) {
+  return XProto::PutImage(PutImageRequest{format, drawable, gc, width, height,
+                                          dst_x, dst_y, left_pad, depth, data});
+}
+
+Future<GetImageReply> XProto::GetImage(const GetImageRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& format = request.format;
+  auto& drawable = request.drawable;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& plane_mask = request.plane_mask;
+
+  // major_opcode
+  uint8_t major_opcode = 73;
+  buf.Write(&major_opcode);
+
+  // format
+  uint8_t tmp104;
+  tmp104 = static_cast<uint8_t>(format);
+  buf.Write(&tmp104);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // plane_mask
+  buf.Write(&plane_mask);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetImageReply>(&buf, "GetImage", false);
+}
+
+Future<GetImageReply> XProto::GetImage(const ImageFormat& format,
+                                       const Drawable& drawable,
+                                       const int16_t& x,
+                                       const int16_t& y,
+                                       const uint16_t& width,
+                                       const uint16_t& height,
+                                       const uint32_t& plane_mask) {
+  return XProto::GetImage(
+      GetImageRequest{format, drawable, x, y, width, height, plane_mask});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetImageReply> detail::ReadReply<GetImageReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetImageReply>();
+
+  auto& depth = (*reply).depth;
+  auto& sequence = (*reply).sequence;
+  auto& visual = (*reply).visual;
+  auto& data = (*reply).data;
+  size_t data_len = data ? data->size() : 0;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // depth
+  Read(&depth, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // visual
+  Read(&visual, &buf);
+
+  // pad0
+  Pad(&buf, 20);
+
+  // data
+  data = buffer->ReadAndAdvance((length) * (4));
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::PolyText8(const PolyText8Request& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& items = request.items;
+  size_t items_len = items.size();
+
+  // major_opcode
+  uint8_t major_opcode = 74;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // items
+  DCHECK_EQ(static_cast<size_t>(items_len), items.size());
+  for (auto& items_elem : items) {
+    // items_elem
+    buf.Write(&items_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolyText8", false);
+}
+
+Future<void> XProto::PolyText8(const Drawable& drawable,
+                               const GraphicsContext& gc,
+                               const int16_t& x,
+                               const int16_t& y,
+                               const std::vector<uint8_t>& items) {
+  return XProto::PolyText8(PolyText8Request{drawable, gc, x, y, items});
+}
+
+Future<void> XProto::PolyText16(const PolyText16Request& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& items = request.items;
+  size_t items_len = items.size();
+
+  // major_opcode
+  uint8_t major_opcode = 75;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // items
+  DCHECK_EQ(static_cast<size_t>(items_len), items.size());
+  for (auto& items_elem : items) {
+    // items_elem
+    buf.Write(&items_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "PolyText16", false);
+}
+
+Future<void> XProto::PolyText16(const Drawable& drawable,
+                                const GraphicsContext& gc,
+                                const int16_t& x,
+                                const int16_t& y,
+                                const std::vector<uint8_t>& items) {
+  return XProto::PolyText16(PolyText16Request{drawable, gc, x, y, items});
+}
+
+Future<void> XProto::ImageText8(const ImageText8Request& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  uint8_t string_len{};
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& string = request.string;
+
+  // major_opcode
+  uint8_t major_opcode = 76;
+  buf.Write(&major_opcode);
+
+  // string_len
+  string_len = string.size();
+  buf.Write(&string_len);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // string
+  DCHECK_EQ(static_cast<size_t>(string_len), string.size());
+  for (auto& string_elem : string) {
+    // string_elem
+    buf.Write(&string_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ImageText8", false);
+}
+
+Future<void> XProto::ImageText8(const Drawable& drawable,
+                                const GraphicsContext& gc,
+                                const int16_t& x,
+                                const int16_t& y,
+                                const std::string& string) {
+  return XProto::ImageText8(ImageText8Request{drawable, gc, x, y, string});
+}
+
+Future<void> XProto::ImageText16(const ImageText16Request& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  uint8_t string_len{};
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& x = request.x;
+  auto& y = request.y;
+  auto& string = request.string;
+
+  // major_opcode
+  uint8_t major_opcode = 77;
+  buf.Write(&major_opcode);
+
+  // string_len
+  string_len = string.size();
+  buf.Write(&string_len);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  // string
+  DCHECK_EQ(static_cast<size_t>(string_len), string.size());
+  for (auto& string_elem : string) {
+    // string_elem
+    {
+      auto& byte1 = string_elem.byte1;
+      auto& byte2 = string_elem.byte2;
+
+      // byte1
+      buf.Write(&byte1);
+
+      // byte2
+      buf.Write(&byte2);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ImageText16", false);
+}
+
+Future<void> XProto::ImageText16(const Drawable& drawable,
+                                 const GraphicsContext& gc,
+                                 const int16_t& x,
+                                 const int16_t& y,
+                                 const std::vector<Char16>& string) {
+  return XProto::ImageText16(ImageText16Request{drawable, gc, x, y, string});
+}
+
+Future<void> XProto::CreateColormap(const CreateColormapRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& alloc = request.alloc;
+  auto& mid = request.mid;
+  auto& window = request.window;
+  auto& visual = request.visual;
+
+  // major_opcode
+  uint8_t major_opcode = 78;
+  buf.Write(&major_opcode);
+
+  // alloc
+  uint8_t tmp105;
+  tmp105 = static_cast<uint8_t>(alloc);
+  buf.Write(&tmp105);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // mid
+  buf.Write(&mid);
+
+  // window
+  buf.Write(&window);
+
+  // visual
+  buf.Write(&visual);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CreateColormap", false);
+}
+
+Future<void> XProto::CreateColormap(const ColormapAlloc& alloc,
+                                    const ColorMap& mid,
+                                    const Window& window,
+                                    const VisualId& visual) {
+  return XProto::CreateColormap(
+      CreateColormapRequest{alloc, mid, window, visual});
+}
+
+Future<void> XProto::FreeColormap(const FreeColormapRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+
+  // major_opcode
+  uint8_t major_opcode = 79;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "FreeColormap", false);
+}
+
+Future<void> XProto::FreeColormap(const ColorMap& cmap) {
+  return XProto::FreeColormap(FreeColormapRequest{cmap});
+}
+
+Future<void> XProto::CopyColormapAndFree(
+    const CopyColormapAndFreeRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mid = request.mid;
+  auto& src_cmap = request.src_cmap;
+
+  // major_opcode
+  uint8_t major_opcode = 80;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // mid
+  buf.Write(&mid);
+
+  // src_cmap
+  buf.Write(&src_cmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CopyColormapAndFree", false);
+}
+
+Future<void> XProto::CopyColormapAndFree(const ColorMap& mid,
+                                         const ColorMap& src_cmap) {
+  return XProto::CopyColormapAndFree(CopyColormapAndFreeRequest{mid, src_cmap});
+}
+
+Future<void> XProto::InstallColormap(const InstallColormapRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+
+  // major_opcode
+  uint8_t major_opcode = 81;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "InstallColormap", false);
+}
+
+Future<void> XProto::InstallColormap(const ColorMap& cmap) {
+  return XProto::InstallColormap(InstallColormapRequest{cmap});
+}
+
+Future<void> XProto::UninstallColormap(
+    const UninstallColormapRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+
+  // major_opcode
+  uint8_t major_opcode = 82;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "UninstallColormap", false);
+}
+
+Future<void> XProto::UninstallColormap(const ColorMap& cmap) {
+  return XProto::UninstallColormap(UninstallColormapRequest{cmap});
+}
+
+Future<ListInstalledColormapsReply> XProto::ListInstalledColormaps(
+    const ListInstalledColormapsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = 83;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<ListInstalledColormapsReply>(
+      &buf, "ListInstalledColormaps", false);
+}
+
+Future<ListInstalledColormapsReply> XProto::ListInstalledColormaps(
+    const Window& window) {
+  return XProto::ListInstalledColormaps(ListInstalledColormapsRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<ListInstalledColormapsReply> detail::ReadReply<
+    ListInstalledColormapsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<ListInstalledColormapsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t cmaps_len{};
+  auto& cmaps = (*reply).cmaps;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // cmaps_len
+  Read(&cmaps_len, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // cmaps
+  cmaps.resize(cmaps_len);
+  for (auto& cmaps_elem : cmaps) {
+    // cmaps_elem
+    Read(&cmaps_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<AllocColorReply> XProto::AllocColor(const AllocColorRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+  auto& red = request.red;
+  auto& green = request.green;
+  auto& blue = request.blue;
+
+  // major_opcode
+  uint8_t major_opcode = 84;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // red
+  buf.Write(&red);
+
+  // green
+  buf.Write(&green);
+
+  // blue
+  buf.Write(&blue);
+
+  // pad1
+  Pad(&buf, 2);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<AllocColorReply>(&buf, "AllocColor", false);
+}
+
+Future<AllocColorReply> XProto::AllocColor(const ColorMap& cmap,
+                                           const uint16_t& red,
+                                           const uint16_t& green,
+                                           const uint16_t& blue) {
+  return XProto::AllocColor(AllocColorRequest{cmap, red, green, blue});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<AllocColorReply> detail::ReadReply<AllocColorReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<AllocColorReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& red = (*reply).red;
+  auto& green = (*reply).green;
+  auto& blue = (*reply).blue;
+  auto& pixel = (*reply).pixel;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // red
+  Read(&red, &buf);
+
+  // green
+  Read(&green, &buf);
+
+  // blue
+  Read(&blue, &buf);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // pixel
+  Read(&pixel, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<AllocNamedColorReply> XProto::AllocNamedColor(
+    const AllocNamedColorRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+  uint16_t name_len{};
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = 85;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // name_len
+  name_len = name.size();
+  buf.Write(&name_len);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<AllocNamedColorReply>(&buf, "AllocNamedColor",
+                                                        false);
+}
+
+Future<AllocNamedColorReply> XProto::AllocNamedColor(const ColorMap& cmap,
+                                                     const std::string& name) {
+  return XProto::AllocNamedColor(AllocNamedColorRequest{cmap, name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<AllocNamedColorReply> detail::ReadReply<AllocNamedColorReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<AllocNamedColorReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& pixel = (*reply).pixel;
+  auto& exact_red = (*reply).exact_red;
+  auto& exact_green = (*reply).exact_green;
+  auto& exact_blue = (*reply).exact_blue;
+  auto& visual_red = (*reply).visual_red;
+  auto& visual_green = (*reply).visual_green;
+  auto& visual_blue = (*reply).visual_blue;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pixel
+  Read(&pixel, &buf);
+
+  // exact_red
+  Read(&exact_red, &buf);
+
+  // exact_green
+  Read(&exact_green, &buf);
+
+  // exact_blue
+  Read(&exact_blue, &buf);
+
+  // visual_red
+  Read(&visual_red, &buf);
+
+  // visual_green
+  Read(&visual_green, &buf);
+
+  // visual_blue
+  Read(&visual_blue, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<AllocColorCellsReply> XProto::AllocColorCells(
+    const AllocColorCellsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& contiguous = request.contiguous;
+  auto& cmap = request.cmap;
+  auto& colors = request.colors;
+  auto& planes = request.planes;
+
+  // major_opcode
+  uint8_t major_opcode = 86;
+  buf.Write(&major_opcode);
+
+  // contiguous
+  buf.Write(&contiguous);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // colors
+  buf.Write(&colors);
+
+  // planes
+  buf.Write(&planes);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<AllocColorCellsReply>(&buf, "AllocColorCells",
+                                                        false);
+}
+
+Future<AllocColorCellsReply> XProto::AllocColorCells(const uint8_t& contiguous,
+                                                     const ColorMap& cmap,
+                                                     const uint16_t& colors,
+                                                     const uint16_t& planes) {
+  return XProto::AllocColorCells(
+      AllocColorCellsRequest{contiguous, cmap, colors, planes});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<AllocColorCellsReply> detail::ReadReply<AllocColorCellsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<AllocColorCellsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t pixels_len{};
+  uint16_t masks_len{};
+  auto& pixels = (*reply).pixels;
+  auto& masks = (*reply).masks;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pixels_len
+  Read(&pixels_len, &buf);
+
+  // masks_len
+  Read(&masks_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // pixels
+  pixels.resize(pixels_len);
+  for (auto& pixels_elem : pixels) {
+    // pixels_elem
+    Read(&pixels_elem, &buf);
+  }
+
+  // masks
+  masks.resize(masks_len);
+  for (auto& masks_elem : masks) {
+    // masks_elem
+    Read(&masks_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<AllocColorPlanesReply> XProto::AllocColorPlanes(
+    const AllocColorPlanesRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& contiguous = request.contiguous;
+  auto& cmap = request.cmap;
+  auto& colors = request.colors;
+  auto& reds = request.reds;
+  auto& greens = request.greens;
+  auto& blues = request.blues;
+
+  // major_opcode
+  uint8_t major_opcode = 87;
+  buf.Write(&major_opcode);
+
+  // contiguous
+  buf.Write(&contiguous);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // colors
+  buf.Write(&colors);
+
+  // reds
+  buf.Write(&reds);
+
+  // greens
+  buf.Write(&greens);
+
+  // blues
+  buf.Write(&blues);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<AllocColorPlanesReply>(
+      &buf, "AllocColorPlanes", false);
+}
+
+Future<AllocColorPlanesReply> XProto::AllocColorPlanes(
+    const uint8_t& contiguous,
+    const ColorMap& cmap,
+    const uint16_t& colors,
+    const uint16_t& reds,
+    const uint16_t& greens,
+    const uint16_t& blues) {
+  return XProto::AllocColorPlanes(
+      AllocColorPlanesRequest{contiguous, cmap, colors, reds, greens, blues});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<AllocColorPlanesReply> detail::ReadReply<AllocColorPlanesReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<AllocColorPlanesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t pixels_len{};
+  auto& red_mask = (*reply).red_mask;
+  auto& green_mask = (*reply).green_mask;
+  auto& blue_mask = (*reply).blue_mask;
+  auto& pixels = (*reply).pixels;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pixels_len
+  Read(&pixels_len, &buf);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // red_mask
+  Read(&red_mask, &buf);
+
+  // green_mask
+  Read(&green_mask, &buf);
+
+  // blue_mask
+  Read(&blue_mask, &buf);
+
+  // pad2
+  Pad(&buf, 8);
+
+  // pixels
+  pixels.resize(pixels_len);
+  for (auto& pixels_elem : pixels) {
+    // pixels_elem
+    Read(&pixels_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::FreeColors(const FreeColorsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+  auto& plane_mask = request.plane_mask;
+  auto& pixels = request.pixels;
+  size_t pixels_len = pixels.size();
+
+  // major_opcode
+  uint8_t major_opcode = 88;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // plane_mask
+  buf.Write(&plane_mask);
+
+  // pixels
+  DCHECK_EQ(static_cast<size_t>(pixels_len), pixels.size());
+  for (auto& pixels_elem : pixels) {
+    // pixels_elem
+    buf.Write(&pixels_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "FreeColors", false);
+}
+
+Future<void> XProto::FreeColors(const ColorMap& cmap,
+                                const uint32_t& plane_mask,
+                                const std::vector<uint32_t>& pixels) {
+  return XProto::FreeColors(FreeColorsRequest{cmap, plane_mask, pixels});
+}
+
+Future<void> XProto::StoreColors(const StoreColorsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+  auto& items = request.items;
+  size_t items_len = items.size();
+
+  // major_opcode
+  uint8_t major_opcode = 89;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // items
+  DCHECK_EQ(static_cast<size_t>(items_len), items.size());
+  for (auto& items_elem : items) {
+    // items_elem
+    {
+      auto& pixel = items_elem.pixel;
+      auto& red = items_elem.red;
+      auto& green = items_elem.green;
+      auto& blue = items_elem.blue;
+      auto& flags = items_elem.flags;
+
+      // pixel
+      buf.Write(&pixel);
+
+      // red
+      buf.Write(&red);
+
+      // green
+      buf.Write(&green);
+
+      // blue
+      buf.Write(&blue);
+
+      // flags
+      uint8_t tmp106;
+      tmp106 = static_cast<uint8_t>(flags);
+      buf.Write(&tmp106);
+
+      // pad0
+      Pad(&buf, 1);
+    }
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "StoreColors", false);
+}
+
+Future<void> XProto::StoreColors(const ColorMap& cmap,
+                                 const std::vector<ColorItem>& items) {
+  return XProto::StoreColors(StoreColorsRequest{cmap, items});
+}
+
+Future<void> XProto::StoreNamedColor(const StoreNamedColorRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& flags = request.flags;
+  auto& cmap = request.cmap;
+  auto& pixel = request.pixel;
+  uint16_t name_len{};
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = 90;
+  buf.Write(&major_opcode);
+
+  // flags
+  uint8_t tmp107;
+  tmp107 = static_cast<uint8_t>(flags);
+  buf.Write(&tmp107);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // pixel
+  buf.Write(&pixel);
+
+  // name_len
+  name_len = name.size();
+  buf.Write(&name_len);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "StoreNamedColor", false);
+}
+
+Future<void> XProto::StoreNamedColor(const ColorFlag& flags,
+                                     const ColorMap& cmap,
+                                     const uint32_t& pixel,
+                                     const std::string& name) {
+  return XProto::StoreNamedColor(
+      StoreNamedColorRequest{flags, cmap, pixel, name});
+}
+
+Future<QueryColorsReply> XProto::QueryColors(
+    const QueryColorsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+  auto& pixels = request.pixels;
+  size_t pixels_len = pixels.size();
+
+  // major_opcode
+  uint8_t major_opcode = 91;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // pixels
+  DCHECK_EQ(static_cast<size_t>(pixels_len), pixels.size());
+  for (auto& pixels_elem : pixels) {
+    // pixels_elem
+    buf.Write(&pixels_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<QueryColorsReply>(&buf, "QueryColors", false);
+}
+
+Future<QueryColorsReply> XProto::QueryColors(
+    const ColorMap& cmap,
+    const std::vector<uint32_t>& pixels) {
+  return XProto::QueryColors(QueryColorsRequest{cmap, pixels});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<QueryColorsReply> detail::ReadReply<QueryColorsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<QueryColorsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t colors_len{};
+  auto& colors = (*reply).colors;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // colors_len
+  Read(&colors_len, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // colors
+  colors.resize(colors_len);
+  for (auto& colors_elem : colors) {
+    // colors_elem
+    {
+      auto& red = colors_elem.red;
+      auto& green = colors_elem.green;
+      auto& blue = colors_elem.blue;
+
+      // red
+      Read(&red, &buf);
+
+      // green
+      Read(&green, &buf);
+
+      // blue
+      Read(&blue, &buf);
+
+      // pad0
+      Pad(&buf, 2);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<LookupColorReply> XProto::LookupColor(
+    const LookupColorRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cmap = request.cmap;
+  uint16_t name_len{};
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = 92;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cmap
+  buf.Write(&cmap);
+
+  // name_len
+  name_len = name.size();
+  buf.Write(&name_len);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<LookupColorReply>(&buf, "LookupColor", false);
+}
+
+Future<LookupColorReply> XProto::LookupColor(const ColorMap& cmap,
+                                             const std::string& name) {
+  return XProto::LookupColor(LookupColorRequest{cmap, name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<LookupColorReply> detail::ReadReply<LookupColorReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<LookupColorReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& exact_red = (*reply).exact_red;
+  auto& exact_green = (*reply).exact_green;
+  auto& exact_blue = (*reply).exact_blue;
+  auto& visual_red = (*reply).visual_red;
+  auto& visual_green = (*reply).visual_green;
+  auto& visual_blue = (*reply).visual_blue;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // exact_red
+  Read(&exact_red, &buf);
+
+  // exact_green
+  Read(&exact_green, &buf);
+
+  // exact_blue
+  Read(&exact_blue, &buf);
+
+  // visual_red
+  Read(&visual_red, &buf);
+
+  // visual_green
+  Read(&visual_green, &buf);
+
+  // visual_blue
+  Read(&visual_blue, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::CreateCursor(const CreateCursorRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cid = request.cid;
+  auto& source = request.source;
+  auto& mask = request.mask;
+  auto& fore_red = request.fore_red;
+  auto& fore_green = request.fore_green;
+  auto& fore_blue = request.fore_blue;
+  auto& back_red = request.back_red;
+  auto& back_green = request.back_green;
+  auto& back_blue = request.back_blue;
+  auto& x = request.x;
+  auto& y = request.y;
+
+  // major_opcode
+  uint8_t major_opcode = 93;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cid
+  buf.Write(&cid);
+
+  // source
+  buf.Write(&source);
+
+  // mask
+  buf.Write(&mask);
+
+  // fore_red
+  buf.Write(&fore_red);
+
+  // fore_green
+  buf.Write(&fore_green);
+
+  // fore_blue
+  buf.Write(&fore_blue);
+
+  // back_red
+  buf.Write(&back_red);
+
+  // back_green
+  buf.Write(&back_green);
+
+  // back_blue
+  buf.Write(&back_blue);
+
+  // x
+  buf.Write(&x);
+
+  // y
+  buf.Write(&y);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CreateCursor", false);
+}
+
+Future<void> XProto::CreateCursor(const Cursor& cid,
+                                  const Pixmap& source,
+                                  const Pixmap& mask,
+                                  const uint16_t& fore_red,
+                                  const uint16_t& fore_green,
+                                  const uint16_t& fore_blue,
+                                  const uint16_t& back_red,
+                                  const uint16_t& back_green,
+                                  const uint16_t& back_blue,
+                                  const uint16_t& x,
+                                  const uint16_t& y) {
+  return XProto::CreateCursor(
+      CreateCursorRequest{cid, source, mask, fore_red, fore_green, fore_blue,
+                          back_red, back_green, back_blue, x, y});
+}
+
+Future<void> XProto::CreateGlyphCursor(
+    const CreateGlyphCursorRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cid = request.cid;
+  auto& source_font = request.source_font;
+  auto& mask_font = request.mask_font;
+  auto& source_char = request.source_char;
+  auto& mask_char = request.mask_char;
+  auto& fore_red = request.fore_red;
+  auto& fore_green = request.fore_green;
+  auto& fore_blue = request.fore_blue;
+  auto& back_red = request.back_red;
+  auto& back_green = request.back_green;
+  auto& back_blue = request.back_blue;
+
+  // major_opcode
+  uint8_t major_opcode = 94;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cid
+  buf.Write(&cid);
+
+  // source_font
+  buf.Write(&source_font);
+
+  // mask_font
+  buf.Write(&mask_font);
+
+  // source_char
+  buf.Write(&source_char);
+
+  // mask_char
+  buf.Write(&mask_char);
+
+  // fore_red
+  buf.Write(&fore_red);
+
+  // fore_green
+  buf.Write(&fore_green);
+
+  // fore_blue
+  buf.Write(&fore_blue);
+
+  // back_red
+  buf.Write(&back_red);
+
+  // back_green
+  buf.Write(&back_green);
+
+  // back_blue
+  buf.Write(&back_blue);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "CreateGlyphCursor", false);
+}
+
+Future<void> XProto::CreateGlyphCursor(const Cursor& cid,
+                                       const Font& source_font,
+                                       const Font& mask_font,
+                                       const uint16_t& source_char,
+                                       const uint16_t& mask_char,
+                                       const uint16_t& fore_red,
+                                       const uint16_t& fore_green,
+                                       const uint16_t& fore_blue,
+                                       const uint16_t& back_red,
+                                       const uint16_t& back_green,
+                                       const uint16_t& back_blue) {
+  return XProto::CreateGlyphCursor(CreateGlyphCursorRequest{
+      cid, source_font, mask_font, source_char, mask_char, fore_red, fore_green,
+      fore_blue, back_red, back_green, back_blue});
+}
+
+Future<void> XProto::FreeCursor(const FreeCursorRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cursor = request.cursor;
+
+  // major_opcode
+  uint8_t major_opcode = 95;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cursor
+  buf.Write(&cursor);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "FreeCursor", false);
+}
+
+Future<void> XProto::FreeCursor(const Cursor& cursor) {
+  return XProto::FreeCursor(FreeCursorRequest{cursor});
+}
+
+Future<void> XProto::RecolorCursor(const RecolorCursorRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& cursor = request.cursor;
+  auto& fore_red = request.fore_red;
+  auto& fore_green = request.fore_green;
+  auto& fore_blue = request.fore_blue;
+  auto& back_red = request.back_red;
+  auto& back_green = request.back_green;
+  auto& back_blue = request.back_blue;
+
+  // major_opcode
+  uint8_t major_opcode = 96;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // cursor
+  buf.Write(&cursor);
+
+  // fore_red
+  buf.Write(&fore_red);
+
+  // fore_green
+  buf.Write(&fore_green);
+
+  // fore_blue
+  buf.Write(&fore_blue);
+
+  // back_red
+  buf.Write(&back_red);
+
+  // back_green
+  buf.Write(&back_green);
+
+  // back_blue
+  buf.Write(&back_blue);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RecolorCursor", false);
+}
+
+Future<void> XProto::RecolorCursor(const Cursor& cursor,
+                                   const uint16_t& fore_red,
+                                   const uint16_t& fore_green,
+                                   const uint16_t& fore_blue,
+                                   const uint16_t& back_red,
+                                   const uint16_t& back_green,
+                                   const uint16_t& back_blue) {
+  return XProto::RecolorCursor(
+      RecolorCursorRequest{cursor, fore_red, fore_green, fore_blue, back_red,
+                           back_green, back_blue});
+}
+
+Future<QueryBestSizeReply> XProto::QueryBestSize(
+    const QueryBestSizeRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& c_class = request.c_class;
+  auto& drawable = request.drawable;
+  auto& width = request.width;
+  auto& height = request.height;
+
+  // major_opcode
+  uint8_t major_opcode = 97;
+  buf.Write(&major_opcode);
+
+  // c_class
+  uint8_t tmp108;
+  tmp108 = static_cast<uint8_t>(c_class);
+  buf.Write(&tmp108);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<QueryBestSizeReply>(&buf, "QueryBestSize",
+                                                      false);
+}
+
+Future<QueryBestSizeReply> XProto::QueryBestSize(const QueryShapeOf& c_class,
+                                                 const Drawable& drawable,
+                                                 const uint16_t& width,
+                                                 const uint16_t& height) {
+  return XProto::QueryBestSize(
+      QueryBestSizeRequest{c_class, drawable, width, height});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<QueryBestSizeReply> detail::ReadReply<QueryBestSizeReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<QueryBestSizeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<QueryExtensionReply> XProto::QueryExtension(
+    const QueryExtensionRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  uint16_t name_len{};
+  auto& name = request.name;
+
+  // major_opcode
+  uint8_t major_opcode = 98;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // name_len
+  name_len = name.size();
+  buf.Write(&name_len);
+
+  // pad1
+  Pad(&buf, 2);
+
+  // name
+  DCHECK_EQ(static_cast<size_t>(name_len), name.size());
+  for (auto& name_elem : name) {
+    // name_elem
+    buf.Write(&name_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<QueryExtensionReply>(&buf, "QueryExtension",
+                                                       false);
+}
+
+Future<QueryExtensionReply> XProto::QueryExtension(const std::string& name) {
+  return XProto::QueryExtension(QueryExtensionRequest{name});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<QueryExtensionReply> detail::ReadReply<QueryExtensionReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<QueryExtensionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& present = (*reply).present;
+  auto& major_opcode = (*reply).major_opcode;
+  auto& first_event = (*reply).first_event;
+  auto& first_error = (*reply).first_error;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // present
+  Read(&present, &buf);
+
+  // major_opcode
+  Read(&major_opcode, &buf);
+
+  // first_event
+  Read(&first_event, &buf);
+
+  // first_error
+  Read(&first_error, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<ListExtensionsReply> XProto::ListExtensions(
+    const ListExtensionsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 99;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<ListExtensionsReply>(&buf, "ListExtensions",
+                                                       false);
+}
+
+Future<ListExtensionsReply> XProto::ListExtensions() {
+  return XProto::ListExtensions(ListExtensionsRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<ListExtensionsReply> detail::ReadReply<ListExtensionsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<ListExtensionsReply>();
+
+  uint8_t names_len{};
+  auto& sequence = (*reply).sequence;
+  auto& names = (*reply).names;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // names_len
+  Read(&names_len, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad0
+  Pad(&buf, 24);
+
+  // names
+  names.resize(names_len);
+  for (auto& names_elem : names) {
+    // names_elem
+    {
+      uint8_t name_len{};
+      auto& name = names_elem.name;
+
+      // name_len
+      Read(&name_len, &buf);
+
+      // name
+      name.resize(name_len);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::ChangeKeyboardMapping(
+    const ChangeKeyboardMappingRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& keycode_count = request.keycode_count;
+  auto& first_keycode = request.first_keycode;
+  auto& keysyms_per_keycode = request.keysyms_per_keycode;
+  auto& keysyms = request.keysyms;
+  size_t keysyms_len = keysyms.size();
+
+  // major_opcode
+  uint8_t major_opcode = 100;
+  buf.Write(&major_opcode);
+
+  // keycode_count
+  buf.Write(&keycode_count);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // first_keycode
+  buf.Write(&first_keycode);
+
+  // keysyms_per_keycode
+  buf.Write(&keysyms_per_keycode);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // keysyms
+  DCHECK_EQ(static_cast<size_t>((keycode_count) * (keysyms_per_keycode)),
+            keysyms.size());
+  for (auto& keysyms_elem : keysyms) {
+    // keysyms_elem
+    buf.Write(&keysyms_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangeKeyboardMapping", false);
+}
+
+Future<void> XProto::ChangeKeyboardMapping(const uint8_t& keycode_count,
+                                           const KeyCode& first_keycode,
+                                           const uint8_t& keysyms_per_keycode,
+                                           const std::vector<KeySym>& keysyms) {
+  return XProto::ChangeKeyboardMapping(ChangeKeyboardMappingRequest{
+      keycode_count, first_keycode, keysyms_per_keycode, keysyms});
+}
+
+Future<GetKeyboardMappingReply> XProto::GetKeyboardMapping(
+    const GetKeyboardMappingRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& first_keycode = request.first_keycode;
+  auto& count = request.count;
+
+  // major_opcode
+  uint8_t major_opcode = 101;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // first_keycode
+  buf.Write(&first_keycode);
+
+  // count
+  buf.Write(&count);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetKeyboardMappingReply>(
+      &buf, "GetKeyboardMapping", false);
+}
+
+Future<GetKeyboardMappingReply> XProto::GetKeyboardMapping(
+    const KeyCode& first_keycode,
+    const uint8_t& count) {
+  return XProto::GetKeyboardMapping(
+      GetKeyboardMappingRequest{first_keycode, count});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetKeyboardMappingReply> detail::ReadReply<
+    GetKeyboardMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetKeyboardMappingReply>();
+
+  auto& keysyms_per_keycode = (*reply).keysyms_per_keycode;
+  auto& sequence = (*reply).sequence;
+  auto& keysyms = (*reply).keysyms;
+  size_t keysyms_len = keysyms.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // keysyms_per_keycode
+  Read(&keysyms_per_keycode, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad0
+  Pad(&buf, 24);
+
+  // keysyms
+  keysyms.resize(length);
+  for (auto& keysyms_elem : keysyms) {
+    // keysyms_elem
+    Read(&keysyms_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::ChangeKeyboardControl(
+    const ChangeKeyboardControlRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  Keyboard value_mask{};
+  auto& value_list = request;
+
+  // major_opcode
+  uint8_t major_opcode = 102;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // value_mask
+  SwitchVar(Keyboard::KeyClickPercent, value_list.key_click_percent.has_value(),
+            true, &value_mask);
+  SwitchVar(Keyboard::BellPercent, value_list.bell_percent.has_value(), true,
+            &value_mask);
+  SwitchVar(Keyboard::BellPitch, value_list.bell_pitch.has_value(), true,
+            &value_mask);
+  SwitchVar(Keyboard::BellDuration, value_list.bell_duration.has_value(), true,
+            &value_mask);
+  SwitchVar(Keyboard::Led, value_list.led.has_value(), true, &value_mask);
+  SwitchVar(Keyboard::LedMode, value_list.led_mode.has_value(), true,
+            &value_mask);
+  SwitchVar(Keyboard::Key, value_list.key.has_value(), true, &value_mask);
+  SwitchVar(Keyboard::AutoRepeatMode, value_list.auto_repeat_mode.has_value(),
+            true, &value_mask);
+  uint32_t tmp109;
+  tmp109 = static_cast<uint32_t>(value_mask);
+  buf.Write(&tmp109);
+
+  // value_list
+  auto value_list_expr = value_mask;
+  if (CaseAnd(value_list_expr, Keyboard::KeyClickPercent)) {
+    auto& key_click_percent = *value_list.key_click_percent;
+
+    // key_click_percent
+    buf.Write(&key_click_percent);
+  }
+  if (CaseAnd(value_list_expr, Keyboard::BellPercent)) {
+    auto& bell_percent = *value_list.bell_percent;
+
+    // bell_percent
+    buf.Write(&bell_percent);
+  }
+  if (CaseAnd(value_list_expr, Keyboard::BellPitch)) {
+    auto& bell_pitch = *value_list.bell_pitch;
+
+    // bell_pitch
+    buf.Write(&bell_pitch);
+  }
+  if (CaseAnd(value_list_expr, Keyboard::BellDuration)) {
+    auto& bell_duration = *value_list.bell_duration;
+
+    // bell_duration
+    buf.Write(&bell_duration);
+  }
+  if (CaseAnd(value_list_expr, Keyboard::Led)) {
+    auto& led = *value_list.led;
+
+    // led
+    buf.Write(&led);
+  }
+  if (CaseAnd(value_list_expr, Keyboard::LedMode)) {
+    auto& led_mode = *value_list.led_mode;
+
+    // led_mode
+    uint32_t tmp110;
+    tmp110 = static_cast<uint32_t>(led_mode);
+    buf.Write(&tmp110);
+  }
+  if (CaseAnd(value_list_expr, Keyboard::Key)) {
+    auto& key = *value_list.key;
+
+    // key
+    buf.Write(&key);
+  }
+  if (CaseAnd(value_list_expr, Keyboard::AutoRepeatMode)) {
+    auto& auto_repeat_mode = *value_list.auto_repeat_mode;
+
+    // auto_repeat_mode
+    uint32_t tmp111;
+    tmp111 = static_cast<uint32_t>(auto_repeat_mode);
+    buf.Write(&tmp111);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangeKeyboardControl", false);
+}
+
+Future<void> XProto::ChangeKeyboardControl(
+    const absl::optional<int32_t>& key_click_percent,
+    const absl::optional<int32_t>& bell_percent,
+    const absl::optional<int32_t>& bell_pitch,
+    const absl::optional<int32_t>& bell_duration,
+    const absl::optional<uint32_t>& led,
+    const absl::optional<LedMode>& led_mode,
+    const absl::optional<KeyCode32>& key,
+    const absl::optional<AutoRepeatMode>& auto_repeat_mode) {
+  return XProto::ChangeKeyboardControl(ChangeKeyboardControlRequest{
+      key_click_percent, bell_percent, bell_pitch, bell_duration, led, led_mode,
+      key, auto_repeat_mode});
+}
+
+Future<GetKeyboardControlReply> XProto::GetKeyboardControl(
+    const GetKeyboardControlRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 103;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetKeyboardControlReply>(
+      &buf, "GetKeyboardControl", false);
+}
+
+Future<GetKeyboardControlReply> XProto::GetKeyboardControl() {
+  return XProto::GetKeyboardControl(GetKeyboardControlRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetKeyboardControlReply> detail::ReadReply<
+    GetKeyboardControlReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetKeyboardControlReply>();
+
+  auto& global_auto_repeat = (*reply).global_auto_repeat;
+  auto& sequence = (*reply).sequence;
+  auto& led_mask = (*reply).led_mask;
+  auto& key_click_percent = (*reply).key_click_percent;
+  auto& bell_percent = (*reply).bell_percent;
+  auto& bell_pitch = (*reply).bell_pitch;
+  auto& bell_duration = (*reply).bell_duration;
+  auto& auto_repeats = (*reply).auto_repeats;
+  size_t auto_repeats_len = auto_repeats.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // global_auto_repeat
+  uint8_t tmp112;
+  Read(&tmp112, &buf);
+  global_auto_repeat = static_cast<AutoRepeatMode>(tmp112);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // led_mask
+  Read(&led_mask, &buf);
+
+  // key_click_percent
+  Read(&key_click_percent, &buf);
+
+  // bell_percent
+  Read(&bell_percent, &buf);
+
+  // bell_pitch
+  Read(&bell_pitch, &buf);
+
+  // bell_duration
+  Read(&bell_duration, &buf);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // auto_repeats
+  for (auto& auto_repeats_elem : auto_repeats) {
+    // auto_repeats_elem
+    Read(&auto_repeats_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::Bell(const BellRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& percent = request.percent;
+
+  // major_opcode
+  uint8_t major_opcode = 104;
+  buf.Write(&major_opcode);
+
+  // percent
+  buf.Write(&percent);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Bell", false);
+}
+
+Future<void> XProto::Bell(const int8_t& percent) {
+  return XProto::Bell(BellRequest{percent});
+}
+
+Future<void> XProto::ChangePointerControl(
+    const ChangePointerControlRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& acceleration_numerator = request.acceleration_numerator;
+  auto& acceleration_denominator = request.acceleration_denominator;
+  auto& threshold = request.threshold;
+  auto& do_acceleration = request.do_acceleration;
+  auto& do_threshold = request.do_threshold;
+
+  // major_opcode
+  uint8_t major_opcode = 105;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // acceleration_numerator
+  buf.Write(&acceleration_numerator);
+
+  // acceleration_denominator
+  buf.Write(&acceleration_denominator);
+
+  // threshold
+  buf.Write(&threshold);
+
+  // do_acceleration
+  buf.Write(&do_acceleration);
+
+  // do_threshold
+  buf.Write(&do_threshold);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangePointerControl", false);
+}
+
+Future<void> XProto::ChangePointerControl(
+    const int16_t& acceleration_numerator,
+    const int16_t& acceleration_denominator,
+    const int16_t& threshold,
+    const uint8_t& do_acceleration,
+    const uint8_t& do_threshold) {
+  return XProto::ChangePointerControl(ChangePointerControlRequest{
+      acceleration_numerator, acceleration_denominator, threshold,
+      do_acceleration, do_threshold});
+}
+
+Future<GetPointerControlReply> XProto::GetPointerControl(
+    const GetPointerControlRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 106;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetPointerControlReply>(
+      &buf, "GetPointerControl", false);
+}
+
+Future<GetPointerControlReply> XProto::GetPointerControl() {
+  return XProto::GetPointerControl(GetPointerControlRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetPointerControlReply> detail::ReadReply<
+    GetPointerControlReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetPointerControlReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& acceleration_numerator = (*reply).acceleration_numerator;
+  auto& acceleration_denominator = (*reply).acceleration_denominator;
+  auto& threshold = (*reply).threshold;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // acceleration_numerator
+  Read(&acceleration_numerator, &buf);
+
+  // acceleration_denominator
+  Read(&acceleration_denominator, &buf);
+
+  // threshold
+  Read(&threshold, &buf);
+
+  // pad1
+  Pad(&buf, 18);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::SetScreenSaver(const SetScreenSaverRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& timeout = request.timeout;
+  auto& interval = request.interval;
+  auto& prefer_blanking = request.prefer_blanking;
+  auto& allow_exposures = request.allow_exposures;
+
+  // major_opcode
+  uint8_t major_opcode = 107;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // timeout
+  buf.Write(&timeout);
+
+  // interval
+  buf.Write(&interval);
+
+  // prefer_blanking
+  uint8_t tmp113;
+  tmp113 = static_cast<uint8_t>(prefer_blanking);
+  buf.Write(&tmp113);
+
+  // allow_exposures
+  uint8_t tmp114;
+  tmp114 = static_cast<uint8_t>(allow_exposures);
+  buf.Write(&tmp114);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SetScreenSaver", false);
+}
+
+Future<void> XProto::SetScreenSaver(const int16_t& timeout,
+                                    const int16_t& interval,
+                                    const Blanking& prefer_blanking,
+                                    const Exposures& allow_exposures) {
+  return XProto::SetScreenSaver(SetScreenSaverRequest{
+      timeout, interval, prefer_blanking, allow_exposures});
+}
+
+Future<GetScreenSaverReply> XProto::GetScreenSaver(
+    const GetScreenSaverRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 108;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetScreenSaverReply>(&buf, "GetScreenSaver",
+                                                       false);
+}
+
+Future<GetScreenSaverReply> XProto::GetScreenSaver() {
+  return XProto::GetScreenSaver(GetScreenSaverRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetScreenSaverReply> detail::ReadReply<GetScreenSaverReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetScreenSaverReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& timeout = (*reply).timeout;
+  auto& interval = (*reply).interval;
+  auto& prefer_blanking = (*reply).prefer_blanking;
+  auto& allow_exposures = (*reply).allow_exposures;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // timeout
+  Read(&timeout, &buf);
+
+  // interval
+  Read(&interval, &buf);
+
+  // prefer_blanking
+  uint8_t tmp115;
+  Read(&tmp115, &buf);
+  prefer_blanking = static_cast<Blanking>(tmp115);
+
+  // allow_exposures
+  uint8_t tmp116;
+  Read(&tmp116, &buf);
+  allow_exposures = static_cast<Exposures>(tmp116);
+
+  // pad1
+  Pad(&buf, 18);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::ChangeHosts(const ChangeHostsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+  auto& family = request.family;
+  uint16_t address_len{};
+  auto& address = request.address;
+
+  // major_opcode
+  uint8_t major_opcode = 109;
+  buf.Write(&major_opcode);
+
+  // mode
+  uint8_t tmp117;
+  tmp117 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp117);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // family
+  uint8_t tmp118;
+  tmp118 = static_cast<uint8_t>(family);
+  buf.Write(&tmp118);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // address_len
+  address_len = address.size();
+  buf.Write(&address_len);
+
+  // address
+  DCHECK_EQ(static_cast<size_t>(address_len), address.size());
+  for (auto& address_elem : address) {
+    // address_elem
+    buf.Write(&address_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ChangeHosts", false);
+}
+
+Future<void> XProto::ChangeHosts(const HostMode& mode,
+                                 const Family& family,
+                                 const std::vector<uint8_t>& address) {
+  return XProto::ChangeHosts(ChangeHostsRequest{mode, family, address});
+}
+
+Future<ListHostsReply> XProto::ListHosts(const ListHostsRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 110;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<ListHostsReply>(&buf, "ListHosts", false);
+}
+
+Future<ListHostsReply> XProto::ListHosts() {
+  return XProto::ListHosts(ListHostsRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<ListHostsReply> detail::ReadReply<ListHostsReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<ListHostsReply>();
+
+  auto& mode = (*reply).mode;
+  auto& sequence = (*reply).sequence;
+  uint16_t hosts_len{};
+  auto& hosts = (*reply).hosts;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // mode
+  uint8_t tmp119;
+  Read(&tmp119, &buf);
+  mode = static_cast<AccessControl>(tmp119);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // hosts_len
+  Read(&hosts_len, &buf);
+
+  // pad0
+  Pad(&buf, 22);
+
+  // hosts
+  hosts.resize(hosts_len);
+  for (auto& hosts_elem : hosts) {
+    // hosts_elem
+    {
+      auto& family = hosts_elem.family;
+      uint16_t address_len{};
+      auto& address = hosts_elem.address;
+
+      // family
+      uint8_t tmp120;
+      Read(&tmp120, &buf);
+      family = static_cast<Family>(tmp120);
+
+      // pad0
+      Pad(&buf, 1);
+
+      // address_len
+      Read(&address_len, &buf);
+
+      // address
+      address.resize(address_len);
+      for (auto& address_elem : address) {
+        // address_elem
+        Read(&address_elem, &buf);
+      }
+
+      // pad1
+      Align(&buf, 4);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::SetAccessControl(const SetAccessControlRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = 111;
+  buf.Write(&major_opcode);
+
+  // mode
+  uint8_t tmp121;
+  tmp121 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp121);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SetAccessControl", false);
+}
+
+Future<void> XProto::SetAccessControl(const AccessControl& mode) {
+  return XProto::SetAccessControl(SetAccessControlRequest{mode});
+}
+
+Future<void> XProto::SetCloseDownMode(const SetCloseDownModeRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = 112;
+  buf.Write(&major_opcode);
+
+  // mode
+  uint8_t tmp122;
+  tmp122 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp122);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SetCloseDownMode", false);
+}
+
+Future<void> XProto::SetCloseDownMode(const CloseDown& mode) {
+  return XProto::SetCloseDownMode(SetCloseDownModeRequest{mode});
+}
+
+Future<void> XProto::KillClient(const KillClientRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& resource = request.resource;
+
+  // major_opcode
+  uint8_t major_opcode = 113;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // resource
+  buf.Write(&resource);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "KillClient", false);
+}
+
+Future<void> XProto::KillClient(const uint32_t& resource) {
+  return XProto::KillClient(KillClientRequest{resource});
+}
+
+Future<void> XProto::RotateProperties(const RotatePropertiesRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  uint16_t atoms_len{};
+  auto& delta = request.delta;
+  auto& atoms = request.atoms;
+
+  // major_opcode
+  uint8_t major_opcode = 114;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // atoms_len
+  atoms_len = atoms.size();
+  buf.Write(&atoms_len);
+
+  // delta
+  buf.Write(&delta);
+
+  // atoms
+  DCHECK_EQ(static_cast<size_t>(atoms_len), atoms.size());
+  for (auto& atoms_elem : atoms) {
+    // atoms_elem
+    buf.Write(&atoms_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "RotateProperties", false);
+}
+
+Future<void> XProto::RotateProperties(const Window& window,
+                                      const int16_t& delta,
+                                      const std::vector<Atom>& atoms) {
+  return XProto::RotateProperties(
+      RotatePropertiesRequest{window, delta, atoms});
+}
+
+Future<void> XProto::ForceScreenSaver(const ForceScreenSaverRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& mode = request.mode;
+
+  // major_opcode
+  uint8_t major_opcode = 115;
+  buf.Write(&major_opcode);
+
+  // mode
+  uint8_t tmp123;
+  tmp123 = static_cast<uint8_t>(mode);
+  buf.Write(&tmp123);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "ForceScreenSaver", false);
+}
+
+Future<void> XProto::ForceScreenSaver(const ScreenSaverMode& mode) {
+  return XProto::ForceScreenSaver(ForceScreenSaverRequest{mode});
+}
+
+Future<SetPointerMappingReply> XProto::SetPointerMapping(
+    const SetPointerMappingRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  uint8_t map_len{};
+  auto& map = request.map;
+
+  // major_opcode
+  uint8_t major_opcode = 116;
+  buf.Write(&major_opcode);
+
+  // map_len
+  map_len = map.size();
+  buf.Write(&map_len);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // map
+  DCHECK_EQ(static_cast<size_t>(map_len), map.size());
+  for (auto& map_elem : map) {
+    // map_elem
+    buf.Write(&map_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SetPointerMappingReply>(
+      &buf, "SetPointerMapping", false);
+}
+
+Future<SetPointerMappingReply> XProto::SetPointerMapping(
+    const std::vector<uint8_t>& map) {
+  return XProto::SetPointerMapping(SetPointerMappingRequest{map});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SetPointerMappingReply> detail::ReadReply<
+    SetPointerMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SetPointerMappingReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp124;
+  Read(&tmp124, &buf);
+  status = static_cast<MappingStatus>(tmp124);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<GetPointerMappingReply> XProto::GetPointerMapping(
+    const GetPointerMappingRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 117;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetPointerMappingReply>(
+      &buf, "GetPointerMapping", false);
+}
+
+Future<GetPointerMappingReply> XProto::GetPointerMapping() {
+  return XProto::GetPointerMapping(GetPointerMappingRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetPointerMappingReply> detail::ReadReply<
+    GetPointerMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetPointerMappingReply>();
+
+  uint8_t map_len{};
+  auto& sequence = (*reply).sequence;
+  auto& map = (*reply).map;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // map_len
+  Read(&map_len, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad0
+  Pad(&buf, 24);
+
+  // map
+  map.resize(map_len);
+  for (auto& map_elem : map) {
+    // map_elem
+    Read(&map_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SetModifierMappingReply> XProto::SetModifierMapping(
+    const SetModifierMappingRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& keycodes_per_modifier = request.keycodes_per_modifier;
+  auto& keycodes = request.keycodes;
+  size_t keycodes_len = keycodes.size();
+
+  // major_opcode
+  uint8_t major_opcode = 118;
+  buf.Write(&major_opcode);
+
+  // keycodes_per_modifier
+  buf.Write(&keycodes_per_modifier);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // keycodes
+  DCHECK_EQ(static_cast<size_t>((keycodes_per_modifier) * (8)),
+            keycodes.size());
+  for (auto& keycodes_elem : keycodes) {
+    // keycodes_elem
+    buf.Write(&keycodes_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SetModifierMappingReply>(
+      &buf, "SetModifierMapping", false);
+}
+
+Future<SetModifierMappingReply> XProto::SetModifierMapping(
+    const uint8_t& keycodes_per_modifier,
+    const std::vector<KeyCode>& keycodes) {
+  return XProto::SetModifierMapping(
+      SetModifierMappingRequest{keycodes_per_modifier, keycodes});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SetModifierMappingReply> detail::ReadReply<
+    SetModifierMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SetModifierMappingReply>();
+
+  auto& status = (*reply).status;
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // status
+  uint8_t tmp125;
+  Read(&tmp125, &buf);
+  status = static_cast<MappingStatus>(tmp125);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<GetModifierMappingReply> XProto::GetModifierMapping(
+    const GetModifierMappingRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 119;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<GetModifierMappingReply>(
+      &buf, "GetModifierMapping", false);
+}
+
+Future<GetModifierMappingReply> XProto::GetModifierMapping() {
+  return XProto::GetModifierMapping(GetModifierMappingRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<GetModifierMappingReply> detail::ReadReply<
+    GetModifierMappingReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<GetModifierMappingReply>();
+
+  auto& keycodes_per_modifier = (*reply).keycodes_per_modifier;
+  auto& sequence = (*reply).sequence;
+  auto& keycodes = (*reply).keycodes;
+  size_t keycodes_len = keycodes.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // keycodes_per_modifier
+  Read(&keycodes_per_modifier, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad0
+  Pad(&buf, 24);
+
+  // keycodes
+  keycodes.resize((keycodes_per_modifier) * (8));
+  for (auto& keycodes_elem : keycodes) {
+    // keycodes_elem
+    Read(&keycodes_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XProto::NoOperation(const NoOperationRequest& request) {
+  if (!connection_->Ready())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = 127;
+  buf.Write(&major_opcode);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "NoOperation", false);
+}
+
+Future<void> XProto::NoOperation() {
+  return XProto::NoOperation(NoOperationRequest{});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xproto.h b/ui/gfx/x/generated_protos/xproto.h
new file mode 100644
index 0000000..fef9551
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xproto.h
@@ -0,0 +1,4408 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XPROTO_H_
+#define UI_GFX_X_GENERATED_PROTOS_XPROTO_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+enum class GraphicsContext : uint32_t {};
+
+enum class ColorMap : uint32_t {};
+
+enum class Bool32 : uint32_t {};
+
+enum class VisualId : uint32_t {};
+
+enum class KeySym : uint32_t {};
+
+enum class KeyCode : uint8_t {};
+
+enum class KeyCode32 : uint32_t {};
+
+enum class Button : uint8_t {};
+
+enum class VisualClass : int {
+  StaticGray = 0,
+  GrayScale = 1,
+  StaticColor = 2,
+  PseudoColor = 3,
+  TrueColor = 4,
+  DirectColor = 5,
+};
+
+enum class EventMask : int {
+  NoEvent = 0,
+  KeyPress = 1 << 0,
+  KeyRelease = 1 << 1,
+  ButtonPress = 1 << 2,
+  ButtonRelease = 1 << 3,
+  EnterWindow = 1 << 4,
+  LeaveWindow = 1 << 5,
+  PointerMotion = 1 << 6,
+  PointerMotionHint = 1 << 7,
+  Button1Motion = 1 << 8,
+  Button2Motion = 1 << 9,
+  Button3Motion = 1 << 10,
+  Button4Motion = 1 << 11,
+  Button5Motion = 1 << 12,
+  ButtonMotion = 1 << 13,
+  KeymapState = 1 << 14,
+  Exposure = 1 << 15,
+  VisibilityChange = 1 << 16,
+  StructureNotify = 1 << 17,
+  ResizeRedirect = 1 << 18,
+  SubstructureNotify = 1 << 19,
+  SubstructureRedirect = 1 << 20,
+  FocusChange = 1 << 21,
+  PropertyChange = 1 << 22,
+  ColorMapChange = 1 << 23,
+  OwnerGrabButton = 1 << 24,
+};
+
+enum class BackingStore : int {
+  NotUseful = 0,
+  WhenMapped = 1,
+  Always = 2,
+};
+
+enum class ImageOrder : int {
+  LSBFirst = 0,
+  MSBFirst = 1,
+};
+
+enum class ModMask : int {
+  Shift = 1 << 0,
+  Lock = 1 << 1,
+  Control = 1 << 2,
+  c_1 = 1 << 3,
+  c_2 = 1 << 4,
+  c_3 = 1 << 5,
+  c_4 = 1 << 6,
+  c_5 = 1 << 7,
+  Any = 1 << 15,
+};
+
+enum class KeyButMask : int {
+  Shift = 1 << 0,
+  Lock = 1 << 1,
+  Control = 1 << 2,
+  Mod1 = 1 << 3,
+  Mod2 = 1 << 4,
+  Mod3 = 1 << 5,
+  Mod4 = 1 << 6,
+  Mod5 = 1 << 7,
+  Button1 = 1 << 8,
+  Button2 = 1 << 9,
+  Button3 = 1 << 10,
+  Button4 = 1 << 11,
+  Button5 = 1 << 12,
+};
+
+enum class Window : uint32_t {
+  None = 0,
+};
+
+enum class ButtonMask : int {
+  c_1 = 1 << 8,
+  c_2 = 1 << 9,
+  c_3 = 1 << 10,
+  c_4 = 1 << 11,
+  c_5 = 1 << 12,
+  Any = 1 << 15,
+};
+
+enum class Motion : int {
+  Normal = 0,
+  Hint = 1,
+};
+
+enum class NotifyDetail : int {
+  Ancestor = 0,
+  Virtual = 1,
+  Inferior = 2,
+  Nonlinear = 3,
+  NonlinearVirtual = 4,
+  Pointer = 5,
+  PointerRoot = 6,
+  None = 7,
+};
+
+enum class NotifyMode : int {
+  Normal = 0,
+  Grab = 1,
+  Ungrab = 2,
+  WhileGrabbed = 3,
+};
+
+enum class Visibility : int {
+  Unobscured = 0,
+  PartiallyObscured = 1,
+  FullyObscured = 2,
+};
+
+enum class Place : int {
+  OnTop = 0,
+  OnBottom = 1,
+};
+
+enum class Property : int {
+  NewValue = 0,
+  Delete = 1,
+};
+
+enum class Time : uint32_t {
+  CurrentTime = 0,
+};
+
+enum class Atom : uint32_t {
+  None = 0,
+  Any = 0,
+  PRIMARY = 1,
+  SECONDARY = 2,
+  ARC = 3,
+  ATOM = 4,
+  BITMAP = 5,
+  CARDINAL = 6,
+  COLORMAP = 7,
+  CURSOR = 8,
+  CUT_BUFFER0 = 9,
+  CUT_BUFFER1 = 10,
+  CUT_BUFFER2 = 11,
+  CUT_BUFFER3 = 12,
+  CUT_BUFFER4 = 13,
+  CUT_BUFFER5 = 14,
+  CUT_BUFFER6 = 15,
+  CUT_BUFFER7 = 16,
+  DRAWABLE = 17,
+  FONT = 18,
+  INTEGER = 19,
+  PIXMAP = 20,
+  POINT = 21,
+  RECTANGLE = 22,
+  RESOURCE_MANAGER = 23,
+  RGB_COLOR_MAP = 24,
+  RGB_BEST_MAP = 25,
+  RGB_BLUE_MAP = 26,
+  RGB_DEFAULT_MAP = 27,
+  RGB_GRAY_MAP = 28,
+  RGB_GREEN_MAP = 29,
+  RGB_RED_MAP = 30,
+  STRING = 31,
+  VISUALID = 32,
+  WINDOW = 33,
+  WM_COMMAND = 34,
+  WM_HINTS = 35,
+  WM_CLIENT_MACHINE = 36,
+  WM_ICON_NAME = 37,
+  WM_ICON_SIZE = 38,
+  WM_NAME = 39,
+  WM_NORMAL_HINTS = 40,
+  WM_SIZE_HINTS = 41,
+  WM_ZOOM_HINTS = 42,
+  MIN_SPACE = 43,
+  NORM_SPACE = 44,
+  MAX_SPACE = 45,
+  END_SPACE = 46,
+  SUPERSCRIPT_X = 47,
+  SUPERSCRIPT_Y = 48,
+  SUBSCRIPT_X = 49,
+  SUBSCRIPT_Y = 50,
+  UNDERLINE_POSITION = 51,
+  UNDERLINE_THICKNESS = 52,
+  STRIKEOUT_ASCENT = 53,
+  STRIKEOUT_DESCENT = 54,
+  ITALIC_ANGLE = 55,
+  X_HEIGHT = 56,
+  QUAD_WIDTH = 57,
+  WEIGHT = 58,
+  POINT_SIZE = 59,
+  RESOLUTION = 60,
+  COPYRIGHT = 61,
+  NOTICE = 62,
+  FONT_NAME = 63,
+  FAMILY_NAME = 64,
+  FULL_NAME = 65,
+  CAP_HEIGHT = 66,
+  WM_CLASS = 67,
+  WM_TRANSIENT_FOR = 68,
+  kLastPredefinedAtom = 68,
+};
+
+enum class ColormapState : int {
+  Uninstalled = 0,
+  Installed = 1,
+};
+
+enum class Colormap : int {
+  None = 0,
+};
+
+enum class Mapping : int {
+  Modifier = 0,
+  Keyboard = 1,
+  Pointer = 2,
+};
+
+enum class WindowClass : int {
+  CopyFromParent = 0,
+  InputOutput = 1,
+  InputOnly = 2,
+};
+
+enum class CreateWindowAttribute : int {
+  BackPixmap = 1 << 0,
+  BackPixel = 1 << 1,
+  BorderPixmap = 1 << 2,
+  BorderPixel = 1 << 3,
+  BitGravity = 1 << 4,
+  WinGravity = 1 << 5,
+  BackingStore = 1 << 6,
+  BackingPlanes = 1 << 7,
+  BackingPixel = 1 << 8,
+  OverrideRedirect = 1 << 9,
+  SaveUnder = 1 << 10,
+  EventMask = 1 << 11,
+  DontPropagate = 1 << 12,
+  Colormap = 1 << 13,
+  Cursor = 1 << 14,
+};
+
+enum class BackPixmap : int {
+  None = 0,
+  ParentRelative = 1,
+};
+
+enum class Gravity : int {
+  BitForget = 0,
+  WinUnmap = 0,
+  NorthWest = 1,
+  North = 2,
+  NorthEast = 3,
+  West = 4,
+  Center = 5,
+  East = 6,
+  SouthWest = 7,
+  South = 8,
+  SouthEast = 9,
+  Static = 10,
+};
+
+enum class MapState : int {
+  Unmapped = 0,
+  Unviewable = 1,
+  Viewable = 2,
+};
+
+enum class SetMode : int {
+  Insert = 0,
+  Delete = 1,
+};
+
+enum class ConfigWindow : int {
+  X = 1 << 0,
+  Y = 1 << 1,
+  Width = 1 << 2,
+  Height = 1 << 3,
+  BorderWidth = 1 << 4,
+  Sibling = 1 << 5,
+  StackMode = 1 << 6,
+};
+
+enum class StackMode : int {
+  Above = 0,
+  Below = 1,
+  TopIf = 2,
+  BottomIf = 3,
+  Opposite = 4,
+};
+
+enum class Circulate : int {
+  RaiseLowest = 0,
+  LowerHighest = 1,
+};
+
+enum class PropMode : int {
+  Replace = 0,
+  Prepend = 1,
+  Append = 2,
+};
+
+enum class GetPropertyType : int {
+  Any = 0,
+};
+
+enum class SendEventDest : int {
+  PointerWindow = 0,
+  ItemFocus = 1,
+};
+
+enum class GrabMode : int {
+  Sync = 0,
+  Async = 1,
+};
+
+enum class GrabStatus : int {
+  Success = 0,
+  AlreadyGrabbed = 1,
+  InvalidTime = 2,
+  NotViewable = 3,
+  Frozen = 4,
+};
+
+enum class Cursor : uint32_t {
+  None = 0,
+};
+
+enum class ButtonIndex : int {
+  Any = 0,
+  c_1 = 1,
+  c_2 = 2,
+  c_3 = 3,
+  c_4 = 4,
+  c_5 = 5,
+};
+
+enum class Grab : int {
+  Any = 0,
+};
+
+enum class Allow : int {
+  AsyncPointer = 0,
+  SyncPointer = 1,
+  ReplayPointer = 2,
+  AsyncKeyboard = 3,
+  SyncKeyboard = 4,
+  ReplayKeyboard = 5,
+  AsyncBoth = 6,
+  SyncBoth = 7,
+};
+
+enum class InputFocus : int {
+  None = 0,
+  PointerRoot = 1,
+  Parent = 2,
+  FollowKeyboard = 3,
+};
+
+enum class FontDraw : int {
+  LeftToRight = 0,
+  RightToLeft = 1,
+};
+
+enum class GraphicsContextAttribute : int {
+  Function = 1 << 0,
+  PlaneMask = 1 << 1,
+  Foreground = 1 << 2,
+  Background = 1 << 3,
+  LineWidth = 1 << 4,
+  LineStyle = 1 << 5,
+  CapStyle = 1 << 6,
+  JoinStyle = 1 << 7,
+  FillStyle = 1 << 8,
+  FillRule = 1 << 9,
+  Tile = 1 << 10,
+  Stipple = 1 << 11,
+  TileStippleOriginX = 1 << 12,
+  TileStippleOriginY = 1 << 13,
+  Font = 1 << 14,
+  SubwindowMode = 1 << 15,
+  GraphicsExposures = 1 << 16,
+  ClipOriginX = 1 << 17,
+  ClipOriginY = 1 << 18,
+  ClipMask = 1 << 19,
+  DashOffset = 1 << 20,
+  DashList = 1 << 21,
+  ArcMode = 1 << 22,
+};
+
+enum class Gx : int {
+  clear = 0,
+  c_and = 1,
+  andReverse = 2,
+  copy = 3,
+  andInverted = 4,
+  noop = 5,
+  c_xor = 6,
+  c_or = 7,
+  nor = 8,
+  equiv = 9,
+  invert = 10,
+  orReverse = 11,
+  copyInverted = 12,
+  orInverted = 13,
+  nand = 14,
+  set = 15,
+};
+
+enum class LineStyle : int {
+  Solid = 0,
+  OnOffDash = 1,
+  DoubleDash = 2,
+};
+
+enum class CapStyle : int {
+  NotLast = 0,
+  Butt = 1,
+  Round = 2,
+  Projecting = 3,
+};
+
+enum class JoinStyle : int {
+  Miter = 0,
+  Round = 1,
+  Bevel = 2,
+};
+
+enum class FillStyle : int {
+  Solid = 0,
+  Tiled = 1,
+  Stippled = 2,
+  OpaqueStippled = 3,
+};
+
+enum class FillRule : int {
+  EvenOdd = 0,
+  Winding = 1,
+};
+
+enum class SubwindowMode : int {
+  ClipByChildren = 0,
+  IncludeInferiors = 1,
+};
+
+enum class ArcMode : int {
+  Chord = 0,
+  PieSlice = 1,
+};
+
+enum class ClipOrdering : int {
+  Unsorted = 0,
+  YSorted = 1,
+  YXSorted = 2,
+  YXBanded = 3,
+};
+
+enum class CoordMode : int {
+  Origin = 0,
+  Previous = 1,
+};
+
+enum class PolyShape : int {
+  Complex = 0,
+  Nonconvex = 1,
+  Convex = 2,
+};
+
+enum class ImageFormat : int {
+  XYBitmap = 0,
+  XYPixmap = 1,
+  ZPixmap = 2,
+};
+
+enum class ColormapAlloc : int {
+  None = 0,
+  All = 1,
+};
+
+enum class ColorFlag : int {
+  Red = 1 << 0,
+  Green = 1 << 1,
+  Blue = 1 << 2,
+};
+
+enum class Pixmap : uint32_t {
+  None = 0,
+};
+
+enum class Font : uint32_t {
+  None = 0,
+};
+
+enum class QueryShapeOf : int {
+  LargestCursor = 0,
+  FastestTile = 1,
+  FastestStipple = 2,
+};
+
+enum class Keyboard : int {
+  KeyClickPercent = 1 << 0,
+  BellPercent = 1 << 1,
+  BellPitch = 1 << 2,
+  BellDuration = 1 << 3,
+  Led = 1 << 4,
+  LedMode = 1 << 5,
+  Key = 1 << 6,
+  AutoRepeatMode = 1 << 7,
+};
+
+enum class LedMode : int {
+  Off = 0,
+  On = 1,
+};
+
+enum class AutoRepeatMode : int {
+  Off = 0,
+  On = 1,
+  Default = 2,
+};
+
+enum class Blanking : int {
+  NotPreferred = 0,
+  Preferred = 1,
+  Default = 2,
+};
+
+enum class Exposures : int {
+  NotAllowed = 0,
+  Allowed = 1,
+  Default = 2,
+};
+
+enum class HostMode : int {
+  Insert = 0,
+  Delete = 1,
+};
+
+enum class Family : int {
+  Internet = 0,
+  DECnet = 1,
+  Chaos = 2,
+  ServerInterpreted = 5,
+  Internet6 = 6,
+};
+
+enum class AccessControl : int {
+  Disable = 0,
+  Enable = 1,
+};
+
+enum class CloseDown : int {
+  DestroyAll = 0,
+  RetainPermanent = 1,
+  RetainTemporary = 2,
+};
+
+enum class Kill : int {
+  AllTemporary = 0,
+};
+
+enum class ScreenSaverMode : int {
+  Reset = 0,
+  Active = 1,
+};
+
+enum class MappingStatus : int {
+  Success = 0,
+  Busy = 1,
+  Failure = 2,
+};
+
+enum class MapIndex : int {
+  Shift = 0,
+  Lock = 1,
+  Control = 2,
+  c_1 = 3,
+  c_2 = 4,
+  c_3 = 5,
+  c_4 = 6,
+  c_5 = 7,
+};
+
+struct Drawable {
+  Drawable() : value{} {}
+
+  Drawable(Window value) : value{static_cast<uint32_t>(value)} {}
+  operator Window() const { return static_cast<Window>(value); }
+
+  Drawable(Pixmap value) : value{static_cast<uint32_t>(value)} {}
+  operator Pixmap() const { return static_cast<Pixmap>(value); }
+
+  uint32_t value{};
+};
+
+struct Fontable {
+  Fontable() : value{} {}
+
+  Fontable(Font value) : value{static_cast<uint32_t>(value)} {}
+  operator Font() const { return static_cast<Font>(value); }
+
+  Fontable(GraphicsContext value) : value{static_cast<uint32_t>(value)} {}
+  operator GraphicsContext() const {
+    return static_cast<GraphicsContext>(value);
+  }
+
+  uint32_t value{};
+};
+
+struct Char16 {
+  uint8_t byte1{};
+  uint8_t byte2{};
+};
+
+struct Point {
+  int16_t x{};
+  int16_t y{};
+};
+
+struct Rectangle {
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+};
+
+struct Arc {
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  int16_t angle1{};
+  int16_t angle2{};
+};
+
+struct Format {
+  uint8_t depth{};
+  uint8_t bits_per_pixel{};
+  uint8_t scanline_pad{};
+};
+
+struct VisualType {
+  VisualId visual_id{};
+  VisualClass c_class{};
+  uint8_t bits_per_rgb_value{};
+  uint16_t colormap_entries{};
+  uint32_t red_mask{};
+  uint32_t green_mask{};
+  uint32_t blue_mask{};
+};
+
+struct Depth {
+  uint8_t depth{};
+  std::vector<VisualType> visuals{};
+};
+
+struct Screen {
+  Window root{};
+  ColorMap default_colormap{};
+  uint32_t white_pixel{};
+  uint32_t black_pixel{};
+  EventMask current_input_masks{};
+  uint16_t width_in_pixels{};
+  uint16_t height_in_pixels{};
+  uint16_t width_in_millimeters{};
+  uint16_t height_in_millimeters{};
+  uint16_t min_installed_maps{};
+  uint16_t max_installed_maps{};
+  VisualId root_visual{};
+  BackingStore backing_stores{};
+  uint8_t save_unders{};
+  uint8_t root_depth{};
+  std::vector<Depth> allowed_depths{};
+};
+
+struct SetupRequest {
+  uint8_t byte_order{};
+  uint16_t protocol_major_version{};
+  uint16_t protocol_minor_version{};
+  std::string authorization_protocol_name{};
+  std::string authorization_protocol_data{};
+};
+
+struct SetupFailed {
+  uint8_t status{};
+  uint16_t protocol_major_version{};
+  uint16_t protocol_minor_version{};
+  uint16_t length{};
+  std::string reason{};
+};
+
+struct SetupAuthenticate {
+  uint8_t status{};
+  uint16_t length{};
+  std::string reason{};
+};
+
+struct Setup {
+  uint8_t status{};
+  uint16_t protocol_major_version{};
+  uint16_t protocol_minor_version{};
+  uint16_t length{};
+  uint32_t release_number{};
+  uint32_t resource_id_base{};
+  uint32_t resource_id_mask{};
+  uint32_t motion_buffer_size{};
+  uint16_t maximum_request_length{};
+  ImageOrder image_byte_order{};
+  ImageOrder bitmap_format_bit_order{};
+  uint8_t bitmap_format_scanline_unit{};
+  uint8_t bitmap_format_scanline_pad{};
+  KeyCode min_keycode{};
+  KeyCode max_keycode{};
+  std::string vendor{};
+  std::vector<Format> pixmap_formats{};
+  std::vector<Screen> roots{};
+};
+
+struct KeyEvent {
+  static constexpr int type_id = 52;
+  enum Opcode {
+    Press = 2,
+    Release = 3,
+  } opcode{};
+  bool send_event{};
+  KeyCode detail{};
+  uint16_t sequence{};
+  Time time{};
+  Window root{};
+  Window event{};
+  Window child{};
+  int16_t root_x{};
+  int16_t root_y{};
+  int16_t event_x{};
+  int16_t event_y{};
+  KeyButMask state{};
+  uint8_t same_screen{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct ButtonEvent {
+  static constexpr int type_id = 53;
+  enum Opcode {
+    Press = 4,
+    Release = 5,
+  } opcode{};
+  bool send_event{};
+  Button detail{};
+  uint16_t sequence{};
+  Time time{};
+  Window root{};
+  Window event{};
+  Window child{};
+  int16_t root_x{};
+  int16_t root_y{};
+  int16_t event_x{};
+  int16_t event_y{};
+  KeyButMask state{};
+  uint8_t same_screen{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct MotionNotifyEvent {
+  static constexpr int type_id = 54;
+  static constexpr uint8_t opcode = 6;
+  bool send_event{};
+  Motion detail{};
+  uint16_t sequence{};
+  Time time{};
+  Window root{};
+  Window event{};
+  Window child{};
+  int16_t root_x{};
+  int16_t root_y{};
+  int16_t event_x{};
+  int16_t event_y{};
+  KeyButMask state{};
+  uint8_t same_screen{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct CrossingEvent {
+  static constexpr int type_id = 55;
+  enum Opcode {
+    EnterNotify = 7,
+    LeaveNotify = 8,
+  } opcode{};
+  bool send_event{};
+  NotifyDetail detail{};
+  uint16_t sequence{};
+  Time time{};
+  Window root{};
+  Window event{};
+  Window child{};
+  int16_t root_x{};
+  int16_t root_y{};
+  int16_t event_x{};
+  int16_t event_y{};
+  KeyButMask state{};
+  NotifyMode mode{};
+  uint8_t same_screen_focus{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct FocusEvent {
+  static constexpr int type_id = 56;
+  enum Opcode {
+    In = 9,
+    Out = 10,
+  } opcode{};
+  bool send_event{};
+  NotifyDetail detail{};
+  uint16_t sequence{};
+  Window event{};
+  NotifyMode mode{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct KeymapNotifyEvent {
+  static constexpr int type_id = 57;
+  static constexpr uint8_t opcode = 11;
+  bool send_event{};
+  std::array<uint8_t, 31> keys{};
+
+  x11::Window* GetWindow() { return nullptr; }
+};
+
+struct ExposeEvent {
+  static constexpr int type_id = 58;
+  static constexpr uint8_t opcode = 12;
+  bool send_event{};
+  uint16_t sequence{};
+  Window window{};
+  uint16_t x{};
+  uint16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint16_t count{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+struct GraphicsExposureEvent {
+  static constexpr int type_id = 59;
+  static constexpr uint8_t opcode = 13;
+  bool send_event{};
+  uint16_t sequence{};
+  Drawable drawable{};
+  uint16_t x{};
+  uint16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint16_t minor_opcode{};
+  uint16_t count{};
+  uint8_t major_opcode{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&drawable); }
+};
+
+struct NoExposureEvent {
+  static constexpr int type_id = 60;
+  static constexpr uint8_t opcode = 14;
+  bool send_event{};
+  uint16_t sequence{};
+  Drawable drawable{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&drawable); }
+};
+
+struct VisibilityNotifyEvent {
+  static constexpr int type_id = 61;
+  static constexpr uint8_t opcode = 15;
+  bool send_event{};
+  uint16_t sequence{};
+  Window window{};
+  Visibility state{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+struct CreateNotifyEvent {
+  static constexpr int type_id = 62;
+  static constexpr uint8_t opcode = 16;
+  bool send_event{};
+  uint16_t sequence{};
+  Window parent{};
+  Window window{};
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint16_t border_width{};
+  uint8_t override_redirect{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+struct DestroyNotifyEvent {
+  static constexpr int type_id = 63;
+  static constexpr uint8_t opcode = 17;
+  bool send_event{};
+  uint16_t sequence{};
+  Window event{};
+  Window window{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct UnmapNotifyEvent {
+  static constexpr int type_id = 64;
+  static constexpr uint8_t opcode = 18;
+  bool send_event{};
+  uint16_t sequence{};
+  Window event{};
+  Window window{};
+  uint8_t from_configure{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct MapNotifyEvent {
+  static constexpr int type_id = 65;
+  static constexpr uint8_t opcode = 19;
+  bool send_event{};
+  uint16_t sequence{};
+  Window event{};
+  Window window{};
+  uint8_t override_redirect{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct MapRequestEvent {
+  static constexpr int type_id = 66;
+  static constexpr uint8_t opcode = 20;
+  bool send_event{};
+  uint16_t sequence{};
+  Window parent{};
+  Window window{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+struct ReparentNotifyEvent {
+  static constexpr int type_id = 67;
+  static constexpr uint8_t opcode = 21;
+  bool send_event{};
+  uint16_t sequence{};
+  Window event{};
+  Window window{};
+  Window parent{};
+  int16_t x{};
+  int16_t y{};
+  uint8_t override_redirect{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct ConfigureNotifyEvent {
+  static constexpr int type_id = 68;
+  static constexpr uint8_t opcode = 22;
+  bool send_event{};
+  uint16_t sequence{};
+  Window event{};
+  Window window{};
+  Window above_sibling{};
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint16_t border_width{};
+  uint8_t override_redirect{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct ConfigureRequestEvent {
+  static constexpr int type_id = 69;
+  static constexpr uint8_t opcode = 23;
+  bool send_event{};
+  StackMode stack_mode{};
+  uint16_t sequence{};
+  Window parent{};
+  Window window{};
+  Window sibling{};
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint16_t border_width{};
+  ConfigWindow value_mask{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+struct GravityNotifyEvent {
+  static constexpr int type_id = 70;
+  static constexpr uint8_t opcode = 24;
+  bool send_event{};
+  uint16_t sequence{};
+  Window event{};
+  Window window{};
+  int16_t x{};
+  int16_t y{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct ResizeRequestEvent {
+  static constexpr int type_id = 71;
+  static constexpr uint8_t opcode = 25;
+  bool send_event{};
+  uint16_t sequence{};
+  Window window{};
+  uint16_t width{};
+  uint16_t height{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+struct CirculateEvent {
+  static constexpr int type_id = 72;
+  enum Opcode {
+    Notify = 26,
+    Request = 27,
+  } opcode{};
+  bool send_event{};
+  uint16_t sequence{};
+  Window event{};
+  Window window{};
+  Place place{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&event); }
+};
+
+struct PropertyNotifyEvent {
+  static constexpr int type_id = 73;
+  static constexpr uint8_t opcode = 28;
+  bool send_event{};
+  uint16_t sequence{};
+  Window window{};
+  Atom atom{};
+  Time time{};
+  Property state{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+struct SelectionClearEvent {
+  static constexpr int type_id = 74;
+  static constexpr uint8_t opcode = 29;
+  bool send_event{};
+  uint16_t sequence{};
+  Time time{};
+  Window owner{};
+  Atom selection{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&owner); }
+};
+
+struct SelectionRequestEvent {
+  static constexpr int type_id = 75;
+  static constexpr uint8_t opcode = 30;
+  bool send_event{};
+  uint16_t sequence{};
+  Time time{};
+  Window owner{};
+  Window requestor{};
+  Atom selection{};
+  Atom target{};
+  Atom property{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&owner); }
+};
+
+struct SelectionNotifyEvent {
+  static constexpr int type_id = 76;
+  static constexpr uint8_t opcode = 31;
+  bool send_event{};
+  uint16_t sequence{};
+  Time time{};
+  Window requestor{};
+  Atom selection{};
+  Atom target{};
+  Atom property{};
+
+  x11::Window* GetWindow() {
+    return reinterpret_cast<x11::Window*>(&requestor);
+  }
+};
+
+struct ColormapNotifyEvent {
+  static constexpr int type_id = 77;
+  static constexpr uint8_t opcode = 32;
+  bool send_event{};
+  uint16_t sequence{};
+  Window window{};
+  ColorMap colormap{};
+  uint8_t c_new{};
+  ColormapState state{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+union ClientMessageData {
+  ClientMessageData() { memset(this, 0, sizeof(*this)); }
+
+  std::array<uint8_t, 20> data8;
+  std::array<uint16_t, 10> data16;
+  std::array<uint32_t, 5> data32;
+};
+static_assert(std::is_trivially_copyable<ClientMessageData>::value, "");
+
+struct ClientMessageEvent {
+  static constexpr int type_id = 78;
+  static constexpr uint8_t opcode = 33;
+  bool send_event{};
+  uint8_t format{};
+  uint16_t sequence{};
+  Window window{};
+  Atom type{};
+  ClientMessageData data{};
+
+  x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
+};
+
+struct MappingNotifyEvent {
+  static constexpr int type_id = 79;
+  static constexpr uint8_t opcode = 34;
+  bool send_event{};
+  uint16_t sequence{};
+  Mapping request{};
+  KeyCode first_keycode{};
+  uint8_t count{};
+
+  x11::Window* GetWindow() { return nullptr; }
+};
+
+struct GeGenericEvent {
+  static constexpr int type_id = 80;
+  static constexpr uint8_t opcode = 35;
+  bool send_event{};
+  uint16_t sequence{};
+
+  x11::Window* GetWindow() { return nullptr; }
+};
+
+struct RequestError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct ValueError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct WindowError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct PixmapError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct AtomError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct CursorError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct FontError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct MatchError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct DrawableError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct AccessError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct AllocError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct ColormapError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct GContextError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct IDChoiceError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct NameError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct LengthError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct ImplementationError : public x11::Error {
+  uint16_t sequence{};
+  uint32_t bad_value{};
+  uint16_t minor_opcode{};
+  uint8_t major_opcode{};
+
+  std::string ToString() const override;
+};
+
+struct TimeCoord {
+  Time time{};
+  int16_t x{};
+  int16_t y{};
+};
+
+struct FontProperty {
+  Atom name{};
+  uint32_t value{};
+};
+
+struct CharInfo {
+  int16_t left_side_bearing{};
+  int16_t right_side_bearing{};
+  int16_t character_width{};
+  int16_t ascent{};
+  int16_t descent{};
+  uint16_t attributes{};
+};
+
+struct Str {
+  std::string name{};
+};
+
+struct Segment {
+  int16_t x1{};
+  int16_t y1{};
+  int16_t x2{};
+  int16_t y2{};
+};
+
+struct ColorItem {
+  uint32_t pixel{};
+  uint16_t red{};
+  uint16_t green{};
+  uint16_t blue{};
+  ColorFlag flags{};
+};
+
+struct Rgb {
+  uint16_t red{};
+  uint16_t green{};
+  uint16_t blue{};
+};
+
+struct Host {
+  Family family{};
+  std::vector<uint8_t> address{};
+};
+
+struct CreateWindowRequest {
+  uint8_t depth{};
+  Window wid{};
+  Window parent{};
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint16_t border_width{};
+  WindowClass c_class{};
+  VisualId visual{};
+  absl::optional<Pixmap> background_pixmap{};
+  absl::optional<uint32_t> background_pixel{};
+  absl::optional<Pixmap> border_pixmap{};
+  absl::optional<uint32_t> border_pixel{};
+  absl::optional<Gravity> bit_gravity{};
+  absl::optional<Gravity> win_gravity{};
+  absl::optional<BackingStore> backing_store{};
+  absl::optional<uint32_t> backing_planes{};
+  absl::optional<uint32_t> backing_pixel{};
+  absl::optional<Bool32> override_redirect{};
+  absl::optional<Bool32> save_under{};
+  absl::optional<EventMask> event_mask{};
+  absl::optional<EventMask> do_not_propogate_mask{};
+  absl::optional<ColorMap> colormap{};
+  absl::optional<Cursor> cursor{};
+};
+
+using CreateWindowResponse = Response<void>;
+
+struct ChangeWindowAttributesRequest {
+  Window window{};
+  absl::optional<Pixmap> background_pixmap{};
+  absl::optional<uint32_t> background_pixel{};
+  absl::optional<Pixmap> border_pixmap{};
+  absl::optional<uint32_t> border_pixel{};
+  absl::optional<Gravity> bit_gravity{};
+  absl::optional<Gravity> win_gravity{};
+  absl::optional<BackingStore> backing_store{};
+  absl::optional<uint32_t> backing_planes{};
+  absl::optional<uint32_t> backing_pixel{};
+  absl::optional<Bool32> override_redirect{};
+  absl::optional<Bool32> save_under{};
+  absl::optional<EventMask> event_mask{};
+  absl::optional<EventMask> do_not_propogate_mask{};
+  absl::optional<ColorMap> colormap{};
+  absl::optional<Cursor> cursor{};
+};
+
+using ChangeWindowAttributesResponse = Response<void>;
+
+struct GetWindowAttributesRequest {
+  Window window{};
+};
+
+struct GetWindowAttributesReply {
+  BackingStore backing_store{};
+  uint16_t sequence{};
+  VisualId visual{};
+  WindowClass c_class{};
+  Gravity bit_gravity{};
+  Gravity win_gravity{};
+  uint32_t backing_planes{};
+  uint32_t backing_pixel{};
+  uint8_t save_under{};
+  uint8_t map_is_installed{};
+  MapState map_state{};
+  uint8_t override_redirect{};
+  ColorMap colormap{};
+  EventMask all_event_masks{};
+  EventMask your_event_mask{};
+  EventMask do_not_propagate_mask{};
+};
+
+using GetWindowAttributesResponse = Response<GetWindowAttributesReply>;
+
+struct DestroyWindowRequest {
+  Window window{};
+};
+
+using DestroyWindowResponse = Response<void>;
+
+struct DestroySubwindowsRequest {
+  Window window{};
+};
+
+using DestroySubwindowsResponse = Response<void>;
+
+struct ChangeSaveSetRequest {
+  SetMode mode{};
+  Window window{};
+};
+
+using ChangeSaveSetResponse = Response<void>;
+
+struct ReparentWindowRequest {
+  Window window{};
+  Window parent{};
+  int16_t x{};
+  int16_t y{};
+};
+
+using ReparentWindowResponse = Response<void>;
+
+struct MapWindowRequest {
+  Window window{};
+};
+
+using MapWindowResponse = Response<void>;
+
+struct MapSubwindowsRequest {
+  Window window{};
+};
+
+using MapSubwindowsResponse = Response<void>;
+
+struct UnmapWindowRequest {
+  Window window{};
+};
+
+using UnmapWindowResponse = Response<void>;
+
+struct UnmapSubwindowsRequest {
+  Window window{};
+};
+
+using UnmapSubwindowsResponse = Response<void>;
+
+struct ConfigureWindowRequest {
+  Window window{};
+  absl::optional<int32_t> x{};
+  absl::optional<int32_t> y{};
+  absl::optional<uint32_t> width{};
+  absl::optional<uint32_t> height{};
+  absl::optional<uint32_t> border_width{};
+  absl::optional<Window> sibling{};
+  absl::optional<StackMode> stack_mode{};
+};
+
+using ConfigureWindowResponse = Response<void>;
+
+struct CirculateWindowRequest {
+  Circulate direction{};
+  Window window{};
+};
+
+using CirculateWindowResponse = Response<void>;
+
+struct GetGeometryRequest {
+  Drawable drawable{};
+};
+
+struct GetGeometryReply {
+  uint8_t depth{};
+  uint16_t sequence{};
+  Window root{};
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint16_t border_width{};
+};
+
+using GetGeometryResponse = Response<GetGeometryReply>;
+
+struct QueryTreeRequest {
+  Window window{};
+};
+
+struct QueryTreeReply {
+  uint16_t sequence{};
+  Window root{};
+  Window parent{};
+  std::vector<Window> children{};
+};
+
+using QueryTreeResponse = Response<QueryTreeReply>;
+
+struct InternAtomRequest {
+  uint8_t only_if_exists{};
+  std::string name{};
+};
+
+struct InternAtomReply {
+  uint16_t sequence{};
+  Atom atom{};
+};
+
+using InternAtomResponse = Response<InternAtomReply>;
+
+struct GetAtomNameRequest {
+  Atom atom{};
+};
+
+struct GetAtomNameReply {
+  uint16_t sequence{};
+  std::string name{};
+};
+
+using GetAtomNameResponse = Response<GetAtomNameReply>;
+
+struct ChangePropertyRequest {
+  PropMode mode{};
+  Window window{};
+  Atom property{};
+  Atom type{};
+  uint8_t format{};
+  uint32_t data_len{};
+  scoped_refptr<base::RefCountedMemory> data{};
+};
+
+using ChangePropertyResponse = Response<void>;
+
+struct DeletePropertyRequest {
+  Window window{};
+  Atom property{};
+};
+
+using DeletePropertyResponse = Response<void>;
+
+struct GetPropertyRequest {
+  uint8_t c_delete{};
+  Window window{};
+  Atom property{};
+  Atom type{};
+  uint32_t long_offset{};
+  uint32_t long_length{};
+};
+
+struct GetPropertyReply {
+  uint8_t format{};
+  uint16_t sequence{};
+  Atom type{};
+  uint32_t bytes_after{};
+  uint32_t value_len{};
+  scoped_refptr<base::RefCountedMemory> value{};
+};
+
+using GetPropertyResponse = Response<GetPropertyReply>;
+
+struct ListPropertiesRequest {
+  Window window{};
+};
+
+struct ListPropertiesReply {
+  uint16_t sequence{};
+  std::vector<Atom> atoms{};
+};
+
+using ListPropertiesResponse = Response<ListPropertiesReply>;
+
+struct SetSelectionOwnerRequest {
+  Window owner{};
+  Atom selection{};
+  Time time{};
+};
+
+using SetSelectionOwnerResponse = Response<void>;
+
+struct GetSelectionOwnerRequest {
+  Atom selection{};
+};
+
+struct GetSelectionOwnerReply {
+  uint16_t sequence{};
+  Window owner{};
+};
+
+using GetSelectionOwnerResponse = Response<GetSelectionOwnerReply>;
+
+struct ConvertSelectionRequest {
+  Window requestor{};
+  Atom selection{};
+  Atom target{};
+  Atom property{};
+  Time time{};
+};
+
+using ConvertSelectionResponse = Response<void>;
+
+struct SendEventRequest {
+  uint8_t propagate{};
+  Window destination{};
+  EventMask event_mask{};
+  std::array<char, 32> event{};
+};
+
+using SendEventResponse = Response<void>;
+
+struct GrabPointerRequest {
+  uint8_t owner_events{};
+  Window grab_window{};
+  EventMask event_mask{};
+  GrabMode pointer_mode{};
+  GrabMode keyboard_mode{};
+  Window confine_to{};
+  Cursor cursor{};
+  Time time{};
+};
+
+struct GrabPointerReply {
+  GrabStatus status{};
+  uint16_t sequence{};
+};
+
+using GrabPointerResponse = Response<GrabPointerReply>;
+
+struct UngrabPointerRequest {
+  Time time{};
+};
+
+using UngrabPointerResponse = Response<void>;
+
+struct GrabButtonRequest {
+  uint8_t owner_events{};
+  Window grab_window{};
+  EventMask event_mask{};
+  GrabMode pointer_mode{};
+  GrabMode keyboard_mode{};
+  Window confine_to{};
+  Cursor cursor{};
+  ButtonIndex button{};
+  ModMask modifiers{};
+};
+
+using GrabButtonResponse = Response<void>;
+
+struct UngrabButtonRequest {
+  ButtonIndex button{};
+  Window grab_window{};
+  ModMask modifiers{};
+};
+
+using UngrabButtonResponse = Response<void>;
+
+struct ChangeActivePointerGrabRequest {
+  Cursor cursor{};
+  Time time{};
+  EventMask event_mask{};
+};
+
+using ChangeActivePointerGrabResponse = Response<void>;
+
+struct GrabKeyboardRequest {
+  uint8_t owner_events{};
+  Window grab_window{};
+  Time time{};
+  GrabMode pointer_mode{};
+  GrabMode keyboard_mode{};
+};
+
+struct GrabKeyboardReply {
+  GrabStatus status{};
+  uint16_t sequence{};
+};
+
+using GrabKeyboardResponse = Response<GrabKeyboardReply>;
+
+struct UngrabKeyboardRequest {
+  Time time{};
+};
+
+using UngrabKeyboardResponse = Response<void>;
+
+struct GrabKeyRequest {
+  uint8_t owner_events{};
+  Window grab_window{};
+  ModMask modifiers{};
+  KeyCode key{};
+  GrabMode pointer_mode{};
+  GrabMode keyboard_mode{};
+};
+
+using GrabKeyResponse = Response<void>;
+
+struct UngrabKeyRequest {
+  KeyCode key{};
+  Window grab_window{};
+  ModMask modifiers{};
+};
+
+using UngrabKeyResponse = Response<void>;
+
+struct AllowEventsRequest {
+  Allow mode{};
+  Time time{};
+};
+
+using AllowEventsResponse = Response<void>;
+
+struct GrabServerRequest {};
+
+using GrabServerResponse = Response<void>;
+
+struct UngrabServerRequest {};
+
+using UngrabServerResponse = Response<void>;
+
+struct QueryPointerRequest {
+  Window window{};
+};
+
+struct QueryPointerReply {
+  uint8_t same_screen{};
+  uint16_t sequence{};
+  Window root{};
+  Window child{};
+  int16_t root_x{};
+  int16_t root_y{};
+  int16_t win_x{};
+  int16_t win_y{};
+  KeyButMask mask{};
+};
+
+using QueryPointerResponse = Response<QueryPointerReply>;
+
+struct GetMotionEventsRequest {
+  Window window{};
+  Time start{};
+  Time stop{};
+};
+
+struct GetMotionEventsReply {
+  uint16_t sequence{};
+  std::vector<TimeCoord> events{};
+};
+
+using GetMotionEventsResponse = Response<GetMotionEventsReply>;
+
+struct TranslateCoordinatesRequest {
+  Window src_window{};
+  Window dst_window{};
+  int16_t src_x{};
+  int16_t src_y{};
+};
+
+struct TranslateCoordinatesReply {
+  uint8_t same_screen{};
+  uint16_t sequence{};
+  Window child{};
+  int16_t dst_x{};
+  int16_t dst_y{};
+};
+
+using TranslateCoordinatesResponse = Response<TranslateCoordinatesReply>;
+
+struct WarpPointerRequest {
+  Window src_window{};
+  Window dst_window{};
+  int16_t src_x{};
+  int16_t src_y{};
+  uint16_t src_width{};
+  uint16_t src_height{};
+  int16_t dst_x{};
+  int16_t dst_y{};
+};
+
+using WarpPointerResponse = Response<void>;
+
+struct SetInputFocusRequest {
+  InputFocus revert_to{};
+  Window focus{};
+  Time time{};
+};
+
+using SetInputFocusResponse = Response<void>;
+
+struct GetInputFocusRequest {};
+
+struct GetInputFocusReply {
+  InputFocus revert_to{};
+  uint16_t sequence{};
+  Window focus{};
+};
+
+using GetInputFocusResponse = Response<GetInputFocusReply>;
+
+struct QueryKeymapRequest {};
+
+struct QueryKeymapReply {
+  uint16_t sequence{};
+  std::array<uint8_t, 32> keys{};
+};
+
+using QueryKeymapResponse = Response<QueryKeymapReply>;
+
+struct OpenFontRequest {
+  Font fid{};
+  std::string name{};
+};
+
+using OpenFontResponse = Response<void>;
+
+struct CloseFontRequest {
+  Font font{};
+};
+
+using CloseFontResponse = Response<void>;
+
+struct QueryFontRequest {
+  Fontable font{};
+};
+
+struct QueryFontReply {
+  uint16_t sequence{};
+  CharInfo min_bounds{};
+  CharInfo max_bounds{};
+  uint16_t min_char_or_byte2{};
+  uint16_t max_char_or_byte2{};
+  uint16_t default_char{};
+  FontDraw draw_direction{};
+  uint8_t min_byte1{};
+  uint8_t max_byte1{};
+  uint8_t all_chars_exist{};
+  int16_t font_ascent{};
+  int16_t font_descent{};
+  std::vector<FontProperty> properties{};
+  std::vector<CharInfo> char_infos{};
+};
+
+using QueryFontResponse = Response<QueryFontReply>;
+
+struct QueryTextExtentsRequest {
+  Fontable font{};
+  std::vector<Char16> string{};
+};
+
+struct QueryTextExtentsReply {
+  FontDraw draw_direction{};
+  uint16_t sequence{};
+  int16_t font_ascent{};
+  int16_t font_descent{};
+  int16_t overall_ascent{};
+  int16_t overall_descent{};
+  int32_t overall_width{};
+  int32_t overall_left{};
+  int32_t overall_right{};
+};
+
+using QueryTextExtentsResponse = Response<QueryTextExtentsReply>;
+
+struct ListFontsRequest {
+  uint16_t max_names{};
+  std::string pattern{};
+};
+
+struct ListFontsReply {
+  uint16_t sequence{};
+  std::vector<Str> names{};
+};
+
+using ListFontsResponse = Response<ListFontsReply>;
+
+struct ListFontsWithInfoRequest {
+  uint16_t max_names{};
+  std::string pattern{};
+};
+
+struct ListFontsWithInfoReply {
+  uint16_t sequence{};
+  CharInfo min_bounds{};
+  CharInfo max_bounds{};
+  uint16_t min_char_or_byte2{};
+  uint16_t max_char_or_byte2{};
+  uint16_t default_char{};
+  FontDraw draw_direction{};
+  uint8_t min_byte1{};
+  uint8_t max_byte1{};
+  uint8_t all_chars_exist{};
+  int16_t font_ascent{};
+  int16_t font_descent{};
+  uint32_t replies_hint{};
+  std::vector<FontProperty> properties{};
+  std::string name{};
+};
+
+using ListFontsWithInfoResponse = Response<ListFontsWithInfoReply>;
+
+struct SetFontPathRequest {
+  std::vector<Str> font{};
+};
+
+using SetFontPathResponse = Response<void>;
+
+struct GetFontPathRequest {};
+
+struct GetFontPathReply {
+  uint16_t sequence{};
+  std::vector<Str> path{};
+};
+
+using GetFontPathResponse = Response<GetFontPathReply>;
+
+struct CreatePixmapRequest {
+  uint8_t depth{};
+  Pixmap pid{};
+  Drawable drawable{};
+  uint16_t width{};
+  uint16_t height{};
+};
+
+using CreatePixmapResponse = Response<void>;
+
+struct FreePixmapRequest {
+  Pixmap pixmap{};
+};
+
+using FreePixmapResponse = Response<void>;
+
+struct CreateGCRequest {
+  GraphicsContext cid{};
+  Drawable drawable{};
+  absl::optional<Gx> function{};
+  absl::optional<uint32_t> plane_mask{};
+  absl::optional<uint32_t> foreground{};
+  absl::optional<uint32_t> background{};
+  absl::optional<uint32_t> line_width{};
+  absl::optional<LineStyle> line_style{};
+  absl::optional<CapStyle> cap_style{};
+  absl::optional<JoinStyle> join_style{};
+  absl::optional<FillStyle> fill_style{};
+  absl::optional<FillRule> fill_rule{};
+  absl::optional<Pixmap> tile{};
+  absl::optional<Pixmap> stipple{};
+  absl::optional<int32_t> tile_stipple_x_origin{};
+  absl::optional<int32_t> tile_stipple_y_origin{};
+  absl::optional<Font> font{};
+  absl::optional<SubwindowMode> subwindow_mode{};
+  absl::optional<Bool32> graphics_exposures{};
+  absl::optional<int32_t> clip_x_origin{};
+  absl::optional<int32_t> clip_y_origin{};
+  absl::optional<Pixmap> clip_mask{};
+  absl::optional<uint32_t> dash_offset{};
+  absl::optional<uint32_t> dashes{};
+  absl::optional<ArcMode> arc_mode{};
+};
+
+using CreateGCResponse = Response<void>;
+
+struct ChangeGCRequest {
+  GraphicsContext gc{};
+  absl::optional<Gx> function{};
+  absl::optional<uint32_t> plane_mask{};
+  absl::optional<uint32_t> foreground{};
+  absl::optional<uint32_t> background{};
+  absl::optional<uint32_t> line_width{};
+  absl::optional<LineStyle> line_style{};
+  absl::optional<CapStyle> cap_style{};
+  absl::optional<JoinStyle> join_style{};
+  absl::optional<FillStyle> fill_style{};
+  absl::optional<FillRule> fill_rule{};
+  absl::optional<Pixmap> tile{};
+  absl::optional<Pixmap> stipple{};
+  absl::optional<int32_t> tile_stipple_x_origin{};
+  absl::optional<int32_t> tile_stipple_y_origin{};
+  absl::optional<Font> font{};
+  absl::optional<SubwindowMode> subwindow_mode{};
+  absl::optional<Bool32> graphics_exposures{};
+  absl::optional<int32_t> clip_x_origin{};
+  absl::optional<int32_t> clip_y_origin{};
+  absl::optional<Pixmap> clip_mask{};
+  absl::optional<uint32_t> dash_offset{};
+  absl::optional<uint32_t> dashes{};
+  absl::optional<ArcMode> arc_mode{};
+};
+
+using ChangeGCResponse = Response<void>;
+
+struct CopyGCRequest {
+  GraphicsContext src_gc{};
+  GraphicsContext dst_gc{};
+  GraphicsContextAttribute value_mask{};
+};
+
+using CopyGCResponse = Response<void>;
+
+struct SetDashesRequest {
+  GraphicsContext gc{};
+  uint16_t dash_offset{};
+  std::vector<uint8_t> dashes{};
+};
+
+using SetDashesResponse = Response<void>;
+
+struct SetClipRectanglesRequest {
+  ClipOrdering ordering{};
+  GraphicsContext gc{};
+  int16_t clip_x_origin{};
+  int16_t clip_y_origin{};
+  std::vector<Rectangle> rectangles{};
+};
+
+using SetClipRectanglesResponse = Response<void>;
+
+struct FreeGCRequest {
+  GraphicsContext gc{};
+};
+
+using FreeGCResponse = Response<void>;
+
+struct ClearAreaRequest {
+  uint8_t exposures{};
+  Window window{};
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+};
+
+using ClearAreaResponse = Response<void>;
+
+struct CopyAreaRequest {
+  Drawable src_drawable{};
+  Drawable dst_drawable{};
+  GraphicsContext gc{};
+  int16_t src_x{};
+  int16_t src_y{};
+  int16_t dst_x{};
+  int16_t dst_y{};
+  uint16_t width{};
+  uint16_t height{};
+};
+
+using CopyAreaResponse = Response<void>;
+
+struct CopyPlaneRequest {
+  Drawable src_drawable{};
+  Drawable dst_drawable{};
+  GraphicsContext gc{};
+  int16_t src_x{};
+  int16_t src_y{};
+  int16_t dst_x{};
+  int16_t dst_y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint32_t bit_plane{};
+};
+
+using CopyPlaneResponse = Response<void>;
+
+struct PolyPointRequest {
+  CoordMode coordinate_mode{};
+  Drawable drawable{};
+  GraphicsContext gc{};
+  std::vector<Point> points{};
+};
+
+using PolyPointResponse = Response<void>;
+
+struct PolyLineRequest {
+  CoordMode coordinate_mode{};
+  Drawable drawable{};
+  GraphicsContext gc{};
+  std::vector<Point> points{};
+};
+
+using PolyLineResponse = Response<void>;
+
+struct PolySegmentRequest {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  std::vector<Segment> segments{};
+};
+
+using PolySegmentResponse = Response<void>;
+
+struct PolyRectangleRequest {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  std::vector<Rectangle> rectangles{};
+};
+
+using PolyRectangleResponse = Response<void>;
+
+struct PolyArcRequest {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  std::vector<Arc> arcs{};
+};
+
+using PolyArcResponse = Response<void>;
+
+struct FillPolyRequest {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  PolyShape shape{};
+  CoordMode coordinate_mode{};
+  std::vector<Point> points{};
+};
+
+using FillPolyResponse = Response<void>;
+
+struct PolyFillRectangleRequest {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  std::vector<Rectangle> rectangles{};
+};
+
+using PolyFillRectangleResponse = Response<void>;
+
+struct PolyFillArcRequest {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  std::vector<Arc> arcs{};
+};
+
+using PolyFillArcResponse = Response<void>;
+
+struct PutImageRequest {
+  ImageFormat format{};
+  Drawable drawable{};
+  GraphicsContext gc{};
+  uint16_t width{};
+  uint16_t height{};
+  int16_t dst_x{};
+  int16_t dst_y{};
+  uint8_t left_pad{};
+  uint8_t depth{};
+  scoped_refptr<base::RefCountedMemory> data{};
+};
+
+using PutImageResponse = Response<void>;
+
+struct GetImageRequest {
+  ImageFormat format{};
+  Drawable drawable{};
+  int16_t x{};
+  int16_t y{};
+  uint16_t width{};
+  uint16_t height{};
+  uint32_t plane_mask{};
+};
+
+struct GetImageReply {
+  uint8_t depth{};
+  uint16_t sequence{};
+  VisualId visual{};
+  scoped_refptr<base::RefCountedMemory> data{};
+};
+
+using GetImageResponse = Response<GetImageReply>;
+
+struct PolyText8Request {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  int16_t x{};
+  int16_t y{};
+  std::vector<uint8_t> items{};
+};
+
+using PolyText8Response = Response<void>;
+
+struct PolyText16Request {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  int16_t x{};
+  int16_t y{};
+  std::vector<uint8_t> items{};
+};
+
+using PolyText16Response = Response<void>;
+
+struct ImageText8Request {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  int16_t x{};
+  int16_t y{};
+  std::string string{};
+};
+
+using ImageText8Response = Response<void>;
+
+struct ImageText16Request {
+  Drawable drawable{};
+  GraphicsContext gc{};
+  int16_t x{};
+  int16_t y{};
+  std::vector<Char16> string{};
+};
+
+using ImageText16Response = Response<void>;
+
+struct CreateColormapRequest {
+  ColormapAlloc alloc{};
+  ColorMap mid{};
+  Window window{};
+  VisualId visual{};
+};
+
+using CreateColormapResponse = Response<void>;
+
+struct FreeColormapRequest {
+  ColorMap cmap{};
+};
+
+using FreeColormapResponse = Response<void>;
+
+struct CopyColormapAndFreeRequest {
+  ColorMap mid{};
+  ColorMap src_cmap{};
+};
+
+using CopyColormapAndFreeResponse = Response<void>;
+
+struct InstallColormapRequest {
+  ColorMap cmap{};
+};
+
+using InstallColormapResponse = Response<void>;
+
+struct UninstallColormapRequest {
+  ColorMap cmap{};
+};
+
+using UninstallColormapResponse = Response<void>;
+
+struct ListInstalledColormapsRequest {
+  Window window{};
+};
+
+struct ListInstalledColormapsReply {
+  uint16_t sequence{};
+  std::vector<ColorMap> cmaps{};
+};
+
+using ListInstalledColormapsResponse = Response<ListInstalledColormapsReply>;
+
+struct AllocColorRequest {
+  ColorMap cmap{};
+  uint16_t red{};
+  uint16_t green{};
+  uint16_t blue{};
+};
+
+struct AllocColorReply {
+  uint16_t sequence{};
+  uint16_t red{};
+  uint16_t green{};
+  uint16_t blue{};
+  uint32_t pixel{};
+};
+
+using AllocColorResponse = Response<AllocColorReply>;
+
+struct AllocNamedColorRequest {
+  ColorMap cmap{};
+  std::string name{};
+};
+
+struct AllocNamedColorReply {
+  uint16_t sequence{};
+  uint32_t pixel{};
+  uint16_t exact_red{};
+  uint16_t exact_green{};
+  uint16_t exact_blue{};
+  uint16_t visual_red{};
+  uint16_t visual_green{};
+  uint16_t visual_blue{};
+};
+
+using AllocNamedColorResponse = Response<AllocNamedColorReply>;
+
+struct AllocColorCellsRequest {
+  uint8_t contiguous{};
+  ColorMap cmap{};
+  uint16_t colors{};
+  uint16_t planes{};
+};
+
+struct AllocColorCellsReply {
+  uint16_t sequence{};
+  std::vector<uint32_t> pixels{};
+  std::vector<uint32_t> masks{};
+};
+
+using AllocColorCellsResponse = Response<AllocColorCellsReply>;
+
+struct AllocColorPlanesRequest {
+  uint8_t contiguous{};
+  ColorMap cmap{};
+  uint16_t colors{};
+  uint16_t reds{};
+  uint16_t greens{};
+  uint16_t blues{};
+};
+
+struct AllocColorPlanesReply {
+  uint16_t sequence{};
+  uint32_t red_mask{};
+  uint32_t green_mask{};
+  uint32_t blue_mask{};
+  std::vector<uint32_t> pixels{};
+};
+
+using AllocColorPlanesResponse = Response<AllocColorPlanesReply>;
+
+struct FreeColorsRequest {
+  ColorMap cmap{};
+  uint32_t plane_mask{};
+  std::vector<uint32_t> pixels{};
+};
+
+using FreeColorsResponse = Response<void>;
+
+struct StoreColorsRequest {
+  ColorMap cmap{};
+  std::vector<ColorItem> items{};
+};
+
+using StoreColorsResponse = Response<void>;
+
+struct StoreNamedColorRequest {
+  ColorFlag flags{};
+  ColorMap cmap{};
+  uint32_t pixel{};
+  std::string name{};
+};
+
+using StoreNamedColorResponse = Response<void>;
+
+struct QueryColorsRequest {
+  ColorMap cmap{};
+  std::vector<uint32_t> pixels{};
+};
+
+struct QueryColorsReply {
+  uint16_t sequence{};
+  std::vector<Rgb> colors{};
+};
+
+using QueryColorsResponse = Response<QueryColorsReply>;
+
+struct LookupColorRequest {
+  ColorMap cmap{};
+  std::string name{};
+};
+
+struct LookupColorReply {
+  uint16_t sequence{};
+  uint16_t exact_red{};
+  uint16_t exact_green{};
+  uint16_t exact_blue{};
+  uint16_t visual_red{};
+  uint16_t visual_green{};
+  uint16_t visual_blue{};
+};
+
+using LookupColorResponse = Response<LookupColorReply>;
+
+struct CreateCursorRequest {
+  Cursor cid{};
+  Pixmap source{};
+  Pixmap mask{};
+  uint16_t fore_red{};
+  uint16_t fore_green{};
+  uint16_t fore_blue{};
+  uint16_t back_red{};
+  uint16_t back_green{};
+  uint16_t back_blue{};
+  uint16_t x{};
+  uint16_t y{};
+};
+
+using CreateCursorResponse = Response<void>;
+
+struct CreateGlyphCursorRequest {
+  Cursor cid{};
+  Font source_font{};
+  Font mask_font{};
+  uint16_t source_char{};
+  uint16_t mask_char{};
+  uint16_t fore_red{};
+  uint16_t fore_green{};
+  uint16_t fore_blue{};
+  uint16_t back_red{};
+  uint16_t back_green{};
+  uint16_t back_blue{};
+};
+
+using CreateGlyphCursorResponse = Response<void>;
+
+struct FreeCursorRequest {
+  Cursor cursor{};
+};
+
+using FreeCursorResponse = Response<void>;
+
+struct RecolorCursorRequest {
+  Cursor cursor{};
+  uint16_t fore_red{};
+  uint16_t fore_green{};
+  uint16_t fore_blue{};
+  uint16_t back_red{};
+  uint16_t back_green{};
+  uint16_t back_blue{};
+};
+
+using RecolorCursorResponse = Response<void>;
+
+struct QueryBestSizeRequest {
+  QueryShapeOf c_class{};
+  Drawable drawable{};
+  uint16_t width{};
+  uint16_t height{};
+};
+
+struct QueryBestSizeReply {
+  uint16_t sequence{};
+  uint16_t width{};
+  uint16_t height{};
+};
+
+using QueryBestSizeResponse = Response<QueryBestSizeReply>;
+
+struct QueryExtensionRequest {
+  std::string name{};
+};
+
+struct QueryExtensionReply {
+  uint16_t sequence{};
+  uint8_t present{};
+  uint8_t major_opcode{};
+  uint8_t first_event{};
+  uint8_t first_error{};
+};
+
+using QueryExtensionResponse = Response<QueryExtensionReply>;
+
+struct ListExtensionsRequest {};
+
+struct ListExtensionsReply {
+  uint16_t sequence{};
+  std::vector<Str> names{};
+};
+
+using ListExtensionsResponse = Response<ListExtensionsReply>;
+
+struct ChangeKeyboardMappingRequest {
+  uint8_t keycode_count{};
+  KeyCode first_keycode{};
+  uint8_t keysyms_per_keycode{};
+  std::vector<KeySym> keysyms{};
+};
+
+using ChangeKeyboardMappingResponse = Response<void>;
+
+struct GetKeyboardMappingRequest {
+  KeyCode first_keycode{};
+  uint8_t count{};
+};
+
+struct GetKeyboardMappingReply {
+  uint8_t keysyms_per_keycode{};
+  uint16_t sequence{};
+  std::vector<KeySym> keysyms{};
+};
+
+using GetKeyboardMappingResponse = Response<GetKeyboardMappingReply>;
+
+struct ChangeKeyboardControlRequest {
+  absl::optional<int32_t> key_click_percent{};
+  absl::optional<int32_t> bell_percent{};
+  absl::optional<int32_t> bell_pitch{};
+  absl::optional<int32_t> bell_duration{};
+  absl::optional<uint32_t> led{};
+  absl::optional<LedMode> led_mode{};
+  absl::optional<KeyCode32> key{};
+  absl::optional<AutoRepeatMode> auto_repeat_mode{};
+};
+
+using ChangeKeyboardControlResponse = Response<void>;
+
+struct GetKeyboardControlRequest {};
+
+struct GetKeyboardControlReply {
+  AutoRepeatMode global_auto_repeat{};
+  uint16_t sequence{};
+  uint32_t led_mask{};
+  uint8_t key_click_percent{};
+  uint8_t bell_percent{};
+  uint16_t bell_pitch{};
+  uint16_t bell_duration{};
+  std::array<uint8_t, 32> auto_repeats{};
+};
+
+using GetKeyboardControlResponse = Response<GetKeyboardControlReply>;
+
+struct BellRequest {
+  int8_t percent{};
+};
+
+using BellResponse = Response<void>;
+
+struct ChangePointerControlRequest {
+  int16_t acceleration_numerator{};
+  int16_t acceleration_denominator{};
+  int16_t threshold{};
+  uint8_t do_acceleration{};
+  uint8_t do_threshold{};
+};
+
+using ChangePointerControlResponse = Response<void>;
+
+struct GetPointerControlRequest {};
+
+struct GetPointerControlReply {
+  uint16_t sequence{};
+  uint16_t acceleration_numerator{};
+  uint16_t acceleration_denominator{};
+  uint16_t threshold{};
+};
+
+using GetPointerControlResponse = Response<GetPointerControlReply>;
+
+struct SetScreenSaverRequest {
+  int16_t timeout{};
+  int16_t interval{};
+  Blanking prefer_blanking{};
+  Exposures allow_exposures{};
+};
+
+using SetScreenSaverResponse = Response<void>;
+
+struct GetScreenSaverRequest {};
+
+struct GetScreenSaverReply {
+  uint16_t sequence{};
+  uint16_t timeout{};
+  uint16_t interval{};
+  Blanking prefer_blanking{};
+  Exposures allow_exposures{};
+};
+
+using GetScreenSaverResponse = Response<GetScreenSaverReply>;
+
+struct ChangeHostsRequest {
+  HostMode mode{};
+  Family family{};
+  std::vector<uint8_t> address{};
+};
+
+using ChangeHostsResponse = Response<void>;
+
+struct ListHostsRequest {};
+
+struct ListHostsReply {
+  AccessControl mode{};
+  uint16_t sequence{};
+  std::vector<Host> hosts{};
+};
+
+using ListHostsResponse = Response<ListHostsReply>;
+
+struct SetAccessControlRequest {
+  AccessControl mode{};
+};
+
+using SetAccessControlResponse = Response<void>;
+
+struct SetCloseDownModeRequest {
+  CloseDown mode{};
+};
+
+using SetCloseDownModeResponse = Response<void>;
+
+struct KillClientRequest {
+  uint32_t resource{};
+};
+
+using KillClientResponse = Response<void>;
+
+struct RotatePropertiesRequest {
+  Window window{};
+  int16_t delta{};
+  std::vector<Atom> atoms{};
+};
+
+using RotatePropertiesResponse = Response<void>;
+
+struct ForceScreenSaverRequest {
+  ScreenSaverMode mode{};
+};
+
+using ForceScreenSaverResponse = Response<void>;
+
+struct SetPointerMappingRequest {
+  std::vector<uint8_t> map{};
+};
+
+struct SetPointerMappingReply {
+  MappingStatus status{};
+  uint16_t sequence{};
+};
+
+using SetPointerMappingResponse = Response<SetPointerMappingReply>;
+
+struct GetPointerMappingRequest {};
+
+struct GetPointerMappingReply {
+  uint16_t sequence{};
+  std::vector<uint8_t> map{};
+};
+
+using GetPointerMappingResponse = Response<GetPointerMappingReply>;
+
+struct SetModifierMappingRequest {
+  uint8_t keycodes_per_modifier{};
+  std::vector<KeyCode> keycodes{};
+};
+
+struct SetModifierMappingReply {
+  MappingStatus status{};
+  uint16_t sequence{};
+};
+
+using SetModifierMappingResponse = Response<SetModifierMappingReply>;
+
+struct GetModifierMappingRequest {};
+
+struct GetModifierMappingReply {
+  uint8_t keycodes_per_modifier{};
+  uint16_t sequence{};
+  std::vector<KeyCode> keycodes{};
+};
+
+using GetModifierMappingResponse = Response<GetModifierMappingReply>;
+
+struct NoOperationRequest {};
+
+using NoOperationResponse = Response<void>;
+
+class COMPONENT_EXPORT(X11) XProto {
+ public:
+  explicit XProto(Connection* connection);
+
+  Connection* connection() const { return connection_; }
+
+  Future<void> CreateWindow(const CreateWindowRequest& request);
+
+  Future<void> CreateWindow(
+      const uint8_t& depth = {},
+      const Window& wid = {},
+      const Window& parent = {},
+      const int16_t& x = {},
+      const int16_t& y = {},
+      const uint16_t& width = {},
+      const uint16_t& height = {},
+      const uint16_t& border_width = {},
+      const WindowClass& c_class = {},
+      const VisualId& visual = {},
+      const absl::optional<Pixmap>& background_pixmap = absl::nullopt,
+      const absl::optional<uint32_t>& background_pixel = absl::nullopt,
+      const absl::optional<Pixmap>& border_pixmap = absl::nullopt,
+      const absl::optional<uint32_t>& border_pixel = absl::nullopt,
+      const absl::optional<Gravity>& bit_gravity = absl::nullopt,
+      const absl::optional<Gravity>& win_gravity = absl::nullopt,
+      const absl::optional<BackingStore>& backing_store = absl::nullopt,
+      const absl::optional<uint32_t>& backing_planes = absl::nullopt,
+      const absl::optional<uint32_t>& backing_pixel = absl::nullopt,
+      const absl::optional<Bool32>& override_redirect = absl::nullopt,
+      const absl::optional<Bool32>& save_under = absl::nullopt,
+      const absl::optional<EventMask>& event_mask = absl::nullopt,
+      const absl::optional<EventMask>& do_not_propogate_mask = absl::nullopt,
+      const absl::optional<ColorMap>& colormap = absl::nullopt,
+      const absl::optional<Cursor>& cursor = absl::nullopt);
+
+  Future<void> ChangeWindowAttributes(
+      const ChangeWindowAttributesRequest& request);
+
+  Future<void> ChangeWindowAttributes(
+      const Window& window = {},
+      const absl::optional<Pixmap>& background_pixmap = absl::nullopt,
+      const absl::optional<uint32_t>& background_pixel = absl::nullopt,
+      const absl::optional<Pixmap>& border_pixmap = absl::nullopt,
+      const absl::optional<uint32_t>& border_pixel = absl::nullopt,
+      const absl::optional<Gravity>& bit_gravity = absl::nullopt,
+      const absl::optional<Gravity>& win_gravity = absl::nullopt,
+      const absl::optional<BackingStore>& backing_store = absl::nullopt,
+      const absl::optional<uint32_t>& backing_planes = absl::nullopt,
+      const absl::optional<uint32_t>& backing_pixel = absl::nullopt,
+      const absl::optional<Bool32>& override_redirect = absl::nullopt,
+      const absl::optional<Bool32>& save_under = absl::nullopt,
+      const absl::optional<EventMask>& event_mask = absl::nullopt,
+      const absl::optional<EventMask>& do_not_propogate_mask = absl::nullopt,
+      const absl::optional<ColorMap>& colormap = absl::nullopt,
+      const absl::optional<Cursor>& cursor = absl::nullopt);
+
+  Future<GetWindowAttributesReply> GetWindowAttributes(
+      const GetWindowAttributesRequest& request);
+
+  Future<GetWindowAttributesReply> GetWindowAttributes(
+      const Window& window = {});
+
+  Future<void> DestroyWindow(const DestroyWindowRequest& request);
+
+  Future<void> DestroyWindow(const Window& window = {});
+
+  Future<void> DestroySubwindows(const DestroySubwindowsRequest& request);
+
+  Future<void> DestroySubwindows(const Window& window = {});
+
+  Future<void> ChangeSaveSet(const ChangeSaveSetRequest& request);
+
+  Future<void> ChangeSaveSet(const SetMode& mode = {},
+                             const Window& window = {});
+
+  Future<void> ReparentWindow(const ReparentWindowRequest& request);
+
+  Future<void> ReparentWindow(const Window& window = {},
+                              const Window& parent = {},
+                              const int16_t& x = {},
+                              const int16_t& y = {});
+
+  Future<void> MapWindow(const MapWindowRequest& request);
+
+  Future<void> MapWindow(const Window& window = {});
+
+  Future<void> MapSubwindows(const MapSubwindowsRequest& request);
+
+  Future<void> MapSubwindows(const Window& window = {});
+
+  Future<void> UnmapWindow(const UnmapWindowRequest& request);
+
+  Future<void> UnmapWindow(const Window& window = {});
+
+  Future<void> UnmapSubwindows(const UnmapSubwindowsRequest& request);
+
+  Future<void> UnmapSubwindows(const Window& window = {});
+
+  Future<void> ConfigureWindow(const ConfigureWindowRequest& request);
+
+  Future<void> ConfigureWindow(
+      const Window& window = {},
+      const absl::optional<int32_t>& x = absl::nullopt,
+      const absl::optional<int32_t>& y = absl::nullopt,
+      const absl::optional<uint32_t>& width = absl::nullopt,
+      const absl::optional<uint32_t>& height = absl::nullopt,
+      const absl::optional<uint32_t>& border_width = absl::nullopt,
+      const absl::optional<Window>& sibling = absl::nullopt,
+      const absl::optional<StackMode>& stack_mode = absl::nullopt);
+
+  Future<void> CirculateWindow(const CirculateWindowRequest& request);
+
+  Future<void> CirculateWindow(const Circulate& direction = {},
+                               const Window& window = {});
+
+  Future<GetGeometryReply> GetGeometry(const GetGeometryRequest& request);
+
+  Future<GetGeometryReply> GetGeometry(const Drawable& drawable = {});
+
+  Future<QueryTreeReply> QueryTree(const QueryTreeRequest& request);
+
+  Future<QueryTreeReply> QueryTree(const Window& window = {});
+
+  Future<InternAtomReply> InternAtom(const InternAtomRequest& request);
+
+  Future<InternAtomReply> InternAtom(const uint8_t& only_if_exists = {},
+                                     const std::string& name = {});
+
+  Future<GetAtomNameReply> GetAtomName(const GetAtomNameRequest& request);
+
+  Future<GetAtomNameReply> GetAtomName(const Atom& atom = {});
+
+  Future<void> ChangeProperty(const ChangePropertyRequest& request);
+
+  Future<void> ChangeProperty(
+      const PropMode& mode = {},
+      const Window& window = {},
+      const Atom& property = {},
+      const Atom& type = {},
+      const uint8_t& format = {},
+      const uint32_t& data_len = {},
+      const scoped_refptr<base::RefCountedMemory>& data = {});
+
+  Future<void> DeleteProperty(const DeletePropertyRequest& request);
+
+  Future<void> DeleteProperty(const Window& window = {},
+                              const Atom& property = {});
+
+  Future<GetPropertyReply> GetProperty(const GetPropertyRequest& request);
+
+  Future<GetPropertyReply> GetProperty(const uint8_t& c_delete = {},
+                                       const Window& window = {},
+                                       const Atom& property = {},
+                                       const Atom& type = {},
+                                       const uint32_t& long_offset = {},
+                                       const uint32_t& long_length = {});
+
+  Future<ListPropertiesReply> ListProperties(
+      const ListPropertiesRequest& request);
+
+  Future<ListPropertiesReply> ListProperties(const Window& window = {});
+
+  Future<void> SetSelectionOwner(const SetSelectionOwnerRequest& request);
+
+  Future<void> SetSelectionOwner(const Window& owner = {},
+                                 const Atom& selection = {},
+                                 const Time& time = {});
+
+  Future<GetSelectionOwnerReply> GetSelectionOwner(
+      const GetSelectionOwnerRequest& request);
+
+  Future<GetSelectionOwnerReply> GetSelectionOwner(const Atom& selection = {});
+
+  Future<void> ConvertSelection(const ConvertSelectionRequest& request);
+
+  Future<void> ConvertSelection(const Window& requestor = {},
+                                const Atom& selection = {},
+                                const Atom& target = {},
+                                const Atom& property = {},
+                                const Time& time = {});
+
+  Future<void> SendEvent(const SendEventRequest& request);
+
+  Future<void> SendEvent(const uint8_t& propagate = {},
+                         const Window& destination = {},
+                         const EventMask& event_mask = {},
+                         const std::array<char, 32>& event = {});
+
+  Future<GrabPointerReply> GrabPointer(const GrabPointerRequest& request);
+
+  Future<GrabPointerReply> GrabPointer(const uint8_t& owner_events = {},
+                                       const Window& grab_window = {},
+                                       const EventMask& event_mask = {},
+                                       const GrabMode& pointer_mode = {},
+                                       const GrabMode& keyboard_mode = {},
+                                       const Window& confine_to = {},
+                                       const Cursor& cursor = {},
+                                       const Time& time = {});
+
+  Future<void> UngrabPointer(const UngrabPointerRequest& request);
+
+  Future<void> UngrabPointer(const Time& time = {});
+
+  Future<void> GrabButton(const GrabButtonRequest& request);
+
+  Future<void> GrabButton(const uint8_t& owner_events = {},
+                          const Window& grab_window = {},
+                          const EventMask& event_mask = {},
+                          const GrabMode& pointer_mode = {},
+                          const GrabMode& keyboard_mode = {},
+                          const Window& confine_to = {},
+                          const Cursor& cursor = {},
+                          const ButtonIndex& button = {},
+                          const ModMask& modifiers = {});
+
+  Future<void> UngrabButton(const UngrabButtonRequest& request);
+
+  Future<void> UngrabButton(const ButtonIndex& button = {},
+                            const Window& grab_window = {},
+                            const ModMask& modifiers = {});
+
+  Future<void> ChangeActivePointerGrab(
+      const ChangeActivePointerGrabRequest& request);
+
+  Future<void> ChangeActivePointerGrab(const Cursor& cursor = {},
+                                       const Time& time = {},
+                                       const EventMask& event_mask = {});
+
+  Future<GrabKeyboardReply> GrabKeyboard(const GrabKeyboardRequest& request);
+
+  Future<GrabKeyboardReply> GrabKeyboard(const uint8_t& owner_events = {},
+                                         const Window& grab_window = {},
+                                         const Time& time = {},
+                                         const GrabMode& pointer_mode = {},
+                                         const GrabMode& keyboard_mode = {});
+
+  Future<void> UngrabKeyboard(const UngrabKeyboardRequest& request);
+
+  Future<void> UngrabKeyboard(const Time& time = {});
+
+  Future<void> GrabKey(const GrabKeyRequest& request);
+
+  Future<void> GrabKey(const uint8_t& owner_events = {},
+                       const Window& grab_window = {},
+                       const ModMask& modifiers = {},
+                       const KeyCode& key = {},
+                       const GrabMode& pointer_mode = {},
+                       const GrabMode& keyboard_mode = {});
+
+  Future<void> UngrabKey(const UngrabKeyRequest& request);
+
+  Future<void> UngrabKey(const KeyCode& key = {},
+                         const Window& grab_window = {},
+                         const ModMask& modifiers = {});
+
+  Future<void> AllowEvents(const AllowEventsRequest& request);
+
+  Future<void> AllowEvents(const Allow& mode = {}, const Time& time = {});
+
+  Future<void> GrabServer(const GrabServerRequest& request);
+
+  Future<void> GrabServer();
+
+  Future<void> UngrabServer(const UngrabServerRequest& request);
+
+  Future<void> UngrabServer();
+
+  Future<QueryPointerReply> QueryPointer(const QueryPointerRequest& request);
+
+  Future<QueryPointerReply> QueryPointer(const Window& window = {});
+
+  Future<GetMotionEventsReply> GetMotionEvents(
+      const GetMotionEventsRequest& request);
+
+  Future<GetMotionEventsReply> GetMotionEvents(const Window& window = {},
+                                               const Time& start = {},
+                                               const Time& stop = {});
+
+  Future<TranslateCoordinatesReply> TranslateCoordinates(
+      const TranslateCoordinatesRequest& request);
+
+  Future<TranslateCoordinatesReply> TranslateCoordinates(
+      const Window& src_window = {},
+      const Window& dst_window = {},
+      const int16_t& src_x = {},
+      const int16_t& src_y = {});
+
+  Future<void> WarpPointer(const WarpPointerRequest& request);
+
+  Future<void> WarpPointer(const Window& src_window = {},
+                           const Window& dst_window = {},
+                           const int16_t& src_x = {},
+                           const int16_t& src_y = {},
+                           const uint16_t& src_width = {},
+                           const uint16_t& src_height = {},
+                           const int16_t& dst_x = {},
+                           const int16_t& dst_y = {});
+
+  Future<void> SetInputFocus(const SetInputFocusRequest& request);
+
+  Future<void> SetInputFocus(const InputFocus& revert_to = {},
+                             const Window& focus = {},
+                             const Time& time = {});
+
+  Future<GetInputFocusReply> GetInputFocus(const GetInputFocusRequest& request);
+
+  Future<GetInputFocusReply> GetInputFocus();
+
+  Future<QueryKeymapReply> QueryKeymap(const QueryKeymapRequest& request);
+
+  Future<QueryKeymapReply> QueryKeymap();
+
+  Future<void> OpenFont(const OpenFontRequest& request);
+
+  Future<void> OpenFont(const Font& fid = {}, const std::string& name = {});
+
+  Future<void> CloseFont(const CloseFontRequest& request);
+
+  Future<void> CloseFont(const Font& font = {});
+
+  Future<QueryFontReply> QueryFont(const QueryFontRequest& request);
+
+  Future<QueryFontReply> QueryFont(const Fontable& font = {});
+
+  Future<QueryTextExtentsReply> QueryTextExtents(
+      const QueryTextExtentsRequest& request);
+
+  Future<QueryTextExtentsReply> QueryTextExtents(
+      const Fontable& font = {},
+      const std::vector<Char16>& string = {});
+
+  Future<ListFontsReply> ListFonts(const ListFontsRequest& request);
+
+  Future<ListFontsReply> ListFonts(const uint16_t& max_names = {},
+                                   const std::string& pattern = {});
+
+  Future<ListFontsWithInfoReply> ListFontsWithInfo(
+      const ListFontsWithInfoRequest& request);
+
+  Future<ListFontsWithInfoReply> ListFontsWithInfo(
+      const uint16_t& max_names = {},
+      const std::string& pattern = {});
+
+  Future<void> SetFontPath(const SetFontPathRequest& request);
+
+  Future<void> SetFontPath(const std::vector<Str>& font = {});
+
+  Future<GetFontPathReply> GetFontPath(const GetFontPathRequest& request);
+
+  Future<GetFontPathReply> GetFontPath();
+
+  Future<void> CreatePixmap(const CreatePixmapRequest& request);
+
+  Future<void> CreatePixmap(const uint8_t& depth = {},
+                            const Pixmap& pid = {},
+                            const Drawable& drawable = {},
+                            const uint16_t& width = {},
+                            const uint16_t& height = {});
+
+  Future<void> FreePixmap(const FreePixmapRequest& request);
+
+  Future<void> FreePixmap(const Pixmap& pixmap = {});
+
+  Future<void> CreateGC(const CreateGCRequest& request);
+
+  Future<void> CreateGC(
+      const GraphicsContext& cid = {},
+      const Drawable& drawable = {},
+      const absl::optional<Gx>& function = absl::nullopt,
+      const absl::optional<uint32_t>& plane_mask = absl::nullopt,
+      const absl::optional<uint32_t>& foreground = absl::nullopt,
+      const absl::optional<uint32_t>& background = absl::nullopt,
+      const absl::optional<uint32_t>& line_width = absl::nullopt,
+      const absl::optional<LineStyle>& line_style = absl::nullopt,
+      const absl::optional<CapStyle>& cap_style = absl::nullopt,
+      const absl::optional<JoinStyle>& join_style = absl::nullopt,
+      const absl::optional<FillStyle>& fill_style = absl::nullopt,
+      const absl::optional<FillRule>& fill_rule = absl::nullopt,
+      const absl::optional<Pixmap>& tile = absl::nullopt,
+      const absl::optional<Pixmap>& stipple = absl::nullopt,
+      const absl::optional<int32_t>& tile_stipple_x_origin = absl::nullopt,
+      const absl::optional<int32_t>& tile_stipple_y_origin = absl::nullopt,
+      const absl::optional<Font>& font = absl::nullopt,
+      const absl::optional<SubwindowMode>& subwindow_mode = absl::nullopt,
+      const absl::optional<Bool32>& graphics_exposures = absl::nullopt,
+      const absl::optional<int32_t>& clip_x_origin = absl::nullopt,
+      const absl::optional<int32_t>& clip_y_origin = absl::nullopt,
+      const absl::optional<Pixmap>& clip_mask = absl::nullopt,
+      const absl::optional<uint32_t>& dash_offset = absl::nullopt,
+      const absl::optional<uint32_t>& dashes = absl::nullopt,
+      const absl::optional<ArcMode>& arc_mode = absl::nullopt);
+
+  Future<void> ChangeGC(const ChangeGCRequest& request);
+
+  Future<void> ChangeGC(
+      const GraphicsContext& gc = {},
+      const absl::optional<Gx>& function = absl::nullopt,
+      const absl::optional<uint32_t>& plane_mask = absl::nullopt,
+      const absl::optional<uint32_t>& foreground = absl::nullopt,
+      const absl::optional<uint32_t>& background = absl::nullopt,
+      const absl::optional<uint32_t>& line_width = absl::nullopt,
+      const absl::optional<LineStyle>& line_style = absl::nullopt,
+      const absl::optional<CapStyle>& cap_style = absl::nullopt,
+      const absl::optional<JoinStyle>& join_style = absl::nullopt,
+      const absl::optional<FillStyle>& fill_style = absl::nullopt,
+      const absl::optional<FillRule>& fill_rule = absl::nullopt,
+      const absl::optional<Pixmap>& tile = absl::nullopt,
+      const absl::optional<Pixmap>& stipple = absl::nullopt,
+      const absl::optional<int32_t>& tile_stipple_x_origin = absl::nullopt,
+      const absl::optional<int32_t>& tile_stipple_y_origin = absl::nullopt,
+      const absl::optional<Font>& font = absl::nullopt,
+      const absl::optional<SubwindowMode>& subwindow_mode = absl::nullopt,
+      const absl::optional<Bool32>& graphics_exposures = absl::nullopt,
+      const absl::optional<int32_t>& clip_x_origin = absl::nullopt,
+      const absl::optional<int32_t>& clip_y_origin = absl::nullopt,
+      const absl::optional<Pixmap>& clip_mask = absl::nullopt,
+      const absl::optional<uint32_t>& dash_offset = absl::nullopt,
+      const absl::optional<uint32_t>& dashes = absl::nullopt,
+      const absl::optional<ArcMode>& arc_mode = absl::nullopt);
+
+  Future<void> CopyGC(const CopyGCRequest& request);
+
+  Future<void> CopyGC(const GraphicsContext& src_gc = {},
+                      const GraphicsContext& dst_gc = {},
+                      const GraphicsContextAttribute& value_mask = {});
+
+  Future<void> SetDashes(const SetDashesRequest& request);
+
+  Future<void> SetDashes(const GraphicsContext& gc = {},
+                         const uint16_t& dash_offset = {},
+                         const std::vector<uint8_t>& dashes = {});
+
+  Future<void> SetClipRectangles(const SetClipRectanglesRequest& request);
+
+  Future<void> SetClipRectangles(const ClipOrdering& ordering = {},
+                                 const GraphicsContext& gc = {},
+                                 const int16_t& clip_x_origin = {},
+                                 const int16_t& clip_y_origin = {},
+                                 const std::vector<Rectangle>& rectangles = {});
+
+  Future<void> FreeGC(const FreeGCRequest& request);
+
+  Future<void> FreeGC(const GraphicsContext& gc = {});
+
+  Future<void> ClearArea(const ClearAreaRequest& request);
+
+  Future<void> ClearArea(const uint8_t& exposures = {},
+                         const Window& window = {},
+                         const int16_t& x = {},
+                         const int16_t& y = {},
+                         const uint16_t& width = {},
+                         const uint16_t& height = {});
+
+  Future<void> CopyArea(const CopyAreaRequest& request);
+
+  Future<void> CopyArea(const Drawable& src_drawable = {},
+                        const Drawable& dst_drawable = {},
+                        const GraphicsContext& gc = {},
+                        const int16_t& src_x = {},
+                        const int16_t& src_y = {},
+                        const int16_t& dst_x = {},
+                        const int16_t& dst_y = {},
+                        const uint16_t& width = {},
+                        const uint16_t& height = {});
+
+  Future<void> CopyPlane(const CopyPlaneRequest& request);
+
+  Future<void> CopyPlane(const Drawable& src_drawable = {},
+                         const Drawable& dst_drawable = {},
+                         const GraphicsContext& gc = {},
+                         const int16_t& src_x = {},
+                         const int16_t& src_y = {},
+                         const int16_t& dst_x = {},
+                         const int16_t& dst_y = {},
+                         const uint16_t& width = {},
+                         const uint16_t& height = {},
+                         const uint32_t& bit_plane = {});
+
+  Future<void> PolyPoint(const PolyPointRequest& request);
+
+  Future<void> PolyPoint(const CoordMode& coordinate_mode = {},
+                         const Drawable& drawable = {},
+                         const GraphicsContext& gc = {},
+                         const std::vector<Point>& points = {});
+
+  Future<void> PolyLine(const PolyLineRequest& request);
+
+  Future<void> PolyLine(const CoordMode& coordinate_mode = {},
+                        const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const std::vector<Point>& points = {});
+
+  Future<void> PolySegment(const PolySegmentRequest& request);
+
+  Future<void> PolySegment(const Drawable& drawable = {},
+                           const GraphicsContext& gc = {},
+                           const std::vector<Segment>& segments = {});
+
+  Future<void> PolyRectangle(const PolyRectangleRequest& request);
+
+  Future<void> PolyRectangle(const Drawable& drawable = {},
+                             const GraphicsContext& gc = {},
+                             const std::vector<Rectangle>& rectangles = {});
+
+  Future<void> PolyArc(const PolyArcRequest& request);
+
+  Future<void> PolyArc(const Drawable& drawable = {},
+                       const GraphicsContext& gc = {},
+                       const std::vector<Arc>& arcs = {});
+
+  Future<void> FillPoly(const FillPolyRequest& request);
+
+  Future<void> FillPoly(const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const PolyShape& shape = {},
+                        const CoordMode& coordinate_mode = {},
+                        const std::vector<Point>& points = {});
+
+  Future<void> PolyFillRectangle(const PolyFillRectangleRequest& request);
+
+  Future<void> PolyFillRectangle(const Drawable& drawable = {},
+                                 const GraphicsContext& gc = {},
+                                 const std::vector<Rectangle>& rectangles = {});
+
+  Future<void> PolyFillArc(const PolyFillArcRequest& request);
+
+  Future<void> PolyFillArc(const Drawable& drawable = {},
+                           const GraphicsContext& gc = {},
+                           const std::vector<Arc>& arcs = {});
+
+  Future<void> PutImage(const PutImageRequest& request);
+
+  Future<void> PutImage(const ImageFormat& format = {},
+                        const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const uint16_t& width = {},
+                        const uint16_t& height = {},
+                        const int16_t& dst_x = {},
+                        const int16_t& dst_y = {},
+                        const uint8_t& left_pad = {},
+                        const uint8_t& depth = {},
+                        const scoped_refptr<base::RefCountedMemory>& data = {});
+
+  Future<GetImageReply> GetImage(const GetImageRequest& request);
+
+  Future<GetImageReply> GetImage(const ImageFormat& format = {},
+                                 const Drawable& drawable = {},
+                                 const int16_t& x = {},
+                                 const int16_t& y = {},
+                                 const uint16_t& width = {},
+                                 const uint16_t& height = {},
+                                 const uint32_t& plane_mask = {});
+
+  Future<void> PolyText8(const PolyText8Request& request);
+
+  Future<void> PolyText8(const Drawable& drawable = {},
+                         const GraphicsContext& gc = {},
+                         const int16_t& x = {},
+                         const int16_t& y = {},
+                         const std::vector<uint8_t>& items = {});
+
+  Future<void> PolyText16(const PolyText16Request& request);
+
+  Future<void> PolyText16(const Drawable& drawable = {},
+                          const GraphicsContext& gc = {},
+                          const int16_t& x = {},
+                          const int16_t& y = {},
+                          const std::vector<uint8_t>& items = {});
+
+  Future<void> ImageText8(const ImageText8Request& request);
+
+  Future<void> ImageText8(const Drawable& drawable = {},
+                          const GraphicsContext& gc = {},
+                          const int16_t& x = {},
+                          const int16_t& y = {},
+                          const std::string& string = {});
+
+  Future<void> ImageText16(const ImageText16Request& request);
+
+  Future<void> ImageText16(const Drawable& drawable = {},
+                           const GraphicsContext& gc = {},
+                           const int16_t& x = {},
+                           const int16_t& y = {},
+                           const std::vector<Char16>& string = {});
+
+  Future<void> CreateColormap(const CreateColormapRequest& request);
+
+  Future<void> CreateColormap(const ColormapAlloc& alloc = {},
+                              const ColorMap& mid = {},
+                              const Window& window = {},
+                              const VisualId& visual = {});
+
+  Future<void> FreeColormap(const FreeColormapRequest& request);
+
+  Future<void> FreeColormap(const ColorMap& cmap = {});
+
+  Future<void> CopyColormapAndFree(const CopyColormapAndFreeRequest& request);
+
+  Future<void> CopyColormapAndFree(const ColorMap& mid = {},
+                                   const ColorMap& src_cmap = {});
+
+  Future<void> InstallColormap(const InstallColormapRequest& request);
+
+  Future<void> InstallColormap(const ColorMap& cmap = {});
+
+  Future<void> UninstallColormap(const UninstallColormapRequest& request);
+
+  Future<void> UninstallColormap(const ColorMap& cmap = {});
+
+  Future<ListInstalledColormapsReply> ListInstalledColormaps(
+      const ListInstalledColormapsRequest& request);
+
+  Future<ListInstalledColormapsReply> ListInstalledColormaps(
+      const Window& window = {});
+
+  Future<AllocColorReply> AllocColor(const AllocColorRequest& request);
+
+  Future<AllocColorReply> AllocColor(const ColorMap& cmap = {},
+                                     const uint16_t& red = {},
+                                     const uint16_t& green = {},
+                                     const uint16_t& blue = {});
+
+  Future<AllocNamedColorReply> AllocNamedColor(
+      const AllocNamedColorRequest& request);
+
+  Future<AllocNamedColorReply> AllocNamedColor(const ColorMap& cmap = {},
+                                               const std::string& name = {});
+
+  Future<AllocColorCellsReply> AllocColorCells(
+      const AllocColorCellsRequest& request);
+
+  Future<AllocColorCellsReply> AllocColorCells(const uint8_t& contiguous = {},
+                                               const ColorMap& cmap = {},
+                                               const uint16_t& colors = {},
+                                               const uint16_t& planes = {});
+
+  Future<AllocColorPlanesReply> AllocColorPlanes(
+      const AllocColorPlanesRequest& request);
+
+  Future<AllocColorPlanesReply> AllocColorPlanes(const uint8_t& contiguous = {},
+                                                 const ColorMap& cmap = {},
+                                                 const uint16_t& colors = {},
+                                                 const uint16_t& reds = {},
+                                                 const uint16_t& greens = {},
+                                                 const uint16_t& blues = {});
+
+  Future<void> FreeColors(const FreeColorsRequest& request);
+
+  Future<void> FreeColors(const ColorMap& cmap = {},
+                          const uint32_t& plane_mask = {},
+                          const std::vector<uint32_t>& pixels = {});
+
+  Future<void> StoreColors(const StoreColorsRequest& request);
+
+  Future<void> StoreColors(const ColorMap& cmap = {},
+                           const std::vector<ColorItem>& items = {});
+
+  Future<void> StoreNamedColor(const StoreNamedColorRequest& request);
+
+  Future<void> StoreNamedColor(const ColorFlag& flags = {},
+                               const ColorMap& cmap = {},
+                               const uint32_t& pixel = {},
+                               const std::string& name = {});
+
+  Future<QueryColorsReply> QueryColors(const QueryColorsRequest& request);
+
+  Future<QueryColorsReply> QueryColors(
+      const ColorMap& cmap = {},
+      const std::vector<uint32_t>& pixels = {});
+
+  Future<LookupColorReply> LookupColor(const LookupColorRequest& request);
+
+  Future<LookupColorReply> LookupColor(const ColorMap& cmap = {},
+                                       const std::string& name = {});
+
+  Future<void> CreateCursor(const CreateCursorRequest& request);
+
+  Future<void> CreateCursor(const Cursor& cid = {},
+                            const Pixmap& source = {},
+                            const Pixmap& mask = {},
+                            const uint16_t& fore_red = {},
+                            const uint16_t& fore_green = {},
+                            const uint16_t& fore_blue = {},
+                            const uint16_t& back_red = {},
+                            const uint16_t& back_green = {},
+                            const uint16_t& back_blue = {},
+                            const uint16_t& x = {},
+                            const uint16_t& y = {});
+
+  Future<void> CreateGlyphCursor(const CreateGlyphCursorRequest& request);
+
+  Future<void> CreateGlyphCursor(const Cursor& cid = {},
+                                 const Font& source_font = {},
+                                 const Font& mask_font = {},
+                                 const uint16_t& source_char = {},
+                                 const uint16_t& mask_char = {},
+                                 const uint16_t& fore_red = {},
+                                 const uint16_t& fore_green = {},
+                                 const uint16_t& fore_blue = {},
+                                 const uint16_t& back_red = {},
+                                 const uint16_t& back_green = {},
+                                 const uint16_t& back_blue = {});
+
+  Future<void> FreeCursor(const FreeCursorRequest& request);
+
+  Future<void> FreeCursor(const Cursor& cursor = {});
+
+  Future<void> RecolorCursor(const RecolorCursorRequest& request);
+
+  Future<void> RecolorCursor(const Cursor& cursor = {},
+                             const uint16_t& fore_red = {},
+                             const uint16_t& fore_green = {},
+                             const uint16_t& fore_blue = {},
+                             const uint16_t& back_red = {},
+                             const uint16_t& back_green = {},
+                             const uint16_t& back_blue = {});
+
+  Future<QueryBestSizeReply> QueryBestSize(const QueryBestSizeRequest& request);
+
+  Future<QueryBestSizeReply> QueryBestSize(const QueryShapeOf& c_class = {},
+                                           const Drawable& drawable = {},
+                                           const uint16_t& width = {},
+                                           const uint16_t& height = {});
+
+  Future<QueryExtensionReply> QueryExtension(
+      const QueryExtensionRequest& request);
+
+  Future<QueryExtensionReply> QueryExtension(const std::string& name = {});
+
+  Future<ListExtensionsReply> ListExtensions(
+      const ListExtensionsRequest& request);
+
+  Future<ListExtensionsReply> ListExtensions();
+
+  Future<void> ChangeKeyboardMapping(
+      const ChangeKeyboardMappingRequest& request);
+
+  Future<void> ChangeKeyboardMapping(const uint8_t& keycode_count = {},
+                                     const KeyCode& first_keycode = {},
+                                     const uint8_t& keysyms_per_keycode = {},
+                                     const std::vector<KeySym>& keysyms = {});
+
+  Future<GetKeyboardMappingReply> GetKeyboardMapping(
+      const GetKeyboardMappingRequest& request);
+
+  Future<GetKeyboardMappingReply> GetKeyboardMapping(
+      const KeyCode& first_keycode = {},
+      const uint8_t& count = {});
+
+  Future<void> ChangeKeyboardControl(
+      const ChangeKeyboardControlRequest& request);
+
+  Future<void> ChangeKeyboardControl(
+      const absl::optional<int32_t>& key_click_percent = absl::nullopt,
+      const absl::optional<int32_t>& bell_percent = absl::nullopt,
+      const absl::optional<int32_t>& bell_pitch = absl::nullopt,
+      const absl::optional<int32_t>& bell_duration = absl::nullopt,
+      const absl::optional<uint32_t>& led = absl::nullopt,
+      const absl::optional<LedMode>& led_mode = absl::nullopt,
+      const absl::optional<KeyCode32>& key = absl::nullopt,
+      const absl::optional<AutoRepeatMode>& auto_repeat_mode = absl::nullopt);
+
+  Future<GetKeyboardControlReply> GetKeyboardControl(
+      const GetKeyboardControlRequest& request);
+
+  Future<GetKeyboardControlReply> GetKeyboardControl();
+
+  Future<void> Bell(const BellRequest& request);
+
+  Future<void> Bell(const int8_t& percent = {});
+
+  Future<void> ChangePointerControl(const ChangePointerControlRequest& request);
+
+  Future<void> ChangePointerControl(
+      const int16_t& acceleration_numerator = {},
+      const int16_t& acceleration_denominator = {},
+      const int16_t& threshold = {},
+      const uint8_t& do_acceleration = {},
+      const uint8_t& do_threshold = {});
+
+  Future<GetPointerControlReply> GetPointerControl(
+      const GetPointerControlRequest& request);
+
+  Future<GetPointerControlReply> GetPointerControl();
+
+  Future<void> SetScreenSaver(const SetScreenSaverRequest& request);
+
+  Future<void> SetScreenSaver(const int16_t& timeout = {},
+                              const int16_t& interval = {},
+                              const Blanking& prefer_blanking = {},
+                              const Exposures& allow_exposures = {});
+
+  Future<GetScreenSaverReply> GetScreenSaver(
+      const GetScreenSaverRequest& request);
+
+  Future<GetScreenSaverReply> GetScreenSaver();
+
+  Future<void> ChangeHosts(const ChangeHostsRequest& request);
+
+  Future<void> ChangeHosts(const HostMode& mode = {},
+                           const Family& family = {},
+                           const std::vector<uint8_t>& address = {});
+
+  Future<ListHostsReply> ListHosts(const ListHostsRequest& request);
+
+  Future<ListHostsReply> ListHosts();
+
+  Future<void> SetAccessControl(const SetAccessControlRequest& request);
+
+  Future<void> SetAccessControl(const AccessControl& mode = {});
+
+  Future<void> SetCloseDownMode(const SetCloseDownModeRequest& request);
+
+  Future<void> SetCloseDownMode(const CloseDown& mode = {});
+
+  Future<void> KillClient(const KillClientRequest& request);
+
+  Future<void> KillClient(const uint32_t& resource = {});
+
+  Future<void> RotateProperties(const RotatePropertiesRequest& request);
+
+  Future<void> RotateProperties(const Window& window = {},
+                                const int16_t& delta = {},
+                                const std::vector<Atom>& atoms = {});
+
+  Future<void> ForceScreenSaver(const ForceScreenSaverRequest& request);
+
+  Future<void> ForceScreenSaver(const ScreenSaverMode& mode = {});
+
+  Future<SetPointerMappingReply> SetPointerMapping(
+      const SetPointerMappingRequest& request);
+
+  Future<SetPointerMappingReply> SetPointerMapping(
+      const std::vector<uint8_t>& map = {});
+
+  Future<GetPointerMappingReply> GetPointerMapping(
+      const GetPointerMappingRequest& request);
+
+  Future<GetPointerMappingReply> GetPointerMapping();
+
+  Future<SetModifierMappingReply> SetModifierMapping(
+      const SetModifierMappingRequest& request);
+
+  Future<SetModifierMappingReply> SetModifierMapping(
+      const uint8_t& keycodes_per_modifier = {},
+      const std::vector<KeyCode>& keycodes = {});
+
+  Future<GetModifierMappingReply> GetModifierMapping(
+      const GetModifierMappingRequest& request);
+
+  Future<GetModifierMappingReply> GetModifierMapping();
+
+  Future<void> NoOperation(const NoOperationRequest& request);
+
+  Future<void> NoOperation();
+
+ private:
+  Connection* const connection_;
+};
+
+}  // namespace x11
+
+inline constexpr x11::VisualClass operator|(x11::VisualClass l,
+                                            x11::VisualClass r) {
+  using T = std::underlying_type_t<x11::VisualClass>;
+  return static_cast<x11::VisualClass>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::VisualClass operator&(x11::VisualClass l,
+                                            x11::VisualClass r) {
+  using T = std::underlying_type_t<x11::VisualClass>;
+  return static_cast<x11::VisualClass>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::EventMask operator|(x11::EventMask l, x11::EventMask r) {
+  using T = std::underlying_type_t<x11::EventMask>;
+  return static_cast<x11::EventMask>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::EventMask operator&(x11::EventMask l, x11::EventMask r) {
+  using T = std::underlying_type_t<x11::EventMask>;
+  return static_cast<x11::EventMask>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::BackingStore operator|(x11::BackingStore l,
+                                             x11::BackingStore r) {
+  using T = std::underlying_type_t<x11::BackingStore>;
+  return static_cast<x11::BackingStore>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::BackingStore operator&(x11::BackingStore l,
+                                             x11::BackingStore r) {
+  using T = std::underlying_type_t<x11::BackingStore>;
+  return static_cast<x11::BackingStore>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ImageOrder operator|(x11::ImageOrder l,
+                                           x11::ImageOrder r) {
+  using T = std::underlying_type_t<x11::ImageOrder>;
+  return static_cast<x11::ImageOrder>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ImageOrder operator&(x11::ImageOrder l,
+                                           x11::ImageOrder r) {
+  using T = std::underlying_type_t<x11::ImageOrder>;
+  return static_cast<x11::ImageOrder>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ModMask operator|(x11::ModMask l, x11::ModMask r) {
+  using T = std::underlying_type_t<x11::ModMask>;
+  return static_cast<x11::ModMask>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ModMask operator&(x11::ModMask l, x11::ModMask r) {
+  using T = std::underlying_type_t<x11::ModMask>;
+  return static_cast<x11::ModMask>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::KeyButMask operator|(x11::KeyButMask l,
+                                           x11::KeyButMask r) {
+  using T = std::underlying_type_t<x11::KeyButMask>;
+  return static_cast<x11::KeyButMask>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::KeyButMask operator&(x11::KeyButMask l,
+                                           x11::KeyButMask r) {
+  using T = std::underlying_type_t<x11::KeyButMask>;
+  return static_cast<x11::KeyButMask>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Window operator|(x11::Window l, x11::Window r) {
+  using T = std::underlying_type_t<x11::Window>;
+  return static_cast<x11::Window>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Window operator&(x11::Window l, x11::Window r) {
+  using T = std::underlying_type_t<x11::Window>;
+  return static_cast<x11::Window>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ButtonMask operator|(x11::ButtonMask l,
+                                           x11::ButtonMask r) {
+  using T = std::underlying_type_t<x11::ButtonMask>;
+  return static_cast<x11::ButtonMask>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ButtonMask operator&(x11::ButtonMask l,
+                                           x11::ButtonMask r) {
+  using T = std::underlying_type_t<x11::ButtonMask>;
+  return static_cast<x11::ButtonMask>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Motion operator|(x11::Motion l, x11::Motion r) {
+  using T = std::underlying_type_t<x11::Motion>;
+  return static_cast<x11::Motion>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Motion operator&(x11::Motion l, x11::Motion r) {
+  using T = std::underlying_type_t<x11::Motion>;
+  return static_cast<x11::Motion>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::NotifyDetail operator|(x11::NotifyDetail l,
+                                             x11::NotifyDetail r) {
+  using T = std::underlying_type_t<x11::NotifyDetail>;
+  return static_cast<x11::NotifyDetail>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::NotifyDetail operator&(x11::NotifyDetail l,
+                                             x11::NotifyDetail r) {
+  using T = std::underlying_type_t<x11::NotifyDetail>;
+  return static_cast<x11::NotifyDetail>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::NotifyMode operator|(x11::NotifyMode l,
+                                           x11::NotifyMode r) {
+  using T = std::underlying_type_t<x11::NotifyMode>;
+  return static_cast<x11::NotifyMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::NotifyMode operator&(x11::NotifyMode l,
+                                           x11::NotifyMode r) {
+  using T = std::underlying_type_t<x11::NotifyMode>;
+  return static_cast<x11::NotifyMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Visibility operator|(x11::Visibility l,
+                                           x11::Visibility r) {
+  using T = std::underlying_type_t<x11::Visibility>;
+  return static_cast<x11::Visibility>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Visibility operator&(x11::Visibility l,
+                                           x11::Visibility r) {
+  using T = std::underlying_type_t<x11::Visibility>;
+  return static_cast<x11::Visibility>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Place operator|(x11::Place l, x11::Place r) {
+  using T = std::underlying_type_t<x11::Place>;
+  return static_cast<x11::Place>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Place operator&(x11::Place l, x11::Place r) {
+  using T = std::underlying_type_t<x11::Place>;
+  return static_cast<x11::Place>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Property operator|(x11::Property l, x11::Property r) {
+  using T = std::underlying_type_t<x11::Property>;
+  return static_cast<x11::Property>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Property operator&(x11::Property l, x11::Property r) {
+  using T = std::underlying_type_t<x11::Property>;
+  return static_cast<x11::Property>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Time operator|(x11::Time l, x11::Time r) {
+  using T = std::underlying_type_t<x11::Time>;
+  return static_cast<x11::Time>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Time operator&(x11::Time l, x11::Time r) {
+  using T = std::underlying_type_t<x11::Time>;
+  return static_cast<x11::Time>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Atom operator|(x11::Atom l, x11::Atom r) {
+  using T = std::underlying_type_t<x11::Atom>;
+  return static_cast<x11::Atom>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Atom operator&(x11::Atom l, x11::Atom r) {
+  using T = std::underlying_type_t<x11::Atom>;
+  return static_cast<x11::Atom>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ColormapState operator|(x11::ColormapState l,
+                                              x11::ColormapState r) {
+  using T = std::underlying_type_t<x11::ColormapState>;
+  return static_cast<x11::ColormapState>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ColormapState operator&(x11::ColormapState l,
+                                              x11::ColormapState r) {
+  using T = std::underlying_type_t<x11::ColormapState>;
+  return static_cast<x11::ColormapState>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Colormap operator|(x11::Colormap l, x11::Colormap r) {
+  using T = std::underlying_type_t<x11::Colormap>;
+  return static_cast<x11::Colormap>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Colormap operator&(x11::Colormap l, x11::Colormap r) {
+  using T = std::underlying_type_t<x11::Colormap>;
+  return static_cast<x11::Colormap>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Mapping operator|(x11::Mapping l, x11::Mapping r) {
+  using T = std::underlying_type_t<x11::Mapping>;
+  return static_cast<x11::Mapping>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Mapping operator&(x11::Mapping l, x11::Mapping r) {
+  using T = std::underlying_type_t<x11::Mapping>;
+  return static_cast<x11::Mapping>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::WindowClass operator|(x11::WindowClass l,
+                                            x11::WindowClass r) {
+  using T = std::underlying_type_t<x11::WindowClass>;
+  return static_cast<x11::WindowClass>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::WindowClass operator&(x11::WindowClass l,
+                                            x11::WindowClass r) {
+  using T = std::underlying_type_t<x11::WindowClass>;
+  return static_cast<x11::WindowClass>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::CreateWindowAttribute operator|(
+    x11::CreateWindowAttribute l,
+    x11::CreateWindowAttribute r) {
+  using T = std::underlying_type_t<x11::CreateWindowAttribute>;
+  return static_cast<x11::CreateWindowAttribute>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::CreateWindowAttribute operator&(
+    x11::CreateWindowAttribute l,
+    x11::CreateWindowAttribute r) {
+  using T = std::underlying_type_t<x11::CreateWindowAttribute>;
+  return static_cast<x11::CreateWindowAttribute>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::BackPixmap operator|(x11::BackPixmap l,
+                                           x11::BackPixmap r) {
+  using T = std::underlying_type_t<x11::BackPixmap>;
+  return static_cast<x11::BackPixmap>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::BackPixmap operator&(x11::BackPixmap l,
+                                           x11::BackPixmap r) {
+  using T = std::underlying_type_t<x11::BackPixmap>;
+  return static_cast<x11::BackPixmap>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Gravity operator|(x11::Gravity l, x11::Gravity r) {
+  using T = std::underlying_type_t<x11::Gravity>;
+  return static_cast<x11::Gravity>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Gravity operator&(x11::Gravity l, x11::Gravity r) {
+  using T = std::underlying_type_t<x11::Gravity>;
+  return static_cast<x11::Gravity>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::MapState operator|(x11::MapState l, x11::MapState r) {
+  using T = std::underlying_type_t<x11::MapState>;
+  return static_cast<x11::MapState>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::MapState operator&(x11::MapState l, x11::MapState r) {
+  using T = std::underlying_type_t<x11::MapState>;
+  return static_cast<x11::MapState>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::SetMode operator|(x11::SetMode l, x11::SetMode r) {
+  using T = std::underlying_type_t<x11::SetMode>;
+  return static_cast<x11::SetMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::SetMode operator&(x11::SetMode l, x11::SetMode r) {
+  using T = std::underlying_type_t<x11::SetMode>;
+  return static_cast<x11::SetMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ConfigWindow operator|(x11::ConfigWindow l,
+                                             x11::ConfigWindow r) {
+  using T = std::underlying_type_t<x11::ConfigWindow>;
+  return static_cast<x11::ConfigWindow>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ConfigWindow operator&(x11::ConfigWindow l,
+                                             x11::ConfigWindow r) {
+  using T = std::underlying_type_t<x11::ConfigWindow>;
+  return static_cast<x11::ConfigWindow>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::StackMode operator|(x11::StackMode l, x11::StackMode r) {
+  using T = std::underlying_type_t<x11::StackMode>;
+  return static_cast<x11::StackMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::StackMode operator&(x11::StackMode l, x11::StackMode r) {
+  using T = std::underlying_type_t<x11::StackMode>;
+  return static_cast<x11::StackMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Circulate operator|(x11::Circulate l, x11::Circulate r) {
+  using T = std::underlying_type_t<x11::Circulate>;
+  return static_cast<x11::Circulate>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Circulate operator&(x11::Circulate l, x11::Circulate r) {
+  using T = std::underlying_type_t<x11::Circulate>;
+  return static_cast<x11::Circulate>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::PropMode operator|(x11::PropMode l, x11::PropMode r) {
+  using T = std::underlying_type_t<x11::PropMode>;
+  return static_cast<x11::PropMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::PropMode operator&(x11::PropMode l, x11::PropMode r) {
+  using T = std::underlying_type_t<x11::PropMode>;
+  return static_cast<x11::PropMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::GetPropertyType operator|(x11::GetPropertyType l,
+                                                x11::GetPropertyType r) {
+  using T = std::underlying_type_t<x11::GetPropertyType>;
+  return static_cast<x11::GetPropertyType>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::GetPropertyType operator&(x11::GetPropertyType l,
+                                                x11::GetPropertyType r) {
+  using T = std::underlying_type_t<x11::GetPropertyType>;
+  return static_cast<x11::GetPropertyType>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::SendEventDest operator|(x11::SendEventDest l,
+                                              x11::SendEventDest r) {
+  using T = std::underlying_type_t<x11::SendEventDest>;
+  return static_cast<x11::SendEventDest>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::SendEventDest operator&(x11::SendEventDest l,
+                                              x11::SendEventDest r) {
+  using T = std::underlying_type_t<x11::SendEventDest>;
+  return static_cast<x11::SendEventDest>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::GrabMode operator|(x11::GrabMode l, x11::GrabMode r) {
+  using T = std::underlying_type_t<x11::GrabMode>;
+  return static_cast<x11::GrabMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::GrabMode operator&(x11::GrabMode l, x11::GrabMode r) {
+  using T = std::underlying_type_t<x11::GrabMode>;
+  return static_cast<x11::GrabMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::GrabStatus operator|(x11::GrabStatus l,
+                                           x11::GrabStatus r) {
+  using T = std::underlying_type_t<x11::GrabStatus>;
+  return static_cast<x11::GrabStatus>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::GrabStatus operator&(x11::GrabStatus l,
+                                           x11::GrabStatus r) {
+  using T = std::underlying_type_t<x11::GrabStatus>;
+  return static_cast<x11::GrabStatus>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Cursor operator|(x11::Cursor l, x11::Cursor r) {
+  using T = std::underlying_type_t<x11::Cursor>;
+  return static_cast<x11::Cursor>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Cursor operator&(x11::Cursor l, x11::Cursor r) {
+  using T = std::underlying_type_t<x11::Cursor>;
+  return static_cast<x11::Cursor>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ButtonIndex operator|(x11::ButtonIndex l,
+                                            x11::ButtonIndex r) {
+  using T = std::underlying_type_t<x11::ButtonIndex>;
+  return static_cast<x11::ButtonIndex>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ButtonIndex operator&(x11::ButtonIndex l,
+                                            x11::ButtonIndex r) {
+  using T = std::underlying_type_t<x11::ButtonIndex>;
+  return static_cast<x11::ButtonIndex>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Grab operator|(x11::Grab l, x11::Grab r) {
+  using T = std::underlying_type_t<x11::Grab>;
+  return static_cast<x11::Grab>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Grab operator&(x11::Grab l, x11::Grab r) {
+  using T = std::underlying_type_t<x11::Grab>;
+  return static_cast<x11::Grab>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Allow operator|(x11::Allow l, x11::Allow r) {
+  using T = std::underlying_type_t<x11::Allow>;
+  return static_cast<x11::Allow>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Allow operator&(x11::Allow l, x11::Allow r) {
+  using T = std::underlying_type_t<x11::Allow>;
+  return static_cast<x11::Allow>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::InputFocus operator|(x11::InputFocus l,
+                                           x11::InputFocus r) {
+  using T = std::underlying_type_t<x11::InputFocus>;
+  return static_cast<x11::InputFocus>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::InputFocus operator&(x11::InputFocus l,
+                                           x11::InputFocus r) {
+  using T = std::underlying_type_t<x11::InputFocus>;
+  return static_cast<x11::InputFocus>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::FontDraw operator|(x11::FontDraw l, x11::FontDraw r) {
+  using T = std::underlying_type_t<x11::FontDraw>;
+  return static_cast<x11::FontDraw>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::FontDraw operator&(x11::FontDraw l, x11::FontDraw r) {
+  using T = std::underlying_type_t<x11::FontDraw>;
+  return static_cast<x11::FontDraw>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::GraphicsContextAttribute operator|(
+    x11::GraphicsContextAttribute l,
+    x11::GraphicsContextAttribute r) {
+  using T = std::underlying_type_t<x11::GraphicsContextAttribute>;
+  return static_cast<x11::GraphicsContextAttribute>(static_cast<T>(l) |
+                                                    static_cast<T>(r));
+}
+
+inline constexpr x11::GraphicsContextAttribute operator&(
+    x11::GraphicsContextAttribute l,
+    x11::GraphicsContextAttribute r) {
+  using T = std::underlying_type_t<x11::GraphicsContextAttribute>;
+  return static_cast<x11::GraphicsContextAttribute>(static_cast<T>(l) &
+                                                    static_cast<T>(r));
+}
+
+inline constexpr x11::Gx operator|(x11::Gx l, x11::Gx r) {
+  using T = std::underlying_type_t<x11::Gx>;
+  return static_cast<x11::Gx>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Gx operator&(x11::Gx l, x11::Gx r) {
+  using T = std::underlying_type_t<x11::Gx>;
+  return static_cast<x11::Gx>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::LineStyle operator|(x11::LineStyle l, x11::LineStyle r) {
+  using T = std::underlying_type_t<x11::LineStyle>;
+  return static_cast<x11::LineStyle>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::LineStyle operator&(x11::LineStyle l, x11::LineStyle r) {
+  using T = std::underlying_type_t<x11::LineStyle>;
+  return static_cast<x11::LineStyle>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::CapStyle operator|(x11::CapStyle l, x11::CapStyle r) {
+  using T = std::underlying_type_t<x11::CapStyle>;
+  return static_cast<x11::CapStyle>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::CapStyle operator&(x11::CapStyle l, x11::CapStyle r) {
+  using T = std::underlying_type_t<x11::CapStyle>;
+  return static_cast<x11::CapStyle>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::JoinStyle operator|(x11::JoinStyle l, x11::JoinStyle r) {
+  using T = std::underlying_type_t<x11::JoinStyle>;
+  return static_cast<x11::JoinStyle>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::JoinStyle operator&(x11::JoinStyle l, x11::JoinStyle r) {
+  using T = std::underlying_type_t<x11::JoinStyle>;
+  return static_cast<x11::JoinStyle>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::FillStyle operator|(x11::FillStyle l, x11::FillStyle r) {
+  using T = std::underlying_type_t<x11::FillStyle>;
+  return static_cast<x11::FillStyle>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::FillStyle operator&(x11::FillStyle l, x11::FillStyle r) {
+  using T = std::underlying_type_t<x11::FillStyle>;
+  return static_cast<x11::FillStyle>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::FillRule operator|(x11::FillRule l, x11::FillRule r) {
+  using T = std::underlying_type_t<x11::FillRule>;
+  return static_cast<x11::FillRule>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::FillRule operator&(x11::FillRule l, x11::FillRule r) {
+  using T = std::underlying_type_t<x11::FillRule>;
+  return static_cast<x11::FillRule>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::SubwindowMode operator|(x11::SubwindowMode l,
+                                              x11::SubwindowMode r) {
+  using T = std::underlying_type_t<x11::SubwindowMode>;
+  return static_cast<x11::SubwindowMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::SubwindowMode operator&(x11::SubwindowMode l,
+                                              x11::SubwindowMode r) {
+  using T = std::underlying_type_t<x11::SubwindowMode>;
+  return static_cast<x11::SubwindowMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ArcMode operator|(x11::ArcMode l, x11::ArcMode r) {
+  using T = std::underlying_type_t<x11::ArcMode>;
+  return static_cast<x11::ArcMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ArcMode operator&(x11::ArcMode l, x11::ArcMode r) {
+  using T = std::underlying_type_t<x11::ArcMode>;
+  return static_cast<x11::ArcMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ClipOrdering operator|(x11::ClipOrdering l,
+                                             x11::ClipOrdering r) {
+  using T = std::underlying_type_t<x11::ClipOrdering>;
+  return static_cast<x11::ClipOrdering>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ClipOrdering operator&(x11::ClipOrdering l,
+                                             x11::ClipOrdering r) {
+  using T = std::underlying_type_t<x11::ClipOrdering>;
+  return static_cast<x11::ClipOrdering>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::CoordMode operator|(x11::CoordMode l, x11::CoordMode r) {
+  using T = std::underlying_type_t<x11::CoordMode>;
+  return static_cast<x11::CoordMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::CoordMode operator&(x11::CoordMode l, x11::CoordMode r) {
+  using T = std::underlying_type_t<x11::CoordMode>;
+  return static_cast<x11::CoordMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::PolyShape operator|(x11::PolyShape l, x11::PolyShape r) {
+  using T = std::underlying_type_t<x11::PolyShape>;
+  return static_cast<x11::PolyShape>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::PolyShape operator&(x11::PolyShape l, x11::PolyShape r) {
+  using T = std::underlying_type_t<x11::PolyShape>;
+  return static_cast<x11::PolyShape>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ImageFormat operator|(x11::ImageFormat l,
+                                            x11::ImageFormat r) {
+  using T = std::underlying_type_t<x11::ImageFormat>;
+  return static_cast<x11::ImageFormat>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ImageFormat operator&(x11::ImageFormat l,
+                                            x11::ImageFormat r) {
+  using T = std::underlying_type_t<x11::ImageFormat>;
+  return static_cast<x11::ImageFormat>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ColormapAlloc operator|(x11::ColormapAlloc l,
+                                              x11::ColormapAlloc r) {
+  using T = std::underlying_type_t<x11::ColormapAlloc>;
+  return static_cast<x11::ColormapAlloc>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ColormapAlloc operator&(x11::ColormapAlloc l,
+                                              x11::ColormapAlloc r) {
+  using T = std::underlying_type_t<x11::ColormapAlloc>;
+  return static_cast<x11::ColormapAlloc>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ColorFlag operator|(x11::ColorFlag l, x11::ColorFlag r) {
+  using T = std::underlying_type_t<x11::ColorFlag>;
+  return static_cast<x11::ColorFlag>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::ColorFlag operator&(x11::ColorFlag l, x11::ColorFlag r) {
+  using T = std::underlying_type_t<x11::ColorFlag>;
+  return static_cast<x11::ColorFlag>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Pixmap operator|(x11::Pixmap l, x11::Pixmap r) {
+  using T = std::underlying_type_t<x11::Pixmap>;
+  return static_cast<x11::Pixmap>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Pixmap operator&(x11::Pixmap l, x11::Pixmap r) {
+  using T = std::underlying_type_t<x11::Pixmap>;
+  return static_cast<x11::Pixmap>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Font operator|(x11::Font l, x11::Font r) {
+  using T = std::underlying_type_t<x11::Font>;
+  return static_cast<x11::Font>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Font operator&(x11::Font l, x11::Font r) {
+  using T = std::underlying_type_t<x11::Font>;
+  return static_cast<x11::Font>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::QueryShapeOf operator|(x11::QueryShapeOf l,
+                                             x11::QueryShapeOf r) {
+  using T = std::underlying_type_t<x11::QueryShapeOf>;
+  return static_cast<x11::QueryShapeOf>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::QueryShapeOf operator&(x11::QueryShapeOf l,
+                                             x11::QueryShapeOf r) {
+  using T = std::underlying_type_t<x11::QueryShapeOf>;
+  return static_cast<x11::QueryShapeOf>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Keyboard operator|(x11::Keyboard l, x11::Keyboard r) {
+  using T = std::underlying_type_t<x11::Keyboard>;
+  return static_cast<x11::Keyboard>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Keyboard operator&(x11::Keyboard l, x11::Keyboard r) {
+  using T = std::underlying_type_t<x11::Keyboard>;
+  return static_cast<x11::Keyboard>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::LedMode operator|(x11::LedMode l, x11::LedMode r) {
+  using T = std::underlying_type_t<x11::LedMode>;
+  return static_cast<x11::LedMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::LedMode operator&(x11::LedMode l, x11::LedMode r) {
+  using T = std::underlying_type_t<x11::LedMode>;
+  return static_cast<x11::LedMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::AutoRepeatMode operator|(x11::AutoRepeatMode l,
+                                               x11::AutoRepeatMode r) {
+  using T = std::underlying_type_t<x11::AutoRepeatMode>;
+  return static_cast<x11::AutoRepeatMode>(static_cast<T>(l) |
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::AutoRepeatMode operator&(x11::AutoRepeatMode l,
+                                               x11::AutoRepeatMode r) {
+  using T = std::underlying_type_t<x11::AutoRepeatMode>;
+  return static_cast<x11::AutoRepeatMode>(static_cast<T>(l) &
+                                          static_cast<T>(r));
+}
+
+inline constexpr x11::Blanking operator|(x11::Blanking l, x11::Blanking r) {
+  using T = std::underlying_type_t<x11::Blanking>;
+  return static_cast<x11::Blanking>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Blanking operator&(x11::Blanking l, x11::Blanking r) {
+  using T = std::underlying_type_t<x11::Blanking>;
+  return static_cast<x11::Blanking>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Exposures operator|(x11::Exposures l, x11::Exposures r) {
+  using T = std::underlying_type_t<x11::Exposures>;
+  return static_cast<x11::Exposures>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Exposures operator&(x11::Exposures l, x11::Exposures r) {
+  using T = std::underlying_type_t<x11::Exposures>;
+  return static_cast<x11::Exposures>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::HostMode operator|(x11::HostMode l, x11::HostMode r) {
+  using T = std::underlying_type_t<x11::HostMode>;
+  return static_cast<x11::HostMode>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::HostMode operator&(x11::HostMode l, x11::HostMode r) {
+  using T = std::underlying_type_t<x11::HostMode>;
+  return static_cast<x11::HostMode>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Family operator|(x11::Family l, x11::Family r) {
+  using T = std::underlying_type_t<x11::Family>;
+  return static_cast<x11::Family>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Family operator&(x11::Family l, x11::Family r) {
+  using T = std::underlying_type_t<x11::Family>;
+  return static_cast<x11::Family>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::AccessControl operator|(x11::AccessControl l,
+                                              x11::AccessControl r) {
+  using T = std::underlying_type_t<x11::AccessControl>;
+  return static_cast<x11::AccessControl>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::AccessControl operator&(x11::AccessControl l,
+                                              x11::AccessControl r) {
+  using T = std::underlying_type_t<x11::AccessControl>;
+  return static_cast<x11::AccessControl>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::CloseDown operator|(x11::CloseDown l, x11::CloseDown r) {
+  using T = std::underlying_type_t<x11::CloseDown>;
+  return static_cast<x11::CloseDown>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::CloseDown operator&(x11::CloseDown l, x11::CloseDown r) {
+  using T = std::underlying_type_t<x11::CloseDown>;
+  return static_cast<x11::CloseDown>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Kill operator|(x11::Kill l, x11::Kill r) {
+  using T = std::underlying_type_t<x11::Kill>;
+  return static_cast<x11::Kill>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Kill operator&(x11::Kill l, x11::Kill r) {
+  using T = std::underlying_type_t<x11::Kill>;
+  return static_cast<x11::Kill>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::ScreenSaverMode operator|(x11::ScreenSaverMode l,
+                                                x11::ScreenSaverMode r) {
+  using T = std::underlying_type_t<x11::ScreenSaverMode>;
+  return static_cast<x11::ScreenSaverMode>(static_cast<T>(l) |
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::ScreenSaverMode operator&(x11::ScreenSaverMode l,
+                                                x11::ScreenSaverMode r) {
+  using T = std::underlying_type_t<x11::ScreenSaverMode>;
+  return static_cast<x11::ScreenSaverMode>(static_cast<T>(l) &
+                                           static_cast<T>(r));
+}
+
+inline constexpr x11::MappingStatus operator|(x11::MappingStatus l,
+                                              x11::MappingStatus r) {
+  using T = std::underlying_type_t<x11::MappingStatus>;
+  return static_cast<x11::MappingStatus>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::MappingStatus operator&(x11::MappingStatus l,
+                                              x11::MappingStatus r) {
+  using T = std::underlying_type_t<x11::MappingStatus>;
+  return static_cast<x11::MappingStatus>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::MapIndex operator|(x11::MapIndex l, x11::MapIndex r) {
+  using T = std::underlying_type_t<x11::MapIndex>;
+  return static_cast<x11::MapIndex>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::MapIndex operator&(x11::MapIndex l, x11::MapIndex r) {
+  using T = std::underlying_type_t<x11::MapIndex>;
+  return static_cast<x11::MapIndex>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XPROTO_H_
diff --git a/ui/gfx/x/generated_protos/xselinux.cc b/ui/gfx/x/generated_protos/xselinux.cc
new file mode 100644
index 0000000..453b3de
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xselinux.cc
@@ -0,0 +1,1683 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xselinux.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+SELinux::SELinux(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<SELinux::QueryVersionReply> SELinux::QueryVersion(
+    const SELinux::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& client_major = request.client_major;
+  auto& client_minor = request.client_minor;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // client_major
+  buf.Write(&client_major);
+
+  // client_minor
+  buf.Write(&client_minor);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::QueryVersionReply>(
+      &buf, "SELinux::QueryVersion", false);
+}
+
+Future<SELinux::QueryVersionReply> SELinux::QueryVersion(
+    const uint8_t& client_major,
+    const uint8_t& client_minor) {
+  return SELinux::QueryVersion(
+      SELinux::QueryVersionRequest{client_major, client_minor});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::QueryVersionReply> detail::ReadReply<
+    SELinux::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& server_major = (*reply).server_major;
+  auto& server_minor = (*reply).server_minor;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // server_major
+  Read(&server_major, &buf);
+
+  // server_minor
+  Read(&server_minor, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> SELinux::SetDeviceCreateContext(
+    const SELinux::SetDeviceCreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t context_len{};
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_len
+  context_len = context.size();
+  buf.Write(&context_len);
+
+  // context
+  DCHECK_EQ(static_cast<size_t>(context_len), context.size());
+  for (auto& context_elem : context) {
+    // context_elem
+    buf.Write(&context_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SELinux::SetDeviceCreateContext",
+                                        false);
+}
+
+Future<void> SELinux::SetDeviceCreateContext(const std::string& context) {
+  return SELinux::SetDeviceCreateContext(
+      SELinux::SetDeviceCreateContextRequest{context});
+}
+
+Future<SELinux::GetDeviceCreateContextReply> SELinux::GetDeviceCreateContext(
+    const SELinux::GetDeviceCreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetDeviceCreateContextReply>(
+      &buf, "SELinux::GetDeviceCreateContext", false);
+}
+
+Future<SELinux::GetDeviceCreateContextReply> SELinux::GetDeviceCreateContext() {
+  return SELinux::GetDeviceCreateContext(
+      SELinux::GetDeviceCreateContextRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetDeviceCreateContextReply> detail::ReadReply<
+    SELinux::GetDeviceCreateContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetDeviceCreateContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> SELinux::SetDeviceContext(
+    const SELinux::SetDeviceContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device = request.device;
+  uint32_t context_len{};
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device
+  buf.Write(&device);
+
+  // context_len
+  context_len = context.size();
+  buf.Write(&context_len);
+
+  // context
+  DCHECK_EQ(static_cast<size_t>(context_len), context.size());
+  for (auto& context_elem : context) {
+    // context_elem
+    buf.Write(&context_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SELinux::SetDeviceContext",
+                                        false);
+}
+
+Future<void> SELinux::SetDeviceContext(const uint32_t& device,
+                                       const std::string& context) {
+  return SELinux::SetDeviceContext(
+      SELinux::SetDeviceContextRequest{device, context});
+}
+
+Future<SELinux::GetDeviceContextReply> SELinux::GetDeviceContext(
+    const SELinux::GetDeviceContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& device = request.device;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // device
+  buf.Write(&device);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetDeviceContextReply>(
+      &buf, "SELinux::GetDeviceContext", false);
+}
+
+Future<SELinux::GetDeviceContextReply> SELinux::GetDeviceContext(
+    const uint32_t& device) {
+  return SELinux::GetDeviceContext(SELinux::GetDeviceContextRequest{device});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetDeviceContextReply> detail::ReadReply<
+    SELinux::GetDeviceContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetDeviceContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> SELinux::SetWindowCreateContext(
+    const SELinux::SetWindowCreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t context_len{};
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_len
+  context_len = context.size();
+  buf.Write(&context_len);
+
+  // context
+  DCHECK_EQ(static_cast<size_t>(context_len), context.size());
+  for (auto& context_elem : context) {
+    // context_elem
+    buf.Write(&context_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SELinux::SetWindowCreateContext",
+                                        false);
+}
+
+Future<void> SELinux::SetWindowCreateContext(const std::string& context) {
+  return SELinux::SetWindowCreateContext(
+      SELinux::SetWindowCreateContextRequest{context});
+}
+
+Future<SELinux::GetWindowCreateContextReply> SELinux::GetWindowCreateContext(
+    const SELinux::GetWindowCreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetWindowCreateContextReply>(
+      &buf, "SELinux::GetWindowCreateContext", false);
+}
+
+Future<SELinux::GetWindowCreateContextReply> SELinux::GetWindowCreateContext() {
+  return SELinux::GetWindowCreateContext(
+      SELinux::GetWindowCreateContextRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetWindowCreateContextReply> detail::ReadReply<
+    SELinux::GetWindowCreateContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetWindowCreateContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SELinux::GetWindowContextReply> SELinux::GetWindowContext(
+    const SELinux::GetWindowContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetWindowContextReply>(
+      &buf, "SELinux::GetWindowContext", false);
+}
+
+Future<SELinux::GetWindowContextReply> SELinux::GetWindowContext(
+    const Window& window) {
+  return SELinux::GetWindowContext(SELinux::GetWindowContextRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetWindowContextReply> detail::ReadReply<
+    SELinux::GetWindowContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetWindowContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> SELinux::SetPropertyCreateContext(
+    const SELinux::SetPropertyCreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t context_len{};
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_len
+  context_len = context.size();
+  buf.Write(&context_len);
+
+  // context
+  DCHECK_EQ(static_cast<size_t>(context_len), context.size());
+  for (auto& context_elem : context) {
+    // context_elem
+    buf.Write(&context_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(
+      &buf, "SELinux::SetPropertyCreateContext", false);
+}
+
+Future<void> SELinux::SetPropertyCreateContext(const std::string& context) {
+  return SELinux::SetPropertyCreateContext(
+      SELinux::SetPropertyCreateContextRequest{context});
+}
+
+Future<SELinux::GetPropertyCreateContextReply>
+SELinux::GetPropertyCreateContext(
+    const SELinux::GetPropertyCreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetPropertyCreateContextReply>(
+      &buf, "SELinux::GetPropertyCreateContext", false);
+}
+
+Future<SELinux::GetPropertyCreateContextReply>
+SELinux::GetPropertyCreateContext() {
+  return SELinux::GetPropertyCreateContext(
+      SELinux::GetPropertyCreateContextRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetPropertyCreateContextReply> detail::ReadReply<
+    SELinux::GetPropertyCreateContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetPropertyCreateContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> SELinux::SetPropertyUseContext(
+    const SELinux::SetPropertyUseContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t context_len{};
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_len
+  context_len = context.size();
+  buf.Write(&context_len);
+
+  // context
+  DCHECK_EQ(static_cast<size_t>(context_len), context.size());
+  for (auto& context_elem : context) {
+    // context_elem
+    buf.Write(&context_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SELinux::SetPropertyUseContext",
+                                        false);
+}
+
+Future<void> SELinux::SetPropertyUseContext(const std::string& context) {
+  return SELinux::SetPropertyUseContext(
+      SELinux::SetPropertyUseContextRequest{context});
+}
+
+Future<SELinux::GetPropertyUseContextReply> SELinux::GetPropertyUseContext(
+    const SELinux::GetPropertyUseContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetPropertyUseContextReply>(
+      &buf, "SELinux::GetPropertyUseContext", false);
+}
+
+Future<SELinux::GetPropertyUseContextReply> SELinux::GetPropertyUseContext() {
+  return SELinux::GetPropertyUseContext(
+      SELinux::GetPropertyUseContextRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetPropertyUseContextReply> detail::ReadReply<
+    SELinux::GetPropertyUseContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetPropertyUseContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SELinux::GetPropertyContextReply> SELinux::GetPropertyContext(
+    const SELinux::GetPropertyContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& property = request.property;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // property
+  buf.Write(&property);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetPropertyContextReply>(
+      &buf, "SELinux::GetPropertyContext", false);
+}
+
+Future<SELinux::GetPropertyContextReply> SELinux::GetPropertyContext(
+    const Window& window,
+    const Atom& property) {
+  return SELinux::GetPropertyContext(
+      SELinux::GetPropertyContextRequest{window, property});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetPropertyContextReply> detail::ReadReply<
+    SELinux::GetPropertyContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetPropertyContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SELinux::GetPropertyDataContextReply> SELinux::GetPropertyDataContext(
+    const SELinux::GetPropertyDataContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& property = request.property;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // property
+  buf.Write(&property);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetPropertyDataContextReply>(
+      &buf, "SELinux::GetPropertyDataContext", false);
+}
+
+Future<SELinux::GetPropertyDataContextReply> SELinux::GetPropertyDataContext(
+    const Window& window,
+    const Atom& property) {
+  return SELinux::GetPropertyDataContext(
+      SELinux::GetPropertyDataContextRequest{window, property});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetPropertyDataContextReply> detail::ReadReply<
+    SELinux::GetPropertyDataContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetPropertyDataContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SELinux::ListPropertiesReply> SELinux::ListProperties(
+    const SELinux::ListPropertiesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::ListPropertiesReply>(
+      &buf, "SELinux::ListProperties", false);
+}
+
+Future<SELinux::ListPropertiesReply> SELinux::ListProperties(
+    const Window& window) {
+  return SELinux::ListProperties(SELinux::ListPropertiesRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::ListPropertiesReply> detail::ReadReply<
+    SELinux::ListPropertiesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::ListPropertiesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t properties_len{};
+  auto& properties = (*reply).properties;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // properties_len
+  Read(&properties_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // properties
+  properties.resize(properties_len);
+  for (auto& properties_elem : properties) {
+    // properties_elem
+    {
+      auto& name = properties_elem.name;
+      uint32_t object_context_len{};
+      uint32_t data_context_len{};
+      auto& object_context = properties_elem.object_context;
+      auto& data_context = properties_elem.data_context;
+
+      // name
+      Read(&name, &buf);
+
+      // object_context_len
+      Read(&object_context_len, &buf);
+
+      // data_context_len
+      Read(&data_context_len, &buf);
+
+      // object_context
+      object_context.resize(object_context_len);
+      for (auto& object_context_elem : object_context) {
+        // object_context_elem
+        Read(&object_context_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 4);
+
+      // data_context
+      data_context.resize(data_context_len);
+      for (auto& data_context_elem : data_context) {
+        // data_context_elem
+        Read(&data_context_elem, &buf);
+      }
+
+      // pad1
+      Align(&buf, 4);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> SELinux::SetSelectionCreateContext(
+    const SELinux::SetSelectionCreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t context_len{};
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_len
+  context_len = context.size();
+  buf.Write(&context_len);
+
+  // context
+  DCHECK_EQ(static_cast<size_t>(context_len), context.size());
+  for (auto& context_elem : context) {
+    // context_elem
+    buf.Write(&context_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(
+      &buf, "SELinux::SetSelectionCreateContext", false);
+}
+
+Future<void> SELinux::SetSelectionCreateContext(const std::string& context) {
+  return SELinux::SetSelectionCreateContext(
+      SELinux::SetSelectionCreateContextRequest{context});
+}
+
+Future<SELinux::GetSelectionCreateContextReply>
+SELinux::GetSelectionCreateContext(
+    const SELinux::GetSelectionCreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetSelectionCreateContextReply>(
+      &buf, "SELinux::GetSelectionCreateContext", false);
+}
+
+Future<SELinux::GetSelectionCreateContextReply>
+SELinux::GetSelectionCreateContext() {
+  return SELinux::GetSelectionCreateContext(
+      SELinux::GetSelectionCreateContextRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetSelectionCreateContextReply> detail::ReadReply<
+    SELinux::GetSelectionCreateContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetSelectionCreateContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> SELinux::SetSelectionUseContext(
+    const SELinux::SetSelectionUseContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  uint32_t context_len{};
+  auto& context = request.context;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_len
+  context_len = context.size();
+  buf.Write(&context_len);
+
+  // context
+  DCHECK_EQ(static_cast<size_t>(context_len), context.size());
+  for (auto& context_elem : context) {
+    // context_elem
+    buf.Write(&context_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "SELinux::SetSelectionUseContext",
+                                        false);
+}
+
+Future<void> SELinux::SetSelectionUseContext(const std::string& context) {
+  return SELinux::SetSelectionUseContext(
+      SELinux::SetSelectionUseContextRequest{context});
+}
+
+Future<SELinux::GetSelectionUseContextReply> SELinux::GetSelectionUseContext(
+    const SELinux::GetSelectionUseContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetSelectionUseContextReply>(
+      &buf, "SELinux::GetSelectionUseContext", false);
+}
+
+Future<SELinux::GetSelectionUseContextReply> SELinux::GetSelectionUseContext() {
+  return SELinux::GetSelectionUseContext(
+      SELinux::GetSelectionUseContextRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetSelectionUseContextReply> detail::ReadReply<
+    SELinux::GetSelectionUseContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetSelectionUseContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SELinux::GetSelectionContextReply> SELinux::GetSelectionContext(
+    const SELinux::GetSelectionContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& selection = request.selection;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // selection
+  buf.Write(&selection);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetSelectionContextReply>(
+      &buf, "SELinux::GetSelectionContext", false);
+}
+
+Future<SELinux::GetSelectionContextReply> SELinux::GetSelectionContext(
+    const Atom& selection) {
+  return SELinux::GetSelectionContext(
+      SELinux::GetSelectionContextRequest{selection});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetSelectionContextReply> detail::ReadReply<
+    SELinux::GetSelectionContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetSelectionContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SELinux::GetSelectionDataContextReply> SELinux::GetSelectionDataContext(
+    const SELinux::GetSelectionDataContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& selection = request.selection;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 20;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // selection
+  buf.Write(&selection);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetSelectionDataContextReply>(
+      &buf, "SELinux::GetSelectionDataContext", false);
+}
+
+Future<SELinux::GetSelectionDataContextReply> SELinux::GetSelectionDataContext(
+    const Atom& selection) {
+  return SELinux::GetSelectionDataContext(
+      SELinux::GetSelectionDataContextRequest{selection});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetSelectionDataContextReply> detail::ReadReply<
+    SELinux::GetSelectionDataContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetSelectionDataContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SELinux::ListSelectionsReply> SELinux::ListSelections(
+    const SELinux::ListSelectionsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 21;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::ListSelectionsReply>(
+      &buf, "SELinux::ListSelections", false);
+}
+
+Future<SELinux::ListSelectionsReply> SELinux::ListSelections() {
+  return SELinux::ListSelections(SELinux::ListSelectionsRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::ListSelectionsReply> detail::ReadReply<
+    SELinux::ListSelectionsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::ListSelectionsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t selections_len{};
+  auto& selections = (*reply).selections;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // selections_len
+  Read(&selections_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // selections
+  selections.resize(selections_len);
+  for (auto& selections_elem : selections) {
+    // selections_elem
+    {
+      auto& name = selections_elem.name;
+      uint32_t object_context_len{};
+      uint32_t data_context_len{};
+      auto& object_context = selections_elem.object_context;
+      auto& data_context = selections_elem.data_context;
+
+      // name
+      Read(&name, &buf);
+
+      // object_context_len
+      Read(&object_context_len, &buf);
+
+      // data_context_len
+      Read(&data_context_len, &buf);
+
+      // object_context
+      object_context.resize(object_context_len);
+      for (auto& object_context_elem : object_context) {
+        // object_context_elem
+        Read(&object_context_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 4);
+
+      // data_context
+      data_context.resize(data_context_len);
+      for (auto& data_context_elem : data_context) {
+        // data_context_elem
+        Read(&data_context_elem, &buf);
+      }
+
+      // pad1
+      Align(&buf, 4);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<SELinux::GetClientContextReply> SELinux::GetClientContext(
+    const SELinux::GetClientContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& resource = request.resource;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 22;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // resource
+  buf.Write(&resource);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<SELinux::GetClientContextReply>(
+      &buf, "SELinux::GetClientContext", false);
+}
+
+Future<SELinux::GetClientContextReply> SELinux::GetClientContext(
+    const uint32_t& resource) {
+  return SELinux::GetClientContext(SELinux::GetClientContextRequest{resource});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<SELinux::GetClientContextReply> detail::ReadReply<
+    SELinux::GetClientContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<SELinux::GetClientContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t context_len{};
+  auto& context = (*reply).context;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // context_len
+  Read(&context_len, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // context
+  context.resize(context_len);
+  for (auto& context_elem : context) {
+    // context_elem
+    Read(&context_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xselinux.h b/ui/gfx/x/generated_protos/xselinux.h
new file mode 100644
index 0000000..172395a
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xselinux.h
@@ -0,0 +1,428 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XSELINUX_H_
+#define UI_GFX_X_GENERATED_PROTOS_XSELINUX_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) SELinux {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 0;
+
+  SELinux(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  struct ListItem {
+    Atom name{};
+    std::string object_context{};
+    std::string data_context{};
+  };
+
+  struct QueryVersionRequest {
+    uint8_t client_major{};
+    uint8_t client_minor{};
+  };
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint16_t server_major{};
+    uint16_t server_minor{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion(const uint8_t& client_major = {},
+                                         const uint8_t& client_minor = {});
+
+  struct SetDeviceCreateContextRequest {
+    std::string context{};
+  };
+
+  using SetDeviceCreateContextResponse = Response<void>;
+
+  Future<void> SetDeviceCreateContext(
+      const SetDeviceCreateContextRequest& request);
+
+  Future<void> SetDeviceCreateContext(const std::string& context = {});
+
+  struct GetDeviceCreateContextRequest {};
+
+  struct GetDeviceCreateContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetDeviceCreateContextResponse = Response<GetDeviceCreateContextReply>;
+
+  Future<GetDeviceCreateContextReply> GetDeviceCreateContext(
+      const GetDeviceCreateContextRequest& request);
+
+  Future<GetDeviceCreateContextReply> GetDeviceCreateContext();
+
+  struct SetDeviceContextRequest {
+    uint32_t device{};
+    std::string context{};
+  };
+
+  using SetDeviceContextResponse = Response<void>;
+
+  Future<void> SetDeviceContext(const SetDeviceContextRequest& request);
+
+  Future<void> SetDeviceContext(const uint32_t& device = {},
+                                const std::string& context = {});
+
+  struct GetDeviceContextRequest {
+    uint32_t device{};
+  };
+
+  struct GetDeviceContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetDeviceContextResponse = Response<GetDeviceContextReply>;
+
+  Future<GetDeviceContextReply> GetDeviceContext(
+      const GetDeviceContextRequest& request);
+
+  Future<GetDeviceContextReply> GetDeviceContext(const uint32_t& device = {});
+
+  struct SetWindowCreateContextRequest {
+    std::string context{};
+  };
+
+  using SetWindowCreateContextResponse = Response<void>;
+
+  Future<void> SetWindowCreateContext(
+      const SetWindowCreateContextRequest& request);
+
+  Future<void> SetWindowCreateContext(const std::string& context = {});
+
+  struct GetWindowCreateContextRequest {};
+
+  struct GetWindowCreateContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetWindowCreateContextResponse = Response<GetWindowCreateContextReply>;
+
+  Future<GetWindowCreateContextReply> GetWindowCreateContext(
+      const GetWindowCreateContextRequest& request);
+
+  Future<GetWindowCreateContextReply> GetWindowCreateContext();
+
+  struct GetWindowContextRequest {
+    Window window{};
+  };
+
+  struct GetWindowContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetWindowContextResponse = Response<GetWindowContextReply>;
+
+  Future<GetWindowContextReply> GetWindowContext(
+      const GetWindowContextRequest& request);
+
+  Future<GetWindowContextReply> GetWindowContext(const Window& window = {});
+
+  struct SetPropertyCreateContextRequest {
+    std::string context{};
+  };
+
+  using SetPropertyCreateContextResponse = Response<void>;
+
+  Future<void> SetPropertyCreateContext(
+      const SetPropertyCreateContextRequest& request);
+
+  Future<void> SetPropertyCreateContext(const std::string& context = {});
+
+  struct GetPropertyCreateContextRequest {};
+
+  struct GetPropertyCreateContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetPropertyCreateContextResponse =
+      Response<GetPropertyCreateContextReply>;
+
+  Future<GetPropertyCreateContextReply> GetPropertyCreateContext(
+      const GetPropertyCreateContextRequest& request);
+
+  Future<GetPropertyCreateContextReply> GetPropertyCreateContext();
+
+  struct SetPropertyUseContextRequest {
+    std::string context{};
+  };
+
+  using SetPropertyUseContextResponse = Response<void>;
+
+  Future<void> SetPropertyUseContext(
+      const SetPropertyUseContextRequest& request);
+
+  Future<void> SetPropertyUseContext(const std::string& context = {});
+
+  struct GetPropertyUseContextRequest {};
+
+  struct GetPropertyUseContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetPropertyUseContextResponse = Response<GetPropertyUseContextReply>;
+
+  Future<GetPropertyUseContextReply> GetPropertyUseContext(
+      const GetPropertyUseContextRequest& request);
+
+  Future<GetPropertyUseContextReply> GetPropertyUseContext();
+
+  struct GetPropertyContextRequest {
+    Window window{};
+    Atom property{};
+  };
+
+  struct GetPropertyContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetPropertyContextResponse = Response<GetPropertyContextReply>;
+
+  Future<GetPropertyContextReply> GetPropertyContext(
+      const GetPropertyContextRequest& request);
+
+  Future<GetPropertyContextReply> GetPropertyContext(const Window& window = {},
+                                                     const Atom& property = {});
+
+  struct GetPropertyDataContextRequest {
+    Window window{};
+    Atom property{};
+  };
+
+  struct GetPropertyDataContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetPropertyDataContextResponse = Response<GetPropertyDataContextReply>;
+
+  Future<GetPropertyDataContextReply> GetPropertyDataContext(
+      const GetPropertyDataContextRequest& request);
+
+  Future<GetPropertyDataContextReply> GetPropertyDataContext(
+      const Window& window = {},
+      const Atom& property = {});
+
+  struct ListPropertiesRequest {
+    Window window{};
+  };
+
+  struct ListPropertiesReply {
+    uint16_t sequence{};
+    std::vector<ListItem> properties{};
+  };
+
+  using ListPropertiesResponse = Response<ListPropertiesReply>;
+
+  Future<ListPropertiesReply> ListProperties(
+      const ListPropertiesRequest& request);
+
+  Future<ListPropertiesReply> ListProperties(const Window& window = {});
+
+  struct SetSelectionCreateContextRequest {
+    std::string context{};
+  };
+
+  using SetSelectionCreateContextResponse = Response<void>;
+
+  Future<void> SetSelectionCreateContext(
+      const SetSelectionCreateContextRequest& request);
+
+  Future<void> SetSelectionCreateContext(const std::string& context = {});
+
+  struct GetSelectionCreateContextRequest {};
+
+  struct GetSelectionCreateContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetSelectionCreateContextResponse =
+      Response<GetSelectionCreateContextReply>;
+
+  Future<GetSelectionCreateContextReply> GetSelectionCreateContext(
+      const GetSelectionCreateContextRequest& request);
+
+  Future<GetSelectionCreateContextReply> GetSelectionCreateContext();
+
+  struct SetSelectionUseContextRequest {
+    std::string context{};
+  };
+
+  using SetSelectionUseContextResponse = Response<void>;
+
+  Future<void> SetSelectionUseContext(
+      const SetSelectionUseContextRequest& request);
+
+  Future<void> SetSelectionUseContext(const std::string& context = {});
+
+  struct GetSelectionUseContextRequest {};
+
+  struct GetSelectionUseContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetSelectionUseContextResponse = Response<GetSelectionUseContextReply>;
+
+  Future<GetSelectionUseContextReply> GetSelectionUseContext(
+      const GetSelectionUseContextRequest& request);
+
+  Future<GetSelectionUseContextReply> GetSelectionUseContext();
+
+  struct GetSelectionContextRequest {
+    Atom selection{};
+  };
+
+  struct GetSelectionContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetSelectionContextResponse = Response<GetSelectionContextReply>;
+
+  Future<GetSelectionContextReply> GetSelectionContext(
+      const GetSelectionContextRequest& request);
+
+  Future<GetSelectionContextReply> GetSelectionContext(
+      const Atom& selection = {});
+
+  struct GetSelectionDataContextRequest {
+    Atom selection{};
+  };
+
+  struct GetSelectionDataContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetSelectionDataContextResponse =
+      Response<GetSelectionDataContextReply>;
+
+  Future<GetSelectionDataContextReply> GetSelectionDataContext(
+      const GetSelectionDataContextRequest& request);
+
+  Future<GetSelectionDataContextReply> GetSelectionDataContext(
+      const Atom& selection = {});
+
+  struct ListSelectionsRequest {};
+
+  struct ListSelectionsReply {
+    uint16_t sequence{};
+    std::vector<ListItem> selections{};
+  };
+
+  using ListSelectionsResponse = Response<ListSelectionsReply>;
+
+  Future<ListSelectionsReply> ListSelections(
+      const ListSelectionsRequest& request);
+
+  Future<ListSelectionsReply> ListSelections();
+
+  struct GetClientContextRequest {
+    uint32_t resource{};
+  };
+
+  struct GetClientContextReply {
+    uint16_t sequence{};
+    std::string context{};
+  };
+
+  using GetClientContextResponse = Response<GetClientContextReply>;
+
+  Future<GetClientContextReply> GetClientContext(
+      const GetClientContextRequest& request);
+
+  Future<GetClientContextReply> GetClientContext(const uint32_t& resource = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XSELINUX_H_
diff --git a/ui/gfx/x/generated_protos/xtest.cc b/ui/gfx/x/generated_protos/xtest.cc
new file mode 100644
index 0000000..709caef
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xtest.cc
@@ -0,0 +1,309 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xtest.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Test::Test(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<Test::GetVersionReply> Test::GetVersion(
+    const Test::GetVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& major_version = request.major_version;
+  auto& minor_version = request.minor_version;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // major_version
+  buf.Write(&major_version);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // minor_version
+  buf.Write(&minor_version);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Test::GetVersionReply>(
+      &buf, "Test::GetVersion", false);
+}
+
+Future<Test::GetVersionReply> Test::GetVersion(const uint8_t& major_version,
+                                               const uint16_t& minor_version) {
+  return Test::GetVersion(
+      Test::GetVersionRequest{major_version, minor_version});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Test::GetVersionReply> detail::ReadReply<Test::GetVersionReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Test::GetVersionReply>();
+
+  auto& major_version = (*reply).major_version;
+  auto& sequence = (*reply).sequence;
+  auto& minor_version = (*reply).minor_version;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // major_version
+  Read(&major_version, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // minor_version
+  Read(&minor_version, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Test::CompareCursorReply> Test::CompareCursor(
+    const Test::CompareCursorRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+  auto& cursor = request.cursor;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  // cursor
+  buf.Write(&cursor);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Test::CompareCursorReply>(
+      &buf, "Test::CompareCursor", false);
+}
+
+Future<Test::CompareCursorReply> Test::CompareCursor(
+    const Window& window,
+    const x11::Cursor& cursor) {
+  return Test::CompareCursor(Test::CompareCursorRequest{window, cursor});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Test::CompareCursorReply> detail::ReadReply<
+    Test::CompareCursorReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Test::CompareCursorReply>();
+
+  auto& same = (*reply).same;
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // same
+  Read(&same, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Test::FakeInput(const Test::FakeInputRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& type = request.type;
+  auto& detail = request.detail;
+  auto& time = request.time;
+  auto& root = request.root;
+  auto& rootX = request.rootX;
+  auto& rootY = request.rootY;
+  auto& deviceid = request.deviceid;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // type
+  buf.Write(&type);
+
+  // detail
+  buf.Write(&detail);
+
+  // pad0
+  Pad(&buf, 2);
+
+  // time
+  buf.Write(&time);
+
+  // root
+  buf.Write(&root);
+
+  // pad1
+  Pad(&buf, 8);
+
+  // rootX
+  buf.Write(&rootX);
+
+  // rootY
+  buf.Write(&rootY);
+
+  // pad2
+  Pad(&buf, 7);
+
+  // deviceid
+  buf.Write(&deviceid);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Test::FakeInput", false);
+}
+
+Future<void> Test::FakeInput(const uint8_t& type,
+                             const uint8_t& detail,
+                             const uint32_t& time,
+                             const Window& root,
+                             const int16_t& rootX,
+                             const int16_t& rootY,
+                             const uint8_t& deviceid) {
+  return Test::FakeInput(
+      Test::FakeInputRequest{type, detail, time, root, rootX, rootY, deviceid});
+}
+
+Future<void> Test::GrabControl(const Test::GrabControlRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& impervious = request.impervious;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // impervious
+  buf.Write(&impervious);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Test::GrabControl", false);
+}
+
+Future<void> Test::GrabControl(const uint8_t& impervious) {
+  return Test::GrabControl(Test::GrabControlRequest{impervious});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xtest.h b/ui/gfx/x/generated_protos/xtest.h
new file mode 100644
index 0000000..b987f53
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xtest.h
@@ -0,0 +1,174 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XTEST_H_
+#define UI_GFX_X_GENERATED_PROTOS_XTEST_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Test {
+ public:
+  static constexpr unsigned major_version = 2;
+  static constexpr unsigned minor_version = 2;
+
+  Test(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Cursor : int {
+    None = 0,
+    Current = 1,
+  };
+
+  struct GetVersionRequest {
+    uint8_t major_version{};
+    uint16_t minor_version{};
+  };
+
+  struct GetVersionReply {
+    uint8_t major_version{};
+    uint16_t sequence{};
+    uint16_t minor_version{};
+  };
+
+  using GetVersionResponse = Response<GetVersionReply>;
+
+  Future<GetVersionReply> GetVersion(const GetVersionRequest& request);
+
+  Future<GetVersionReply> GetVersion(const uint8_t& major_version = {},
+                                     const uint16_t& minor_version = {});
+
+  struct CompareCursorRequest {
+    Window window{};
+    x11::Cursor cursor{};
+  };
+
+  struct CompareCursorReply {
+    uint8_t same{};
+    uint16_t sequence{};
+  };
+
+  using CompareCursorResponse = Response<CompareCursorReply>;
+
+  Future<CompareCursorReply> CompareCursor(const CompareCursorRequest& request);
+
+  Future<CompareCursorReply> CompareCursor(const Window& window = {},
+                                           const x11::Cursor& cursor = {});
+
+  struct FakeInputRequest {
+    uint8_t type{};
+    uint8_t detail{};
+    uint32_t time{};
+    Window root{};
+    int16_t rootX{};
+    int16_t rootY{};
+    uint8_t deviceid{};
+  };
+
+  using FakeInputResponse = Response<void>;
+
+  Future<void> FakeInput(const FakeInputRequest& request);
+
+  Future<void> FakeInput(const uint8_t& type = {},
+                         const uint8_t& detail = {},
+                         const uint32_t& time = {},
+                         const Window& root = {},
+                         const int16_t& rootX = {},
+                         const int16_t& rootY = {},
+                         const uint8_t& deviceid = {});
+
+  struct GrabControlRequest {
+    uint8_t impervious{};
+  };
+
+  using GrabControlResponse = Response<void>;
+
+  Future<void> GrabControl(const GrabControlRequest& request);
+
+  Future<void> GrabControl(const uint8_t& impervious = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Test::Cursor operator|(x11::Test::Cursor l,
+                                             x11::Test::Cursor r) {
+  using T = std::underlying_type_t<x11::Test::Cursor>;
+  return static_cast<x11::Test::Cursor>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Test::Cursor operator&(x11::Test::Cursor l,
+                                             x11::Test::Cursor r) {
+  using T = std::underlying_type_t<x11::Test::Cursor>;
+  return static_cast<x11::Test::Cursor>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XTEST_H_
diff --git a/ui/gfx/x/generated_protos/xv.cc b/ui/gfx/x/generated_protos/xv.cc
new file mode 100644
index 0000000..0171ced
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xv.cc
@@ -0,0 +1,1967 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xv.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+Xv::Xv(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+std::string Xv::BadPortError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Xv::BadPortError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Xv::BadPortError>(Xv::BadPortError* error_, ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Xv::BadEncodingError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Xv::BadEncodingError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Xv::BadEncodingError>(Xv::BadEncodingError* error_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+std::string Xv::BadControlError::ToString() const {
+  std::stringstream ss_;
+  ss_ << "Xv::BadControlError{";
+  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
+  ss_ << "}";
+  return ss_.str();
+}
+
+template <>
+void ReadError<Xv::BadControlError>(Xv::BadControlError* error_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*error_).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // error_code
+  uint8_t error_code;
+  Read(&error_code, &buf);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xv::VideoNotifyEvent>(Xv::VideoNotifyEvent* event_,
+                                     ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& reason = (*event_).reason;
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& drawable = (*event_).drawable;
+  auto& port = (*event_).port;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // reason
+  uint8_t tmp0;
+  Read(&tmp0, &buf);
+  reason = static_cast<Xv::VideoNotifyReason>(tmp0);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // drawable
+  Read(&drawable, &buf);
+
+  // port
+  Read(&port, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+void ReadEvent<Xv::PortNotifyEvent>(Xv::PortNotifyEvent* event_,
+                                    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+
+  auto& sequence = (*event_).sequence;
+  auto& time = (*event_).time;
+  auto& port = (*event_).port;
+  auto& attribute = (*event_).attribute;
+  auto& value = (*event_).value;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // time
+  Read(&time, &buf);
+
+  // port
+  Read(&port, &buf);
+
+  // attribute
+  Read(&attribute, &buf);
+
+  // value
+  Read(&value, &buf);
+
+  DCHECK_LE(buf.offset, 32ul);
+}
+
+Future<Xv::QueryExtensionReply> Xv::QueryExtension(
+    const Xv::QueryExtensionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::QueryExtensionReply>(
+      &buf, "Xv::QueryExtension", false);
+}
+
+Future<Xv::QueryExtensionReply> Xv::QueryExtension() {
+  return Xv::QueryExtension(Xv::QueryExtensionRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::QueryExtensionReply> detail::ReadReply<
+    Xv::QueryExtensionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::QueryExtensionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major = (*reply).major;
+  auto& minor = (*reply).minor;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major
+  Read(&major, &buf);
+
+  // minor
+  Read(&minor, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xv::QueryAdaptorsReply> Xv::QueryAdaptors(
+    const Xv::QueryAdaptorsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& window = request.window;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // window
+  buf.Write(&window);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::QueryAdaptorsReply>(
+      &buf, "Xv::QueryAdaptors", false);
+}
+
+Future<Xv::QueryAdaptorsReply> Xv::QueryAdaptors(const Window& window) {
+  return Xv::QueryAdaptors(Xv::QueryAdaptorsRequest{window});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::QueryAdaptorsReply> detail::ReadReply<
+    Xv::QueryAdaptorsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::QueryAdaptorsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t num_adaptors{};
+  auto& info = (*reply).info;
+  size_t info_len = info.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_adaptors
+  Read(&num_adaptors, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // info
+  info.resize(num_adaptors);
+  for (auto& info_elem : info) {
+    // info_elem
+    {
+      auto& base_id = info_elem.base_id;
+      uint16_t name_size{};
+      auto& num_ports = info_elem.num_ports;
+      uint16_t num_formats{};
+      auto& type = info_elem.type;
+      auto& name = info_elem.name;
+      size_t name_len = name.size();
+      auto& formats = info_elem.formats;
+      size_t formats_len = formats.size();
+
+      // base_id
+      Read(&base_id, &buf);
+
+      // name_size
+      Read(&name_size, &buf);
+
+      // num_ports
+      Read(&num_ports, &buf);
+
+      // num_formats
+      Read(&num_formats, &buf);
+
+      // type
+      uint8_t tmp1;
+      Read(&tmp1, &buf);
+      type = static_cast<Xv::Type>(tmp1);
+
+      // pad0
+      Pad(&buf, 1);
+
+      // name
+      name.resize(name_size);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+
+      // pad1
+      Align(&buf, 4);
+
+      // formats
+      formats.resize(num_formats);
+      for (auto& formats_elem : formats) {
+        // formats_elem
+        {
+          auto& visual = formats_elem.visual;
+          auto& depth = formats_elem.depth;
+
+          // visual
+          Read(&visual, &buf);
+
+          // depth
+          Read(&depth, &buf);
+
+          // pad0
+          Pad(&buf, 3);
+        }
+      }
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xv::QueryEncodingsReply> Xv::QueryEncodings(
+    const Xv::QueryEncodingsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::QueryEncodingsReply>(
+      &buf, "Xv::QueryEncodings", false);
+}
+
+Future<Xv::QueryEncodingsReply> Xv::QueryEncodings(const Port& port) {
+  return Xv::QueryEncodings(Xv::QueryEncodingsRequest{port});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::QueryEncodingsReply> detail::ReadReply<
+    Xv::QueryEncodingsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::QueryEncodingsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint16_t num_encodings{};
+  auto& info = (*reply).info;
+  size_t info_len = info.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_encodings
+  Read(&num_encodings, &buf);
+
+  // pad1
+  Pad(&buf, 22);
+
+  // info
+  info.resize(num_encodings);
+  for (auto& info_elem : info) {
+    // info_elem
+    {
+      auto& encoding = info_elem.encoding;
+      uint16_t name_size{};
+      auto& width = info_elem.width;
+      auto& height = info_elem.height;
+      auto& rate = info_elem.rate;
+      auto& name = info_elem.name;
+      size_t name_len = name.size();
+
+      // encoding
+      Read(&encoding, &buf);
+
+      // name_size
+      Read(&name_size, &buf);
+
+      // width
+      Read(&width, &buf);
+
+      // height
+      Read(&height, &buf);
+
+      // pad0
+      Pad(&buf, 2);
+
+      // rate
+      {
+        auto& numerator = rate.numerator;
+        auto& denominator = rate.denominator;
+
+        // numerator
+        Read(&numerator, &buf);
+
+        // denominator
+        Read(&denominator, &buf);
+      }
+
+      // name
+      name.resize(name_size);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+
+      // pad1
+      Align(&buf, 4);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xv::GrabPortReply> Xv::GrabPort(const Xv::GrabPortRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::GrabPortReply>(&buf, "Xv::GrabPort",
+                                                     false);
+}
+
+Future<Xv::GrabPortReply> Xv::GrabPort(const Port& port, const Time& time) {
+  return Xv::GrabPort(Xv::GrabPortRequest{port, time});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::GrabPortReply> detail::ReadReply<Xv::GrabPortReply>(
+    ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::GrabPortReply>();
+
+  auto& result = (*reply).result;
+  auto& sequence = (*reply).sequence;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // result
+  uint8_t tmp2;
+  Read(&tmp2, &buf);
+  result = static_cast<Xv::GrabPortStatus>(tmp2);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xv::UngrabPort(const Xv::UngrabPortRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& time = request.time;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // time
+  buf.Write(&time);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::UngrabPort", false);
+}
+
+Future<void> Xv::UngrabPort(const Port& port, const Time& time) {
+  return Xv::UngrabPort(Xv::UngrabPortRequest{port, time});
+}
+
+Future<void> Xv::PutVideo(const Xv::PutVideoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& vid_x = request.vid_x;
+  auto& vid_y = request.vid_y;
+  auto& vid_w = request.vid_w;
+  auto& vid_h = request.vid_h;
+  auto& drw_x = request.drw_x;
+  auto& drw_y = request.drw_y;
+  auto& drw_w = request.drw_w;
+  auto& drw_h = request.drw_h;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // vid_x
+  buf.Write(&vid_x);
+
+  // vid_y
+  buf.Write(&vid_y);
+
+  // vid_w
+  buf.Write(&vid_w);
+
+  // vid_h
+  buf.Write(&vid_h);
+
+  // drw_x
+  buf.Write(&drw_x);
+
+  // drw_y
+  buf.Write(&drw_y);
+
+  // drw_w
+  buf.Write(&drw_w);
+
+  // drw_h
+  buf.Write(&drw_h);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::PutVideo", false);
+}
+
+Future<void> Xv::PutVideo(const Port& port,
+                          const Drawable& drawable,
+                          const GraphicsContext& gc,
+                          const int16_t& vid_x,
+                          const int16_t& vid_y,
+                          const uint16_t& vid_w,
+                          const uint16_t& vid_h,
+                          const int16_t& drw_x,
+                          const int16_t& drw_y,
+                          const uint16_t& drw_w,
+                          const uint16_t& drw_h) {
+  return Xv::PutVideo(Xv::PutVideoRequest{port, drawable, gc, vid_x, vid_y,
+                                          vid_w, vid_h, drw_x, drw_y, drw_w,
+                                          drw_h});
+}
+
+Future<void> Xv::PutStill(const Xv::PutStillRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& vid_x = request.vid_x;
+  auto& vid_y = request.vid_y;
+  auto& vid_w = request.vid_w;
+  auto& vid_h = request.vid_h;
+  auto& drw_x = request.drw_x;
+  auto& drw_y = request.drw_y;
+  auto& drw_w = request.drw_w;
+  auto& drw_h = request.drw_h;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // vid_x
+  buf.Write(&vid_x);
+
+  // vid_y
+  buf.Write(&vid_y);
+
+  // vid_w
+  buf.Write(&vid_w);
+
+  // vid_h
+  buf.Write(&vid_h);
+
+  // drw_x
+  buf.Write(&drw_x);
+
+  // drw_y
+  buf.Write(&drw_y);
+
+  // drw_w
+  buf.Write(&drw_w);
+
+  // drw_h
+  buf.Write(&drw_h);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::PutStill", false);
+}
+
+Future<void> Xv::PutStill(const Port& port,
+                          const Drawable& drawable,
+                          const GraphicsContext& gc,
+                          const int16_t& vid_x,
+                          const int16_t& vid_y,
+                          const uint16_t& vid_w,
+                          const uint16_t& vid_h,
+                          const int16_t& drw_x,
+                          const int16_t& drw_y,
+                          const uint16_t& drw_w,
+                          const uint16_t& drw_h) {
+  return Xv::PutStill(Xv::PutStillRequest{port, drawable, gc, vid_x, vid_y,
+                                          vid_w, vid_h, drw_x, drw_y, drw_w,
+                                          drw_h});
+}
+
+Future<void> Xv::GetVideo(const Xv::GetVideoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& vid_x = request.vid_x;
+  auto& vid_y = request.vid_y;
+  auto& vid_w = request.vid_w;
+  auto& vid_h = request.vid_h;
+  auto& drw_x = request.drw_x;
+  auto& drw_y = request.drw_y;
+  auto& drw_w = request.drw_w;
+  auto& drw_h = request.drw_h;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // vid_x
+  buf.Write(&vid_x);
+
+  // vid_y
+  buf.Write(&vid_y);
+
+  // vid_w
+  buf.Write(&vid_w);
+
+  // vid_h
+  buf.Write(&vid_h);
+
+  // drw_x
+  buf.Write(&drw_x);
+
+  // drw_y
+  buf.Write(&drw_y);
+
+  // drw_w
+  buf.Write(&drw_w);
+
+  // drw_h
+  buf.Write(&drw_h);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::GetVideo", false);
+}
+
+Future<void> Xv::GetVideo(const Port& port,
+                          const Drawable& drawable,
+                          const GraphicsContext& gc,
+                          const int16_t& vid_x,
+                          const int16_t& vid_y,
+                          const uint16_t& vid_w,
+                          const uint16_t& vid_h,
+                          const int16_t& drw_x,
+                          const int16_t& drw_y,
+                          const uint16_t& drw_w,
+                          const uint16_t& drw_h) {
+  return Xv::GetVideo(Xv::GetVideoRequest{port, drawable, gc, vid_x, vid_y,
+                                          vid_w, vid_h, drw_x, drw_y, drw_w,
+                                          drw_h});
+}
+
+Future<void> Xv::GetStill(const Xv::GetStillRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& vid_x = request.vid_x;
+  auto& vid_y = request.vid_y;
+  auto& vid_w = request.vid_w;
+  auto& vid_h = request.vid_h;
+  auto& drw_x = request.drw_x;
+  auto& drw_y = request.drw_y;
+  auto& drw_w = request.drw_w;
+  auto& drw_h = request.drw_h;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // vid_x
+  buf.Write(&vid_x);
+
+  // vid_y
+  buf.Write(&vid_y);
+
+  // vid_w
+  buf.Write(&vid_w);
+
+  // vid_h
+  buf.Write(&vid_h);
+
+  // drw_x
+  buf.Write(&drw_x);
+
+  // drw_y
+  buf.Write(&drw_y);
+
+  // drw_w
+  buf.Write(&drw_w);
+
+  // drw_h
+  buf.Write(&drw_h);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::GetStill", false);
+}
+
+Future<void> Xv::GetStill(const Port& port,
+                          const Drawable& drawable,
+                          const GraphicsContext& gc,
+                          const int16_t& vid_x,
+                          const int16_t& vid_y,
+                          const uint16_t& vid_w,
+                          const uint16_t& vid_h,
+                          const int16_t& drw_x,
+                          const int16_t& drw_y,
+                          const uint16_t& drw_w,
+                          const uint16_t& drw_h) {
+  return Xv::GetStill(Xv::GetStillRequest{port, drawable, gc, vid_x, vid_y,
+                                          vid_w, vid_h, drw_x, drw_y, drw_w,
+                                          drw_h});
+}
+
+Future<void> Xv::StopVideo(const Xv::StopVideoRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& drawable = request.drawable;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 9;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // drawable
+  buf.Write(&drawable);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::StopVideo", false);
+}
+
+Future<void> Xv::StopVideo(const Port& port, const Drawable& drawable) {
+  return Xv::StopVideo(Xv::StopVideoRequest{port, drawable});
+}
+
+Future<void> Xv::SelectVideoNotify(
+    const Xv::SelectVideoNotifyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& drawable = request.drawable;
+  auto& onoff = request.onoff;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 10;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // drawable
+  buf.Write(&drawable);
+
+  // onoff
+  buf.Write(&onoff);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::SelectVideoNotify", false);
+}
+
+Future<void> Xv::SelectVideoNotify(const Drawable& drawable,
+                                   const uint8_t& onoff) {
+  return Xv::SelectVideoNotify(Xv::SelectVideoNotifyRequest{drawable, onoff});
+}
+
+Future<void> Xv::SelectPortNotify(const Xv::SelectPortNotifyRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& onoff = request.onoff;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 11;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // onoff
+  buf.Write(&onoff);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::SelectPortNotify", false);
+}
+
+Future<void> Xv::SelectPortNotify(const Port& port, const uint8_t& onoff) {
+  return Xv::SelectPortNotify(Xv::SelectPortNotifyRequest{port, onoff});
+}
+
+Future<Xv::QueryBestSizeReply> Xv::QueryBestSize(
+    const Xv::QueryBestSizeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& vid_w = request.vid_w;
+  auto& vid_h = request.vid_h;
+  auto& drw_w = request.drw_w;
+  auto& drw_h = request.drw_h;
+  auto& motion = request.motion;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 12;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // vid_w
+  buf.Write(&vid_w);
+
+  // vid_h
+  buf.Write(&vid_h);
+
+  // drw_w
+  buf.Write(&drw_w);
+
+  // drw_h
+  buf.Write(&drw_h);
+
+  // motion
+  buf.Write(&motion);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::QueryBestSizeReply>(
+      &buf, "Xv::QueryBestSize", false);
+}
+
+Future<Xv::QueryBestSizeReply> Xv::QueryBestSize(const Port& port,
+                                                 const uint16_t& vid_w,
+                                                 const uint16_t& vid_h,
+                                                 const uint16_t& drw_w,
+                                                 const uint16_t& drw_h,
+                                                 const uint8_t& motion) {
+  return Xv::QueryBestSize(
+      Xv::QueryBestSizeRequest{port, vid_w, vid_h, drw_w, drw_h, motion});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::QueryBestSizeReply> detail::ReadReply<
+    Xv::QueryBestSizeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::QueryBestSizeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& actual_width = (*reply).actual_width;
+  auto& actual_height = (*reply).actual_height;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // actual_width
+  Read(&actual_width, &buf);
+
+  // actual_height
+  Read(&actual_height, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xv::SetPortAttribute(const Xv::SetPortAttributeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& attribute = request.attribute;
+  auto& value = request.value;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 13;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // attribute
+  buf.Write(&attribute);
+
+  // value
+  buf.Write(&value);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::SetPortAttribute", false);
+}
+
+Future<void> Xv::SetPortAttribute(const Port& port,
+                                  const Atom& attribute,
+                                  const int32_t& value) {
+  return Xv::SetPortAttribute(
+      Xv::SetPortAttributeRequest{port, attribute, value});
+}
+
+Future<Xv::GetPortAttributeReply> Xv::GetPortAttribute(
+    const Xv::GetPortAttributeRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& attribute = request.attribute;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 14;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // attribute
+  buf.Write(&attribute);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::GetPortAttributeReply>(
+      &buf, "Xv::GetPortAttribute", false);
+}
+
+Future<Xv::GetPortAttributeReply> Xv::GetPortAttribute(const Port& port,
+                                                       const Atom& attribute) {
+  return Xv::GetPortAttribute(Xv::GetPortAttributeRequest{port, attribute});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::GetPortAttributeReply> detail::ReadReply<
+    Xv::GetPortAttributeReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::GetPortAttributeReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& value = (*reply).value;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // value
+  Read(&value, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xv::QueryPortAttributesReply> Xv::QueryPortAttributes(
+    const Xv::QueryPortAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 15;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::QueryPortAttributesReply>(
+      &buf, "Xv::QueryPortAttributes", false);
+}
+
+Future<Xv::QueryPortAttributesReply> Xv::QueryPortAttributes(const Port& port) {
+  return Xv::QueryPortAttributes(Xv::QueryPortAttributesRequest{port});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::QueryPortAttributesReply> detail::ReadReply<
+    Xv::QueryPortAttributesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::QueryPortAttributesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_attributes{};
+  auto& text_size = (*reply).text_size;
+  auto& attributes = (*reply).attributes;
+  size_t attributes_len = attributes.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_attributes
+  Read(&num_attributes, &buf);
+
+  // text_size
+  Read(&text_size, &buf);
+
+  // pad1
+  Pad(&buf, 16);
+
+  // attributes
+  attributes.resize(num_attributes);
+  for (auto& attributes_elem : attributes) {
+    // attributes_elem
+    {
+      auto& flags = attributes_elem.flags;
+      auto& min = attributes_elem.min;
+      auto& max = attributes_elem.max;
+      uint32_t size{};
+      auto& name = attributes_elem.name;
+      size_t name_len = name.size();
+
+      // flags
+      uint32_t tmp3;
+      Read(&tmp3, &buf);
+      flags = static_cast<Xv::AttributeFlag>(tmp3);
+
+      // min
+      Read(&min, &buf);
+
+      // max
+      Read(&max, &buf);
+
+      // size
+      Read(&size, &buf);
+
+      // name
+      name.resize(size);
+      for (auto& name_elem : name) {
+        // name_elem
+        Read(&name_elem, &buf);
+      }
+
+      // pad0
+      Align(&buf, 4);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xv::ListImageFormatsReply> Xv::ListImageFormats(
+    const Xv::ListImageFormatsRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 16;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::ListImageFormatsReply>(
+      &buf, "Xv::ListImageFormats", false);
+}
+
+Future<Xv::ListImageFormatsReply> Xv::ListImageFormats(const Port& port) {
+  return Xv::ListImageFormats(Xv::ListImageFormatsRequest{port});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::ListImageFormatsReply> detail::ReadReply<
+    Xv::ListImageFormatsReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::ListImageFormatsReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_formats{};
+  auto& format = (*reply).format;
+  size_t format_len = format.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_formats
+  Read(&num_formats, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // format
+  format.resize(num_formats);
+  for (auto& format_elem : format) {
+    // format_elem
+    {
+      auto& id = format_elem.id;
+      auto& type = format_elem.type;
+      auto& byte_order = format_elem.byte_order;
+      auto& guid = format_elem.guid;
+      size_t guid_len = guid.size();
+      auto& bpp = format_elem.bpp;
+      auto& num_planes = format_elem.num_planes;
+      auto& depth = format_elem.depth;
+      auto& red_mask = format_elem.red_mask;
+      auto& green_mask = format_elem.green_mask;
+      auto& blue_mask = format_elem.blue_mask;
+      auto& format = format_elem.format;
+      auto& y_sample_bits = format_elem.y_sample_bits;
+      auto& u_sample_bits = format_elem.u_sample_bits;
+      auto& v_sample_bits = format_elem.v_sample_bits;
+      auto& vhorz_y_period = format_elem.vhorz_y_period;
+      auto& vhorz_u_period = format_elem.vhorz_u_period;
+      auto& vhorz_v_period = format_elem.vhorz_v_period;
+      auto& vvert_y_period = format_elem.vvert_y_period;
+      auto& vvert_u_period = format_elem.vvert_u_period;
+      auto& vvert_v_period = format_elem.vvert_v_period;
+      auto& vcomp_order = format_elem.vcomp_order;
+      size_t vcomp_order_len = vcomp_order.size();
+      auto& vscanline_order = format_elem.vscanline_order;
+
+      // id
+      Read(&id, &buf);
+
+      // type
+      uint8_t tmp4;
+      Read(&tmp4, &buf);
+      type = static_cast<Xv::ImageFormatInfoType>(tmp4);
+
+      // byte_order
+      uint8_t tmp5;
+      Read(&tmp5, &buf);
+      byte_order = static_cast<ImageOrder>(tmp5);
+
+      // pad0
+      Pad(&buf, 2);
+
+      // guid
+      for (auto& guid_elem : guid) {
+        // guid_elem
+        Read(&guid_elem, &buf);
+      }
+
+      // bpp
+      Read(&bpp, &buf);
+
+      // num_planes
+      Read(&num_planes, &buf);
+
+      // pad1
+      Pad(&buf, 2);
+
+      // depth
+      Read(&depth, &buf);
+
+      // pad2
+      Pad(&buf, 3);
+
+      // red_mask
+      Read(&red_mask, &buf);
+
+      // green_mask
+      Read(&green_mask, &buf);
+
+      // blue_mask
+      Read(&blue_mask, &buf);
+
+      // format
+      uint8_t tmp6;
+      Read(&tmp6, &buf);
+      format = static_cast<Xv::ImageFormatInfoFormat>(tmp6);
+
+      // pad3
+      Pad(&buf, 3);
+
+      // y_sample_bits
+      Read(&y_sample_bits, &buf);
+
+      // u_sample_bits
+      Read(&u_sample_bits, &buf);
+
+      // v_sample_bits
+      Read(&v_sample_bits, &buf);
+
+      // vhorz_y_period
+      Read(&vhorz_y_period, &buf);
+
+      // vhorz_u_period
+      Read(&vhorz_u_period, &buf);
+
+      // vhorz_v_period
+      Read(&vhorz_v_period, &buf);
+
+      // vvert_y_period
+      Read(&vvert_y_period, &buf);
+
+      // vvert_u_period
+      Read(&vvert_u_period, &buf);
+
+      // vvert_v_period
+      Read(&vvert_v_period, &buf);
+
+      // vcomp_order
+      for (auto& vcomp_order_elem : vcomp_order) {
+        // vcomp_order_elem
+        Read(&vcomp_order_elem, &buf);
+      }
+
+      // vscanline_order
+      uint8_t tmp7;
+      Read(&tmp7, &buf);
+      vscanline_order = static_cast<Xv::ScanlineOrder>(tmp7);
+
+      // pad4
+      Pad(&buf, 11);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<Xv::QueryImageAttributesReply> Xv::QueryImageAttributes(
+    const Xv::QueryImageAttributesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& id = request.id;
+  auto& width = request.width;
+  auto& height = request.height;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 17;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // id
+  buf.Write(&id);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<Xv::QueryImageAttributesReply>(
+      &buf, "Xv::QueryImageAttributes", false);
+}
+
+Future<Xv::QueryImageAttributesReply> Xv::QueryImageAttributes(
+    const Port& port,
+    const uint32_t& id,
+    const uint16_t& width,
+    const uint16_t& height) {
+  return Xv::QueryImageAttributes(
+      Xv::QueryImageAttributesRequest{port, id, width, height});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<Xv::QueryImageAttributesReply> detail::ReadReply<
+    Xv::QueryImageAttributesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<Xv::QueryImageAttributesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num_planes{};
+  auto& data_size = (*reply).data_size;
+  auto& width = (*reply).width;
+  auto& height = (*reply).height;
+  auto& pitches = (*reply).pitches;
+  size_t pitches_len = pitches.size();
+  auto& offsets = (*reply).offsets;
+  size_t offsets_len = offsets.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num_planes
+  Read(&num_planes, &buf);
+
+  // data_size
+  Read(&data_size, &buf);
+
+  // width
+  Read(&width, &buf);
+
+  // height
+  Read(&height, &buf);
+
+  // pad1
+  Pad(&buf, 12);
+
+  // pitches
+  pitches.resize(num_planes);
+  for (auto& pitches_elem : pitches) {
+    // pitches_elem
+    Read(&pitches_elem, &buf);
+  }
+
+  // offsets
+  offsets.resize(num_planes);
+  for (auto& offsets_elem : offsets) {
+    // offsets_elem
+    Read(&offsets_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> Xv::PutImage(const Xv::PutImageRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& id = request.id;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& src_w = request.src_w;
+  auto& src_h = request.src_h;
+  auto& drw_x = request.drw_x;
+  auto& drw_y = request.drw_y;
+  auto& drw_w = request.drw_w;
+  auto& drw_h = request.drw_h;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& data = request.data;
+  size_t data_len = data.size();
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 18;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // id
+  buf.Write(&id);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // src_w
+  buf.Write(&src_w);
+
+  // src_h
+  buf.Write(&src_h);
+
+  // drw_x
+  buf.Write(&drw_x);
+
+  // drw_y
+  buf.Write(&drw_y);
+
+  // drw_w
+  buf.Write(&drw_w);
+
+  // drw_h
+  buf.Write(&drw_h);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // data
+  DCHECK_EQ(static_cast<size_t>(data_len), data.size());
+  for (auto& data_elem : data) {
+    // data_elem
+    buf.Write(&data_elem);
+  }
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::PutImage", false);
+}
+
+Future<void> Xv::PutImage(const Port& port,
+                          const Drawable& drawable,
+                          const GraphicsContext& gc,
+                          const uint32_t& id,
+                          const int16_t& src_x,
+                          const int16_t& src_y,
+                          const uint16_t& src_w,
+                          const uint16_t& src_h,
+                          const int16_t& drw_x,
+                          const int16_t& drw_y,
+                          const uint16_t& drw_w,
+                          const uint16_t& drw_h,
+                          const uint16_t& width,
+                          const uint16_t& height,
+                          const std::vector<uint8_t>& data) {
+  return Xv::PutImage(Xv::PutImageRequest{port, drawable, gc, id, src_x, src_y,
+                                          src_w, src_h, drw_x, drw_y, drw_w,
+                                          drw_h, width, height, data});
+}
+
+Future<void> Xv::ShmPutImage(const Xv::ShmPutImageRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port = request.port;
+  auto& drawable = request.drawable;
+  auto& gc = request.gc;
+  auto& shmseg = request.shmseg;
+  auto& id = request.id;
+  auto& offset = request.offset;
+  auto& src_x = request.src_x;
+  auto& src_y = request.src_y;
+  auto& src_w = request.src_w;
+  auto& src_h = request.src_h;
+  auto& drw_x = request.drw_x;
+  auto& drw_y = request.drw_y;
+  auto& drw_w = request.drw_w;
+  auto& drw_h = request.drw_h;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& send_event = request.send_event;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 19;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port
+  buf.Write(&port);
+
+  // drawable
+  buf.Write(&drawable);
+
+  // gc
+  buf.Write(&gc);
+
+  // shmseg
+  buf.Write(&shmseg);
+
+  // id
+  buf.Write(&id);
+
+  // offset
+  buf.Write(&offset);
+
+  // src_x
+  buf.Write(&src_x);
+
+  // src_y
+  buf.Write(&src_y);
+
+  // src_w
+  buf.Write(&src_w);
+
+  // src_h
+  buf.Write(&src_h);
+
+  // drw_x
+  buf.Write(&drw_x);
+
+  // drw_y
+  buf.Write(&drw_y);
+
+  // drw_w
+  buf.Write(&drw_w);
+
+  // drw_h
+  buf.Write(&drw_h);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // send_event
+  buf.Write(&send_event);
+
+  // pad0
+  Pad(&buf, 3);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "Xv::ShmPutImage", false);
+}
+
+Future<void> Xv::ShmPutImage(const Port& port,
+                             const Drawable& drawable,
+                             const GraphicsContext& gc,
+                             const Shm::Seg& shmseg,
+                             const uint32_t& id,
+                             const uint32_t& offset,
+                             const int16_t& src_x,
+                             const int16_t& src_y,
+                             const uint16_t& src_w,
+                             const uint16_t& src_h,
+                             const int16_t& drw_x,
+                             const int16_t& drw_y,
+                             const uint16_t& drw_w,
+                             const uint16_t& drw_h,
+                             const uint16_t& width,
+                             const uint16_t& height,
+                             const uint8_t& send_event) {
+  return Xv::ShmPutImage(Xv::ShmPutImageRequest{
+      port, drawable, gc, shmseg, id, offset, src_x, src_y, src_w, src_h, drw_x,
+      drw_y, drw_w, drw_h, width, height, send_event});
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xv.h b/ui/gfx/x/generated_protos/xv.h
new file mode 100644
index 0000000..c4a89f3
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xv.h
@@ -0,0 +1,779 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XV_H_
+#define UI_GFX_X_GENERATED_PROTOS_XV_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "shm.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) Xv {
+ public:
+  static constexpr unsigned major_version = 2;
+  static constexpr unsigned minor_version = 2;
+
+  Xv(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Port : uint32_t {};
+
+  enum class Encoding : uint32_t {};
+
+  enum class Type : int {
+    InputMask = 1 << 0,
+    OutputMask = 1 << 1,
+    VideoMask = 1 << 2,
+    StillMask = 1 << 3,
+    ImageMask = 1 << 4,
+  };
+
+  enum class ImageFormatInfoType : int {
+    RGB = 0,
+    YUV = 1,
+  };
+
+  enum class ImageFormatInfoFormat : int {
+    Packed = 0,
+    Planar = 1,
+  };
+
+  enum class AttributeFlag : int {
+    Gettable = 1 << 0,
+    Settable = 1 << 1,
+  };
+
+  enum class VideoNotifyReason : int {
+    Started = 0,
+    Stopped = 1,
+    Busy = 2,
+    Preempted = 3,
+    HardError = 4,
+  };
+
+  enum class ScanlineOrder : int {
+    TopToBottom = 0,
+    BottomToTop = 1,
+  };
+
+  enum class GrabPortStatus : int {
+    Success = 0,
+    BadExtension = 1,
+    AlreadyGrabbed = 2,
+    InvalidTime = 3,
+    BadReply = 4,
+    BadAlloc = 5,
+  };
+
+  struct Rational {
+    int32_t numerator{};
+    int32_t denominator{};
+  };
+
+  struct Format {
+    VisualId visual{};
+    uint8_t depth{};
+  };
+
+  struct AdaptorInfo {
+    Port base_id{};
+    uint16_t num_ports{};
+    Type type{};
+    std::string name{};
+    std::vector<Format> formats{};
+  };
+
+  struct EncodingInfo {
+    Encoding encoding{};
+    uint16_t width{};
+    uint16_t height{};
+    Rational rate{};
+    std::string name{};
+  };
+
+  struct Image {
+    uint32_t id{};
+    uint16_t width{};
+    uint16_t height{};
+    std::vector<uint32_t> pitches{};
+    std::vector<uint32_t> offsets{};
+    std::vector<uint8_t> data{};
+  };
+
+  struct AttributeInfo {
+    AttributeFlag flags{};
+    int32_t min{};
+    int32_t max{};
+    std::string name{};
+  };
+
+  struct ImageFormatInfo {
+    uint32_t id{};
+    ImageFormatInfoType type{};
+    ImageOrder byte_order{};
+    std::array<uint8_t, 16> guid{};
+    uint8_t bpp{};
+    uint8_t num_planes{};
+    uint8_t depth{};
+    uint32_t red_mask{};
+    uint32_t green_mask{};
+    uint32_t blue_mask{};
+    ImageFormatInfoFormat format{};
+    uint32_t y_sample_bits{};
+    uint32_t u_sample_bits{};
+    uint32_t v_sample_bits{};
+    uint32_t vhorz_y_period{};
+    uint32_t vhorz_u_period{};
+    uint32_t vhorz_v_period{};
+    uint32_t vvert_y_period{};
+    uint32_t vvert_u_period{};
+    uint32_t vvert_v_period{};
+    std::array<uint8_t, 32> vcomp_order{};
+    ScanlineOrder vscanline_order{};
+  };
+
+  struct BadPortError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadEncodingError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct BadControlError : public x11::Error {
+    uint16_t sequence{};
+
+    std::string ToString() const override;
+  };
+
+  struct VideoNotifyEvent {
+    static constexpr int type_id = 81;
+    static constexpr uint8_t opcode = 0;
+    bool send_event{};
+    VideoNotifyReason reason{};
+    uint16_t sequence{};
+    Time time{};
+    Drawable drawable{};
+    Port port{};
+
+    x11::Window* GetWindow() {
+      return reinterpret_cast<x11::Window*>(&drawable);
+    }
+  };
+
+  struct PortNotifyEvent {
+    static constexpr int type_id = 82;
+    static constexpr uint8_t opcode = 1;
+    bool send_event{};
+    uint16_t sequence{};
+    Time time{};
+    Port port{};
+    Atom attribute{};
+    int32_t value{};
+
+    x11::Window* GetWindow() { return nullptr; }
+  };
+
+  struct QueryExtensionRequest {};
+
+  struct QueryExtensionReply {
+    uint16_t sequence{};
+    uint16_t major{};
+    uint16_t minor{};
+  };
+
+  using QueryExtensionResponse = Response<QueryExtensionReply>;
+
+  Future<QueryExtensionReply> QueryExtension(
+      const QueryExtensionRequest& request);
+
+  Future<QueryExtensionReply> QueryExtension();
+
+  struct QueryAdaptorsRequest {
+    Window window{};
+  };
+
+  struct QueryAdaptorsReply {
+    uint16_t sequence{};
+    std::vector<AdaptorInfo> info{};
+  };
+
+  using QueryAdaptorsResponse = Response<QueryAdaptorsReply>;
+
+  Future<QueryAdaptorsReply> QueryAdaptors(const QueryAdaptorsRequest& request);
+
+  Future<QueryAdaptorsReply> QueryAdaptors(const Window& window = {});
+
+  struct QueryEncodingsRequest {
+    Port port{};
+  };
+
+  struct QueryEncodingsReply {
+    uint16_t sequence{};
+    std::vector<EncodingInfo> info{};
+  };
+
+  using QueryEncodingsResponse = Response<QueryEncodingsReply>;
+
+  Future<QueryEncodingsReply> QueryEncodings(
+      const QueryEncodingsRequest& request);
+
+  Future<QueryEncodingsReply> QueryEncodings(const Port& port = {});
+
+  struct GrabPortRequest {
+    Port port{};
+    Time time{};
+  };
+
+  struct GrabPortReply {
+    GrabPortStatus result{};
+    uint16_t sequence{};
+  };
+
+  using GrabPortResponse = Response<GrabPortReply>;
+
+  Future<GrabPortReply> GrabPort(const GrabPortRequest& request);
+
+  Future<GrabPortReply> GrabPort(const Port& port = {}, const Time& time = {});
+
+  struct UngrabPortRequest {
+    Port port{};
+    Time time{};
+  };
+
+  using UngrabPortResponse = Response<void>;
+
+  Future<void> UngrabPort(const UngrabPortRequest& request);
+
+  Future<void> UngrabPort(const Port& port = {}, const Time& time = {});
+
+  struct PutVideoRequest {
+    Port port{};
+    Drawable drawable{};
+    GraphicsContext gc{};
+    int16_t vid_x{};
+    int16_t vid_y{};
+    uint16_t vid_w{};
+    uint16_t vid_h{};
+    int16_t drw_x{};
+    int16_t drw_y{};
+    uint16_t drw_w{};
+    uint16_t drw_h{};
+  };
+
+  using PutVideoResponse = Response<void>;
+
+  Future<void> PutVideo(const PutVideoRequest& request);
+
+  Future<void> PutVideo(const Port& port = {},
+                        const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const int16_t& vid_x = {},
+                        const int16_t& vid_y = {},
+                        const uint16_t& vid_w = {},
+                        const uint16_t& vid_h = {},
+                        const int16_t& drw_x = {},
+                        const int16_t& drw_y = {},
+                        const uint16_t& drw_w = {},
+                        const uint16_t& drw_h = {});
+
+  struct PutStillRequest {
+    Port port{};
+    Drawable drawable{};
+    GraphicsContext gc{};
+    int16_t vid_x{};
+    int16_t vid_y{};
+    uint16_t vid_w{};
+    uint16_t vid_h{};
+    int16_t drw_x{};
+    int16_t drw_y{};
+    uint16_t drw_w{};
+    uint16_t drw_h{};
+  };
+
+  using PutStillResponse = Response<void>;
+
+  Future<void> PutStill(const PutStillRequest& request);
+
+  Future<void> PutStill(const Port& port = {},
+                        const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const int16_t& vid_x = {},
+                        const int16_t& vid_y = {},
+                        const uint16_t& vid_w = {},
+                        const uint16_t& vid_h = {},
+                        const int16_t& drw_x = {},
+                        const int16_t& drw_y = {},
+                        const uint16_t& drw_w = {},
+                        const uint16_t& drw_h = {});
+
+  struct GetVideoRequest {
+    Port port{};
+    Drawable drawable{};
+    GraphicsContext gc{};
+    int16_t vid_x{};
+    int16_t vid_y{};
+    uint16_t vid_w{};
+    uint16_t vid_h{};
+    int16_t drw_x{};
+    int16_t drw_y{};
+    uint16_t drw_w{};
+    uint16_t drw_h{};
+  };
+
+  using GetVideoResponse = Response<void>;
+
+  Future<void> GetVideo(const GetVideoRequest& request);
+
+  Future<void> GetVideo(const Port& port = {},
+                        const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const int16_t& vid_x = {},
+                        const int16_t& vid_y = {},
+                        const uint16_t& vid_w = {},
+                        const uint16_t& vid_h = {},
+                        const int16_t& drw_x = {},
+                        const int16_t& drw_y = {},
+                        const uint16_t& drw_w = {},
+                        const uint16_t& drw_h = {});
+
+  struct GetStillRequest {
+    Port port{};
+    Drawable drawable{};
+    GraphicsContext gc{};
+    int16_t vid_x{};
+    int16_t vid_y{};
+    uint16_t vid_w{};
+    uint16_t vid_h{};
+    int16_t drw_x{};
+    int16_t drw_y{};
+    uint16_t drw_w{};
+    uint16_t drw_h{};
+  };
+
+  using GetStillResponse = Response<void>;
+
+  Future<void> GetStill(const GetStillRequest& request);
+
+  Future<void> GetStill(const Port& port = {},
+                        const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const int16_t& vid_x = {},
+                        const int16_t& vid_y = {},
+                        const uint16_t& vid_w = {},
+                        const uint16_t& vid_h = {},
+                        const int16_t& drw_x = {},
+                        const int16_t& drw_y = {},
+                        const uint16_t& drw_w = {},
+                        const uint16_t& drw_h = {});
+
+  struct StopVideoRequest {
+    Port port{};
+    Drawable drawable{};
+  };
+
+  using StopVideoResponse = Response<void>;
+
+  Future<void> StopVideo(const StopVideoRequest& request);
+
+  Future<void> StopVideo(const Port& port = {}, const Drawable& drawable = {});
+
+  struct SelectVideoNotifyRequest {
+    Drawable drawable{};
+    uint8_t onoff{};
+  };
+
+  using SelectVideoNotifyResponse = Response<void>;
+
+  Future<void> SelectVideoNotify(const SelectVideoNotifyRequest& request);
+
+  Future<void> SelectVideoNotify(const Drawable& drawable = {},
+                                 const uint8_t& onoff = {});
+
+  struct SelectPortNotifyRequest {
+    Port port{};
+    uint8_t onoff{};
+  };
+
+  using SelectPortNotifyResponse = Response<void>;
+
+  Future<void> SelectPortNotify(const SelectPortNotifyRequest& request);
+
+  Future<void> SelectPortNotify(const Port& port = {},
+                                const uint8_t& onoff = {});
+
+  struct QueryBestSizeRequest {
+    Port port{};
+    uint16_t vid_w{};
+    uint16_t vid_h{};
+    uint16_t drw_w{};
+    uint16_t drw_h{};
+    uint8_t motion{};
+  };
+
+  struct QueryBestSizeReply {
+    uint16_t sequence{};
+    uint16_t actual_width{};
+    uint16_t actual_height{};
+  };
+
+  using QueryBestSizeResponse = Response<QueryBestSizeReply>;
+
+  Future<QueryBestSizeReply> QueryBestSize(const QueryBestSizeRequest& request);
+
+  Future<QueryBestSizeReply> QueryBestSize(const Port& port = {},
+                                           const uint16_t& vid_w = {},
+                                           const uint16_t& vid_h = {},
+                                           const uint16_t& drw_w = {},
+                                           const uint16_t& drw_h = {},
+                                           const uint8_t& motion = {});
+
+  struct SetPortAttributeRequest {
+    Port port{};
+    Atom attribute{};
+    int32_t value{};
+  };
+
+  using SetPortAttributeResponse = Response<void>;
+
+  Future<void> SetPortAttribute(const SetPortAttributeRequest& request);
+
+  Future<void> SetPortAttribute(const Port& port = {},
+                                const Atom& attribute = {},
+                                const int32_t& value = {});
+
+  struct GetPortAttributeRequest {
+    Port port{};
+    Atom attribute{};
+  };
+
+  struct GetPortAttributeReply {
+    uint16_t sequence{};
+    int32_t value{};
+  };
+
+  using GetPortAttributeResponse = Response<GetPortAttributeReply>;
+
+  Future<GetPortAttributeReply> GetPortAttribute(
+      const GetPortAttributeRequest& request);
+
+  Future<GetPortAttributeReply> GetPortAttribute(const Port& port = {},
+                                                 const Atom& attribute = {});
+
+  struct QueryPortAttributesRequest {
+    Port port{};
+  };
+
+  struct QueryPortAttributesReply {
+    uint16_t sequence{};
+    uint32_t text_size{};
+    std::vector<AttributeInfo> attributes{};
+  };
+
+  using QueryPortAttributesResponse = Response<QueryPortAttributesReply>;
+
+  Future<QueryPortAttributesReply> QueryPortAttributes(
+      const QueryPortAttributesRequest& request);
+
+  Future<QueryPortAttributesReply> QueryPortAttributes(const Port& port = {});
+
+  struct ListImageFormatsRequest {
+    Port port{};
+  };
+
+  struct ListImageFormatsReply {
+    uint16_t sequence{};
+    std::vector<ImageFormatInfo> format{};
+  };
+
+  using ListImageFormatsResponse = Response<ListImageFormatsReply>;
+
+  Future<ListImageFormatsReply> ListImageFormats(
+      const ListImageFormatsRequest& request);
+
+  Future<ListImageFormatsReply> ListImageFormats(const Port& port = {});
+
+  struct QueryImageAttributesRequest {
+    Port port{};
+    uint32_t id{};
+    uint16_t width{};
+    uint16_t height{};
+  };
+
+  struct QueryImageAttributesReply {
+    uint16_t sequence{};
+    uint32_t data_size{};
+    uint16_t width{};
+    uint16_t height{};
+    std::vector<uint32_t> pitches{};
+    std::vector<uint32_t> offsets{};
+  };
+
+  using QueryImageAttributesResponse = Response<QueryImageAttributesReply>;
+
+  Future<QueryImageAttributesReply> QueryImageAttributes(
+      const QueryImageAttributesRequest& request);
+
+  Future<QueryImageAttributesReply> QueryImageAttributes(
+      const Port& port = {},
+      const uint32_t& id = {},
+      const uint16_t& width = {},
+      const uint16_t& height = {});
+
+  struct PutImageRequest {
+    Port port{};
+    Drawable drawable{};
+    GraphicsContext gc{};
+    uint32_t id{};
+    int16_t src_x{};
+    int16_t src_y{};
+    uint16_t src_w{};
+    uint16_t src_h{};
+    int16_t drw_x{};
+    int16_t drw_y{};
+    uint16_t drw_w{};
+    uint16_t drw_h{};
+    uint16_t width{};
+    uint16_t height{};
+    std::vector<uint8_t> data{};
+  };
+
+  using PutImageResponse = Response<void>;
+
+  Future<void> PutImage(const PutImageRequest& request);
+
+  Future<void> PutImage(const Port& port = {},
+                        const Drawable& drawable = {},
+                        const GraphicsContext& gc = {},
+                        const uint32_t& id = {},
+                        const int16_t& src_x = {},
+                        const int16_t& src_y = {},
+                        const uint16_t& src_w = {},
+                        const uint16_t& src_h = {},
+                        const int16_t& drw_x = {},
+                        const int16_t& drw_y = {},
+                        const uint16_t& drw_w = {},
+                        const uint16_t& drw_h = {},
+                        const uint16_t& width = {},
+                        const uint16_t& height = {},
+                        const std::vector<uint8_t>& data = {});
+
+  struct ShmPutImageRequest {
+    Port port{};
+    Drawable drawable{};
+    GraphicsContext gc{};
+    Shm::Seg shmseg{};
+    uint32_t id{};
+    uint32_t offset{};
+    int16_t src_x{};
+    int16_t src_y{};
+    uint16_t src_w{};
+    uint16_t src_h{};
+    int16_t drw_x{};
+    int16_t drw_y{};
+    uint16_t drw_w{};
+    uint16_t drw_h{};
+    uint16_t width{};
+    uint16_t height{};
+    uint8_t send_event{};
+  };
+
+  using ShmPutImageResponse = Response<void>;
+
+  Future<void> ShmPutImage(const ShmPutImageRequest& request);
+
+  Future<void> ShmPutImage(const Port& port = {},
+                           const Drawable& drawable = {},
+                           const GraphicsContext& gc = {},
+                           const Shm::Seg& shmseg = {},
+                           const uint32_t& id = {},
+                           const uint32_t& offset = {},
+                           const int16_t& src_x = {},
+                           const int16_t& src_y = {},
+                           const uint16_t& src_w = {},
+                           const uint16_t& src_h = {},
+                           const int16_t& drw_x = {},
+                           const int16_t& drw_y = {},
+                           const uint16_t& drw_w = {},
+                           const uint16_t& drw_h = {},
+                           const uint16_t& width = {},
+                           const uint16_t& height = {},
+                           const uint8_t& send_event = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+inline constexpr x11::Xv::Type operator|(x11::Xv::Type l, x11::Xv::Type r) {
+  using T = std::underlying_type_t<x11::Xv::Type>;
+  return static_cast<x11::Xv::Type>(static_cast<T>(l) | static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::Type operator&(x11::Xv::Type l, x11::Xv::Type r) {
+  using T = std::underlying_type_t<x11::Xv::Type>;
+  return static_cast<x11::Xv::Type>(static_cast<T>(l) & static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::ImageFormatInfoType operator|(
+    x11::Xv::ImageFormatInfoType l,
+    x11::Xv::ImageFormatInfoType r) {
+  using T = std::underlying_type_t<x11::Xv::ImageFormatInfoType>;
+  return static_cast<x11::Xv::ImageFormatInfoType>(static_cast<T>(l) |
+                                                   static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::ImageFormatInfoType operator&(
+    x11::Xv::ImageFormatInfoType l,
+    x11::Xv::ImageFormatInfoType r) {
+  using T = std::underlying_type_t<x11::Xv::ImageFormatInfoType>;
+  return static_cast<x11::Xv::ImageFormatInfoType>(static_cast<T>(l) &
+                                                   static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::ImageFormatInfoFormat operator|(
+    x11::Xv::ImageFormatInfoFormat l,
+    x11::Xv::ImageFormatInfoFormat r) {
+  using T = std::underlying_type_t<x11::Xv::ImageFormatInfoFormat>;
+  return static_cast<x11::Xv::ImageFormatInfoFormat>(static_cast<T>(l) |
+                                                     static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::ImageFormatInfoFormat operator&(
+    x11::Xv::ImageFormatInfoFormat l,
+    x11::Xv::ImageFormatInfoFormat r) {
+  using T = std::underlying_type_t<x11::Xv::ImageFormatInfoFormat>;
+  return static_cast<x11::Xv::ImageFormatInfoFormat>(static_cast<T>(l) &
+                                                     static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::AttributeFlag operator|(x11::Xv::AttributeFlag l,
+                                                  x11::Xv::AttributeFlag r) {
+  using T = std::underlying_type_t<x11::Xv::AttributeFlag>;
+  return static_cast<x11::Xv::AttributeFlag>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::AttributeFlag operator&(x11::Xv::AttributeFlag l,
+                                                  x11::Xv::AttributeFlag r) {
+  using T = std::underlying_type_t<x11::Xv::AttributeFlag>;
+  return static_cast<x11::Xv::AttributeFlag>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::VideoNotifyReason operator|(
+    x11::Xv::VideoNotifyReason l,
+    x11::Xv::VideoNotifyReason r) {
+  using T = std::underlying_type_t<x11::Xv::VideoNotifyReason>;
+  return static_cast<x11::Xv::VideoNotifyReason>(static_cast<T>(l) |
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::VideoNotifyReason operator&(
+    x11::Xv::VideoNotifyReason l,
+    x11::Xv::VideoNotifyReason r) {
+  using T = std::underlying_type_t<x11::Xv::VideoNotifyReason>;
+  return static_cast<x11::Xv::VideoNotifyReason>(static_cast<T>(l) &
+                                                 static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::ScanlineOrder operator|(x11::Xv::ScanlineOrder l,
+                                                  x11::Xv::ScanlineOrder r) {
+  using T = std::underlying_type_t<x11::Xv::ScanlineOrder>;
+  return static_cast<x11::Xv::ScanlineOrder>(static_cast<T>(l) |
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::ScanlineOrder operator&(x11::Xv::ScanlineOrder l,
+                                                  x11::Xv::ScanlineOrder r) {
+  using T = std::underlying_type_t<x11::Xv::ScanlineOrder>;
+  return static_cast<x11::Xv::ScanlineOrder>(static_cast<T>(l) &
+                                             static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::GrabPortStatus operator|(x11::Xv::GrabPortStatus l,
+                                                   x11::Xv::GrabPortStatus r) {
+  using T = std::underlying_type_t<x11::Xv::GrabPortStatus>;
+  return static_cast<x11::Xv::GrabPortStatus>(static_cast<T>(l) |
+                                              static_cast<T>(r));
+}
+
+inline constexpr x11::Xv::GrabPortStatus operator&(x11::Xv::GrabPortStatus l,
+                                                   x11::Xv::GrabPortStatus r) {
+  using T = std::underlying_type_t<x11::Xv::GrabPortStatus>;
+  return static_cast<x11::Xv::GrabPortStatus>(static_cast<T>(l) &
+                                              static_cast<T>(r));
+}
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XV_H_
diff --git a/ui/gfx/x/generated_protos/xvmc.cc b/ui/gfx/x/generated_protos/xvmc.cc
new file mode 100644
index 0000000..98fbbb5
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xvmc.cc
@@ -0,0 +1,857 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#include "xvmc.h"
+
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+XvMC::XvMC(Connection* connection, const x11::QueryExtensionReply& info)
+    : connection_(connection), info_(info) {}
+
+Future<XvMC::QueryVersionReply> XvMC::QueryVersion(
+    const XvMC::QueryVersionRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 0;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XvMC::QueryVersionReply>(
+      &buf, "XvMC::QueryVersion", false);
+}
+
+Future<XvMC::QueryVersionReply> XvMC::QueryVersion() {
+  return XvMC::QueryVersion(XvMC::QueryVersionRequest{});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XvMC::QueryVersionReply> detail::ReadReply<
+    XvMC::QueryVersionReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XvMC::QueryVersionReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& major = (*reply).major;
+  auto& minor = (*reply).minor;
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // major
+  Read(&major, &buf);
+
+  // minor
+  Read(&minor, &buf);
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XvMC::ListSurfaceTypesReply> XvMC::ListSurfaceTypes(
+    const XvMC::ListSurfaceTypesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port_id = request.port_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 1;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port_id
+  buf.Write(&port_id);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XvMC::ListSurfaceTypesReply>(
+      &buf, "XvMC::ListSurfaceTypes", false);
+}
+
+Future<XvMC::ListSurfaceTypesReply> XvMC::ListSurfaceTypes(
+    const Xv::Port& port_id) {
+  return XvMC::ListSurfaceTypes(XvMC::ListSurfaceTypesRequest{port_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XvMC::ListSurfaceTypesReply> detail::ReadReply<
+    XvMC::ListSurfaceTypesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XvMC::ListSurfaceTypesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num{};
+  auto& surfaces = (*reply).surfaces;
+  size_t surfaces_len = surfaces.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num
+  Read(&num, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // surfaces
+  surfaces.resize(num);
+  for (auto& surfaces_elem : surfaces) {
+    // surfaces_elem
+    {
+      auto& id = surfaces_elem.id;
+      auto& chroma_format = surfaces_elem.chroma_format;
+      auto& pad0 = surfaces_elem.pad0;
+      auto& max_width = surfaces_elem.max_width;
+      auto& max_height = surfaces_elem.max_height;
+      auto& subpicture_max_width = surfaces_elem.subpicture_max_width;
+      auto& subpicture_max_height = surfaces_elem.subpicture_max_height;
+      auto& mc_type = surfaces_elem.mc_type;
+      auto& flags = surfaces_elem.flags;
+
+      // id
+      Read(&id, &buf);
+
+      // chroma_format
+      Read(&chroma_format, &buf);
+
+      // pad0
+      Read(&pad0, &buf);
+
+      // max_width
+      Read(&max_width, &buf);
+
+      // max_height
+      Read(&max_height, &buf);
+
+      // subpicture_max_width
+      Read(&subpicture_max_width, &buf);
+
+      // subpicture_max_height
+      Read(&subpicture_max_height, &buf);
+
+      // mc_type
+      Read(&mc_type, &buf);
+
+      // flags
+      Read(&flags, &buf);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<XvMC::CreateContextReply> XvMC::CreateContext(
+    const XvMC::CreateContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_id = request.context_id;
+  auto& port_id = request.port_id;
+  auto& surface_id = request.surface_id;
+  auto& width = request.width;
+  auto& height = request.height;
+  auto& flags = request.flags;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 2;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_id
+  buf.Write(&context_id);
+
+  // port_id
+  buf.Write(&port_id);
+
+  // surface_id
+  buf.Write(&surface_id);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  // flags
+  buf.Write(&flags);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XvMC::CreateContextReply>(
+      &buf, "XvMC::CreateContext", false);
+}
+
+Future<XvMC::CreateContextReply> XvMC::CreateContext(const Context& context_id,
+                                                     const Xv::Port& port_id,
+                                                     const Surface& surface_id,
+                                                     const uint16_t& width,
+                                                     const uint16_t& height,
+                                                     const uint32_t& flags) {
+  return XvMC::CreateContext(XvMC::CreateContextRequest{
+      context_id, port_id, surface_id, width, height, flags});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XvMC::CreateContextReply> detail::ReadReply<
+    XvMC::CreateContextReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XvMC::CreateContextReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width_actual = (*reply).width_actual;
+  auto& height_actual = (*reply).height_actual;
+  auto& flags_return = (*reply).flags_return;
+  auto& priv_data = (*reply).priv_data;
+  size_t priv_data_len = priv_data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // width_actual
+  Read(&width_actual, &buf);
+
+  // height_actual
+  Read(&height_actual, &buf);
+
+  // flags_return
+  Read(&flags_return, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // priv_data
+  priv_data.resize(length);
+  for (auto& priv_data_elem : priv_data) {
+    // priv_data_elem
+    Read(&priv_data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XvMC::DestroyContext(const XvMC::DestroyContextRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& context_id = request.context_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 3;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // context_id
+  buf.Write(&context_id);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XvMC::DestroyContext", false);
+}
+
+Future<void> XvMC::DestroyContext(const Context& context_id) {
+  return XvMC::DestroyContext(XvMC::DestroyContextRequest{context_id});
+}
+
+Future<XvMC::CreateSurfaceReply> XvMC::CreateSurface(
+    const XvMC::CreateSurfaceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& surface_id = request.surface_id;
+  auto& context_id = request.context_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 4;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // surface_id
+  buf.Write(&surface_id);
+
+  // context_id
+  buf.Write(&context_id);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XvMC::CreateSurfaceReply>(
+      &buf, "XvMC::CreateSurface", false);
+}
+
+Future<XvMC::CreateSurfaceReply> XvMC::CreateSurface(
+    const Surface& surface_id,
+    const Context& context_id) {
+  return XvMC::CreateSurface(
+      XvMC::CreateSurfaceRequest{surface_id, context_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XvMC::CreateSurfaceReply> detail::ReadReply<
+    XvMC::CreateSurfaceReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XvMC::CreateSurfaceReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& priv_data = (*reply).priv_data;
+  size_t priv_data_len = priv_data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // pad1
+  Pad(&buf, 24);
+
+  // priv_data
+  priv_data.resize(length);
+  for (auto& priv_data_elem : priv_data) {
+    // priv_data_elem
+    Read(&priv_data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XvMC::DestroySurface(const XvMC::DestroySurfaceRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& surface_id = request.surface_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 5;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // surface_id
+  buf.Write(&surface_id);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XvMC::DestroySurface", false);
+}
+
+Future<void> XvMC::DestroySurface(const Surface& surface_id) {
+  return XvMC::DestroySurface(XvMC::DestroySurfaceRequest{surface_id});
+}
+
+Future<XvMC::CreateSubpictureReply> XvMC::CreateSubpicture(
+    const XvMC::CreateSubpictureRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& subpicture_id = request.subpicture_id;
+  auto& context = request.context;
+  auto& xvimage_id = request.xvimage_id;
+  auto& width = request.width;
+  auto& height = request.height;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 6;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // subpicture_id
+  buf.Write(&subpicture_id);
+
+  // context
+  buf.Write(&context);
+
+  // xvimage_id
+  buf.Write(&xvimage_id);
+
+  // width
+  buf.Write(&width);
+
+  // height
+  buf.Write(&height);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XvMC::CreateSubpictureReply>(
+      &buf, "XvMC::CreateSubpicture", false);
+}
+
+Future<XvMC::CreateSubpictureReply> XvMC::CreateSubpicture(
+    const SubPicture& subpicture_id,
+    const Context& context,
+    const uint32_t& xvimage_id,
+    const uint16_t& width,
+    const uint16_t& height) {
+  return XvMC::CreateSubpicture(XvMC::CreateSubpictureRequest{
+      subpicture_id, context, xvimage_id, width, height});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XvMC::CreateSubpictureReply> detail::ReadReply<
+    XvMC::CreateSubpictureReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XvMC::CreateSubpictureReply>();
+
+  auto& sequence = (*reply).sequence;
+  auto& width_actual = (*reply).width_actual;
+  auto& height_actual = (*reply).height_actual;
+  auto& num_palette_entries = (*reply).num_palette_entries;
+  auto& entry_bytes = (*reply).entry_bytes;
+  auto& component_order = (*reply).component_order;
+  size_t component_order_len = component_order.size();
+  auto& priv_data = (*reply).priv_data;
+  size_t priv_data_len = priv_data.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // width_actual
+  Read(&width_actual, &buf);
+
+  // height_actual
+  Read(&height_actual, &buf);
+
+  // num_palette_entries
+  Read(&num_palette_entries, &buf);
+
+  // entry_bytes
+  Read(&entry_bytes, &buf);
+
+  // component_order
+  for (auto& component_order_elem : component_order) {
+    // component_order_elem
+    Read(&component_order_elem, &buf);
+  }
+
+  // pad1
+  Pad(&buf, 12);
+
+  // priv_data
+  priv_data.resize(length);
+  for (auto& priv_data_elem : priv_data) {
+    // priv_data_elem
+    Read(&priv_data_elem, &buf);
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+Future<void> XvMC::DestroySubpicture(
+    const XvMC::DestroySubpictureRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& subpicture_id = request.subpicture_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 7;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // subpicture_id
+  buf.Write(&subpicture_id);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<void>(&buf, "XvMC::DestroySubpicture", false);
+}
+
+Future<void> XvMC::DestroySubpicture(const SubPicture& subpicture_id) {
+  return XvMC::DestroySubpicture(XvMC::DestroySubpictureRequest{subpicture_id});
+}
+
+Future<XvMC::ListSubpictureTypesReply> XvMC::ListSubpictureTypes(
+    const XvMC::ListSubpictureTypesRequest& request) {
+  if (!connection_->Ready() || !present())
+    return {};
+
+  WriteBuffer buf;
+
+  auto& port_id = request.port_id;
+  auto& surface_id = request.surface_id;
+
+  // major_opcode
+  uint8_t major_opcode = info_.major_opcode;
+  buf.Write(&major_opcode);
+
+  // minor_opcode
+  uint8_t minor_opcode = 8;
+  buf.Write(&minor_opcode);
+
+  // length
+  // Caller fills in length for writes.
+  Pad(&buf, sizeof(uint16_t));
+
+  // port_id
+  buf.Write(&port_id);
+
+  // surface_id
+  buf.Write(&surface_id);
+
+  Align(&buf, 4);
+
+  return connection_->SendRequest<XvMC::ListSubpictureTypesReply>(
+      &buf, "XvMC::ListSubpictureTypes", false);
+}
+
+Future<XvMC::ListSubpictureTypesReply> XvMC::ListSubpictureTypes(
+    const Xv::Port& port_id,
+    const Surface& surface_id) {
+  return XvMC::ListSubpictureTypes(
+      XvMC::ListSubpictureTypesRequest{port_id, surface_id});
+}
+
+template <>
+COMPONENT_EXPORT(X11)
+std::unique_ptr<XvMC::ListSubpictureTypesReply> detail::ReadReply<
+    XvMC::ListSubpictureTypesReply>(ReadBuffer* buffer) {
+  auto& buf = *buffer;
+  auto reply = std::make_unique<XvMC::ListSubpictureTypesReply>();
+
+  auto& sequence = (*reply).sequence;
+  uint32_t num{};
+  auto& types = (*reply).types;
+  size_t types_len = types.size();
+
+  // response_type
+  uint8_t response_type;
+  Read(&response_type, &buf);
+
+  // pad0
+  Pad(&buf, 1);
+
+  // sequence
+  Read(&sequence, &buf);
+
+  // length
+  uint32_t length;
+  Read(&length, &buf);
+
+  // num
+  Read(&num, &buf);
+
+  // pad1
+  Pad(&buf, 20);
+
+  // types
+  types.resize(num);
+  for (auto& types_elem : types) {
+    // types_elem
+    {
+      auto& id = types_elem.id;
+      auto& type = types_elem.type;
+      auto& byte_order = types_elem.byte_order;
+      auto& guid = types_elem.guid;
+      size_t guid_len = guid.size();
+      auto& bpp = types_elem.bpp;
+      auto& num_planes = types_elem.num_planes;
+      auto& depth = types_elem.depth;
+      auto& red_mask = types_elem.red_mask;
+      auto& green_mask = types_elem.green_mask;
+      auto& blue_mask = types_elem.blue_mask;
+      auto& format = types_elem.format;
+      auto& y_sample_bits = types_elem.y_sample_bits;
+      auto& u_sample_bits = types_elem.u_sample_bits;
+      auto& v_sample_bits = types_elem.v_sample_bits;
+      auto& vhorz_y_period = types_elem.vhorz_y_period;
+      auto& vhorz_u_period = types_elem.vhorz_u_period;
+      auto& vhorz_v_period = types_elem.vhorz_v_period;
+      auto& vvert_y_period = types_elem.vvert_y_period;
+      auto& vvert_u_period = types_elem.vvert_u_period;
+      auto& vvert_v_period = types_elem.vvert_v_period;
+      auto& vcomp_order = types_elem.vcomp_order;
+      size_t vcomp_order_len = vcomp_order.size();
+      auto& vscanline_order = types_elem.vscanline_order;
+
+      // id
+      Read(&id, &buf);
+
+      // type
+      uint8_t tmp0;
+      Read(&tmp0, &buf);
+      type = static_cast<Xv::ImageFormatInfoType>(tmp0);
+
+      // byte_order
+      uint8_t tmp1;
+      Read(&tmp1, &buf);
+      byte_order = static_cast<ImageOrder>(tmp1);
+
+      // pad0
+      Pad(&buf, 2);
+
+      // guid
+      for (auto& guid_elem : guid) {
+        // guid_elem
+        Read(&guid_elem, &buf);
+      }
+
+      // bpp
+      Read(&bpp, &buf);
+
+      // num_planes
+      Read(&num_planes, &buf);
+
+      // pad1
+      Pad(&buf, 2);
+
+      // depth
+      Read(&depth, &buf);
+
+      // pad2
+      Pad(&buf, 3);
+
+      // red_mask
+      Read(&red_mask, &buf);
+
+      // green_mask
+      Read(&green_mask, &buf);
+
+      // blue_mask
+      Read(&blue_mask, &buf);
+
+      // format
+      uint8_t tmp2;
+      Read(&tmp2, &buf);
+      format = static_cast<Xv::ImageFormatInfoFormat>(tmp2);
+
+      // pad3
+      Pad(&buf, 3);
+
+      // y_sample_bits
+      Read(&y_sample_bits, &buf);
+
+      // u_sample_bits
+      Read(&u_sample_bits, &buf);
+
+      // v_sample_bits
+      Read(&v_sample_bits, &buf);
+
+      // vhorz_y_period
+      Read(&vhorz_y_period, &buf);
+
+      // vhorz_u_period
+      Read(&vhorz_u_period, &buf);
+
+      // vhorz_v_period
+      Read(&vhorz_v_period, &buf);
+
+      // vvert_y_period
+      Read(&vvert_y_period, &buf);
+
+      // vvert_u_period
+      Read(&vvert_u_period, &buf);
+
+      // vvert_v_period
+      Read(&vvert_v_period, &buf);
+
+      // vcomp_order
+      for (auto& vcomp_order_elem : vcomp_order) {
+        // vcomp_order_elem
+        Read(&vcomp_order_elem, &buf);
+      }
+
+      // vscanline_order
+      uint8_t tmp3;
+      Read(&tmp3, &buf);
+      vscanline_order = static_cast<Xv::ScanlineOrder>(tmp3);
+
+      // pad4
+      Pad(&buf, 11);
+    }
+  }
+
+  Align(&buf, 4);
+  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);
+
+  return reply;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/generated_protos/xvmc.h b/ui/gfx/x/generated_protos/xvmc.h
new file mode 100644
index 0000000..b166167
--- /dev/null
+++ b/ui/gfx/x/generated_protos/xvmc.h
@@ -0,0 +1,263 @@
+// Copyright 2021 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.
+
+// This file was automatically generated with:
+// ../../ui/gfx/x/gen_xproto.py \
+//    ../../third_party/xcbproto/src \
+//    gen/ui/gfx/x \
+//    bigreq \
+//    composite \
+//    damage \
+//    dpms \
+//    dri2 \
+//    dri3 \
+//    ge \
+//    glx \
+//    present \
+//    randr \
+//    record \
+//    render \
+//    res \
+//    screensaver \
+//    shape \
+//    shm \
+//    sync \
+//    xc_misc \
+//    xevie \
+//    xf86dri \
+//    xf86vidmode \
+//    xfixes \
+//    xinerama \
+//    xinput \
+//    xkb \
+//    xprint \
+//    xproto \
+//    xselinux \
+//    xtest \
+//    xv \
+//    xvmc
+
+#ifndef UI_GFX_X_GENERATED_PROTOS_XVMC_H_
+#define UI_GFX_X_GENERATED_PROTOS_XVMC_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/error.h"
+#include "ui/gfx/x/ref_counted_fd.h"
+#include "xproto.h"
+#include "xv.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename Reply>
+struct Response;
+
+template <typename Reply>
+class Future;
+
+class COMPONENT_EXPORT(X11) XvMC {
+ public:
+  static constexpr unsigned major_version = 1;
+  static constexpr unsigned minor_version = 1;
+
+  XvMC(Connection* connection, const x11::QueryExtensionReply& info);
+
+  uint8_t present() const { return info_.present; }
+  uint8_t major_opcode() const { return info_.major_opcode; }
+  uint8_t first_event() const { return info_.first_event; }
+  uint8_t first_error() const { return info_.first_error; }
+
+  Connection* connection() const { return connection_; }
+
+  enum class Context : uint32_t {};
+
+  enum class Surface : uint32_t {};
+
+  enum class SubPicture : uint32_t {};
+
+  struct SurfaceInfo {
+    Surface id{};
+    uint16_t chroma_format{};
+    uint16_t pad0{};
+    uint16_t max_width{};
+    uint16_t max_height{};
+    uint16_t subpicture_max_width{};
+    uint16_t subpicture_max_height{};
+    uint32_t mc_type{};
+    uint32_t flags{};
+  };
+
+  struct QueryVersionRequest {};
+
+  struct QueryVersionReply {
+    uint16_t sequence{};
+    uint32_t major{};
+    uint32_t minor{};
+  };
+
+  using QueryVersionResponse = Response<QueryVersionReply>;
+
+  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);
+
+  Future<QueryVersionReply> QueryVersion();
+
+  struct ListSurfaceTypesRequest {
+    Xv::Port port_id{};
+  };
+
+  struct ListSurfaceTypesReply {
+    uint16_t sequence{};
+    std::vector<SurfaceInfo> surfaces{};
+  };
+
+  using ListSurfaceTypesResponse = Response<ListSurfaceTypesReply>;
+
+  Future<ListSurfaceTypesReply> ListSurfaceTypes(
+      const ListSurfaceTypesRequest& request);
+
+  Future<ListSurfaceTypesReply> ListSurfaceTypes(const Xv::Port& port_id = {});
+
+  struct CreateContextRequest {
+    Context context_id{};
+    Xv::Port port_id{};
+    Surface surface_id{};
+    uint16_t width{};
+    uint16_t height{};
+    uint32_t flags{};
+  };
+
+  struct CreateContextReply {
+    uint16_t sequence{};
+    uint16_t width_actual{};
+    uint16_t height_actual{};
+    uint32_t flags_return{};
+    std::vector<uint32_t> priv_data{};
+  };
+
+  using CreateContextResponse = Response<CreateContextReply>;
+
+  Future<CreateContextReply> CreateContext(const CreateContextRequest& request);
+
+  Future<CreateContextReply> CreateContext(const Context& context_id = {},
+                                           const Xv::Port& port_id = {},
+                                           const Surface& surface_id = {},
+                                           const uint16_t& width = {},
+                                           const uint16_t& height = {},
+                                           const uint32_t& flags = {});
+
+  struct DestroyContextRequest {
+    Context context_id{};
+  };
+
+  using DestroyContextResponse = Response<void>;
+
+  Future<void> DestroyContext(const DestroyContextRequest& request);
+
+  Future<void> DestroyContext(const Context& context_id = {});
+
+  struct CreateSurfaceRequest {
+    Surface surface_id{};
+    Context context_id{};
+  };
+
+  struct CreateSurfaceReply {
+    uint16_t sequence{};
+    std::vector<uint32_t> priv_data{};
+  };
+
+  using CreateSurfaceResponse = Response<CreateSurfaceReply>;
+
+  Future<CreateSurfaceReply> CreateSurface(const CreateSurfaceRequest& request);
+
+  Future<CreateSurfaceReply> CreateSurface(const Surface& surface_id = {},
+                                           const Context& context_id = {});
+
+  struct DestroySurfaceRequest {
+    Surface surface_id{};
+  };
+
+  using DestroySurfaceResponse = Response<void>;
+
+  Future<void> DestroySurface(const DestroySurfaceRequest& request);
+
+  Future<void> DestroySurface(const Surface& surface_id = {});
+
+  struct CreateSubpictureRequest {
+    SubPicture subpicture_id{};
+    Context context{};
+    uint32_t xvimage_id{};
+    uint16_t width{};
+    uint16_t height{};
+  };
+
+  struct CreateSubpictureReply {
+    uint16_t sequence{};
+    uint16_t width_actual{};
+    uint16_t height_actual{};
+    uint16_t num_palette_entries{};
+    uint16_t entry_bytes{};
+    std::array<uint8_t, 4> component_order{};
+    std::vector<uint32_t> priv_data{};
+  };
+
+  using CreateSubpictureResponse = Response<CreateSubpictureReply>;
+
+  Future<CreateSubpictureReply> CreateSubpicture(
+      const CreateSubpictureRequest& request);
+
+  Future<CreateSubpictureReply> CreateSubpicture(
+      const SubPicture& subpicture_id = {},
+      const Context& context = {},
+      const uint32_t& xvimage_id = {},
+      const uint16_t& width = {},
+      const uint16_t& height = {});
+
+  struct DestroySubpictureRequest {
+    SubPicture subpicture_id{};
+  };
+
+  using DestroySubpictureResponse = Response<void>;
+
+  Future<void> DestroySubpicture(const DestroySubpictureRequest& request);
+
+  Future<void> DestroySubpicture(const SubPicture& subpicture_id = {});
+
+  struct ListSubpictureTypesRequest {
+    Xv::Port port_id{};
+    Surface surface_id{};
+  };
+
+  struct ListSubpictureTypesReply {
+    uint16_t sequence{};
+    std::vector<Xv::ImageFormatInfo> types{};
+  };
+
+  using ListSubpictureTypesResponse = Response<ListSubpictureTypesReply>;
+
+  Future<ListSubpictureTypesReply> ListSubpictureTypes(
+      const ListSubpictureTypesRequest& request);
+
+  Future<ListSubpictureTypesReply> ListSubpictureTypes(
+      const Xv::Port& port_id = {},
+      const Surface& surface_id = {});
+
+ private:
+  Connection* const connection_;
+  x11::QueryExtensionReply info_{};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_GENERATED_PROTOS_XVMC_H_
diff --git a/ui/gfx/x/keyboard_state.cc b/ui/gfx/x/keyboard_state.cc
new file mode 100644
index 0000000..147b6c0
--- /dev/null
+++ b/ui/gfx/x/keyboard_state.cc
@@ -0,0 +1,137 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/keyboard_state.h"
+
+#include "base/i18n/case_conversion.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/future.h"
+#include "ui/gfx/x/keysyms/keysyms.h"
+#include "ui/gfx/x/xkb.h"
+#include "ui/gfx/x/xproto.h"
+
+namespace x11 {
+
+namespace {
+
+constexpr KeySym kNoSymbol = static_cast<KeySym>(0);
+
+void ConvertCaseImpl(uint32_t sym, uint32_t* lower, uint32_t* upper);
+
+void ConvertCase(KeySym sym, KeySym* lower, KeySym* upper) {
+  uint32_t lower32;
+  uint32_t upper32;
+  ConvertCaseImpl(static_cast<uint32_t>(sym), &lower32, &upper32);
+  *lower = static_cast<KeySym>(lower32);
+  *upper = static_cast<KeySym>(upper32);
+}
+
+bool IsPublicOrPrivateKeypadKey(KeySym keysym) {
+  auto key = static_cast<uint32_t>(keysym);
+  return (key >= XK_KP_Space && key <= XK_KP_Equal) ||
+         (key >= 0x11000000 && key <= 0x1100FFFF);
+}
+
+int GetXkbGroupFromState(int state) {
+  return (state >> 13) & 0x3;
+}
+
+#include "third_party/libx11/src/KeyBind.c"
+#include "third_party/libx11/src/xkb/XKBBind.c"
+#include "third_party/libxcb-keysyms/keysyms/keysyms.c"
+
+}  // namespace
+
+KeyboardState::KeyboardState() = default;
+
+KeyboardState::~KeyboardState() = default;
+
+// Non-XKB (core protocol) implementation of KeysymToKeycode and
+// KeycodeToKeysym.
+class CoreKeyboardState : public KeyboardState {
+ public:
+  explicit CoreKeyboardState(Connection* connection) : connection_(connection) {
+    UpdateMapping();
+  }
+
+  ~CoreKeyboardState() override = default;
+
+  KeyCode KeysymToKeycode(uint32_t keysym) const override {
+    auto min_keycode = static_cast<uint8_t>(connection_->setup().min_keycode);
+    auto max_keycode = static_cast<uint8_t>(connection_->setup().max_keycode);
+    int count = max_keycode - min_keycode + 1;
+    DCHECK_EQ(count * keyboard_mapping_.keysyms_per_keycode,
+              static_cast<int>(keyboard_mapping_.keysyms.size()));
+    for (size_t i = 0; i < keyboard_mapping_.keysyms.size(); i++) {
+      auto keycode = min_keycode + i / keyboard_mapping_.keysyms_per_keycode;
+      if (keyboard_mapping_.keysyms[i] == static_cast<KeySym>(keysym))
+        return static_cast<KeyCode>(keycode);
+    }
+    return {};
+  }
+
+  uint32_t KeycodeToKeysym(KeyCode keycode, uint32_t modifiers) const override {
+    auto sym = static_cast<uint32_t>(KeycodeToKeysymCoreImpl(
+        keycode, modifiers, connection_, keyboard_mapping_, lock_meaning_,
+        mode_switch_, num_lock_));
+    return sym == XK_VoidSymbol ? 0 : sym;
+  }
+
+ private:
+  void UpdateMapping() override {
+    UpdateMappingImpl(connection_, &keyboard_mapping_, &lock_meaning_,
+                      &mode_switch_, &num_lock_);
+  }
+
+  Connection* const connection_;
+  GetKeyboardMappingReply keyboard_mapping_;
+  uint16_t lock_meaning_ = 0;
+  uint8_t mode_switch_ = 0;
+  uint8_t num_lock_ = 0;
+};
+
+// XKB implementation of KeysymToKeycode and KeycodeToKeysym.
+class XkbKeyboardState : public KeyboardState {
+ public:
+  explicit XkbKeyboardState(Connection* connection) : connection_(connection) {
+    UpdateMapping();
+  }
+
+  ~XkbKeyboardState() override = default;
+
+  KeyCode KeysymToKeycode(uint32_t keysym) const override {
+    int first_keycode = static_cast<int>(map_.firstKeySym);
+    for (int keycode = 0; keycode < map_.nKeySyms; keycode++) {
+      for (auto sym : map_.syms_rtrn->at(keycode).syms) {
+        if (static_cast<uint32_t>(sym) == keysym)
+          return static_cast<KeyCode>(keycode + first_keycode);
+      }
+    }
+    return {};
+  }
+
+  uint32_t KeycodeToKeysym(KeyCode key, uint32_t modifiers) const override {
+    return KeycodeToKeysymXkbImpl(key, modifiers, map_);
+  }
+
+ private:
+  void UpdateMapping() override {
+    auto future = connection_->xkb().GetMap(
+        {static_cast<Xkb::DeviceSpec>(Xkb::Id::UseCoreKbd),
+         Xkb::MapPart::KeyTypes | Xkb::MapPart::KeySyms});
+    if (auto response = future.Sync())
+      map_ = std::move(*response.reply);
+  }
+
+  Connection* const connection_;
+  Xkb::GetMapReply map_;
+};
+
+std::unique_ptr<KeyboardState> CreateKeyboardState(Connection* connection) {
+  if (connection->xkb().present())
+    return std::make_unique<XkbKeyboardState>(connection);
+  return std::make_unique<CoreKeyboardState>(connection);
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/keyboard_state.h b/ui/gfx/x/keyboard_state.h
new file mode 100644
index 0000000..d28fe59
--- /dev/null
+++ b/ui/gfx/x/keyboard_state.h
@@ -0,0 +1,37 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_KEYBOARD_STATE_H_
+#define UI_GFX_X_KEYBOARD_STATE_H_
+
+#include <memory>
+
+#include "ui/gfx/x/xproto.h"
+
+namespace x11 {
+
+class Connection;
+
+// This is an interface used by Connection to manage conversion between keycodes
+// (8 bit values) and keysyms (32 bit values).
+class KeyboardState {
+ public:
+  KeyboardState();
+  virtual ~KeyboardState();
+
+  virtual KeyCode KeysymToKeycode(uint32_t keysym) const = 0;
+  virtual uint32_t KeycodeToKeysym(KeyCode keycode,
+                                   uint32_t modifiers) const = 0;
+
+ private:
+  friend class Connection;
+
+  virtual void UpdateMapping() = 0;
+};
+
+std::unique_ptr<KeyboardState> CreateKeyboardState(Connection* connection);
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_KEYBOARD_STATE_H_
diff --git a/ui/gfx/x/keysyms/BUILD.gn b/ui/gfx/x/keysyms/BUILD.gn
new file mode 100644
index 0000000..7ebb583
--- /dev/null
+++ b/ui/gfx/x/keysyms/BUILD.gn
@@ -0,0 +1,7 @@
+# Copyright 2020 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.
+
+source_set("keysyms") {
+  public = [ "keysyms.h" ]
+}
diff --git a/ui/gfx/x/keysyms/keysyms.h b/ui/gfx/x/keysyms/keysyms.h
new file mode 100644
index 0000000..c43ca1a
--- /dev/null
+++ b/ui/gfx/x/keysyms/keysyms.h
@@ -0,0 +1,12 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_KEYSYMS_KEYSYMS_H_
+#define UI_GFX_X_KEYSYMS_KEYSYMS_H_
+
+#include <cstdint>
+
+#include "third_party/x11proto/keysymdef.h"
+
+#endif  // UI_GFX_X_KEYSYMS_KEYSYMS_H_
diff --git a/ui/gfx/x/property_cache.cc b/ui/gfx/x/property_cache.cc
new file mode 100644
index 0000000..2f318a2
--- /dev/null
+++ b/ui/gfx/x/property_cache.cc
@@ -0,0 +1,90 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/property_cache.h"
+
+#include <limits>
+
+#include "base/check_op.h"
+#include "ui/gfx/x/event.h"
+#include "ui/gfx/x/xproto.h"
+
+namespace x11 {
+
+PropertyCache::PropertyCache(Connection* connection,
+                             Window window,
+                             const std::vector<Atom>& properties)
+    : connection_(connection),
+      window_(window),
+      event_selector_(window_, EventMask::PropertyChange) {
+  connection_->AddEventObserver(this);
+
+  std::vector<std::pair<Atom, PropertyValue>> mem(properties.size());
+  for (size_t i = 0; i < properties.size(); i++) {
+    mem[i].first = properties[i];
+    FetchProperty(properties[i], &mem[i].second);
+  }
+  properties_ = base::flat_map<Atom, PropertyValue>(std::move(mem));
+}
+
+PropertyCache::~PropertyCache() {
+  connection_->RemoveEventObserver(this);
+}
+
+const GetPropertyResponse& PropertyCache::Get(Atom atom) {
+  auto it = properties_.find(atom);
+  DCHECK(it != properties_.end());
+
+  if (!it->second.response.has_value())
+    it->second.future.Wait();
+  DCHECK(it->second.response.has_value());
+
+  return it->second.response.value();
+}
+
+void PropertyCache::OnEvent(const Event& xev) {
+  auto* prop = xev.As<PropertyNotifyEvent>();
+  if (!prop)
+    return;
+  if (prop->window != window_)
+    return;
+  auto it = properties_.find(prop->atom);
+  if (it == properties_.end())
+    return;
+  if (prop->state == Property::NewValue) {
+    FetchProperty(it->first, &it->second);
+  } else {
+    DCHECK_EQ(prop->state, Property::Delete);
+    // When the property is deleted, a GetPropertyRequest will result in a
+    // zeroed GetPropertyReply, so set the reply state now to avoid making an
+    // unnecessary request.
+    it->second.response =
+        GetPropertyResponse{std::make_unique<GetPropertyReply>(), nullptr};
+  }
+}
+
+void PropertyCache::FetchProperty(Atom property, PropertyValue* value) {
+  value->future = connection_->GetProperty({
+      .window = window_,
+      .property = property,
+      .long_length = std::numeric_limits<uint32_t>::max(),
+  });
+  value->future.OnResponse(base::BindOnce(&PropertyCache::OnGetPropertyResponse,
+                                          weak_factory_.GetWeakPtr(), value));
+}
+
+void PropertyCache::OnGetPropertyResponse(PropertyValue* value,
+                                          GetPropertyResponse response) {
+  value->response = std::move(response);
+}
+
+PropertyCache::PropertyValue::PropertyValue() = default;
+
+PropertyCache::PropertyValue::PropertyValue(PropertyValue&&) = default;
+PropertyCache::PropertyValue& PropertyCache::PropertyValue::operator=(
+    PropertyValue&&) = default;
+
+PropertyCache::PropertyValue::~PropertyValue() = default;
+
+}  // namespace x11
diff --git a/ui/gfx/x/property_cache.h b/ui/gfx/x/property_cache.h
new file mode 100644
index 0000000..1004b07
--- /dev/null
+++ b/ui/gfx/x/property_cache.h
@@ -0,0 +1,85 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_PROPERTY_CACHE_H_
+#define UI_GFX_X_PROPERTY_CACHE_H_
+
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/containers/flat_map.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/weak_ptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/future.h"
+#include "ui/gfx/x/x11_window_event_manager.h"
+#include "ui/gfx/x/xproto.h"
+
+namespace x11 {
+
+// Watches properties on an X11 window.  Property values are obtained once upon
+// creation and are refreshed after each property change.
+class COMPONENT_EXPORT(X11) PropertyCache : public EventObserver {
+ public:
+  PropertyCache(Connection* connection,
+                Window window,
+                const std::vector<Atom>& properties);
+
+  PropertyCache(const PropertyCache&) = delete;
+  PropertyCache& operator=(const PropertyCache&) = delete;
+
+  ~PropertyCache() override;
+
+  const GetPropertyResponse& Get(Atom atom);
+
+  template <typename T>
+  const T* GetAs(Atom atom, size_t* size = nullptr) {
+    auto& response = Get(atom);
+    if (size)
+      *size = 0;
+    if (!response || response->format != CHAR_BIT * sizeof(T) ||
+        !response->value_len) {
+      return nullptr;
+    }
+    if (size)
+      *size = response->value_len;
+    return response->value->front_as<T>();
+  }
+
+ private:
+  friend class PropertyCacheTest;
+
+  struct PropertyValue {
+    PropertyValue();
+
+    PropertyValue(PropertyValue&&);
+    PropertyValue& operator=(PropertyValue&&);
+
+    ~PropertyValue();
+
+    Future<GetPropertyReply> future;
+    // |response| is nullopt if the request hasn't yet finished.
+    absl::optional<GetPropertyResponse> response = absl::nullopt;
+  };
+
+  // EventObserver:
+  void OnEvent(const Event& xev) override;
+
+  void FetchProperty(Atom property, PropertyValue* value);
+
+  void OnGetPropertyResponse(PropertyValue* value,
+                             GetPropertyResponse response);
+
+  Connection* connection_;
+  Window window_;
+  XScopedEventSelector event_selector_;
+  base::flat_map<Atom, PropertyValue> properties_;
+
+  base::WeakPtrFactory<PropertyCache> weak_factory_{this};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_PROPERTY_CACHE_H_
diff --git a/ui/gfx/x/property_cache_unittest.cc b/ui/gfx/x/property_cache_unittest.cc
new file mode 100644
index 0000000..ffc39d6
--- /dev/null
+++ b/ui/gfx/x/property_cache_unittest.cc
@@ -0,0 +1,173 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/property_cache.h"
+
+#include <memory>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/x/x11_atom_cache.h"
+#include "ui/gfx/x/xproto.h"
+#include "ui/gfx/x/xproto_util.h"
+
+namespace x11 {
+
+class PropertyCacheTest : public testing::Test {
+ public:
+  ~PropertyCacheTest() override = default;
+
+ protected:
+  base::flat_map<Atom, PropertyCache::PropertyValue>& GetProperties(
+      PropertyCache* property_cache) {
+    return property_cache->properties_;
+  }
+
+  Connection* connection() { return connection_; }
+
+  Window window() { return window_; }
+
+ private:
+  void SetUp() override {
+    connection_ = Connection::Get();
+    window_ = CreateDummyWindow("");
+  }
+
+  void TearDown() override {
+    connection_->DestroyWindow({window_}).Sync();
+    window_ = Window::None;
+    connection_ = nullptr;
+  }
+
+  Connection* connection_ = nullptr;
+  Window window_ = Window::None;
+};
+
+TEST_F(PropertyCacheTest, GetSync) {
+  auto atom = x11::GetAtom("DUMMY ATOM");
+  SetProperty(window(), atom, Atom::CARDINAL, 1234);
+
+  PropertyCache cache(connection(), window(), {atom});
+
+  // The cache should Sync() on getting the value.
+  EXPECT_FALSE(GetProperties(&cache)[atom].response.has_value());
+  auto* value = cache.GetAs<uint32_t>(atom);
+  EXPECT_TRUE(GetProperties(&cache)[atom].response.has_value());
+
+  ASSERT_TRUE(value);
+  EXPECT_EQ(*value, 1234u);
+}
+
+TEST_F(PropertyCacheTest, GetAsync) {
+  auto atom = x11::GetAtom("DUMMY ATOM");
+  SetProperty(window(), atom, Atom::CARDINAL, 1234);
+
+  PropertyCache cache(connection(), window(), {atom});
+
+  // The cache should not Sync() unnecessarily.
+  EXPECT_FALSE(GetProperties(&cache)[atom].response.has_value());
+  connection()->Sync();
+  connection()->DispatchAll();
+  EXPECT_TRUE(GetProperties(&cache)[atom].response.has_value());
+
+  auto* value = cache.GetAs<uint32_t>(atom);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(*value, 1234u);
+}
+
+TEST_F(PropertyCacheTest, Event) {
+  auto atom = x11::GetAtom("DUMMY ATOM");
+  SetProperty(window(), atom, Atom::CARDINAL, 1234);
+
+  PropertyCache cache(connection(), window(), {atom});
+
+  auto* value = cache.GetAs<uint32_t>(atom);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(*value, 1234u);
+
+  // Change the property and sync to ensure the PropertyNotify event is ready to
+  // be dispatched.
+  SetProperty(window(), atom, Atom::CARDINAL, 5678);
+  connection()->Sync();
+  connection()->ReadResponses();
+
+  // Dispatch the PropertyNotify event, which will cause the PropertyCache to
+  // send another GetPropertyRequest.  Calling DispatchAll() would introduce a
+  // race condition where we could get the GetPropertyResponse early if the 2
+  // round trips are completed fast enough.  To avoid this, we use Dispatch(),
+  // which doesn't read or write on the socket.
+  while (connection()->Dispatch()) {
+  }
+
+  // We don't have the new GetPropertyResponse yet, so the old value should
+  // still be there.
+  value = cache.GetAs<uint32_t>(atom);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(*value, 1234u);
+
+  // Complete the second round trip to acquire the new property value.
+  connection()->Sync();
+  connection()->DispatchAll();
+
+  // Now the cache should have the new value.
+  value = cache.GetAs<uint32_t>(atom);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(*value, 5678u);
+}
+
+TEST_F(PropertyCacheTest, GetAs) {
+  auto atom = x11::GetAtom("DUMMY ATOM");
+  SetProperty(window(), atom, Atom::CARDINAL, 1234);
+
+  PropertyCache cache(connection(), window(), {atom});
+
+  // Get() should return the correct property value.
+  auto& response = cache.Get(atom);
+  ASSERT_TRUE(response);
+  EXPECT_EQ(response->bytes_after, 0u);
+  EXPECT_EQ(response->format, 32);
+  EXPECT_EQ(response->type, Atom::CARDINAL);
+  EXPECT_EQ(*response->value->front_as<uint32_t>(), 1234u);
+  EXPECT_EQ(response->value_len, 1u);
+
+  // GetAs() should do the same thing as Get().
+  size_t size = 0;
+  auto* value = cache.GetAs<uint32_t>(atom, &size);
+  EXPECT_EQ(size, 1u);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(*value, 1234u);
+
+  // GetAs() should allow a nullptr size.
+  value = cache.GetAs<uint32_t>(atom /* size is defaulted to nullptr */);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(*value, 1234u);
+
+  // The below checks make requests and requires event dispatching, so
+  // synchronize all requests to avoid verbosity from Sync()ing everywhere.
+  connection()->SynchronizeForTest(true);
+
+  // GetAs() should return nullptr if the type's size is mismatched.
+  SetProperty(window(), atom, Atom::CARDINAL, static_cast<uint8_t>(123));
+  connection()->DispatchAll();
+  value = cache.GetAs<uint32_t>(atom, &size);
+  EXPECT_EQ(size, 0u);
+  EXPECT_FALSE(value);
+
+  // GetAs() should return nullptr if the property has no elements.
+  SetArrayProperty(window(), atom, Atom::CARDINAL, std::vector<uint32_t>());
+  connection()->DispatchAll();
+  value = cache.GetAs<uint32_t>(atom, &size);
+  EXPECT_EQ(size, 0u);
+  EXPECT_FALSE(value);
+
+  // GetAs() should return nullptr if the property is deleted.
+  DeleteProperty(window(), atom);
+  connection()->DispatchAll();
+  value = cache.GetAs<uint32_t>(atom, &size);
+  EXPECT_EQ(size, 0u);
+  EXPECT_FALSE(value);
+
+  connection()->SynchronizeForTest(true);
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/ref_counted_fd.cc b/ui/gfx/x/ref_counted_fd.cc
new file mode 100644
index 0000000..64ed2a8
--- /dev/null
+++ b/ui/gfx/x/ref_counted_fd.cc
@@ -0,0 +1,37 @@
+// Copyright 2021 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.
+
+#include "ui/gfx/x/ref_counted_fd.h"
+
+#include "base/check_op.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/posix/eintr_wrapper.h"
+
+namespace x11 {
+
+RefCountedFD::RefCountedFD() = default;
+
+RefCountedFD::RefCountedFD(int fd) : impl_(base::MakeRefCounted<Impl>(fd)) {}
+
+RefCountedFD::RefCountedFD(base::ScopedFD fd)
+    : impl_(base::MakeRefCounted<Impl>(std::move(fd))) {}
+
+RefCountedFD::RefCountedFD(const RefCountedFD& other) = default;
+RefCountedFD::RefCountedFD(RefCountedFD&&) = default;
+RefCountedFD& RefCountedFD::operator=(const RefCountedFD& other) = default;
+RefCountedFD& RefCountedFD::operator=(RefCountedFD&&) = default;
+RefCountedFD::~RefCountedFD() = default;
+
+int RefCountedFD::get() const {
+  return impl_ ? impl_->fd().get() : -1;
+}
+
+RefCountedFD::Impl::Impl(int fd) : fd_(fd) {}
+
+RefCountedFD::Impl::Impl(base::ScopedFD fd) : fd_(std::move(fd)) {}
+
+RefCountedFD::Impl::~Impl() = default;
+
+}  // namespace x11
diff --git a/ui/gfx/x/ref_counted_fd.h b/ui/gfx/x/ref_counted_fd.h
new file mode 100644
index 0000000..991c9e7
--- /dev/null
+++ b/ui/gfx/x/ref_counted_fd.h
@@ -0,0 +1,54 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_REF_COUNTED_FD_H_
+#define UI_GFX_X_REF_COUNTED_FD_H_
+
+#include "base/component_export.h"
+#include "base/files/scoped_file.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
+
+namespace x11 {
+
+// Wraps a native file descriptor and close()s it when there are no more active
+// scoped_refptrs.  This class is needed to implement request argument
+// forwarding and is probably not useful outside of that context.
+class COMPONENT_EXPORT(X11) RefCountedFD {
+ public:
+  RefCountedFD();
+  explicit RefCountedFD(int fd);
+  explicit RefCountedFD(base::ScopedFD);
+
+  // All special members are defaulted.
+  RefCountedFD(const RefCountedFD&);
+  RefCountedFD(RefCountedFD&&);
+  RefCountedFD& operator=(const RefCountedFD&);
+  RefCountedFD& operator=(RefCountedFD&&);
+  ~RefCountedFD();
+
+  int get() const;
+
+ private:
+  class Impl : public base::RefCounted<Impl> {
+   public:
+    explicit Impl(int fd);
+    explicit Impl(base::ScopedFD fd);
+
+    base::ScopedFD& fd() { return fd_; }
+
+   private:
+    friend class base::RefCounted<Impl>;
+
+    ~Impl();
+
+    base::ScopedFD fd_;
+  };
+
+  scoped_refptr<Impl> impl_;
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_REF_COUNTED_FD_H_
diff --git a/ui/gfx/x/scoped_ignore_errors.cc b/ui/gfx/x/scoped_ignore_errors.cc
new file mode 100644
index 0000000..9364dbd
--- /dev/null
+++ b/ui/gfx/x/scoped_ignore_errors.cc
@@ -0,0 +1,25 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/scoped_ignore_errors.h"
+
+namespace x11 {
+
+namespace {
+
+void IgnoreErrors(const Error* error, const char* request_name) {}
+
+}  // namespace
+
+ScopedIgnoreErrors::ScopedIgnoreErrors(Connection* connection)
+    : connection_(connection) {
+  old_error_handler_ =
+      connection_->SetErrorHandler(base::BindRepeating(IgnoreErrors));
+}
+
+ScopedIgnoreErrors::~ScopedIgnoreErrors() {
+  connection_->SetErrorHandler(old_error_handler_);
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/scoped_ignore_errors.h b/ui/gfx/x/scoped_ignore_errors.h
new file mode 100644
index 0000000..baa48b5
--- /dev/null
+++ b/ui/gfx/x/scoped_ignore_errors.h
@@ -0,0 +1,26 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_SCOPED_IGNORE_ERRORS_H_
+#define UI_GFX_X_SCOPED_IGNORE_ERRORS_H_
+
+#include "base/component_export.h"
+#include "ui/gfx/x/connection.h"
+
+namespace x11 {
+
+// Sets a no-op error handler for a connection while this class is alive.
+class COMPONENT_EXPORT(X11) ScopedIgnoreErrors {
+ public:
+  explicit ScopedIgnoreErrors(Connection* connection);
+  ~ScopedIgnoreErrors();
+
+ private:
+  Connection* const connection_;
+  Connection::ErrorHandler old_error_handler_;
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_SCOPED_IGNORE_ERRORS_H_
diff --git a/ui/gfx/x/x11_atom_cache.cc b/ui/gfx/x/x11_atom_cache.cc
new file mode 100644
index 0000000..a262069
--- /dev/null
+++ b/ui/gfx/x/x11_atom_cache.cc
@@ -0,0 +1,224 @@
+// Copyright (c) 2012 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.
+
+#include "ui/gfx/x/x11_atom_cache.h"
+
+#include <utility>
+#include <vector>
+
+#include "base/check.h"
+#include "base/cxx17_backports.h"
+#include "base/memory/singleton.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/future.h"
+
+namespace x11 {
+
+namespace {
+
+constexpr const char* kAtomsToCache[] = {
+    "ATOM_PAIR",
+    "Abs Dbl End Timestamp",
+    "Abs Dbl Fling X Velocity",
+    "Abs Dbl Fling Y Velocity",
+    "Abs Dbl Metrics Data 1",
+    "Abs Dbl Metrics Data 2",
+    "Abs Dbl Ordinal X",
+    "Abs Dbl Ordinal Y",
+    "Abs Dbl Start Timestamp",
+    "Abs Finger Count",
+    "Abs Fling State",
+    "Abs MT Orientation",
+    "Abs MT Position X",
+    "Abs MT Position Y",
+    "Abs MT Pressure",
+    "Abs MT Touch Major",
+    "Abs MT Touch Minor",
+    "Abs MT Tracking ID",
+    "Abs Metrics Type",
+    "CHECK",
+    "CHOME_SELECTION",
+    "CHROME_SELECTION",
+    "CHROMIUM_COMPOSITE_WINDOW",
+    "CHROMIUM_TIMESTAMP",
+    "CLIPBOARD",
+    "CLIPBOARD_MANAGER",
+    "Content Protection",
+    "Desired",
+    "Device Node",
+    "Device Product ID",
+    "EDID",
+    "Enabled",
+    "FAKE_SELECTION",
+    "Full aspect",
+    "_GTK_FRAME_EXTENTS",
+    "INCR",
+    "KEYBOARD",
+    "LOCK",
+    "MOUSE",
+    "MULTIPLE",
+    "Rel Horiz Wheel",
+    "Rel Vert Wheel",
+    "SAVE_TARGETS",
+    "SELECTION_STRING",
+    "TARGET1",
+    "TARGET2",
+    "TARGETS",
+    "TEXT",
+    "TIMESTAMP",
+    "TOUCHPAD",
+    "TOUCHSCREEN",
+    "Tap Paused",
+    "Touch Timestamp",
+    "UTF8_STRING",
+    "Undesired",
+    "WM_DELETE_WINDOW",
+    "WM_PROTOCOLS",
+    "WM_WINDOW_ROLE",
+    "XdndActionAsk",
+    "XdndActionCopy",
+    "XdndActionDirectSave",
+    "XdndActionLink",
+    "XdndActionList",
+    "XdndActionMove",
+    "XdndActionPrivate",
+    "XdndAware",
+    "XdndDirectSave0",
+    "XdndDrop",
+    "XdndEnter",
+    "XdndFinished",
+    "XdndLeave",
+    "XdndPosition",
+    "XdndProxy",
+    "XdndSelection",
+    "XdndStatus",
+    "XdndTypeList",
+    "_CHROME_DISPLAY_INTERNAL",
+    "_CHROME_DISPLAY_ROTATION",
+    "_CHROME_DISPLAY_SCALE_FACTOR",
+    "_CHROMIUM_DRAG_RECEIVER",
+    "_GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED",
+    "_GTK_THEME_VARIANT",
+    "_ICC_PROFILE",
+    "_MOTIF_WM_HINTS",
+    "_NETSCAPE_URL",
+    "_NET_ACTIVE_WINDOW",
+    "_NET_CLIENT_LIST_STACKING",
+    "_NET_CURRENT_DESKTOP",
+    "_NET_FRAME_EXTENTS",
+    "_NET_SUPPORTED",
+    "_NET_SUPPORTING_WM_CHECK",
+    "_NET_SYSTEM_TRAY_OPCODE",
+    "_NET_SYSTEM_TRAY_S0",
+    "_NET_SYSTEM_TRAY_VISUAL",
+    "_NET_WM_BYPASS_COMPOSITOR",
+    "_NET_WM_CM_S0",
+    "_NET_WM_DESKTOP",
+    "_NET_WM_ICON",
+    "_NET_WM_MOVERESIZE",
+    "_NET_WM_NAME",
+    "_NET_WM_OPAQUE_REGION",
+    "_NET_WM_PID",
+    "_NET_WM_PING",
+    "_NET_WM_STATE",
+    "_NET_WM_STATE_ABOVE",
+    "_NET_WM_STATE_FOCUSED",
+    "_NET_WM_STATE_FULLSCREEN",
+    "_NET_WM_STATE_HIDDEN",
+    "_NET_WM_STATE_MAXIMIZED_HORZ",
+    "_NET_WM_STATE_MAXIMIZED_VERT",
+    "_NET_WM_STATE_SKIP_TASKBAR",
+    "_NET_WM_STATE_STICKY",
+    "_NET_WM_SYNC_REQUEST",
+    "_NET_WM_SYNC_REQUEST_COUNTER",
+    "_NET_WM_USER_TIME",
+    "_NET_WM_WINDOW_OPACITY",
+    "_NET_WM_WINDOW_TYPE",
+    "_NET_WM_WINDOW_TYPE_DIALOG",
+    "_NET_WM_WINDOW_TYPE_DND",
+    "_NET_WM_WINDOW_TYPE_MENU",
+    "_NET_WM_WINDOW_TYPE_NORMAL",
+    "_NET_WM_WINDOW_TYPE_NOTIFICATION",
+    "_NET_WM_WINDOW_TYPE_TOOLTIP",
+    "_NET_WORKAREA",
+    "_SCREENSAVER_STATUS",
+    "_SCREENSAVER_VERSION",
+    "_XEMBED_INFO",
+    "application/octet-stream",
+    "application/vnd.chromium.test",
+    "chromium/filename",
+    "chromium/x-bookmark-entries",
+    "chromium/x-browser-actions",
+    "chromium/x-file-system-files",
+    "chromium/x-pepper-custom-data",
+    "chromium/x-renderer-taint",
+    "chromium/x-web-custom-data",
+    "chromium/x-webkit-paste",
+    "image/png",
+    "image/svg+xml",
+    "marker_event",
+    "scaling mode",
+    "text/html",
+    "text/plain",
+    "text/plain;charset=utf-8",
+    "text/rtf",
+    "text/uri-list",
+    "text/x-moz-url",
+    "xwayland-pointer",
+    "xwayland-keyboard",
+    "xwayland-touch",
+};
+
+constexpr int kCacheCount = base::size(kAtomsToCache);
+
+}  // namespace
+
+Atom GetAtom(const std::string& name) {
+  return X11AtomCache::GetInstance()->GetAtom(name);
+}
+
+X11AtomCache* X11AtomCache::GetInstance() {
+  return base::Singleton<X11AtomCache>::get();
+}
+
+X11AtomCache::X11AtomCache() : connection_(Connection::Get()) {
+  // Clipboard formats are keyed on their format string (eg. "STRING",
+  // "UTF8_STRING", "image/png").  Plumbing through x11::Atoms instead would be
+  // tricky, so set "STRING" here to prevent hitting the DCHECK_GT() in
+  // GetAtom().
+  cached_atoms_["STRING"] = x11::Atom::STRING;
+
+  std::vector<Future<InternAtomReply>> requests;
+  requests.reserve(kCacheCount);
+  for (const char* name : kAtomsToCache)
+    requests.push_back(
+        connection_->InternAtom(InternAtomRequest{.name = name}));
+  // Flush so all requests are sent before waiting on any replies.
+  connection_->Flush();
+  for (size_t i = 0; i < kCacheCount; ++i) {
+    if (auto response = requests[i].Sync())
+      cached_atoms_[kAtomsToCache[i]] = static_cast<Atom>(response->atom);
+  }
+}
+
+X11AtomCache::~X11AtomCache() = default;
+
+Atom X11AtomCache::GetAtom(const std::string& name) const {
+  const auto it = cached_atoms_.find(name);
+  if (it != cached_atoms_.end())
+    return it->second;
+
+  Atom atom = Atom::None;
+  if (auto response =
+          connection_->InternAtom(InternAtomRequest{.name = name}).Sync()) {
+    atom = response->atom;
+    DCHECK_GT(atom, x11::Atom::kLastPredefinedAtom)
+        << " Use x11::Atom::" << name << " instead of x11::GetAtom(\"" << name
+        << "\")";
+    cached_atoms_.emplace(name, atom);
+  }
+  return atom;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/x11_atom_cache.h b/ui/gfx/x/x11_atom_cache.h
new file mode 100644
index 0000000..063b438
--- /dev/null
+++ b/ui/gfx/x/x11_atom_cache.h
@@ -0,0 +1,59 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_X11_ATOM_CACHE_H_
+#define UI_GFX_X_X11_ATOM_CACHE_H_
+
+#include <map>
+#include <string>
+
+#include "base/component_export.h"
+#include "base/macros.h"
+#include "ui/gfx/x/xproto.h"
+
+namespace base {
+template <typename T>
+struct DefaultSingletonTraits;
+}
+
+namespace x11 {
+class Connection;
+}
+
+namespace x11 {
+
+// Gets the X atom for default display corresponding to atom_name.
+COMPONENT_EXPORT(X11) Atom GetAtom(const std::string& atom_name);
+
+// Pre-caches all Atoms on first use to minimize roundtrips to the X11
+// server. By default, GetAtom() will CHECK() that atoms accessed through
+// GetAtom() were passed to the constructor, but this behaviour can be changed
+// with allow_uncached_atoms().
+class COMPONENT_EXPORT(X11) X11AtomCache {
+ public:
+  static X11AtomCache* GetInstance();
+
+  X11AtomCache(const X11AtomCache&) = delete;
+  X11AtomCache& operator=(const X11AtomCache&) = delete;
+
+ private:
+  friend Atom GetAtom(const std::string& atom_name);
+  friend struct base::DefaultSingletonTraits<X11AtomCache>;
+
+  X11AtomCache();
+  ~X11AtomCache();
+
+  // Returns the pre-interned Atom without having to go to the x server.
+  // On failure, None is returned.
+  Atom GetAtom(const std::string&) const;
+
+  Connection* connection_;
+
+  // Using std::map, as it is possible for thousands of atoms to be registered.
+  mutable std::map<std::string, Atom> cached_atoms_;
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_X11_ATOM_CACHE_H_
diff --git a/ui/gfx/x/x11_path.cc b/ui/gfx/x/x11_path.cc
new file mode 100644
index 0000000..9d4a2bb
--- /dev/null
+++ b/ui/gfx/x/x11_path.cc
@@ -0,0 +1,38 @@
+// 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.
+
+#include "ui/gfx/x/x11_path.h"
+
+#include <memory>
+
+#include "third_party/skia/include/core/SkPath.h"
+#include "third_party/skia/include/core/SkRegion.h"
+
+namespace x11 {
+
+std::unique_ptr<std::vector<Rectangle>> CreateRegionFromSkRegion(
+    const SkRegion& region) {
+  auto result = std::make_unique<std::vector<Rectangle>>();
+
+  for (SkRegion::Iterator i(region); !i.done(); i.next()) {
+    result->push_back({
+        .x = static_cast<int16_t>(i.rect().x()),
+        .y = static_cast<int16_t>(i.rect().y()),
+        .width = static_cast<uint16_t>(i.rect().width()),
+        .height = static_cast<uint16_t>(i.rect().height()),
+    });
+  }
+
+  return result;
+}
+
+std::unique_ptr<std::vector<Rectangle>> CreateRegionFromSkPath(
+    const SkPath& path) {
+  SkRegion clip{path.getBounds().roundOut()};
+  SkRegion region;
+  region.setPath(path, clip);
+  return CreateRegionFromSkRegion(region);
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/x11_path.h b/ui/gfx/x/x11_path.h
new file mode 100644
index 0000000..6a44b2f
--- /dev/null
+++ b/ui/gfx/x/x11_path.h
@@ -0,0 +1,30 @@
+// 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.
+
+#ifndef UI_GFX_X_X11_PATH_H_
+#define UI_GFX_X_X11_PATH_H_
+
+#include "base/component_export.h"
+#include "ui/gfx/x/xproto.h"
+
+class SkPath;
+class SkRegion;
+
+namespace x11 {
+
+// Creates a new XRegion given |region|. The caller is responsible for
+// destroying the returned region.
+COMPONENT_EXPORT(X11)
+std::unique_ptr<std::vector<Rectangle>> CreateRegionFromSkRegion(
+    const SkRegion& region);
+
+// Creates a new XRegion given |path|. The caller is responsible for destroying
+// the returned region.
+COMPONENT_EXPORT(X11)
+std::unique_ptr<std::vector<Rectangle>> CreateRegionFromSkPath(
+    const SkPath& path);
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_X11_PATH_H_
diff --git a/ui/gfx/x/x11_switches.cc b/ui/gfx/x/x11_switches.cc
new file mode 100644
index 0000000..9e53afd
--- /dev/null
+++ b/ui/gfx/x/x11_switches.cc
@@ -0,0 +1,16 @@
+// Copyright 2014 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.
+
+#include "ui/gfx/x/x11_switches.h"
+
+namespace switches {
+
+// Which X11 display to connect to. Emulates the GTK+ "--display=" command line
+// argument.
+const char kX11Display[] = "display";
+
+// Disables MIT-SHM extension.
+const char kNoXshm[] = "no-xshm";
+
+}  // namespace switches
diff --git a/ui/gfx/x/x11_switches.h b/ui/gfx/x/x11_switches.h
new file mode 100644
index 0000000..2df00e5
--- /dev/null
+++ b/ui/gfx/x/x11_switches.h
@@ -0,0 +1,18 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_X11_SWITCHES_H_
+#define UI_GFX_X_X11_SWITCHES_H_
+
+#include "base/component_export.h"
+
+namespace switches {
+
+COMPONENT_EXPORT(X11) extern const char kX11Display[];
+
+COMPONENT_EXPORT(X11) extern const char kNoXshm[];
+
+}  // namespace switches
+
+#endif  // UI_GFX_X_X11_SWITCHES_H_
diff --git a/ui/gfx/x/x11_window_event_manager.cc b/ui/gfx/x/x11_window_event_manager.cc
new file mode 100644
index 0000000..ac86642
--- /dev/null
+++ b/ui/gfx/x/x11_window_event_manager.cc
@@ -0,0 +1,124 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gfx/x/x11_window_event_manager.h"
+
+#include <stddef.h>
+
+#include "base/memory/singleton.h"
+#include "ui/gfx/x/future.h"
+
+namespace x11 {
+
+namespace {
+
+// Asks the X server to set |window|'s event mask to |new_mask|.
+void SetEventMask(Window window, EventMask new_mask) {
+  auto* connection = Connection::Get();
+  // Window |window| may already be destroyed at this point, so the
+  // change_attributes request may give a BadWindow error.  In this case, just
+  // ignore the error.
+  connection
+      ->ChangeWindowAttributes(ChangeWindowAttributesRequest{
+          .window = window, .event_mask = static_cast<EventMask>(new_mask)})
+      .IgnoreError();
+}
+
+}  // anonymous namespace
+
+XScopedEventSelector::XScopedEventSelector(Window window, EventMask event_mask)
+    : window_(window),
+      event_mask_(event_mask),
+      event_manager_(
+          XWindowEventManager::GetInstance()->weak_ptr_factory_.GetWeakPtr()) {
+  event_manager_->SelectEvents(window_, event_mask_);
+}
+
+XScopedEventSelector::~XScopedEventSelector() {
+  if (event_manager_)
+    event_manager_->DeselectEvents(window_, event_mask_);
+}
+
+// static
+XWindowEventManager* XWindowEventManager::GetInstance() {
+  return base::Singleton<XWindowEventManager>::get();
+}
+
+class XWindowEventManager::MultiMask {
+ public:
+  MultiMask() { memset(mask_bits_, 0, sizeof(mask_bits_)); }
+
+  MultiMask(const MultiMask&) = delete;
+  MultiMask& operator=(const MultiMask&) = delete;
+
+  ~MultiMask() = default;
+
+  void AddMask(EventMask mask) {
+    for (int i = 0; i < kMaskSize; i++) {
+      if (static_cast<uint32_t>(mask) & (1 << i))
+        mask_bits_[i]++;
+    }
+  }
+
+  void RemoveMask(EventMask mask) {
+    for (int i = 0; i < kMaskSize; i++) {
+      if (static_cast<uint32_t>(mask) & (1 << i)) {
+        DCHECK(mask_bits_[i]);
+        mask_bits_[i]--;
+      }
+    }
+  }
+
+  EventMask ToMask() const {
+    EventMask mask = EventMask::NoEvent;
+    for (int i = 0; i < kMaskSize; i++) {
+      if (mask_bits_[i])
+        mask = mask | static_cast<EventMask>(1 << i);
+    }
+    return mask;
+  }
+
+ private:
+  static constexpr auto kMaskSize = 25;
+
+  int mask_bits_[kMaskSize];
+};
+
+XWindowEventManager::XWindowEventManager() = default;
+
+XWindowEventManager::~XWindowEventManager() {
+  // Clear events still requested by not-yet-deleted XScopedEventSelectors.
+  for (const auto& mask_pair : mask_map_)
+    SetEventMask(mask_pair.first, EventMask::NoEvent);
+}
+
+void XWindowEventManager::SelectEvents(Window window, EventMask event_mask) {
+  std::unique_ptr<MultiMask>& mask = mask_map_[window];
+  if (!mask)
+    mask = std::make_unique<MultiMask>();
+  EventMask old_mask = mask_map_[window]->ToMask();
+  mask->AddMask(event_mask);
+  AfterMaskChanged(window, old_mask);
+}
+
+void XWindowEventManager::DeselectEvents(Window window, EventMask event_mask) {
+  DCHECK(mask_map_.find(window) != mask_map_.end());
+  std::unique_ptr<MultiMask>& mask = mask_map_[window];
+  EventMask old_mask = mask->ToMask();
+  mask->RemoveMask(event_mask);
+  AfterMaskChanged(window, old_mask);
+}
+
+void XWindowEventManager::AfterMaskChanged(Window window, EventMask old_mask) {
+  EventMask new_mask = mask_map_[window]->ToMask();
+  if (new_mask == old_mask)
+    return;
+
+  SetEventMask(window, new_mask);
+
+  if (new_mask == EventMask::NoEvent)
+    mask_map_.erase(window);
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/x11_window_event_manager.h b/ui/gfx/x/x11_window_event_manager.h
new file mode 100644
index 0000000..50e5855
--- /dev/null
+++ b/ui/gfx/x/x11_window_event_manager.h
@@ -0,0 +1,80 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_X11_WINDOW_EVENT_MANAGER_H_
+#define UI_GFX_X_X11_WINDOW_EVENT_MANAGER_H_
+
+#include <map>
+
+#include "base/component_export.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "ui/gfx/x/connection.h"
+
+namespace base {
+template <typename T>
+struct DefaultSingletonTraits;
+}
+
+namespace x11 {
+
+class XWindowEventManager;
+
+// Ensures events in |event_mask| are selected on |window| for the duration of
+// this object's lifetime.
+class COMPONENT_EXPORT(X11) XScopedEventSelector {
+ public:
+  XScopedEventSelector(Window window, EventMask event_mask);
+
+  XScopedEventSelector(const XScopedEventSelector&) = delete;
+  XScopedEventSelector& operator=(const XScopedEventSelector&) = delete;
+
+  ~XScopedEventSelector();
+
+ private:
+  Window window_;
+  EventMask event_mask_;
+  base::WeakPtr<XWindowEventManager> event_manager_;
+};
+
+// Allows multiple clients within Chrome to select events on the same X window.
+class XWindowEventManager {
+ public:
+  static XWindowEventManager* GetInstance();
+
+  XWindowEventManager(const XWindowEventManager&) = delete;
+  XWindowEventManager& operator=(const XWindowEventManager&) = delete;
+
+ private:
+  friend struct base::DefaultSingletonTraits<XWindowEventManager>;
+  friend class XScopedEventSelector;
+
+  class MultiMask;
+
+  XWindowEventManager();
+  ~XWindowEventManager();
+
+  // Guarantees that events in |event_mask| will be reported to Chrome.
+  void SelectEvents(Window window, EventMask event_mask);
+
+  // Deselects events on |event_mask|.  Chrome will stop receiving events for
+  // any set bit in |event_mask| only if no other client has selected that bit.
+  void DeselectEvents(Window window, EventMask event_mask);
+
+  // Helper method called by SelectEvents and DeselectEvents whenever the mask
+  // corresponding to |window| might have changed.  Calls SetEventMask if
+  // necessary.
+  void AfterMaskChanged(Window window, EventMask old_mask);
+
+  std::map<Window, std::unique_ptr<MultiMask>> mask_map_;
+
+  // This is used to set XScopedEventSelector::event_manager_.  If |this| is
+  // destroyed before any XScopedEventSelector, the |event_manager_| will become
+  // invalidated.
+  base::WeakPtrFactory<XWindowEventManager> weak_ptr_factory_{this};
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_X11_WINDOW_EVENT_MANAGER_H_
diff --git a/ui/gfx/x/xlib.h b/ui/gfx/x/xlib.h
new file mode 100644
index 0000000..1c26ffd
--- /dev/null
+++ b/ui/gfx/x/xlib.h
@@ -0,0 +1,19 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_XLIB_H_
+#define UI_GFX_X_XLIB_H_
+
+extern "C" {
+int XInitThreads(void);
+struct _XDisplay* XOpenDisplay(const char*);
+int XCloseDisplay(struct _XDisplay*);
+int XFlush(struct _XDisplay*);
+int XSynchronize(struct _XDisplay*, int);
+int XSetErrorHandler(int (*)(void*, void*));
+void XFree(void*);
+int XPending(struct _XDisplay*);
+}
+
+#endif  // UI_GFX_X_XLIB_H_
diff --git a/ui/gfx/x/xlib_support.cc b/ui/gfx/x/xlib_support.cc
new file mode 100644
index 0000000..281c318
--- /dev/null
+++ b/ui/gfx/x/xlib_support.cc
@@ -0,0 +1,127 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/xlib_support.h"
+
+#include "base/check.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "library_loaders/xlib_loader.h"
+#include "library_loaders/xlib_xcb_loader.h"
+
+namespace x11 {
+
+namespace {
+
+int XlibErrorHandler(void*, void*) {
+  DVLOG(1) << "Xlib error received";
+  return 0;
+}
+
+XlibLoader* GetXlibLoader() {
+  static base::NoDestructor<XlibLoader> xlib_loader;
+  return xlib_loader.get();
+}
+
+XlibXcbLoader* GetXlibXcbLoader() {
+  static base::NoDestructor<XlibXcbLoader> xlib_xcb_loader;
+  return xlib_xcb_loader.get();
+}
+
+}  // namespace
+
+DISABLE_CFI_ICALL
+void InitXlib() {
+  auto* xlib_loader = GetXlibLoader();
+  if (xlib_loader->loaded())
+    return;
+
+  CHECK(xlib_loader->Load("libX11.so.6"));
+
+  auto* xlib_xcb_loader = GetXlibXcbLoader();
+  CHECK(xlib_xcb_loader->Load("libX11-xcb.so.1"));
+
+  CHECK(xlib_loader->XInitThreads());
+
+  // The default Xlib error handler calls exit(1), which we don't want.  This
+  // shouldn't happen in the browser process since only XProto requests are
+  // made, but in the GPU process, GLX can make Xlib requests, so setting an
+  // error handler is necessary.  Importantly, there's also an IO error handler,
+  // and Xlib always calls exit(1) with no way to change this behavior.
+  SetXlibErrorHandler();
+}
+
+DISABLE_CFI_ICALL
+void SetXlibErrorHandler() {
+  GetXlibLoader()->XSetErrorHandler(XlibErrorHandler);
+}
+
+DISABLE_CFI_ICALL
+void XlibFree(void* data) {
+  GetXlibLoader()->XFree(data);
+}
+
+DISABLE_CFI_ICALL
+XlibDisplay::XlibDisplay(const std::string& address) {
+  InitXlib();
+
+  display_ = GetXlibLoader()->XOpenDisplay(address.empty() ? nullptr
+                                                           : address.c_str());
+}
+
+DISABLE_CFI_ICALL
+XlibDisplay::~XlibDisplay() {
+  if (!display_)
+    return;
+
+  auto* loader = GetXlibLoader();
+  // Events are not processed on |display_|, so if any client asks to receive
+  // events, they will just queue up and leak memory.  This check makes sure
+  // |display_| never had any pending events before it is closed.
+  CHECK(!loader->XPending(display_));
+  loader->XCloseDisplay(display_);
+}
+
+DISABLE_CFI_ICALL
+XlibDisplayWrapper::XlibDisplayWrapper(struct _XDisplay* display,
+                                       XlibDisplayType type)
+    : display_(display), type_(type) {
+  if (!display_)
+    return;
+  if (type == XlibDisplayType::kSyncing)
+    GetXlibLoader()->XSynchronize(display_, true);
+}
+
+DISABLE_CFI_ICALL
+XlibDisplayWrapper::~XlibDisplayWrapper() {
+  if (!display_)
+    return;
+  if (type_ == XlibDisplayType::kFlushing)
+    GetXlibLoader()->XFlush(display_);
+  else if (type_ == XlibDisplayType::kSyncing)
+    GetXlibLoader()->XSynchronize(display_, false);
+}
+
+XlibDisplayWrapper::XlibDisplayWrapper(XlibDisplayWrapper&& other) {
+  display_ = other.display_;
+  type_ = other.type_;
+  other.display_ = nullptr;
+  other.type_ = XlibDisplayType::kNormal;
+}
+
+XlibDisplayWrapper& XlibDisplayWrapper::operator=(XlibDisplayWrapper&& other) {
+  display_ = other.display_;
+  type_ = other.type_;
+  other.display_ = nullptr;
+  other.type_ = XlibDisplayType::kNormal;
+  return *this;
+}
+
+DISABLE_CFI_ICALL
+struct xcb_connection_t* XlibDisplayWrapper::GetXcbConnection() {
+  return GetXlibXcbLoader()->XGetXCBConnection(display_);
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/xlib_support.h b/ui/gfx/x/xlib_support.h
new file mode 100644
index 0000000..26accef
--- /dev/null
+++ b/ui/gfx/x/xlib_support.h
@@ -0,0 +1,80 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_XLIB_SUPPORT_H_
+#define UI_GFX_X_XLIB_SUPPORT_H_
+
+#include <memory>
+#include <string>
+
+#include "base/component_export.h"
+
+struct _XDisplay;
+struct xcb_connection_t;
+
+namespace x11 {
+
+// Specifies the behavior of XlibDisplayWrapper.
+enum class XlibDisplayType {
+  // No action taken on wrapper construction or destruction.
+  kNormal,
+
+  // Flushes the connection on destruction.
+  kFlushing,
+
+  // Synchronizes all requests while the wrapper is alive.
+  kSyncing,
+};
+
+// Loads Xlib, initializes threads, and sets a default error handler.
+COMPONENT_EXPORT(X11) void InitXlib();
+
+// Sets an async error handler which only logs an error message.
+COMPONENT_EXPORT(X11) void SetXlibErrorHandler();
+
+// Wraps XFree().
+COMPONENT_EXPORT(X11) void XlibFree(void* data);
+
+// A scoped Xlib display.
+class COMPONENT_EXPORT(X11) XlibDisplay {
+ public:
+  ~XlibDisplay();
+
+ private:
+  friend class Connection;
+  friend class XlibDisplayWrapper;
+
+  explicit XlibDisplay(const std::string& address);
+
+  struct _XDisplay* display_ = nullptr;
+};
+
+// A temporary wrapper around an unowned Xlib display that adds behavior
+// on construction and destruction (see XlibDisplayType).
+class COMPONENT_EXPORT(X11) XlibDisplayWrapper {
+ public:
+  ~XlibDisplayWrapper();
+
+  struct _XDisplay* display() {
+    return display_;
+  }
+  operator struct _XDisplay *() { return display_; }
+
+  struct xcb_connection_t* GetXcbConnection();
+
+  XlibDisplayWrapper(XlibDisplayWrapper&& other);
+  XlibDisplayWrapper& operator=(XlibDisplayWrapper&& other);
+
+ private:
+  XlibDisplayWrapper(struct _XDisplay* display, XlibDisplayType type);
+
+  friend class Connection;
+
+  struct _XDisplay* display_;
+  XlibDisplayType type_;
+};
+
+}  // namespace x11
+
+#endif  // UI_GFX_X_XLIB_SUPPORT_H_
diff --git a/ui/gfx/x/xlib_xcb.h b/ui/gfx/x/xlib_xcb.h
new file mode 100644
index 0000000..73d5649
--- /dev/null
+++ b/ui/gfx/x/xlib_xcb.h
@@ -0,0 +1,12 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_XLIB_XCB_H_
+#define UI_GFX_X_XLIB_XCB_H_
+
+extern "C" {
+struct xcb_connection_t* XGetXCBConnection(struct _XDisplay*);
+}
+
+#endif  // UI_GFX_X_XLIB_XCB_H_
diff --git a/ui/gfx/x/xproto_internal.cc b/ui/gfx/x/xproto_internal.cc
new file mode 100644
index 0000000..e0ffe7e
--- /dev/null
+++ b/ui/gfx/x/xproto_internal.cc
@@ -0,0 +1,61 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/xproto_internal.h"
+
+#include <stdint.h>
+#include <xcb/xcb.h>
+#include <xcb/xcbext.h>
+
+namespace x11 {
+
+MallocedRefCountedMemory::MallocedRefCountedMemory(void* data)
+    : data_(reinterpret_cast<uint8_t*>(data)) {}
+
+const uint8_t* MallocedRefCountedMemory::front() const {
+  return data_;
+}
+
+size_t MallocedRefCountedMemory::size() const {
+  // There's no easy way to tell how large malloc'ed data is.
+  NOTREACHED();
+  return 0;
+}
+
+MallocedRefCountedMemory::~MallocedRefCountedMemory() {
+  free(data_);
+}
+
+OffsetRefCountedMemory::OffsetRefCountedMemory(
+    scoped_refptr<base::RefCountedMemory> memory,
+    size_t offset,
+    size_t size)
+    : memory_(memory), offset_(offset), size_(size) {}
+
+const uint8_t* OffsetRefCountedMemory::front() const {
+  return memory_->front() + offset_;
+}
+
+size_t OffsetRefCountedMemory::size() const {
+  return size_;
+}
+
+OffsetRefCountedMemory::~OffsetRefCountedMemory() = default;
+
+UnretainedRefCountedMemory::UnretainedRefCountedMemory(const void* data)
+    : data_(reinterpret_cast<const uint8_t*>(data)) {}
+
+const uint8_t* UnretainedRefCountedMemory::front() const {
+  return data_;
+}
+
+size_t UnretainedRefCountedMemory::size() const {
+  // There's no easy way to tell how large malloc'ed data is.
+  NOTREACHED();
+  return 0;
+}
+
+UnretainedRefCountedMemory::~UnretainedRefCountedMemory() = default;
+
+}  // namespace x11
diff --git a/ui/gfx/x/xproto_internal.h b/ui/gfx/x/xproto_internal.h
new file mode 100644
index 0000000..6bf0f51
--- /dev/null
+++ b/ui/gfx/x/xproto_internal.h
@@ -0,0 +1,204 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_XPROTO_INTERNAL_H_
+#define UI_GFX_X_XPROTO_INTERNAL_H_
+
+#ifndef IS_X11_IMPL
+#error "This file should only be included by //ui/gfx/x:xprotos"
+#endif
+
+#include <bitset>
+#include <type_traits>
+
+#include "base/component_export.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted_memory.h"
+#include "ui/gfx/x/future.h"
+#include "ui/gfx/x/xproto.h"
+#include "ui/gfx/x/xproto_types.h"
+
+namespace x11 {
+
+class Connection;
+
+template <typename T, typename Enable = void>
+struct EnumBase {
+  using type = T;
+};
+
+template <typename T>
+struct EnumBase<T, typename std::enable_if_t<std::is_enum<T>::value>> {
+  using type = typename std::underlying_type<T>::type;
+};
+
+template <typename T>
+using EnumBaseType = typename EnumBase<T>::type;
+
+template <typename T>
+void ReadError(T* error, ReadBuffer* buf);
+
+// Calls free() on the underlying data when the count drops to 0.
+class COMPONENT_EXPORT(X11) MallocedRefCountedMemory
+    : public base::RefCountedMemory {
+ public:
+  explicit MallocedRefCountedMemory(void* data);
+
+  MallocedRefCountedMemory(const MallocedRefCountedMemory&) = delete;
+  MallocedRefCountedMemory& operator=(const MallocedRefCountedMemory&) = delete;
+
+  const uint8_t* front() const override;
+
+  size_t size() const override;
+
+ private:
+  ~MallocedRefCountedMemory() override;
+
+  uint8_t* const data_;
+};
+
+// Wraps another RefCountedMemory, giving a view into it.  Similar to
+// base::StringPiece, the data is some contiguous subarray, but unlike
+// StringPiece, a counted reference is kept on the underlying memory.
+class COMPONENT_EXPORT(X11) OffsetRefCountedMemory
+    : public base::RefCountedMemory {
+ public:
+  OffsetRefCountedMemory(scoped_refptr<base::RefCountedMemory> memory,
+                         size_t offset,
+                         size_t size);
+
+  OffsetRefCountedMemory(const OffsetRefCountedMemory&) = delete;
+  OffsetRefCountedMemory& operator=(const OffsetRefCountedMemory&) = delete;
+
+  const uint8_t* front() const override;
+
+  size_t size() const override;
+
+ private:
+  ~OffsetRefCountedMemory() override;
+
+  scoped_refptr<base::RefCountedMemory> memory_;
+  size_t offset_;
+  size_t size_;
+};
+
+// Wraps a bare pointer and does not take any action when the reference count
+// reaches 0.  This is used to wrap stack-alloctaed or persistent data so we can
+// pass those to Read/ReadEvent/ReadReply which expect RefCountedMemory.
+class COMPONENT_EXPORT(X11) UnretainedRefCountedMemory
+    : public base::RefCountedMemory {
+ public:
+  explicit UnretainedRefCountedMemory(const void* data);
+
+  UnretainedRefCountedMemory(const UnretainedRefCountedMemory&) = delete;
+  UnretainedRefCountedMemory& operator=(const UnretainedRefCountedMemory&) =
+      delete;
+
+  const uint8_t* front() const override;
+
+  size_t size() const override;
+
+ private:
+  ~UnretainedRefCountedMemory() override;
+
+  const uint8_t* const data_;
+};
+
+template <typename T>
+void Read(T* t, ReadBuffer* buf) {
+  static_assert(std::is_trivially_copyable<T>::value, "");
+  detail::VerifyAlignment(t, buf->offset);
+  memcpy(t, buf->data->data() + buf->offset, sizeof(*t));
+  buf->offset += sizeof(*t);
+}
+
+inline void Pad(WriteBuffer* buf, size_t amount) {
+  uint8_t zero = 0;
+  for (size_t i = 0; i < amount; i++)
+    buf->Write(&zero);
+}
+
+inline void Pad(ReadBuffer* buf, size_t amount) {
+  buf->offset += amount;
+}
+
+inline void Align(WriteBuffer* buf, size_t align) {
+  Pad(buf, (align - (buf->offset() % align)) % align);
+}
+
+inline void Align(ReadBuffer* buf, size_t align) {
+  Pad(buf, (align - (buf->offset % align)) % align);
+}
+
+// Helper function for xcbproto popcount.  Given an integral type, returns the
+// number of 1 bits present.
+template <typename T>
+size_t PopCount(T t) {
+  return std::bitset<sizeof(T) * 8>(static_cast<EnumBaseType<T>>(t)).count();
+}
+
+// Helper function for xcbproto sumof.  Given a function |f| and a container
+// |t|, maps the elements uisng |f| and reduces by summing the results.
+template <typename F, typename T>
+auto SumOf(F&& f, T& t) {
+  decltype(f(t[0])) sum = 0;
+  for (auto& v : t)
+    sum += f(v);
+  return sum;
+}
+
+// Helper function for xcbproto case.  Checks for equality between |t| and |s|.
+template <typename T, typename S>
+bool CaseEq(T t, S s) {
+  return t == static_cast<decltype(t)>(s);
+}
+
+// Helper function for xcbproto bitcase expressions.  Checks if the bitmasks |t|
+// and |s| have any intersection.
+template <typename T, typename S>
+bool CaseAnd(T t, S s) {
+  return static_cast<EnumBaseType<T>>(t) & static_cast<EnumBaseType<T>>(s);
+}
+
+// Helper function for xcbproto & expressions.  Computes |t| & |s|.
+template <typename T, typename S>
+auto BitAnd(T t, S s) {
+  return static_cast<EnumBaseType<T>>(t) & static_cast<EnumBaseType<T>>(s);
+}
+
+// Helper function for xcbproto ~ expressions.
+template <typename T>
+auto BitNot(T t) {
+  return ~static_cast<EnumBaseType<T>>(t);
+}
+
+// Helper function for generating switch values.  |switch_var| is the value to
+// modify.  |enum_val| is the value to set |switch_var| to if this is a regular
+// case, or the bit to be set in |switch_var| if this is a bit case.  This
+// function is a no-op when |condition| is false.
+template <typename T>
+auto SwitchVar(T enum_val, bool condition, bool is_bitcase, T* switch_var) {
+  using EnumInt = EnumBaseType<T>;
+  if (!condition)
+    return;
+  EnumInt switch_int = static_cast<EnumInt>(*switch_var);
+  if (is_bitcase) {
+    *switch_var = static_cast<T>(switch_int | static_cast<EnumInt>(enum_val));
+  } else {
+    DCHECK(!switch_int);
+    *switch_var = enum_val;
+  }
+}
+
+template <typename T>
+std::unique_ptr<T> MakeExtension(Connection* connection,
+                                 Future<QueryExtensionReply> future) {
+  auto reply = future.Sync();
+  return std::make_unique<T>(connection,
+                             reply ? *reply.reply : QueryExtensionReply{});
+}
+
+}  // namespace x11
+
+#endif  //  UI_GFX_X_XPROTO_INTERNAL_H_
diff --git a/ui/gfx/x/xproto_types.cc b/ui/gfx/x/xproto_types.cc
new file mode 100644
index 0000000..5546cd8
--- /dev/null
+++ b/ui/gfx/x/xproto_types.cc
@@ -0,0 +1,88 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/xproto_types.h"
+
+#include <xcb/xcbext.h>
+
+#include "base/memory/scoped_refptr.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/xproto_internal.h"
+
+namespace x11 {
+
+namespace {
+
+constexpr uint8_t kResponseTypeReply = 1;
+
+struct ReplyHeader {
+  uint8_t response_type;
+  uint8_t pad;
+  uint16_t sequence;
+  uint32_t length;
+};
+
+}  // namespace
+
+ReadBuffer::ReadBuffer(scoped_refptr<base::RefCountedMemory> data,
+                       bool setup_message)
+    : data(data) {
+  // X connection setup uses a special reply without the standard header, see:
+  // https://www.x.org/releases/X11R7.6/doc/xproto/x11protocol.html#server_response
+  // Don't try to parse it like a normal reply.
+  if (setup_message)
+    return;
+
+  const auto* reply_header = reinterpret_cast<const ReplyHeader*>(data->data());
+
+  // Only replies can have FDs, not events or errors.
+  if (reply_header->response_type == kResponseTypeReply) {
+    // All replies are at least 32 bytes.  The length field specifies the
+    // amount of extra data in 4-byte multiples after the fixed 32 bytes.
+    size_t reply_length = 32 + 4 * reply_header->length;
+
+    // libxcb stores the fds after the reply data.
+    fds = reinterpret_cast<const int*>(data->data() + reply_length);
+  }
+}
+
+ReadBuffer::ReadBuffer(ReadBuffer&&) = default;
+
+ReadBuffer::~ReadBuffer() = default;
+
+scoped_refptr<base::RefCountedMemory> ReadBuffer::ReadAndAdvance(
+    size_t length) {
+  auto buf = base::MakeRefCounted<OffsetRefCountedMemory>(data, offset, length);
+  offset += length;
+  return buf;
+}
+
+int ReadBuffer::TakeFd() {
+  return *fds++;
+}
+
+WriteBuffer::WriteBuffer() = default;
+
+WriteBuffer::WriteBuffer(WriteBuffer&&) = default;
+
+WriteBuffer::~WriteBuffer() = default;
+
+void WriteBuffer::AppendBuffer(scoped_refptr<base::RefCountedMemory> buffer,
+                               size_t size) {
+  AppendCurrentBuffer();
+  buffers_.push_back(buffer);
+  offset_ += size;
+}
+
+std::vector<scoped_refptr<base::RefCountedMemory>>& WriteBuffer::GetBuffers() {
+  if (!current_buffer_.empty())
+    AppendCurrentBuffer();
+  return buffers_;
+}
+
+void WriteBuffer::AppendCurrentBuffer() {
+  buffers_.push_back(base::RefCountedBytes::TakeVector(&current_buffer_));
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/xproto_types.h b/ui/gfx/x/xproto_types.h
new file mode 100644
index 0000000..e670fce
--- /dev/null
+++ b/ui/gfx/x/xproto_types.h
@@ -0,0 +1,135 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_XPROTO_TYPES_H_
+#define UI_GFX_X_XPROTO_TYPES_H_
+
+#include <cstdint>
+#include <memory>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/component_export.h"
+#include "base/memory/free_deleter.h"
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_refptr.h"
+
+namespace x11 {
+
+class Error;
+
+constexpr uint8_t kSendEventMask = 0x80;
+
+namespace detail {
+
+template <typename T>
+void VerifyAlignment(T* t, size_t offset) {
+  // On the wire, X11 types are always aligned to their size.  This is a sanity
+  // check to ensure padding etc are working properly.
+  if (sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8)
+    DCHECK_EQ(offset % sizeof(*t), 0UL);
+}
+
+}  // namespace detail
+
+// Wraps data read from the connection.
+struct COMPONENT_EXPORT(X11) ReadBuffer {
+  explicit ReadBuffer(scoped_refptr<base::RefCountedMemory> data,
+                      bool setup_message = false);
+
+  ReadBuffer(const ReadBuffer&) = delete;
+  ReadBuffer(ReadBuffer&&);
+
+  ~ReadBuffer();
+
+  scoped_refptr<base::RefCountedMemory> ReadAndAdvance(size_t length);
+
+  int TakeFd();
+
+  scoped_refptr<base::RefCountedMemory> data;
+  size_t offset = 0;
+  const int* fds = nullptr;
+};
+
+// Wraps data to write to the connection.
+class COMPONENT_EXPORT(X11) WriteBuffer {
+ public:
+  WriteBuffer();
+
+  WriteBuffer(const WriteBuffer&) = delete;
+  WriteBuffer(WriteBuffer&&);
+
+  ~WriteBuffer();
+
+  void AppendBuffer(scoped_refptr<base::RefCountedMemory> buffer, size_t size);
+
+  std::vector<scoped_refptr<base::RefCountedMemory>>& GetBuffers();
+
+  size_t offset() const { return offset_; }
+
+  std::vector<int>& fds() { return fds_; }
+
+  template <typename T>
+  void Write(const T* t) {
+    static_assert(std::is_trivially_copyable<T>::value, "");
+    detail::VerifyAlignment(t, offset_);
+    const uint8_t* start = reinterpret_cast<const uint8_t*>(t);
+    std::copy(start, start + sizeof(*t), std::back_inserter(current_buffer_));
+    offset_ += sizeof(*t);
+  }
+
+ private:
+  void AppendCurrentBuffer();
+
+  std::vector<scoped_refptr<base::RefCountedMemory>> buffers_;
+  std::vector<uint8_t> current_buffer_;
+  size_t offset_ = 0;
+  std::vector<int> fds_;
+};
+
+namespace detail {
+
+template <typename Reply>
+std::unique_ptr<Reply> ReadReply(ReadBuffer* buffer);
+
+}  // namespace detail
+
+template <class Reply>
+class Future;
+
+template <typename T>
+T Read(ReadBuffer* buf);
+
+template <typename T>
+WriteBuffer Write(const T& t);
+
+template <typename T>
+void ReadEvent(T* event, ReadBuffer* buf);
+
+template <typename Reply>
+struct Response {
+  Response(std::unique_ptr<Reply> reply, std::unique_ptr<Error> error)
+      : reply(std::move(reply)), error(std::move(error)) {}
+
+  operator bool() const { return reply.get(); }
+  const Reply* operator->() const { return reply.get(); }
+  Reply* operator->() { return reply.get(); }
+
+  std::unique_ptr<Reply> reply;
+  std::unique_ptr<Error> error;
+};
+
+template <>
+struct Response<void> {
+  std::unique_ptr<Error> error;
+
+ private:
+  friend class Future<void>;
+
+  explicit Response(std::unique_ptr<Error> error) : error(std::move(error)) {}
+};
+
+}  // namespace x11
+
+#endif  //  UI_GFX_X_XPROTO_TYPES_H_
diff --git a/ui/gfx/x/xproto_util.cc b/ui/gfx/x/xproto_util.cc
new file mode 100644
index 0000000..6662b12
--- /dev/null
+++ b/ui/gfx/x/xproto_util.cc
@@ -0,0 +1,42 @@
+// Copyright 2020 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.
+
+#include "ui/gfx/x/xproto_util.h"
+
+namespace x11 {
+
+void DeleteProperty(x11::Window window, x11::Atom name) {
+  x11::Connection::Get()->DeleteProperty({
+      .window = static_cast<x11::Window>(window),
+      .property = name,
+  });
+}
+
+void SetStringProperty(Window window,
+                       Atom property,
+                       Atom type,
+                       const std::string& value,
+                       Connection* connection) {
+  std::vector<char> str(value.begin(), value.end());
+  SetArrayProperty(window, property, type, str, connection);
+}
+
+Window CreateDummyWindow(const std::string& name, Connection* connection) {
+  auto window = connection->GenerateId<Window>();
+  connection->CreateWindow(CreateWindowRequest{
+      .wid = window,
+      .parent = connection->default_root(),
+      .x = -100,
+      .y = -100,
+      .width = 10,
+      .height = 10,
+      .c_class = WindowClass::InputOnly,
+      .override_redirect = Bool32(true),
+  });
+  if (!name.empty())
+    SetStringProperty(window, Atom::WM_NAME, Atom::STRING, name);
+  return window;
+}
+
+}  // namespace x11
diff --git a/ui/gfx/x/xproto_util.h b/ui/gfx/x/xproto_util.h
new file mode 100644
index 0000000..60b1a35
--- /dev/null
+++ b/ui/gfx/x/xproto_util.h
@@ -0,0 +1,129 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_GFX_X_XPROTO_UTIL_H_
+#define UI_GFX_X_XPROTO_UTIL_H_
+
+#include <cstdint>
+
+#include "base/component_export.h"
+#include "ui/gfx/x/connection.h"
+#include "ui/gfx/x/future.h"
+#include "ui/gfx/x/xproto.h"
+#include "ui/gfx/x/xproto_types.h"
+
+namespace x11 {
+
+template <typename T>
+Future<void> SendEvent(const T& event,
+                       Window target,
+                       EventMask mask,
+                       Connection* connection = Connection::Get()) {
+  static_assert(T::type_id > 0, "T must be an *Event type");
+  auto write_buffer = Write(event);
+  DCHECK_EQ(write_buffer.GetBuffers().size(), 1ul);
+  auto& first_buffer = write_buffer.GetBuffers()[0];
+  DCHECK_LE(first_buffer->size(), 32ul);
+  std::vector<uint8_t> event_bytes(32);
+  memcpy(event_bytes.data(), first_buffer->data(), first_buffer->size());
+
+  SendEventRequest send_event{false, target, mask};
+  std::copy(event_bytes.begin(), event_bytes.end(), send_event.event.begin());
+  return connection->SendEvent(send_event);
+}
+
+template <typename T>
+bool GetArrayProperty(Window window,
+                      Atom name,
+                      std::vector<T>* value,
+                      Atom* out_type = nullptr,
+                      size_t amount = 0,
+                      Connection* connection = Connection::Get()) {
+  static_assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4, "");
+
+  size_t bytes = amount * sizeof(T);
+  // The length field specifies the maximum amount of data we would like the
+  // server to give us.  It's specified in units of 4 bytes, so divide by 4.
+  // Add 3 before division to round up.
+  size_t length = (bytes + 3) / 4;
+  using lentype = decltype(GetPropertyRequest::long_length);
+  auto response =
+      connection
+          ->GetProperty(GetPropertyRequest{
+              .window = static_cast<Window>(window),
+              .property = name,
+              .long_length = static_cast<uint32_t>(
+                  amount ? length : std::numeric_limits<lentype>::max())})
+          .Sync();
+  if (!response || response->format != CHAR_BIT * sizeof(T))
+    return false;
+
+  DCHECK_EQ(response->format / CHAR_BIT * response->value_len,
+            response->value->size());
+  value->resize(response->value_len);
+  memcpy(value->data(), response->value->data(), response->value->size());
+  if (out_type)
+    *out_type = response->type;
+  return true;
+}
+
+template <typename T>
+bool GetProperty(Window window,
+                 const Atom name,
+                 T* value,
+                 Connection* connection = Connection::Get()) {
+  std::vector<T> values;
+  if (!GetArrayProperty(window, name, &values, nullptr, 1, connection) ||
+      values.empty()) {
+    return false;
+  }
+  *value = values[0];
+  return true;
+}
+
+template <typename T>
+Future<void> SetArrayProperty(Window window,
+                              Atom name,
+                              Atom type,
+                              const std::vector<T>& values,
+                              Connection* connection = Connection::Get()) {
+  static_assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4, "");
+  std::vector<uint8_t> data(sizeof(T) * values.size());
+  memcpy(data.data(), values.data(), sizeof(T) * values.size());
+  return connection->ChangeProperty(
+      ChangePropertyRequest{.window = static_cast<Window>(window),
+                            .property = name,
+                            .type = type,
+                            .format = CHAR_BIT * sizeof(T),
+                            .data_len = static_cast<uint32_t>(values.size()),
+                            .data = base::RefCountedBytes::TakeVector(&data)});
+}
+
+template <typename T>
+Future<void> SetProperty(Window window,
+                         Atom name,
+                         Atom type,
+                         const T& value,
+                         Connection* connection = Connection::Get()) {
+  return SetArrayProperty(window, name, type, std::vector<T>{value},
+                          connection);
+}
+
+COMPONENT_EXPORT(X11)
+void DeleteProperty(x11::Window window, x11::Atom name);
+
+COMPONENT_EXPORT(X11)
+void SetStringProperty(Window window,
+                       Atom property,
+                       Atom type,
+                       const std::string& value,
+                       Connection* connection = Connection::Get());
+
+COMPONENT_EXPORT(X11)
+Window CreateDummyWindow(const std::string& name = std::string(),
+                         Connection* connection = Connection::Get());
+
+}  // namespace x11
+
+#endif  //  UI_GFX_X_XPROTO_UTIL_H_