content/browser/renderer_host/websocket_dispatcher_host_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/websocket_dispatcher_host.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "content/browser/renderer_host/websocket_host.h"
  16 #include "content/common/websocket.h"
  17 #include "content/common/websocket_messages.h"
  18 #include "ipc/ipc_message.h"
  19 #include "net/websockets/websocket_errors.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "url/gurl.h"
  22 #include "url/origin.h"
  23
  24 namespace content {
  25 namespace {
  26
  27 // This number is unlikely to occur by chance.
  28 static const int kMagicRenderProcessId = 506116062;
  29
  30 class WebSocketDispatcherHostTest;
  31
  32 // A mock of WebsocketHost which records received messages.
  33 class MockWebSocketHost : public WebSocketHost {
  34  public:
  35   MockWebSocketHost(int routing_id,
  36                     WebSocketDispatcherHost* dispatcher,
  37                     net::URLRequestContext* url_request_context,
  38                     base::TimeDelta delay,
  39                     WebSocketDispatcherHostTest* owner);
  40
  41   ~MockWebSocketHost() override {}
  42
  43   bool OnMessageReceived(const IPC::Message& message) override {
  44     received_messages_.push_back(message);
  45     switch (message.type()) {
  46       case WebSocketMsg_DropChannel::ID:
  47         // Needed for PerRendererThrottlingFailedHandshakes, because without
  48         // calling WebSocketHost::OnMessageReceived() (and thus
  49         // WebSocketHost::OnDropChannel()), the connection stays pending and
  50         // we cannot test per-renderer throttling with failed connections.
  51         return WebSocketHost::OnMessageReceived(message);
  52
  53       default:
  54         return true;
  55     }
  56   }
  57
  58   void GoAway() override;
  59
  60   std::vector<IPC::Message> received_messages_;
  61   base::WeakPtr<WebSocketDispatcherHostTest> owner_;
  62   base::TimeDelta delay_;
  63 };
  64
  65 class TestingWebSocketDispatcherHost : public WebSocketDispatcherHost {
  66  public:
  67   TestingWebSocketDispatcherHost(
  68       int process_id,
  69       const GetRequestContextCallback& get_context_callback,
  70       const WebSocketHostFactory& websocket_host_factory)
  71       : WebSocketDispatcherHost(process_id,
  72                                 get_context_callback,
  73                                 websocket_host_factory) {}
  74
  75   // This is needed because BrowserMessageFilter::Send() tries post the task to
  76   // the IO thread, which doesn't exist in the context of these tests.
  77   bool Send(IPC::Message* message) override {
  78     delete message;
  79     return true;
  80   }
  81
  82   using WebSocketDispatcherHost::num_pending_connections;
  83   using WebSocketDispatcherHost::num_failed_connections;
  84   using WebSocketDispatcherHost::num_succeeded_connections;
  85
  86  private:
  87   ~TestingWebSocketDispatcherHost() override {}
  88 };
  89
  90 class WebSocketDispatcherHostTest : public ::testing::Test {
  91  public:
  92   WebSocketDispatcherHostTest()
  93       : next_routing_id_(123),
  94         weak_ptr_factory_(this) {
  95     dispatcher_host_ = new TestingWebSocketDispatcherHost(
  96         kMagicRenderProcessId,
  97         base::Bind(&WebSocketDispatcherHostTest::OnGetRequestContext,
  98                    base::Unretained(this)),
  99         base::Bind(&WebSocketDispatcherHostTest::CreateWebSocketHost,
 100                    base::Unretained(this)));
 101   }
 102
 103   ~WebSocketDispatcherHostTest() override {
 104     // We need to invalidate the issued WeakPtrs at the beginning of the
 105     // destructor in order not to access destructed member variables.
 106     weak_ptr_factory_.InvalidateWeakPtrs();
 107   }
 108
 109   void GoAway(int routing_id) {
 110     gone_hosts_.push_back(routing_id);
 111   }
 112
 113   base::WeakPtr<WebSocketDispatcherHostTest> GetWeakPtr() {
 114     return weak_ptr_factory_.GetWeakPtr();
 115   }
 116
 117  protected:
 118   // Adds |n| connections. Returns true if succeeded.
 119   bool AddMultipleChannels(int number_of_channels) {
 120     GURL socket_url("ws://example.com/test");
 121     std::vector<std::string> requested_protocols;
 122     url::Origin origin(GURL("http://example.com"));
 123     int render_frame_id = -3;
 124
 125     for (int i = 0; i < number_of_channels; ++i) {
 126       int routing_id = next_routing_id_++;
 127       WebSocketHostMsg_AddChannelRequest message(
 128           routing_id,
 129           socket_url,
 130           requested_protocols,
 131           origin,
 132           render_frame_id);
 133       if (!dispatcher_host_->OnMessageReceived(message))
 134         return false;
 135     }
 136
 137     return true;
 138   }
 139
 140   // Adds and cancels |n| connections. Returns true if succeeded.
 141   bool AddAndCancelMultipleChannels(int number_of_channels) {
 142     GURL socket_url("ws://example.com/test");
 143     std::vector<std::string> requested_protocols;
 144     url::Origin origin(GURL("http://example.com"));
 145     int render_frame_id = -3;
 146
 147     for (int i = 0; i < number_of_channels; ++i) {
 148       int routing_id = next_routing_id_++;
 149       WebSocketHostMsg_AddChannelRequest messageAddChannelRequest(
 150           routing_id,
 151           socket_url,
 152           requested_protocols,
 153           origin,
 154           render_frame_id);
 155       if (!dispatcher_host_->OnMessageReceived(messageAddChannelRequest))
 156         return false;
 157
 158       WebSocketMsg_DropChannel messageDropChannel(
 159           routing_id, false, net::kWebSocketErrorAbnormalClosure, "");
 160       if (!dispatcher_host_->OnMessageReceived(messageDropChannel))
 161         return false;
 162     }
 163
 164     return true;
 165   }
 166
 167   scoped_refptr<TestingWebSocketDispatcherHost> dispatcher_host_;
 168
 169   // Stores allocated MockWebSocketHost instances. Doesn't take ownership of
 170   // them.
 171   std::vector<MockWebSocketHost*> mock_hosts_;
 172   std::vector<int> gone_hosts_;
 173
 174  private:
 175   net::URLRequestContext* OnGetRequestContext() {
 176     return NULL;
 177   }
 178
 179   WebSocketHost* CreateWebSocketHost(int routing_id, base::TimeDelta delay) {
 180     MockWebSocketHost* host = new MockWebSocketHost(
 181         routing_id, dispatcher_host_.get(), NULL, delay, this);
 182     mock_hosts_.push_back(host);
 183     return host;
 184   }
 185
 186   base::MessageLoop message_loop_;
 187
 188   int next_routing_id_;
 189
 190   base::WeakPtrFactory<WebSocketDispatcherHostTest> weak_ptr_factory_;
 191 };
 192
 193 MockWebSocketHost::MockWebSocketHost(
 194     int routing_id,
 195     WebSocketDispatcherHost* dispatcher,
 196     net::URLRequestContext* url_request_context,
 197     base::TimeDelta delay,
 198     WebSocketDispatcherHostTest* owner)
 199     : WebSocketHost(routing_id, dispatcher, url_request_context, delay),
 200       owner_(owner->GetWeakPtr()),
 201       delay_(delay) {}
 202
 203 void MockWebSocketHost::GoAway() {
 204   if (owner_)
 205     owner_->GoAway(routing_id());
 206 }
 207
 208 TEST_F(WebSocketDispatcherHostTest, Construct) {
 209   // Do nothing.
 210 }
 211
 212 TEST_F(WebSocketDispatcherHostTest, UnrelatedMessage) {
 213   IPC::Message message;
 214   EXPECT_FALSE(dispatcher_host_->OnMessageReceived(message));
 215 }
 216
 217 TEST_F(WebSocketDispatcherHostTest, RenderProcessIdGetter) {
 218   EXPECT_EQ(kMagicRenderProcessId, dispatcher_host_->render_process_id());
 219 }
 220
 221 TEST_F(WebSocketDispatcherHostTest, AddChannelRequest) {
 222   int routing_id = 123;
 223   GURL socket_url("ws://example.com/test");
 224   std::vector<std::string> requested_protocols;
 225   requested_protocols.push_back("hello");
 226   url::Origin origin(GURL("http://example.com"));
 227   int render_frame_id = -2;
 228   WebSocketHostMsg_AddChannelRequest message(
 229       routing_id, socket_url, requested_protocols, origin, render_frame_id);
 230
 231   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message));
 232
 233   ASSERT_EQ(1U, mock_hosts_.size());
 234   MockWebSocketHost* host = mock_hosts_[0];
 235
 236   ASSERT_EQ(1U, host->received_messages_.size());
 237   const IPC::Message& forwarded_message = host->received_messages_[0];
 238   EXPECT_EQ(WebSocketHostMsg_AddChannelRequest::ID, forwarded_message.type());
 239   EXPECT_EQ(routing_id, forwarded_message.routing_id());
 240 }
 241
 242 TEST_F(WebSocketDispatcherHostTest, SendFrameButNoHostYet) {
 243   int routing_id = 123;
 244   std::vector<char> data;
 245   WebSocketMsg_SendFrame message(
 246       routing_id, true, WEB_SOCKET_MESSAGE_TYPE_TEXT, data);
 247
 248   // Expected to be ignored.
 249   EXPECT_TRUE(dispatcher_host_->OnMessageReceived(message));
 250
 251   EXPECT_EQ(0U, mock_hosts_.size());
 252 }
 253
 254 TEST_F(WebSocketDispatcherHostTest, SendFrame) {
 255   int routing_id = 123;
 256
 257   GURL socket_url("ws://example.com/test");
 258   std::vector<std::string> requested_protocols;
 259   requested_protocols.push_back("hello");
 260   url::Origin origin(GURL("http://example.com"));
 261   int render_frame_id = -2;
 262   WebSocketHostMsg_AddChannelRequest add_channel_message(
 263       routing_id, socket_url, requested_protocols, origin, render_frame_id);
 264
 265   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(add_channel_message));
 266
 267   std::vector<char> data;
 268   WebSocketMsg_SendFrame send_frame_message(
 269       routing_id, true, WEB_SOCKET_MESSAGE_TYPE_TEXT, data);
 270
 271   EXPECT_TRUE(dispatcher_host_->OnMessageReceived(send_frame_message));
 272
 273   ASSERT_EQ(1U, mock_hosts_.size());
 274   MockWebSocketHost* host = mock_hosts_[0];
 275
 276   ASSERT_EQ(2U, host->received_messages_.size());
 277   {
 278     const IPC::Message& forwarded_message = host->received_messages_[0];
 279     EXPECT_EQ(WebSocketHostMsg_AddChannelRequest::ID, forwarded_message.type());
 280     EXPECT_EQ(routing_id, forwarded_message.routing_id());
 281   }
 282   {
 283     const IPC::Message& forwarded_message = host->received_messages_[1];
 284     EXPECT_EQ(WebSocketMsg_SendFrame::ID, forwarded_message.type());
 285     EXPECT_EQ(routing_id, forwarded_message.routing_id());
 286   }
 287 }
 288
 289 TEST_F(WebSocketDispatcherHostTest, Destruct) {
 290   WebSocketHostMsg_AddChannelRequest message1(
 291       123, GURL("ws://example.com/test"), std::vector<std::string>(),
 292       url::Origin(GURL("http://example.com")), -1);
 293   WebSocketHostMsg_AddChannelRequest message2(
 294       456, GURL("ws://example.com/test2"), std::vector<std::string>(),
 295       url::Origin(GURL("http://example.com")), -1);
 296
 297   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message1));
 298   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message2));
 299
 300   ASSERT_EQ(2u, mock_hosts_.size());
 301
 302   mock_hosts_.clear();
 303   dispatcher_host_ = NULL;
 304
 305   ASSERT_EQ(2u, gone_hosts_.size());
 306   // The gone_hosts_ ordering is not predictable because it depends on the
 307   // hash_map ordering.
 308   std::sort(gone_hosts_.begin(), gone_hosts_.end());
 309   EXPECT_EQ(123, gone_hosts_[0]);
 310   EXPECT_EQ(456, gone_hosts_[1]);
 311 }
 312
 313 TEST_F(WebSocketDispatcherHostTest, DelayFor4thPendingConnectionIsZero) {
 314   ASSERT_TRUE(AddMultipleChannels(4));
 315
 316   EXPECT_EQ(4, dispatcher_host_->num_pending_connections());
 317   EXPECT_EQ(0, dispatcher_host_->num_failed_connections());
 318   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 319
 320   ASSERT_EQ(4U, mock_hosts_.size());
 321   EXPECT_EQ(base::TimeDelta(), mock_hosts_[3]->delay_);
 322 }
 323
 324 TEST_F(WebSocketDispatcherHostTest, DelayFor8thPendingConnectionIsNonZero) {
 325   ASSERT_TRUE(AddMultipleChannels(8));
 326
 327   EXPECT_EQ(8, dispatcher_host_->num_pending_connections());
 328   EXPECT_EQ(0, dispatcher_host_->num_failed_connections());
 329   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 330
 331   ASSERT_EQ(8U, mock_hosts_.size());
 332   EXPECT_LT(base::TimeDelta(), mock_hosts_[7]->delay_);
 333 }
 334
 335 TEST_F(WebSocketDispatcherHostTest, DelayFor17thPendingConnection) {
 336   ASSERT_TRUE(AddMultipleChannels(17));
 337
 338   EXPECT_EQ(17, dispatcher_host_->num_pending_connections());
 339   EXPECT_EQ(0, dispatcher_host_->num_failed_connections());
 340   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 341
 342   ASSERT_EQ(17U, mock_hosts_.size());
 343   EXPECT_LE(base::TimeDelta::FromMilliseconds(1000), mock_hosts_[16]->delay_);
 344   EXPECT_GE(base::TimeDelta::FromMilliseconds(5000), mock_hosts_[16]->delay_);
 345 }
 346
 347 // The 256th connection is rejected by per-renderer WebSocket throttling.
 348 // This is not counted as a failure.
 349 TEST_F(WebSocketDispatcherHostTest, Rejects256thPendingConnection) {
 350   ASSERT_TRUE(AddMultipleChannels(256));
 351
 352   EXPECT_EQ(255, dispatcher_host_->num_pending_connections());
 353   EXPECT_EQ(0, dispatcher_host_->num_failed_connections());
 354   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 355
 356   ASSERT_EQ(255U, mock_hosts_.size());
 357 }
 358
 359 TEST_F(WebSocketDispatcherHostTest, DelayIsZeroAfter3FailedConnections) {
 360   ASSERT_TRUE(AddAndCancelMultipleChannels(3));
 361
 362   EXPECT_EQ(0, dispatcher_host_->num_pending_connections());
 363   EXPECT_EQ(3, dispatcher_host_->num_failed_connections());
 364   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 365
 366   ASSERT_TRUE(AddMultipleChannels(1));
 367
 368   ASSERT_EQ(4U, mock_hosts_.size());
 369   EXPECT_EQ(base::TimeDelta(), mock_hosts_[3]->delay_);
 370 }
 371
 372 TEST_F(WebSocketDispatcherHostTest, DelayIsNonZeroAfter7FailedConnections) {
 373   ASSERT_TRUE(AddAndCancelMultipleChannels(7));
 374
 375   EXPECT_EQ(0, dispatcher_host_->num_pending_connections());
 376   EXPECT_EQ(7, dispatcher_host_->num_failed_connections());
 377   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 378
 379   ASSERT_TRUE(AddMultipleChannels(1));
 380
 381   ASSERT_EQ(8U, mock_hosts_.size());
 382   EXPECT_LT(base::TimeDelta(), mock_hosts_[7]->delay_);
 383 }
 384
 385 TEST_F(WebSocketDispatcherHostTest, DelayAfter16FailedConnections) {
 386   ASSERT_TRUE(AddAndCancelMultipleChannels(16));
 387
 388   EXPECT_EQ(0, dispatcher_host_->num_pending_connections());
 389   EXPECT_EQ(16, dispatcher_host_->num_failed_connections());
 390   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 391
 392   ASSERT_TRUE(AddMultipleChannels(1));
 393
 394   ASSERT_EQ(17U, mock_hosts_.size());
 395   EXPECT_LE(base::TimeDelta::FromMilliseconds(1000), mock_hosts_[16]->delay_);
 396   EXPECT_GE(base::TimeDelta::FromMilliseconds(5000), mock_hosts_[16]->delay_);
 397 }
 398
 399 TEST_F(WebSocketDispatcherHostTest, NotRejectedAfter255FailedConnections) {
 400   ASSERT_TRUE(AddAndCancelMultipleChannels(255));
 401
 402   EXPECT_EQ(0, dispatcher_host_->num_pending_connections());
 403   EXPECT_EQ(255, dispatcher_host_->num_failed_connections());
 404   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 405
 406   ASSERT_TRUE(AddMultipleChannels(1));
 407
 408   EXPECT_EQ(1, dispatcher_host_->num_pending_connections());
 409   EXPECT_EQ(255, dispatcher_host_->num_failed_connections());
 410   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 411 }
 412
 413 // This is a regression test for https://crrev.com/998173003/.
 414 TEST_F(WebSocketDispatcherHostTest, InvalidScheme) {
 415   int routing_id = 123;
 416   GURL socket_url("http://example.com/test");
 417   std::vector<std::string> requested_protocols;
 418   requested_protocols.push_back("hello");
 419   url::Origin origin(GURL("http://example.com"));
 420   int render_frame_id = -2;
 421   WebSocketHostMsg_AddChannelRequest message(
 422       routing_id, socket_url, requested_protocols, origin, render_frame_id);
 423
 424   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message));
 425
 426   ASSERT_EQ(1U, mock_hosts_.size());
 427   MockWebSocketHost* host = mock_hosts_[0];
 428
 429   // Tests that WebSocketHost::OnMessageReceived() doesn't cause a crash and
 430   // the connection with an invalid scheme fails here.
 431   // We call WebSocketHost::OnMessageReceived() here explicitly because
 432   // MockWebSocketHost does not call WebSocketHost::OnMessageReceived() for
 433   // WebSocketHostMsg_AddChannelRequest.
 434   host->WebSocketHost::OnMessageReceived(message);
 435
 436   EXPECT_EQ(0, dispatcher_host_->num_pending_connections());
 437   EXPECT_EQ(1, dispatcher_host_->num_failed_connections());
 438   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 439 }
 440
 441 }  // namespace
 442 }  // namespace content