[WebSocket] Send a close frame when the renderer process is gone.

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"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/renderer_host/websocket_host.h"
 #include "content/common/websocket.h"
 #include "content/common/websocket_messages.h"
 #include "ipc/ipc_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace content {
 namespace {
 
 // This number is unlikely to occur by chance.
 static const int kMagicRenderProcessId = 506116062;
 
+class WebSocketDispatcherHostTest;
+
 // A mock of WebsocketHost which records received messages.
 class MockWebSocketHost : public WebSocketHost {
  public:
   MockWebSocketHost(int routing_id,
                     WebSocketDispatcherHost* dispatcher,
-                    net::URLRequestContext* url_request_context)
-      : WebSocketHost(routing_id, dispatcher, url_request_context) {
+                    net::URLRequestContext* url_request_context,
+                    WebSocketDispatcherHostTest* owner)
+      : WebSocketHost(routing_id, dispatcher, url_request_context),
+        owner_(owner) {
   }
 
   virtual ~MockWebSocketHost() {}
 
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE{
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     received_messages_.push_back(message);
     return true;
   }
 
+  virtual void GoAway() OVERRIDE;
+
   std::vector<IPC::Message> received_messages_;
+  WebSocketDispatcherHostTest* owner_;
 };
 
 class WebSocketDispatcherHostTest : public ::testing::Test {
  public:
-  WebSocketDispatcherHostTest() {
+  WebSocketDispatcherHostTest()
+      : on_destruction_(false) {
     dispatcher_host_ = new WebSocketDispatcherHost(
         kMagicRenderProcessId,
         base::Bind(&WebSocketDispatcherHostTest::OnGetRequestContext,
                    base::Unretained(this)),
         base::Bind(&WebSocketDispatcherHostTest::CreateWebSocketHost,
                    base::Unretained(this)));
   }
 
-  virtual ~WebSocketDispatcherHostTest() {}
+  virtual ~WebSocketDispatcherHostTest() {
+    on_destruction_ = true;

[Adam Rice, 2014/07/28 04:29:22]

This doesn't seem safe to me. How about changing the MockWebSocketHost owner_
pointer to a WeakPtr, and checking it is non-null before calling
owner_->GoAway() ?

[yhirano, 2014/07/28 05:08:52]

Done.

+  }
+
+  void GoAway(int routing_id) {
+    if (!on_destruction_)
+      gone_hosts_.push_back(routing_id);
+  }
 
  protected:
   scoped_refptr<WebSocketDispatcherHost> dispatcher_host_;
 
   // Stores allocated MockWebSocketHost instances. Doesn't take ownership of
   // them.
   std::vector<MockWebSocketHost*> mock_hosts_;
+  std::vector<int> gone_hosts_;
+  bool on_destruction_;
 
  private:
   net::URLRequestContext* OnGetRequestContext() {
     return NULL;
   }
 
   WebSocketHost* CreateWebSocketHost(int routing_id) {
     MockWebSocketHost* host =
-        new MockWebSocketHost(routing_id, dispatcher_host_.get(), NULL);
+        new MockWebSocketHost(routing_id, dispatcher_host_.get(), NULL, this);
     mock_hosts_.push_back(host);
     return host;
   }
 };
 
+void MockWebSocketHost::GoAway() {
+  owner_->GoAway(routing_id());
+}
+
 TEST_F(WebSocketDispatcherHostTest, Construct) {
   // Do nothing.
 }
 
 TEST_F(WebSocketDispatcherHostTest, UnrelatedMessage) {
   IPC::Message message;
   EXPECT_FALSE(dispatcher_host_->OnMessageReceived(message));
 }
 
 TEST_F(WebSocketDispatcherHostTest, RenderProcessIdGetter) {
@@ skipping 61 matching lines @@
     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("http://example.com"), -1);
+  WebSocketHostMsg_AddChannelRequest message2(
+      456, GURL("ws://example.com/test2"), std::vector<std::string>(),
+      url::Origin("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());
+  // The gone_hosts_ ordering is not predictable because it depends on the
+  // hash_map ordering.
+  std::sort(gone_hosts_.begin(), gone_hosts_.end());
+  EXPECT_EQ(123, gone_hosts_[0]);
+  EXPECT_EQ(456, gone_hosts_[1]);
+}
+
 }  // namespace
 }  // namespace content