net: Remove typedef net::URLRequestJob URLRequestJob;

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 33 matching lines @@
                      sizeof(kCompressed));
   } else {
     return false;
   }
 
   return true;
 }
 
 class MockJobObserver : public URLRequestJobTracker::JobObserver {
  public:
-  MOCK_METHOD1(OnJobAdded, void(URLRequestJob* job));
-  MOCK_METHOD1(OnJobRemoved, void(URLRequestJob* job));
-  MOCK_METHOD2(OnJobDone, void(URLRequestJob* job,
+  MOCK_METHOD1(OnJobAdded, void(net::URLRequestJob* job));
+  MOCK_METHOD1(OnJobRemoved, void(net::URLRequestJob* job));
+  MOCK_METHOD2(OnJobDone, void(net::URLRequestJob* job,
                                const URLRequestStatus& status));
-  MOCK_METHOD3(OnJobRedirect, void(URLRequestJob* job,
+  MOCK_METHOD3(OnJobRedirect, void(net::URLRequestJob* job,
                                    const GURL& location,
                                    int status_code));
-  MOCK_METHOD3(OnBytesRead, void(URLRequestJob* job,
+  MOCK_METHOD3(OnBytesRead, void(net::URLRequestJob* job,
                                  const char* buf,
                                  int byte_count));
 };
 
-// A URLRequestJob that returns static content for given URLs. We do
+// A net::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
+// callback. This test requires a net::URLRequestJob that returns false for
 // async reads, in order to exercise the real async read codepath.
-class URLRequestJobTrackerTestJob : public URLRequestJob {
+class URLRequestJobTrackerTestJob : public net::URLRequestJob {
  public:
   URLRequestJobTrackerTestJob(net::URLRequest* request, bool async_reads)
-      : URLRequestJob(request), async_reads_(async_reads) {}
+      : net::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 33 matching lines @@
   }
 
   bool GetContentEncodings(
       std::vector<Filter::FilterType>* encoding_types) {
     if (request_->url().spec() == "test:basic") {
       return false;
     } else if (request_->url().spec() == "test:compressed") {
       encoding_types->push_back(Filter::FILTER_TYPE_GZIP);
       return true;
     } else {
-      return URLRequestJob::GetContentEncodings(encoding_types);
+      return net::URLRequestJob::GetContentEncodings(encoding_types);
     }
   }
 
   // The data to send, will be set in Start().
   std::string response_data_;
 
   // Should reads be synchronous or asynchronous?
   const bool async_reads_;
 };
 
@@ skipping 55 matching lines @@
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_STREQ(kBasic, d.data_received().c_str());
   }
 
   static net::URLRequest::ProtocolFactory Factory;
   static bool g_async_reads;
 };
 
 // static
-URLRequestJob* URLRequestJobTrackerTest::Factory(net::URLRequest* request,
-                                                 const std::string& scheme) {
+net::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