Lots of random cleanups, mostly for native_theme_win.cc:
[chromium-blink-merge.git] / net / http / http_transaction_test_util.cc
blobf54c99f3b4b2b3cbfec5f3eec11e9688a580e38f
1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "net/http/http_transaction_test_util.h"
7 #include <algorithm>
9 #include "base/bind.h"
10 #include "base/message_loop/message_loop.h"
11 #include "base/strings/stringprintf.h"
12 #include "base/time/time.h"
13 #include "net/base/load_flags.h"
14 #include "net/base/load_timing_info.h"
15 #include "net/base/net_errors.h"
16 #include "net/disk_cache/disk_cache.h"
17 #include "net/http/http_cache.h"
18 #include "net/http/http_request_info.h"
19 #include "net/http/http_response_info.h"
20 #include "net/http/http_transaction.h"
21 #include "testing/gtest/include/gtest/gtest.h"
23 namespace {
24 typedef base::hash_map<std::string, const MockTransaction*> MockTransactionMap;
25 static MockTransactionMap mock_transactions;
26 } // namespace
28 //-----------------------------------------------------------------------------
29 // mock transaction data
31 const MockTransaction kSimpleGET_Transaction = {
32 "http://www.google.com/",
33 "GET",
34 base::Time(),
35 "",
36 net::LOAD_NORMAL,
37 "HTTP/1.1 200 OK",
38 "Cache-Control: max-age=10000\n",
39 base::Time(),
40 "<html><body>Google Blah Blah</body></html>",
41 TEST_MODE_NORMAL,
42 NULL,
44 net::OK
47 const MockTransaction kSimplePOST_Transaction = {
48 "http://bugdatabase.com/edit",
49 "POST",
50 base::Time(),
51 "",
52 net::LOAD_NORMAL,
53 "HTTP/1.1 200 OK",
54 "",
55 base::Time(),
56 "<html><body>Google Blah Blah</body></html>",
57 TEST_MODE_NORMAL,
58 NULL,
60 net::OK
63 const MockTransaction kTypicalGET_Transaction = {
64 "http://www.example.com/~foo/bar.html",
65 "GET",
66 base::Time(),
67 "",
68 net::LOAD_NORMAL,
69 "HTTP/1.1 200 OK",
70 "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
71 "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n",
72 base::Time(),
73 "<html><body>Google Blah Blah</body></html>",
74 TEST_MODE_NORMAL,
75 NULL,
77 net::OK
80 const MockTransaction kETagGET_Transaction = {
81 "http://www.google.com/foopy",
82 "GET",
83 base::Time(),
84 "",
85 net::LOAD_NORMAL,
86 "HTTP/1.1 200 OK",
87 "Cache-Control: max-age=10000\n"
88 "Etag: \"foopy\"\n",
89 base::Time(),
90 "<html><body>Google Blah Blah</body></html>",
91 TEST_MODE_NORMAL,
92 NULL,
94 net::OK
97 const MockTransaction kRangeGET_Transaction = {
98 "http://www.google.com/",
99 "GET",
100 base::Time(),
101 "Range: 0-100\r\n",
102 net::LOAD_NORMAL,
103 "HTTP/1.1 200 OK",
104 "Cache-Control: max-age=10000\n",
105 base::Time(),
106 "<html><body>Google Blah Blah</body></html>",
107 TEST_MODE_NORMAL,
108 NULL,
110 net::OK
113 static const MockTransaction* const kBuiltinMockTransactions[] = {
114 &kSimpleGET_Transaction,
115 &kSimplePOST_Transaction,
116 &kTypicalGET_Transaction,
117 &kETagGET_Transaction,
118 &kRangeGET_Transaction
121 const MockTransaction* FindMockTransaction(const GURL& url) {
122 // look for overrides:
123 MockTransactionMap::const_iterator it = mock_transactions.find(url.spec());
124 if (it != mock_transactions.end())
125 return it->second;
127 // look for builtins:
128 for (size_t i = 0; i < arraysize(kBuiltinMockTransactions); ++i) {
129 if (url == GURL(kBuiltinMockTransactions[i]->url))
130 return kBuiltinMockTransactions[i];
132 return NULL;
135 void AddMockTransaction(const MockTransaction* trans) {
136 mock_transactions[GURL(trans->url).spec()] = trans;
139 void RemoveMockTransaction(const MockTransaction* trans) {
140 mock_transactions.erase(GURL(trans->url).spec());
143 MockHttpRequest::MockHttpRequest(const MockTransaction& t) {
144 url = GURL(t.url);
145 method = t.method;
146 extra_headers.AddHeadersFromString(t.request_headers);
147 load_flags = t.load_flags;
150 //-----------------------------------------------------------------------------
152 // static
153 int TestTransactionConsumer::quit_counter_ = 0;
155 TestTransactionConsumer::TestTransactionConsumer(
156 net::RequestPriority priority,
157 net::HttpTransactionFactory* factory)
158 : state_(IDLE), error_(net::OK) {
159 // Disregard the error code.
160 factory->CreateTransaction(priority, &trans_);
161 ++quit_counter_;
164 TestTransactionConsumer::~TestTransactionConsumer() {
167 void TestTransactionConsumer::Start(const net::HttpRequestInfo* request,
168 const net::BoundNetLog& net_log) {
169 state_ = STARTING;
170 int result = trans_->Start(
171 request, base::Bind(&TestTransactionConsumer::OnIOComplete,
172 base::Unretained(this)), net_log);
173 if (result != net::ERR_IO_PENDING)
174 DidStart(result);
177 void TestTransactionConsumer::DidStart(int result) {
178 if (result != net::OK) {
179 DidFinish(result);
180 } else {
181 Read();
185 void TestTransactionConsumer::DidRead(int result) {
186 if (result <= 0) {
187 DidFinish(result);
188 } else {
189 content_.append(read_buf_->data(), result);
190 Read();
194 void TestTransactionConsumer::DidFinish(int result) {
195 state_ = DONE;
196 error_ = result;
197 if (--quit_counter_ == 0)
198 base::MessageLoop::current()->Quit();
201 void TestTransactionConsumer::Read() {
202 state_ = READING;
203 read_buf_ = new net::IOBuffer(1024);
204 int result = trans_->Read(read_buf_.get(),
205 1024,
206 base::Bind(&TestTransactionConsumer::OnIOComplete,
207 base::Unretained(this)));
208 if (result != net::ERR_IO_PENDING)
209 DidRead(result);
212 void TestTransactionConsumer::OnIOComplete(int result) {
213 switch (state_) {
214 case STARTING:
215 DidStart(result);
216 break;
217 case READING:
218 DidRead(result);
219 break;
220 default:
221 NOTREACHED();
225 MockNetworkTransaction::MockNetworkTransaction(
226 net::RequestPriority priority,
227 MockNetworkLayer* factory)
228 : weak_factory_(this),
229 request_(NULL),
230 data_cursor_(0),
231 priority_(priority),
232 websocket_handshake_stream_create_helper_(NULL),
233 transaction_factory_(factory->AsWeakPtr()),
234 received_bytes_(0),
235 socket_log_id_(net::NetLog::Source::kInvalidId) {
238 MockNetworkTransaction::~MockNetworkTransaction() {}
240 int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
241 const net::CompletionCallback& callback,
242 const net::BoundNetLog& net_log) {
243 if (request_)
244 return net::ERR_FAILED;
246 request_ = request;
247 return StartInternal(request, callback, net_log);
250 int MockNetworkTransaction::RestartIgnoringLastError(
251 const net::CompletionCallback& callback) {
252 return net::ERR_FAILED;
255 int MockNetworkTransaction::RestartWithCertificate(
256 net::X509Certificate* client_cert,
257 const net::CompletionCallback& callback) {
258 return net::ERR_FAILED;
261 int MockNetworkTransaction::RestartWithAuth(
262 const net::AuthCredentials& credentials,
263 const net::CompletionCallback& callback) {
264 if (!IsReadyToRestartForAuth())
265 return net::ERR_FAILED;
267 net::HttpRequestInfo auth_request_info = *request_;
268 auth_request_info.extra_headers.AddHeaderFromString("Authorization: Bar");
270 // Let the MockTransactionHandler worry about this: the only way for this
271 // test to succeed is by using an explicit handler for the transaction so
272 // that server behavior can be simulated.
273 return StartInternal(&auth_request_info, callback, net::BoundNetLog());
276 bool MockNetworkTransaction::IsReadyToRestartForAuth() {
277 if (!request_)
278 return false;
280 // Only mock auth when the test asks for it.
281 return request_->extra_headers.HasHeader("X-Require-Mock-Auth");
284 int MockNetworkTransaction::Read(net::IOBuffer* buf, int buf_len,
285 const net::CompletionCallback& callback) {
286 int data_len = static_cast<int>(data_.size());
287 int num = std::min(buf_len, data_len - data_cursor_);
288 if (test_mode_ & TEST_MODE_SLOW_READ)
289 num = std::min(num, 1);
290 if (num) {
291 memcpy(buf->data(), data_.data() + data_cursor_, num);
292 data_cursor_ += num;
294 if (test_mode_ & TEST_MODE_SYNC_NET_READ)
295 return num;
297 CallbackLater(callback, num);
298 return net::ERR_IO_PENDING;
301 void MockNetworkTransaction::StopCaching() {
302 if (transaction_factory_.get())
303 transaction_factory_->TransactionStopCaching();
306 bool MockNetworkTransaction::GetFullRequestHeaders(
307 net::HttpRequestHeaders* headers) const {
308 return false;
311 int64 MockNetworkTransaction::GetTotalReceivedBytes() const {
312 return received_bytes_;
315 void MockNetworkTransaction::DoneReading() {
316 if (transaction_factory_.get())
317 transaction_factory_->TransactionDoneReading();
320 const net::HttpResponseInfo* MockNetworkTransaction::GetResponseInfo() const {
321 return &response_;
324 net::LoadState MockNetworkTransaction::GetLoadState() const {
325 if (data_cursor_)
326 return net::LOAD_STATE_READING_RESPONSE;
327 return net::LOAD_STATE_IDLE;
330 net::UploadProgress MockNetworkTransaction::GetUploadProgress() const {
331 return net::UploadProgress();
334 void MockNetworkTransaction::SetQuicServerInfo(
335 net::QuicServerInfo* quic_server_info) {}
337 bool MockNetworkTransaction::GetLoadTimingInfo(
338 net::LoadTimingInfo* load_timing_info) const {
339 if (socket_log_id_ != net::NetLog::Source::kInvalidId) {
340 // The minimal set of times for a request that gets a response, assuming it
341 // gets a new socket.
342 load_timing_info->socket_reused = false;
343 load_timing_info->socket_log_id = socket_log_id_;
344 load_timing_info->connect_timing.connect_start = base::TimeTicks::Now();
345 load_timing_info->connect_timing.connect_end = base::TimeTicks::Now();
346 load_timing_info->send_start = base::TimeTicks::Now();
347 load_timing_info->send_end = base::TimeTicks::Now();
348 } else {
349 // If there's no valid socket ID, just use the generic socket reused values.
350 // No tests currently depend on this, just should not match the values set
351 // by a cache hit.
352 load_timing_info->socket_reused = true;
353 load_timing_info->send_start = base::TimeTicks::Now();
354 load_timing_info->send_end = base::TimeTicks::Now();
356 return true;
359 void MockNetworkTransaction::SetPriority(net::RequestPriority priority) {
360 priority_ = priority;
363 void MockNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
364 net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
365 websocket_handshake_stream_create_helper_ = create_helper;
368 int MockNetworkTransaction::StartInternal(
369 const net::HttpRequestInfo* request,
370 const net::CompletionCallback& callback,
371 const net::BoundNetLog& net_log) {
372 const MockTransaction* t = FindMockTransaction(request->url);
373 if (!t)
374 return net::ERR_FAILED;
376 test_mode_ = t->test_mode;
378 // Return immediately if we're returning an error.
379 if (net::OK != t->return_code) {
380 if (test_mode_ & TEST_MODE_SYNC_NET_START)
381 return t->return_code;
382 CallbackLater(callback, t->return_code);
383 return net::ERR_IO_PENDING;
386 std::string resp_status = t->status;
387 std::string resp_headers = t->response_headers;
388 std::string resp_data = t->data;
389 received_bytes_ = resp_status.size() + resp_headers.size() + resp_data.size();
390 if (t->handler)
391 (t->handler)(request, &resp_status, &resp_headers, &resp_data);
393 std::string header_data = base::StringPrintf(
394 "%s\n%s\n", resp_status.c_str(), resp_headers.c_str());
395 std::replace(header_data.begin(), header_data.end(), '\n', '\0');
397 response_.request_time = base::Time::Now();
398 if (!t->request_time.is_null())
399 response_.request_time = t->request_time;
401 response_.was_cached = false;
402 response_.network_accessed = true;
404 response_.response_time = base::Time::Now();
405 if (!t->response_time.is_null())
406 response_.response_time = t->response_time;
408 response_.headers = new net::HttpResponseHeaders(header_data);
409 response_.vary_data.Init(*request, *response_.headers.get());
410 response_.ssl_info.cert_status = t->cert_status;
411 data_ = resp_data;
413 if (net_log.net_log())
414 socket_log_id_ = net_log.net_log()->NextID();
416 if (test_mode_ & TEST_MODE_SYNC_NET_START)
417 return net::OK;
419 CallbackLater(callback, net::OK);
420 return net::ERR_IO_PENDING;
423 void MockNetworkTransaction::SetBeforeNetworkStartCallback(
424 const BeforeNetworkStartCallback& callback) {
427 void MockNetworkTransaction::SetBeforeProxyHeadersSentCallback(
428 const BeforeProxyHeadersSentCallback& callback) {
431 int MockNetworkTransaction::ResumeNetworkStart() {
432 // Should not get here.
433 return net::ERR_FAILED;
436 void MockNetworkTransaction::CallbackLater(
437 const net::CompletionCallback& callback, int result) {
438 base::MessageLoop::current()->PostTask(
439 FROM_HERE, base::Bind(&MockNetworkTransaction::RunCallback,
440 weak_factory_.GetWeakPtr(), callback, result));
443 void MockNetworkTransaction::RunCallback(
444 const net::CompletionCallback& callback, int result) {
445 callback.Run(result);
448 MockNetworkLayer::MockNetworkLayer()
449 : transaction_count_(0),
450 done_reading_called_(false),
451 stop_caching_called_(false),
452 last_create_transaction_priority_(net::DEFAULT_PRIORITY) {}
454 MockNetworkLayer::~MockNetworkLayer() {}
456 void MockNetworkLayer::TransactionDoneReading() {
457 done_reading_called_ = true;
460 void MockNetworkLayer::TransactionStopCaching() {
461 stop_caching_called_ = true;
464 int MockNetworkLayer::CreateTransaction(
465 net::RequestPriority priority,
466 scoped_ptr<net::HttpTransaction>* trans) {
467 transaction_count_++;
468 last_create_transaction_priority_ = priority;
469 scoped_ptr<MockNetworkTransaction> mock_transaction(
470 new MockNetworkTransaction(priority, this));
471 last_transaction_ = mock_transaction->AsWeakPtr();
472 *trans = mock_transaction.Pass();
473 return net::OK;
476 net::HttpCache* MockNetworkLayer::GetCache() {
477 return NULL;
480 net::HttpNetworkSession* MockNetworkLayer::GetSession() {
481 return NULL;
484 //-----------------------------------------------------------------------------
485 // helpers
487 int ReadTransaction(net::HttpTransaction* trans, std::string* result) {
488 int rv;
490 net::TestCompletionCallback callback;
492 std::string content;
493 do {
494 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
495 rv = trans->Read(buf.get(), 256, callback.callback());
496 if (rv == net::ERR_IO_PENDING)
497 rv = callback.WaitForResult();
499 if (rv > 0)
500 content.append(buf->data(), rv);
501 else if (rv < 0)
502 return rv;
503 } while (rv > 0);
505 result->swap(content);
506 return net::OK;