Index: content/test/test_url_fetcher_factory.cc |
=================================================================== |
--- content/test/test_url_fetcher_factory.cc (revision 107268) |
+++ content/test/test_url_fetcher_factory.cc (working copy) |
@@ -8,11 +8,14 @@ |
#include "base/compiler_specific.h" |
#include "base/message_loop.h" |
+#include "content/common/net/url_fetcher.h" |
#include "content/public/common/url_fetcher_delegate.h" |
+#include "net/base/host_port_pair.h" |
#include "net/http/http_response_headers.h" |
#include "net/url_request/url_request_status.h" |
-ScopedURLFetcherFactory::ScopedURLFetcherFactory(URLFetcher::Factory* factory) { |
+ScopedURLFetcherFactory::ScopedURLFetcherFactory( |
+ content::URLFetcherFactory* factory) { |
DCHECK(!URLFetcher::factory()); |
URLFetcher::set_factory(factory); |
} |
@@ -26,15 +29,28 @@ |
const GURL& url, |
URLFetcher::RequestType request_type, |
content::URLFetcherDelegate* d) |
wtc
2011/10/27 21:29:16
The |request_type| argument is not used. I am not
jam
2011/10/27 22:34:41
when doing this originally i wasn't sure if it's n
|
- : URLFetcher(url, request_type, d), |
- id_(id), |
+ : id_(id), |
original_url_(url), |
- did_receive_last_chunk_(false) { |
+ delegate_(d), |
+ did_receive_last_chunk_(false), |
+ fake_load_flags_(0), |
+ fake_response_code_(-1), |
+ fake_response_destination_(STRING), |
+ fake_was_fetched_via_proxy_(false), |
+ fake_max_retries_(0) { |
} |
TestURLFetcher::~TestURLFetcher() { |
} |
+void TestURLFetcher::SetUploadData(const std::string& upload_content_type, |
+ const std::string& upload_content) { |
+ upload_data_ = upload_content; |
+} |
+ |
+void TestURLFetcher::SetChunkedUpload(const std::string& upload_content_type) { |
+} |
+ |
void TestURLFetcher::AppendChunkToUpload(const std::string& data, |
bool is_last_chunk) { |
DCHECK(!did_receive_last_chunk_); |
@@ -42,36 +58,104 @@ |
chunks_.push_back(data); |
} |
+void TestURLFetcher::SetLoadFlags(int load_flags) { |
+ fake_load_flags_= load_flags; |
+} |
+ |
+int TestURLFetcher::GetLoadFlags() const { |
+ return fake_load_flags_; |
+} |
+ |
+void TestURLFetcher::SetReferrer(const std::string& referrer) { |
+} |
+ |
+void TestURLFetcher::SetExtraRequestHeaders( |
+ const std::string& extra_request_headers) { |
+ fake_extra_request_headers_.Clear(); |
+ fake_extra_request_headers_.AddHeadersFromString(extra_request_headers); |
+} |
+ |
+void TestURLFetcher::GetExtraRequestHeaders(net::HttpRequestHeaders* headers) { |
+ *headers = fake_extra_request_headers_; |
+} |
+ |
+void TestURLFetcher::SetRequestContext( |
+ net::URLRequestContextGetter* request_context_getter) { |
+} |
+ |
+void TestURLFetcher::SetAutomaticallyRetryOn5xx(bool retry) { |
+} |
+ |
+void TestURLFetcher::SetMaxRetries(int max_retries) { |
+ fake_max_retries_ = max_retries; |
+} |
+ |
+int TestURLFetcher::GetMaxRetries() const { |
+ return fake_max_retries_; |
+} |
+ |
+base::TimeDelta TestURLFetcher::GetBackoffDelay() const { |
+ return fake_backoff_delay_; |
+} |
+ |
+void TestURLFetcher::SaveResponseToTemporaryFile( |
+ scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) { |
+} |
+ |
+net::HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const { |
+ return fake_response_headers_; |
+} |
+ |
+net::HostPortPair TestURLFetcher::GetSocketAddress() const { |
+ NOTIMPLEMENTED(); |
+ return net::HostPortPair(); |
+} |
+ |
+bool TestURLFetcher::WasFetchedViaProxy() const { |
+ return fake_was_fetched_via_proxy_; |
+} |
+ |
+void TestURLFetcher::Start() { |
+ // Overriden to do nothing. It is assumed the caller will notify the delegate. |
+} |
+ |
+void TestURLFetcher::StartWithRequestContextGetter( |
+ net::URLRequestContextGetter* request_context_getter) { |
+ NOTIMPLEMENTED(); |
+} |
+ |
const GURL& TestURLFetcher::GetOriginalUrl() const { |
return original_url_; |
} |
-void TestURLFetcher::set_status(const net::URLRequestStatus& status) { |
- fake_status_ = status; |
+const GURL& TestURLFetcher::GetUrl() const { |
+ return fake_url_; |
} |
-void TestURLFetcher::set_was_fetched_via_proxy(bool flag) { |
- URLFetcher::set_was_fetched_via_proxy(flag); |
+const net::URLRequestStatus& TestURLFetcher::GetStatus() const { |
+ return fake_status_; |
} |
-void TestURLFetcher::set_response_headers( |
- scoped_refptr<net::HttpResponseHeaders> headers) { |
- URLFetcher::set_response_headers(headers); |
+int TestURLFetcher::GetResponseCode() const { |
+ return fake_response_code_; |
} |
-void TestURLFetcher::SetResponseString(const std::string& response) { |
- SetResponseDestinationForTesting(STRING); |
- fake_response_string_ = response; |
+const net::ResponseCookies& TestURLFetcher::GetCookies() const { |
+ return fake_cookies_; |
} |
-void TestURLFetcher::SetResponseFilePath(const FilePath& path) { |
- SetResponseDestinationForTesting(TEMP_FILE); |
- fake_response_file_path_ = path; |
+bool TestURLFetcher::FileErrorOccurred( |
+ base::PlatformFileError* out_error_code) const { |
+ NOTIMPLEMENTED(); |
+ return false; |
} |
+void TestURLFetcher::ReceivedContentWasMalformed() { |
+} |
+ |
bool TestURLFetcher::GetResponseAsString( |
std::string* out_response_string) const { |
- if (GetResponseDestinationForTesting() != STRING) |
+ if (fake_response_destination_ != STRING) |
return false; |
*out_response_string = fake_response_string_; |
@@ -80,23 +164,50 @@ |
bool TestURLFetcher::GetResponseAsFilePath( |
bool take_ownership, FilePath* out_response_path) const { |
- if (GetResponseDestinationForTesting() != TEMP_FILE) |
+ if (fake_response_destination_ != TEMP_FILE) |
return false; |
*out_response_path = fake_response_file_path_; |
return true; |
} |
+void TestURLFetcher::set_status(const net::URLRequestStatus& status) { |
+ fake_status_ = status; |
+} |
+ |
+void TestURLFetcher::set_was_fetched_via_proxy(bool flag) { |
+ fake_was_fetched_via_proxy_ = flag; |
+} |
+ |
+void TestURLFetcher::set_response_headers( |
+ scoped_refptr<net::HttpResponseHeaders> headers) { |
+ fake_response_headers_ = headers; |
+} |
+ |
+void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) { |
+ fake_backoff_delay_ = backoff_delay; |
+} |
+ |
+void TestURLFetcher::SetResponseString(const std::string& response) { |
+ fake_response_destination_ = STRING; |
+ fake_response_string_ = response; |
+} |
+ |
+void TestURLFetcher::SetResponseFilePath(const FilePath& path) { |
+ fake_response_destination_ = TEMP_FILE; |
+ fake_response_file_path_ = path; |
+} |
+ |
TestURLFetcherFactory::TestURLFetcherFactory() |
: ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { |
} |
TestURLFetcherFactory::~TestURLFetcherFactory() {} |
-URLFetcher* TestURLFetcherFactory::CreateURLFetcher( |
+content::URLFetcher* TestURLFetcherFactory::CreateURLFetcher( |
int id, |
const GURL& url, |
- URLFetcher::RequestType request_type, |
+ content::URLFetcher::RequestType request_type, |
content::URLFetcherDelegate* d) { |
TestURLFetcher* fetcher = new TestURLFetcher(id, url, request_type, d); |
fetchers_[id] = fetcher; |
@@ -114,36 +225,20 @@ |
fetchers_.erase(i); |
} |
-const GURL& TestURLFetcher::GetUrl() const { |
- return fake_url_; |
-} |
- |
-const net::URLRequestStatus& TestURLFetcher::GetStatus() const { |
- return fake_status_; |
-} |
- |
-int TestURLFetcher::GetResponseCode() const { |
- return fake_response_code_; |
-} |
- |
-const net::ResponseCookies& TestURLFetcher::GetCookies() const { |
- return fake_cookies_; |
-} |
- |
// This class is used by the FakeURLFetcherFactory below. |
-class FakeURLFetcher : public URLFetcher { |
+class FakeURLFetcher : public TestURLFetcher { |
public: |
// Normal URL fetcher constructor but also takes in a pre-baked response. |
FakeURLFetcher(const GURL& url, RequestType request_type, |
content::URLFetcherDelegate* d, |
const std::string& response_data, bool success) |
- : URLFetcher(url, request_type, d), |
- url_(url), |
- response_data_(response_data), |
- success_(success), |
- status_(success ? net::URLRequestStatus::SUCCESS : |
- net::URLRequestStatus::FAILED, 0), |
+ : TestURLFetcher(0, url, request_type, d), |
ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) { |
+ set_status(net::URLRequestStatus( |
+ success ? net::URLRequestStatus::SUCCESS :net::URLRequestStatus::FAILED, |
wtc
2011/10/27 21:29:16
Add a space before net::URLRequestStatus::FAILED.
jam
2011/10/27 22:34:41
Done.
|
+ 0)); |
+ set_response_code(success ? 200 : 500); |
+ SetResponseString(response_data); |
} |
// Start the request. This will call the given delegate asynchronously |
@@ -154,28 +249,8 @@ |
method_factory_.NewRunnableMethod(&FakeURLFetcher::RunDelegate)); |
} |
- // These methods are overriden so we can use the version of |
- // OnURLFetchComplete that only has a single URLFetcher argument. |
- virtual const net::ResponseCookies& GetCookies() const OVERRIDE { |
- return cookies_; |
- } |
- |
- virtual bool GetResponseAsString( |
- std::string* out_response_string) const OVERRIDE { |
- *out_response_string = response_data_; |
- return true; |
- } |
- |
- virtual int GetResponseCode() const OVERRIDE { |
- return success_ ? 200 : 500; |
- } |
- |
- virtual const net::URLRequestStatus& GetStatus() const OVERRIDE { |
- return status_; |
- } |
- |
virtual const GURL& GetUrl() const OVERRIDE { |
- return url_; |
+ return TestURLFetcher::GetOriginalUrl(); |
} |
private: |
@@ -188,14 +263,6 @@ |
delegate()->OnURLFetchComplete(this); |
} |
- // Pre-baked response data and flag which indicates whether the request should |
- // be successful or not. |
- GURL url_; |
- std::string response_data_; |
- bool success_; |
- net::URLRequestStatus status_; |
- net::ResponseCookies cookies_; |
- |
// Method factory used to run the delegate. |
ScopedRunnableMethodFactory<FakeURLFetcher> method_factory_; |
@@ -207,17 +274,17 @@ |
} |
FakeURLFetcherFactory::FakeURLFetcherFactory( |
- URLFetcher::Factory* default_factory) |
+ content::URLFetcherFactory* default_factory) |
: ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)), |
default_factory_(default_factory) { |
} |
FakeURLFetcherFactory::~FakeURLFetcherFactory() {} |
-URLFetcher* FakeURLFetcherFactory::CreateURLFetcher( |
+content::URLFetcher* FakeURLFetcherFactory::CreateURLFetcher( |
int id, |
const GURL& url, |
- URLFetcher::RequestType request_type, |
+ content::URLFetcher::RequestType request_type, |
content::URLFetcherDelegate* d) { |
FakeResponseMap::const_iterator it = fake_responses_.find(url); |
if (it == fake_responses_.end()) { |
@@ -248,10 +315,10 @@ |
URLFetcherFactory::~URLFetcherFactory() {} |
-URLFetcher* URLFetcherFactory::CreateURLFetcher( |
+content::URLFetcher* URLFetcherFactory::CreateURLFetcher( |
int id, |
const GURL& url, |
- URLFetcher::RequestType request_type, |
+ content::URLFetcher::RequestType request_type, |
content::URLFetcherDelegate* d) { |
return new URLFetcher(url, request_type, d); |
} |