Support moving pending requests from one DataUseRecorder to another

components/data_use_measurement/core/data_use_recorder.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 COMPONENTS_DATA_USE_MEASUREMENT_CORE_DATA_USE_RECORDER_H_
 #define COMPONENTS_DATA_USE_MEASUREMENT_CORE_DATA_USE_RECORDER_H_
 
 #include <stdint.h>
+#include <map>

[tbansal1, 2017/06/23 22:11:21]

nit: line break before #include <map>

[Raj, 2017/06/26 21:40:22]

Done

 
-#include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/supports_user_data.h"
 #include "components/data_use_measurement/core/data_use.h"
 #include "net/base/net_export.h"
 
 namespace net {
 class URLRequest;
 }
 
 namespace data_use_measurement {
 
 // Tracks all network data used by a single high level entity. An entity
 // can make multiple URLRequests, so there is a one:many relationship between
 // DataUseRecorders and URLRequests. Data used by each URLRequest will be
 // tracked by exactly one DataUseRecorder.
 class DataUseRecorder {
  public:
+  // Stores network data used by a URLRequest.
+  struct URLRequestDataUse {
+    URLRequestDataUse() : bytes_sent(0), bytes_received(0) {}
+

[rajendrant, 2017/06/20 21:34:00]

base::TimeTicks start_time will be added in a later CL. That will indicate when
the request started.

[tbansal1, 2017/06/26 21:44:28]

Acknowledged.

+    int64_t bytes_sent;
+    int64_t bytes_received;

[tbansal1, 2017/06/23 22:11:22]

For consistency, it would be better to have bytes_received  before bytes_sent. I
believe that's the order being followed everywhere else in this file.

[Raj, 2017/06/26 21:40:22]

Done

+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(URLRequestDataUse);
+  };
+
   explicit DataUseRecorder(DataUse::TrafficType traffic_type);
   virtual ~DataUseRecorder();
 
   // Returns the actual data used by the entity being tracked.
   DataUse& data_use() { return data_use_; }
-  const base::hash_set<net::URLRequest*>& pending_url_requests() const {
+  const std::map<net::URLRequest*, URLRequestDataUse>& pending_url_requests()
+      const {
     return pending_url_requests_;
   }
   const net::URLRequest* main_url_request() const { return main_url_request_; }
 
   void set_main_url_request(const net::URLRequest* request) {
     main_url_request_ = request;
   }
 
   bool is_visible() const { return is_visible_; }
 
   void set_is_visible(bool is_visible) { is_visible_ = is_visible; }
 
   uint64_t page_transition() const { return page_transition_; }
 
   void set_page_transition(uint64_t page_transition) {
     page_transition_ = page_transition;
   }
 
   // Returns whether data use is complete and no additional data can be used
   // by the entity tracked by this recorder. For example,
   bool IsDataUseComplete();
 
   // Adds |request| to the list of pending URLRequests that ascribe data use to
   // this recorder.
   void AddPendingURLRequest(net::URLRequest* request);
 
+  // Moves pending |request| from |this| recorder to |other| recorder, and
+  // updates the data use for the recorders.
+  void MovePendingURLRequest(DataUseRecorder* other, net::URLRequest* request);
+
   // Clears the list of pending URLRequests that ascribe data use to this
   // recorder.
   void RemoveAllPendingURLRequests();
 
   // Merge another DataUseRecorder to this instance.
   void MergeFrom(DataUseRecorder* other);
 
   // Network Delegate methods:
   void OnBeforeUrlRequest(net::URLRequest* request);
   void OnUrlRequestDestroyed(net::URLRequest* request);
   void OnNetworkBytesSent(net::URLRequest* request, int64_t bytes_sent);
   void OnNetworkBytesReceived(net::URLRequest* request, int64_t bytes_received);
 
  private:
+  // Updates the network data use for the url request.
+  void UpdateNetworkByteCounts(net::URLRequest* request,
+                               int64_t bytes_received,
+                               int64_t bytes_sent);
+
   // Pending URLRequests whose data is being tracked by this DataUseRecorder.
-  base::hash_set<net::URLRequest*> pending_url_requests_;
-
-  // Data sources other than URLRequests, whose data is being tracked by this
-  // DataUseRecorder.
-  base::hash_set<const void*> pending_data_sources_;
+  std::map<net::URLRequest*, URLRequestDataUse> pending_url_requests_;
 
   // The main frame URLRequest for page loads. Null if this is not tracking a
   // page load.
   const net::URLRequest* main_url_request_;
 
   // The network data use measured by this DataUseRecorder.
   DataUse data_use_;
 
   // Whether the entity that owns this data use is currently visible.
   bool is_visible_;
 
   // ui::PageTransition casted as a uint64_t.
   uint64_t page_transition_;
 
   DISALLOW_COPY_AND_ASSIGN(DataUseRecorder);
 };
 
 }  // namespace data_use_measurement
 
 #endif  // COMPONENTS_DATA_USE_MEASUREMENT_CORE_DATA_USE_RECORDER_H_