Change SDCHDictionaryFetcher to use URLRequest instead of URLFetcher.

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 27 matching lines @@
 
 class URLFetcherCore
     : public base::RefCountedThreadSafe<URLFetcherCore>,
       public URLRequest::Delegate {
  public:
   URLFetcherCore(URLFetcher* fetcher,
                  const GURL& original_url,
                  URLFetcher::RequestType request_type,
                  URLFetcherDelegate* d);
 
-  // Starts the load.  It's important that this not happen in the constructor
+  // Starts the load. It's important that this not happen in the constructor
   // because it causes the IO thread to begin AddRef()ing and Release()ing
-  // us.  If our caller hasn't had time to fully construct us and take a
+  // us. If our caller hasn't had time to fully construct us and take a
   // reference, the IO thread could interrupt things, run a task, Release()
   // us, and destroy us, leaving the caller with an already-destroyed object
   // when construction finishes.
   void Start();
 
-  // Stops any in-progress load and ensures no callback will happen.  It is
+  // Stops any in-progress load and ensures no callback will happen. It is
   // safe to call this multiple times.
   void Stop();
 
   // URLFetcher-like functions.
 
   // For POST requests, set |content_type| to the MIME type of the
   // content and set |content| to the data to upload.
   void SetUploadData(const std::string& upload_content_type,
                      const std::string& upload_content);
   void SetUploadFilePath(const std::string& upload_content_type,
@@ skipping 37 matching lines @@
       scoped_ptr<URLFetcherResponseWriter> response_writer);
   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;
   // Reports that the received content was malformed (i.e. failed parsing
-  // or validation).  This makes the throttling logic that does exponential
+  // or validation). This makes the throttling logic that does exponential
   // back-off when servers are having problems treat the current request as
-  // a failure.  Your call to this method will be ignored if your request is
+  // a failure. Your call to this method will be ignored if your request is
   // already considered a failure based on the HTTP response code or response
   // headers.
   void ReceivedContentWasMalformed();
   bool GetResponseAsString(std::string* out_response_string) const;
   bool GetResponseAsFilePath(bool take_ownership,
                              base::FilePath* out_response_path);
 
   // Overridden from URLRequest::Delegate:
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
@@ skipping 117 matching lines @@
   std::string upload_content_type_;  // MIME type of POST payload
   std::string referrer_;             // HTTP Referer header value and policy
   URLRequest::ReferrerPolicy referrer_policy_;
   bool is_chunked_upload_;           // True if using chunked transfer encoding
 
   // Used to determine how long to wait before making a request or doing a
   // retry.
   //
   // Both of them can only be accessed on the IO thread.
   //
-  // We need not only the throttler entry for |original_URL|, but also
-  // the one for |url|. For example, consider the case that URL A
-  // redirects to URL B, for which the server returns a 500
-  // response. In this case, the exponential back-off release time of
-  // URL A won't increase. If we retry without considering the
-  // back-off constraint of URL B, we may send out too many requests
-  // for URL A in a short period of time.
+  // To determine the proper backoff timing, throttler entries for
+  // both |original_URL| and |url| are needed. For example, consider
+  // the case that URL A redirects to URL B, for which the server
+  // returns a 500 response. In this case, the exponential back-off
+  // release time of URL A won't increase. If only the backoff
+  // constraints for URL A are considered, too many requests for URL A
+  // may be sent in a short period of time.
   //
   // Both of these will be NULL if
   // URLRequestContext::throttler_manager() is NULL.
   scoped_refptr<URLRequestThrottlerEntryInterface>
       original_url_throttler_entry_;
   scoped_refptr<URLRequestThrottlerEntryInterface> url_throttler_entry_;
 
   // True if the URLFetcher has been cancelled.
   bool was_cancelled_;
 
   // Writer object to write response to the destination like file and string.
   scoped_ptr<URLFetcherResponseWriter> response_writer_;
 
-  // By default any server-initiated redirects are automatically followed.  If
+  // By default any server-initiated redirects are automatically followed. If
   // this flag is set to true, however, a redirect will halt the fetch and call
   // back to to the delegate immediately.
   bool stop_on_redirect_;
-  // True when we're actually stopped due to a redirect halted by the above.  We
+  // True when we're actually stopped due to a redirect halted by the above. We
   // use this to ensure that |url_| is set to the redirect destination rather
   // than the originally-fetched URL.
   bool stopped_on_redirect_;
 
   // If |automatically_retry_on_5xx_| is false, 5xx responses will be
   // propagated to the observer, if it is true URLFetcher will automatically
   // re-execute the request, after the back-off delay has expired.
   // true by default.
   bool automatically_retry_on_5xx_;
   // |num_retries_on_5xx_| indicates how many times we've failed to successfully
-  // fetch this URL due to 5xx responses.  Once this value exceeds the maximum
+  // fetch this URL due to 5xx responses. Once this value exceeds the maximum
   // number of retries specified by the owner URLFetcher instance,
   // we'll give up.
   int num_retries_on_5xx_;
   // Maximum retries allowed when 5xx responses are received.
   int max_retries_on_5xx_;
   // Back-off time delay. 0 by default.
   base::TimeDelta backoff_delay_;
 
   // The number of retries that have been attempted due to ERR_NETWORK_CHANGED.
   int num_retries_on_network_changes_;
@@ skipping 16 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_