Moving file_util::FileInfo to base::PlatformFileInfo, and adding the...

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 29 matching lines @@
 
 #if defined(OS_WIN)
 class URLRequestFileJob::AsyncResolver :
     public base::RefCountedThreadSafe<URLRequestFileJob::AsyncResolver> {
  public:
   explicit AsyncResolver(URLRequestFileJob* owner)
       : owner_(owner), owner_loop_(MessageLoop::current()) {
   }
 
   void Resolve(const FilePath& file_path) {
-    file_util::FileInfo file_info;
+    base::PlatformFileInfo file_info;
     bool exists = file_util::GetFileInfo(file_path, &file_info);
     AutoLock locked(lock_);
     if (owner_loop_) {
       owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
           this, &AsyncResolver::ReturnResults, exists, file_info));
     }
   }
 
   void Cancel() {
     owner_ = NULL;
 
     AutoLock locked(lock_);
     owner_loop_ = NULL;
   }
 
  private:
   friend class base::RefCountedThreadSafe<URLRequestFileJob::AsyncResolver>;
 
   ~AsyncResolver() {}
 
-  void ReturnResults(bool exists, const file_util::FileInfo& file_info) {
+  void ReturnResults(bool exists, const base::PlatformFileInfo& file_info) {
     if (owner_)
       owner_->DidResolve(exists, file_info);
   }
 
   URLRequestFileJob* owner_;
 
   Lock lock_;
   MessageLoop* owner_loop_;
 };
 #endif
@@ skipping 39 matching lines @@
 #if defined(OS_WIN)
   // Resolve UNC paths on a background thread.
   if (!file_path_.value().compare(0, 2, L"\\\\")) {
     DCHECK(!async_resolver_);
     async_resolver_ = new AsyncResolver(this);
     WorkerPool::PostTask(FROM_HERE, NewRunnableMethod(
         async_resolver_.get(), &AsyncResolver::Resolve, file_path_), true);
     return;
   }
 #endif
-  file_util::FileInfo file_info;
+  base::PlatformFileInfo file_info;
   bool exists = file_util::GetFileInfo(file_path_, &file_info);
 
   // Continue asynchronously.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &URLRequestFileJob::DidResolve, exists, file_info));
 }
 
 void URLRequestFileJob::Kill() {
   stream_.Close();
 
@@ skipping 72 matching lines @@
         // TODO(hclam): decide whether we want to support multiple range
         // requests.
         NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
                                     net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
       }
     }
   }
 }
 
 void URLRequestFileJob::DidResolve(
-    bool exists, const file_util::FileInfo& file_info) {
+    bool exists, const base::PlatformFileInfo& file_info) {
 #if defined(OS_WIN)
   async_resolver_ = NULL;
 #endif
 
   // We may have been orphaned...
   if (!request_)
     return;
 
   is_directory_ = file_info.is_directory;
 
@@ skipping 88 matching lines @@
   if (!resolved)
     return false;
 
   *location = net::FilePathToFileURL(new_path);
   *http_status_code = 301;
   return true;
 #else
   return false;
 #endif
 }