Remove use of deprecated DelayedSocketData gcm_unit_test.

google_apis/gcm/engine/connection_handler_impl_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/engine/connection_handler_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 100 matching lines @@
   net::StreamSocket* BuildSocket(const ReadList& read_list,
                                  const WriteList& write_list);
 
   // Pump |message_loop_|, resetting |run_loop_| after completion.
   void PumpLoop();
 
   ConnectionHandlerImpl* connection_handler() {
     return connection_handler_.get();
   }
   base::MessageLoop* message_loop() { return &message_loop_; };
-  net::DelayedSocketData* data_provider() { return data_provider_.get(); }
+  net::StaticSocketDataProvider* data_provider() {
+    return data_provider_.get();
+  }
   int last_error() const { return last_error_; }
 
   // Initialize the connection handler, setting |dst_proto| as the destination
   // for any received messages.
   void Connect(ScopedMessage* dst_proto);
 
   // Runs the message loop until a message is received.
   void WaitForMessage();
 
  private:
   void ReadContinuation(ScopedMessage* dst_proto, ScopedMessage new_proto);
   void WriteContinuation();
   void ConnectionContinuation(int error);
 
   // SocketStreams and their data provider.
   ReadList mock_reads_;
   WriteList mock_writes_;
-  scoped_ptr<net::DelayedSocketData> data_provider_;
+  scoped_ptr<net::StaticSocketDataProvider> data_provider_;
 
   // The connection handler being tested.
   scoped_ptr<ConnectionHandlerImpl> connection_handler_;
 
   // The last connection error received.
   int last_error_;
 
   // net:: components.
   scoped_ptr<net::StreamSocket> socket_;
   net::MockClientSocketFactory socket_factory_;
@@ skipping 12 matching lines @@
 
 GCMConnectionHandlerImplTest::~GCMConnectionHandlerImplTest() {
 }
 
 net::StreamSocket* GCMConnectionHandlerImplTest::BuildSocket(
     const ReadList& read_list,
     const WriteList& write_list) {
   mock_reads_ = read_list;
   mock_writes_ = write_list;
   data_provider_.reset(
-      new net::DelayedSocketData(0,
-                                 &(mock_reads_[0]), mock_reads_.size(),
-                                 &(mock_writes_[0]), mock_writes_.size()));
+      new net::StaticSocketDataProvider(
+          &(mock_reads_[0]), mock_reads_.size(),
+          &(mock_writes_[0]), mock_writes_.size()));
   socket_factory_.AddSocketDataProvider(data_provider_.get());
 
   socket_ = socket_factory_.CreateTransportClientSocket(
       address_list_, NULL, net::NetLog::Source());
   socket_->Connect(net::CompletionCallback());
 
   run_loop_.reset(new base::RunLoop());
   PumpLoop();
 
   DCHECK(socket_->IsConnected());
@@ skipping 379 matching lines @@
 
   ScopedMessage received_message;
   Connect(&received_message);
   WaitForMessage();  // The login send.
   WaitForMessage();  // The login response.
   received_message.reset();
   WaitForMessage();  // Should time out.
   EXPECT_FALSE(received_message.get());
   EXPECT_EQ(net::ERR_TIMED_OUT, last_error());
   EXPECT_FALSE(connection_handler()->CanSendMessage());
-
-  // Finish the socket read. Should have no effect.
-  data_provider()->ForceNextRead();
 }
 
 // Receive a message with zero data bytes.
 TEST_F(GCMConnectionHandlerImplTest, RecvMsgNoData) {
   std::string handshake_request = EncodeHandshakeRequest();
   WriteList write_list(1, net::MockWrite(net::ASYNC,
                                          handshake_request.c_str(),
                                          handshake_request.size()));
   std::string handshake_response = EncodeHandshakeResponse();
 
@@ skipping 213 matching lines @@
   WaitForMessage();  // The login send.
   WaitForMessage();  // The login response.
   WaitForMessage();  // The data message.
   ASSERT_TRUE(received_message.get());
   EXPECT_EQ(data_message_proto, received_message->SerializeAsString());
   EXPECT_EQ(net::OK, last_error());
 }
 
 }  // namespace
 }  // namespace gcm