Split NQE to multiple files

net/nqe/network_quality.h

Index: net/nqe/network_quality.h
diff --git a/net/nqe/network_quality.h b/net/nqe/network_quality.h
new file mode 100644
index 0000000000000000000000000000000000000000..a962be516a5493dbc999767db0ac70253ceb47c8
--- /dev/null
+++ b/net/nqe/network_quality.h
@@ -0,0 +1,93 @@
+// 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_NETWORK_QUALITY_H_
+#define NET_NQE_NETWORK_QUALITY_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "base/gtest_prod_util.h"
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "net/base/net_export.h"
+
+namespace net {
+
+namespace nqe {
+
+namespace internal {
+
+// Returns the RTT value to be used when the valid RTT is unavailable. Readers
+// should discard RTT if it is set to the value returned by |InvalidRTT()|.
+NET_EXPORT_PRIVATE base::TimeDelta InvalidRTT();
+
+// Throughput is set to |kInvalidThroughput| if a valid value is
+// unavailable. Readers should discard throughput value if it is set to
+// |kInvalidThroughput|.
+const int32_t kInvalidThroughput = 0;

[bengr, 2016/05/03 21:59:45]

Why doesn't have a corresponding method? E.g., InvalidThroughput(). Why is the
return an int32_t instead of an int64_t? Why is 0 invalid? Can't throughput be
0?

[tbansal1, 2016/05/04 22:07:24]

Method was required for RTT because there can't be static fields in classes that
have non-basic data types. It is okay to have static int32 object but not static
TimeDelta object.
Because throughput is int32 field.
0 is invalid because currently NQE takes a throughput sample only when there is
some network activity.

+
+// NetworkQuality is used to cache the quality of a network connection.
+class NET_EXPORT_PRIVATE NetworkQuality {
+ public:
+  NetworkQuality();
+  // |rtt| is the estimate of the round trip time.
+  // |downstream_throughput_kbps| is the estimate of the downstream
+  // throughput in kilobits per second.
+  NetworkQuality(const base::TimeDelta& rtt,
+                 int32_t downstream_throughput_kbps);

[bengr, 2016/05/03 21:59:45]

You use int32_t and int64_t in different parts of the code. Can we move
everything to one or the other?

[tbansal1, 2016/05/04 22:07:24]

I do not see int64_t anywhere in this CL. 
It might be in the other throughput CL. If
that's what you are referring to, then throughput is int32_t  kbps
but the byte or bit count is int64_t.

The latter (byte or bit count) has to be int64_t. It would be
overkill to make throughput (in kbps) a 64 bit variable.

+  NetworkQuality(const NetworkQuality& other);
+  ~NetworkQuality();
+
+  NetworkQuality& operator=(const NetworkQuality& other);
+
+  // Returns the estimate of the round trip time.
+  const base::TimeDelta& rtt() const { return rtt_; }

[bengr, 2016/05/03 21:59:45]

Which RTT is this?

[tbansal1, 2016/05/04 22:07:24]

Fixed. NetworkQuality structure needs to be expanded so it can hold on transport
layer RTT. I am planning to do that in a future CL.

+
+  // Returns the estimate of the downstream throughput in Kbps (Kilobits per
+  // second).
+  int32_t downstream_throughput_kbps() const {
+    return downstream_throughput_kbps_;
+  }
+
+ private:
+  // Estimated round trip time.

[bengr, 2016/05/03 21:59:45]

Again, which RTT?

[tbansal1, 2016/05/04 22:07:24]

Done.

+  base::TimeDelta rtt_;
+
+  // Estimated downstream throughput in kilobits per second.
+  int32_t downstream_throughput_kbps_;
+};
+
+// CachedNetworkQuality stores the quality of a previously seen network.
+class NET_EXPORT_PRIVATE CachedNetworkQuality {
+ public:
+  explicit CachedNetworkQuality(const NetworkQuality& network_quality);
+  CachedNetworkQuality(const CachedNetworkQuality& other);
+  ~CachedNetworkQuality();
+
+  // Returns the network quality associated with this cached entry.
+  const NetworkQuality& network_quality() const { return network_quality_; }
+
+  // Returns true if this cache entry was updated before
+  // |cached_network_quality|.
+  bool OlderThan(const CachedNetworkQuality& cached_network_quality) const;
+
+  // Time when this cache entry was last updated.
+  const base::TimeTicks last_update_time_;
+
+  // Quality of this cached network.
+  const NetworkQuality network_quality_;
+
+ private:
+  DISALLOW_ASSIGN(CachedNetworkQuality);
+};
+
+}  // namespace internal
+
+}  // namespace nqe
+
+}  // namespace net
+
+#endif  // NET_NQE_NETWORK_QUALITY_H_