net: Remove typedef net::URLRequest URLRequest;

net/url_request/url_request_unittest.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 #pragma once
 
 #include <stdlib.h>
 
@@ skipping 161 matching lines @@
         net::HttpCache::DefaultBackend::InMemory(0));
     // In-memory cookie store.
     cookie_store_ = new net::CookieMonster(NULL, NULL);
     accept_language_ = "en-us,fr";
     accept_charset_ = "iso-8859-1,*,utf-8";
   }
 };
 
 //-----------------------------------------------------------------------------
 
-class TestURLRequest : public URLRequest {
+class TestURLRequest : public net::URLRequest {
  public:
   TestURLRequest(const GURL& url, Delegate* delegate)
-      : URLRequest(url, delegate) {
+      : net::URLRequest(url, delegate) {
     set_context(new TestURLRequestContext());
   }
 };
 
 //-----------------------------------------------------------------------------
 
-class TestDelegate : public URLRequest::Delegate {
+class TestDelegate : public net::URLRequest::Delegate {
  public:
   TestDelegate()
       : cancel_in_rr_(false),
         cancel_in_rs_(false),
         cancel_in_rd_(false),
         cancel_in_rd_pending_(false),
         cancel_in_getcookiesblocked_(false),
         cancel_in_setcookieblocked_(false),
         quit_on_complete_(true),
         quit_on_redirect_(false),
         allow_certificate_errors_(false),
         response_started_count_(0),
         received_bytes_count_(0),
         received_redirect_count_(0),
         blocked_get_cookies_count_(0),
         blocked_set_cookie_count_(0),
         set_cookie_count_(0),
         received_data_before_response_(false),
         request_failed_(false),
         have_certificate_errors_(false),
         buf_(new net::IOBuffer(kBufferSize)) {
   }
 
-  virtual void OnReceivedRedirect(URLRequest* request, const GURL& new_url,
+  virtual void OnReceivedRedirect(net::URLRequest* request, const GURL& new_url,
                                   bool* defer_redirect) {
     received_redirect_count_++;
     if (quit_on_redirect_) {
       *defer_redirect = true;
       MessageLoop::current()->Quit();
     } else if (cancel_in_rr_) {
       request->Cancel();
     }
   }
 
-  virtual void OnResponseStarted(URLRequest* request) {
+  virtual void OnResponseStarted(net::URLRequest* request) {
     // It doesn't make sense for the request to have IO pending at this point.
     DCHECK(!request->status().is_io_pending());
 
     response_started_count_++;
     if (cancel_in_rs_) {
       request->Cancel();
       OnResponseCompleted(request);
     } else if (!request->status().is_success()) {
       DCHECK(request->status().status() == URLRequestStatus::FAILED ||
              request->status().status() == URLRequestStatus::CANCELED);
       request_failed_ = true;
       OnResponseCompleted(request);
     } else {
       // Initiate the first read.
       int bytes_read = 0;
       if (request->Read(buf_, kBufferSize, &bytes_read))
         OnReadCompleted(request, bytes_read);
       else if (!request->status().is_io_pending())
         OnResponseCompleted(request);
     }
   }
 
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read) {
+  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {
     // It doesn't make sense for the request to have IO pending at this point.
     DCHECK(!request->status().is_io_pending());
 
     if (response_started_count_ == 0)
       received_data_before_response_ = true;
 
     if (cancel_in_rd_)
       request->Cancel();
 
     if (bytes_read >= 0) {
@@ skipping 15 matching lines @@
           break;
         }
       }
     }
     if (!request->status().is_io_pending())
       OnResponseCompleted(request);
     else if (cancel_in_rd_pending_)
       request->Cancel();
   }
 
-  virtual void OnResponseCompleted(URLRequest* request) {
+  virtual void OnResponseCompleted(net::URLRequest* request) {
     if (quit_on_complete_)
       MessageLoop::current()->Quit();
   }
 
-  void OnAuthRequired(URLRequest* request, net::AuthChallengeInfo* auth_info) {
+  void OnAuthRequired(net::URLRequest* request,
+                      net::AuthChallengeInfo* auth_info) {
     if (!username_.empty() || !password_.empty()) {
       request->SetAuth(username_, password_);
     } else {
       request->CancelAuth();
     }
   }
 
-  virtual void OnSSLCertificateError(URLRequest* request,
+  virtual void OnSSLCertificateError(net::URLRequest* request,
                                      int cert_error,
                                      net::X509Certificate* cert) {
     // The caller can control whether it needs all SSL requests to go through,
     // independent of any possible errors, or whether it wants SSL errors to
     // cancel the request.
     have_certificate_errors_ = true;
     if (allow_certificate_errors_)
       request->ContinueDespiteLastError();
     else
       request->Cancel();
   }
 
-  virtual void OnGetCookies(URLRequest* request, bool blocked_by_policy) {
+  virtual void OnGetCookies(net::URLRequest* request, bool blocked_by_policy) {
     if (blocked_by_policy) {
       blocked_get_cookies_count_++;
       if (cancel_in_getcookiesblocked_)
         request->Cancel();
     }
   }
 
-  virtual void OnSetCookie(URLRequest* request,
+  virtual void OnSetCookie(net::URLRequest* request,
                            const std::string& cookie_line,
                            const net::CookieOptions& options,
                            bool blocked_by_policy) {
     if (blocked_by_policy) {
       blocked_set_cookie_count_++;
       if (cancel_in_setcookieblocked_)
         request->Cancel();
     } else {
       set_cookie_count_++;
     }
@@ skipping 59 matching lines @@
   bool received_data_before_response_;
   bool request_failed_;
   bool have_certificate_errors_;
   std::string data_received_;
 
   // our read buffer
   scoped_refptr<net::IOBuffer> buf_;
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_