Fix XmppSignalStrategy to return correct result from SendStanza().

remoting/signaling/xmpp_signal_strategy_unittest.cc

 // Copyright 2015 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 "remoting/signaling/xmpp_signal_strategy.h"
 
 #include "base/base64.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 namespace remoting {
 
 namespace {
 
-class XmppSocketDataProvider: public net::SocketDataProvider {
+class XmppSocketDataProvider : public net::SocketDataProvider {
  public:
   net::MockRead OnRead() override {
     return net::MockRead(net::ASYNC, net::ERR_IO_PENDING);
   }
 
   net::MockWriteResult OnWrite(const std::string& data) override {
+    if (write_error_ != net::OK)
+      return net::MockWriteResult(net::SYNCHRONOUS, write_error_);
+
     written_data_.append(data);
 
     if (use_async_write_) {
       pending_write_size_ = data.size();
       return net::MockWriteResult(net::ASYNC, net::ERR_IO_PENDING);
     }
 
     return net::MockWriteResult(net::SYNCHRONOUS, data.size());
   }
 
   void Reset() override {}
 
   bool AllReadDataConsumed() const override {
     return true;
   }
 
   bool AllWriteDataConsumed() const override {
     return true;
   }
 
   void ReceiveData(const std::string& text) {
     socket()->OnReadComplete(
         net::MockRead(net::ASYNC, text.data(), text.size()));
   }
 
   void Close() {
     ReceiveData(std::string());
   }
 
-  void SimulateNetworkError() {
+  void SimulateAsyncReadError() {
     socket()->OnReadComplete(
         net::MockRead(net::ASYNC, net::ERR_CONNECTION_RESET));
   }
 
   std::string GetAndClearWrittenData() {
     std::string data;
     data.swap(written_data_);
     return data;
   }
 
   void set_use_async_write(bool use_async_write) {
     use_async_write_ = use_async_write;
   }
 
+  void set_write_error(net::Error error) {
+    write_error_ = error;
+  }
+
   void CompletePendingWrite() {
     socket()->OnWriteComplete(pending_write_size_);
   }
 
  private:
   std::string written_data_;
   bool use_async_write_ = false;
   int pending_write_size_ = 0;
+  net::Error write_error_ = net::OK;
 };
 
 class MockClientSocketFactory : public net::MockClientSocketFactory {
  public:
   scoped_ptr<net::SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<net::ClientSocketHandle> transport_socket,
       const net::HostPortPair& host_and_port,
       const net::SSLConfig& ssl_config,
       const net::SSLClientSocketContext& context) override {
     ssl_socket_created_ = true;
@@ skipping 201 matching lines @@
   EXPECT_EQ(SignalStrategy::OK, signal_strategy_->GetError());
 
   // Can't send messages anymore.
   EXPECT_FALSE(signal_strategy_->SendStanza(make_scoped_ptr(
       new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
 
   // Try connecting again.
   Connect(true);
 }
 
-TEST_F(XmppSignalStrategyTest, NetworkError) {
+TEST_F(XmppSignalStrategyTest, NetworkReadError) {
   CreateSignalStrategy(kDefaultPort);
   Connect(true);
 
-  socket_data_provider_->SimulateNetworkError();
+  socket_data_provider_->SimulateAsyncReadError();
 
   EXPECT_EQ(3U, state_history_.size());
   EXPECT_EQ(SignalStrategy::DISCONNECTED, state_history_[2]);
   EXPECT_EQ(SignalStrategy::NETWORK_ERROR, signal_strategy_->GetError());
 
   // Can't send messages anymore.
   EXPECT_FALSE(signal_strategy_->SendStanza(make_scoped_ptr(
       new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
 
   // Try connecting again.
   Connect(true);
 }
 
+TEST_F(XmppSignalStrategyTest, NetworkWriteError) {
+  CreateSignalStrategy(kDefaultPort);
+  Connect(true);
+
+  socket_data_provider_->set_write_error(net::ERR_FAILED);
+
+  // Next SendMessage() will call Write() which will fail.
+  EXPECT_FALSE(signal_strategy_->SendStanza(make_scoped_ptr(
+      new buzz::XmlElement(buzz::QName(std::string(), "hello")))));
+
+  EXPECT_EQ(3U, state_history_.size());
+  EXPECT_EQ(SignalStrategy::DISCONNECTED, state_history_[2]);
+  EXPECT_EQ(SignalStrategy::NETWORK_ERROR, signal_strategy_->GetError());
+
+  // Try connecting again.
+  Connect(true);
+}
+
 TEST_F(XmppSignalStrategyTest, StartTlsWithPendingWrite) {
   // Use port 5222 so that XmppLoginHandler uses starttls/proceed handshake
   // before starting TLS.
   CreateSignalStrategy(5222);
 
   socket_data_provider_.reset(new XmppSocketDataProvider());
   socket_data_provider_->set_connect_data(
       net::MockConnect(net::SYNCHRONOUS, net::OK));
   client_socket_factory_.AddSocketDataProvider(socket_data_provider_.get());
 
@@ skipping 19 matching lines @@
         "<proceed xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"/>");
 
   // Verify that SSL is connected only after write is finished.
   EXPECT_FALSE(client_socket_factory_.ssl_socket_created());
   socket_data_provider_->CompletePendingWrite();
   EXPECT_TRUE(client_socket_factory_.ssl_socket_created());
 }
 
 
   }  // namespace remoting