Create a content::UrlFetcher interface that lives in content/public/common and convert users to i...

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"
@@ skipping 53 matching lines @@
   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);
 
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::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 15 matching lines @@
   // dispatches its requests to.  When we wish to simulate being used from
   // a UI thread, we dispatch a worker thread to do so.
   MessageLoopForIO io_loop_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 
   URLFetcher* fetcher_;
 };
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
-  fetcher_->set_request_context(new TestURLRequestContextGetter(
+  fetcher_->SetRequestContext(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
   fetcher_->Start();
 }
 
-void URLFetcherTest::OnURLFetchComplete(const URLFetcher* source) {
-  EXPECT_TRUE(source->status().is_success());
-  EXPECT_EQ(200, source->response_code());  // HTTP OK
+void URLFetcherTest::OnURLFetchComplete(const content::URLFetcher* source) {
+  EXPECT_TRUE(source->GetStatus().is_success());
+  EXPECT_EQ(200, source->GetResponseCode());  // 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);
 
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::URLFetcher* source);
 };
 
 // Version of URLFetcherTest that tests headers.
 class URLFetcherHeadersTest : public URLFetcherTest {
  public:
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::URLFetcher* source);
 };
 
 // Version of URLFetcherTest that tests SocketAddress.
 class URLFetcherSocketAddressTest : public URLFetcherTest {
  public:
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::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);
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::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);
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::URLFetcher* source);
  private:
   Time start_time_;
 };
 
 // Version of URLFetcherTest that tests bad HTTPS requests.
 class URLFetcherBadHTTPSTest : public URLFetcherTest {
  public:
   URLFetcherBadHTTPSTest();
 
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::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);
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::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 27 matching lines @@
 
   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:
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::URLFetcher* source);
  private:
   std::string data_;
 };
 
 class URLFetcherTempFileTest : public URLFetcherTest {
  public:
   URLFetcherTempFileTest()
       : take_ownership_of_temp_file_(false) {
   }
 
   // content::URLFetcherDelegate
-  virtual void OnURLFetchComplete(const URLFetcher* source);
+  virtual void OnURLFetchComplete(const content::URLFetcher* source);
 
   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_;
 };
 
 void URLFetcherTempFileTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
-  fetcher_->set_request_context(new TestURLRequestContextGetter(
+  fetcher_->SetRequestContext(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
 
   // Use the IO message loop to do the file operations in this test.
   fetcher_->SaveResponseToTemporaryFile(io_message_loop_proxy());
   fetcher_->Start();
 }
 
 TEST_F(URLFetcherTempFileTest, SmallGet) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
@@ skipping 54 matching lines @@
     test_->CreateFetcher(url_);
   }
 
  private:
   URLFetcherTest* test_;
   GURL url_;
 };
 
 void URLFetcherPostTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::POST, this);
-  fetcher_->set_request_context(new TestURLRequestContextGetter(
+  fetcher_->SetRequestContext(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
-  fetcher_->set_upload_data("application/x-www-form-urlencoded",
-                            "bobsyeruncle");
+  fetcher_->SetUploadData("application/x-www-form-urlencoded",
+                          "bobsyeruncle");
   fetcher_->Start();
 }
 
-void URLFetcherPostTest::OnURLFetchComplete(const URLFetcher* source) {
+void URLFetcherPostTest::OnURLFetchComplete(const content::URLFetcher* source) {
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_EQ(std::string("bobsyeruncle"), data);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
-void URLFetcherHeadersTest::OnURLFetchComplete(const URLFetcher* source) {
+void URLFetcherHeadersTest::OnURLFetchComplete(const content::URLFetcher* source) {
   std::string header;
-  EXPECT_TRUE(source->response_headers()->GetNormalizedHeader("cache-control",
-                                                              &header));
+  EXPECT_TRUE(source->GetResponseHeaders()->GetNormalizedHeader("cache-control",
+                                                                &header));
   EXPECT_EQ("private", header);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
-void URLFetcherSocketAddressTest::OnURLFetchComplete(const URLFetcher* source) {
-  EXPECT_EQ("127.0.0.1", source->socket_address().host());
-  EXPECT_EQ(expected_port_, source->socket_address().port());
+void URLFetcherSocketAddressTest::OnURLFetchComplete(
+    const content::URLFetcher* source) {
+  EXPECT_EQ("127.0.0.1", source->GetSocketAddress().host());
+  EXPECT_EQ(expected_port_, source->GetSocketAddress().port());
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
 void URLFetcherProtectTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
-  fetcher_->set_request_context(new TestURLRequestContextGetter(
+  fetcher_->SetRequestContext(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
   start_time_ = Time::Now();
-  fetcher_->set_max_retries(11);
+  fetcher_->SetMaxRetries(11);
   fetcher_->Start();
 }
 
-void URLFetcherProtectTest::OnURLFetchComplete(const URLFetcher* source) {
+void URLFetcherProtectTest::OnURLFetchComplete(
+    const content::URLFetcher* source) {
   const TimeDelta one_second = TimeDelta::FromMilliseconds(1000);
-  if (source->response_code() >= 500) {
+  if (source->GetResponseCode() >= 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(source->status().is_success());
+    EXPECT_TRUE(source->GetStatus().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);
     }
   }
 }
 
 void URLFetcherProtectTestPassedThrough::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
-  fetcher_->set_request_context(new TestURLRequestContextGetter(
+  fetcher_->SetRequestContext(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
-  fetcher_->set_automatically_retry_on_5xx(false);
+  fetcher_->SetAutomaticallyRetryOn5xx(false);
   start_time_ = Time::Now();
-  fetcher_->set_max_retries(11);
+  fetcher_->SetMaxRetries(11);
   fetcher_->Start();
 }
 
 void URLFetcherProtectTestPassedThrough::OnURLFetchComplete(
-    const URLFetcher* source) {
+    const content::URLFetcher* source) {
   const TimeDelta one_minute = TimeDelta::FromMilliseconds(60000);
-  if (source->response_code() >= 500) {
+  if (source->GetResponseCode() >= 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(source->status().is_success());
+    EXPECT_TRUE(source->GetStatus().is_success());
     // Check that suggested back off time is bigger than 0.
-    EXPECT_GT(fetcher_->backoff_delay().InMicroseconds(), 0);
+    EXPECT_GT(fetcher_->GetBackoffDelay().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) {
+void URLFetcherBadHTTPSTest::OnURLFetchComplete(
+    const content::URLFetcher* source) {
   // This part is different from URLFetcherTest::OnURLFetchComplete
   // because this test expects the request to be cancelled.
-  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());
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, source->GetStatus().status());
+  EXPECT_EQ(net::ERR_ABORTED, source->GetStatus().error());
+  EXPECT_EQ(-1, source->GetResponseCode());
+  EXPECT_TRUE(source->GetCookies().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_->SetRequestContext(context_getter);
+  fetcher_->SetMaxRetries(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) {
+void URLFetcherCancelTest::OnURLFetchComplete(
+    const content::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) {
-  EXPECT_TRUE(source->status().is_success());
-  EXPECT_EQ(200, source->response_code());  // HTTP OK
+    const content::URLFetcher* source) {
+  EXPECT_TRUE(source->GetStatus().is_success());
+  EXPECT_EQ(200, source->GetResponseCode());  // 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.
 
     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.
   }
 }
 
-void URLFetcherTempFileTest::OnURLFetchComplete(const URLFetcher* source) {
-  EXPECT_TRUE(source->status().is_success());
-  EXPECT_EQ(source->response_code(), 200);
+void URLFetcherTempFileTest::OnURLFetchComplete(
+    const content::URLFetcher* source) {
+  EXPECT_TRUE(source->GetStatus().is_success());
+  EXPECT_EQ(source->GetResponseCode(), 200);
 
   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());
 }
@@ skipping 248 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.