Don't capture variables explicitly in lambda expression.

webrtc/modules/audio_coding/neteq/neteq_impl_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.
  */
 
@@ skipping 295 matching lines @@
   rtp_header.header.timestamp = kFirstTimestamp;
   rtp_header.header.ssrc = kSsrc;
   Packet fake_packet;
   fake_packet.payload_type = kPayloadType;
   fake_packet.sequence_number = kFirstSequenceNumber;
   fake_packet.timestamp = kFirstTimestamp;
 
   rtc::scoped_refptr<MockAudioDecoderFactory> mock_decoder_factory(
       new rtc::RefCountedObject<MockAudioDecoderFactory>);
   EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _))
-      .WillOnce(Invoke([kPayloadLength, kFirstSequenceNumber, kFirstTimestamp,
-                        kFirstReceiveTime](const SdpAudioFormat& format,
-                                           std::unique_ptr<AudioDecoder>* dec) {
+      .WillOnce(Invoke([=](const SdpAudioFormat& format,
+                          std::unique_ptr<AudioDecoder>* dec) {

[kwiberg-webrtc, 2017/02/02 18:24:59]

Uh? I clearly see those constants being used a bit further down in the lambda
body... whatever compiler you're using must be confused.

However. If you must make a default capture, it's probably better to capture by
reference. Otherwise, it's very hard to see exactly what sort of copy
constructors end up being called.

(Yes, that means the lambda must not be called after the end of the block in
which it was created, but that is the case here. If it weren't the case, I would
have objected to default capturing, by reference OR by value.)

[ossu, 2017/02/06 14:20:51]

If I were to guess as to why this happens, it's the compiler replacing constants
with literal values in the lambda body and only afterwards checking for
unnecessary captures. Very strange. Sounds like a compiler bug. Which compiler
does this? GCC? MSVC?

         EXPECT_EQ("pcmu", format.name);
 
         std::unique_ptr<MockAudioDecoder> mock_decoder(new MockAudioDecoder);
         EXPECT_CALL(*mock_decoder, Channels()).WillRepeatedly(Return(1));
         EXPECT_CALL(*mock_decoder, SampleRateHz()).WillRepeatedly(Return(8000));
         // BWE update function called with first packet.
         EXPECT_CALL(*mock_decoder,
                     IncomingPacket(_, kPayloadLength, kFirstSequenceNumber,
                                    kFirstTimestamp, kFirstReceiveTime));
         // BWE update function called with second packet.
@@ skipping 1162 matching lines @@
   EXPECT_CALL(*mock_delay_manager_, BufferLimits(_, _))
       .Times(1)
       .WillOnce(DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2)));
 
   bool muted;
   EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kAccelerate, neteq_->last_operation_for_test());
 }
 
 }// namespace webrtc