Create component to expose network usage stats to consumers.

components/data_usage/core/data_use_aggregator.cc

Index: components/data_usage/core/data_use_aggregator.cc
diff --git a/components/data_usage/core/data_use_aggregator.cc b/components/data_usage/core/data_use_aggregator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c08d18eaa19edb790ce3b67b8e9a66f1353f1ab2
--- /dev/null
+++ b/components/data_usage/core/data_use_aggregator.cc
@@ -0,0 +1,87 @@
+// Copyright 2015 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 "components/data_usage/core/data_use_aggregator.h"
+
+namespace data_usage {
+
+DataUseDelta::DataUseDelta()
+    : tab_id(-1),
+      connection_type(net::NetworkChangeNotifier::CONNECTION_UNKNOWN),
+      tx_bytes(0),
+      rx_bytes(0) {}
+
+DataUseAggregator::Observer::~Observer() {}
+
+// static
+scoped_ptr<DataUseAggregator> DataUseAggregator::Create() {
+  scoped_ptr<DataUseAggregator> data_use_aggregator(new DataUseAggregator());
+  return data_use_aggregator.Pass();
+}
+
+DataUseAggregator::~DataUseAggregator() {
+  // TODO(sclittle): Most observers are probably already destroyed by the time
+  // this destructor runs. Find some way to ensure that no data usage gets lost.
+  if (!buffered_data_use_deltas_.empty()) {
+    NotifyDataUse(buffered_data_use_deltas_);
+    buffered_data_use_deltas_.clear();
+  }
+}
+
+void DataUseAggregator::RegisterObserver(Observer* observer) {
+  auto insertion_result = observers_.insert(observer);
+  DCHECK(insertion_result.second) << "Duplicate observer registered.";
+}
+
+void DataUseAggregator::UnregisterObserver(Observer* observer) {
+  auto observer_it = observers_.find(observer);

[tbansal1, 2015/10/01 20:30:43]

Using ObserverList  would be simpler and is probably the recommended way.

[sclittle, 2015/10/03 03:27:52]

Done.

+  DCHECK(observer_it != observers_.end())

[tbansal1, 2015/10/01 20:30:43]

This DCHECK might be compiled out. If iterator is invalid, we should return.
Behavior of std::vector::erase() is undefined if the iterator is invalid (if I
am reading the documentation correctly :P).

http://www.cplusplus.com/reference/vector/vector/erase/

[sclittle, 2015/10/03 03:27:52]

Removed this, since the ObserverList already handles this.

+      << "Nonexistent observer unregistered.";
+  observers_.erase(observer_it);
+}
+
+void DataUseAggregator::ReportDataUse(const GURL& url,
+                                      const GURL& first_party_for_cookies,
+                                      TabId tab_id,
+                                      int64_t tx_bytes,
+                                      int64_t rx_bytes) {
+  DataUseDelta data_use_delta;
+  data_use_delta.url = url;

[bengr, 2015/10/02 19:32:22]

DataUseDelta could have a constructor for all of these. Would be less error
prone in that you wouldn't forget any.

[sclittle, 2015/10/03 03:27:52]

Done.

+  data_use_delta.first_party_for_cookies = first_party_for_cookies;
+  data_use_delta.tab_id = tab_id;
+  data_use_delta.connection_type =
+      net::NetworkChangeNotifier::GetConnectionType();
+  data_use_delta.tx_bytes = tx_bytes;
+  data_use_delta.rx_bytes = rx_bytes;
+
+  // TODO(sclittle): Once actual buffering/aggregation is being done, consider
+  // combining deltas into previous deltas with the same keys.
+  buffered_data_use_deltas_.push_back(data_use_delta);

[bengr, 2015/10/02 19:32:22]

Is there any limit to how much this class will buffer?

[sclittle, 2015/10/03 03:27:52]

Right now, it doesn't buffer at all. We can impose a limit on how big the buffer
can get once buffering is implemented.

+
+  // TODO(sclittle): Amortize data use on supported platforms.
+  NotifyDataUse(buffered_data_use_deltas_);
+  buffered_data_use_deltas_.clear();
+}
+
+void DataUseAggregator::ReportOffTheRecordDataUse(int64_t tx_bytes,
+                                                  int64_t rx_bytes) {
+  // TODO(sclittle): Once data usage amortization is implemented, keep track of
+  // the off-the-record bytes so that they can be taken out of the amortized
+  // data usage calculations if applicable.
+}
+
+base::WeakPtr<DataUseAggregator> DataUseAggregator::GetWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
+DataUseAggregator::DataUseAggregator() : weak_ptr_factory_(this) {}
+
+void DataUseAggregator::NotifyDataUse(
+    const std::vector<DataUseDelta>& data_use_deltas) {
+  for (Observer* observer : observers_) {
+    observer->OnDataUse(data_use_deltas);
+  }
+}
+
+}  // namespace data_usage