Use stream operators for appending to InfoLog.

src/libANGLE/Program.h

@@ -71,8 +71,62 @@ class InfoLog : angle::NonCopyable
     void getLog(GLsizei bufSize, GLsizei *length, char *infoLog);
 
     void appendSanitized(const char *message);
-    void append(const char *info, ...);
     void reset();
+
+    // This helper class ensures we append a newline after writing a line.
+    class StreamHelper : angle::NonCopyable
+    {
+      public:
+        StreamHelper(StreamHelper &&rhs)
+            : mStream(rhs.mStream)
+        {
+            rhs.mStream = nullptr;
+        }
+
+        StreamHelper &operator=(StreamHelper &&rhs)
+        {
+            std::swap(mStream, rhs.mStream);
+            return *this;
+        }
+
+        ~StreamHelper()
+        {
+            // Write newline when destroyed on the stack
+            if (mStream)
+            {
+                (*mStream) << std::endl;
+            }
+        }
+
+        template <typename T>
+        StreamHelper &operator<<(const T &value)
+        {
+            (*mStream) << value;
+            return *this;
+        }
+
+      private:
+        friend class InfoLog;
+
+        StreamHelper(std::stringstream *stream)
+            : mStream(stream)
+        {
+            ASSERT(stream);
+        }
+
+        std::stringstream *mStream;
+    };
+
+    template <typename T>
+    StreamHelper operator<<(const T &value)
+    {
+        StreamHelper helper(&mStream);
+        helper << value;
+        return helper;
+    }
+
+    std::string str() const { return mStream.str(); }
+
   private:
     std::stringstream mStream;
 };

src/libANGLE/Program_unittest.cpp

@@ -21,10 +21,23 @@ TEST(InfoLogTest, LogLengthCountsTerminator)
 {
     InfoLog infoLog;
     EXPECT_EQ(0u, infoLog.getLength());
-    infoLog.append(" ");
+    infoLog << " ";
 
     // " \n\0" = 3 characters
     EXPECT_EQ(3u, infoLog.getLength());
 }
 
+// Tests that newlines get appended to the info log properly.
+TEST(InfoLogTest, AppendingNewline)
+{
+    InfoLog infoLog;
+
+    infoLog << "First" << 1 << 'x';
+    infoLog << "Second" << 2 << 'y';
+
+    std::string expected = "First1x\nSecond2y\n";
+
+    EXPECT_EQ(expected, infoLog.str());
+}
+
 } // namespace

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -262,7 +262,7 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, ShaderD3
         }
         else
         {
-            infoLog.append("Could not pack varying %s", varying->name.c_str());
+            infoLog << "Could not pack varying " << varying->name;
             return -1;
         }
     }
@@ -287,7 +287,7 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, ShaderD3
                 {
                     if (!packVarying(varying, maxVaryingVectors, packing))
                     {
-                        infoLog.append("Could not pack varying %s", varying->name.c_str());
+                        infoLog << "Could not pack varying " << varying->name;
                         return -1;
                     }
 
@@ -298,7 +298,9 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, ShaderD3
 
             if (!found)
             {
-                infoLog.append("Transform feedback varying %s does not exist in the vertex shader.", transformFeedbackVarying.c_str());
+                infoLog << "Transform feedback varying "
+                        << transformFeedbackVarying
+                        << " does not exist in the vertex shader.";
                 return -1;
             }
         }
@@ -757,7 +759,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data, InfoLog &infoLog,
 
     if (usesFragColor && usesFragData)
     {
-        infoLog.append("Cannot use both gl_FragColor and gl_FragData in the same fragment shader.");
+        infoLog << "Cannot use both gl_FragColor and gl_FragData in the same fragment shader.";
         return false;
     }
 
@@ -780,7 +782,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data, InfoLog &infoLog,
 
     if (static_cast<GLuint>(registersNeeded) > data.caps->maxVaryingVectors)
     {
-        infoLog.append("No varying registers left to support gl_FragCoord/gl_PointCoord");
+        infoLog << "No varying registers left to support gl_FragCoord/gl_PointCoord";
         return false;
     }
 

src/libANGLE/renderer/d3d/HLSLCompiler.cpp

@@ -268,11 +268,11 @@ gl::Error HLSLCompiler::compileToBinary(gl::InfoLog &infoLog, const std::string
                 return gl::Error(GL_OUT_OF_MEMORY, "HLSL compiler had an unexpected failure, result: 0x%X.", result);
             }
 
-            infoLog.append("Warning: D3D shader compilation failed with %s flags.", configs[i].name.c_str());
+            infoLog << "Warning: D3D shader compilation failed with " << configs[i].name << " flags.";
 
             if (i + 1 < configs.size())
             {
-                infoLog.append(" Retrying with %s.\n", configs[i + 1].name.c_str());
+                infoLog << " Retrying with " << configs[i + 1].name;
             }
         }
     }

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -360,7 +360,9 @@ bool ProgramD3D::validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps)
             {
                 if (infoLog)
                 {
-                    infoLog->append("Sampler uniform (%d) exceeds GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, caps.maxCombinedTextureImageUnits);
+                    (*infoLog) << "Sampler uniform (" << unit
+                               << ") exceeds GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS ("
+                               << caps.maxCombinedTextureImageUnits << ")";
                 }
 
                 mCachedValidateSamplersResult = false;
@@ -373,7 +375,8 @@ bool ProgramD3D::validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps)
                 {
                     if (infoLog)
                     {
-                        infoLog->append("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
+                        (*infoLog) << "Samplers of conflicting types refer to the same texture image unit ("
+                                   << unit << ").";
                     }
 
                     mCachedValidateSamplersResult = false;
@@ -397,7 +400,9 @@ bool ProgramD3D::validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps)
             {
                 if (infoLog)
                 {
-                    infoLog->append("Sampler uniform (%d) exceeds GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, caps.maxCombinedTextureImageUnits);
+                    (*infoLog) << "Sampler uniform (" << unit
+                               << ") exceeds GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS ("
+                               << caps.maxCombinedTextureImageUnits << ")";
                 }
 
                 mCachedValidateSamplersResult = false;
@@ -410,7 +415,8 @@ bool ProgramD3D::validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps)
                 {
                     if (infoLog)
                     {
-                        infoLog->append("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
+                        (*infoLog) << "Samplers of conflicting types refer to the same texture image unit ("
+                                   << unit << ").";
                     }
 
                     mCachedValidateSamplersResult = false;
@@ -433,7 +439,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
     int compileFlags = stream->readInt<int>();
     if (compileFlags != ANGLE_COMPILE_OPTIMIZATION_LEVEL)
     {
-        infoLog.append("Mismatched compilation flags.");
+        infoLog << "Mismatched compilation flags.";
         return LinkResult(false, gl::Error(GL_NO_ERROR));
     }
 
@@ -464,7 +470,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
     const unsigned int uniformCount = stream->readInt<unsigned int>();
     if (stream->error())
     {
-        infoLog.append("Invalid program binary.");
+        infoLog << "Invalid program binary.";
         return LinkResult(false, gl::Error(GL_NO_ERROR));
     }
 
@@ -497,7 +503,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
     const unsigned int uniformIndexCount = stream->readInt<unsigned int>();
     if (stream->error())
     {
-        infoLog.append("Invalid program binary.");
+        infoLog << "Invalid program binary.";
         return LinkResult(false, gl::Error(GL_NO_ERROR));
     }
 
@@ -512,7 +518,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
     unsigned int uniformBlockCount = stream->readInt<unsigned int>();
     if (stream->error())
     {
-        infoLog.append("Invalid program binary.");
+        infoLog << "Invalid program binary.";
         return LinkResult(false, gl::Error(GL_NO_ERROR));
     }
 
@@ -602,7 +608,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
 
         if (!shaderExecutable)
         {
-            infoLog.append("Could not create vertex shader.");
+            infoLog << "Could not create vertex shader.";
             return LinkResult(false, gl::Error(GL_NO_ERROR));
         }
 
@@ -640,7 +646,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
 
         if (!shaderExecutable)
         {
-            infoLog.append("Could not create pixel shader.");
+            infoLog << "Could not create pixel shader.";
             return LinkResult(false, gl::Error(GL_NO_ERROR));
         }
 
@@ -666,7 +672,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
 
         if (!mGeometryExecutable)
         {
-            infoLog.append("Could not create geometry shader.");
+            infoLog << "Could not create geometry shader.";
             return LinkResult(false, gl::Error(GL_NO_ERROR));
         }
         stream->skip(geometryShaderSize);
@@ -678,7 +684,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
     GUID identifier = mRenderer->getAdapterIdentifier();
     if (memcmp(&identifier, &binaryIdentifier, sizeof(GUID)) != 0)
     {
-        infoLog.append("Invalid program binary.");
+        infoLog << "Invalid program binary.";
         return LinkResult(false, gl::Error(GL_NO_ERROR));
     }
 
@@ -1188,7 +1194,7 @@ bool ProgramD3D::assignUniformBlockRegister(gl::InfoLog &infoLog, gl::UniformBlo
         uniformBlock->vsRegisterIndex = registerIndex;
         if (registerIndex - mRenderer->getReservedVertexUniformBuffers() >= caps.maxVertexUniformBlocks)
         {
-            infoLog.append("Vertex shader uniform block count exceed GL_MAX_VERTEX_UNIFORM_BLOCKS (%u)", caps.maxVertexUniformBlocks);
+            infoLog << "Vertex shader uniform block count exceed GL_MAX_VERTEX_UNIFORM_BLOCKS (" << caps.maxVertexUniformBlocks << ")";
             return false;
         }
     }
@@ -1197,7 +1203,7 @@ bool ProgramD3D::assignUniformBlockRegister(gl::InfoLog &infoLog, gl::UniformBlo
         uniformBlock->psRegisterIndex = registerIndex;
         if (registerIndex - mRenderer->getReservedFragmentUniformBuffers() >= caps.maxFragmentUniformBlocks)
         {
-            infoLog.append("Fragment shader uniform block count exceed GL_MAX_FRAGMENT_UNIFORM_BLOCKS (%u)", caps.maxFragmentUniformBlocks);
+            infoLog << "Fragment shader uniform block count exceed GL_MAX_FRAGMENT_UNIFORM_BLOCKS (" << caps.maxFragmentUniformBlocks << ")";
             return false;
         }
     }
@@ -1893,16 +1899,16 @@ bool ProgramD3D::indexSamplerUniform(const gl::LinkedUniform &uniform, gl::InfoL
         if (!assignSamplers(uniform.vsRegisterIndex, uniform.type, uniform.arraySize, mSamplersVS,
                             &mUsedVertexSamplerRange))
         {
-            infoLog.append("Vertex shader sampler count exceeds the maximum vertex texture units (%d).",
-                           mSamplersVS.size());
+            infoLog << "Vertex shader sampler count exceeds the maximum vertex texture units ("
+                    << mSamplersVS.size() << ").";
             return false;
         }
 
         unsigned int maxVertexVectors = mRenderer->getReservedVertexUniformVectors() + caps.maxVertexUniformVectors;
         if (uniform.vsRegisterIndex + uniform.registerCount > maxVertexVectors)
         {
-            infoLog.append("Vertex shader active uniforms exceed GL_MAX_VERTEX_UNIFORM_VECTORS (%u)",
-                           caps.maxVertexUniformVectors);
+            infoLog << "Vertex shader active uniforms exceed GL_MAX_VERTEX_UNIFORM_VECTORS ("
+                    << caps.maxVertexUniformVectors << ").";
             return false;
         }
     }
@@ -1912,16 +1918,16 @@ bool ProgramD3D::indexSamplerUniform(const gl::LinkedUniform &uniform, gl::InfoL
         if (!assignSamplers(uniform.psRegisterIndex, uniform.type, uniform.arraySize, mSamplersPS,
                             &mUsedPixelSamplerRange))
         {
-            infoLog.append("Pixel shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS (%d).",
-                           mSamplersPS.size());
+            infoLog << "Pixel shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS ("
+                    << mSamplersPS.size() << ").";
             return false;
         }
 
         unsigned int maxFragmentVectors = mRenderer->getReservedFragmentUniformVectors() + caps.maxFragmentUniformVectors;
         if (uniform.psRegisterIndex + uniform.registerCount > maxFragmentVectors)
         {
-            infoLog.append("Fragment shader active uniforms exceed GL_MAX_FRAGMENT_UNIFORM_VECTORS (%u)",
-                           caps.maxFragmentUniformVectors);
+            infoLog << "Fragment shader active uniforms exceed GL_MAX_FRAGMENT_UNIFORM_VECTORS ("
+                    << caps.maxFragmentUniformVectors << ").";
             return false;
         }
     }

src/libANGLE/renderer/gl/ProgramGL.cpp

@@ -113,7 +113,7 @@ LinkResult ProgramGL::link(const gl::Data &data, gl::InfoLog &infoLog,
         mFunctions->deleteProgram(mProgramID);
         mProgramID = 0;
 
-        infoLog.append(&buf[0]);
+        infoLog << &buf[0];
         TRACE("\n%s", &buf[0]);
 
         // TODO, return GL_OUT_OF_MEMORY or just fail the link? This is an unexpected case