Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(68)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/http/http_transaction_test_util.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/http/http_transaction_test_util.h ('k') | net/http/http_util.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/http/http_transaction_test_util.cc
diff --git a/net/http/http_transaction_test_util.cc b/net/http/http_transaction_test_util.cc
deleted file mode 100644
index f3bbf98df3dd4acc4c260e08ebfd7c78946910ca..0000000000000000000000000000000000000000
--- a/net/http/http_transaction_test_util.cc
+++ /dev/null
@@ -1,529 +0,0 @@
-// Copyright 2014 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 "net/http/http_transaction_test_util.h"
-
-#include <algorithm>
-
-#include "base/bind.h"
-#include "base/message_loop/message_loop.h"
-#include "base/strings/stringprintf.h"
-#include "base/time/clock.h"
-#include "base/time/time.h"
-#include "net/base/load_flags.h"
-#include "net/base/load_timing_info.h"
-#include "net/base/net_errors.h"
-#include "net/disk_cache/disk_cache.h"
-#include "net/http/http_cache.h"
-#include "net/http/http_request_info.h"
-#include "net/http/http_response_info.h"
-#include "net/http/http_transaction.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-typedef base::hash_map<std::string, const MockTransaction*> MockTransactionMap;
-static MockTransactionMap mock_transactions;
-} // namespace
-
-//-----------------------------------------------------------------------------
-// mock transaction data
-
-const MockTransaction kSimpleGET_Transaction = {
- "http://www.google.com/",
- "GET",
- base::Time(),
- "",
- net::LOAD_NORMAL,
- "HTTP/1.1 200 OK",
- "Cache-Control: max-age=10000\n",
- base::Time(),
- "<html><body>Google Blah Blah</body></html>",
- TEST_MODE_NORMAL,
- NULL,
- 0,
- net::OK
-};
-
-const MockTransaction kSimplePOST_Transaction = {
- "http://bugdatabase.com/edit",
- "POST",
- base::Time(),
- "",
- net::LOAD_NORMAL,
- "HTTP/1.1 200 OK",
- "",
- base::Time(),
- "<html><body>Google Blah Blah</body></html>",
- TEST_MODE_NORMAL,
- NULL,
- 0,
- net::OK
-};
-
-const MockTransaction kTypicalGET_Transaction = {
- "http://www.example.com/~foo/bar.html",
- "GET",
- base::Time(),
- "",
- net::LOAD_NORMAL,
- "HTTP/1.1 200 OK",
- "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
- "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n",
- base::Time(),
- "<html><body>Google Blah Blah</body></html>",
- TEST_MODE_NORMAL,
- NULL,
- 0,
- net::OK
-};
-
-const MockTransaction kETagGET_Transaction = {
- "http://www.google.com/foopy",
- "GET",
- base::Time(),
- "",
- net::LOAD_NORMAL,
- "HTTP/1.1 200 OK",
- "Cache-Control: max-age=10000\n"
- "Etag: \"foopy\"\n",
- base::Time(),
- "<html><body>Google Blah Blah</body></html>",
- TEST_MODE_NORMAL,
- NULL,
- 0,
- net::OK
-};
-
-const MockTransaction kRangeGET_Transaction = {
- "http://www.google.com/",
- "GET",
- base::Time(),
- "Range: 0-100\r\n",
- net::LOAD_NORMAL,
- "HTTP/1.1 200 OK",
- "Cache-Control: max-age=10000\n",
- base::Time(),
- "<html><body>Google Blah Blah</body></html>",
- TEST_MODE_NORMAL,
- NULL,
- 0,
- net::OK
-};
-
-static const MockTransaction* const kBuiltinMockTransactions[] = {
- &kSimpleGET_Transaction,
- &kSimplePOST_Transaction,
- &kTypicalGET_Transaction,
- &kETagGET_Transaction,
- &kRangeGET_Transaction
-};
-
-const MockTransaction* FindMockTransaction(const GURL& url) {
- // look for overrides:
- MockTransactionMap::const_iterator it = mock_transactions.find(url.spec());
- if (it != mock_transactions.end())
- return it->second;
-
- // look for builtins:
- for (size_t i = 0; i < arraysize(kBuiltinMockTransactions); ++i) {
- if (url == GURL(kBuiltinMockTransactions[i]->url))
- return kBuiltinMockTransactions[i];
- }
- return NULL;
-}
-
-void AddMockTransaction(const MockTransaction* trans) {
- mock_transactions[GURL(trans->url).spec()] = trans;
-}
-
-void RemoveMockTransaction(const MockTransaction* trans) {
- mock_transactions.erase(GURL(trans->url).spec());
-}
-
-MockHttpRequest::MockHttpRequest(const MockTransaction& t) {
- url = GURL(t.url);
- method = t.method;
- extra_headers.AddHeadersFromString(t.request_headers);
- load_flags = t.load_flags;
-}
-
-//-----------------------------------------------------------------------------
-
-// static
-int TestTransactionConsumer::quit_counter_ = 0;
-
-TestTransactionConsumer::TestTransactionConsumer(
- net::RequestPriority priority,
- net::HttpTransactionFactory* factory)
- : state_(IDLE), error_(net::OK) {
- // Disregard the error code.
- factory->CreateTransaction(priority, &trans_);
- ++quit_counter_;
-}
-
-TestTransactionConsumer::~TestTransactionConsumer() {
-}
-
-void TestTransactionConsumer::Start(const net::HttpRequestInfo* request,
- const net::BoundNetLog& net_log) {
- state_ = STARTING;
- int result = trans_->Start(
- request, base::Bind(&TestTransactionConsumer::OnIOComplete,
- base::Unretained(this)), net_log);
- if (result != net::ERR_IO_PENDING)
- DidStart(result);
-}
-
-void TestTransactionConsumer::DidStart(int result) {
- if (result != net::OK) {
- DidFinish(result);
- } else {
- Read();
- }
-}
-
-void TestTransactionConsumer::DidRead(int result) {
- if (result <= 0) {
- DidFinish(result);
- } else {
- content_.append(read_buf_->data(), result);
- Read();
- }
-}
-
-void TestTransactionConsumer::DidFinish(int result) {
- state_ = DONE;
- error_ = result;
- if (--quit_counter_ == 0)
- base::MessageLoop::current()->Quit();
-}
-
-void TestTransactionConsumer::Read() {
- state_ = READING;
- read_buf_ = new net::IOBuffer(1024);
- int result = trans_->Read(read_buf_.get(),
- 1024,
- base::Bind(&TestTransactionConsumer::OnIOComplete,
- base::Unretained(this)));
- if (result != net::ERR_IO_PENDING)
- DidRead(result);
-}
-
-void TestTransactionConsumer::OnIOComplete(int result) {
- switch (state_) {
- case STARTING:
- DidStart(result);
- break;
- case READING:
- DidRead(result);
- break;
- default:
- NOTREACHED();
- }
-}
-
-MockNetworkTransaction::MockNetworkTransaction(
- net::RequestPriority priority,
- MockNetworkLayer* factory)
- : request_(NULL),
- data_cursor_(0),
- priority_(priority),
- websocket_handshake_stream_create_helper_(NULL),
- transaction_factory_(factory->AsWeakPtr()),
- received_bytes_(0),
- socket_log_id_(net::NetLog::Source::kInvalidId),
- weak_factory_(this) {
-}
-
-MockNetworkTransaction::~MockNetworkTransaction() {}
-
-int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
- const net::CompletionCallback& callback,
- const net::BoundNetLog& net_log) {
- if (request_)
- return net::ERR_FAILED;
-
- request_ = request;
- return StartInternal(request, callback, net_log);
-}
-
-int MockNetworkTransaction::RestartIgnoringLastError(
- const net::CompletionCallback& callback) {
- return net::ERR_FAILED;
-}
-
-int MockNetworkTransaction::RestartWithCertificate(
- net::X509Certificate* client_cert,
- const net::CompletionCallback& callback) {
- return net::ERR_FAILED;
-}
-
-int MockNetworkTransaction::RestartWithAuth(
- const net::AuthCredentials& credentials,
- const net::CompletionCallback& callback) {
- if (!IsReadyToRestartForAuth())
- return net::ERR_FAILED;
-
- net::HttpRequestInfo auth_request_info = *request_;
- auth_request_info.extra_headers.AddHeaderFromString("Authorization: Bar");
-
- // Let the MockTransactionHandler worry about this: the only way for this
- // test to succeed is by using an explicit handler for the transaction so
- // that server behavior can be simulated.
- return StartInternal(&auth_request_info, callback, net::BoundNetLog());
-}
-
-bool MockNetworkTransaction::IsReadyToRestartForAuth() {
- if (!request_)
- return false;
-
- if (!request_->extra_headers.HasHeader("X-Require-Mock-Auth"))
- return false;
-
- // Allow the mock server to decide whether authentication is required or not.
- std::string status_line = response_.headers->GetStatusLine();
- return status_line.find(" 401 ") != std::string::npos ||
- status_line.find(" 407 ") != std::string::npos;
-}
-
-int MockNetworkTransaction::Read(net::IOBuffer* buf, int buf_len,
- const net::CompletionCallback& callback) {
- int data_len = static_cast<int>(data_.size());
- int num = std::min(buf_len, data_len - data_cursor_);
- if (test_mode_ & TEST_MODE_SLOW_READ)
- num = std::min(num, 1);
- if (num) {
- memcpy(buf->data(), data_.data() + data_cursor_, num);
- data_cursor_ += num;
- }
- if (test_mode_ & TEST_MODE_SYNC_NET_READ)
- return num;
-
- CallbackLater(callback, num);
- return net::ERR_IO_PENDING;
-}
-
-void MockNetworkTransaction::StopCaching() {
- if (transaction_factory_.get())
- transaction_factory_->TransactionStopCaching();
-}
-
-bool MockNetworkTransaction::GetFullRequestHeaders(
- net::HttpRequestHeaders* headers) const {
- return false;
-}
-
-int64 MockNetworkTransaction::GetTotalReceivedBytes() const {
- return received_bytes_;
-}
-
-void MockNetworkTransaction::DoneReading() {
- if (transaction_factory_.get())
- transaction_factory_->TransactionDoneReading();
-}
-
-const net::HttpResponseInfo* MockNetworkTransaction::GetResponseInfo() const {
- return &response_;
-}
-
-net::LoadState MockNetworkTransaction::GetLoadState() const {
- if (data_cursor_)
- return net::LOAD_STATE_READING_RESPONSE;
- return net::LOAD_STATE_IDLE;
-}
-
-net::UploadProgress MockNetworkTransaction::GetUploadProgress() const {
- return net::UploadProgress();
-}
-
-void MockNetworkTransaction::SetQuicServerInfo(
- net::QuicServerInfo* quic_server_info) {}
-
-bool MockNetworkTransaction::GetLoadTimingInfo(
- net::LoadTimingInfo* load_timing_info) const {
- if (socket_log_id_ != net::NetLog::Source::kInvalidId) {
- // The minimal set of times for a request that gets a response, assuming it
- // gets a new socket.
- load_timing_info->socket_reused = false;
- load_timing_info->socket_log_id = socket_log_id_;
- load_timing_info->connect_timing.connect_start = base::TimeTicks::Now();
- load_timing_info->connect_timing.connect_end = base::TimeTicks::Now();
- load_timing_info->send_start = base::TimeTicks::Now();
- load_timing_info->send_end = base::TimeTicks::Now();
- } else {
- // If there's no valid socket ID, just use the generic socket reused values.
- // No tests currently depend on this, just should not match the values set
- // by a cache hit.
- load_timing_info->socket_reused = true;
- load_timing_info->send_start = base::TimeTicks::Now();
- load_timing_info->send_end = base::TimeTicks::Now();
- }
- return true;
-}
-
-void MockNetworkTransaction::SetPriority(net::RequestPriority priority) {
- priority_ = priority;
-}
-
-void MockNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
- net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
- websocket_handshake_stream_create_helper_ = create_helper;
-}
-
-int MockNetworkTransaction::StartInternal(
- const net::HttpRequestInfo* request,
- const net::CompletionCallback& callback,
- const net::BoundNetLog& net_log) {
- const MockTransaction* t = FindMockTransaction(request->url);
- if (!t)
- return net::ERR_FAILED;
-
- test_mode_ = t->test_mode;
-
- // Return immediately if we're returning an error.
- if (net::OK != t->return_code) {
- if (test_mode_ & TEST_MODE_SYNC_NET_START)
- return t->return_code;
- CallbackLater(callback, t->return_code);
- return net::ERR_IO_PENDING;
- }
-
- std::string resp_status = t->status;
- std::string resp_headers = t->response_headers;
- std::string resp_data = t->data;
- received_bytes_ = resp_status.size() + resp_headers.size() + resp_data.size();
- if (t->handler)
- (t->handler)(request, &resp_status, &resp_headers, &resp_data);
-
- std::string header_data = base::StringPrintf(
- "%s\n%s\n", resp_status.c_str(), resp_headers.c_str());
- std::replace(header_data.begin(), header_data.end(), '\n', '\0');
-
- response_.request_time = transaction_factory_->Now();
- if (!t->request_time.is_null())
- response_.request_time = t->request_time;
-
- response_.was_cached = false;
- response_.network_accessed = true;
-
- response_.response_time = transaction_factory_->Now();
- if (!t->response_time.is_null())
- response_.response_time = t->response_time;
-
- response_.headers = new net::HttpResponseHeaders(header_data);
- response_.vary_data.Init(*request, *response_.headers.get());
- response_.ssl_info.cert_status = t->cert_status;
- data_ = resp_data;
-
- if (net_log.net_log())
- socket_log_id_ = net_log.net_log()->NextID();
-
- if (request_->load_flags & net::LOAD_PREFETCH)
- response_.unused_since_prefetch = true;
-
- if (test_mode_ & TEST_MODE_SYNC_NET_START)
- return net::OK;
-
- CallbackLater(callback, net::OK);
- return net::ERR_IO_PENDING;
-}
-
-void MockNetworkTransaction::SetBeforeNetworkStartCallback(
- const BeforeNetworkStartCallback& callback) {
-}
-
-void MockNetworkTransaction::SetBeforeProxyHeadersSentCallback(
- const BeforeProxyHeadersSentCallback& callback) {
-}
-
-int MockNetworkTransaction::ResumeNetworkStart() {
- // Should not get here.
- return net::ERR_FAILED;
-}
-
-void MockNetworkTransaction::CallbackLater(
- const net::CompletionCallback& callback, int result) {
- base::MessageLoop::current()->PostTask(
- FROM_HERE, base::Bind(&MockNetworkTransaction::RunCallback,
- weak_factory_.GetWeakPtr(), callback, result));
-}
-
-void MockNetworkTransaction::RunCallback(
- const net::CompletionCallback& callback, int result) {
- callback.Run(result);
-}
-
-MockNetworkLayer::MockNetworkLayer()
- : transaction_count_(0),
- done_reading_called_(false),
- stop_caching_called_(false),
- last_create_transaction_priority_(net::DEFAULT_PRIORITY),
- clock_(nullptr) {
-}
-
-MockNetworkLayer::~MockNetworkLayer() {}
-
-void MockNetworkLayer::TransactionDoneReading() {
- done_reading_called_ = true;
-}
-
-void MockNetworkLayer::TransactionStopCaching() {
- stop_caching_called_ = true;
-}
-
-int MockNetworkLayer::CreateTransaction(
- net::RequestPriority priority,
- scoped_ptr<net::HttpTransaction>* trans) {
- transaction_count_++;
- last_create_transaction_priority_ = priority;
- scoped_ptr<MockNetworkTransaction> mock_transaction(
- new MockNetworkTransaction(priority, this));
- last_transaction_ = mock_transaction->AsWeakPtr();
- *trans = mock_transaction.Pass();
- return net::OK;
-}
-
-net::HttpCache* MockNetworkLayer::GetCache() {
- return NULL;
-}
-
-net::HttpNetworkSession* MockNetworkLayer::GetSession() {
- return NULL;
-}
-
-void MockNetworkLayer::SetClock(base::Clock* clock) {
- DCHECK(!clock_);
- clock_ = clock;
-}
-
-base::Time MockNetworkLayer::Now() {
- if (clock_)
- return clock_->Now();
- return base::Time::Now();
-}
-
-//-----------------------------------------------------------------------------
-// helpers
-
-int ReadTransaction(net::HttpTransaction* trans, std::string* result) {
- int rv;
-
- net::TestCompletionCallback callback;
-
- std::string content;
- do {
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
- rv = trans->Read(buf.get(), 256, callback.callback());
- if (rv == net::ERR_IO_PENDING)
- rv = callback.WaitForResult();
-
- if (rv > 0)
- content.append(buf->data(), rv);
- else if (rv < 0)
- return rv;
- } while (rv > 0);
-
- result->swap(content);
- return net::OK;
-}
« no previous file with comments | « net/http/http_transaction_test_util.h ('k') | net/http/http_util.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698