Update from chromium 62675d9fb31fb8cedc40f68e78e8445a74f362e7

cc/output/shader.cc

 // Copyright 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.
 
 #include "cc/output/shader.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 691 matching lines @@
         bgTexCoord.x /= backdropRect.z;
         bgTexCoord.y /= backdropRect.w;
         return TextureLookup(s_backdropTexture, bgTexCoord);
       }
 
       vec4 ApplyBlendMode(vec4 src) {
         vec4 dst = GetBackdropColor();
         return Blend(src, dst);
       }
       // clang-format off
-  );
+  );  // NOLINT(whitespace/parens)
   // clang-format on
 
   return "precision mediump float;" + GetHelperFunctions() +
          GetBlendFunction() + kFunctionApplyBlendMode + shader_string;
 }
 
 std::string FragmentTexBlendMode::GetHelperFunctions() const {
   // clang-format off
   static const std::string kFunctionHardLight = SHADER0(
       // clang-format on
       vec3 hardLight(vec4 src, vec4 dst) {
         vec3 result;
         result.r =
             (2.0 * src.r <= src.a)
                 ? (2.0 * src.r * dst.r)
                 : (src.a * dst.a - 2.0 * (dst.a - dst.r) * (src.a - src.r));
         result.g =
             (2.0 * src.g <= src.a)
                 ? (2.0 * src.g * dst.g)
                 : (src.a * dst.a - 2.0 * (dst.a - dst.g) * (src.a - src.g));
         result.b =
             (2.0 * src.b <= src.a)
                 ? (2.0 * src.b * dst.b)
                 : (src.a * dst.a - 2.0 * (dst.a - dst.b) * (src.a - src.b));
         result.rgb += src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a);
         return result;
       }
       // clang-format off
-  );
+  );  // NOLINT(whitespace/parens)
 
   static const std::string kFunctionColorDodgeComponent = SHADER0(
       // clang-format on
       float getColorDodgeComponent(
           float srcc, float srca, float dstc, float dsta) {
         if (0.0 == dstc)
           return srcc * (1.0 - dsta);
         float d = srca - srcc;
         if (0.0 == d)
           return srca * dsta + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
         d = min(dsta, dstc * srca / d);
         return d * srca + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
       }
       // clang-format off
-  );
+  );  // NOLINT(whitespace/parens)
 
   static const std::string kFunctionColorBurnComponent = SHADER0(
       // clang-format on
       float getColorBurnComponent(
           float srcc, float srca, float dstc, float dsta) {
         if (dsta == dstc)
           return srca * dsta + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
         if (0.0 == srcc)
           return dstc * (1.0 - srca);
         float d = max(0.0, dsta - (dsta - dstc) * srca / srcc);
         return srca * d + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
       }
       // clang-format off
-  );
+  );  // NOLINT(whitespace/parens)
 
   static const std::string kFunctionSoftLightComponentPosDstAlpha = SHADER0(
       // clang-format on
       float getSoftLightComponent(
           float srcc, float srca, float dstc, float dsta) {
         if (2.0 * srcc <= srca) {
           return (dstc * dstc * (srca - 2.0 * srcc)) / dsta +
                  (1.0 - dsta) * srcc + dstc * (-srca + 2.0 * srcc + 1.0);
         } else if (4.0 * dstc <= dsta) {
           float DSqd = dstc * dstc;
           float DCub = DSqd * dstc;
           float DaSqd = dsta * dsta;
           float DaCub = DaSqd * dsta;
           return (-DaCub * srcc +
                   DaSqd * (srcc - dstc * (3.0 * srca - 6.0 * srcc - 1.0)) +
                   12.0 * dsta * DSqd * (srca - 2.0 * srcc) -
                   16.0 * DCub * (srca - 2.0 * srcc)) /
                  DaSqd;
         } else {
           return -sqrt(dsta * dstc) * (srca - 2.0 * srcc) - dsta * srcc +
                  dstc * (srca - 2.0 * srcc + 1.0) + srcc;
         }
       }
       // clang-format off
-  );
+  );  // NOLINT(whitespace/parens)
 
   static const std::string kFunctionLum = SHADER0(
       // clang-format on
       float luminance(vec3 color) { return dot(vec3(0.3, 0.59, 0.11), color); }
 
       vec3 set_luminance(vec3 hueSat, float alpha, vec3 lumColor) {
         float diff = luminance(lumColor - hueSat);
         vec3 outColor = hueSat + diff;
         float outLum = luminance(outColor);
         float minComp = min(min(outColor.r, outColor.g), outColor.b);
         float maxComp = max(max(outColor.r, outColor.g), outColor.b);
         if (minComp < 0.0) {
           outColor = outLum +
                      ((outColor - vec3(outLum, outLum, outLum)) * outLum) /
                          (outLum - minComp);
         }
         if (maxComp > alpha) {
           outColor =
               outLum +
               ((outColor - vec3(outLum, outLum, outLum)) * (alpha - outLum)) /
                   (maxComp - outLum);
         }
         return outColor;
       }
       // clang-format off
-  );
+  );  // NOLINT(whitespace/parens)
 
   static const std::string kFunctionSat = SHADER0(
       // clang-format on
       float saturation(vec3 color) {
         return max(max(color.r, color.g), color.b) -
                min(min(color.r, color.g), color.b);
       }
 
       vec3 set_saturation_helper(
           float minComp, float midComp, float maxComp, float sat) {
@@ skipping 27 matching lines @@
         } else if (hueLumColor.g <= hueLumColor.b) {
           hueLumColor.gbr = set_saturation_helper(
               hueLumColor.g, hueLumColor.b, hueLumColor.r, sat);
         } else {
           hueLumColor.bgr = set_saturation_helper(
               hueLumColor.b, hueLumColor.g, hueLumColor.r, sat);
         }
         return hueLumColor;
       }
       // clang-format off
-  );
+  );  // NOLINT(whitespace/parens)
   // clang-format on
 
   switch (blend_mode_) {
     case BlendModeOverlay:
     case BlendModeHardLight:
       return kFunctionHardLight;
     case BlendModeColorDodge:
       return kFunctionColorDodgeComponent;
     case BlendModeColorBurn:
       return kFunctionColorBurnComponent;
@@ skipping 1099 matching lines @@
         vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
         float picker = abs(coord.x - coord.y);  // NOLINT
         gl_FragColor = mix(color1, color2, picker) * alpha;
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 }  // namespace cc