Include tab IDs when reporting data use accounting.

components/data_usage/core/data_use_aggregator.cc

 // 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"
 
+#include <sstream>

[tbansal1, 2015/10/26 22:24:30]

why is sstream required?

[sclittle, 2015/10/26 23:56:01]

<sstream> and <string> are just included right now for debug logging, they'll be
removed in a later patch on this CL.

+#include <string>
+
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "components/data_usage/core/data_use.h"
 #include "net/base/network_change_notifier.h"
 #include "net/url_request/url_request.h"
 
 namespace data_usage {
 
+namespace {
+
+// Observer for debug logging.
+// TODO in this CL: Remove this before landing.

[bengr, 2015/10/27 00:01:47]

Please do remove it.

[sclittle, 2015/10/28 22:30:45]

Done.

+class LoggingObserver : public DataUseAggregator::Observer {
+ public:
+  LoggingObserver(DataUseAggregator* aggregator) : aggregator_(aggregator) {
+    DCHECK(aggregator_);
+    aggregator_->AddObserver(this);
+  }
+
+  ~LoggingObserver() override { aggregator_->RemoveObserver(this); }
+
+  void OnDataUse(
+      const std::vector<const DataUse*>& data_use_sequence) override {
+    std::ostringstream os;
+    for (const DataUse* data_use : data_use_sequence) {
+      os << "\n["
+         << "url=" << data_use->url << " rt=" << data_use->request_time
+         << " fp=" << data_use->first_party_for_cookies
+         << " tab_id=" << data_use->tab_id
+         << " ctype=" << data_use->connection_type
+         << " tx=" << data_use->tx_bytes << " rx=" << data_use->rx_bytes << "]";
+    }
+    LOG(WARNING) << "OnDataUse:" << os.str();
+  }
+
+ private:
+  DataUseAggregator* aggregator_;
+};
+
+}  // namespace
+
 DataUseAggregator::DataUseAggregator()
     : off_the_record_tx_bytes_since_last_flush_(0),
       off_the_record_rx_bytes_since_last_flush_(0),
       is_flush_pending_(false),
       weak_ptr_factory_(this) {}
 
 DataUseAggregator::~DataUseAggregator() {}
 
 void DataUseAggregator::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observer_list_.AddObserver(observer);
 }
 
 void DataUseAggregator::RemoveObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observer_list_.RemoveObserver(observer);
 }
 
-void DataUseAggregator::ReportDataUse(const net::URLRequest& request,
-                                      int32_t tab_id,
-                                      int64_t tx_bytes,
-                                      int64_t rx_bytes) {
+void DataUseAggregator::ReportDataUse(int64_t tx_bytes,
+                                      int64_t rx_bytes,
+                                      const GURL& url,
+                                      const base::Time& request_time,
+                                      const GURL& first_party_for_cookies,
+                                      int32_t tab_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<DataUse> data_use(new DataUse(
-      request.url(), request.request_time(), request.first_party_for_cookies(),
-      tab_id, net::NetworkChangeNotifier::GetConnectionType(), tx_bytes,
-      rx_bytes));
+      url, request_time, first_party_for_cookies, tab_id,
+      net::NetworkChangeNotifier::GetConnectionType(), tx_bytes, rx_bytes));
 
   // As an optimization, attempt to combine the newly reported data use with the
   // most recent buffered data use, if the annotations on the data use are the
   // same.
   if (!buffered_data_use_.empty() &&
       buffered_data_use_.back()->CanCombineWith(*data_use)) {
-    buffered_data_use_.back()->tx_bytes += tx_bytes;
-    buffered_data_use_.back()->rx_bytes += rx_bytes;
+    buffered_data_use_.back()->tx_bytes += data_use->tx_bytes;
+    buffered_data_use_.back()->rx_bytes += data_use->rx_bytes;
   } else {
     buffered_data_use_.push_back(data_use.Pass());
   }
 
   if (!is_flush_pending_) {
     // Post a flush operation to happen in the future, so that the
     // DataUseAggregator has a chance to batch together some data use before
     // notifying observers.
     base::MessageLoop::current()->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&DataUseAggregator::FlushBufferedDataUse, GetWeakPtr()));
     is_flush_pending_ = true;
   }
 }
 
 void DataUseAggregator::ReportOffTheRecordDataUse(int64_t tx_bytes,
                                                   int64_t rx_bytes) {
   DCHECK(thread_checker_.CalledOnValidThread());
   off_the_record_tx_bytes_since_last_flush_ += tx_bytes;
   off_the_record_rx_bytes_since_last_flush_ += rx_bytes;
 }
 
 base::WeakPtr<DataUseAggregator> DataUseAggregator::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void DataUseAggregator::FlushBufferedDataUse() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  // TODO in this CL: Remove this debug logging observer.

[bengr, 2015/10/27 00:01:47]

And this too.

[sclittle, 2015/10/28 22:30:45]

Done.

+  LoggingObserver logging_observer(this);
+
   // TODO(sclittle): Amortize data use on supported platforms before notifying
   // observers.
 
   // Pass Observers a sequence of const DataUse pointers instead of using the
   // buffer directly in order to prevent Observers from modifying the DataUse
   // objects.
   std::vector<const DataUse*> const_sequence(buffered_data_use_.begin(),
                                              buffered_data_use_.end());
   DCHECK(!ContainsValue(const_sequence, nullptr));
   FOR_EACH_OBSERVER(Observer, observer_list_, OnDataUse(const_sequence));
 
   buffered_data_use_.clear();
   off_the_record_tx_bytes_since_last_flush_ = 0;
   off_the_record_rx_bytes_since_last_flush_ = 0;
   is_flush_pending_ = false;
 }
 
 }  // namespace data_usage