Make a new test to enforce the sizes of all structs and enums in the C API....

ppapi/c/dev/pp_video_dev.h

 // 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.
 
 #ifndef PPAPI_C_DEV_PP_VIDEO_DEV_H_
 #define PPAPI_C_DEV_PP_VIDEO_DEV_H_
 
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
@@ skipping 21 matching lines @@
   PP_VIDEOKEY_FRAMEINFOFLAG,
 
   // Subset for H.264 features, value of 1 means supported. This is needed in
   // case decoder has partial support for certain profile.
   PP_VIDEOKEY_H264FEATURE_FMO = 0x100,
   PP_VIDEOKEY_H264FEATURE_ASO,
   PP_VIDEOKEY_H264FEATURE_INTERLACE,
   PP_VIDEOKEY_H264FEATURE_CABAC,
   PP_VIDEOKEY_H264FEATURE_WEIGHTEDPREDICTION
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoKey_Dev, 4);
 
 enum PP_VideoDecoderEvent_Dev {
   PP_VIDEODECODEREVENT_NONE = 0,
   // Signaling that an error has been hit.
   PP_VIDEODECODEREVENT_ERROR,
   // Signaling new width/height of video frame
   PP_VIDEODECODEREVENT_NEWDIMENSION,
   // Signaling new cropping rectangle
   PP_VIDEODECODEREVENT_NEWCROP
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoDecoderEvent_Dev, 4);
 
 enum PP_VideoDecodeError_Dev {
   PP_VIDEODECODEERROR_NONE = 0,
   PP_VIDEODECODEERROR_NOTSUPPORTED,
   PP_VIDEODECODEERROR_INSUFFICIENTRESOURCES,
   PP_VIDEODECODEERROR_UNDEFINED,
   PP_VIDEODECODEERROR_BADINPUT,
   PP_VIDEODECODEERROR_HARDWARE
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoDecodeError_Dev, 4);
 
 enum PP_VideoCodecId_Dev {
   PP_VIDEODECODECID_NONE = 0,
   PP_VIDEODECODECID_H264,
   PP_VIDEODECODECID_VC1,
   PP_VIDEODECODECID_MPEG2,
   PP_VIDEODECODECID_VP8
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoCodecId_Dev, 4);
 
 enum PP_VideoOperation_Dev {
   PP_VIDEOOPERATION_NONE = 0,
   PP_VIDEOOPERATION_DECODE,
   PP_VIDEOOPERATION_ENCODE
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoOperation_Dev, 4);
 
 enum PP_VideoCodecProfile_Dev {
   PP_VIDEOCODECPROFILE_NONE = 0,
   PP_VIDEOCODECPROFILE_H264_BASELINE,
   PP_VIDEOCODECPROFILE_H264_MAIN,
   PP_VIDEOCODECPROFILE_H264_EXTENDED,
   PP_VIDEOCODECPROFILE_H264_HIGH,
   PP_VIDEOCODECPROFILE_H264_SCALABLEBASELINE,
   PP_VIDEOCODECPROFILE_H264_SCALABLEHIGH,
   PP_VIDEOCODECPROFILE_H264_STEREOHIGH,
   PP_VIDEOCODECPROFILE_H264_MULTIVIEWHIGH,
 
   PP_VIDEOCODECPROFILE_VC1_SIMPLE = 0x40,
   PP_VIDEOCODECPROFILE_VC1_MAIN,
   PP_VIDEOCODECPROFILE_VC1_ADVANCED,
 
   PP_VIDEOCODECPROFILE_MPEG2_SIMPLE = 0x80,
   PP_VIDEOCODECPROFILE_MPEG2_MAIN,
   PP_VIDEOCODECPROFILE_MPEG2_SNR,
   PP_VIDEOCODECPROFILE_MPEG2_SPATIAL,
   PP_VIDEOCODECPROFILE_MPEG2_HIGH
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoCodecProfile_Dev, 4);
 
 enum PP_VideoCodecLevel_Dev {
   PP_VIDEOCODECLEVEL_NONE = 0,
   PP_VIDEOCODECLEVEL_H264_10,
   PP_VIDEOCODECLEVEL_H264_1B,
   PP_VIDEOCODECLEVEL_H264_11,
   PP_VIDEOCODECLEVEL_H264_12,
   PP_VIDEOCODECLEVEL_H264_13,
   PP_VIDEOCODECLEVEL_H264_20,
   PP_VIDEOCODECLEVEL_H264_21,
@@ skipping 14 matching lines @@
   PP_VIDEOCODECLEVEL_VC1_L1,
   PP_VIDEOCODECLEVEL_VC1_L2,
   PP_VIDEOCODECLEVEL_VC1_L3,
   PP_VIDEOCODECLEVEL_VC1_L4,
 
   PP_VIDEOCODECLEVEL_MPEG2_LOW = 0x80,
   PP_VIDEOCODECLEVEL_MPEG2_MAIN,
   PP_VIDEOCODECLEVEL_MPEG2_HIGH1440,
   PP_VIDEOCODECLEVEL_MPEG2_HIGH
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoCodecLevel_Dev, 4);
 
 enum PP_VideoPayloadFormat_Dev {
   PP_VIDEOPAYLOADFORMAT_NONE = 0,
   PP_VIDEOPAYLOADFORMAT_BYTESTREAM,
   PP_VIDEOPAYLOADFORMAT_RTPPAYLOAD
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoPayloadFormat_Dev, 4);
 
 enum PP_VideoFrameColorType_Dev {
   PP_VIDEOFRAMECOLORTYPE_NONE = 0,
   PP_VIDEOFRAMECOLORTYPE_RGB565,
   PP_VIDEOFRAMECOLORTYPE_ARGB8888,
   PP_VIDEOFRAMECOLORTYPE_YUV,
   PP_VIDEOFRAMECOLORTYPE_Monochrome,
   PP_VIDEOFRAMECOLORTYPE_YUV420PLANAR,
   PP_VIDEOFRAMECOLORTYPE_YUV422PLANAR,
   PP_VIDEOFRAMECOLORTYPE_YUV444PLANAR
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoFrameColorType_Dev, 4);
 
 enum PP_VideoFrameSurfaceType_Dev {
   PP_VIDEOFRAMESURFACETYPE_NONE = 0,
   PP_VIDEOFRAMESURFACETYPE_SYSTEMMEMORY,
   PP_VIDEOFRAMESURFACETYPE_GLTEXTURE,
   PP_VIDEOFRAMESURFACETYPE_PIXMAP
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoFrameSurfaceType_Dev, 4);
 
 enum PP_VideoFrameInfoFlag_Dev {
   PP_VIDEOFRAMEINFOFLAG_NONE = 0,
   // Indicate this is the end of stream. Used by both plugin and browser.
   PP_VIDEOFRAMEINFOFLAG_EOS = 1 << 0,
   // Decode the frame only, don't return decoded frame. Used by plugin.
   PP_VIDEOFRAMEINFOFLAG_NOEMIT = 1 << 1,
   // Indicate this is an anchor frame. Used by plugin.
   PP_VIDEOFRAMEINFOFLAG_SYNCFRAME = 1 << 2,
   // Indicate the decoded frame has data corruption. Used by browser.
   PP_VIDEOFRAMEINFOFLAG_DATACORRUPT = 1 << 3
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoFrameInfoFlag_Dev, 4);
 
 enum PP_VideoFrameBufferConst_Dev {
   // YUV formats
   PP_VIDEOFRAMEBUFFER_YPLANE = 0,
   PP_VIDEOFRAMEBUFFER_UPLANE = 1,
   PP_VIDEOFRAMEBUFFER_VPLANE = 2,
   PP_VIDEOFRAMEBUFFER_NUMBERYUVPLANES = 3,
 
   // RGBA formats
   PP_VIDEOFRAMEBUFFER_RGBAPLANE = 0,
   PP_VIDEOFRAMEBUFFER_NUMBERRGBAPLANES = 1,
 
   PP_VIDEOFRAMEBUFFER_MAXNUMBERPLANES = 4
 };
+PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(PP_VideoFrameBufferConst_Dev, 4);
 
 typedef int64_t PP_VideoDecodeData_Dev;
+PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_VideoDecodeData_Dev, 8);
 
 // Array of key/value pairs describing video configuration.
 // It could include any keys from PP_VideoKey. Its last element shall be
 // PP_VIDEOKEY_NONE with no corresponding value.
 // An example:
 // {
 //   PP_VIDEOKEY_CODECID,      PP_VIDEODECODECID_H264,
 //   PP_VIDEOKEY_OPERATION,    PP_VIDEOOPERATION_DECODE,
 //   PP_VIDEOKEY_CODECPROFILE, PP_VIDEOCODECPROFILE_H264_HIGH,
 //   PP_VIDEOKEY_CODECLEVEL,   PP_VIDEOCODECLEVEL_H264_41,
 //   PP_VIDEOKEY_ACCELERATION, 1
 //   PP_VIDEOKEY_NONE,
 // };
 typedef int32_t* PP_VideoConfig_Dev;
 typedef int32_t PP_VideoConfigElement_Dev;
+PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_VideoConfigElement_Dev, 4);
 
 // The data structure for compressed data buffer.
 struct PP_VideoCompressedDataBuffer_Dev {
   // The buffer is created through PPB_Buffer API.
   // TODO(wjia): would uint8_t* be good, too?
   PP_Resource buffer;
+
   // number of bytes with real data in the buffer.
   int32_t filled_size;
 
+  // Bit mask of PP_VideoFrameInfoFlag.
+  uint32_t flags;
+
   // Time stamp of the frame in microsecond.
   uint64_t time_stamp_us;
-
-  // Bit mask of PP_VideoFrameInfoFlag.
-  uint32_t flags;
 };
+PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_VideoCompressedDataBuffer_Dev, 24);
 
 struct PP_VideoFrameBuffer_Dev {
   union {
     struct {
-      int32_t planes;
       struct {
         int32_t width;
         int32_t height;
         int32_t stride;
 
+        // Padding to ensure the PP_Resource is 8-byte aligned relative to the
+        // start of the struct.  This helps ensure PP_VideoFrameBuffer_Dev has
+        // consistent size and alignment across compilers.
+        int32_t padding;
+
         // TODO(wjia): uint8* would be better for some cases.
         PP_Resource buffer;
       } data_plane[PP_VIDEOFRAMEBUFFER_MAXNUMBERPLANES];
+
+      int32_t planes;
+      int32_t padding;
     } sys_mem;
 
     // Handle for pixmap, gl texture, etc.
     void* handle;
   } buffer;
 
   // Storage for decoder to save some private data. It could be useful when
   // plugin returns frame buffer to decoder.
   void* private_handle;
+
+  // In some 32-bit platforms (NaCl and Win32), this struct is 8-byte aligned
+  // due to the PP_Resource above.  That causes the compiler to pad it an extra
+  // 4 bytes on the end.  In other 32-bit platforms, there is no such pad.  This
+  // padding ensures that the size is consistent on 32-bit platforms (and it
+  // is still consistent on 64-bit platforms, just bigger than it would be
+  // without the padding).
+  int32_t padding;
 };
 
 struct PP_VideoUncompressedDataBuffer_Dev {
   PP_VideoConfig_Dev format;
-  struct PP_VideoFrameBuffer_Dev buffer;
+
+  // Bit mask of PP_VideoFrameInfoFlag.
+  uint32_t flags;
 
   // Time stamp of the frame in microsecond.
   uint64_t time_stamp_us;
 
-  // Bit mask of PP_VideoFrameInfoFlag.
-  uint32_t flags;
+  struct PP_VideoFrameBuffer_Dev buffer;
 
   // Output from decoder, indicating the decoded frame has error pixels. This
   // could be resulted from corrupted input bit stream and error concealment
   // in decoding.  PP_TRUE indicates error.
   // TODO(wjia): add more info about error pixels, such as error MB map, etc.
   PP_Bool error;
+
+  // TODO(dmichael): document
+  int32_t padding;
 };
 
 // Plugin callback for decoder to deliver decoded frame buffers.
 // |format| in |buffer| specifies the format of decoded frame, with
 // PP_VIDEOKEY_COLORTYPE and PP_VIDEOKEY_SURFACETYPE required.
 typedef void (*PP_VideoDecodeOutputCallback_Func_Dev)(
     PP_Instance instance,
     struct PP_VideoUncompressedDataBuffer_Dev* buffer);
 
 // Plugin callback for decoder to return input data buffers.
@@ skipping 20 matching lines @@
 // Requested decoder configuration and callback from plugin.
 struct PP_VideoDecoderConfig_Dev {
   PP_VideoConfig_Dev input_format;
   PP_VideoConfig_Dev output_format;
   PP_VideoDecodeOutputCallback_Func_Dev output_callback;
   PP_VideoDecodeInputCallback_Func_Dev input_callback;
   PP_VideoDecodeEventHandler_Func_Dev event_handler;
 };
 
 #endif  // PPAPI_C_DEV_PP_VIDEO_DEV_H_