color: Use classic locale for printing

ui/gfx/color_transform.cc

 // Copyright (c) 2016 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.
 
 #include "ui/gfx/color_transform.h"
 
 #include <algorithm>
 #include <cmath>
 #include <list>
 #include <memory>
+#include <sstream>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "third_party/qcms/src/qcms.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/skia_color_space_util.h"
 #include "ui/gfx/transform.h"
 
 #ifndef THIS_MUST_BE_INCLUDED_AFTER_QCMS_H
 extern "C" {
 #include "third_party/qcms/src/chain.h"
 };
 #endif
 
 using std::exp;
 using std::log;
 using std::max;
 using std::min;
 using std::pow;
 using std::sqrt;
 
 namespace gfx {
 
 namespace {
 
+void InitStringStream(std::stringstream* ss) {
+  ss->imbue(std::locale::classic());
+  ss->precision(8);
+  *ss << std::scientific;
+}
+
 std::string Str(float f) {
-  return base::StringPrintf("%+1.8e", f);
+  std::stringstream ss;
+  InitStringStream(&ss);
+  ss << f;
+  return ss.str();
 }
 
 // Helper for scoped QCMS profiles.
 struct QcmsProfileDeleter {
   void operator()(qcms_profile* p) {
     if (p) {
       qcms_profile_release(p);
     }
   }
 };
 using ScopedQcmsProfile = std::unique_ptr<qcms_profile, QcmsProfileDeleter>;
 
 Transform Invert(const Transform& t) {
   Transform ret = t;
   if (!t.GetInverse(&ret)) {
-    LOG(ERROR) << "Inverse should alsways be possible.";
+    LOG(ERROR) << "Inverse should always be possible.";
   }
   return ret;
 }
 
 float FromLinear(ColorSpace::TransferID id, float v) {
   switch (id) {
     case ColorSpace::TransferID::SMPTEST2084_NON_HDR:
       // Should already be handled.
       break;
 
@@ skipping 186 matching lines @@
 
   // Join methods, returns true if the |next| transform was successfully
   // assimilated into |this|.
   // If Join() returns true, |next| is no longer needed and can be deleted.
   virtual bool Join(ColorTransformStep* next) { return false; }
 
   // Return true if this is a null transform.
   virtual bool IsNull() { return false; }
   virtual void Transform(ColorTransform::TriStim* color, size_t num) const = 0;
   virtual bool CanAppendShaderSource() { return false; }
-  virtual void AppendShaderSource(std::string* result) { NOTREACHED(); }
+  virtual void AppendShaderSource(std::stringstream* result) { NOTREACHED(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ColorTransformStep);
 };
 
 class ColorTransformInternal : public ColorTransform {
  public:
   ColorTransformInternal(const ColorSpace& from,
                          const ColorSpace& to,
                          Intent intent);
@@ skipping 20 matching lines @@
   // Retrieve the ICC profile from which |color_space| was created, only if that
   // is a more precise representation of the color space than the primaries and
   // transfer function in |color_space|.
   ScopedQcmsProfile GetQCMSProfileIfNecessary(const ColorSpace& color_space);
 
   std::list<std::unique_ptr<ColorTransformStep>> steps_;
   gfx::ColorSpace src_;
   gfx::ColorSpace dst_;
 };
 
-#define SRC(...)                                                     \
-  do {                                                               \
-    *result += std::string("  ") + base::StringPrintf(__VA_ARGS__) + \
-               std::string("\n");                                    \
-  } while (0)
-
 class ColorTransformNull : public ColorTransformStep {
  public:
   ColorTransformNull* GetNull() override { return this; }
   bool IsNull() override { return true; }
   void Transform(ColorTransform::TriStim* color, size_t num) const override {}
   bool CanAppendShaderSource() override { return true; }
-  void AppendShaderSource(std::string* result) override {}
+  void AppendShaderSource(std::stringstream* result) override {}
 };
 
 class ColorTransformMatrix : public ColorTransformStep {
  public:
   explicit ColorTransformMatrix(const class Transform& matrix)
       : matrix_(matrix) {}
   ColorTransformMatrix* GetMatrix() override { return this; }
   bool Join(ColorTransformStep* next_untyped) override {
     ColorTransformMatrix* next = next_untyped->GetMatrix();
     if (!next)
       return false;
     class Transform tmp = next->matrix_;
     tmp *= matrix_;
     matrix_ = tmp;
     return true;
   }
 
   bool IsNull() override {
     return SkMatrixIsApproximatelyIdentity(matrix_.matrix());
   }
 
   void Transform(ColorTransform::TriStim* colors, size_t num) const override {
     for (size_t i = 0; i < num; i++)
       matrix_.TransformPoint(colors + i);
   }
 
   bool CanAppendShaderSource() override { return true; }
 
-  void AppendShaderSource(std::string* result) override {
+  void AppendShaderSource(std::stringstream* result) override {
     const SkMatrix44& m = matrix_.matrix();
-    SRC("color = mat3(%+1.8e, %+1.8e, %+1.8e,",  // column 1
-        m.get(0, 0), m.get(1, 0), m.get(2, 0));
-    SRC("             %+1.8e, %+1.8e, %+1.8e,",  // column 2
-        m.get(0, 1), m.get(1, 1), m.get(2, 1));
-    SRC("             %+1.8e, %+1.8e, %+1.8e) * color;",  // column 3
-        m.get(0, 2), m.get(1, 2), m.get(2, 2));
-    SRC("color = vec3(%+1.8e, %+1.8e, %+1.8e) + color;",  // column 4
-        m.get(0, 3), m.get(1, 3), m.get(2, 3));
+    *result << "  color = mat3(";
+    *result << m.get(0, 0) << ", " << m.get(1, 0) << ", " << m.get(2, 0) << ",";
+    *result << std::endl;
+    *result << "               ";
+    *result << m.get(0, 1) << ", " << m.get(1, 1) << ", " << m.get(2, 1) << ",";
+    *result << std::endl;
+    *result << "               ";
+    *result << m.get(0, 2) << ", " << m.get(1, 2) << ", " << m.get(2, 2) << ")";
+    *result << " * color;" << std::endl;
+
+    // Only print the translational component if it isn't the identity.
+    if (m.get(0, 3) != 0.f || m.get(1, 3) != 0.f || m.get(2, 3) != 0.f) {
+      *result << "  color += vec3(";
+      *result << m.get(0, 3) << ", " << m.get(1, 3) << ", " << m.get(2, 3);
+      *result << ");" << std::endl;
+    }
   }
 
  private:
   class Transform matrix_;
 };
 
 class ColorTransformSkTransferFn : public ColorTransformStep {
  public:
   explicit ColorTransformSkTransferFn(const SkColorSpaceTransferFn& fn)
       : fn_(fn) {}
@@ skipping 22 matching lines @@
   void Transform(ColorTransform::TriStim* colors, size_t num) const override {
     for (size_t i = 0; i < num; i++) {
       colors[i].set_x(SkTransferFnEval(fn_, colors[i].x()));
       colors[i].set_y(SkTransferFnEval(fn_, colors[i].y()));
       colors[i].set_z(SkTransferFnEval(fn_, colors[i].z()));
     }
   }
 
   bool CanAppendShaderSource() override { return true; }
 
-  void AppendShaderSourceChannel(std::string* result, const char* value) {
+  void AppendShaderSourceChannel(std::stringstream* result, const char* value) {
     const float kEpsilon = 1.f / 1024.f;
 
     // Construct the linear segment
     //   linear = C * x + F
     // Elide operations that will be close to the identity.
     std::string linear = value;
     if (std::abs(fn_.fC - 1.f) > kEpsilon)
       linear = Str(fn_.fC) + " * " + linear;
     if (std::abs(fn_.fF) > kEpsilon)
       linear = linear + " + " + Str(fn_.fF);
 
     // Construct the nonlinear segment.
     //   nonlinear = pow(A * x + B, G) + E
     // Elide operations (especially the pow) that will be close to the
     // identity.
     std::string nonlinear = value;
     if (std::abs(fn_.fA - 1.f) > kEpsilon)
       nonlinear = Str(fn_.fA) + " * " + nonlinear;
     if (std::abs(fn_.fB) > kEpsilon)
       nonlinear = nonlinear + " + " + Str(fn_.fB);
     if (std::abs(fn_.fG - 1.f) > kEpsilon)
       nonlinear = "pow(" + nonlinear + ", " + Str(fn_.fG) + ")";
     if (std::abs(fn_.fE) > kEpsilon)
       nonlinear = nonlinear + " + " + Str(fn_.fE);
 
     // Add both parts, skpping the if clause if possible.
     if (fn_.fD > kEpsilon) {
-      SRC("if (%s < %f)", value, fn_.fD);
-      SRC("  %s = %s;", value, linear.c_str());
-      SRC("else");
-      SRC("  %s = %s;", value, nonlinear.c_str());
+      *result << "  if (" << value << " < " << Str(fn_.fD) << ")" << std::endl;
+      *result << "    " << value << " = " << linear << ";" << std::endl;
+      *result << "  else" << std::endl;
+      *result << "    " << value << " = " << nonlinear << ";" << std::endl;
     } else {
-      SRC("%s = %s;", value, nonlinear.c_str());
+      *result << "  " << value << " = " << nonlinear << ";" << std::endl;
     }
   }
 
-  void AppendShaderSource(std::string* result) override {
+  void AppendShaderSource(std::stringstream* result) override {
     // Append the transfer function for each channel.
     AppendShaderSourceChannel(result, "color.r");
     AppendShaderSourceChannel(result, "color.g");
     AppendShaderSourceChannel(result, "color.b");
   }
 
  private:
   SkColorSpaceTransferFn fn_;
 };
 
@@ skipping 365 matching lines @@
   if (dst_profile) {
     steps_.push_back(base::MakeUnique<QCMSColorTransform>(
         GetXYZD50Profile(), std::move(dst_profile)));
   }
 
   if (intent != Intent::TEST_NO_OPT)
     Simplify();
 }
 
 std::string ColorTransformInternal::GetShaderSource() const {
-  std::string result;
-  result += "vec3 DoColorConversion(vec3 color) {\n";
+  std::stringstream result;
+  InitStringStream(&result);
+  result << "vec3 DoColorConversion(vec3 color) {" << std::endl;
   for (const auto& step : steps_)
     step->AppendShaderSource(&result);
-  result += "  return color;\n";
-  result += "}\n";
-  return result;
+  result << "  return color;" << std::endl;
+  result << "}" << std::endl;
+  return result.str();
 }
 
 bool ColorTransformInternal::CanGetShaderSource() const {
   for (const auto& step : steps_) {
     if (!step->CanAppendShaderSource())
       return false;
   }
   return true;
 }
 
@@ skipping 36 matching lines @@
     const ColorSpace& to,
     Intent intent) {
   return std::unique_ptr<ColorTransform>(
       new ColorTransformInternal(from, to, intent));
 }
 
 ColorTransform::ColorTransform() {}
 ColorTransform::~ColorTransform() {}
 
 }  // namespace gfx