Remove DynamicSocketDataProvider

net/ftp/ftp_network_transaction_unittest.cc

 // Copyright (c) 2012 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/ftp/ftp_network_transaction.h"
 
 #include "build/build_config.h"
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
@@ skipping 13 matching lines @@
 
 namespace {
 
 // Size we use for IOBuffers used to receive data from the test data socket.
 const int kBufferSize = 128;
 
 }  // namespace
 
 namespace net {
 
-class FtpSocketDataProvider : public DynamicSocketDataProvider {
+class FtpSocketDataProvider : public SocketDataProvider {
  public:
   enum State {
     NONE,
     PRE_USER,
     PRE_PASSWD,
     PRE_SYST,
     PRE_PWD,
     PRE_TYPE,
     PRE_SIZE,
     PRE_LIST_EPSV,
     PRE_LIST_PASV,
     PRE_LIST,
     PRE_RETR,
     PRE_RETR_EPSV,
     PRE_RETR_PASV,
     PRE_CWD,
     PRE_QUIT,
     PRE_NOPASV,
     QUIT
   };
 
   FtpSocketDataProvider()
-      : failure_injection_state_(NONE),
+      : short_read_limit_(0),
+        allow_unconsumed_reads_(false),
+        failure_injection_state_(NONE),
         multiline_welcome_(false),
         use_epsv_(true),
         data_type_('I') {
     Init();
   }
 
+  // SocketDataProvider implementation.
+  MockRead OnRead() override {
+    if (reads_.empty())
+      return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
+    MockRead result = reads_.front();
+    if (short_read_limit_ == 0 || result.data_len <= short_read_limit_) {
+      reads_.pop_front();
+    } else {
+      result.data_len = short_read_limit_;
+      reads_.front().data += result.data_len;
+      reads_.front().data_len -= result.data_len;
+    }
+    return result;
+  }
+
   MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_USER:
         return Verify("USER anonymous\r\n", data, PRE_PASSWD,
                       "331 Password needed\r\n");
       case PRE_PASSWD:
         {
           static const char response_one[] = "230 Welcome\r\n";
@@ skipping 43 matching lines @@
     failure_injection_state_ = state;
     failure_injection_next_state_ = next_state;
     fault_response_ = response;
   }
 
   State state() const {
     return state_;
   }
 
   void Reset() override {
-    DynamicSocketDataProvider::Reset();
+    reads_.clear();
     Init();
   }
 
   bool AllReadDataConsumed() const override { return state_ == QUIT; }
 
   bool AllWriteDataConsumed() const override { return state_ == QUIT; }
 
   void set_multiline_welcome(bool multiline) { multiline_welcome_ = multiline; }
 
   bool use_epsv() const { return use_epsv_; }
   void set_use_epsv(bool use_epsv) { use_epsv_ = use_epsv; }
 
   void set_data_type(char data_type) { data_type_ = data_type; }
 
+  int short_read_limit() const { return short_read_limit_; }
+  void set_short_read_limit(int limit) { short_read_limit_ = limit; }
+
+  void set_allow_unconsumed_reads(bool allow) {
+    allow_unconsumed_reads_ = allow;
+  }
+
  protected:
   void Init() {
     state_ = PRE_USER;
     SimulateRead("220 host TestFTPd\r\n");
   }
 
   // If protocol fault injection has been requested, adjusts state and mocked
   // read and returns true.
   bool InjectFault() {
     if (state_ != failure_injection_state_)
@@ skipping 18 matching lines @@
   }
 
   MockWriteResult Verify(const std::string& expected,
                          const std::string& data,
                          State next_state,
                          const char* next_read) {
     return Verify(expected, data, next_state,
                   next_read, std::strlen(next_read));
   }
 
+  // The next time there is a read from this socket, it will return |data|.
+  // Before calling SimulateRead next time, the previous data must be consumed.
+  void SimulateRead(const char* data, size_t length) {
+    if (!allow_unconsumed_reads_) {
+      EXPECT_TRUE(reads_.empty()) << "Unconsumed read: " << reads_.front().data;
+    }
+    reads_.push_back(MockRead(ASYNC, data, length));
+  }
+  void SimulateRead(const char* data) { SimulateRead(data, std::strlen(data)); }
 
  private:
+  // List of reads to be consumed.
+  std::deque<MockRead> reads_;
+
+  // Max number of bytes we will read at a time. 0 means no limit.
+  int short_read_limit_;
+
+  // If true, we'll not require the client to consume all data before we
+  // mock the next read.
+  bool allow_unconsumed_reads_;
+
   State state_;
   State failure_injection_state_;
   State failure_injection_next_state_;
   const char* fault_response_;
 
   // If true, we will send multiple 230 lines as response after PASS.
   bool multiline_welcome_;
 
   // If true, we will use EPSV command.
   bool use_epsv_;
@@ skipping 751 matching lines @@
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionShortReads5) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   ctrl_socket.set_short_read_limit(5);
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 }
 
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcomeShort) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   // The client will not consume all three 230 lines. That's good, we want to
   // test that scenario.
-  ctrl_socket.allow_unconsumed_reads(true);
+  ctrl_socket.set_allow_unconsumed_reads(true);
   ctrl_socket.set_multiline_welcome(true);
   ctrl_socket.set_short_read_limit(5);
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 }
 
 // Regression test for http://crbug.com/60555.
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionZeroSize) {
   FtpSocketDataProviderDirectoryListingZeroSize ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 }
@@ skipping 610 matching lines @@
                         FtpSocketDataProvider::PRE_TYPE,
                         "257 \"\"\r\n",
                         OK);
 }
 
 INSTANTIATE_TEST_CASE_P(FTP,
                         FtpNetworkTransactionTest,
                         ::testing::Values(AF_INET, AF_INET6));
 
 }  // namespace net