net: Remove typedef net::URLRequest URLRequest;

net/url_request/url_request_unittest.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/url_request/url_request_unittest.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <shlobj.h>
@@ skipping 101 matching lines @@
       ssl_info.connection_status);
   EXPECT_NE(0, cipher_suite);
 }
 
 }  // namespace
 
 // Inherit PlatformTest since we require the autorelease pool on Mac OS X.f
 class URLRequestTest : public PlatformTest {
  public:
   static void SetUpTestCase() {
-    URLRequest::AllowFileAccess();
+    net::URLRequest::AllowFileAccess();
   }
 };
 
 class URLRequestTestHTTP : public URLRequestTest {
  public:
   URLRequestTestHTTP()
       : test_server_(net::TestServer::TYPE_HTTP,
                      FilePath(FILE_PATH_LITERAL(
                                   "net/data/url_request_unittest"))) {
   }
@@ skipping 14 matching lines @@
         if (++marker > 'z')
           marker = 'a';
       }
     }
     uploadBytes[kMsgSize] = '\0';
 
     scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
 
     for (int i = 0; i < kIterations; ++i) {
       TestDelegate d;
-      URLRequest r(test_server_.GetURL("echo"), &d);
+      net::URLRequest r(test_server_.GetURL("echo"), &d);
       r.set_context(context);
       r.set_method(method.c_str());
 
       r.AppendBytesToUpload(uploadBytes, kMsgSize);
 
       r.Start();
       EXPECT_TRUE(r.is_pending());
 
       MessageLoop::current()->Run();
 
@@ skipping 13 matching lines @@
 
 // In this unit test, we're using the HTTPTestServer as a proxy server and
 // issuing a CONNECT request with the magic host name "www.redirect.com".
 // The HTTPTestServer will return a 302 response, which we should not
 // follow.
 TEST_F(URLRequestTestHTTP, ProxyTunnelRedirectTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(GURL("https://www.redirect.com/"), &d);
+    net::URLRequest r(GURL("https://www.redirect.com/"), &d);
     r.set_context(
         new TestURLRequestContext(test_server_.host_port_pair().ToString()));
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
     EXPECT_EQ(net::ERR_TUNNEL_CONNECTION_FAILED, r.status().os_error());
     EXPECT_EQ(1, d.response_started_count());
     // We should not have followed the redirect.
     EXPECT_EQ(0, d.received_redirect_count());
   }
 }
 
 // In this unit test, we're using the HTTPTestServer as a proxy server and
 // issuing a CONNECT request with the magic host name "www.server-auth.com".
 // The HTTPTestServer will return a 401 response, which we should balk at.
 TEST_F(URLRequestTestHTTP, UnexpectedServerAuthTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(GURL("https://www.server-auth.com/"), &d);
+    net::URLRequest r(GURL("https://www.server-auth.com/"), &d);
     r.set_context(
         new TestURLRequestContext(test_server_.host_port_pair().ToString()));
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
     EXPECT_EQ(net::ERR_TUNNEL_CONNECTION_FAILED, r.status().os_error());
@@ skipping 152 matching lines @@
   }
 }
 
 namespace {
 
 class SSLClientAuthTestDelegate : public TestDelegate {
  public:
   SSLClientAuthTestDelegate() : on_certificate_requested_count_(0) {
   }
   virtual void OnCertificateRequested(
-      URLRequest* request,
+      net::URLRequest* request,
       net::SSLCertRequestInfo* cert_request_info) {
     on_certificate_requested_count_++;
     MessageLoop::current()->Quit();
   }
   int on_certificate_requested_count() {
     return on_certificate_requested_count_;
   }
  private:
   int on_certificate_requested_count_;
 };
@@ skipping 129 matching lines @@
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest5) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
 
   // populate cache
   {
     TestDelegate d;
-    URLRequest r(test_server_.GetURL("cachetime"), &d);
+    net::URLRequest r(test_server_.GetURL("cachetime"), &d);
     r.set_context(context);
     r.Start();
     MessageLoop::current()->Run();
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
   }
 
   // cancel read from cache (see bug 990242)
   {
     TestDelegate d;
-    URLRequest r(test_server_.GetURL("cachetime"), &d);
+    net::URLRequest r(test_server_.GetURL("cachetime"), &d);
     r.set_context(context);
     r.Start();
     r.Cancel();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
   }
@@ skipping 576 matching lines @@
 }
 
 TEST_F(URLRequestTestHTTP, VaryHeader) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
 
   // populate the cache
   {
     TestDelegate d;
-    URLRequest req(test_server_.GetURL("echoheader?foo"), &d);
+    net::URLRequest req(test_server_.GetURL("echoheader?foo"), &d);
     req.set_context(context);
     net::HttpRequestHeaders headers;
     headers.SetHeader("foo", "1");
     req.SetExtraRequestHeaders(headers);
     req.Start();
     MessageLoop::current()->Run();
   }
 
   // expect a cache hit
   {
     TestDelegate d;
-    URLRequest req(test_server_.GetURL("echoheader?foo"), &d);
+    net::URLRequest req(test_server_.GetURL("echoheader?foo"), &d);
     req.set_context(context);
     net::HttpRequestHeaders headers;
     headers.SetHeader("foo", "1");
     req.SetExtraRequestHeaders(headers);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(req.was_cached());
   }
 
   // expect a cache miss
   {
     TestDelegate d;
-    URLRequest req(test_server_.GetURL("echoheader?foo"), &d);
+    net::URLRequest req(test_server_.GetURL("echoheader?foo"), &d);
     req.set_context(context);
     net::HttpRequestHeaders headers;
     headers.SetHeader("foo", "2");
     req.SetExtraRequestHeaders(headers);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_FALSE(req.was_cached());
   }
 }
 
 TEST_F(URLRequestTestHTTP, BasicAuth) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
 
   // populate the cache
   {
     TestDelegate d;
     d.set_username(kUser);
     d.set_password(kSecret);
 
-    URLRequest r(test_server_.GetURL("auth-basic"), &d);
+    net::URLRequest r(test_server_.GetURL("auth-basic"), &d);
     r.set_context(context);
     r.Start();
 
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
   }
 
   // repeat request with end-to-end validation.  since auth-basic results in a
   // cachable page, we expect this test to result in a 304.  in which case, the
   // response should be fetched from the cache.
   {
     TestDelegate d;
     d.set_username(kUser);
     d.set_password(kSecret);
 
-    URLRequest r(test_server_.GetURL("auth-basic"), &d);
+    net::URLRequest r(test_server_.GetURL("auth-basic"), &d);
     r.set_context(context);
     r.set_load_flags(net::LOAD_VALIDATE_CACHE);
     r.Start();
 
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Should be the same cached document.
     EXPECT_TRUE(r.was_cached());
   }
 }
 
 // Check that Set-Cookie headers in 401 responses are respected.
 // http://crbug.com/6450
 TEST_F(URLRequestTestHTTP, BasicAuthWithCookies) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL url_requiring_auth =
       test_server_.GetURL("auth-basic?set-cookie-if-challenged");
 
   // Request a page that will give a 401 containing a Set-Cookie header.
   // Verify that when the transaction is restarted, it includes the new cookie.
   {
     scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
     TestDelegate d;
     d.set_username(kUser);
     d.set_password(kSecret);
 
-    URLRequest r(url_requiring_auth, &d);
+    net::URLRequest r(url_requiring_auth, &d);
     r.set_context(context);
     r.Start();
 
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Make sure we sent the cookie in the restarted transaction.
     EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
         != std::string::npos);
   }
 
   // Same test as above, except this time the restart is initiated earlier
   // (without user intervention since identity is embedded in the URL).
   {
     scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
     TestDelegate d;
 
     GURL::Replacements replacements;
     std::string username("user2");
     std::string password("secret");
     replacements.SetUsernameStr(username);
     replacements.SetPasswordStr(password);
     GURL url_with_identity = url_requiring_auth.ReplaceComponents(replacements);
 
-    URLRequest r(url_with_identity, &d);
+    net::URLRequest r(url_with_identity, &d);
     r.set_context(context);
     r.Start();
 
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(d.data_received().find("user2/secret") != std::string::npos);
 
     // Make sure we sent the cookie in the restarted transaction.
     EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
         != std::string::npos);
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
 
   // Set up a cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is set.
   {
     TestDelegate d;
@@ skipping 28 matching lines @@
 
 TEST_F(URLRequestTest, DoNotSaveCookies) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
 
   // Set up a cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
-                   &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
+                        &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
     EXPECT_EQ(1, d.set_cookie_count());
   }
 
   // Try to set-up another cookie and update the previous cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL(
+    net::URLRequest req(test_server.GetURL(
         "set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"), &d);
     req.set_load_flags(net::LOAD_DO_NOT_SAVE_COOKIES);
     req.set_context(context);
     req.Start();
 
     MessageLoop::current()->Run();
 
     // LOAD_DO_NOT_SAVE_COOKIES does not trigger OnSetCookie.
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
@@ skipping 21 matching lines @@
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   // Set up a cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is set.
   {
@@ skipping 33 matching lines @@
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   // Set up a cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
-                   &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
+                        &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   // Try to set-up another cookie and update the previous cookie.
   {
     TestCookiePolicy cookie_policy(TestCookiePolicy::NO_SET_COOKIE);
     context->set_cookie_policy(&cookie_policy);
 
     TestDelegate d;
-    URLRequest req(test_server.GetURL(
+    net::URLRequest req(test_server.GetURL(
         "set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"), &d);
     req.set_context(context);
     req.Start();
 
     MessageLoop::current()->Run();
 
     context->set_cookie_policy(NULL);
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(2, d.blocked_set_cookie_count());
@@ skipping 20 matching lines @@
 
 TEST_F(URLRequestTest, DoNotSaveEmptyCookies) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   // Set up an empty cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie"), &d);
+    net::URLRequest req(test_server.GetURL("set-cookie"), &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
     EXPECT_EQ(0, d.set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy_Async) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   // Set up a cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is set.
   {
@@ skipping 34 matching lines @@
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   // Set up a cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
-                   &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),
+                        &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   // Try to set-up another cookie and update the previous cookie.
   {
     TestCookiePolicy cookie_policy(TestCookiePolicy::NO_SET_COOKIE |
                                    TestCookiePolicy::ASYNC);
     context->set_cookie_policy(&cookie_policy);
 
     TestDelegate d;
-    URLRequest req(test_server.GetURL(
+    net::URLRequest req(test_server.GetURL(
         "set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"), &d);
     req.set_context(context);
     req.Start();
 
     MessageLoop::current()->Run();
 
     context->set_cookie_policy(NULL);
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(2, d.blocked_set_cookie_count());
@@ skipping 22 matching lines @@
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   TestCookiePolicy cookie_policy(TestCookiePolicy::ASYNC);
   context->set_cookie_policy(&cookie_policy);
 
   // Set up a cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL("set-cookie?A=1&B=2&C=3"),
-                   &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?A=1&B=2&C=3"),
+                        &d);
     req.set_context(context);
     req.Start();  // Triggers an asynchronous cookie policy check.
 
     // But, now we cancel the request by letting it go out of scope.  This
     // should not cause a crash.
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   context->set_cookie_policy(NULL);
 
   // Let the cookie policy complete.  Make sure it handles the destruction of
-  // the URLRequest properly.
+  // the net::URLRequest properly.
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(URLRequestTest, CancelTest_During_OnGetCookies) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   TestCookiePolicy cookie_policy(TestCookiePolicy::NO_GET_COOKIES);
   context->set_cookie_policy(&cookie_policy);
 
   // Set up a cookie.
   {
     TestDelegate d;
     d.set_cancel_in_get_cookies_blocked(true);
-    URLRequest req(test_server.GetURL("set-cookie?A=1&B=2&C=3"),
-                   &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?A=1&B=2&C=3"),
+                        &d);
     req.set_context(context);
     req.Start();  // Triggers an asynchronous cookie policy check.
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
 
     EXPECT_EQ(1, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   context->set_cookie_policy(NULL);
 }
 
 TEST_F(URLRequestTest, CancelTest_During_OnSetCookie) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   TestCookiePolicy cookie_policy(TestCookiePolicy::NO_SET_COOKIE);
   context->set_cookie_policy(&cookie_policy);
 
   // Set up a cookie.
   {
     TestDelegate d;
     d.set_cancel_in_set_cookie_blocked(true);
-    URLRequest req(test_server.GetURL("set-cookie?A=1&B=2&C=3"),
-                   &d);
+    net::URLRequest req(test_server.GetURL("set-cookie?A=1&B=2&C=3"),
+                        &d);
     req.set_context(context);
     req.Start();  // Triggers an asynchronous cookie policy check.
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
 
     // Even though the response will contain 3 set-cookie headers, we expect
     // only one to be blocked as that first one will cause OnSetCookie to be
     // called, which will cancel the request.  Once canceled, it should not
@@ skipping 11 matching lines @@
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext());
 
   TestCookiePolicy cookie_policy(TestCookiePolicy::FORCE_SESSION);
   context->set_cookie_policy(&cookie_policy);
 
   // Set up a cookie.
   {
     TestDelegate d;
-    URLRequest req(test_server.GetURL(
+    net::URLRequest req(test_server.GetURL(
         "set-cookie?A=1;expires=\"Fri, 05 Feb 2010 23:42:01 GMT\""), &d);
     req.set_context(context);
     req.Start();  // Triggers an asynchronous cookie policy check.
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
@@ skipping 68 matching lines @@
   req.SetExtraRequestHeaders(headers);
   req.Start();
   MessageLoop::current()->Run();
   EXPECT_EQ("POST", req.method());
   EXPECT_EQ(kData, d.data_received());
 }
 
 // Custom URLRequestJobs for use with interceptor tests
 class RestartTestJob : public URLRequestTestJob {
  public:
-  explicit RestartTestJob(URLRequest* request)
+  explicit RestartTestJob(net::URLRequest* request)
     : URLRequestTestJob(request, true) {}
  protected:
   virtual void StartAsync() {
     this->NotifyRestartRequired();
   }
  private:
   ~RestartTestJob() {}
 };
 
 class CancelTestJob : public URLRequestTestJob {
  public:
-  explicit CancelTestJob(URLRequest* request)
+  explicit CancelTestJob(net::URLRequest* request)
     : URLRequestTestJob(request, true) {}
  protected:
   virtual void StartAsync() {
     request_->Cancel();
   }
  private:
   ~CancelTestJob() {}
 };
 
 class CancelThenRestartTestJob : public URLRequestTestJob {
  public:
-  explicit CancelThenRestartTestJob(URLRequest* request)
+  explicit CancelThenRestartTestJob(net::URLRequest* request)
       : URLRequestTestJob(request, true) {
   }
  protected:
   virtual void StartAsync() {
     request_->Cancel();
     this->NotifyRestartRequired();
   }
  private:
   ~CancelThenRestartTestJob() {}
 };
 
 // An Interceptor for use with interceptor tests
-class TestInterceptor : URLRequest::Interceptor {
+class TestInterceptor : net::URLRequest::Interceptor {
  public:
   TestInterceptor()
       : intercept_main_request_(false), restart_main_request_(false),
         cancel_main_request_(false), cancel_then_restart_main_request_(false),
         simulate_main_network_error_(false),
         intercept_redirect_(false), cancel_redirect_request_(false),
         intercept_final_response_(false), cancel_final_request_(false),
         did_intercept_main_(false), did_restart_main_(false),
         did_cancel_main_(false), did_cancel_then_restart_main_(false),
         did_simulate_error_main_(false),
         did_intercept_redirect_(false), did_cancel_redirect_(false),
         did_intercept_final_(false), did_cancel_final_(false) {
-    URLRequest::RegisterRequestInterceptor(this);
+    net::URLRequest::RegisterRequestInterceptor(this);
   }
 
   ~TestInterceptor() {
-    URLRequest::UnregisterRequestInterceptor(this);
+    net::URLRequest::UnregisterRequestInterceptor(this);
   }
 
-  virtual URLRequestJob* MaybeIntercept(URLRequest* request) {
+  virtual URLRequestJob* MaybeIntercept(net::URLRequest* request) {
     if (restart_main_request_) {
       restart_main_request_ = false;
       did_restart_main_ = true;
       return new RestartTestJob(request);
     }
     if (cancel_main_request_) {
       cancel_main_request_ = false;
       did_cancel_main_ = true;
       return new CancelTestJob(request);
     }
@@ skipping 11 matching lines @@
     if (!intercept_main_request_)
       return NULL;
     intercept_main_request_ = false;
     did_intercept_main_ = true;
     return new URLRequestTestJob(request,
                                  main_headers_,
                                  main_data_,
                                  true);
   }
 
-  virtual URLRequestJob* MaybeInterceptRedirect(URLRequest* request,
+  virtual URLRequestJob* MaybeInterceptRedirect(net::URLRequest* request,
                                                 const GURL& location) {
     if (cancel_redirect_request_) {
       cancel_redirect_request_ = false;
       did_cancel_redirect_ = true;
       return new CancelTestJob(request);
     }
     if (!intercept_redirect_)
       return NULL;
     intercept_redirect_ = false;
     did_intercept_redirect_ = true;
     return new URLRequestTestJob(request,
                                  redirect_headers_,
                                  redirect_data_,
                                  true);
   }
 
-  virtual URLRequestJob* MaybeInterceptResponse(URLRequest* request) {
+  virtual URLRequestJob* MaybeInterceptResponse(net::URLRequest* request) {
     if (cancel_final_request_) {
       cancel_final_request_ = false;
       did_cancel_final_ = true;
       return new CancelTestJob(request);
     }
     if (!intercept_final_response_)
       return NULL;
     intercept_final_response_ = false;
     did_intercept_final_ = true;
     return new URLRequestTestJob(request,
@@ skipping 70 matching lines @@
 TEST_F(URLRequestTest, Intercept) {
   TestInterceptor interceptor;
 
   // intercept the main request and respond with a simple response
   interceptor.intercept_main_request_ = true;
   interceptor.main_headers_ = TestInterceptor::ok_headers();
   interceptor.main_data_ = TestInterceptor::ok_data();
 
   TestDelegate d;
   TestURLRequest req(GURL("http://test_intercept/foo"), &d);
-  URLRequest::UserData* user_data0 = new URLRequest::UserData();
-  URLRequest::UserData* user_data1 = new URLRequest::UserData();
-  URLRequest::UserData* user_data2 = new URLRequest::UserData();
+  net::URLRequest::UserData* user_data0 = new net::URLRequest::UserData();
+  net::URLRequest::UserData* user_data1 = new net::URLRequest::UserData();
+  net::URLRequest::UserData* user_data2 = new net::URLRequest::UserData();
   req.SetUserData(NULL, user_data0);
   req.SetUserData(&user_data1, user_data1);
   req.SetUserData(&user_data2, user_data2);
   req.set_method("GET");
   req.Start();
   MessageLoop::current()->Run();
 
   // Make sure we can retrieve our specific user data
   EXPECT_EQ(user_data0, req.GetUserData(NULL));
   EXPECT_EQ(user_data1, req.GetUserData(&user_data1));
@@ skipping 600 matching lines @@
   TestURLRequest
       req(test_server_.GetURL("echoheaderoverride?Accept-Charset"), &d);
   req.set_context(new TestURLRequestContext());
   net::HttpRequestHeaders headers;
   headers.SetHeader(net::HttpRequestHeaders::kAcceptCharset, "koi-8r");
   req.SetExtraRequestHeaders(headers);
   req.Start();
   MessageLoop::current()->Run();
   EXPECT_EQ(std::string("koi-8r"), d.data_received());
 }