Schetch changes required to support URLFetcher saving response to a file

chrome/common/net/url_fetcher.h

 // 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.
 
 // This file contains URLFetcher, a wrapper around net::URLRequest that handles
 // low-level details like thread safety, ref counting, and incremental buffer
 // reading.  This is useful for callers who simply want to get the data from a
 // URL and don't care about all the nitty-gritty details.
 //
 // NOTE(willchan): Only one "IO" thread is supported for URLFetcher.  This is a
@@ skipping 49 matching lines @@
 // interception is explicitly enabled in tests.
 
 class URLFetcher {
  public:
   enum RequestType {
     GET,
     POST,
     HEAD,
   };
 
+  // Abstract class used to hold the response body. Delegate generates
+  // an implementation of this interface, and gets a pointer to it when
+  // the fetch is complete.
+  class ResponseBodyContainerInterface {
+   public:
+    // Add bytes to the response body.
+    virtual void Append(char* data, int data_length) = 0;
+
+    // If the class supports returning the body as a string, return true
+    // and set |out_body| to the response body. Otherwise, return false.
+    virtual bool GetAsString(std::string* out_body) const = 0;
+  };
+
   class Delegate {
    public:
     // This will be called when the URL has been fetched, successfully or not.
     // |response_code| is the HTTP response code (200, 404, etc.) if
     // applicable.  |url|, |status| and |data| are all valid until the
     // URLFetcher instance is destroyed.
+    virtual void OnURLFetchCompleteNew(
+        const URLFetcher* source,
+        const GURL& url,
+        const net::URLRequestStatus& status,
+        int response_code,
+        const ResponseCookies& cookies,
+        const ResponseBodyContainerInterface& response_body);
+
+    // TODO(skerner): To avoid changing existing code, keep the old
+    // method, whre |data| is a string.  Once we finalize interface changes,
+    // this will be removed.
     virtual void OnURLFetchComplete(const URLFetcher* source,
                                     const GURL& url,
                                     const net::URLRequestStatus& status,
                                     int response_code,
                                     const ResponseCookies& cookies,
                                     const std::string& data) = 0;
 
+    // Get a container into which the response body can be written.
+    // Delegate can control how response is held by the choice of the
+    // concrete type this method returns. For example, to process the
+    // response body as it is received, return a class that does
+    // processing on each call to ResponseBodyContainerInterface::Append().
+    virtual ResponseBodyContainerInterface* CreateResponseBodyContainer();
+
    protected:
     virtual ~Delegate() {}
   };
 
   // URLFetcher::Create uses the currently registered Factory to create the
   // URLFetcher. Factory is intended for testing.
   class Factory {
    public:
     virtual URLFetcher* CreateURLFetcher(int id,
                                          const GURL& url,
@@ skipping 140 matching lines @@
   base::TimeDelta backoff_delay_;
   // Maximum retries allowed.
   int max_retries_;
 
   static bool g_interception_enabled;
 
   DISALLOW_COPY_AND_ASSIGN(URLFetcher);
 };
 
 #endif  // CHROME_COMMON_NET_URL_FETCHER_H_