Fix unused lambda captures in //net.

net/quic/test_tools/simulator/simulator_test.cc

 // Copyright (c) 2012 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 "net/quic/test_tools/simulator/simulator.h"
 
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simulator/alarm_factory.h"
@@ skipping 291 matching lines @@
   CounterPort counter;
 
   OneWayLink local_link(&simulator, "Local link", &queue, local_bandwidth,
                         local_propagation_delay);
   OneWayLink bottleneck_link(&simulator, "Bottleneck link", &counter,
                              bottleneck_bandwidth,
                              bottleneck_propagation_delay);
   saturator.SetTxPort(&local_link);
   queue.set_tx_port(&bottleneck_link);
 
-  const QuicPacketCount packets_received = 1000;
-  simulator.RunUntil([&counter, packets_received]() {
-    return counter.packets() == packets_received;
-  });
+  static const QuicPacketCount packets_received = 1000;

[eroman, 2017/01/20 17:49:25]

[optional] These should probably be renamed to kPacketsReceived to match the
constants style. On the other hand given the other use of "const" in this file
that would be inconsistent, so maybe best to leave current names.

[krasin1, 2017/01/20 18:02:20]

Let's leave it as is. Yesterday, in a similar case I was asked to renamed a var
from kSomethingSomething to something_something. Which means there is no
agreement between the owners, and doing fewer back-n-forth changes is probably
wise.

+  simulator.RunUntil(
+      [&counter]() { return counter.packets() == packets_received; });
   const double loss_ratio =
       1 -
       static_cast<double>(packets_received) / saturator.packets_transmitted();
   EXPECT_NEAR(loss_ratio, 0.9, 0.001);
 }
 
 // Verify that the queue of exactly one packet allows the transmission to
 // actually go through.
 TEST(SimulatorTest, OnePacketQueue) {
   const QuicBandwidth local_bandwidth =
@@ skipping 10 matching lines @@
   CounterPort counter;
 
   OneWayLink local_link(&simulator, "Local link", &queue, local_bandwidth,
                         local_propagation_delay);
   OneWayLink bottleneck_link(&simulator, "Bottleneck link", &counter,
                              bottleneck_bandwidth,
                              bottleneck_propagation_delay);
   saturator.SetTxPort(&local_link);
   queue.set_tx_port(&bottleneck_link);
 
-  const QuicPacketCount packets_received = 10;
+  static const QuicPacketCount packets_received = 10;
   // The deadline here is to prevent this tests from looping infinitely in case
   // the packets never reach the receiver.
   const QuicTime deadline =
       simulator.GetClock()->Now() + QuicTime::Delta::FromSeconds(10);
-  simulator.RunUntil([&simulator, &counter, packets_received, deadline]() {
+  simulator.RunUntil([&simulator, &counter, deadline]() {
     return counter.packets() == packets_received ||
            simulator.GetClock()->Now() > deadline;
   });
   ASSERT_EQ(packets_received, counter.packets());
 }
 
 // Simulate a network where three endpoints are connected to a switch and they
 // are sending traffic in circle (1 -> 2, 2 -> 3, 3 -> 1).
 TEST(SimulatorTest, SwitchedNetwork) {
   const QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(10000);
@@ skipping 10 matching lines @@
   // For determinicity, make it so that the first packet will arrive from
   // Saturator 1, then from Saturator 2, and then from Saturator 3.
   SymmetricLink link1(&saturator1, network_switch.port(1), bandwidth,
                       base_propagation_delay);
   SymmetricLink link2(&saturator2, network_switch.port(2), bandwidth,
                       base_propagation_delay * 2);
   SymmetricLink link3(&saturator3, network_switch.port(3), bandwidth,
                       base_propagation_delay * 3);
 
   const QuicTime start_time = simulator.GetClock()->Now();
-  const QuicPacketCount bytes_received = 64 * 1000;
-  simulator.RunUntil([&saturator1, bytes_received]() {
+  static const QuicPacketCount bytes_received = 64 * 1000;
+  simulator.RunUntil([&saturator1]() {
     return saturator1.counter()->bytes() >= bytes_received;
   });
   const QuicTime end_time = simulator.GetClock()->Now();
 
   const QuicBandwidth observed_bandwidth = QuicBandwidth::FromBytesAndTimeDelta(
       bytes_received, end_time - start_time);
   const double bandwidth_ratio =
       static_cast<double>(observed_bandwidth.ToBitsPerSecond()) /
       bandwidth.ToBitsPerSecond();
   EXPECT_NEAR(1, bandwidth_ratio, 0.1);
@@ skipping 229 matching lines @@
   const QuicTime::Delta base_propagation_delay =
       QuicTime::Delta::FromMilliseconds(5);
   const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(10);
 
   Simulator simulator;
   LinkSaturator saturator1(&simulator, "Saturator 1", 1000, "Saturator 2");
   LinkSaturator saturator2(&simulator, "Saturator 2", 1000, "Saturator 1");
   Switch network_switch(&simulator, "Switch", 8,
                         bandwidth * base_propagation_delay * 10);
 
-  const QuicByteCount initial_burst = 1000 * 10;
-  const QuicByteCount max_bucket_size = 1000 * 100;
-  const QuicBandwidth target_bandwidth = bandwidth * 0.25;
+  static const QuicByteCount initial_burst = 1000 * 10;
+  static const QuicByteCount max_bucket_size = 1000 * 100;
+  static const QuicBandwidth target_bandwidth = bandwidth * 0.25;
   TrafficPolicer policer(&simulator, "Policer", initial_burst, max_bucket_size,
                          target_bandwidth, network_switch.port(2));
 
   SymmetricLink link1(&saturator1, network_switch.port(1), bandwidth,
                       base_propagation_delay);
   SymmetricLink link2(&saturator2, &policer, bandwidth, base_propagation_delay);
 
   // Ensure the initial burst passes without being dropped at all.
   bool simulator_result = simulator.RunUntilOrTimeout(
-      [&saturator1, initial_burst]() {
+      [&saturator1]() {
         return saturator1.bytes_transmitted() == initial_burst;
       },
       timeout);
   ASSERT_TRUE(simulator_result);
   saturator1.Pause();
   simulator_result = simulator.RunUntilOrTimeout(
-      [&saturator2, initial_burst]() {
+      [&saturator2]() {
         return saturator2.counter()->bytes() == initial_burst;
       },
       timeout);
   ASSERT_TRUE(simulator_result);
   saturator1.Resume();
 
   // Run for some time so that the initial burst is not visible.
   const QuicTime::Delta simulation_time = QuicTime::Delta::FromSeconds(10);
   simulator.RunFor(simulation_time);
 
@@ skipping 61 matching lines @@
 
   // Expect subsequent traffic to be policed.
   saturator1.Resume();
   simulator.RunFor(QuicTime::Delta::FromSeconds(10));
   test::ExpectApproxEq(saturator1.bytes_transmitted() / 4,
                        saturator2.counter()->bytes(), 0.1f);
 }
 
 }  // namespace simulator
 }  // namespace net