Trace/Replay: Pass CallCapture to parameter replay writer.

null77 · Commit Bot · commit 263232efc8be · 2020-02-24T22:03:43.000Z
This will allow more advanced processing when writing the cpp replay for a specific parmeter. For the uniform locations map it'll allow us to look up the specified program from the call parameters. Bug: angleproject:4411 Change-Id: I4e91b3e4c6775c42140d00b2d155344b553a7404 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2067629 Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com> Reviewed-by: Cody Northrop <cnorthrop@google.com> Commit-Queue: Jamie Madill <jmadill@chromium.org>
diff --git a/scripts/code_generation_hashes/GL_EGL_entry_points.json b/scripts/code_generation_hashes/GL_EGL_entry_points.json
@@ -6,7 +6,7 @@
   "scripts/entry_point_packed_gl_enums.json":
     "63f508a08611e75810daedb297dca0e9",
   "scripts/generate_entry_points.py":
-    "2e6615919533b8ca9042093287589165",
+    "e12540094b7f57778de97b05c16d2e28",
   "scripts/gl.xml":
     "2af7b077ec347349b3a92683e8fb8b03",
   "scripts/gl_angle_ext.xml":
@@ -96,9 +96,9 @@
   "src/libANGLE/frame_capture_replay_autogen.cpp":
     "c0d57704c21e0032a486a6195ddb87e4",
   "src/libANGLE/frame_capture_utils_autogen.cpp":
-    "ef0545342e0458e55e17abf46a8cde60",
+    "cf2257638fb6df56061721775efda084",
   "src/libANGLE/frame_capture_utils_autogen.h":
-    "637125f7c18f05c17800e5da2516fd6b",
+    "1cd48ca4faeba4379456943d002ea412",
   "src/libANGLE/validationES1_autogen.h":
     "c8edb0a5b26303bf7c4692b9d0b05c1f",
   "src/libANGLE/validationES2_autogen.h":
diff --git a/scripts/generate_entry_points.py b/scripts/generate_entry_points.py
@@ -563,7 +563,10 @@ class Context;
     }}
 }}
 
-void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue& paramValue);
+struct CallCapture;
+struct ParamCapture;
+
+void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param);
 const char *ParamTypeToString(ParamType paramType);
 
 enum class ResourceIDType
@@ -594,9 +597,9 @@ class Context;
 
 namespace angle
 {{
-void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue& paramValue)
+void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param)
 {{
-    switch (paramType)
+    switch (param.type)
     {{
 {write_param_type_to_stream_cases}
         default:
@@ -659,7 +662,7 @@ class Context;
             break;"""
 
 template_write_param_type_to_stream_case = """        case ParamType::T{enum}:
-            WriteParamValueToStream<ParamType::T{enum}>(os, paramValue.{union_name});
+            WriteParamValueReplay<ParamType::T{enum}>(os, call, param.value.{union_name});
             break;"""
 
 template_param_type_to_string_case = """        case ParamType::T{enum}:
diff --git a/src/libANGLE/FrameCapture.cpp b/src/libANGLE/FrameCapture.cpp
@@ -487,7 +487,7 @@ void WriteCppReplayForCall(const CallCapture &call,
             }
             else
             {
-                callOut << param;
+                WriteParamCaptureReplay(callOut, call, param);
             }
         }
         else
@@ -2584,12 +2584,6 @@ void FrameCapture::reset()
     // necessary.
 }
 
-std::ostream &operator<<(std::ostream &os, const ParamCapture &capture)
-{
-    WriteParamTypeToStream(os, capture.type, capture.value);
-    return os;
-}
-
 void CaptureMemory(const void *source, size_t size, ParamCapture *paramCapture)
 {
     std::vector<uint8_t> data(size);
@@ -2632,7 +2626,9 @@ void CaptureGenHandlesImpl(GLsizei n, GLuint *handles, ParamCapture *paramCaptur
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TGLboolean>(std::ostream &os, GLboolean value)
+void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  GLboolean value)
 {
     switch (value)
     {
@@ -2648,7 +2644,9 @@ void WriteParamValueToStream<ParamType::TGLboolean>(std::ostream &os, GLboolean
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TvoidConstPointer>(std::ostream &os, const void *value)
+void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os,
+                                                         const CallCapture &call,
+                                                         const void *value)
 {
     if (value == 0)
     {
@@ -2662,103 +2660,133 @@ void WriteParamValueToStream<ParamType::TvoidConstPointer>(std::ostream &os, con
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TGLDEBUGPROCKHR>(std::ostream &os, GLDEBUGPROCKHR value)
+void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       GLDEBUGPROCKHR value)
 {}
 
 template <>
-void WriteParamValueToStream<ParamType::TGLDEBUGPROC>(std::ostream &os, GLDEBUGPROC value)
+void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os,
+                                                    const CallCapture &call,
+                                                    GLDEBUGPROC value)
 {}
 
 template <>
-void WriteParamValueToStream<ParamType::TBufferID>(std::ostream &os, gl::BufferID value)
+void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os,
+                                                 const CallCapture &call,
+                                                 gl::BufferID value)
 {
     os << "gBufferMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TFenceNVID>(std::ostream &os, gl::FenceNVID value)
+void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::FenceNVID value)
 {
     os << "gFenceMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TFramebufferID>(std::ostream &os, gl::FramebufferID value)
+void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os,
+                                                      const CallCapture &call,
+                                                      gl::FramebufferID value)
 {
     os << "gFramebufferMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TMemoryObjectID>(std::ostream &os, gl::MemoryObjectID value)
+void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       gl::MemoryObjectID value)
 {
     os << "gMemoryObjectMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TPathID>(std::ostream &os, gl::PathID value)
+void WriteParamValueReplay<ParamType::TPathID>(std::ostream &os,
+                                               const CallCapture &call,
+                                               gl::PathID value)
 {
     os << "gPathMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TProgramPipelineID>(std::ostream &os,
-                                                            gl::ProgramPipelineID value)
+void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os,
+                                                          const CallCapture &call,
+                                                          gl::ProgramPipelineID value)
 {
     os << "gProgramPipelineMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TQueryID>(std::ostream &os, gl::QueryID value)
+void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os,
+                                                const CallCapture &call,
+                                                gl::QueryID value)
 {
     os << "gQueryMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TRenderbufferID>(std::ostream &os, gl::RenderbufferID value)
+void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       gl::RenderbufferID value)
 {
     os << "gRenderbufferMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TSamplerID>(std::ostream &os, gl::SamplerID value)
+void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::SamplerID value)
 {
     os << "gSamplerMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TSemaphoreID>(std::ostream &os, gl::SemaphoreID value)
+void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os,
+                                                    const CallCapture &call,
+                                                    gl::SemaphoreID value)
 {
     os << "gSempahoreMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TShaderProgramID>(std::ostream &os,
-                                                          gl::ShaderProgramID value)
+void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os,
+                                                        const CallCapture &call,
+                                                        gl::ShaderProgramID value)
 {
     os << "gShaderProgramMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TTextureID>(std::ostream &os, gl::TextureID value)
+void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::TextureID value)
 {
     os << "gTextureMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TTransformFeedbackID>(std::ostream &os,
-                                                              gl::TransformFeedbackID value)
+void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os,
+                                                            const CallCapture &call,
+                                                            gl::TransformFeedbackID value)
 {
     os << "gTransformFeedbackMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TVertexArrayID>(std::ostream &os, gl::VertexArrayID value)
+void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os,
+                                                      const CallCapture &call,
+                                                      gl::VertexArrayID value)
 {
     os << "gVertexArrayMap[" << value.value << "]";
 }
 
 template <>
-void WriteParamValueToStream<ParamType::TUniformLocation>(std::ostream &os,
-                                                          gl::UniformLocation value)
+void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os,
+                                                        const CallCapture &call,
+                                                        gl::UniformLocation value)
 {
     // TODO(jmadill): Uniform locations map. http://anglebug.com/4411
     os << value.value;
diff --git a/src/libANGLE/FrameCapture.h b/src/libANGLE/FrameCapture.h
@@ -295,74 +295,106 @@ void CaptureGenHandles(GLsizei n, T *handles, ParamCapture *paramCapture)
 }
 
 template <ParamType ParamT, typename T>
-void WriteParamValueToStream(std::ostream &os, T value);
+void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value);
 
 template <>
-void WriteParamValueToStream<ParamType::TGLboolean>(std::ostream &os, GLboolean value);
+void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  GLboolean value);
 
 template <>
-void WriteParamValueToStream<ParamType::TvoidConstPointer>(std::ostream &os, const void *value);
+void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os,
+                                                         const CallCapture &call,
+                                                         const void *value);
 
 template <>
-void WriteParamValueToStream<ParamType::TGLDEBUGPROCKHR>(std::ostream &os, GLDEBUGPROCKHR value);
+void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       GLDEBUGPROCKHR value);
 
 template <>
-void WriteParamValueToStream<ParamType::TGLDEBUGPROC>(std::ostream &os, GLDEBUGPROC value);
+void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os,
+                                                    const CallCapture &call,
+                                                    GLDEBUGPROC value);
 
 template <>
-void WriteParamValueToStream<ParamType::TBufferID>(std::ostream &os, gl::BufferID value);
+void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os,
+                                                 const CallCapture &call,
+                                                 gl::BufferID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TFenceNVID>(std::ostream &os, gl::FenceNVID value);
+void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::FenceNVID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TFramebufferID>(std::ostream &os, gl::FramebufferID value);
+void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os,
+                                                      const CallCapture &call,
+                                                      gl::FramebufferID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TMemoryObjectID>(std::ostream &os,
-                                                         gl::MemoryObjectID value);
+void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       gl::MemoryObjectID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TPathID>(std::ostream &os, gl::PathID value);
+void WriteParamValueReplay<ParamType::TPathID>(std::ostream &os,
+                                               const CallCapture &call,
+                                               gl::PathID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TProgramPipelineID>(std::ostream &os,
-                                                            gl::ProgramPipelineID value);
+void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os,
+                                                          const CallCapture &call,
+                                                          gl::ProgramPipelineID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TQueryID>(std::ostream &os, gl::QueryID value);
+void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os,
+                                                const CallCapture &call,
+                                                gl::QueryID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TRenderbufferID>(std::ostream &os,
-                                                         gl::RenderbufferID value);
+void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os,
+                                                       const CallCapture &call,
+                                                       gl::RenderbufferID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TSamplerID>(std::ostream &os, gl::SamplerID value);
+void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::SamplerID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TSemaphoreID>(std::ostream &os, gl::SemaphoreID value);
+void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os,
+                                                    const CallCapture &call,
+                                                    gl::SemaphoreID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TShaderProgramID>(std::ostream &os,
-                                                          gl::ShaderProgramID value);
+void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os,
+                                                        const CallCapture &call,
+                                                        gl::ShaderProgramID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TTextureID>(std::ostream &os, gl::TextureID value);
+void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os,
+                                                  const CallCapture &call,
+                                                  gl::TextureID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TTransformFeedbackID>(std::ostream &os,
-                                                              gl::TransformFeedbackID value);
+void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os,
+                                                            const CallCapture &call,
+                                                            gl::TransformFeedbackID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TVertexArrayID>(std::ostream &os, gl::VertexArrayID value);
+void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os,
+                                                      const CallCapture &call,
+                                                      gl::VertexArrayID value);
 
 template <>
-void WriteParamValueToStream<ParamType::TUniformLocation>(std::ostream &os,
-                                                          gl::UniformLocation value);
+void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os,
+                                                        const CallCapture &call,
+                                                        gl::UniformLocation value);
 
 // General fallback for any unspecific type.
 template <ParamType ParamT, typename T>
-void WriteParamValueToStream(std::ostream &os, T value)
+void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value)
 {
     os << value;
 }
diff --git a/src/libANGLE/frame_capture_utils_autogen.cpp b/src/libANGLE/frame_capture_utils_autogen.cpp
diff --git a/src/libANGLE/frame_capture_utils_autogen.h b/src/libANGLE/frame_capture_utils_autogen.h

Original file line number	Diff line number	Diff line change
`@@ -487,7 +487,7 @@ void WriteCppReplayForCall(const CallCapture &call,`
`487`	`487`	`}`
`488`	`488`	`else`
`489`	`489`	`{`
`490`		`- callOut << param;`
	`490`	`+ WriteParamCaptureReplay(callOut, call, param);`
`491`	`491`	`}`
`492`	`492`	`}`
`493`	`493`	`else`
`@@ -2584,12 +2584,6 @@ void FrameCapture::reset()`
`2584`	`2584`	`// necessary.`
`2585`	`2585`	`}`
`2586`	`2586`
`2587`		`-std::ostream &operator<<(std::ostream &os, const ParamCapture &capture)`
`2588`		`-{`
`2589`		`- WriteParamTypeToStream(os, capture.type, capture.value);`
`2590`		`- return os;`
`2591`		`-}`
`2592`		`-`
`2593`	`2587`	`void CaptureMemory(const void source, size_t size, ParamCapture paramCapture)`
`2594`	`2588`	`{`
`2595`	`2589`	`std::vector<uint8_t> data(size);`
`@@ -2632,7 +2626,9 @@ void CaptureGenHandlesImpl(GLsizei n, GLuint handles, ParamCapture paramCaptur`
`2632`	`2626`	`}`
`2633`	`2627`
`2634`	`2628`	`template <>`
`2635`		`-void WriteParamValueToStream<ParamType::TGLboolean>(std::ostream &os, GLboolean value)`
	`2629`	`+void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os,`
	`2630`	`+ const CallCapture &call,`
	`2631`	`+ GLboolean value)`
`2636`	`2632`	`{`
`2637`	`2633`	`switch (value)`
`2638`	`2634`	`{`
`@@ -2648,7 +2644,9 @@ void WriteParamValueToStream<ParamType::TGLboolean>(std::ostream &os, GLboolean`
`2648`	`2644`	`}`
`2649`	`2645`
`2650`	`2646`	`template <>`
`2651`		`-void WriteParamValueToStream<ParamType::TvoidConstPointer>(std::ostream &os, const void *value)`
	`2647`	`+void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os,`
	`2648`	`+ const CallCapture &call,`
	`2649`	`+ const void *value)`
`2652`	`2650`	`{`
`2653`	`2651`	`if (value == 0)`
`2654`	`2652`	`{`
`@@ -2662,103 +2660,133 @@ void WriteParamValueToStream<ParamType::TvoidConstPointer>(std::ostream &os, con`
`2662`	`2660`	`}`
`2663`	`2661`
`2664`	`2662`	`template <>`
`2665`		`-void WriteParamValueToStream<ParamType::TGLDEBUGPROCKHR>(std::ostream &os, GLDEBUGPROCKHR value)`
	`2663`	`+void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os,`
	`2664`	`+ const CallCapture &call,`
	`2665`	`+ GLDEBUGPROCKHR value)`
`2666`	`2666`	`{}`
`2667`	`2667`
`2668`	`2668`	`template <>`
`2669`		`-void WriteParamValueToStream<ParamType::TGLDEBUGPROC>(std::ostream &os, GLDEBUGPROC value)`
	`2669`	`+void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os,`
	`2670`	`+ const CallCapture &call,`
	`2671`	`+ GLDEBUGPROC value)`
`2670`	`2672`	`{}`
`2671`	`2673`
`2672`	`2674`	`template <>`
`2673`		`-void WriteParamValueToStream<ParamType::TBufferID>(std::ostream &os, gl::BufferID value)`
	`2675`	`+void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os,`
	`2676`	`+ const CallCapture &call,`
	`2677`	`+ gl::BufferID value)`
`2674`	`2678`	`{`
`2675`	`2679`	`os << "gBufferMap[" << value.value << "]";`
`2676`	`2680`	`}`
`2677`	`2681`
`2678`	`2682`	`template <>`
`2679`		`-void WriteParamValueToStream<ParamType::TFenceNVID>(std::ostream &os, gl::FenceNVID value)`
	`2683`	`+void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os,`
	`2684`	`+ const CallCapture &call,`
	`2685`	`+ gl::FenceNVID value)`
`2680`	`2686`	`{`
`2681`	`2687`	`os << "gFenceMap[" << value.value << "]";`
`2682`	`2688`	`}`
`2683`	`2689`
`2684`	`2690`	`template <>`
`2685`		`-void WriteParamValueToStream<ParamType::TFramebufferID>(std::ostream &os, gl::FramebufferID value)`
	`2691`	`+void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os,`
	`2692`	`+ const CallCapture &call,`
	`2693`	`+ gl::FramebufferID value)`
`2686`	`2694`	`{`
`2687`	`2695`	`os << "gFramebufferMap[" << value.value << "]";`
`2688`	`2696`	`}`
`2689`	`2697`
`2690`	`2698`	`template <>`
`2691`		`-void WriteParamValueToStream<ParamType::TMemoryObjectID>(std::ostream &os, gl::MemoryObjectID value)`
	`2699`	`+void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os,`
	`2700`	`+ const CallCapture &call,`
	`2701`	`+ gl::MemoryObjectID value)`
`2692`	`2702`	`{`
`2693`	`2703`	`os << "gMemoryObjectMap[" << value.value << "]";`
`2694`	`2704`	`}`
`2695`	`2705`
`2696`	`2706`	`template <>`
`2697`		`-void WriteParamValueToStream<ParamType::TPathID>(std::ostream &os, gl::PathID value)`
	`2707`	`+void WriteParamValueReplay<ParamType::TPathID>(std::ostream &os,`
	`2708`	`+ const CallCapture &call,`
	`2709`	`+ gl::PathID value)`
`2698`	`2710`	`{`
`2699`	`2711`	`os << "gPathMap[" << value.value << "]";`
`2700`	`2712`	`}`
`2701`	`2713`
`2702`	`2714`	`template <>`
`2703`		`-void WriteParamValueToStream<ParamType::TProgramPipelineID>(std::ostream &os,`
`2704`		`- gl::ProgramPipelineID value)`
	`2715`	`+void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os,`
	`2716`	`+ const CallCapture &call,`
	`2717`	`+ gl::ProgramPipelineID value)`
`2705`	`2718`	`{`
`2706`	`2719`	`os << "gProgramPipelineMap[" << value.value << "]";`
`2707`	`2720`	`}`
`2708`	`2721`
`2709`	`2722`	`template <>`
`2710`		`-void WriteParamValueToStream<ParamType::TQueryID>(std::ostream &os, gl::QueryID value)`
	`2723`	`+void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os,`
	`2724`	`+ const CallCapture &call,`
	`2725`	`+ gl::QueryID value)`
`2711`	`2726`	`{`
`2712`	`2727`	`os << "gQueryMap[" << value.value << "]";`
`2713`	`2728`	`}`
`2714`	`2729`
`2715`	`2730`	`template <>`
`2716`		`-void WriteParamValueToStream<ParamType::TRenderbufferID>(std::ostream &os, gl::RenderbufferID value)`
	`2731`	`+void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os,`
	`2732`	`+ const CallCapture &call,`
	`2733`	`+ gl::RenderbufferID value)`
`2717`	`2734`	`{`
`2718`	`2735`	`os << "gRenderbufferMap[" << value.value << "]";`
`2719`	`2736`	`}`
`2720`	`2737`
`2721`	`2738`	`template <>`
`2722`		`-void WriteParamValueToStream<ParamType::TSamplerID>(std::ostream &os, gl::SamplerID value)`
	`2739`	`+void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os,`
	`2740`	`+ const CallCapture &call,`
	`2741`	`+ gl::SamplerID value)`
`2723`	`2742`	`{`
`2724`	`2743`	`os << "gSamplerMap[" << value.value << "]";`
`2725`	`2744`	`}`
`2726`	`2745`
`2727`	`2746`	`template <>`
`2728`		`-void WriteParamValueToStream<ParamType::TSemaphoreID>(std::ostream &os, gl::SemaphoreID value)`
	`2747`	`+void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os,`
	`2748`	`+ const CallCapture &call,`
	`2749`	`+ gl::SemaphoreID value)`
`2729`	`2750`	`{`
`2730`	`2751`	`os << "gSempahoreMap[" << value.value << "]";`
`2731`	`2752`	`}`
`2732`	`2753`
`2733`	`2754`	`template <>`
`2734`		`-void WriteParamValueToStream<ParamType::TShaderProgramID>(std::ostream &os,`
`2735`		`- gl::ShaderProgramID value)`
	`2755`	`+void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os,`
	`2756`	`+ const CallCapture &call,`
	`2757`	`+ gl::ShaderProgramID value)`
`2736`	`2758`	`{`
`2737`	`2759`	`os << "gShaderProgramMap[" << value.value << "]";`
`2738`	`2760`	`}`
`2739`	`2761`
`2740`	`2762`	`template <>`
`2741`		`-void WriteParamValueToStream<ParamType::TTextureID>(std::ostream &os, gl::TextureID value)`
	`2763`	`+void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os,`
	`2764`	`+ const CallCapture &call,`
	`2765`	`+ gl::TextureID value)`
`2742`	`2766`	`{`
`2743`	`2767`	`os << "gTextureMap[" << value.value << "]";`
`2744`	`2768`	`}`
`2745`	`2769`
`2746`	`2770`	`template <>`
`2747`		`-void WriteParamValueToStream<ParamType::TTransformFeedbackID>(std::ostream &os,`
`2748`		`- gl::TransformFeedbackID value)`
	`2771`	`+void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os,`
	`2772`	`+ const CallCapture &call,`
	`2773`	`+ gl::TransformFeedbackID value)`
`2749`	`2774`	`{`
`2750`	`2775`	`os << "gTransformFeedbackMap[" << value.value << "]";`
`2751`	`2776`	`}`
`2752`	`2777`
`2753`	`2778`	`template <>`
`2754`		`-void WriteParamValueToStream<ParamType::TVertexArrayID>(std::ostream &os, gl::VertexArrayID value)`
	`2779`	`+void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os,`
	`2780`	`+ const CallCapture &call,`
	`2781`	`+ gl::VertexArrayID value)`
`2755`	`2782`	`{`
`2756`	`2783`	`os << "gVertexArrayMap[" << value.value << "]";`
`2757`	`2784`	`}`
`2758`	`2785`
`2759`	`2786`	`template <>`
`2760`		`-void WriteParamValueToStream<ParamType::TUniformLocation>(std::ostream &os,`
`2761`		`- gl::UniformLocation value)`
	`2787`	`+void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os,`
	`2788`	`+ const CallCapture &call,`
	`2789`	`+ gl::UniformLocation value)`
`2762`	`2790`	`{`
`2763`	`2791`	`// TODO(jmadill): Uniform locations map. http://anglebug.com/4411`
`2764`	`2792`	`os << value.value;`