Convert URLFetcher::Delegates to use an interface in content/public/common. Also remove the old U...

content/common/net/url_fetcher_unittest.cc

 // Copyright (c) 2011 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 "content/common/net/url_fetcher.h"
 
 #include "base/bind.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
+#include "content/public/common/url_fetcher_delegate.h"
 #include "crypto/nss_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/test_server.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_NSS)
 #include "net/ocsp/nss_ocsp.h"
@@ skipping 28 matching lines @@
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 
  private:
   virtual ~TestURLRequestContextGetter() {}
 
   scoped_refptr<net::URLRequestContext> context_;
 };
 
 }  // namespace
 
-class URLFetcherTest : public testing::Test, public URLFetcher::Delegate {
+class URLFetcherTest : public testing::Test,
+                       public content::URLFetcherDelegate {
  public:
   URLFetcherTest() : fetcher_(NULL) { }
 
   static int GetNumFetcherCores() {
     return URLFetcher::GetNumFetcherCores();
   }
 
   // Creates a URLFetcher, using the program's main thread to do IO.
   virtual void CreateFetcher(const GURL& url);
 
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy() {
     return io_message_loop_proxy_;
   }
 
  protected:
   virtual void SetUp() {
     testing::Test::SetUp();
 
     io_message_loop_proxy_ = base::MessageLoopProxy::current();
@@ skipping 20 matching lines @@
   URLFetcher* fetcher_;
 };
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
   fetcher_->set_request_context(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
   fetcher_->Start();
 }
 
-void URLFetcherTest::OnURLFetchComplete(const URLFetcher* source,
-                                        const GURL& url,
-                                        const net::URLRequestStatus& status,
-                                        int response_code,
-                                        const net::ResponseCookies& cookies,
-                                        const std::string& data) {
-  EXPECT_TRUE(status.is_success());
-  EXPECT_EQ(200, response_code);  // HTTP OK
+void URLFetcherTest::OnURLFetchComplete(const URLFetcher* source) {
+  EXPECT_TRUE(source->status().is_success());
+  EXPECT_EQ(200, source->response_code());  // HTTP OK
+
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_FALSE(data.empty());
 
   delete fetcher_;  // Have to delete this here and not in the destructor,
                     // because the destructor won't necessarily run on the
                     // same thread that CreateFetcher() did.
 
   io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   // If the current message loop is not the IO loop, it will be shut down when
   // the main loop returns and this thread subsequently goes out of scope.
 }
 
 namespace {
 
 // Version of URLFetcherTest that does a POST instead
 class URLFetcherPostTest : public URLFetcherTest {
  public:
   virtual void CreateFetcher(const GURL& url);
 
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
 };
 
 // Version of URLFetcherTest that tests headers.
 class URLFetcherHeadersTest : public URLFetcherTest {
  public:
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
 };
 
 // Version of URLFetcherTest that tests SocketAddress.
 class URLFetcherSocketAddressTest : public URLFetcherTest {
  public:
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
  protected:
   std::string expected_host_;
   uint16 expected_port_;
 };
 
 // Version of URLFetcherTest that tests overload protection.
 class URLFetcherProtectTest : public URLFetcherTest {
  public:
   virtual void CreateFetcher(const GURL& url);
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
  private:
   Time start_time_;
 };
 
 // Version of URLFetcherTest that tests overload protection, when responses
 // passed through.
 class URLFetcherProtectTestPassedThrough : public URLFetcherTest {
  public:
   virtual void CreateFetcher(const GURL& url);
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
  private:
   Time start_time_;
 };
 
 // Version of URLFetcherTest that tests bad HTTPS requests.
 class URLFetcherBadHTTPSTest : public URLFetcherTest {
  public:
   URLFetcherBadHTTPSTest();
 
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
 
  private:
   FilePath cert_dir_;
 };
 
 // Version of URLFetcherTest that tests request cancellation on shutdown.
 class URLFetcherCancelTest : public URLFetcherTest {
  public:
   virtual void CreateFetcher(const GURL& url);
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
 
   void CancelRequest();
 };
 
 // Version of TestURLRequestContext that posts a Quit task to the IO
 // thread once it is deleted.
 class CancelTestURLRequestContext : public TestURLRequestContext {
   virtual ~CancelTestURLRequestContext() {
     // The d'tor should execute in the IO thread. Post the quit task to the
     // current thread.
@@ skipping 26 matching lines @@
   ~CancelTestURLRequestContextGetter() {}
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
   base::WaitableEvent context_created_;
   scoped_refptr<net::URLRequestContext> context_;
 };
 
 // Version of URLFetcherTest that tests retying the same request twice.
 class URLFetcherMultipleAttemptTest : public URLFetcherTest {
  public:
-  // URLFetcher::Delegate
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
+  // content::URLFetcherDelegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
  private:
   std::string data_;
 };
 
 class URLFetcherTempFileTest : public URLFetcherTest {
  public:
   URLFetcherTempFileTest()
       : take_ownership_of_temp_file_(false) {
   }
 
-  // URLFetcher::Delegate
+  // content::URLFetcherDelegate
   virtual void OnURLFetchComplete(const URLFetcher* source);
 
-  // This obsolete signature should not be used, but must be present
-  // to make clang happy.
-  virtual void OnURLFetchComplete(const URLFetcher* source,
-                                  const GURL& url,
-                                  const net::URLRequestStatus& status,
-                                  int response_code,
-                                  const net::ResponseCookies& cookies,
-                                  const std::string& data);
-
   virtual void CreateFetcher(const GURL& url);
 
  protected:
   FilePath expected_file_;
   FilePath temp_file_;
 
   // Set by the test. Used in OnURLFetchComplete() to decide if
   // the URLFetcher should own the temp file, so that we can test
   // disowning prevents the file from being deleted.
   bool take_ownership_of_temp_file_;
@@ skipping 76 matching lines @@
 
 void URLFetcherPostTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::POST, this);
   fetcher_->set_request_context(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
   fetcher_->set_upload_data("application/x-www-form-urlencoded",
                             "bobsyeruncle");
   fetcher_->Start();
 }
 
-void URLFetcherPostTest::OnURLFetchComplete(const URLFetcher* source,
-                                            const GURL& url,
-                                            const net::URLRequestStatus& status,
-                                            int response_code,
-                                            const net::ResponseCookies& cookies,
-                                            const std::string& data) {
+void URLFetcherPostTest::OnURLFetchComplete(const URLFetcher* source) {
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_EQ(std::string("bobsyeruncle"), data);
-  URLFetcherTest::OnURLFetchComplete(source, url, status, response_code,
-                                     cookies, data);
+  URLFetcherTest::OnURLFetchComplete(source);
 }
 
-void URLFetcherHeadersTest::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
+void URLFetcherHeadersTest::OnURLFetchComplete(const URLFetcher* source) {
   std::string header;
   EXPECT_TRUE(source->response_headers()->GetNormalizedHeader("cache-control",
                                                               &header));
   EXPECT_EQ("private", header);
-  URLFetcherTest::OnURLFetchComplete(source, url, status, response_code,
-                                     cookies, data);
+  URLFetcherTest::OnURLFetchComplete(source);
 }
 
-void URLFetcherSocketAddressTest::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
+void URLFetcherSocketAddressTest::OnURLFetchComplete(const URLFetcher* source) {
   EXPECT_EQ("127.0.0.1", source->socket_address().host());
   EXPECT_EQ(expected_port_, source->socket_address().port());
-  URLFetcherTest::OnURLFetchComplete(source, url, status, response_code,
-                                     cookies, data);
+  URLFetcherTest::OnURLFetchComplete(source);
 }
 
 void URLFetcherProtectTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
   fetcher_->set_request_context(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
   start_time_ = Time::Now();
   fetcher_->set_max_retries(11);
   fetcher_->Start();
 }
 
-void URLFetcherProtectTest::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
+void URLFetcherProtectTest::OnURLFetchComplete(const URLFetcher* source) {
   const TimeDelta one_second = TimeDelta::FromMilliseconds(1000);
-  if (response_code >= 500) {
+  if (source->response_code() >= 500) {
     // Now running ServerUnavailable test.
     // It takes more than 1 second to finish all 11 requests.
     EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
-    EXPECT_TRUE(status.is_success());
+    EXPECT_TRUE(source->status().is_success());
+    std::string data;
+    EXPECT_TRUE(source->GetResponseAsString(&data));
     EXPECT_FALSE(data.empty());
     delete fetcher_;
     io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   } else {
     // Now running Overload test.
     static int count = 0;
     count++;
     if (count < 20) {
       fetcher_->StartWithRequestContextGetter(new TestURLRequestContextGetter(
           io_message_loop_proxy()));
     } else {
       // We have already sent 20 requests continuously. And we expect that
       // it takes more than 1 second due to the overload protection settings.
       EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
-      URLFetcherTest::OnURLFetchComplete(source, url, status, response_code,
-                                         cookies, data);
+      URLFetcherTest::OnURLFetchComplete(source);
     }
   }
 }
 
 void URLFetcherProtectTestPassedThrough::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
   fetcher_->set_request_context(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
   fetcher_->set_automatically_retry_on_5xx(false);
   start_time_ = Time::Now();
   fetcher_->set_max_retries(11);
   fetcher_->Start();
 }
 
 void URLFetcherProtectTestPassedThrough::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
+    const URLFetcher* source) {
   const TimeDelta one_minute = TimeDelta::FromMilliseconds(60000);
-  if (response_code >= 500) {
+  if (source->response_code() >= 500) {
     // Now running ServerUnavailable test.
     // It should get here on the first attempt, so almost immediately and
     // *not* to attempt to execute all 11 requests (2.5 minutes).
     EXPECT_TRUE(Time::Now() - start_time_ < one_minute);
-    EXPECT_TRUE(status.is_success());
+    EXPECT_TRUE(source->status().is_success());
     // Check that suggested back off time is bigger than 0.
     EXPECT_GT(fetcher_->backoff_delay().InMicroseconds(), 0);
+    std::string data;
+    EXPECT_TRUE(source->GetResponseAsString(&data));
     EXPECT_FALSE(data.empty());
   } else {
     // We should not get here!
     ADD_FAILURE();
   }
 
   delete fetcher_;
   io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 
 URLFetcherBadHTTPSTest::URLFetcherBadHTTPSTest() {
   PathService::Get(base::DIR_SOURCE_ROOT, &cert_dir_);
   cert_dir_ = cert_dir_.AppendASCII("chrome");
   cert_dir_ = cert_dir_.AppendASCII("test");
   cert_dir_ = cert_dir_.AppendASCII("data");
   cert_dir_ = cert_dir_.AppendASCII("ssl");
   cert_dir_ = cert_dir_.AppendASCII("certificates");
 }
 
 // The "server certificate expired" error should result in automatic
 // cancellation of the request by
 // net::URLRequest::Delegate::OnSSLCertificateError.
-void URLFetcherBadHTTPSTest::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
+void URLFetcherBadHTTPSTest::OnURLFetchComplete(const URLFetcher* source) {
   // This part is different from URLFetcherTest::OnURLFetchComplete
   // because this test expects the request to be cancelled.
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, status.status());
-  EXPECT_EQ(net::ERR_ABORTED, status.error());
-  EXPECT_EQ(-1, response_code);
-  EXPECT_TRUE(cookies.empty());
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, source->status().status());
+  EXPECT_EQ(net::ERR_ABORTED, source->status().error());
+  EXPECT_EQ(-1, source->response_code());
+  EXPECT_TRUE(source->cookies().empty());
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 
   // The rest is the same as URLFetcherTest::OnURLFetchComplete.
   delete fetcher_;
   io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 void URLFetcherCancelTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
   CancelTestURLRequestContextGetter* context_getter =
       new CancelTestURLRequestContextGetter(io_message_loop_proxy());
   fetcher_->set_request_context(context_getter);
   fetcher_->set_max_retries(2);
   fetcher_->Start();
   // We need to wait for the creation of the net::URLRequestContext, since we
   // rely on it being destroyed as a signal to end the test.
   context_getter->WaitForContextCreation();
   CancelRequest();
 }
 
-void URLFetcherCancelTest::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
+void URLFetcherCancelTest::OnURLFetchComplete(const URLFetcher* source) {
   // We should have cancelled the request before completion.
   ADD_FAILURE();
   delete fetcher_;
   io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 void URLFetcherCancelTest::CancelRequest() {
   delete fetcher_;
   // The URLFetcher's test context will post a Quit task once it is
   // deleted. So if this test simply hangs, it means cancellation
   // did not work.
 }
 
 void URLFetcherMultipleAttemptTest::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
-  EXPECT_TRUE(status.is_success());
-  EXPECT_EQ(200, response_code);  // HTTP OK
+    const URLFetcher* source) {
+  EXPECT_TRUE(source->status().is_success());
+  EXPECT_EQ(200, source->response_code());  // HTTP OK
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_FALSE(data.empty());
   if (!data.empty() && data_.empty()) {
     data_ = data;
     fetcher_->StartWithRequestContextGetter(
         new TestURLRequestContextGetter(io_message_loop_proxy()));
   } else {
     EXPECT_EQ(data, data_);
     delete fetcher_;  // Have to delete this here and not in the destructor,
                       // because the destructor won't necessarily run on the
                       // same thread that CreateFetcher() did.
@@ skipping 11 matching lines @@
   EXPECT_TRUE(source->GetResponseAsFilePath(
       take_ownership_of_temp_file_, &temp_file_));
 
   EXPECT_TRUE(file_util::ContentsEqual(expected_file_, temp_file_));
 
   delete fetcher_;
 
   io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
-void URLFetcherTempFileTest::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
-  NOTREACHED();
-}
-
-
 TEST_F(URLFetcherTest, SameThreadsTest) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   // Create the fetcher on the main thread.  Since IO will happen on the main
   // thread, this will test URLFetcher's ability to do everything on one
   // thread.
   CreateFetcher(test_server.GetURL("defaultresponse"));
 
   MessageLoop::current()->Run();
@@ skipping 237 matching lines @@
       FROM_HERE,
       base::Bind(&CancelAllOnIO),
       base::Bind(&MessageLoop::Quit,
                  base::Unretained(MessageLoop::current())));
   MessageLoop::current()->Run();
   EXPECT_EQ(0, GetNumFetcherCores());
   delete fetcher_;
 }
 
 }  // namespace.