[Devtools] Allow User-Agent header override for Websockets

content/browser/renderer_host/websocket_dispatcher_host_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 "content/browser/renderer_host/websocket_dispatcher_host.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 111 matching lines @@
     url::Origin origin(GURL("http://example.com"));
     int render_frame_id = -3;
 
     for (int i = 0; i < number_of_channels; ++i) {
       int routing_id = next_routing_id_++;
       WebSocketHostMsg_AddChannelRequest message(
           routing_id,
           socket_url,
           requested_protocols,
           origin,
+          "",
           render_frame_id);
       if (!dispatcher_host_->OnMessageReceived(message))
         return false;
     }
 
     return true;
   }
 
   // Adds and cancels |n| connections. Returns true if succeeded.
   bool AddAndCancelMultipleChannels(int number_of_channels) {
     GURL socket_url("ws://example.com/test");
     std::vector<std::string> requested_protocols;
     url::Origin origin(GURL("http://example.com"));
     int render_frame_id = -3;
 
     for (int i = 0; i < number_of_channels; ++i) {
       int routing_id = next_routing_id_++;
       WebSocketHostMsg_AddChannelRequest messageAddChannelRequest(
           routing_id,
           socket_url,
           requested_protocols,
           origin,
+          "",
           render_frame_id);
       if (!dispatcher_host_->OnMessageReceived(messageAddChannelRequest))
         return false;
 
       WebSocketMsg_DropChannel messageDropChannel(
           routing_id, false, net::kWebSocketErrorAbnormalClosure, "");
       if (!dispatcher_host_->OnMessageReceived(messageDropChannel))
         return false;
     }
 
@@ skipping 55 matching lines @@
 }
 
 TEST_F(WebSocketDispatcherHostTest, AddChannelRequest) {
   int routing_id = 123;
   GURL socket_url("ws://example.com/test");
   std::vector<std::string> requested_protocols;
   requested_protocols.push_back("hello");
   url::Origin origin(GURL("http://example.com"));
   int render_frame_id = -2;
   WebSocketHostMsg_AddChannelRequest message(
-      routing_id, socket_url, requested_protocols, origin, render_frame_id);
+      routing_id, socket_url, requested_protocols, origin, "", render_frame_id);
 
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message));
 
   ASSERT_EQ(1U, mock_hosts_.size());
   MockWebSocketHost* host = mock_hosts_[0];
 
   ASSERT_EQ(1U, host->received_messages_.size());
   const IPC::Message& forwarded_message = host->received_messages_[0];
   EXPECT_EQ(WebSocketHostMsg_AddChannelRequest::ID, forwarded_message.type());
   EXPECT_EQ(routing_id, forwarded_message.routing_id());
@@ skipping 13 matching lines @@
 
 TEST_F(WebSocketDispatcherHostTest, SendFrame) {
   int routing_id = 123;
 
   GURL socket_url("ws://example.com/test");
   std::vector<std::string> requested_protocols;
   requested_protocols.push_back("hello");
   url::Origin origin(GURL("http://example.com"));
   int render_frame_id = -2;
   WebSocketHostMsg_AddChannelRequest add_channel_message(
-      routing_id, socket_url, requested_protocols, origin, render_frame_id);
+      routing_id, socket_url, requested_protocols, origin, "", render_frame_id);
 
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(add_channel_message));
 
   std::vector<char> data;
   WebSocketMsg_SendFrame send_frame_message(
       routing_id, true, WEB_SOCKET_MESSAGE_TYPE_TEXT, data);
 
   EXPECT_TRUE(dispatcher_host_->OnMessageReceived(send_frame_message));
 
   ASSERT_EQ(1U, mock_hosts_.size());
   MockWebSocketHost* host = mock_hosts_[0];
 
   ASSERT_EQ(2U, host->received_messages_.size());
   {
     const IPC::Message& forwarded_message = host->received_messages_[0];
     EXPECT_EQ(WebSocketHostMsg_AddChannelRequest::ID, forwarded_message.type());
     EXPECT_EQ(routing_id, forwarded_message.routing_id());
   }
   {
     const IPC::Message& forwarded_message = host->received_messages_[1];
     EXPECT_EQ(WebSocketMsg_SendFrame::ID, forwarded_message.type());
     EXPECT_EQ(routing_id, forwarded_message.routing_id());
   }
 }
 
 TEST_F(WebSocketDispatcherHostTest, Destruct) {
   WebSocketHostMsg_AddChannelRequest message1(
       123, GURL("ws://example.com/test"), std::vector<std::string>(),
-      url::Origin(GURL("http://example.com")), -1);
+      url::Origin(GURL("http://example.com")), "", -1);
   WebSocketHostMsg_AddChannelRequest message2(
       456, GURL("ws://example.com/test2"), std::vector<std::string>(),
-      url::Origin(GURL("http://example.com")), -1);
+      url::Origin(GURL("http://example.com")), "", -1);
 
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message1));
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message2));
 
   ASSERT_EQ(2u, mock_hosts_.size());
 
   mock_hosts_.clear();
   dispatcher_host_ = NULL;
 
   ASSERT_EQ(2u, gone_hosts_.size());
@@ skipping 106 matching lines @@
 
 // This is a regression test for https://crrev.com/998173003/.
 TEST_F(WebSocketDispatcherHostTest, InvalidScheme) {
   int routing_id = 123;
   GURL socket_url("http://example.com/test");
   std::vector<std::string> requested_protocols;
   requested_protocols.push_back("hello");
   url::Origin origin(GURL("http://example.com"));
   int render_frame_id = -2;
   WebSocketHostMsg_AddChannelRequest message(
-      routing_id, socket_url, requested_protocols, origin, render_frame_id);
+      routing_id, socket_url, requested_protocols, origin, "", render_frame_id);
 
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message));
 
   ASSERT_EQ(1U, mock_hosts_.size());
   MockWebSocketHost* host = mock_hosts_[0];
 
   // Tests that WebSocketHost::OnMessageReceived() doesn't cause a crash and
   // the connection with an invalid scheme fails here.
   // We call WebSocketHost::OnMessageReceived() here explicitly because
   // MockWebSocketHost does not call WebSocketHost::OnMessageReceived() for
   // WebSocketHostMsg_AddChannelRequest.
   host->WebSocketHost::OnMessageReceived(message);
 
   EXPECT_EQ(0, dispatcher_host_->num_pending_connections());
   EXPECT_EQ(1, dispatcher_host_->num_failed_connections());
   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 }
 
 }  // namespace
 }  // namespace content