net: Remove typedef net::URLRequestJob URLRequestJob;

webkit/appcache/appcache_update_job_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/stl_util-inl.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "net/base/net_errors.h"
@@ skipping 23 matching lines @@
 
 // There are a handful of http accessible resources that we need to conduct
 // these tests. Instead of running a seperate server to host these resources,
 // we mock them up.
 class MockHttpServer {
  public:
   static GURL GetMockUrl(const std::string& path) {
     return GURL("http://mockhost/" + path);
   }
 
-  static URLRequestJob* JobFactory(net::URLRequest* request,
-                                   const std::string& scheme) {
+  static net::URLRequestJob* JobFactory(net::URLRequest* request,
+                                        const std::string& scheme) {
     if (request->url().host() != "mockhost")
       return new URLRequestErrorJob(request, -1);
 
     std::string headers, body;
     GetMockResponse(request->url().path(), &headers, &body);
     return new URLRequestTestJob(request, headers, body, true);
   }
 
  private:
   static void GetMockResponse(const std::string& path,
@@ skipping 224 matching lines @@
   int last_progress_total_;
   int last_progress_complete_;
 
   // Add ability for frontend to add master entries to an inprogress update.
   EventID start_update_trigger_;
   AppCacheUpdateJob* update_;
   std::vector<AppCacheHost*> update_hosts_;
 };
 
 // Helper factories to simulate redirected URL responses for tests.
-static URLRequestJob* RedirectFactory(net::URLRequest* request,
-                                      const std::string& scheme) {
+static net::URLRequestJob* RedirectFactory(net::URLRequest* request,
+                                           const std::string& scheme) {
   return new URLRequestTestJob(request,
                                URLRequestTestJob::test_redirect_headers(),
                                URLRequestTestJob::test_data_1(),
                                true);
 }
 
 // Helper class to simulate a URL that returns retry or success.
 class RetryRequestTestJob : public URLRequestTestJob {
  public:
   enum RetryHeader {
@@ skipping 13 matching lines @@
     expected_requests_ = expected_requests;
   }
 
   // Verifies results at end of test and resets counters.
   static void Verify() {
     EXPECT_EQ(expected_requests_, num_requests_);
     num_requests_ = 0;
     expected_requests_ = 0;
   }
 
-  static URLRequestJob* RetryFactory(net::URLRequest* request,
-                                     const std::string& scheme) {
+  static net::URLRequestJob* RetryFactory(net::URLRequest* request,
+                                          const std::string& scheme) {
     ++num_requests_;
     if (num_retries_ > 0 && request->original_url() == kRetryUrl) {
       --num_retries_;
       return new RetryRequestTestJob(
           request, RetryRequestTestJob::retry_headers(), 503);
     } else {
       return new RetryRequestTestJob(
           request, RetryRequestTestJob::manifest_headers(), 200);
     }
   }
@@ skipping 80 matching lines @@
       EXPECT_TRUE(saw_if_none_match_);
 
     // Reset.
     expect_if_modified_since_.clear();
     saw_if_modified_since_ = false;
     expect_if_none_match_.clear();
     saw_if_none_match_ = false;
     already_checked_ = false;
   }
 
-  static URLRequestJob* IfModifiedSinceFactory(net::URLRequest* request,
-                                               const std::string& scheme) {
+  static net::URLRequestJob* IfModifiedSinceFactory(net::URLRequest* request,
+                                                    const std::string& scheme) {
     if (!already_checked_) {
       already_checked_ = true;  // only check once for a test
       const net::HttpRequestHeaders& extra_headers =
           request->extra_request_headers();
       std::string header_value;
       saw_if_modified_since_ =
           extra_headers.GetHeader(
               net::HttpRequestHeaders::kIfModifiedSince, &header_value) &&
           header_value == expect_if_modified_since_;
 
@@ skipping 3018 matching lines @@
   RunTestOnIOThread(&AppCacheUpdateJobTest::MultipleHeadersRefetchTest);
 }
 
 }  // namespace appcache
 
 // AppCacheUpdateJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheUpdateJobTest);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(
     appcache::AppCacheUpdateJobTest::MockAppCachePolicy);