Delegate WebSocket message handlers to the loading task runner

content/child/websocket_dispatcher.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/child/websocket_dispatcher.h"
 
 #include <stdint.h>
 #include <map>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "content/child/websocket_bridge.h"
 #include "content/common/websocket_messages.h"
 #include "ipc/ipc_message.h"
 #include "url/gurl.h"
 
 namespace content {
 
-WebSocketDispatcher::WebSocketDispatcher() : channel_id_max_(0) {}
+WebSocketDispatcher::WebSocketDispatcher() : channel_id_max_(0) {
+}
 
 WebSocketDispatcher::~WebSocketDispatcher() {}
 
 int WebSocketDispatcher::AddBridge(WebSocketBridge* bridge) {
   ++channel_id_max_;
   bridges_.insert(std::make_pair(channel_id_max_, bridge));
   return channel_id_max_;
 }
 
 void WebSocketDispatcher::RemoveBridge(int channel_id) {
@@ skipping 13 matching lines @@
     case WebSocketMsg_NotifyFailure::ID:
     case WebSocketMsg_SendFrame::ID:
     case WebSocketMsg_FlowControl::ID:
     case WebSocketMsg_DropChannel::ID:
     case WebSocketMsg_NotifyClosing::ID:
       break;
     default:
       return false;
   }
 
+  loading_task_runner_->PostTask(FROM_HERE,

[Sami, 2016/05/23 09:56:07]

I guess what will end up happening here is that OnMessageReceived() will first
get called on the main thread and schedule this PostTask, which will also happen
on the main thread. Depending on how busy the main thread is this could add
significant delays to WebSocket messages.

A better alternative would be to turn WebSocketDispatcher into a IPC message
filter and have it PostTask to the loading task queue from the IO thread. I'm
not sure if we need to do that refactoring now, but I would suggest giving it
some thought (and adding a TODO at least).

+      base::Bind(&WebSocketDispatcher::OnMessageReceivedOnLoadingTaskRunner,
+                 base::Unretained(this), msg));
+  return true;
+}
+
+void WebSocketDispatcher::SetLoadingTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner) {
+  loading_task_runner_ = loading_task_runner;
+}
+
+void WebSocketDispatcher::OnMessageReceivedOnLoadingTaskRunner(
+    IPC::Message msg) {
   WebSocketBridge* bridge = GetBridge(msg.routing_id(), msg.type());
-  if (!bridge)
-    return true;
-  return bridge->OnMessageReceived(msg);
+  if (bridge)
+    bridge->OnMessageReceived(msg);
 }
 
 WebSocketBridge* WebSocketDispatcher::GetBridge(int channel_id, uint32_t type) {
   std::map<int, WebSocketBridge*>::iterator iter = bridges_.find(channel_id);
   if (iter == bridges_.end()) {
     DVLOG(1) << "No bridge for channel_id=" << channel_id
              << ", type=" << type;
     return NULL;
   }
   return iter->second;
 }
 
 }  // namespace content