Update from https://crrev.com/304121

net/websockets/websocket_channel_test.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 "net/websockets/websocket_channel.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include <iostream>
@@ skipping 109 matching lines @@
 
 // The amount of quota a new connection gets by default.
 // TODO(ricea): If kDefaultSendQuotaHighWaterMark changes, then this value will
 // need to be updated.
 const size_t kDefaultInitialQuota = 1 << 17;
 // The amount of bytes we need to send after the initial connection to trigger a
 // quota refresh. TODO(ricea): Change this if kDefaultSendQuotaHighWaterMark or
 // kDefaultSendQuotaLowWaterMark change.
 const size_t kDefaultQuotaRefreshTrigger = (1 << 16) + 1;
 
+const int kVeryBigTimeoutMillis = 60 * 60 * 24 * 1000;
+
 // TestTimeouts::tiny_timeout() is 100ms! I could run halfway around the world
 // in that time! I would like my tests to run a bit quicker.
 const int kVeryTinyTimeoutMillis = 1;
 
 // Enough quota to pass any test.
 const int64 kPlentyOfQuota = INT_MAX;
 
 typedef WebSocketEventInterface::ChannelState ChannelState;
 const ChannelState CHANNEL_ALIVE = WebSocketEventInterface::CHANNEL_ALIVE;
 const ChannelState CHANNEL_DELETED = WebSocketEventInterface::CHANNEL_DELETED;
@@ skipping 1998 matching lines @@
     EXPECT_CALL(*event_interface_,
                 OnDropChannel(false, kWebSocketErrorAbnormalClosure, _))
         .WillOnce(InvokeClosureReturnDeleted(completion.closure()));
   }
   CreateChannelAndConnectSuccessfully();
   // OneShotTimer is not very friendly to testing; there is no apparent way to
   // set an expectation on it. Instead the tests need to infer that the timeout
   // was fired by the behaviour of the WebSocketChannel object.
   channel_->SetClosingHandshakeTimeoutForTesting(
       TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
+  channel_->SetUnderlyingConnectionCloseTimeoutForTesting(
+      TimeDelta::FromMilliseconds(kVeryBigTimeoutMillis));
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "");
   checkpoint.Call(1);
   completion.WaitForResult();
 }
 
 // The closing handshake times out and sends an OnDropChannel event if a Close
 // message is received but the connection isn't closed by the remote host.
 TEST_F(WebSocketChannelEventInterfaceTest,
        ServerInitiatedClosingHandshakeTimesOut) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
@@ skipping 10 matching lines @@
   {
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*event_interface_, OnClosingHandshake());
     EXPECT_CALL(*event_interface_,
                 OnDropChannel(false, kWebSocketErrorAbnormalClosure, _))
         .WillOnce(InvokeClosureReturnDeleted(completion.closure()));
   }
   CreateChannelAndConnectSuccessfully();
   channel_->SetClosingHandshakeTimeoutForTesting(
+      TimeDelta::FromMilliseconds(kVeryBigTimeoutMillis));
+  channel_->SetUnderlyingConnectionCloseTimeoutForTesting(
       TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
   checkpoint.Call(1);
   completion.WaitForResult();
 }
 
 // The renderer should provide us with some quota immediately, and then
 // WebSocketChannel calls ReadFrames as soon as the stream is available.
 TEST_F(WebSocketChannelStreamTest, FlowControlEarly) {
   Checkpoint checkpoint;
   EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
@@ skipping 1109 matching lines @@
 class WebSocketChannelStreamTimeoutTest : public WebSocketChannelStreamTest {
  protected:
   WebSocketChannelStreamTimeoutTest() {}
 
   void CreateChannelAndConnectSuccessfully() override {
     set_stream(mock_stream_.Pass());
     CreateChannelAndConnect();
     channel_->SendFlowControl(kPlentyOfQuota);
     channel_->SetClosingHandshakeTimeoutForTesting(
         TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
+    channel_->SetUnderlyingConnectionCloseTimeoutForTesting(
+        TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
     connect_data_.creator.connect_delegate->OnSuccess(stream_.Pass());
   }
 };
 
 // In this case the server initiates the closing handshake with a Close
 // message. WebSocketChannel responds with a matching Close message, and waits
 // for the server to close the TCP/IP connection. The server never closes the
 // connection, so the closing handshake times out and WebSocketChannel closes
 // the connection itself.
 TEST_F(WebSocketChannelStreamTimeoutTest, ServerInitiatedCloseTimesOut) {
@@ skipping 92 matching lines @@
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
   ASSERT_TRUE(read_frames);
   // Provide the "Close" message from the server.
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   completion.WaitForResult();
 }
 
 }  // namespace
 }  // namespace net