net: Remove typedef net::URLRequest URLRequest;

net/url_request/url_request_job_tracker_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 <string.h>
 #include <algorithm>
 #include <string>
 #include <vector>
 #include "base/message_loop.h"
 #include "googleurl/src/gurl.h"
@@ skipping 52 matching lines @@
                                  int byte_count));
 };
 
 // A URLRequestJob that returns static content for given URLs. We do
 // not use URLRequestTestJob here because URLRequestTestJob fakes
 // async operations by calling ReadRawData synchronously in an async
 // callback. This test requires a URLRequestJob that returns false for
 // async reads, in order to exercise the real async read codepath.
 class URLRequestJobTrackerTestJob : public URLRequestJob {
  public:
-  URLRequestJobTrackerTestJob(URLRequest* request, bool async_reads)
+  URLRequestJobTrackerTestJob(net::URLRequest* request, bool async_reads)
       : URLRequestJob(request), async_reads_(async_reads) {}
 
   void Start() {
     ASSERT_TRUE(GetResponseBody(request_->url(), &response_data_));
 
     // Start reading asynchronously so that all error reporting and data
     // callbacks happen as they would for network requests.
     MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &URLRequestJobTrackerTestJob::NotifyHeadersComplete));
   }
@@ skipping 60 matching lines @@
 }
 
 // Google Mock Matcher to check that two blocks of memory are equal.
 MATCHER_P2(MemEq, other, len, "") {
   return memcmp(arg, other, len) == 0;
 }
 
 class URLRequestJobTrackerTest : public PlatformTest {
  protected:
   static void SetUpTestCase() {
-    URLRequest::RegisterProtocolFactory("test", &Factory);
+    net::URLRequest::RegisterProtocolFactory("test", &Factory);
   }
 
   virtual void SetUp() {
     g_async_reads = true;
   }
 
   void AssertJobTrackerCallbacks(const char* url) {
     InSequence seq;
     testing::StrictMock<MockJobObserver> observer;
 
@@ skipping 12 matching lines @@
 
     // Attach our observer and perform the resource fetch.
     g_url_request_job_tracker.AddObserver(&observer);
     Fetch(gurl);
     g_url_request_job_tracker.RemoveObserver(&observer);
   }
 
   void Fetch(const GURL& url) {
     TestDelegate d;
     {
-      URLRequest request(url, &d);
+      net::URLRequest request(url, &d);
       request.Start();
       MessageLoop::current()->RunAllPending();
     }
 
     // A few sanity checks to make sure that the delegate also
     // receives the expected callbacks.
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_STREQ(kBasic, d.data_received().c_str());
   }
 
-  static URLRequest::ProtocolFactory Factory;
+  static net::URLRequest::ProtocolFactory Factory;
   static bool g_async_reads;
 };
 
 // static
-URLRequestJob* URLRequestJobTrackerTest::Factory(URLRequest* request,
+URLRequestJob* URLRequestJobTrackerTest::Factory(net::URLRequest* request,
                                                  const std::string& scheme) {
   return new URLRequestJobTrackerTestJob(request, g_async_reads);
 }
 
 // static
 bool URLRequestJobTrackerTest::g_async_reads = true;
 
 TEST_F(URLRequestJobTrackerTest, BasicAsync) {
   g_async_reads = true;
   AssertJobTrackerCallbacks("test:basic");
 }
 
 TEST_F(URLRequestJobTrackerTest, BasicSync) {
   g_async_reads = false;
   AssertJobTrackerCallbacks("test:basic");
 }
 
 TEST_F(URLRequestJobTrackerTest, CompressedAsync) {
   g_async_reads = true;
   AssertJobTrackerCallbacks("test:compressed");
 }
 
 TEST_F(URLRequestJobTrackerTest, CompressedSync) {
   g_async_reads = false;
   AssertJobTrackerCallbacks("test:compressed");
 }
 
 }  // namespace