Get the latest ParseFTPList code from Mozilla, and apply only the absolutely

net/url_request/url_request_new_ftp_job.cc

 // Copyright (c) 2009 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 "net/url_request/url_request_new_ftp_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_version_info.h"
 #include "base/message_loop.h"
 #include "base/sys_string_conversions.h"
@@ skipping 227 matching lines @@
   //
   // TODO(jungshik): UTF-8 has to be 'enforced' without any heuristics when
   // we're talking to an FTP server compliant to RFC 2640 (that is, its response
   // to FEAT command includes 'UTF8').
   // See http://wiki.filezilla-project.org/Character_Set
   if (encoding_.empty())
     encoding_ = DetectEncoding(buf->data(), bytes_read);
 
   int64 file_size;
   std::istringstream iss(std::string(buf->data(), bytes_read));
-  struct net::ListState state;
+  struct net::list_state state;
   memset(&state, 0, sizeof(state));
   while (getline(iss, line)) {
-    struct net::ListResult result;
+    struct net::list_result result;
     std::replace(line.begin(), line.end(), '\r', '\0');
-    net::LineType line_type = ParseFTPLine(line.c_str(), &state, &result);
+    int line_type = net::ParseFTPList(line.c_str(), &state, &result);
+
+    // The original code assumed months are in range 0-11 (PRExplodedTime),
+    // but our Time class expects a 1-12 range. Adjust it here, because
+    // the third-party parsing code uses bit-shifting on the month,

[wtc, 2009/09/10 18:55:32]

I now understand the bit-shifting code in ParseFTPList.cpp.
The bit-shifting code works whether 'month' is 0-based or
1-based.

+    // and it'd be too easy to break that logic.
+    result.fe_time.month++;
+    DCHECK_LE(1, result.fe_time.month);
+    DCHECK_GE(12, result.fe_time.month);
+
     switch (line_type) {
-      case net::FTP_TYPE_DIRECTORY:
+      case 'd':  // Directory entry.
         file_entry.append(net::GetDirectoryListingEntry(
             RawByteSequenceToFilename(result.fe_fname, encoding_),
             result.fe_fname, true, 0,
             base::Time::FromLocalExploded(result.fe_time)));
         break;
-      case net::FTP_TYPE_FILE:
+      case 'f':  // File entry.
         if (StringToInt64(result.fe_size, &file_size))
           file_entry.append(net::GetDirectoryListingEntry(
               RawByteSequenceToFilename(result.fe_fname, encoding_),
               result.fe_fname, false, file_size,
               base::Time::FromLocalExploded(result.fe_time)));
         break;
-      case net::FTP_TYPE_SYMLINK: {
+      case 'l': {  // Symlink entry.
           std::string filename(result.fe_fname, result.fe_fnlen);
 
           // Parsers for styles 'U' and 'W' handle " -> " themselves.
           if (state.lstyle != 'U' && state.lstyle != 'W') {
             std::string::size_type offset = filename.find(" -> ");
             if (offset != std::string::npos)
               filename = filename.substr(0, offset);
           }
 
           if (StringToInt64(result.fe_size, &file_size)) {
             file_entry.append(net::GetDirectoryListingEntry(
                 RawByteSequenceToFilename(filename.c_str(), encoding_),
                 filename, false, file_size,
                 base::Time::FromLocalExploded(result.fe_time)));
           }
         }
         break;
-      case net::FTP_TYPE_JUNK:
-      case net::FTP_TYPE_COMMENT:
+      case '?':  // Junk entry.
+      case '"':  // Comment entry.
         break;
       default:
+        NOTREACHED();
         break;
     }
   }
   LogFtpServerType(state);
   directory_html_.append(file_entry);
   size_t bytes_to_copy = std::min(static_cast<size_t>(buf_size),
                                   directory_html_.length());
   if (bytes_to_copy) {
     memcpy(buf->data(), directory_html_.c_str(), bytes_to_copy);
     directory_html_.erase(0, bytes_to_copy);
   }
   return bytes_to_copy;
 }
 
-void URLRequestNewFtpJob::LogFtpServerType(const net::ListState& list_state) {
+void URLRequestNewFtpJob::LogFtpServerType(
+    const struct net::list_state& list_state) {
   // We can't recognize server type based on empty directory listings. Don't log
   // that as unknown, it's misleading.
   if (!list_state.parsed_one)
     return;
 
   switch (list_state.lstyle) {
     case 'E':
       net::UpdateFtpServerTypeHistograms(net::SERVER_EPLF);
       break;
     case 'V':
@@ skipping 107 matching lines @@
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &URLRequestNewFtpJob::OnStartCompleted, rv));
 }
 
 void URLRequestNewFtpJob::DestroyTransaction() {
   DCHECK(transaction_.get());
 
   transaction_.reset();
   response_info_ = NULL;
 }