Move WebSocketHandleImpl into Blink (take 2)

content/browser/websockets/websocket_manager_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 <algorithm>
 #include <memory>
 #include <vector>
 
 #include "content/browser/websockets/websocket_manager.h"
 #include "content/public/test/test_browser_thread_bundle.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 TestWebSocketImpl : public WebSocketImpl {
  public:
   TestWebSocketImpl(Delegate* delegate,
-                    mojom::WebSocketRequest request,
+                    blink::mojom::WebSocketRequest request,
                     int frame_id,
                     base::TimeDelta delay)
       : WebSocketImpl(delegate, std::move(request), frame_id, delay) {}
 
   base::TimeDelta delay() const { return delay_; }
 
   void SimulateConnectionError() {
     OnConnectionError();
   }
 };
@@ skipping 11 matching lines @@
     return num_pending_connections_;
   }
   int64_t num_failed_connections() const {
     return num_current_failed_connections_ + num_previous_failed_connections_;
   }
   int64_t num_succeeded_connections() const {
     return num_current_succeeded_connections_ +
            num_previous_succeeded_connections_;
   }
 
-  void DoCreateWebSocket(mojom::WebSocketRequest request) {
+  void DoCreateWebSocket(blink::mojom::WebSocketRequest request) {
     WebSocketManager::DoCreateWebSocket(MSG_ROUTING_NONE, std::move(request));
   }
 
  private:
   WebSocketImpl* CreateWebSocketImpl(WebSocketImpl::Delegate* delegate,
-                                     mojom::WebSocketRequest request,
+                                     blink::mojom::WebSocketRequest request,
                                      int frame_id,
                                      base::TimeDelta delay) override {
     TestWebSocketImpl* impl =
         new TestWebSocketImpl(delegate, std::move(request), frame_id, delay);
     // We keep a vector of sockets here to track their creation order.
     sockets_.push_back(impl);
     return impl;
   }
 
   void OnLostConnectionToClient(WebSocketImpl* impl) override {
@@ skipping 10 matching lines @@
 
 class WebSocketManagerTest : public ::testing::Test {
  public:
   WebSocketManagerTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {
     websocket_manager_.reset(new TestWebSocketManager());
   }
 
   void AddMultipleChannels(int number_of_channels) {
     for (int i = 0; i < number_of_channels; ++i) {
-      mojom::WebSocketPtr websocket;
+      blink::mojom::WebSocketPtr websocket;
       websocket_manager_->DoCreateWebSocket(mojo::GetProxy(&websocket));
     }
   }
 
   void AddAndCancelMultipleChannels(int number_of_channels) {
     for (int i = 0; i < number_of_channels; ++i) {
-      mojom::WebSocketPtr websocket;
+      blink::mojom::WebSocketPtr websocket;
       websocket_manager_->DoCreateWebSocket(mojo::GetProxy(&websocket));
       websocket_manager_->sockets().back()->SimulateConnectionError();
     }
   }
 
   TestWebSocketManager* websocket_manager() { return websocket_manager_.get(); }
 
  private:
   TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<TestWebSocketManager> websocket_manager_;
 };
 
 TEST_F(WebSocketManagerTest, Construct) {
   // Do nothing.
 }
 
 TEST_F(WebSocketManagerTest, CreateWebSocket) {
-  mojom::WebSocketPtr websocket;
+  blink::mojom::WebSocketPtr websocket;
 
   websocket_manager()->DoCreateWebSocket(mojo::GetProxy(&websocket));
 
   EXPECT_EQ(1U, websocket_manager()->sockets().size());
 }
 
 TEST_F(WebSocketManagerTest, SendFrameButNotConnectedYet) {
-  mojom::WebSocketPtr websocket;
+  blink::mojom::WebSocketPtr websocket;
 
   websocket_manager()->DoCreateWebSocket(mojo::GetProxy(&websocket));
 
   // This should not crash.
   mojo::Array<uint8_t> data;
   websocket->SendFrame(
-      true, mojom::WebSocketMessageType::TEXT, std::move(data));
+      true, blink::mojom::WebSocketMessageType::TEXT, std::move(data));
 }
 
 TEST_F(WebSocketManagerTest, DelayFor4thPendingConnectionIsZero) {
   AddMultipleChannels(4);
 
   EXPECT_EQ(4, websocket_manager()->num_pending_connections());
   EXPECT_EQ(0, websocket_manager()->num_failed_connections());
   EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
 
   ASSERT_EQ(4U, websocket_manager()->sockets().size());
@@ skipping 88 matching lines @@
 
   AddMultipleChannels(1);
 
   EXPECT_EQ(1, websocket_manager()->num_pending_connections());
   EXPECT_EQ(255, websocket_manager()->num_failed_connections());
   EXPECT_EQ(0, websocket_manager()->num_succeeded_connections());
 }
 
 }  // namespace
 }  // namespace content