net: Remove typedef net::URLRequest URLRequest;

net/proxy/proxy_script_fetcher_impl.cc

 // Copyright (c) 2010 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_impl.h"
 
 #include "base/compiler_specific.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 68 matching lines @@
       cur_request_id_(0),
       callback_(NULL),
       result_code_(OK),
       result_text_(NULL),
       max_response_bytes_(kDefaultMaxResponseBytes),
       max_duration_(base::TimeDelta::FromMilliseconds(kDefaultMaxDurationMs)) {
   DCHECK(url_request_context);
 }
 
 ProxyScriptFetcherImpl::~ProxyScriptFetcherImpl() {
-  // The URLRequest's destructor will cancel the outstanding request, and
+  // The net::URLRequest's destructor will cancel the outstanding request, and
   // ensure that the delegate (this) is not called again.
 }
 
 int ProxyScriptFetcherImpl::Fetch(const GURL& url,
                                   string16* text,
                                   CompletionCallback* callback) {
   // It is invalid to call Fetch() while a request is already in progress.
   DCHECK(!cur_request_.get());
 
   DCHECK(callback);
   DCHECK(text);
 
-  cur_request_.reset(new URLRequest(url, this));
+  cur_request_.reset(new net::URLRequest(url, this));
   cur_request_->set_context(url_request_context_);
   cur_request_->set_method("GET");
 
   // Make sure that the PAC script is downloaded using a direct connection,
   // to avoid circular dependencies (fetching is a part of proxy resolution).
   // Also disable the use of the disk cache. The cache is disabled so that if
   // the user switches networks we don't potentially use the cached response
   // from old network when we should in fact be re-fetching on the new network.
   cur_request_->set_load_flags(LOAD_BYPASS_PROXY | LOAD_DISABLE_CACHE);
 
   // Save the caller's info for notification on completion.
   callback_ = callback;
   result_text_ = text;
 
   bytes_read_so_far_.clear();
 
   // 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_.InMilliseconds()));
 
   // Start the request.
   cur_request_->Start();
   return ERR_IO_PENDING;
 }
 
 void ProxyScriptFetcherImpl::Cancel() {
-  // ResetCurRequestState will free the URLRequest, which will cause
+  // ResetCurRequestState will free the net::URLRequest, which will cause
   // cancellation.
   ResetCurRequestState();
 }
 
 URLRequestContext* ProxyScriptFetcherImpl::GetRequestContext() {
   return url_request_context_;
 }
 
-void ProxyScriptFetcherImpl::OnAuthRequired(URLRequest* request,
+void ProxyScriptFetcherImpl::OnAuthRequired(net::URLRequest* request,
                                             AuthChallengeInfo* auth_info) {
   DCHECK_EQ(request, cur_request_.get());
   // TODO(eroman):
   LOG(WARNING) << "Auth required to fetch PAC script, aborting.";
   result_code_ = ERR_NOT_IMPLEMENTED;
   request->CancelAuth();
 }
 
-void ProxyScriptFetcherImpl::OnSSLCertificateError(URLRequest* request,
+void ProxyScriptFetcherImpl::OnSSLCertificateError(net::URLRequest* request,
                                                    int cert_error,
                                                    X509Certificate* cert) {
   DCHECK_EQ(request, cur_request_.get());
   LOG(WARNING) << "SSL certificate error when fetching PAC script, aborting.";
   // Certificate errors are in same space as net errors.
   result_code_ = cert_error;
   request->Cancel();
 }
 
-void ProxyScriptFetcherImpl::OnResponseStarted(URLRequest* request) {
+void ProxyScriptFetcherImpl::OnResponseStarted(net::URLRequest* request) {
   DCHECK_EQ(request, cur_request_.get());
 
   if (!request->status().is_success()) {
     OnResponseCompleted(request);
     return;
   }
 
   // Require HTTP responses to have a success status code.
   if (request->url().SchemeIs("http") || request->url().SchemeIs("https")) {
     // NOTE about status codes: We are like Firefox 3 in this respect.
@@ skipping 13 matching lines @@
     cur_request_->GetMimeType(&mime_type);
     if (!IsPacMimeType(mime_type)) {
       VLOG(1) << "Fetched PAC script does not have a proper mime type: "
               << mime_type;
     }
   }
 
   ReadBody(request);
 }
 
-void ProxyScriptFetcherImpl::OnReadCompleted(URLRequest* request,
+void ProxyScriptFetcherImpl::OnReadCompleted(net::URLRequest* request,
                                              int num_bytes) {
   DCHECK_EQ(request, cur_request_.get());
   if (ConsumeBytesRead(request, num_bytes)) {
     // Keep reading.
     ReadBody(request);
   }
 }
 
-void ProxyScriptFetcherImpl::OnResponseCompleted(URLRequest* request) {
+void ProxyScriptFetcherImpl::OnResponseCompleted(net::URLRequest* request) {
   DCHECK_EQ(request, cur_request_.get());
 
   // Use |result_code_| as the request's error if we have already set it to
   // something specific.
   if (result_code_ == OK && !request->status().is_success())
     result_code_ = request->status().os_error();
 
   FetchCompleted();
 }
 
-void ProxyScriptFetcherImpl::ReadBody(URLRequest* request) {
+void ProxyScriptFetcherImpl::ReadBody(net::URLRequest* request) {
   // Read as many bytes as are available synchronously.
   while (true) {
     int num_bytes;
     if (!request->Read(buf_, kBufSize, &num_bytes)) {
       // Check whether the read failed synchronously.
       if (!request->status().is_io_pending())
         OnResponseCompleted(request);
       return;
     }
     if (!ConsumeBytesRead(request, num_bytes))
       return;
   }
 }
 
-bool ProxyScriptFetcherImpl::ConsumeBytesRead(URLRequest* request,
+bool ProxyScriptFetcherImpl::ConsumeBytesRead(net::URLRequest* request,
                                               int num_bytes) {
   if (num_bytes <= 0) {
     // Error while reading, or EOF.
     OnResponseCompleted(request);
     return false;
   }
 
   // Enforce maximum size bound.
   if (num_bytes + bytes_read_so_far_.size() >
       static_cast<size_t>(max_response_bytes_)) {
@@ skipping 30 matching lines @@
 
 void ProxyScriptFetcherImpl::ResetCurRequestState() {
   cur_request_.reset();
   cur_request_id_ = 0;
   callback_ = NULL;
   result_code_ = OK;
   result_text_ = NULL;
 }
 
 void ProxyScriptFetcherImpl::OnTimeout(int id) {
-  // Timeout tasks may outlive the URLRequest they reference. Make sure it
+  // Timeout tasks may outlive the net::URLRequest they reference. Make sure it
   // is still applicable.
   if (cur_request_id_ != id)
     return;
 
   DCHECK(cur_request_.get());
   result_code_ = ERR_TIMED_OUT;
   cur_request_->Cancel();
 }
 
 base::TimeDelta ProxyScriptFetcherImpl::SetTimeoutConstraint(
     base::TimeDelta timeout) {
   base::TimeDelta prev = max_duration_;
   max_duration_ = timeout;
   return prev;
 }
 
 size_t ProxyScriptFetcherImpl::SetSizeConstraint(size_t size_bytes) {
   size_t prev = max_response_bytes_;
   max_response_bytes_ = size_bytes;
   return prev;
 }
 
 }  // namespace net