OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/data_usage/core/data_use_aggregator.h" | 5 #include "components/data_usage/core/data_use_aggregator.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
11 #include "base/memory/scoped_ptr.h" | 11 #include "base/memory/scoped_ptr.h" |
12 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
13 #include "components/data_usage/core/data_use.h" | 13 #include "components/data_usage/core/data_use.h" |
| 14 #include "components/data_usage/core/data_use_amortizer.h" |
14 #include "net/base/network_change_notifier.h" | 15 #include "net/base/network_change_notifier.h" |
15 #include "net/base/network_delegate_impl.h" | 16 #include "net/base/network_delegate_impl.h" |
16 #include "net/socket/socket_test_util.h" | 17 #include "net/socket/socket_test_util.h" |
17 #include "net/url_request/url_request.h" | 18 #include "net/url_request/url_request.h" |
18 #include "net/url_request/url_request_test_util.h" | 19 #include "net/url_request/url_request_test_util.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
20 #include "url/gurl.h" | 21 #include "url/gurl.h" |
21 | 22 |
22 namespace data_usage { | 23 namespace data_usage { |
23 | 24 |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
99 return observed_data_use_; | 100 return observed_data_use_; |
100 } | 101 } |
101 | 102 |
102 private: | 103 private: |
103 DataUseAggregator* data_use_aggregator_; | 104 DataUseAggregator* data_use_aggregator_; |
104 std::vector<DataUse> observed_data_use_; | 105 std::vector<DataUse> observed_data_use_; |
105 | 106 |
106 DISALLOW_COPY_AND_ASSIGN(TestObserver); | 107 DISALLOW_COPY_AND_ASSIGN(TestObserver); |
107 }; | 108 }; |
108 | 109 |
| 110 // An amortizer that doubles all byte counts it sees. |
| 111 class DoublingAmortizer : public DataUseAmortizer { |
| 112 public: |
| 113 DoublingAmortizer() {} |
| 114 ~DoublingAmortizer() override {} |
| 115 |
| 116 void Amortize(std::vector<DataUse>* data_use_sequence, |
| 117 int64_t extra_tx_bytes, |
| 118 int64_t extra_rx_bytes) override { |
| 119 for (DataUse& data_use : *data_use_sequence) { |
| 120 data_use.tx_bytes *= 2; |
| 121 data_use.rx_bytes *= 2; |
| 122 } |
| 123 } |
| 124 }; |
| 125 |
109 class DataUseAggregatorTest : public testing::Test { | 126 class DataUseAggregatorTest : public testing::Test { |
110 public: | 127 public: |
111 DataUseAggregatorTest() | 128 DataUseAggregatorTest() {} |
112 : reporting_network_delegate_(&data_use_aggregator_), | 129 ~DataUseAggregatorTest() override {} |
113 context_(true), | 130 |
114 test_observer_(&data_use_aggregator_) { | 131 void Initialize(scoped_ptr<DataUseAmortizer> data_use_amortizer) { |
115 context_.set_client_socket_factory(&mock_socket_factory_); | 132 // Ensure that nothing outlives the |data_use_aggregator_|. |
116 context_.set_network_delegate(&reporting_network_delegate_); | 133 test_observer_.reset(); |
117 context_.Init(); | 134 context_.reset(); |
| 135 reporting_network_delegate_.reset(); |
| 136 mock_socket_factory_.reset(); |
| 137 |
| 138 data_use_aggregator_.reset( |
| 139 new DataUseAggregator(data_use_amortizer.Pass())); |
| 140 test_observer_.reset(new TestObserver(data_use_aggregator_.get())); |
| 141 |
| 142 context_.reset(new net::TestURLRequestContext(true)); |
| 143 mock_socket_factory_.reset(new net::MockClientSocketFactory()); |
| 144 context_->set_client_socket_factory(mock_socket_factory_.get()); |
| 145 reporting_network_delegate_.reset( |
| 146 new ReportingNetworkDelegate(data_use_aggregator_.get())); |
| 147 context_->set_network_delegate(reporting_network_delegate_.get()); |
| 148 context_->Init(); |
118 } | 149 } |
119 | 150 |
120 ~DataUseAggregatorTest() override {} | |
121 | |
122 scoped_ptr<net::URLRequest> ExecuteRequest( | 151 scoped_ptr<net::URLRequest> ExecuteRequest( |
123 const GURL& url, | 152 const GURL& url, |
124 const GURL& first_party_for_cookies) { | 153 const GURL& first_party_for_cookies) { |
125 net::MockRead reads[] = { | 154 net::MockRead reads[] = { |
126 net::MockRead("HTTP/1.1 200 OK\r\n\r\n"), net::MockRead("hello world"), | 155 net::MockRead("HTTP/1.1 200 OK\r\n\r\n"), net::MockRead("hello world"), |
127 net::MockRead(net::SYNCHRONOUS, net::OK), | 156 net::MockRead(net::SYNCHRONOUS, net::OK), |
128 }; | 157 }; |
129 net::StaticSocketDataProvider socket(reads, arraysize(reads), nullptr, 0); | 158 net::StaticSocketDataProvider socket(reads, arraysize(reads), nullptr, 0); |
130 mock_socket_factory_.AddSocketDataProvider(&socket); | 159 mock_socket_factory_->AddSocketDataProvider(&socket); |
131 | 160 |
132 net::TestDelegate delegate; | 161 net::TestDelegate delegate; |
133 scoped_ptr<net::URLRequest> request = | 162 scoped_ptr<net::URLRequest> request = |
134 context_.CreateRequest(url, net::IDLE, &delegate); | 163 context_->CreateRequest(url, net::IDLE, &delegate); |
135 request->set_first_party_for_cookies(first_party_for_cookies); | 164 request->set_first_party_for_cookies(first_party_for_cookies); |
136 request->Start(); | 165 request->Start(); |
137 loop_.RunUntilIdle(); | 166 loop_.RunUntilIdle(); |
138 | 167 |
139 return request.Pass(); | 168 return request.Pass(); |
140 } | 169 } |
141 | 170 |
142 void SimulateNetworkConnectionChange( | 171 void SimulateNetworkConnectionChange( |
143 net::NetworkChangeNotifier::ConnectionType connection_type) { | 172 net::NetworkChangeNotifier::ConnectionType connection_type) { |
144 test_network_change_notifier_.SimulateNetworkConnectionChange( | 173 test_network_change_notifier_.SimulateNetworkConnectionChange( |
145 connection_type); | 174 connection_type); |
146 } | 175 } |
147 | 176 |
148 void set_tab_id_for_requests(int32_t tab_id_for_requests) { | 177 void set_tab_id_for_requests(int32_t tab_id_for_requests) { |
149 reporting_network_delegate_.set_tab_id_for_requests(tab_id_for_requests); | 178 reporting_network_delegate_->set_tab_id_for_requests(tab_id_for_requests); |
150 } | 179 } |
151 | 180 |
152 DataUseAggregator* data_use_aggregator() { return &data_use_aggregator_; } | 181 DataUseAggregator* data_use_aggregator() { |
| 182 return data_use_aggregator_.get(); |
| 183 } |
153 | 184 |
154 const std::vector<DataUse>& observed_data_use() const { | 185 const std::vector<DataUse>& observed_data_use() const { |
155 return test_observer_.observed_data_use(); | 186 return test_observer_->observed_data_use(); |
156 } | 187 } |
157 | 188 |
158 private: | 189 private: |
159 base::MessageLoopForIO loop_; | 190 base::MessageLoopForIO loop_; |
160 TestNetworkChangeNotifier test_network_change_notifier_; | 191 TestNetworkChangeNotifier test_network_change_notifier_; |
161 | 192 |
162 DataUseAggregator data_use_aggregator_; | 193 scoped_ptr<DataUseAggregator> data_use_aggregator_; |
163 net::MockClientSocketFactory mock_socket_factory_; | 194 scoped_ptr<net::MockClientSocketFactory> mock_socket_factory_; |
164 ReportingNetworkDelegate reporting_network_delegate_; | 195 scoped_ptr<ReportingNetworkDelegate> reporting_network_delegate_; |
165 net::TestURLRequestContext context_; | 196 scoped_ptr<net::TestURLRequestContext> context_; |
166 TestObserver test_observer_; | 197 scoped_ptr<TestObserver> test_observer_; |
167 | 198 |
168 DISALLOW_COPY_AND_ASSIGN(DataUseAggregatorTest); | 199 DISALLOW_COPY_AND_ASSIGN(DataUseAggregatorTest); |
169 }; | 200 }; |
170 | 201 |
171 TEST_F(DataUseAggregatorTest, ReportDataUse) { | 202 TEST_F(DataUseAggregatorTest, ReportDataUse) { |
172 const net::NetworkChangeNotifier::ConnectionType kFooConnectionType = | 203 const bool kBooleans[] = {false, true}; |
173 net::NetworkChangeNotifier::CONNECTION_2G; | 204 for (bool use_doubling_amortizer : kBooleans) { |
174 SimulateNetworkConnectionChange(kFooConnectionType); | 205 Initialize(use_doubling_amortizer |
175 const int32_t kFooTabId = 10; | 206 ? scoped_ptr<DataUseAmortizer>(new DoublingAmortizer()) |
176 set_tab_id_for_requests(kFooTabId); | 207 : scoped_ptr<DataUseAmortizer>()); |
177 const scoped_ptr<net::URLRequest> foo_request = | |
178 ExecuteRequest(GURL("http://foo.com"), GURL("http://foofirstparty.com")); | |
179 | 208 |
180 const net::NetworkChangeNotifier::ConnectionType kBarConnectionType = | 209 const net::NetworkChangeNotifier::ConnectionType kFooConnectionType = |
181 net::NetworkChangeNotifier::CONNECTION_WIFI; | 210 net::NetworkChangeNotifier::CONNECTION_2G; |
182 SimulateNetworkConnectionChange(kBarConnectionType); | 211 SimulateNetworkConnectionChange(kFooConnectionType); |
183 const int32_t kBarTabId = 20; | 212 const int32_t kFooTabId = 10; |
184 set_tab_id_for_requests(kBarTabId); | 213 set_tab_id_for_requests(kFooTabId); |
185 scoped_ptr<net::URLRequest> bar_request = | 214 const scoped_ptr<net::URLRequest> foo_request = ExecuteRequest( |
186 ExecuteRequest(GURL("http://bar.com"), GURL("http://barfirstparty.com")); | 215 GURL("http://foo.com"), GURL("http://foofirstparty.com")); |
187 | 216 |
188 auto data_use_it = observed_data_use().begin(); | 217 const net::NetworkChangeNotifier::ConnectionType kBarConnectionType = |
| 218 net::NetworkChangeNotifier::CONNECTION_WIFI; |
| 219 SimulateNetworkConnectionChange(kBarConnectionType); |
| 220 const int32_t kBarTabId = 20; |
| 221 set_tab_id_for_requests(kBarTabId); |
| 222 scoped_ptr<net::URLRequest> bar_request = ExecuteRequest( |
| 223 GURL("http://bar.com"), GURL("http://barfirstparty.com")); |
189 | 224 |
190 // First, the |foo_request| data use should have happened. | 225 auto data_use_it = observed_data_use().begin(); |
191 int64_t observed_foo_tx_bytes = 0, observed_foo_rx_bytes = 0; | |
192 while (data_use_it != observed_data_use().end() && | |
193 data_use_it->url == GURL("http://foo.com")) { | |
194 EXPECT_EQ(foo_request->request_time(), data_use_it->request_time); | |
195 EXPECT_EQ(GURL("http://foofirstparty.com"), | |
196 data_use_it->first_party_for_cookies); | |
197 EXPECT_EQ(kFooTabId, data_use_it->tab_id); | |
198 EXPECT_EQ(kFooConnectionType, data_use_it->connection_type); | |
199 | 226 |
200 observed_foo_tx_bytes += data_use_it->tx_bytes; | 227 // First, the |foo_request| data use should have happened. |
201 observed_foo_rx_bytes += data_use_it->rx_bytes; | 228 int64_t observed_foo_tx_bytes = 0, observed_foo_rx_bytes = 0; |
202 ++data_use_it; | 229 while (data_use_it != observed_data_use().end() && |
| 230 data_use_it->url == GURL("http://foo.com")) { |
| 231 EXPECT_EQ(foo_request->request_time(), data_use_it->request_time); |
| 232 EXPECT_EQ(GURL("http://foofirstparty.com"), |
| 233 data_use_it->first_party_for_cookies); |
| 234 EXPECT_EQ(kFooTabId, data_use_it->tab_id); |
| 235 EXPECT_EQ(kFooConnectionType, data_use_it->connection_type); |
| 236 |
| 237 observed_foo_tx_bytes += data_use_it->tx_bytes; |
| 238 observed_foo_rx_bytes += data_use_it->rx_bytes; |
| 239 ++data_use_it; |
| 240 } |
| 241 if (use_doubling_amortizer) { |
| 242 EXPECT_EQ(2 * foo_request->GetTotalSentBytes(), observed_foo_tx_bytes); |
| 243 EXPECT_EQ(2 * foo_request->GetTotalReceivedBytes(), |
| 244 observed_foo_rx_bytes); |
| 245 } else { |
| 246 EXPECT_EQ(foo_request->GetTotalSentBytes(), observed_foo_tx_bytes); |
| 247 EXPECT_EQ(foo_request->GetTotalReceivedBytes(), observed_foo_rx_bytes); |
| 248 } |
| 249 |
| 250 // Then, the |bar_request| data use should have happened. |
| 251 int64_t observed_bar_tx_bytes = 0, observed_bar_rx_bytes = 0; |
| 252 while (data_use_it != observed_data_use().end()) { |
| 253 EXPECT_EQ(GURL("http://bar.com"), data_use_it->url); |
| 254 EXPECT_EQ(bar_request->request_time(), data_use_it->request_time); |
| 255 EXPECT_EQ(GURL("http://barfirstparty.com"), |
| 256 data_use_it->first_party_for_cookies); |
| 257 EXPECT_EQ(kBarTabId, data_use_it->tab_id); |
| 258 EXPECT_EQ(kBarConnectionType, data_use_it->connection_type); |
| 259 |
| 260 observed_bar_tx_bytes += data_use_it->tx_bytes; |
| 261 observed_bar_rx_bytes += data_use_it->rx_bytes; |
| 262 ++data_use_it; |
| 263 } |
| 264 if (use_doubling_amortizer) { |
| 265 EXPECT_EQ(2 * bar_request->GetTotalSentBytes(), observed_bar_tx_bytes); |
| 266 EXPECT_EQ(2 * bar_request->GetTotalReceivedBytes(), |
| 267 observed_bar_rx_bytes); |
| 268 } else { |
| 269 EXPECT_EQ(bar_request->GetTotalSentBytes(), observed_bar_tx_bytes); |
| 270 EXPECT_EQ(bar_request->GetTotalReceivedBytes(), observed_bar_rx_bytes); |
| 271 } |
203 } | 272 } |
204 EXPECT_EQ(foo_request->GetTotalSentBytes(), observed_foo_tx_bytes); | |
205 EXPECT_EQ(foo_request->GetTotalReceivedBytes(), observed_foo_rx_bytes); | |
206 | |
207 // Then, the |bar_request| data use should have happened. | |
208 int64_t observed_bar_tx_bytes = 0, observed_bar_rx_bytes = 0; | |
209 while (data_use_it != observed_data_use().end()) { | |
210 EXPECT_EQ(GURL("http://bar.com"), data_use_it->url); | |
211 EXPECT_EQ(bar_request->request_time(), data_use_it->request_time); | |
212 EXPECT_EQ(GURL("http://barfirstparty.com"), | |
213 data_use_it->first_party_for_cookies); | |
214 EXPECT_EQ(kBarTabId, data_use_it->tab_id); | |
215 EXPECT_EQ(kBarConnectionType, data_use_it->connection_type); | |
216 | |
217 observed_bar_tx_bytes += data_use_it->tx_bytes; | |
218 observed_bar_rx_bytes += data_use_it->rx_bytes; | |
219 ++data_use_it; | |
220 } | |
221 EXPECT_EQ(bar_request->GetTotalSentBytes(), observed_bar_tx_bytes); | |
222 EXPECT_EQ(bar_request->GetTotalReceivedBytes(), observed_bar_rx_bytes); | |
223 } | 273 } |
224 | 274 |
225 TEST_F(DataUseAggregatorTest, ReportOffTheRecordDataUse) { | 275 TEST_F(DataUseAggregatorTest, ReportOffTheRecordDataUse) { |
| 276 Initialize(scoped_ptr<DataUseAmortizer>(new DoublingAmortizer())); |
| 277 |
226 // Off the record data use should not be reported to observers. | 278 // Off the record data use should not be reported to observers. |
227 data_use_aggregator()->ReportOffTheRecordDataUse(1000, 1000); | 279 data_use_aggregator()->ReportOffTheRecordDataUse(1000, 1000); |
228 base::MessageLoop::current()->RunUntilIdle(); | 280 base::MessageLoop::current()->RunUntilIdle(); |
229 EXPECT_EQ(static_cast<size_t>(0), observed_data_use().size()); | 281 EXPECT_EQ(static_cast<size_t>(0), observed_data_use().size()); |
230 } | 282 } |
231 | 283 |
232 } // namespace | 284 } // namespace |
233 | 285 |
234 } // namespace data_usage | 286 } // namespace data_usage |
OLD | NEW |