Add AllReadDataConsumed and AllWriteDataConsumed methods to SocketDataProvider

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <cstring>
 #include <deque>
 #include <string>
@@ skipping 180 matching lines @@
 
   virtual ~SocketDataProvider() {}
 
   // Returns the buffer and result code for the next simulated read.
   // If the |MockRead.result| is ERR_IO_PENDING, it informs the caller
   // that it will be called via the AsyncSocket::OnReadComplete()
   // function at a later time.
   virtual MockRead OnRead() = 0;
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
   virtual void Reset() = 0;
+  virtual bool AllReadDataConsumed() const = 0;
+  virtual bool AllWriteDataConsumed() const = 0;
 
   // Accessor for the socket which is using the SocketDataProvider.
   AsyncSocket* socket() { return socket_; }
   void set_socket(AsyncSocket* socket) { socket_ = socket; }
 
   MockConnect connect_data() const { return connect_; }
   void set_connect_data(const MockConnect& connect) { connect_ = connect; }
 
  private:
   MockConnect connect_;
@@ skipping 40 matching lines @@
   const MockWrite& AdvanceWrite();
 
   // Resets the read and write indexes to 0.
   void Reset();
 
   // Returns true if |data| is valid data for the next write. In order
   // to support short writes, the next write may be longer than |data|
   // in which case this method will still return true.
   bool VerifyWriteData(const std::string& data);
 
+  // Return true of all read data has been consumed.

[ramant (doing other things), 2015/05/01 20:25:41]

overly nit: "true of all" -> "true if all"?

[Ryan Hamilton, 2015/05/01 21:23:32]

Done.

+  bool AllReadDataConsumed() const;
+
+  // Return true of all write data has been consumed.

[ramant (doing other things), 2015/05/01 20:25:41]

overly nit: "true of all" -> "true if all"?

[Ryan Hamilton, 2015/05/01 21:23:32]

Done.

+  bool AllWriteDataConsumed() const;
+
   size_t read_index() const { return read_index_; }
   size_t write_index() const { return write_index_; }
   size_t read_count() const { return read_count_; }
   size_t write_count() const { return write_count_; }
 
-  bool at_read_eof() const { return read_index_ >= read_count_; }
-  bool at_write_eof() const { return write_index_ >= write_count_; }
-
  private:
   MockRead* reads_;
   size_t read_index_;
   size_t read_count_;
   MockWrite* writes_;
   size_t write_index_;
   size_t write_count_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSocketDataHelper);
 };
 
 // SocketDataProvider which responds based on static tables of mock reads and
 // writes.
 class StaticSocketDataProvider : public SocketDataProvider {
  public:
   StaticSocketDataProvider();
   StaticSocketDataProvider(MockRead* reads,
                            size_t reads_count,
                            MockWrite* writes,
                            size_t writes_count);
   ~StaticSocketDataProvider() override;
 
   virtual void CompleteRead() {}
 
   // SocketDataProvider implementation.
   MockRead OnRead() override;
   MockWriteResult OnWrite(const std::string& data) override;
   void Reset() override;
+  bool AllReadDataConsumed() const override;
+  bool AllWriteDataConsumed() const override;
 
   size_t read_index() const { return helper_.read_index(); }
   size_t write_index() const { return helper_.write_index(); }
   size_t read_count() const { return helper_.read_count(); }
   size_t write_count() const { return helper_.write_count(); }
 
-  bool at_read_eof() const { return helper_.at_read_eof(); }
-  bool at_write_eof() const { return helper_.at_write_eof(); }
-
  protected:
   StaticSocketDataHelper* helper() { return &helper_; }
 
  private:
   StaticSocketDataHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSocketDataProvider);
 };
 
 // SocketDataProvider which can make decisions about next mock reads based on
@@ skipping 176 matching lines @@
                       size_t reads_count,
                       MockWrite* writes,
                       size_t writes_count);
 
   ~SequencedSocketData() override;
 
   // SocketDataProviderBase implementation.
   MockRead OnRead() override;
   MockWriteResult OnWrite(const std::string& data) override;
   void Reset() override;
-
-  // Returns true if all data has been read.
-  bool at_read_eof() const;
-
-  // Returns true if all data has been written.
-  bool at_write_eof() const;
+  bool AllReadDataConsumed() const override;
+  bool AllWriteDataConsumed() const override;
 
  private:
   // Defines the state for the read or write path.
   enum IoState {
     IDLE,        // No async operation is in progress.
     PENDING,     // An async operation in waiting for another opteration to
                  // complete.
     COMPLETING,  // A task has been posted to complet an async operation.
   };
   void OnReadComplete();
@@ skipping 860 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_