Make new FtpNetworkTransaction handle short reads correctly....

net/ftp/ftp_network_transaction.h

 // Copyright (c) 2008 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.
 
 #ifndef NET_FTP_FTP_NETWORK_TRANSACTION_H_
 #define NET_FTP_FTP_NETWORK_TRANSACTION_H_
 
 #include <string>
+#include <queue>
+#include <utility>
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "net/base/address_list.h"
 #include "net/base/host_resolver.h"
 #include "net/ftp/ftp_response_info.h"
 #include "net/ftp/ftp_transaction.h"
 
 namespace net {
 
@@ skipping 44 matching lines @@
     ERROR_CLASS_PENDING,        // The command accepted, but the
                                 // request on hold.
     ERROR_CLASS_ERROR_RETRY,    // The command was not accepted and the
                                 // requested action did not take place,
                                 // but the error condition is temporary and the
                                 // action may be requested again.
     ERROR_CLASS_ERROR,          // The command was not accepted and
                                 // the requested action did not take place.
   };
 
+  struct ResponseLine {
+    ResponseLine(int code, const std::string& text) : code(code), text(text) {
+    }
+
+    int code;  // Three-digit status code.
+    std::string text;  // Text after the code, without ending CRLF.
+  };
+
   void DoCallback(int result);
   void OnIOComplete(int result);
-  int GetRespnseCode();
-  int ProcessResponse(int response_code);
-  int ParsePasvResponse();
+
+  // Executes correct ProcessResponse + command_name function based on last
+  // issued command. Returns error code.
+  int ProcessCtrlResponses();
+
+  // Parses as much as possible from response_message_buf_. Puts index of the
+  // first unparsed character in cut_pos. Returns error code.
+  int ParseCtrlResponse(int* cut_pos);
 
   int SendFtpCommand(const std::string& command, Command cmd);
 
   // TODO(ibrar): Use C++ static_cast.
   ErrorClass GetErrorClass(int response_code) {
     return (ErrorClass)(response_code / 100);
   }
 
   // Runs the state transition loop.
   int DoLoop(int result);
 
   // Each of these methods corresponds to a State value.  Those with an input
   // argument receive the result from the previous state.  If a method returns
   // ERR_IO_PENDING, then the result from OnIOComplete will be passed to the
   // next state method as the result arg.
   int DoCtrlInit();
   int DoCtrlInitComplete(int result);
   int DoCtrlResolveHost();
   int DoCtrlResolveHostComplete(int result);
   int DoCtrlConnect();
   int DoCtrlConnectComplete(int result);
   int DoCtrlRead();
   int DoCtrlReadComplete(int result);
   int DoCtrlWriteUSER();
-  int ProcessResponseUSER(int response_code);
+  int ProcessResponseUSER(const ResponseLine& response);
   int DoCtrlWritePASS();
-  int ProcessResponsePASS(int response_code);
+  int ProcessResponsePASS(const ResponseLine& response);
   int DoCtrlWriteACCT();
-  int ProcessResponseACCT(int response_code);
+  int ProcessResponseACCT(const ResponseLine& response);
   int DoCtrlWriteSYST();
-  int ProcessResponseSYST(int response_code);
+  int ProcessResponseSYST(const ResponseLine& response);
   int DoCtrlWritePWD();
-  int ProcessResponsePWD(int response_code);
+  int ProcessResponsePWD(const ResponseLine& response);
   int DoCtrlWriteTYPE();
-  int ProcessResponseTYPE(int response_code);
+  int ProcessResponseTYPE(const ResponseLine& response);
   int DoCtrlWritePASV();
-  int ProcessResponsePASV(int response_code);
+  int ProcessResponsePASV(const ResponseLine& response);
   int DoCtrlWriteRETR();
-  int ProcessResponseRETR(int response_code);
+  int ProcessResponseRETR(const ResponseLine& response);
   int DoCtrlWriteSIZE();
-  int ProcessResponseSIZE(int response_code);
+  int ProcessResponseSIZE(const ResponseLine& response);
   int DoCtrlWriteCWD();
-  int ProcessResponseCWD(int response_code);
+  int ProcessResponseCWD(const ResponseLine& response);
   int DoCtrlWriteLIST();
-  int ProcessResponseLIST(int response_code);
+  int ProcessResponseLIST(const ResponseLine& response);
   int DoCtrlWriteMDTM();
-  int ProcessResponseMDTM(int response_code);
+  int ProcessResponseMDTM(const ResponseLine& response);
   int DoCtrlWriteQUIT();
-  int ProcessResponseQUIT(int response_code);
+  int ProcessResponseQUIT(const ResponseLine& response);
 
   int DoDataResolveHost();
   int DoDataResolveHostComplete(int result);
   int DoDataConnect();
   int DoDataConnectComplete(int result);
   int DoDataRead();
   int DoDataReadComplete(int result);
 
   Command command_sent_;
 
   CompletionCallbackImpl<FtpNetworkTransaction> io_callback_;
   CompletionCallback* user_callback_;
 
   scoped_refptr<FtpNetworkSession> session_;
 
   const FtpRequestInfo* request_;
   FtpResponseInfo response_;
 
   // Cancels the outstanding request on destruction.
   SingleRequestHostResolver resolver_;
   AddressList addresses_;
 
-  // User buffer and length passed to the Read method.
-  scoped_refptr<IOBuffer> read_ctrl_buf_;
-  int read_ctrl_buf_size_;
+  // As we read full response lines, we parse them and add to the queue.
+  std::queue<ResponseLine> ctrl_responses_;
 
-  scoped_refptr<IOBuffer> response_message_buf_;
+  // Buffer holding not-yet-parsed control socket responses.
+  scoped_refptr<IOBufferWithSize> response_message_buf_;
   int response_message_buf_len_;
 
+  // User buffer passed to the Read method. It actually writes to the
+  // response_message_buf_ at correct offset.
+  scoped_refptr<ReusedIOBuffer> read_ctrl_buf_;
+
   scoped_refptr<IOBuffer> read_data_buf_;
   int read_data_buf_len_;
   int file_data_len_;
 
   scoped_refptr<IOBuffer> write_buf_;
 
   int last_error_;
 
   bool is_anonymous_;
   bool retr_failed_;
@@ skipping 37 matching lines @@
     STATE_DATA_READ,
     STATE_DATA_READ_COMPLETE,
     STATE_NONE
   };
   State next_state_;
 };
 
 }  // namespace net
 
 #endif  // NET_FTP_FTP_NETWORK_TRANSACTION_H_