Introduced TestURLFetcher::DelegateForTests interface to allow event-driven end-to-end tests of cla…

net/url_request/test_url_fetcher_factory.cc

 // Copyright (c) 2012 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/url_request/test_url_fetcher_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 17 matching lines @@
   DCHECK(URLFetcherImpl::factory());
   URLFetcherImpl::set_factory(NULL);
 }
 
 TestURLFetcher::TestURLFetcher(int id,
                                const GURL& url,
                                URLFetcherDelegate* d)
     : id_(id),
       original_url_(url),
       delegate_(d),
+      delegate_for_tests_(NULL),
       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() {
+  if (delegate_for_tests_)
+    delegate_for_tests_->OnRequestEnd(id_);
 }
 
 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_);
   did_receive_last_chunk_ = is_last_chunk;
   chunks_.push_back(data);
+  if (delegate_for_tests_)
+    delegate_for_tests_->OnChunkUpload(id_);
 }
 
 void TestURLFetcher::SetLoadFlags(int load_flags) {
   fake_load_flags_= load_flags;
 }
 
 int TestURLFetcher::GetLoadFlags() const {
   return fake_load_flags_;
 }
 
@@ skipping 63 matching lines @@
   NOTIMPLEMENTED();
   return 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.
+  if (delegate_for_tests_)
+    delegate_for_tests_->OnRequestStart(id_);
 }
 
 const GURL& TestURLFetcher::GetOriginalURL() const {
   return original_url_;
 }
 
 const GURL& TestURLFetcher::GetURL() const {
   return fake_url_;
 }
 
@@ skipping 46 matching lines @@
 
 void TestURLFetcher::set_response_headers(
     scoped_refptr<HttpResponseHeaders> headers) {
   fake_response_headers_ = headers;
 }
 
 void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) {
   fake_backoff_delay_ = backoff_delay;
 }
 
+void TestURLFetcher::SetDelegateForTests(DelegateForTests* delegate_for_tests) {
+  delegate_for_tests_ = delegate_for_tests;
+}
+
 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)) {
+    : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      delegate_for_tests_(NULL) {
 }
 
 TestURLFetcherFactory::~TestURLFetcherFactory() {}
 
 URLFetcher* TestURLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     URLFetcherDelegate* d) {
   TestURLFetcher* fetcher = new TestURLFetcher(id, url, d);
+  fetcher->SetDelegateForTests(delegate_for_tests_);
   fetchers_[id] = fetcher;
   return fetcher;
 }
 
 TestURLFetcher* TestURLFetcherFactory::GetFetcherByID(int id) const {
   Fetchers::const_iterator i = fetchers_.find(id);
   return i == fetchers_.end() ? NULL : i->second;
 }
 
 void TestURLFetcherFactory::RemoveFetcherFromMap(int id) {
   Fetchers::iterator i = fetchers_.find(id);
   DCHECK(i != fetchers_.end());
   fetchers_.erase(i);
 }
 
+void TestURLFetcherFactory::SetDelegateForTests(
+    TestURLFetcherDelegateForTests* delegate_for_tests) {
+  delegate_for_tests_ = delegate_for_tests;
+}
+
 // This class is used by the FakeURLFetcherFactory below.
 class FakeURLFetcher : public TestURLFetcher {
  public:
   // Normal URL fetcher constructor but also takes in a pre-baked response.
   FakeURLFetcher(const GURL& url,
                  URLFetcherDelegate* d,
                  const std::string& response_data, bool success)
     : TestURLFetcher(0, url, d),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
     set_status(URLRequestStatus(
@@ skipping 79 matching lines @@
 
 URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     URLFetcherDelegate* d) {
   return new URLFetcherImpl(url, request_type, d);
 }
 
 }  // namespace net