Revert of [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,
-                    WebSocketDispatcherHostTest* owner)
-      : WebSocketHost(routing_id, dispatcher, url_request_context),
-        owner_(owner) {
+                    net::URLRequestContext* url_request_context)
+      : WebSocketHost(routing_id, dispatcher, url_request_context) {
   }
 
   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() {
     dispatcher_host_ = new WebSocketDispatcherHost(
         kMagicRenderProcessId,
         base::Bind(&WebSocketDispatcherHostTest::OnGetRequestContext,
                    base::Unretained(this)),
         base::Bind(&WebSocketDispatcherHostTest::CreateWebSocketHost,
                    base::Unretained(this)));
   }
 
   virtual ~WebSocketDispatcherHostTest() {}
 
-  void GoAway(int routing_id) {
-    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_;
 
  private:
   net::URLRequestContext* OnGetRequestContext() {
     return NULL;
   }
 
   WebSocketHost* CreateWebSocketHost(int routing_id) {
     MockWebSocketHost* host =
-        new MockWebSocketHost(routing_id, dispatcher_host_.get(), NULL, this);
+        new MockWebSocketHost(routing_id, dispatcher_host_.get(), NULL);
     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