Revert of Enable cpplint and fix cpplint errors in webrtc/*audio

webrtc/common_audio/signal_processing/signal_processing_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <algorithm>
 #include <sstream>
 
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/test/gtest.h"
 
 static const size_t kVector16Size = 9;
 static const int16_t vector16[kVector16Size] = {1, -15511, 4323, 1963,
   WEBRTC_SPL_WORD16_MAX, 0, WEBRTC_SPL_WORD16_MIN + 5, -3333, 345};
 
 class SplTest : public testing::Test {
  protected:
-  SplTest() {
-    WebRtcSpl_Init();
-  }
-  virtual ~SplTest() {
-  }
+   SplTest() {
+     WebRtcSpl_Init();
+   }
+   virtual ~SplTest() {
+   }
 };
 
 TEST_F(SplTest, MacroTest) {
     // Macros with inputs.
     int A = 10;
     int B = 21;
     int a = -3;
     int b = WEBRTC_SPL_WORD32_MAX;
 
     EXPECT_EQ(10, WEBRTC_SPL_MIN(A, B));
@@ skipping 283 matching lines @@
 
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         a16[kk] = B[kk];
         b16[kk] = B[kk];
     }
 
     WebRtcSpl_AffineTransformVector(bTmp16, b16, 3, 7, 2, kVectorSize);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ((B[kk]*3+7)>>2, bTmp16[kk]);
     }
-    WebRtcSpl_ScaleAndAddVectorsWithRound(b16, 3, b16, 2, 2, bTmp16,
-                                          kVectorSize);
+    WebRtcSpl_ScaleAndAddVectorsWithRound(b16, 3, b16, 2, 2, bTmp16, kVectorSize);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ((B[kk]*3+B[kk]*2+2)>>2, bTmp16[kk]);
     }
 
     WebRtcSpl_AddAffineVectorToVector(bTmp16, b16, 3, 7, 2, kVectorSize);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ(((B[kk]*3+B[kk]*2+2)>>2)+((b16[kk]*3+7)>>2), bTmp16[kk]);
     }
 
     WebRtcSpl_ScaleVector(b16, bTmp16, 13, kVectorSize, 2);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ((b16[kk]*13)>>2, bTmp16[kk]);
     }
     WebRtcSpl_ScaleVectorWithSat(b16, bTmp16, 13, kVectorSize, 2);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ((b16[kk]*13)>>2, bTmp16[kk]);
     }
     WebRtcSpl_ScaleAndAddVectors(a16, 13, 2, b16, 7, 2, bTmp16, kVectorSize);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ(((a16[kk]*13)>>2)+((b16[kk]*7)>>2), bTmp16[kk]);
     }
 
     WebRtcSpl_AddVectorsAndShift(bTmp16, a16, b16, kVectorSize, 2);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ(B[kk] >> 1, bTmp16[kk]);
     }
-    WebRtcSpl_ReverseOrderMultArrayElements(bTmp16, a16, &b16[3],
-                                            kVectorSize, 2);
+    WebRtcSpl_ReverseOrderMultArrayElements(bTmp16, a16, &b16[3], kVectorSize, 2);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ((a16[kk]*b16[3-kk])>>2, bTmp16[kk]);
     }
     WebRtcSpl_ElementwiseVectorMult(bTmp16, a16, b16, kVectorSize, 6);
     for (size_t kk = 0; kk < kVectorSize; ++kk) {
         EXPECT_EQ((a16[kk]*b16[kk])>>6, bTmp16[kk]);
     }
 
     WebRtcSpl_SqrtOfOneMinusXSquared(b16, kVectorSize, bTmp16);
     for (size_t kk = 0; kk < kVectorSize - 1; ++kk) {
@@ skipping 182 matching lines @@
     EXPECT_EQ(0, WebRtcSpl_ComplexFFT(B, 3, 1));
 //    for (int kk = 0; kk < 16; ++kk) {
 //        EXPECT_EQ(A[kk], B[kk]);
 //    }
     EXPECT_EQ(0, WebRtcSpl_ComplexIFFT(B, 3, 1));
 //    for (int kk = 0; kk < 16; ++kk) {
 //        EXPECT_EQ(A[kk], B[kk]);
 //    }
     WebRtcSpl_ComplexBitReverse(B, 3);
     for (int kk = 0; kk < 16; ++kk) {
-//      EXPECT_EQ(A[kk], B[kk]);
+        //EXPECT_EQ(A[kk], B[kk]);
     }
 }
 
 TEST_F(SplTest, Resample48WithSaturationTest) {
   // The test resamples 3*kBlockSize number of samples to 2*kBlockSize number
   // of samples.
   const size_t kBlockSize = 16;
 
   // Saturated input vector of 48 samples.
   const int32_t kVectorSaturated[3 * kBlockSize + 7] = {
@@ skipping 26 matching lines @@
   // 12-15 are skipped to account for the filter lag.
   for (size_t i = 0; i < 12; ++i) {
     EXPECT_EQ(kRefValue32kHz1, out_vector[i]);
     EXPECT_EQ(kRefValue16kHz1, out_vector_w16[i]);
   }
   for (size_t i = 16; i < 2 * kBlockSize; ++i) {
     EXPECT_EQ(kRefValue32kHz2, out_vector[i]);
     EXPECT_EQ(kRefValue16kHz2, out_vector_w16[i]);
   }
 }