Clang format slam.

net/base/bandwidth_metrics.h

 // Copyright (c) 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.
 
 #ifndef NET_BASE_BANDWIDTH_METRICS_H_
 #define NET_BASE_BANDWIDTH_METRICS_H_
 
 #include <list>
 
 #include "base/logging.h"
@@ skipping 39 matching lines @@
 //   tracker.StopStream();
 //
 // NOTE: This class is not thread safe.
 //
 class BandwidthMetrics {
  public:
   BandwidthMetrics()
       : num_streams_in_progress_(0),
         num_data_samples_(0),
         data_sum_(0.0),
-        bytes_since_last_start_(0) {
-  }
+        bytes_since_last_start_(0) {}
 
   // Get the bandwidth.  Returns Kbps (kilo-bits-per-second).
-  double bandwidth() const {
-    return data_sum_ / num_data_samples_;
-  }
+  double bandwidth() const { return data_sum_ / num_data_samples_; }
 
   // Record that we've started a stream.
   void StartStream() {
     // If we're the only stream, we've finished some idle time.  Record a new
     // timestamp to indicate the start of data flow.
     if (++num_streams_in_progress_ == 1) {
       last_start_ = base::TimeTicks::HighResNow();
       bytes_since_last_start_ = 0;
     }
   }
 
   // Track that we've completed a stream.
   void StopStream() {
     if (--num_streams_in_progress_ == 0) {
       // We don't use small streams when tracking bandwidth because they are not
       // precise; imagine a 25 byte stream.  The sample is too small to make
       // a good measurement.
       // 20KB is an arbitrary value.  We might want to use a lesser value.
       static const int64 kRecordSizeThreshold = 20 * 1024;
       if (bytes_since_last_start_ < kRecordSizeThreshold)
         return;
 
       base::TimeDelta delta = base::TimeTicks::HighResNow() - last_start_;
       double ms = delta.InMillisecondsF();
       if (ms > 0.0) {
         double kbps = static_cast<double>(bytes_since_last_start_) * 8 / ms;
         ++num_data_samples_;
         data_sum_ += kbps;
-        VLOG(1) << "Bandwidth: " << kbps
-                << "Kbps (avg " << bandwidth() << "Kbps)";
+        VLOG(1) << "Bandwidth: " << kbps << "Kbps (avg " << bandwidth()
+                << "Kbps)";
         int kbps_int = static_cast<int>(kbps);
         UMA_HISTOGRAM_COUNTS_10000("Net.DownloadBandwidth", kbps_int);
       }
     }
   }
 
   // Add a sample of the number of bytes read from the network into the tracker.
   void RecordBytes(int bytes) {
     DCHECK(num_streams_in_progress_);
     bytes_since_last_start_ += static_cast<int64>(bytes);
   }
 
  private:
-  int num_streams_in_progress_;   // The number of streams in progress.
+  int num_streams_in_progress_;  // The number of streams in progress.
   // TODO(mbelshe): Use a rolling buffer of 30 samples instead of an average.
   int num_data_samples_;          // The number of samples collected.
   double data_sum_;               // The sum of all samples collected.
   int64 bytes_since_last_start_;  // Bytes tracked during this "session".
   base::TimeTicks last_start_;    // Timestamp of the begin of this "session".
 };
 
 // A utility class for managing the lifecycle of a measured stream.
 // It is important that we not leave unclosed streams, and this class helps
 // ensure we always stop them.
 class ScopedBandwidthMetrics {
  public:
   ScopedBandwidthMetrics();
   ~ScopedBandwidthMetrics();
 
   void StartStream();
   void StopStream();
   void RecordBytes(int bytes);
 
  private:
   bool started_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_BANDWIDTH_METRICS_H_