net: Remove typedef net::URLRequestJob URLRequestJob;

net/url_request/url_request_file_job.cc

 // Copyright (c) 2006-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.
 
 // For loading files, we make use of overlapped i/o to ensure that reading from
 // the filesystem (e.g., a network filesystem) does not block the calling
 // thread.  An alternative approach would be to use a background thread or pool
 // of threads, but it seems better to leverage the operating system's ability
 // to do background file reads for us.
 //
@@ skipping 65 matching lines @@
   }
 
   URLRequestFileJob* owner_;
 
   Lock lock_;
   MessageLoop* owner_loop_;
 };
 #endif
 
 // static
-URLRequestJob* URLRequestFileJob::Factory(net::URLRequest* request,
-                                          const std::string& scheme) {
+net::URLRequestJob* URLRequestFileJob::Factory(net::URLRequest* request,
+                                               const std::string& scheme) {
 
   FilePath file_path;
   const bool is_file = net::FileURLToFilePath(request->url(), &file_path);
 
 #if defined(OS_CHROMEOS)
   // Check file access.
   if (AccessDisabled(file_path))
     return new URLRequestErrorJob(request, net::ERR_ACCESS_DENIED);
 #endif
 
   // We need to decide whether to create URLRequestFileJob for file access or
   // URLRequestFileDirJob for directory access. To avoid accessing the
   // filesystem, we only look at the path string here.
   // The code in the URLRequestFileJob::Start() method discovers that a path,
   // which doesn't end with a slash, should really be treated as a directory,
   // and it then redirects to the URLRequestFileDirJob.
   if (is_file &&
       file_util::EndsWithSeparator(file_path) &&
       file_path.IsAbsolute())
     return new URLRequestFileDirJob(request, file_path);
 
   // Use a regular file request job for all non-directories (including invalid
   // file names).
   return new URLRequestFileJob(request, file_path);
 }
 
 URLRequestFileJob::URLRequestFileJob(net::URLRequest* request,
                                      const FilePath& file_path)
-    : URLRequestJob(request),
+    : net::URLRequestJob(request),
       file_path_(file_path),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &URLRequestFileJob::DidRead)),
       is_directory_(false),
       remaining_bytes_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
 }
 
 URLRequestFileJob::~URLRequestFileJob() {
 #if defined(OS_WIN)
@@ skipping 32 matching lines @@
 void URLRequestFileJob::Kill() {
   stream_.Close();
 
 #if defined(OS_WIN)
   if (async_resolver_) {
     async_resolver_->Cancel();
     async_resolver_ = NULL;
   }
 #endif
 
-  URLRequestJob::Kill();
+  net::URLRequestJob::Kill();
   method_factory_.RevokeAll();
 }
 
 bool URLRequestFileJob::ReadRawData(net::IOBuffer* dest, int dest_size,
                                     int *bytes_read) {
   DCHECK_NE(dest_size, 0);
   DCHECK(bytes_read);
   DCHECK_GE(remaining_bytes_, 0);
 
   if (remaining_bytes_ < dest_size)
@@ skipping 199 matching lines @@
     const FilePath white_listed_path(kLocalAccessWhiteList[i]);
     // FilePath::operator== should probably handle trailing seperators.
     if (white_listed_path == file_path.StripTrailingSeparators() ||
         white_listed_path.IsParent(file_path)) {
       return false;
     }
   }
   return true;
 }
 #endif