Implement proper synchronization between HW video decode IPC and CommandBuffer.

content/common/gpu/gpu_messages.h

 // 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.
 
+// Multiply-included message file, hence no include guard here, but see below
+// for a much smaller-than-usual include guard section.
+
 #include <vector>
 #include <string>
 
-
 #include "base/shared_memory.h"
 #include "content/common/common_param_traits.h"
 #include "content/common/gpu/gpu_info.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/ipc/gpu_command_buffer_traits.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_message_macros.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/size.h"
-// Multiply-included message file, hence no include guard.
+
+// Singly-included section.
+#ifndef CONTENT_COMMON_GPU_GPU_MESSAGES_H_
+#define CONTENT_COMMON_GPU_GPU_MESSAGES_H_
+// typedef is required because commas confuse IPC_MESSAGE_* macro expansions.
+// Pair contains: first: last_token_read, second: last_token_written.
+typedef std::pair<int32, int32> ReadWriteTokens;

[scherkus (not reviewing), 2011/06/27 22:54:47]

do we have to use std::pair?

a struct w/ two fields names last_token_read / last_token_written is
self-documenting and avoids having to find this comment

[Ami GONE FROM CHROMIUM, 2011/06/28 00:06:35]

That's true, but comes at the cost of having to define a custom pickling routine
pair.  I mildly prefer to use the pair with its pre-canned codecs.  Let me know
if you care enough for me to flip it.

[scherkus (not reviewing), 2011/06/28 01:22:15]

If you have an externally declared struct:
struct ReadWriteTokens {
  int32 last_token_read;
  int32 last_token_written;
};

...here you can have:
IPC_STRUCT_TRAITS_BEGIN(ReadWriteTokens)
  IPC_STRUCT_TRAITS_MEMBER(last_token_read)
  IPC_STRUCT_TRAITS_MEMBER(last_token_written)
IPC_STRUCT_TRAITS_END()

...which expands into that pickling stuff for you:
ipc/param_traits_macros.h

Take a look at GPUInfo for an example:
content/common/gpu/gpu_info.h
content/common/gpu/gpu_messages.h

[Ami GONE FROM CHROMIUM, 2011/06/28 21:02:32]

Done.

+#endif  // CONTENT_COMMON_GPU_GPU_MESSAGES_H_
 
 #define IPC_MESSAGE_START GpuMsgStart
 
 IPC_STRUCT_BEGIN(GPUCreateCommandBufferConfig)
   IPC_STRUCT_MEMBER(std::string, allowed_extensions)
   IPC_STRUCT_MEMBER(std::vector<int>, attribs)
   IPC_STRUCT_MEMBER(GURL, active_url)
 IPC_STRUCT_END()
 
 #if defined(OS_MACOSX)
@@ skipping 269 matching lines @@
 
 // Create a surface for offscreen rendering.
 IPC_SYNC_MESSAGE_CONTROL1_1(GpuChannelMsg_CreateOffscreenSurface,
                             gfx::Size, /* size */
                             int /* route_id */)
 
 // Destroy a surface by routing id.
 IPC_MESSAGE_CONTROL1(GpuChannelMsg_DestroySurface,
                      int /* route_id */)
 
-// Create hardware video decoder && associate it with the output |decoder_id|;
+// Create a hardware video decoder; the new route ID is returned through
+// AcceleratedVideoDecoderHostMsg_CreateDone.
 // We need this to be control message because we had to map the GpuChannel and
 // |decoder_id|.
 IPC_MESSAGE_CONTROL3(GpuChannelMsg_CreateVideoDecoder,
-                     int32, /* decoder_id */
+                     int32, /* decoder_host_id */
                      uint32, /* command buffer route id*/
                      std::vector<uint32>) /* configs */
 
 // Release all resource of the hardware video decoder which was assocaited
 // with the input |decoder_id|.
 // TODO(hclam): This message needs to be asynchronous.
 IPC_SYNC_MESSAGE_CONTROL1_0(GpuChannelMsg_DestroyVideoDecoder,
                             int32 /* decoder_id */)
 
 // Create a TransportTexture corresponding to |host_id|.
 IPC_MESSAGE_CONTROL2(GpuChannelMsg_CreateTransportTexture,
                      int32, /* context_route_id */
                      int32 /* host_id */)
 
-// Sent from Renderer process to the GPU process to give the texture IDs for
-// the textures the decoder will use for output.
-IPC_MESSAGE_CONTROL4(GpuChannelMsg_AssignTexturesToVideoDecoder,
-                     int32, /* Decoder ID */
-                     std::vector<int32>, /* Picture buffer ID */
-                     std::vector<uint32>, /* Texture ID */
-                     std::vector<gfx::Size>) /* Size */
 //------------------------------------------------------------------------------
 // GPU Command Buffer Messages
 // These are messages between a renderer process to the GPU process relating to
 // a single OpenGL context.
 // Initialize a command buffer with the given number of command entries.
 // Returns the shared memory handle for the command buffer mapped to the
 // calling process.
 IPC_SYNC_MESSAGE_ROUTED2_1(GpuCommandBufferMsg_Initialize,
                            base::SharedMemoryHandle /* ring_buffer */,
                            int32 /* size */,
@@ skipping 112 matching lines @@
 // Instruct the renderer to release all generated textures.
 IPC_MESSAGE_ROUTED0(GpuTransportTextureHostMsg_ReleaseTextures)
 
 // Notify a texture has been updated. The texture id is in the client context.
 IPC_MESSAGE_ROUTED1(GpuTransportTextureHostMsg_TextureUpdated,
                     int /* texture_id */)
 
 //------------------------------------------------------------------------------
 // Accelerated Video Decoder Messages
 // These messages are sent from Renderer process to GPU process.
+//
+// Most of these messages defer execution until |tokens.second| is seen (using
+// |tokens.first| as a wrap-around indicator).
+
 // Message to query configuration information from the GPU process.
-IPC_SYNC_MESSAGE_CONTROL1_1(AcceleratedVideoDecoderMsg_GetConfigs,
+IPC_SYNC_MESSAGE_CONTROL2_1(AcceleratedVideoDecoderMsg_GetConfigs,
+                            ReadWriteTokens, /* tokens: <read,write> */
                             std::vector<uint32>, /* Proto config */
                             std::vector<uint32>) /* Matching configs */
 
 // Message to initialize the accelerated video decoder.
-IPC_MESSAGE_ROUTED1(AcceleratedVideoDecoderMsg_Initialize,
+IPC_MESSAGE_ROUTED2(AcceleratedVideoDecoderMsg_Initialize,
+                    ReadWriteTokens, /* tokens: <read,write> */
                     std::vector<uint32>) /* Config */
 
 // Send input buffer for decoding.
-IPC_MESSAGE_ROUTED3(AcceleratedVideoDecoderMsg_Decode,
+IPC_MESSAGE_ROUTED4(AcceleratedVideoDecoderMsg_Decode,
+                    ReadWriteTokens, /* tokens: <read,write> */
+                    base::SharedMemoryHandle, /* input_buffer_handle */
                     int32, /* bitstream_buffer_id */
-                    base::SharedMemoryHandle, /* input_buffer_handle */
                     int32) /* size */
 
+// Sent from Renderer process to the GPU process to give the texture IDs for
+// the textures the decoder will use for output.  Delays evaluation until
+// |token.second| is seen.
+IPC_MESSAGE_ROUTED4(AcceleratedVideoDecoderMsg_AssignTextures,
+                    ReadWriteTokens, /* tokens: <read,write> */
+                    std::vector<int32>, /* Picture buffer ID */
+                    std::vector<uint32>, /* Texture ID */
+                    std::vector<gfx::Size>) /* Size */
+
 // Sent from Renderer process to the GPU process to give the system memory
 // buffers that the decoder will use for output.
 //
 // The length of the list of SharedMemoryHandles cannot exceed
 // FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE; see
 // ipc/file_descriptor_set_posix.
-IPC_MESSAGE_ROUTED3(AcceleratedVideoDecoderMsg_AssignSysmemBuffers,
+IPC_MESSAGE_ROUTED4(AcceleratedVideoDecoderMsg_AssignSysmemBuffers,
+                    ReadWriteTokens, /* tokens: <read,write> */
                     std::vector<int32>, /* Picture buffer ID */
                     std::vector<base::SharedMemoryHandle>, /* Sysmem buffer */
                     std::vector<gfx::Size>) /* Size */
 
 // Send from Renderer process to the GPU process to recycle the given picture
 // buffer for further decoding.
-IPC_MESSAGE_ROUTED1(AcceleratedVideoDecoderMsg_ReusePictureBuffer,
+IPC_MESSAGE_ROUTED2(AcceleratedVideoDecoderMsg_ReusePictureBuffer,
+                    ReadWriteTokens, /* tokens: <read,write> */
                     int32) /* Picture buffer ID */
 
 // Send flush request to the decoder.
-IPC_MESSAGE_ROUTED0(AcceleratedVideoDecoderMsg_Flush)
+IPC_MESSAGE_ROUTED1(AcceleratedVideoDecoderMsg_Flush,
+                    ReadWriteTokens) /* tokens: <read,write> */
 
 // Send abort request to the decoder.
-IPC_MESSAGE_ROUTED0(AcceleratedVideoDecoderMsg_Abort)
+IPC_MESSAGE_ROUTED1(AcceleratedVideoDecoderMsg_Abort,
+                    ReadWriteTokens) /* tokens: <read,write> */
 
 // Destroy and release decoder asynchronously.
-IPC_SYNC_MESSAGE_CONTROL0_0(AcceleratedVideoDecoderMsg_Destroy)
+IPC_SYNC_MESSAGE_CONTROL1_0(AcceleratedVideoDecoderMsg_Destroy,
+                            ReadWriteTokens) /* tokens: <read,write> */
 
 //------------------------------------------------------------------------------
 // Accelerated Video Decoder Host Messages
 // These messages are sent from GPU process to Renderer process.
 // Inform AcceleratedVideoDecoderHost that AcceleratedVideoDecoder has been
 // created.
 
 // Accelerated video decoder has consumed input buffer from transfer buffer.
 IPC_MESSAGE_ROUTED1(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed,
                     int32) /* Processed buffer ID */
@@ skipping 28 matching lines @@
 
 // Confirm decoder has been aborted.
 IPC_MESSAGE_ROUTED0(AcceleratedVideoDecoderHostMsg_AbortDone)
 
 // Decoder has faced end of stream marker in the stream.
 IPC_MESSAGE_ROUTED0(AcceleratedVideoDecoderHostMsg_EndOfStream)
 
 // Video decoder has encountered an error.
 IPC_MESSAGE_ROUTED1(AcceleratedVideoDecoderHostMsg_ErrorNotification,
                     uint32) /* Error ID */