Bug 1518111 - Re-generate FFI header. r=kats
authorWR Updater Bot <graphics-team@mozilla.staktrace.com>
Tue, 08 Jan 2019 03:37:55 +0000
changeset 452801 37af3b328b15168bdbc185bdb52e344c3c551da0
parent 452800 d77ee4b960ad795291b03507d9b0edb30f77d6eb
child 452802 275e1a2e1d91468d53642a12fbc41b2cb456cab7
push id35330
push useropoprus@mozilla.com
push dateTue, 08 Jan 2019 09:41:12 +0000
treeherdermozilla-central@4ad5b70956ab [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerskats
bugs1518111
milestone66.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1518111 - Re-generate FFI header. r=kats Depends on D15893 Differential Revision: https://phabricator.services.mozilla.com/D15894
gfx/webrender_bindings/webrender_ffi_generated.h
--- a/gfx/webrender_bindings/webrender_ffi_generated.h
+++ b/gfx/webrender_bindings/webrender_ffi_generated.h
@@ -1,28 +1,29 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-/* Generated with cbindgen:0.6.7 */
+/* Generated with cbindgen:0.6.8 */
 
 /* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.
  * To generate this file:
  *   1. Get the latest cbindgen using `cargo install --force cbindgen`
  *      a. Alternatively, you can clone `https://github.com/eqrion/cbindgen` and use a tagged release
  *   2. Run `rustup run nightly cbindgen toolkit/library/rust/ --lockfile Cargo.lock --crate webrender_bindings -o gfx/webrender_bindings/webrender_ffi_generated.h`
  */
 
+#include <cstdarg>
 #include <cstdint>
 #include <cstdlib>
 
 namespace mozilla {
 namespace wr {
 
-// Whether a border should be antialiased.
+/// Whether a border should be antialiased.
 enum class AntialiasBorder {
   No = 0,
   Yes,
 
   Sentinel /* this must be last for serialization purposes. */
 };
 
 enum class BorderStyle : uint32_t {
@@ -47,39 +48,39 @@ enum class BoxShadowClipMode : uint32_t 
   Sentinel /* this must be last for serialization purposes. */
 };
 
 enum class Checkpoint : uint32_t {
   SceneBuilt,
   FrameBuilt,
   FrameTexturesUpdated,
   FrameRendered,
-  // NotificationRequests get notified with this if they get dropped without having been
-  // notified. This provides the guarantee that if a request is created it will get notified.
+  /// NotificationRequests get notified with this if they get dropped without having been
+  /// notified. This provides the guarantee that if a request is created it will get notified.
   TransactionDropped,
 
   Sentinel /* this must be last for serialization purposes. */
 };
 
 enum class ClipMode {
   Clip,
   ClipOut,
 
   Sentinel /* this must be last for serialization purposes. */
 };
 
-// Specifies the color depth of an image. Currently only used for YUV images.
+/// Specifies the color depth of an image. Currently only used for YUV images.
 enum class ColorDepth : uint8_t {
-  // 8 bits image (most common)
+  /// 8 bits image (most common)
   Color8,
-  // 10 bits image
+  /// 10 bits image
   Color10,
-  // 12 bits image
+  /// 12 bits image
   Color12,
-  // 16 bits image
+  /// 16 bits image
   Color16,
 
   Sentinel /* this must be last for serialization purposes. */
 };
 
 enum class ExtendMode : uint8_t {
   Clamp,
   Repeat,
@@ -113,34 +114,34 @@ enum class FontLCDFilter : uint8_t {
 enum class FontRenderMode : uint32_t {
   Mono = 0,
   Alpha,
   Subpixel,
 
   Sentinel /* this must be last for serialization purposes. */
 };
 
-// Specifies the format of a series of pixels, in driver terms.
+/// Specifies the format of a series of pixels, in driver terms.
 enum class ImageFormat : uint32_t {
-  // One-channel, byte storage. The "red" doesn't map to the color
-  // red per se, and is just the way that OpenGL has historically referred
-  // to single-channel buffers.
+  /// One-channel, byte storage. The "red" doesn't map to the color
+  /// red per se, and is just the way that OpenGL has historically referred
+  /// to single-channel buffers.
   R8 = 1,
-  // One-channel, short storage
+  /// One-channel, short storage
   R16 = 2,
-  // Four channels, byte storage.
+  /// Four channels, byte storage.
   BGRA8 = 3,
-  // Four channels, float storage.
+  /// Four channels, float storage.
   RGBAF32 = 4,
-  // Two-channels, byte storage. Similar to `R8`, this just means
-  // "two channels" rather than "red and green".
+  /// Two-channels, byte storage. Similar to `R8`, this just means
+  /// "two channels" rather than "red and green".
   RG8 = 5,
-  // Four channels, signed integer storage.
+  /// Four channels, signed integer storage.
   RGBAI32 = 6,
-  // Four channels, byte storage.
+  /// Four channels, byte storage.
   RGBA8 = 7,
 
   Sentinel /* this must be last for serialization purposes. */
 };
 
 enum class ImageRendering : uint32_t {
   Auto = 0,
   CrispEdges = 1,
@@ -181,17 +182,17 @@ enum class MixBlendMode : uint32_t {
   Hue = 12,
   Saturation = 13,
   Color = 14,
   Luminosity = 15,
 
   Sentinel /* this must be last for serialization purposes. */
 };
 
-// Used to indicate if an image is opaque, or has an alpha channel.
+/// Used to indicate if an image is opaque, or has an alpha channel.
 enum class OpacityType : uint8_t {
   Opaque = 0,
   HasAlphaChannel = 1,
 
   Sentinel /* this must be last for serialization purposes. */
 };
 
 enum class RepeatMode : uint32_t {
@@ -268,45 +269,44 @@ enum class YuvColorSpace : uint32_t {
   Sentinel /* this must be last for serialization purposes. */
 };
 
 template<typename T>
 struct Arc;
 
 struct Device;
 
-// Geometry in the coordinate system of the render target (screen or intermediate
-// surface) in physical pixels.
+/// Geometry in the coordinate system of the render target (screen or intermediate
+/// surface) in physical pixels.
 struct DevicePixel;
 
 struct DocumentHandle;
 
-// Geometry in a stacking context's local coordinate space (logical pixels).
+/// Geometry in a stacking context's local coordinate space (logical pixels).
 struct LayoutPixel;
 
-// The renderer is responsible for submitting to the GPU the work prepared by the
-// RenderBackend.
-//
-// We have a separate `Renderer` instance for each instance of WebRender (generally
-// one per OS window), and all instances share the same thread.
+/// The renderer is responsible for submitting to the GPU the work prepared by the
+/// RenderBackend.
+/// We have a separate `Renderer` instance for each instance of WebRender (generally
+/// one per OS window), and all instances share the same thread.
 struct Renderer;
 
-// Unit for tile coordinates.
+/// Unit for tile coordinates.
 struct TileCoordinate;
 
-// Represents the work associated to a transaction before scene building.
+/// Represents the work associated to a transaction before scene building.
 struct Transaction;
 
-// The default unit.
+/// The default unit.
 struct UnknownUnit;
 
 template<typename T>
 struct Vec;
 
-// Geometry in the document's coordinate space (logical pixels).
+/// Geometry in the document's coordinate space (logical pixels).
 struct WorldPixel;
 
 struct WrProgramCache;
 
 struct WrShaders;
 
 struct WrState;
 
@@ -348,19 +348,18 @@ struct FontKey {
   bool operator==(const FontKey& aOther) const {
     return mNamespace == aOther.mNamespace &&
            mHandle == aOther.mHandle;
   }
 };
 
 using WrFontKey = FontKey;
 
-// Represents RGBA screen colors with one byte per channel.
-//
-// If the alpha value `a` is 255 the color is opaque.
+/// Represents RGBA screen colors with one byte per channel.
+/// If the alpha value `a` is 255 the color is opaque.
 struct ColorU {
   uint8_t r;
   uint8_t g;
   uint8_t b;
   uint8_t a;
 
   bool operator==(const ColorU& aOther) const {
     return r == aOther.r &&
@@ -376,19 +375,19 @@ struct SyntheticItalics {
   bool operator==(const SyntheticItalics& aOther) const {
     return angle == aOther.angle;
   }
 };
 
 struct FontInstanceOptions {
   FontRenderMode render_mode;
   FontInstanceFlags flags;
-  // When bg_color.a is != 0 and render_mode is FontRenderMode::Subpixel,
-  // the text will be rendered with bg_color.r/g/b as an opaque estimated
-  // background color.
+  /// When bg_color.a is != 0 and render_mode is FontRenderMode::Subpixel,
+  /// the text will be rendered with bg_color.r/g/b as an opaque estimated
+  /// background color.
   ColorU bg_color;
   SyntheticItalics synthetic_italics;
 
   bool operator==(const FontInstanceOptions& aOther) const {
     return render_mode == aOther.render_mode &&
            flags == aOther.flags &&
            bg_color == aOther.bg_color &&
            synthetic_italics == aOther.synthetic_italics;
@@ -454,24 +453,24 @@ struct WrWindowId {
   bool operator<(const WrWindowId& aOther) const {
     return mHandle < aOther.mHandle;
   }
   bool operator<=(const WrWindowId& aOther) const {
     return mHandle <= aOther.mHandle;
   }
 };
 
-// This type carries no valuable semantics for WR. However, it reflects the fact that
-// clients (Servo) may generate pipelines by different semi-independent sources.
-// These pipelines still belong to the same `IdNamespace` and the same `DocumentId`.
-// Having this extra Id field enables them to generate `PipelineId` without collision.
+/// This type carries no valuable semantics for WR. However, it reflects the fact that
+/// clients (Servo) may generate pipelines by different semi-independent sources.
+/// These pipelines still belong to the same `IdNamespace` and the same `DocumentId`.
+/// Having this extra Id field enables them to generate `PipelineId` without collision.
 using PipelineSourceId = uint32_t;
 
-// From the point of view of WR, `PipelineId` is completely opaque and generic as long as
-// it's clonable, serializable, comparable, and hashable.
+/// From the point of view of WR, `PipelineId` is completely opaque and generic as long as
+/// it's clonable, serializable, comparable, and hashable.
 struct PipelineId {
   PipelineSourceId mNamespace;
   uint32_t mHandle;
 
   bool operator==(const PipelineId& aOther) const {
     return mNamespace == aOther.mNamespace &&
            mHandle == aOther.mHandle;
   }
@@ -523,17 +522,17 @@ struct WrPipelineInfo {
   FfiVec<PipelineId> removed_pipelines;
 
   bool operator==(const WrPipelineInfo& aOther) const {
     return epochs == aOther.epochs &&
            removed_pipelines == aOther.removed_pipelines;
   }
 };
 
-// Collection of heap sizes, in bytes.
+/// Collection of heap sizes, in bytes.
 struct MemoryReport {
   uintptr_t primitive_stores;
   uintptr_t clip_stores;
   uintptr_t gpu_cache_metadata;
   uintptr_t gpu_cache_cpu_mirror;
   uintptr_t render_tasks;
   uintptr_t hit_testers;
   uintptr_t fonts;
@@ -581,30 +580,29 @@ struct TypedSize2D {
            height == aOther.height;
   }
 };
 
 using DeviceIntSize = TypedSize2D<int32_t, DevicePixel>;
 
 using LayoutSize = TypedSize2D<float, LayoutPixel>;
 
-// Describes the memory layout of a display list.
-//
-// A display list consists of some number of display list items, followed by a number of display
-// items.
+/// Describes the memory layout of a display list.
+/// A display list consists of some number of display list items, followed by a number of display
+/// items.
 struct BuiltDisplayListDescriptor {
-  // The first IPC time stamp: before any work has been done
+  /// The first IPC time stamp: before any work has been done
   uint64_t builder_start_time;
-  // The second IPC time stamp: after serialization
+  /// The second IPC time stamp: after serialization
   uint64_t builder_finish_time;
-  // The third IPC time stamp: just before sending
+  /// The third IPC time stamp: just before sending
   uint64_t send_start_time;
-  // The amount of clipping nodes created while building this display list.
+  /// The amount of clipping nodes created while building this display list.
   uintptr_t total_clip_nodes;
-  // The amount of spatial nodes created while building this display list.
+  /// The amount of spatial nodes created while building this display list.
   uintptr_t total_spatial_nodes;
 
   bool operator==(const BuiltDisplayListDescriptor& aOther) const {
     return builder_start_time == aOther.builder_start_time &&
            builder_finish_time == aOther.builder_finish_time &&
            send_start_time == aOther.send_start_time &&
            total_clip_nodes == aOther.total_clip_nodes &&
            total_spatial_nodes == aOther.total_spatial_nodes;
@@ -618,17 +616,17 @@ struct WrVecU8 {
 
   bool operator==(const WrVecU8& aOther) const {
     return data == aOther.data &&
            length == aOther.length &&
            capacity == aOther.capacity;
   }
 };
 
-// A 2d Point tagged with a unit.
+/// A 2d Point tagged with a unit.
 template<typename T, typename U>
 struct TypedPoint2D {
   T x;
   T y;
 
   bool operator==(const TypedPoint2D& aOther) const {
     return x == aOther.x &&
            y == aOther.y;
@@ -648,17 +646,17 @@ struct WrDebugFlags {
 struct WrClipId {
   uintptr_t id;
 
   bool operator==(const WrClipId& aOther) const {
     return id == aOther.id;
   }
 };
 
-// A 2d Rectangle optionally tagged with a unit.
+/// A 2d Rectangle optionally tagged with a unit.
 template<typename T, typename U>
 struct TypedRect {
   TypedPoint2D<T, U> origin;
   TypedSize2D<T, U> size;
 
   bool operator==(const TypedRect& aOther) const {
     return origin == aOther.origin &&
            size == aOther.size;
@@ -677,34 +675,34 @@ struct BorderRadius {
     return top_left == aOther.top_left &&
            top_right == aOther.top_right &&
            bottom_left == aOther.bottom_left &&
            bottom_right == aOther.bottom_right;
   }
 };
 
 struct ComplexClipRegion {
-  // The boundaries of the rectangle.
+  /// The boundaries of the rectangle.
   LayoutRect rect;
-  // Border radii of this rectangle.
+  /// Border radii of this rectangle.
   BorderRadius radii;
-  // Whether we are clipping inside or outside
-  // the region.
+  /// Whether we are clipping inside or outside
+  /// the region.
   ClipMode mode;
 
   bool operator==(const ComplexClipRegion& aOther) const {
     return rect == aOther.rect &&
            radii == aOther.radii &&
            mode == aOther.mode;
   }
 };
 
-// An opaque identifier describing an image registered with WebRender.
-// This is used as a handle to reference images, and is used as the
-// hash map key for the actual image storage in the `ResourceCache`.
+/// An opaque identifier describing an image registered with WebRender.
+/// This is used as a handle to reference images, and is used as the
+/// hash map key for the actual image storage in the `ResourceCache`.
 struct ImageKey {
   IdNamespace mNamespace;
   uint32_t mHandle;
 
   bool operator==(const ImageKey& aOther) const {
     return mNamespace == aOther.mNamespace &&
            mHandle == aOther.mHandle;
   }
@@ -723,34 +721,34 @@ struct WrImageMask {
 
   bool operator==(const WrImageMask& aOther) const {
     return image == aOther.image &&
            rect == aOther.rect &&
            repeat == aOther.repeat;
   }
 };
 
-// The minimum and maximum allowable offset for a sticky frame in a single dimension.
+/// The minimum and maximum allowable offset for a sticky frame in a single dimension.
 struct StickyOffsetBounds {
-  // The minimum offset for this frame, typically a negative value, which specifies how
-  // far in the negative direction the sticky frame can offset its contents in this
-  // dimension.
+  /// The minimum offset for this frame, typically a negative value, which specifies how
+  /// far in the negative direction the sticky frame can offset its contents in this
+  /// dimension.
   float min;
-  // The maximum offset for this frame, typically a positive value, which specifies how
-  // far in the positive direction the sticky frame can offset its contents in this
-  // dimension.
+  /// The maximum offset for this frame, typically a positive value, which specifies how
+  /// far in the positive direction the sticky frame can offset its contents in this
+  /// dimension.
   float max;
 
   bool operator==(const StickyOffsetBounds& aOther) const {
     return min == aOther.min &&
            max == aOther.max;
   }
 };
 
-// A 2d Vector tagged with a unit.
+/// A 2d Vector tagged with a unit.
 template<typename T, typename U>
 struct TypedVector2D {
   T x;
   T y;
 
   bool operator==(const TypedVector2D& aOther) const {
     return x == aOther.x &&
            y == aOther.y;
@@ -771,20 +769,19 @@ struct TypedSideOffsets2D {
            right == aOther.right &&
            bottom == aOther.bottom &&
            left == aOther.left;
   }
 };
 
 using LayoutSideOffsets = TypedSideOffsets2D<float, LayoutPixel>;
 
-// Represents RGBA screen colors with floating point numbers.
-//
-// All components must be between 0.0 and 1.0.
-// An alpha value of 1.0 is opaque while 0.0 is fully transparent.
+/// Represents RGBA screen colors with floating point numbers.
+/// All components must be between 0.0 and 1.0.
+/// An alpha value of 1.0 is opaque while 0.0 is fully transparent.
 struct ColorF {
   float r;
   float g;
   float b;
   float a;
 
   bool operator==(const ColorF& aOther) const {
     return r == aOther.r &&
@@ -799,17 +796,17 @@ struct BorderSide {
   BorderStyle style;
 
   bool operator==(const BorderSide& aOther) const {
     return color == aOther.color &&
            style == aOther.style;
   }
 };
 
-// The default side offset type with no unit.
+/// The default side offset type with no unit.
 template<typename T>
 using SideOffsets2D = TypedSideOffsets2D<T, UnknownUnit>;
 
 using LayoutPoint = TypedPoint2D<float, LayoutPixel>;
 
 struct GradientStop {
   float offset;
   ColorF color;
@@ -837,27 +834,25 @@ struct WrAnimationProperty {
   uint64_t id;
 
   bool operator==(const WrAnimationProperty& aOther) const {
     return effect_type == aOther.effect_type &&
            id == aOther.id;
   }
 };
 
-// A 3d transform stored as a 4 by 4 matrix in row-major order in memory.
-//
-// Transforms can be parametrized over the source and destination units, to describe a
-// transformation from a space to another.
-// For example, `TypedTransform3D<f32, WorldSpace, ScreenSpace>::transform_point3d`
-// takes a `TypedPoint3D<f32, WorldSpace>` and returns a `TypedPoint3D<f32, ScreenSpace>`.
-//
-// Transforms expose a set of convenience methods for pre- and post-transformations.
-// A pre-transformation corresponds to adding an operation that is applied before
-// the rest of the transformation, while a post-transformation adds an operation
-// that is applied after.
+/// A 3d transform stored as a 4 by 4 matrix in row-major order in memory.
+/// Transforms can be parametrized over the source and destination units, to describe a
+/// transformation from a space to another.
+/// For example, `TypedTransform3D<f32, WorldSpace, ScreenSpace>::transform_point3d`
+/// takes a `TypedPoint3D<f32, WorldSpace>` and returns a `TypedPoint3D<f32, ScreenSpace>`.
+/// Transforms expose a set of convenience methods for pre- and post-transformations.
+/// A pre-transformation corresponds to adding an operation that is applied before
+/// the rest of the transformation, while a post-transformation adds an operation
+/// that is applied after.
 template<typename T, typename Src, typename Dst>
 struct TypedTransform3D {
   T m11;
   T m12;
   T m13;
   T m14;
   T m21;
   T m22;
@@ -897,22 +892,22 @@ using LayoutTransform = TypedTransform3D
 struct WrFilterOp {
   WrFilterOpType filter_type;
   float argument;
   LayoutVector2D offset;
   ColorF color;
   float matrix[20];
 };
 
-// Configure whether the contents of a stacking context
-// should be rasterized in local space or screen space.
-// Local space rasterized pictures are typically used
-// when we want to cache the output, and performance is
-// important. Note that this is a performance hint only,
-// which WR may choose to ignore.
+/// Configure whether the contents of a stacking context
+/// should be rasterized in local space or screen space.
+/// Local space rasterized pictures are typically used
+/// when we want to cache the output, and performance is
+/// important. Note that this is a performance hint only,
+/// which WR may choose to ignore.
 union RasterSpace {
   enum class Tag : uint32_t {
     Local,
     Screen,
 
     Sentinel /* this must be last for serialization purposes. */
   };
 
@@ -925,17 +920,17 @@ union RasterSpace {
     }
   };
 
   struct {
     Tag tag;
   };
   Local_Body local;
 
-  static RasterSpace Local(float const& a0) {
+  static RasterSpace Local(const float &a0) {
     RasterSpace result;
     result.local._0 = a0;
     result.tag = Tag::Local;
     return result;
   }
 
   static RasterSpace Screen() {
     RasterSpace result;
@@ -1007,21 +1002,20 @@ struct MutByteSlice {
   uintptr_t len;
 
   bool operator==(const MutByteSlice& aOther) const {
     return buffer == aOther.buffer &&
            len == aOther.len;
   }
 };
 
-// A C function that takes a pointer to a heap allocation and returns its size.
-//
-// This is borrowed from the malloc_size_of crate, upon which we want to avoid
-// a dependency from WebRender.
-using VoidPtrToSizeFn = uintptr_t(*)(const void*);
+/// A C function that takes a pointer to a heap allocation and returns its size.
+/// This is borrowed from the malloc_size_of crate, upon which we want to avoid
+/// a dependency from WebRender.
+using VoidPtrToSizeFn = uintptr_t(*)(const void *ptr);
 
 struct RendererStats {
   uintptr_t total_draw_calls;
   uintptr_t alpha_target_count;
   uintptr_t color_target_count;
   uintptr_t texture_upload_kb;
   uint64_t resource_upload_time;
   uint64_t gpu_cache_upload_time;
@@ -1077,19 +1071,19 @@ struct WrExternalImageHandler {
 
   bool operator==(const WrExternalImageHandler& aOther) const {
     return external_image_obj == aOther.external_image_obj &&
            lock_func == aOther.lock_func &&
            unlock_func == aOther.unlock_func;
   }
 };
 
-// An opaque identifier describing a blob image registered with WebRender.
-// This is used as a handle to reference blob images, and can be used as an
-// image in display items.
+/// An opaque identifier describing a blob image registered with WebRender.
+/// This is used as a handle to reference blob images, and can be used as an
+/// image in display items.
 struct BlobImageKey {
   ImageKey _0;
 
   bool operator==(const BlobImageKey& aOther) const {
     return _0 == aOther._0;
   }
 };
 
@@ -1570,42 +1564,42 @@ void wr_dp_push_text(WrState *aState,
                      bool aIsBackfaceVisible,
                      ColorF aColor,
                      WrFontInstanceKey aFontKey,
                      const GlyphInstance *aGlyphs,
                      uint32_t aGlyphCount,
                      const GlyphOptions *aGlyphOptions)
 WR_FUNC;
 
-// Push a 2 planar NV12 image.
+/// Push a 2 planar NV12 image.
 WR_INLINE
 void wr_dp_push_yuv_NV12_image(WrState *aState,
                                LayoutRect aBounds,
                                LayoutRect aClip,
                                bool aIsBackfaceVisible,
                                WrImageKey aImageKey0,
                                WrImageKey aImageKey1,
                                WrColorDepth aColorDepth,
                                WrYuvColorSpace aColorSpace,
                                ImageRendering aImageRendering)
 WR_FUNC;
 
-// Push a yuv interleaved image.
+/// Push a yuv interleaved image.
 WR_INLINE
 void wr_dp_push_yuv_interleaved_image(WrState *aState,
                                       LayoutRect aBounds,
                                       LayoutRect aClip,
                                       bool aIsBackfaceVisible,
                                       WrImageKey aImageKey0,
                                       WrColorDepth aColorDepth,
                                       WrYuvColorSpace aColorSpace,
                                       ImageRendering aImageRendering)
 WR_FUNC;
 
-// Push a 3 planar yuv image.
+/// Push a 3 planar yuv image.
 WR_INLINE
 void wr_dp_push_yuv_planar_image(WrState *aState,
                                  LayoutRect aBounds,
                                  LayoutRect aClip,
                                  bool aIsBackfaceVisible,
                                  WrImageKey aImageKey0,
                                  WrImageKey aImageKey1,
                                  WrImageKey aImageKey2,