URLFetcher uses a TaskRunner instead of a message loop.

net/url_request/url_fetcher_core.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_FETCHER_CORE_H_
 #define NET_URL_REQUEST_URL_FETCHER_CORE_H_
 
 #include <set>
 #include <string>
 
@@ skipping 73 matching lines @@
   void SetURLRequestUserData(
       const void* key,
       const URLFetcher::CreateDataCallback& create_data_callback);
   void SetStopOnRedirect(bool stop_on_redirect);
   void SetAutomaticallyRetryOn5xx(bool retry);
   void SetMaxRetries(int max_retries);
   int GetMaxRetries() const;
   base::TimeDelta GetBackoffDelay() const;
   void SaveResponseToFileAtPath(
       const FilePath& file_path,
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);
+      scoped_refptr<base::TaskRunner> file_task_runner);
   void SaveResponseToTemporaryFile(
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);
+      scoped_refptr<base::TaskRunner> file_task_runner);
   HttpResponseHeaders* GetResponseHeaders() const;
   HostPortPair GetSocketAddress() const;
   bool WasFetchedViaProxy() const;
   const GURL& GetOriginalURL() const;
   const GURL& GetURL() const;
   const URLRequestStatus& GetStatus() const;
   int GetResponseCode() const;
   const ResponseCookies& GetCookies() const;
   bool FileErrorOccurred(base::PlatformFileError* out_error_code) const;
   // Reports that the received content was malformed (i.e. failed parsing
@@ skipping 48 matching lines @@
     std::set<URLFetcherCore*> fetchers_;
 
     DISALLOW_COPY_AND_ASSIGN(Registry);
   };
 
   // Class FileWriter encapsulates all state involved in writing
   // response bytes to a file. It is only used if
   // |URLFetcherCore::response_destination_| == TEMP_FILE ||
   // |URLFetcherCore::response_destination_| == PERMANENT_FILE.  Each
   // instance of FileWriter is owned by a URLFetcherCore, which
-  // manages its lifetime and never transfers ownership.  While
-  // writing to a file, all function calls happen on the IO thread.
+  // manages its lifetime and never transfers ownership. All file operations
+  // happen on |file_task_runner_|.
   class FileWriter {
    public:
     FileWriter(URLFetcherCore* core,
-               scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);
+               scoped_refptr<base::TaskRunner> file_task_runner);
     ~FileWriter();
 
     void CreateFileAtPath(const FilePath& file_path);
     void CreateTempFile();
 
     // Record |num_bytes_| response bytes in |core_->buffer_| to the file.
     void WriteBuffer(int num_bytes);
 
     // Called when a write has been done.  Continues writing if there are
     // any more bytes to write.  Otherwise, initiates a read in core_.
     void ContinueWrite(base::PlatformFileError error_code, int bytes_written);
 
     // Drop ownership of the file at |file_path_|.
     // This class will not delete it or write to it again.
     void DisownFile();
 
     // Close the file if it is open.
     void CloseFileAndCompleteRequest();
 
-    // Remove the file if we have created one.
-    void RemoveFile();
+    // Close the file if it is open and then delete it.
+    void CloseAndDeleteFile();
 
     const FilePath& file_path() const { return file_path_; }
     int64 total_bytes_written() { return total_bytes_written_; }
     base::PlatformFileError error_code() const { return error_code_; }
 
    private:
     // Callback which gets the result of a permanent file creation.
     void DidCreateFile(const FilePath& file_path,
                        base::PlatformFileError error_code,
                        base::PassPlatformFile file_handle,
                        bool created);
     // Callback which gets the result of a temporary file creation.
     void DidCreateTempFile(base::PlatformFileError error_code,
                            base::PassPlatformFile file_handle,
                            const FilePath& file_path);
     // This method is used to implement DidCreateFile and DidCreateTempFile.
     void DidCreateFileInternal(const FilePath& file_path,
                                base::PlatformFileError error_code,
                                base::PassPlatformFile file_handle);
 
     // Callback which gets the result of closing the file.
     void DidCloseFile(base::PlatformFileError error);
 
+    // Callback which gets the result of closing the file. Deletes the file if
+    // it has been created.
+    void DeleteFile(base::PlatformFileError error_code);
+
     // The URLFetcherCore which instantiated this class.
     URLFetcherCore* core_;
 
     // The last error encountered on a file operation.  base::PLATFORM_FILE_OK
     // if no error occurred.
     base::PlatformFileError error_code_;
 
     // Callbacks are created for use with base::FileUtilProxy.
     base::WeakPtrFactory<URLFetcherCore::FileWriter> weak_factory_;
 
-    // Task runner for the thread on which file operations should happen.
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
+    // Task runner on which file operations should happen.
+    scoped_refptr<base::TaskRunner> file_task_runner_;
 
     // Path to the file.  This path is empty when there is no file.
     FilePath file_path_;
 
     // Handle to the file.
     base::PlatformFile file_handle_;
 
     // We always append to the file.  Track the total number of bytes
     // written, so that writes know the offset to give.
     int64 total_bytes_written_;
@@ skipping 57 matching lines @@
 
   URLFetcher* fetcher_;              // Corresponding fetcher object
   GURL original_url_;                // The URL we were asked to fetch
   GURL url_;                         // The URL we eventually wound up at
   URLFetcher::RequestType request_type_;  // What type of request is this?
   URLRequestStatus status_;          // Status of the request
   URLFetcherDelegate* delegate_;     // Object to notify on completion
   scoped_refptr<base::SingleThreadTaskRunner> delegate_task_runner_;
                                      // Task runner for the creating thread.
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
-                                     // Task runner for the thread
-                                     // on which the request IO happens.
-  scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
+                                     // Task runner for file access.
+  scoped_refptr<base::TaskRunner> file_task_runner_;
                                      // Task runner for the thread
                                      // on which file access happens.
   scoped_ptr<URLRequest> request_;   // The actual request this wraps
   int load_flags_;                   // Flags for the load operation
   int response_code_;                // HTTP status code for the request
   std::string data_;                 // Results of the request, when we are
                                      // storing the response as a string.
   scoped_refptr<IOBuffer> buffer_;
                                      // Read buffer
   scoped_refptr<URLRequestContextGetter> request_context_getter_;
@@ skipping 84 matching lines @@
   base::debug::StackTrace stack_trace_;
 
   static base::LazyInstance<Registry> g_registry;
 
   DISALLOW_COPY_AND_ASSIGN(URLFetcherCore);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_FETCHER_CORE_H_