Schetch changes required to support URLFetcher saving response to a file

chrome/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 "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "chrome/common/net/url_fetcher.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"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 
 // TODO(eroman): Add a regression test for http://crbug.com/40505.
 
 namespace {
 
 const FilePath::CharType kDocRoot[] = FILE_PATH_LITERAL("chrome/test/data");
+const std::string kTestServerFilePrefix = "files/";
 
 class CurriedTask : public Task {
  public:
   CurriedTask(Task* task, MessageLoop* target_loop)
       : task_(task),
         target_loop_(target_loop) {}
 
   virtual void Run() {
     target_loop_->PostTask(FROM_HERE, task_);
   }
@@ skipping 78 matching lines @@
   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(
       io_message_loop_proxy()));
+
+  // Do file ops on the io thead.
   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());
@@ skipping 161 matching lines @@
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const net::URLRequestStatus& status,
                                   int response_code,
                                   const net::ResponseCookies& cookies,
                                   const std::string& data);
  private:
   std::string data_;
 };
 
+class URLFetcherTempFileTest : 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);
+
+  virtual void CreateFetcher(const GURL& url);
+
+ protected:
+  FilePath expected_file_;
+  FilePath temp_file_;
+};
+
+void URLFetcherTempFileTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
+  fetcher_->set_request_context(new TestURLRequestContextGetter(
+      io_message_loop_proxy()));
+
+  // Use the IO message loop to do the file operations in this test.
+  fetcher_->set_file_message_loop_proxy(
+      io_message_loop_proxy());
+
+  fetcher_->set_response_destination(URLFetcher::TEMP_FILE);
+  fetcher_->Start();
+}
+
+TEST_F(URLFetcherTempFileTest, SmallGet) {
+  net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a small file.
+  const char* kFileToFetch = "simple.html";
+  expected_file_ = test_server.document_root().AppendASCII(kFileToFetch);
+  CreateFetcher(test_server.GetURL(kTestServerFilePrefix + kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+
+  ASSERT_TRUE(file_util::PathExists(temp_file_))
+      << temp_file_.value() << " not found.";
+
+  // Deleting the fetcher should remove the file.
+  delete fetcher_;
+
+  MessageLoop::current()->RunAllPending();
+  ASSERT_FALSE(file_util::PathExists(temp_file_))
+      << temp_file_.value() << " not removed.";
+}
+
+TEST_F(URLFetcherTempFileTest, LargeGet) {
+  net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a file large enough to require more than one read into
+  // URLFetcher::Core's IOBuffer.
+  const char* kFileToFetch = "animate1.gif";
+  expected_file_ = test_server.document_root().AppendASCII(kFileToFetch);
+  CreateFetcher(test_server.GetURL(kTestServerFilePrefix + kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+}
+
 // Wrapper that lets us call CreateFetcher() on a thread of our choice.  We
 // could make URLFetcherTest refcounted and use PostTask(FROM_HERE.. ) to call
 // CreateFetcher() directly, but the ownership of the URLFetcherTest is a bit
 // confusing in that case because GTest doesn't know about the refcounting.
 // It's less confusing to just do it this way.
 class FetcherWrapperTask : public Task {
  public:
   FetcherWrapperTask(URLFetcherTest* test, const GURL& url)
       : test_(test), url_(url) { }
   virtual void Run() {
@@ skipping 214 matching lines @@
     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,
+    const GURL& url,
+    const net::URLRequestStatus& status,
+    int response_code,
+    const net::ResponseCookies& cookies) {
+  ASSERT_TRUE(source->GetResponseAsFilePath(&temp_file_));
+
+  ASSERT_TRUE(file_util::PathExists(temp_file_))
+      << temp_file_.value() << " not found.";
+  ASSERT_TRUE(file_util::PathExists(expected_file_))
+      << expected_file_.value() << " not found.";
+  ASSERT_TRUE(file_util::ContentsEqual(expected_file_, temp_file_));
+
+  io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+}
+
 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 146 matching lines @@
 TEST_F(URLFetcherCancelTest, DISABLED_ReleasesContext) {
 #else
 TEST_F(URLFetcherCancelTest, ReleasesContext) {
 #endif
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
-  //     new_backoff = 2.0 * old_backoff + 0
+  //     new_backoff = 2.0 * old_backoff +0
   // The initial backoff is 2 seconds and maximum backoff is 4 seconds.
   // Maximum retries allowed is set to 2.
   net::URLRequestThrottlerManager* manager =
       net::URLRequestThrottlerManager::GetInstance();
   scoped_refptr<net::URLRequestThrottlerEntry> entry(
       new net::URLRequestThrottlerEntry(
           manager, 200, 3, 2000, 2.0, 0.0, 4000));
   manager->OverrideEntryForTests(url, entry);
 
   // Create a separate thread that will create the URLFetcher.  The current
@@ skipping 64 matching lines @@
       FROM_HERE,
       new CurriedTask(new MessageLoop::QuitTask(), MessageLoop::current()));
   MessageLoop::current()->Run();
   EXPECT_EQ(1, GetNumFetcherCores());
   URLFetcher::CancelAll();
   EXPECT_EQ(0, GetNumFetcherCores());
   delete fetcher_;
 }
 
 }  // namespace.