Fix to allow NOOP to work again.

command_buffer/service/cross/gapi_decoder.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 72 matching lines @@
 // by a (malicious) client at any time, so if validation has to happen, it
 // should operate on a copy of them.
 BufferSyncInterface::ParseError GAPIDecoder::DoCommand(
     unsigned int command,
     unsigned int arg_count,
     const void* cmd_data) {
   if (command < arraysize(g_command_info)) {
     const CommandInfo& info = g_command_info[command];
   unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count);
     if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) ||
-        (info.arg_flags == cmd::kAtLeastN && arg_count > info_arg_count)) {
+        (info.arg_flags == cmd::kAtLeastN && arg_count >= info_arg_count)) {
       switch (command) {
         #define O3D_COMMAND_BUFFER_CMD_OP(name)                    \
           case cmd::name::kCmdId:                                  \
             return Handle ## name(                                 \
                 arg_count,                                         \
                 *static_cast<const cmd::name*>(cmd_data));         \
 
         O3D_COMMAND_BUFFER_CMDS
 
         #undef O3D_COMMAND_BUFFER_CMD_OP
@@ skipping 79 matching lines @@
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyVertexBuffer(
     uint32 arg_count,
     const cmd::DestroyVertexBuffer& args) {
   return gapi_->DestroyVertexBuffer(args.id);
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexBufferDataImmediate(
     uint32 arg_count,
     const cmd::SetVertexBufferDataImmediate& args) {
+  uint32 size = ImmediateDataSize(arg_count, args);
+  if (size == 0) {
+    return ParseError::kParseNoError;
+  }
   return gapi_->SetVertexBufferData(args.id, args.offset,
-                                    ImmediateDataSize(arg_count, args),
+                                    size,
                                     AddressAfterStruct(args));
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexBufferData(
     uint32 arg_count,
     const cmd::SetVertexBufferData& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
@@ skipping 24 matching lines @@
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyIndexBuffer(
     uint32 arg_count,
     const cmd::DestroyIndexBuffer& args) {
   return gapi_->DestroyIndexBuffer(args.id);
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleSetIndexBufferDataImmediate(
     uint32 arg_count,
     const cmd::SetIndexBufferDataImmediate& args) {
-  return gapi_->SetIndexBufferData(args.id, args.offset,
-                                   ImmediateDataSize(arg_count, args),
+  uint32 size = ImmediateDataSize(arg_count, args);
+  if (size == 0) {
+    return ParseError::kParseNoError;
+  }
+  return gapi_->SetIndexBufferData(args.id, args.offset, size,
                                    AddressAfterStruct(args));
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleSetIndexBufferData(
     uint32 arg_count,
     const cmd::SetIndexBufferData& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
@@ skipping 96 matching lines @@
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleCreateEffectImmediate(
     uint32 arg_count,
     const cmd::CreateEffectImmediate& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   uint32 data_size = ImmediateDataSize(arg_count, args);
   if (size > data_size)
     return BufferSyncInterface::kParseInvalidArguments;
+  if (data_size == 0) {
+    return ParseError::kParseNoError;
+  }
   return gapi_->CreateEffect(args.id, size, AddressAfterStruct(args));
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyEffect(
     uint32 arg_count,
     const cmd::DestroyEffect& args) {
   return gapi_->DestroyEffect(args.id);
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleSetEffect(
@@ skipping 37 matching lines @@
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleCreateParamByNameImmediate(
     uint32 arg_count,
     const cmd::CreateParamByNameImmediate& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   uint32 data_size = ImmediateDataSize(arg_count, args);
   if (size > data_size)
     return BufferSyncInterface::kParseInvalidArguments;
+  if (data_size == 0) {
+    return ParseError::kParseNoError;
+  }
   return gapi_->CreateParamByName(args.param_id, args.effect_id, size,
                                   AddressAfterStruct(args));
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyParam(
     uint32 arg_count,
     const cmd::DestroyParam& args) {
   return gapi_->DestroyParam(args.id);
 }
 
@@ skipping 12 matching lines @@
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleSetParamDataImmediate(
     uint32 arg_count,
     const cmd::SetParamDataImmediate& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   uint32 data_size = ImmediateDataSize(arg_count, args);
   if (size > data_size)
     return BufferSyncInterface::kParseInvalidArguments;
+  if (data_size == 0) {
+    return ParseError::kParseNoError;
+  }
   return gapi_->SetParamData(args.id, size, AddressAfterStruct(args));
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleGetParamDesc(
     uint32 arg_count,
     const cmd::GetParamDesc& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
@@ skipping 150 matching lines @@
   unsigned int height = cmd::Height::Get(width_height);
   unsigned int z = cmd::Z::Get(z_depth);
   unsigned int depth = cmd::Depth::Get(z_depth);
   unsigned int level = cmd::Level::Get(level_face);
   unsigned int face = cmd::Face::Get(level_face);
   unsigned int unused = cmd::Unused::Get(level_face);
   uint32 data_size = ImmediateDataSize(arg_count, args);
   if (face >= 6 || unused != 0 ||
       size > data_size)
     return BufferSyncInterface::kParseInvalidArguments;
+  if (data_size == 0) {
+    return ParseError::kParseNoError;
+  }
   return gapi_->SetTextureData(
       args.texture_id, x, y, z, width, height, depth, level,
       static_cast<texture::Face>(face), args.row_pitch,
       args.slice_pitch, size, AddressAfterStruct(args));
 }
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleGetTextureData(
     uint32 arg_count,
     const cmd::GetTextureData& args) {
   namespace cmd = get_texture_data_cmd;
@@ skipping 303 matching lines @@
 
 BufferSyncInterface::ParseError GAPIDecoder::HandleSetBackSurfaces(
     uint32 arg_count,
     const cmd::SetBackSurfaces& args) {
   gapi_->SetBackSurfaces();
   return  BufferSyncInterface::kParseNoError;
 }
 
 }  // namespace command_buffer
 }  // namespace o3d