revert 5730

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@5731 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 132 insertions, 182 deletions

diff --git a/base/file_util.h b/base/file_util.h
index 0103003..e274d6a 100644
--- a/base/file_util.h
+++ b/base/file_util.h
@@ -14,7 +14,6 @@
 #include <windows.h>
 #elif defined(OS_POSIX)
 #include <fts.h>
-#include <sys/stat.h>
 #endif
 
 #include <stdio.h>
@@ -324,15 +323,6 @@ bool SetCurrentDirectory(const std::wstring& current_directory);
 // program where latency does not matter. This class is blocking.
 class FileEnumerator {
  public:
-#if defined(OS_WIN)
-  typedef WIN32_FIND_DATA FindInfo;
-#elif defined(OS_POSIX)
-  typedef struct {
-    struct stat stat;
-    std::string filename;
-  } FindInfo;
-#endif
-
   enum FILE_TYPE {
     FILES                 = 0x1,
     DIRECTORIES           = 0x2,
@@ -371,9 +361,6 @@ class FileEnumerator {
   // Returns an empty string if there are no more results.
   std::wstring Next();
 
-  // Write the file info into |info|.
-  void GetFindInfo(FindInfo* info);
-
  private:
   std::wstring root_path_;
   bool recursive_;
@@ -393,7 +380,6 @@ class FileEnumerator {
   HANDLE find_handle_;
 #elif defined(OS_POSIX)
   FTS* fts_;
-  FTSENT* fts_ent_;
 #endif
 
   DISALLOW_EVIL_CONSTRUCTORS(FileEnumerator);
diff --git a/base/file_util_posix.cc b/base/file_util_posix.cc
index 5760a68..1afb573 100644
--- a/base/file_util_posix.cc
+++ b/base/file_util_posix.cc
@@ -409,16 +409,6 @@ FileEnumerator::~FileEnumerator() {
     fts_close(fts_);
 }
 
-void FileEnumerator::GetFindInfo(FindInfo* info) {
-  DCHECK(info);
-
-  if (!is_in_find_op_)
-    return;
-
-  memcpy(&(info->stat), fts_ent_->fts_statp, sizeof(info->stat));
-  info->filename.assign(fts_ent_->fts_name);
-}
-
 // As it stands, this method calls itself recursively when the next item of
 // the fts enumeration doesn't match (type, pattern, etc.).  In the case of
 // large directories with many files this can be quite deep.
@@ -427,12 +417,12 @@ std::wstring FileEnumerator::Next() {
   if (!is_in_find_op_) {
     if (pending_paths_.empty())
       return std::wstring();
-
+    
     // The last find FindFirstFile operation is done, prepare a new one.
     root_path_ = pending_paths_.top();
     TrimTrailingSeparator(&root_path_);
     pending_paths_.pop();
-
+    
     // Start a new find operation.
     int ftsflags = FTS_LOGICAL;
     char top_dir[PATH_MAX];
@@ -443,41 +433,41 @@ std::wstring FileEnumerator::Next() {
       return Next();
     is_in_find_op_ = true;
   }
-
-  fts_ent_ = fts_read(fts_);
-  if (fts_ent_ == NULL) {
+  
+  FTSENT* fts_ent = fts_read(fts_);
+  if (fts_ent == NULL) {
     fts_close(fts_);
     fts_ = NULL;
     is_in_find_op_ = false;
     return Next();
   }
-
+  
   // Level 0 is the top, which is always skipped.
-  if (fts_ent_->fts_level == 0)
+  if (fts_ent->fts_level == 0)
     return Next();
-
+  
   // Patterns are only matched on the items in the top-most directory.
   // (see Windows implementation)
-  if (fts_ent_->fts_level == 1 && pattern_.length() > 0) {
-    if (fnmatch(WideToUTF8(pattern_).c_str(), fts_ent_->fts_path, 0) != 0) {
-      if (fts_ent_->fts_info == FTS_D)
-        fts_set(fts_, fts_ent_, FTS_SKIP);
+  if (fts_ent->fts_level == 1 && pattern_.length() > 0) {
+    if (fnmatch(WideToUTF8(pattern_).c_str(), fts_ent->fts_path, 0) != 0) {
+      if (fts_ent->fts_info == FTS_D)
+        fts_set(fts_, fts_ent, FTS_SKIP);
       return Next();
     }
   }
-
-  std::wstring cur_file(UTF8ToWide(fts_ent_->fts_path));
-  if (fts_ent_->fts_info == FTS_D) {
+  
+  std::wstring cur_file(UTF8ToWide(fts_ent->fts_path));
+  if (fts_ent->fts_info == FTS_D) {
     // If not recursive, then prune children.
     if (!recursive_)
-      fts_set(fts_, fts_ent_, FTS_SKIP);
+      fts_set(fts_, fts_ent, FTS_SKIP);
     return (file_type_ & FileEnumerator::DIRECTORIES) ? cur_file : Next();
-  } else if (fts_ent_->fts_info == FTS_F) {
+  } else if (fts_ent->fts_info == FTS_F) {
     return (file_type_ & FileEnumerator::FILES) ? cur_file : Next();
   }
   // TODO(erikkay) - verify that the other fts_info types aren't interesting
   return Next();
 }
-
-
+  
+  
 } // namespace file_util
diff --git a/base/file_util_win.cc b/base/file_util_win.cc
index fdfd6dd..459e3a8 100644
--- a/base/file_util_win.cc
+++ b/base/file_util_win.cc
@@ -625,15 +625,6 @@ FileEnumerator::~FileEnumerator() {
     FindClose(find_handle_);
 }
 
-void FileEnumerator::GetFindInfo(FindInfo* info) {
-  DCHECK(info);
-
-  if (!is_in_find_op_)
-    return;
-
-  memcpy(info, &find_data_, sizeof(*info));
-}
-
 std::wstring FileEnumerator::Next() {
   if (!is_in_find_op_) {
     if (pending_paths_.empty())
diff --git a/net/base/directory_lister.cc b/net/base/directory_lister.cc
index a04aec2..0204ce4 100644
--- a/net/base/directory_lister.cc
+++ b/net/base/directory_lister.cc
@@ -2,12 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <process.h>
+
 #include "net/base/directory_lister.h"
 
-#include "base/file_util.h"
 #include "base/message_loop.h"
-#include "base/platform_thread.h"
-#include "net/base/net_errors.h"
 
 namespace net {
 
@@ -28,24 +27,65 @@ class DirectoryDataEvent : public Task {
   }
 
   scoped_refptr<DirectoryLister> lister;
-  file_util::FileEnumerator::FindInfo data[kFilesPerEvent];
-  int count, error;
+  WIN32_FIND_DATA data[kFilesPerEvent];
+  int count;
+  DWORD error;
 };
 
-DirectoryLister::DirectoryLister(const std::wstring& dir,
-                                 DirectoryListerDelegate* delegate)
+/*static*/
+unsigned __stdcall DirectoryLister::ThreadFunc(void* param) {
+  DirectoryLister* self = reinterpret_cast<DirectoryLister*>(param);
+
+  std::wstring pattern = self->directory();
+  if (pattern[pattern.size()-1] != '\\') {
+    pattern.append(L"\\*");
+  } else {
+    pattern.append(L"*");
+  }
+
+  DirectoryDataEvent* e = new DirectoryDataEvent(self);
+
+  HANDLE handle = FindFirstFile(pattern.c_str(), &e->data[e->count]);
+  if (handle == INVALID_HANDLE_VALUE) {
+    e->error = GetLastError();
+    self->message_loop_->PostTask(FROM_HERE, e);
+    e = NULL;
+  } else {
+    do {
+      if (++e->count == kFilesPerEvent) {
+        self->message_loop_->PostTask(FROM_HERE, e);
+        e = new DirectoryDataEvent(self);
+      }
+    } while (!self->was_canceled() && FindNextFile(handle, &e->data[e->count]));
+
+    FindClose(handle);
+
+    if (e->count > 0) {
+      self->message_loop_->PostTask(FROM_HERE, e);
+      e = NULL;
+    }
+
+    // Notify done
+    e = new DirectoryDataEvent(self);
+    self->message_loop_->PostTask(FROM_HERE, e);
+  }
+
+  self->Release();
+  return 0;
+}
+
+DirectoryLister::DirectoryLister(const std::wstring& dir, Delegate* delegate)
     : dir_(dir),
-      delegate_(delegate),
       message_loop_(NULL),
+      delegate_(delegate),
       thread_(NULL),
       canceled_(false) {
   DCHECK(!dir.empty());
 }
 
 DirectoryLister::~DirectoryLister() {
-  if (thread_) {
-    PlatformThread::Join(thread_);
-  }
+  if (thread_)
+    CloseHandle(thread_);
 }
 
 bool DirectoryLister::Start() {
@@ -57,7 +97,12 @@ bool DirectoryLister::Start() {
 
   AddRef();  // the thread will release us when it is done
 
-  if (!PlatformThread::Create(0, this, &thread_)) {
+  unsigned thread_id;
+  thread_ = reinterpret_cast<HANDLE>(
+      _beginthreadex(NULL, 0, DirectoryLister::ThreadFunc, this, 0,
+                     &thread_id));
+
+  if (!thread_) {
     Release();
     return false;
   }
@@ -69,48 +114,13 @@ void DirectoryLister::Cancel() {
   canceled_ = true;
 
   if (thread_) {
-    PlatformThread::Join(thread_);
+    WaitForSingleObject(thread_, INFINITE);
+    CloseHandle(thread_);
     thread_ = NULL;
   }
 }
 
-void DirectoryLister::ThreadMain() {
-  DirectoryDataEvent* e = new DirectoryDataEvent(this);
-
-  if (!file_util::DirectoryExists(directory())) {
-    e->error = net::ERR_FILE_NOT_FOUND;
-    message_loop_->PostTask(FROM_HERE, e);
-    Release();
-    return;
-  }
-
-  file_util::FileEnumerator file_enum(directory(), false,
-      file_util::FileEnumerator::FILES_AND_DIRECTORIES);
-
-  std::wstring filename;
-  while (!was_canceled() && !(filename = file_enum.Next()).empty()) {
-    file_enum.GetFindInfo(&e->data[e->count]);
-
-    if (++e->count == kFilesPerEvent) {
-      message_loop_->PostTask(FROM_HERE, e);
-      e = new DirectoryDataEvent(this);
-    }
-  }
-
-  if (e->count > 0) {
-    message_loop_->PostTask(FROM_HERE, e);
-    e = NULL;
-  }
-
-  // Notify done
-  e = new DirectoryDataEvent(this);
-  message_loop_->PostTask(FROM_HERE, e);
-
-  Release();
-}
-
-void DirectoryLister::OnReceivedData(
-    const file_util::FileEnumerator::FindInfo* data, int count) {
+void DirectoryLister::OnReceivedData(const WIN32_FIND_DATA* data, int count) {
   // Since the delegate can clear itself during the OnListFile callback, we
   // need to null check it during each iteration of the loop.  Similarly, it is
   // necessary to check the canceled_ flag to avoid sending data to a delegate
@@ -123,7 +133,7 @@ void DirectoryLister::OnDone(int error) {
   // If canceled, we need to report some kind of error, but don't overwrite the
   // error condition if it is already set.
   if (!error && canceled_)
-    error = net::ERR_ABORTED;
+    error = ERROR_OPERATION_ABORTED;
 
   if (delegate_)
     delegate_->OnListDone(error);
diff --git a/net/base/directory_lister.h b/net/base/directory_lister.h
index 06d1b37..5f826ce 100644
--- a/net/base/directory_lister.h
+++ b/net/base/directory_lister.h
@@ -5,10 +5,9 @@
 #ifndef NET_BASE_DIRECTORY_LISTER_H__
 #define NET_BASE_DIRECTORY_LISTER_H__
 
+#include <windows.h>
 #include <string>
 
-#include "base/file_util.h"
-#include "base/platform_thread.h"
 #include "base/ref_counted.h"
 
 class MessageLoop;
@@ -22,18 +21,16 @@ namespace net {
 // structs over to the main application thread.  The consumer of this class
 // is insulated from any of the multi-threading details.
 //
-class DirectoryLister : public base::RefCountedThreadSafe<DirectoryLister>,
-                        public PlatformThread::Delegate {
+class DirectoryLister : public base::RefCountedThreadSafe<DirectoryLister> {
  public:
   // Implement this class to receive directory entries.
-  class DirectoryListerDelegate {
+  class Delegate {
    public:
-    virtual void OnListFile(
-        const file_util::FileEnumerator::FindInfo& data) = 0;
+    virtual void OnListFile(const WIN32_FIND_DATA& data) = 0;
     virtual void OnListDone(int error) = 0;
   };
 
-  DirectoryLister(const std::wstring& dir, DirectoryListerDelegate* delegate);
+  DirectoryLister(const std::wstring& dir, Delegate* delegate);
   ~DirectoryLister();
 
   // Call this method to start the directory enumeration thread.
@@ -45,8 +42,8 @@ class DirectoryLister : public base::RefCountedThreadSafe<DirectoryLister>,
   void Cancel();
 
   // The delegate pointer may be modified at any time.
-  DirectoryListerDelegate* delegate() const { return delegate_; }
-  void set_delegate(DirectoryListerDelegate* d) { delegate_ = d; }
+  Delegate* delegate() const { return delegate_; }
+  void set_delegate(Delegate* d) { delegate_ = d; }
 
   // Returns the directory being enumerated.
   const std::wstring& directory() const { return dir_; }
@@ -54,21 +51,18 @@ class DirectoryLister : public base::RefCountedThreadSafe<DirectoryLister>,
   // Returns true if the directory enumeration was canceled.
   bool was_canceled() const { return canceled_; }
 
-  // PlatformThread::Delegate implementation
-  void ThreadMain();
-
  private:
   friend class DirectoryDataEvent;
-  friend class ThreadDelegate;
 
-  void OnReceivedData(const file_util::FileEnumerator::FindInfo* data,
-                      int count);
+  void OnReceivedData(const WIN32_FIND_DATA* data, int count);
   void OnDone(int error);
 
+  static unsigned __stdcall ThreadFunc(void* param);
+
   std::wstring dir_;
-  DirectoryListerDelegate* delegate_;
+  Delegate* delegate_;
   MessageLoop* message_loop_;
-  PlatformThreadHandle thread_;
+  HANDLE thread_;
   bool canceled_;
 };
 
diff --git a/net/base/net_util.cc b/net/base/net_util.cc
index 3946c6b..05419fb 100644
--- a/net/base/net_util.cc
+++ b/net/base/net_util.cc
@@ -23,7 +23,6 @@
 #include "net/base/net_util.h"
 
 #include "base/basictypes.h"
-#include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
@@ -799,22 +798,12 @@ std::string CanonicalizeHost(const std::wstring& host, bool* is_ip_address) {
   return CanonicalizeHost(converted_host, is_ip_address);
 }
   
+#ifdef OS_WIN
 std::string GetDirectoryListingHeader(const std::string& title) {
-#if defined(OS_WIN)
   std::string result = NetModule::GetResource(IDR_DIR_HEADER_HTML);
   if (result.empty()) {
     NOTREACHED() << "expected resource not found";
   }
-#elif defined(OS_POSIX)
-  // TODO(estade): Temporary hack. Remove these platform #ifdefs when we
-  // have implemented resources for non-Windows platforms.
-  LOG(INFO) << "FIXME: hacked resource loading";
-  FilePath path;
-  PathService::Get(base::DIR_EXE, &path);
-  path = path.Append("../../net/base/dir_header.html");
-  std::string result;
-  file_util::ReadFileToString(path.ToWStringHack(), &result);
-#endif
 
   result.append("<script>start(");
   string_escape::JavascriptDoubleQuote(title, true, &result);
@@ -824,16 +813,16 @@ std::string GetDirectoryListingHeader(const std::string& title) {
 }
 
 std::string GetDirectoryListingEntry(const std::string& name,
-                                     bool is_dir,
+                                     DWORD attrib,
                                      int64 size,
-                                     const Time& modified) {
+                                     const FILETIME* modified) {
   std::string result;
   result.append("<script>addRow(");
   string_escape::JavascriptDoubleQuote(name, true, &result);
   result.append(",");
   string_escape::JavascriptDoubleQuote(
       EscapePath(name), true, &result);
-  if (is_dir) {
+  if (attrib & FILE_ATTRIBUTE_DIRECTORY) {
     result.append(",1,");
   } else {
     result.append(",0,");
@@ -846,8 +835,9 @@ std::string GetDirectoryListingEntry(const std::string& name,
 
   std::wstring modified_str;
   // |modified| can be NULL in FTP listings.
-  if (!modified.is_null()) {
-    modified_str = base::TimeFormatShortDateAndTime(modified);
+  if (modified) {
+    Time time(Time::FromFileTime(*modified));
+    modified_str = base::TimeFormatShortDateAndTime(time);
   }
   string_escape::JavascriptDoubleQuote(modified_str, true, &result);
 
@@ -855,6 +845,7 @@ std::string GetDirectoryListingEntry(const std::string& name,
 
   return result;
 }
+#endif
 
 std::wstring StripWWW(const std::wstring& text) {
   const std::wstring www(L"www.");
diff --git a/net/base/net_util.h b/net/base/net_util.h
index f8f49b8..7adfc57 100644
--- a/net/base/net_util.h
+++ b/net/base/net_util.h
@@ -19,10 +19,6 @@
 
 class GURL;
 
-namespace base {
-class Time;
-}
-
 namespace net {
 
 // Given the full path to a file name, creates a file: URL. The returned URL
@@ -99,12 +95,15 @@ void IDNToUnicode(const char* host,
 std::string CanonicalizeHost(const std::string& host, bool* is_ip_address);
 std::string CanonicalizeHost(const std::wstring& host, bool* is_ip_address);
 
+#ifdef OS_WIN
+// TODO: Port GetDirectoryListingEntry for OSX and linux.
 // Call these functions to get the html for a directory listing.
 // They will pass non-7bit-ascii characters unescaped, allowing
 // the browser to interpret the encoding (utf8, etc).
 std::string GetDirectoryListingHeader(const std::string& title);
-std::string GetDirectoryListingEntry(const std::string& name, bool is_dir,
-                                     int64 size, const base::Time& modified);
+std::string GetDirectoryListingEntry(const std::string& name, DWORD attrib,
+                                     int64 size, const FILETIME* modified);
+#endif
 
 // If text starts with "www." it is removed, otherwise text is returned
 // unmodified.
diff --git a/net/net_lib.scons b/net/net_lib.scons
index 0e0b329..707216f 100644
--- a/net/net_lib.scons
+++ b/net/net_lib.scons
@@ -110,9 +110,11 @@ if env['PLATFORM'] in ('posix', 'darwin'):
   # Remove files that still need to be ported from the input_files list.
   # TODO(port): delete files from this list as they get ported.
   to_be_ported_files = [
+      'base/directory_lister.cc',
       'base/ssl_config_service.cc',
       'http/http_transaction_winhttp.cc',
       'http/winhttp_request_throttle.cc',
+      'url_request/url_request_file_dir_job.cc',
       'url_request/url_request_ftp_job.cc',
   ]
   for remove in to_be_ported_files:
diff --git a/net/url_request/url_request_file_dir_job.cc b/net/url_request/url_request_file_dir_job.cc
index 3685107..731d741 100644
--- a/net/url_request/url_request_file_dir_job.cc
+++ b/net/url_request/url_request_file_dir_job.cc
@@ -7,18 +7,16 @@
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
-#include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
+#include "net/base/wininet_util.h"
 #include "net/url_request/url_request.h"
 
-#if defined(OS_POSIX)
-#include <sys/stat.h>
-#endif
-
 using std::string;
 using std::wstring;
 
+using net::WinInetUtil;
+
 URLRequestFileDirJob::URLRequestFileDirJob(URLRequest* request,
                                            const wstring& dir_path)
     : URLRequestJob(request),
@@ -99,8 +97,12 @@ bool URLRequestFileDirJob::GetCharset(string* charset) {
   return true;
 }
 
-void URLRequestFileDirJob::OnListFile(
-    const file_util::FileEnumerator::FindInfo& data) {
+void URLRequestFileDirJob::OnListFile(const WIN32_FIND_DATA& data) {
+  FILETIME local_time;
+  FileTimeToLocalFileTime(&data.ftLastWriteTime, &local_time);
+  int64 size = (static_cast<unsigned __int64>(data.nFileSizeHigh) << 32) |
+      data.nFileSizeLow;
+
   // We wait to write out the header until we get the first file, so that we
   // can catch errors from DirectoryLister and show an error page.
   if (!wrote_header_) {
@@ -108,27 +110,11 @@ void URLRequestFileDirJob::OnListFile(
     wrote_header_ = true;
   }
 
-#if defined(OS_WIN)
-  FILETIME local_time;
-  ::FileTimeToLocalFileTime(&data.ftLastWriteTime, &local_time);
-  int64 size = (static_cast<unsigned __int64>(data.nFileSizeHigh) << 32) |
-      data.nFileSizeLow;
-
   data_.append(net::GetDirectoryListingEntry(
-      WideToUTF8(data.cFileName),
-      (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? true : false,
-      size,
-      base::Time::FromFileTime(local_time)));
-
-#elif defined(OS_POSIX)
-  data_.append(net::GetDirectoryListingEntry(
-      data.filename.c_str(),
-      S_ISDIR(data.stat.st_mode),
-      data.stat.st_size,
-      base::Time::FromTimeT(data.stat.st_mtime)));
-#endif
+      WideToUTF8(data.cFileName), data.dwFileAttributes, size, &local_time));
 
   // TODO(darin): coalesce more?
+
   CompleteRead();
 }
 
@@ -137,7 +123,8 @@ void URLRequestFileDirJob::OnListDone(int error) {
 
   if (error) {
     read_pending_ = false;
-    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, error));
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
+                                WinInetUtil::OSErrorToNetError(error)));
   } else if (canceled_) {
     read_pending_ = false;
     NotifyCanceled();
@@ -189,8 +176,7 @@ void URLRequestFileDirJob::CompleteRead() {
       NotifyReadComplete(bytes_read);
     } else {
       NOTREACHED();
-      // TODO: Better error code.
-      NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, 0));
+      NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, 0));  // TODO: Better error code.
     }
   }
 }
diff --git a/net/url_request/url_request_file_dir_job.h b/net/url_request/url_request_file_dir_job.h
index afbb56b..d8e7d43 100644
--- a/net/url_request/url_request_file_dir_job.h
+++ b/net/url_request/url_request_file_dir_job.h
@@ -5,13 +5,11 @@
 #ifndef NET_URL_REQUEST_URL_REQUEST_FILE_DIR_JOB_H__
 #define NET_URL_REQUEST_URL_REQUEST_FILE_DIR_JOB_H__
 
-#include "base/file_util.h"
 #include "net/base/directory_lister.h"
 #include "net/url_request/url_request_job.h"
 
-class URLRequestFileDirJob
-  : public URLRequestJob,
-    public net::DirectoryLister::DirectoryListerDelegate {
+class URLRequestFileDirJob : public URLRequestJob,
+                             public net::DirectoryLister::Delegate {
  public:
   URLRequestFileDirJob(URLRequest* request, const std::wstring& dir_path);
   virtual ~URLRequestFileDirJob();
@@ -24,8 +22,8 @@ class URLRequestFileDirJob
   virtual bool GetMimeType(std::string* mime_type);
   virtual bool GetCharset(std::string* charset);
 
-  // DirectoryLister::DirectoryListerDelegate methods:
-  virtual void OnListFile(const file_util::FileEnumerator::FindInfo& data);
+  // DirectoryLister::Delegate methods:
+  virtual void OnListFile(const WIN32_FIND_DATA& data);
   virtual void OnListDone(int error);
 
  private:
diff --git a/net/url_request/url_request_file_job.cc b/net/url_request/url_request_file_job.cc
index 5c823d8..608dc64 100644
--- a/net/url_request/url_request_file_job.cc
+++ b/net/url_request/url_request_file_job.cc
@@ -28,7 +28,9 @@
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request.h"
+#if defined(OS_WIN)
 #include "net/url_request/url_request_file_dir_job.h"
+#endif
 
 #if defined(OS_WIN)
 class URLRequestFileJob::AsyncResolver :
@@ -74,8 +76,10 @@ URLRequestJob* URLRequestFileJob::Factory(
   std::wstring file_path;
   if (net::FileURLToFilePath(request->url(), &file_path)) {
     if (file_path[file_path.size() - 1] == file_util::kPathSeparator) {
+#if defined(OS_WIN)
       // Only directories have trailing slashes.
       return new URLRequestFileDirJob(request, file_path);
+#endif
     }
   }
 
diff --git a/net/url_request/url_request_ftp_job.cc b/net/url_request/url_request_ftp_job.cc
index 7b72118..9cd7ca9 100644
--- a/net/url_request/url_request_ftp_job.cc
+++ b/net/url_request/url_request_ftp_job.cc
@@ -9,7 +9,6 @@
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
-#include "base/time.h"
 #include "net/base/auth.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
@@ -379,8 +378,8 @@ void URLRequestFtpJob::OnFindFile(DWORD last_error) {
     // We don't know the encoding, and can't assume utf8, so pass the 8bit
     // directly to the browser for it to decide.
     string file_entry = net::GetDirectoryListingEntry(
-        find_data_.cFileName, false, size,
-        base::Time::FromFileTime(find_data_.ftLastWriteTime));
+        find_data_.cFileName, find_data_.dwFileAttributes, size,
+        &find_data_.ftLastWriteTime);
     WriteData(&file_entry, true);
 
     FindNextFile();
@@ -402,7 +401,7 @@ void URLRequestFtpJob::OnStartDirectoryTraversal() {
   // If this isn't top level directory (i.e. the path isn't "/",) add a link to
   // the parent directory.
   if (request_->url().path().length() > 1)
-    html.append(net::GetDirectoryListingEntry("..", false, 0, base::Time()));
+    html.append(net::GetDirectoryListingEntry("..", 0, 0, NULL));
 
   WriteData(&html, true);