Better match IE's proxy settings....

net/proxy/proxy_script_fetcher.cc

 // Copyright (c) 2008 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 "net/proxy/proxy_script_fetcher.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
@@ skipping 39 matching lines @@
  public:
   // Creates a ProxyScriptFetcher that issues requests through
   // |url_request_context|. |url_request_context| must remain valid for the
   // lifetime of ProxyScriptFetcherImpl.
   explicit ProxyScriptFetcherImpl(URLRequestContext* url_request_context);
 
   virtual ~ProxyScriptFetcherImpl();
 
   // ProxyScriptFetcher methods:
 
-  virtual void Fetch(const GURL& url, std::string* bytes,
-                     CompletionCallback* callback);
+  virtual int Fetch(const GURL& url, std::string* bytes,
+                    CompletionCallback* callback);
   virtual void Cancel();
 
   // URLRequest::Delegate methods:
 
   virtual void OnAuthRequired(URLRequest* request,
                               AuthChallengeInfo* auth_info);
   virtual void OnSSLCertificateError(URLRequest* request, int cert_error,
                                      X509Certificate* cert);
   virtual void OnResponseStarted(URLRequest* request);
   virtual void OnReadCompleted(URLRequest* request, int num_bytes);
@@ skipping 58 matching lines @@
       result_code_(OK),
       result_bytes_(NULL) {
   DCHECK(url_request_context);
 }
 
 ProxyScriptFetcherImpl::~ProxyScriptFetcherImpl() {
   // The URLRequest's destructor will cancel the outstanding request, and
   // ensure that the delegate (this) is not called again.
 }
 
-void ProxyScriptFetcherImpl::Fetch(const GURL& url,
-                                   std::string* bytes,
-                                   CompletionCallback* callback) {
+int ProxyScriptFetcherImpl::Fetch(const GURL& url,
+                                  std::string* bytes,
+                                  CompletionCallback* callback) {
   // It is invalid to call Fetch() while a request is already in progress.
   DCHECK(!cur_request_.get());
 
   DCHECK(callback);
   DCHECK(bytes);
 
   cur_request_.reset(new URLRequest(url, this));
   cur_request_->set_context(url_request_context_);
   cur_request_->set_method("GET");
 
@@ skipping 11 matching lines @@
 
   // Post a task to timeout this request if it takes too long.
   cur_request_id_ = ++next_id_;
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       task_factory_.NewRunnableMethod(&ProxyScriptFetcherImpl::OnTimeout,
                                       cur_request_id_),
       static_cast<int>(max_duration_ms));
 
   // Start the request.
   cur_request_->Start();
+  return ERR_IO_PENDING;
 }
 
 void ProxyScriptFetcherImpl::Cancel() {
   // ResetCurRequestState will free the URLRequest, which will cause
   // cancellation.
   ResetCurRequestState();
 }
 
 void ProxyScriptFetcherImpl::OnAuthRequired(URLRequest* request,
                                             AuthChallengeInfo* auth_info) {
@@ skipping 134 matching lines @@
 }
 
 // static
 size_t ProxyScriptFetcher::SetSizeConstraintForUnittest(size_t size_bytes) {
   size_t prev = max_response_bytes;
   max_response_bytes = size_bytes;
   return prev;
 }
 
 }  // namespace net