Fix some non-const ref function argument types.

net/nqe/observation_buffer.h

 // Copyright 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.
 
 #ifndef NET_NQE_OBSERVATION_BUFFER_H_
 #define NET_NQE_OBSERVATION_BUFFER_H_
 
 #include <float.h>
 
 #include <algorithm>
@@ skipping 76 matching lines @@
                      int percentile,
                      const std::vector<NetworkQualityObservationSource>&
                          disallowed_observation_sources) const {
     // Stores weighted observations in increasing order by value.
     std::vector<WeightedObservation<ValueType>> weighted_observations;
 
     // Total weight of all observations in |weighted_observations|.
     double total_weight = 0.0;
 
     ComputeWeightedObservations(begin_timestamp, current_signal_strength_dbm,
-                                weighted_observations, &total_weight,
+                                &weighted_observations, &total_weight,
                                 disallowed_observation_sources);
     if (weighted_observations.empty())
       return false;
 
     double desired_weight = percentile / 100.0 * total_weight;
 
     double cumulative_weight_seen_so_far = 0.0;
     for (const auto& weighted_observation : weighted_observations) {
       cumulative_weight_seen_so_far += weighted_observation.weight;
 
@@ skipping 24 matching lines @@
                           const std::vector<NetworkQualityObservationSource>&
                               disallowed_observation_sources,
                           ValueType* result) const {
     // Stores weighted observations in increasing order by value.
     std::vector<WeightedObservation<ValueType>> weighted_observations;
 
     // Total weight of all observations in |weighted_observations|.
     double total_weight = 0.0;
 
     ComputeWeightedObservations(begin_timestamp, current_signal_strength_dbm,
-                                weighted_observations, &total_weight,
+                                &weighted_observations, &total_weight,
                                 disallowed_observation_sources);
     if (weighted_observations.empty())
       return false;
 
     // Weighted average is the sum of observations times their respective
     // weights, divided by the sum of the weights of all observations.
     double total_weight_times_value = 0.0;
     for (const auto& weighted_observation : weighted_observations) {
       total_weight_times_value +=
           (weighted_observation.weight *
@@ skipping 16 matching lines @@
                             const std::vector<NetworkQualityObservationSource>&
                                 disallowed_observation_sources,
                             ValueType* result) const {
     // Stores weighted observations in increasing order by value.
     std::vector<WeightedObservation<ValueType>> weighted_observations;
 
     // Total weight of all observations in |weighted_observations|.
     double total_weight = 0.0;
 
     ComputeWeightedObservations(begin_timestamp, current_signal_strength_dbm,
-                                weighted_observations, &total_weight,
+                                &weighted_observations, &total_weight,
                                 disallowed_observation_sources);
     if (weighted_observations.empty())
       return false;
 
     // The unweighted average is the sum of all observations divided by the
     // number of observations.
     double total_value = 0.0;
     for (const auto& weighted_observation : weighted_observations)
       total_value += ConvertValueTypeToDouble(weighted_observation.value);
 
@@ skipping 29 matching lines @@
   // |weighted_observations| sorted by ascending |WeightedObservation.value|.
   // Only the observations with timestamp later than |begin_timestamp| are
   // considered. |current_signal_strength_dbm| is the current signal strength
   // (in dBm) when the observation was taken, and is set to INT32_MIN if the
   // signal strength is currently unavailable. This method also sets
   // |total_weight| to the total weight of all observations. Should be called
   // only when there is at least one observation in the buffer.
   void ComputeWeightedObservations(
       const base::TimeTicks& begin_timestamp,
       int32_t current_signal_strength_dbm,
-      std::vector<WeightedObservation<ValueType>>& weighted_observations,
+      std::vector<WeightedObservation<ValueType>>* weighted_observations,
       double* total_weight,
       const std::vector<NetworkQualityObservationSource>&
           disallowed_observation_sources) const {
     DCHECK_GE(Capacity(), Size());
 
-    weighted_observations.clear();
+    weighted_observations->clear();
     double total_weight_observations = 0.0;
     base::TimeTicks now = tick_clock_->NowTicks();
 
     for (const auto& observation : observations_) {
       if (observation.timestamp < begin_timestamp)
         continue;
       bool disallowed = false;
       for (const auto& disallowed_source : disallowed_observation_sources) {
         if (disallowed_source == observation.source)
           disallowed = true;
@@ skipping 12 matching lines @@
         int32_t signal_strength_weight_diff = std::abs(
             current_signal_strength_dbm - observation.signal_strength_dbm);
         signal_strength_weight =
             pow(weight_multiplier_per_dbm_, signal_strength_weight_diff);
       }
 
       double weight = time_weight * signal_strength_weight;
 
       weight = std::max(DBL_MIN, std::min(1.0, weight));
 
-      weighted_observations.push_back(
+      weighted_observations->push_back(
           WeightedObservation<ValueType>(observation.value, weight));
       total_weight_observations += weight;
     }
 
     // Sort the samples by value in ascending order.
-    std::sort(weighted_observations.begin(), weighted_observations.end());
+    std::sort(weighted_observations->begin(), weighted_observations->end());
     *total_weight = total_weight_observations;
 
     DCHECK_LE(0.0, *total_weight);
-    DCHECK(weighted_observations.empty() || 0.0 < *total_weight);
+    DCHECK(weighted_observations->empty() || 0.0 < *total_weight);
 
     // |weighted_observations| may have a smaller size than |observations_|
     // since the former contains only the observations later than
     // |begin_timestamp|.
-    DCHECK_GE(observations_.size(), weighted_observations.size());
+    DCHECK_GE(observations_.size(), weighted_observations->size());
   }
 
   // Holds observations sorted by time, with the oldest observation at the
   // front of the queue.
   std::deque<Observation<ValueType>> observations_;
 
   // The factor by which the weight of an observation reduces every second.
   // For example, if an observation is 6 seconds old, its weight would be:
   //     weight_multiplier_per_second_ ^ 6
   // Calculated from |kHalfLifeSeconds| by solving the following equation:
@@ skipping 13 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ObservationBuffer);
 };
 
 }  // namespace internal
 
 }  // namespace nqe
 
 }  // namespace net
 
 #endif  // NET_NQE_OBSERVATION_BUFFER_H_