Remove use of deprecated DelayedSocketData gcm_unit_test.

google_apis/gcm/base/socket_stream_unittest.cc

 // Copyright 2013 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 "google_apis/gcm/base/socket_stream.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 28 matching lines @@
 
   // Simulates a google::protobuf::io::CodedInputStream read.
   base::StringPiece DoInputStreamRead(int bytes);
   // Simulates a google::protobuf::io::CodedOutputStream write.
   int DoOutputStreamWrite(const base::StringPiece& write_src);
 
   // Synchronous Refresh wrapper.
   void WaitForData(int msg_size);
 
   base::MessageLoop* message_loop() { return &message_loop_; };
-  net::DelayedSocketData* data_provider() { return data_provider_.get(); }
+  net::StaticSocketDataProvider* data_provider() {
+    return data_provider_.get();
+  }
   SocketInputStream* input_stream() { return socket_input_stream_.get(); }
   SocketOutputStream* output_stream() { return socket_output_stream_.get(); }
   net::StreamSocket* socket() { return socket_.get(); }
 
  private:
   void OpenConnection();
   void ResetInputStream();
   void ResetOutputStream();
 
   void ConnectCallback(int result);
 
   // SocketStreams and their data providers.
   ReadList mock_reads_;
   WriteList mock_writes_;
-  scoped_ptr<net::DelayedSocketData> data_provider_;
+  scoped_ptr<net::StaticSocketDataProvider> data_provider_;
   scoped_ptr<SocketInputStream> socket_input_stream_;
   scoped_ptr<SocketOutputStream> socket_output_stream_;
 
   // net:: components.
   scoped_ptr<net::StreamSocket> socket_;
   net::MockClientSocketFactory socket_factory_;
   net::AddressList address_list_;
 
   base::MessageLoopForIO message_loop_;
 };
 
 GCMSocketStreamTest::GCMSocketStreamTest() {
   net::IPAddressNumber ip_number;
   net::ParseIPLiteralToNumber("127.0.0.1", &ip_number);
   address_list_ = net::AddressList::CreateFromIPAddress(ip_number, 5228);
 }
 
 GCMSocketStreamTest::~GCMSocketStreamTest() {}
 
 void GCMSocketStreamTest::BuildSocket(const ReadList& read_list,
                                       const WriteList& write_list) {
   mock_reads_ = read_list;
   mock_writes_ = write_list;
   data_provider_.reset(
-      new net::DelayedSocketData(
-          0,
+      new net::StaticSocketDataProvider(
           vector_as_array(&mock_reads_), mock_reads_.size(),
           vector_as_array(&mock_writes_), mock_writes_.size()));
   socket_factory_.AddSocketDataProvider(data_provider_.get());
   OpenConnection();
   ResetInputStream();
   ResetOutputStream();
 }
 
 void GCMSocketStreamTest::PumpLoop() {
   base::RunLoop run_loop;
@@ skipping 123 matching lines @@
   ASSERT_EQ(std::string(kReadData, kReadDataSize),
             DoInputStreamRead(kReadDataSize));
 }
 
 // A read where no data is available at first (IO_PENDING will be returned).
 TEST_F(GCMSocketStreamTest, ReadAsync) {
   int first_read_len = kReadDataSize / 2;
   int second_read_len = kReadDataSize - first_read_len;
   ReadList read_list;
   read_list.push_back(
-      net::MockRead(net::SYNCHRONOUS, net::ERR_IO_PENDING));
-  read_list.push_back(
       net::MockRead(net::ASYNC, kReadData, first_read_len));
   read_list.push_back(
       net::MockRead(net::ASYNC, &kReadData[first_read_len], second_read_len));
   BuildSocket(read_list, WriteList());
-
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&net::DelayedSocketData::ForceNextRead,
-                 base::Unretained(data_provider())));
   WaitForData(kReadDataSize);
   ASSERT_EQ(std::string(kReadData, kReadDataSize),
             DoInputStreamRead(kReadDataSize));
 }
 
 // Simulate two packets arriving at once. Read them in two separate calls.
 TEST_F(GCMSocketStreamTest, TwoReadsAtOnce) {
   std::string long_data = std::string(kReadData, kReadDataSize) +
                           std::string(kReadData2, kReadData2Size);
   BuildSocket(ReadList(1, net::MockRead(net::SYNCHRONOUS,
@@ skipping 142 matching lines @@
 TEST_F(GCMSocketStreamTest, WriteDisconnected) {
   BuildSocket(ReadList(), WriteList());
   socket()->Disconnect();
   DoOutputStreamWrite(base::StringPiece(kWriteData, kWriteDataSize));
   ASSERT_EQ(SocketOutputStream::CLOSED, output_stream()->GetState());
   ASSERT_EQ(net::ERR_CONNECTION_CLOSED, output_stream()->last_error());
 }
 
 }  // namespace
 }  // namespace gcm