[not for commit] try out fix with darin's cl.

content/browser/websockets/websocket_impl.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/websockets/websocket_impl.h"
 
 #include <inttypes.h>
 
 #include <utility>
 
@@ skipping 25 matching lines @@
 #include "net/websockets/websocket_frame.h"  // for WebSocketFrameHeader::OpCode
 #include "net/websockets/websocket_handshake_request_info.h"
 #include "net/websockets/websocket_handshake_response_info.h"
 #include "url/origin.h"
 
 namespace content {
 namespace {
 
 typedef net::WebSocketEventInterface::ChannelState ChannelState;
 
-// Convert a mojom::WebSocketMessageType to a
+// Convert a blink::mojom::WebSocketMessageType to a
 // net::WebSocketFrameHeader::OpCode
 net::WebSocketFrameHeader::OpCode MessageTypeToOpCode(
-    mojom::WebSocketMessageType type) {
-  DCHECK(type == mojom::WebSocketMessageType::CONTINUATION ||
-         type == mojom::WebSocketMessageType::TEXT ||
-         type == mojom::WebSocketMessageType::BINARY);
+    blink::mojom::WebSocketMessageType type) {
+  DCHECK(type == blink::mojom::WebSocketMessageType::CONTINUATION ||
+         type == blink::mojom::WebSocketMessageType::TEXT ||
+         type == blink::mojom::WebSocketMessageType::BINARY);
   typedef net::WebSocketFrameHeader::OpCode OpCode;
   // These compile asserts verify that the same underlying values are used for
   // both types, so we can simply cast between them.
   static_assert(
-      static_cast<OpCode>(mojom::WebSocketMessageType::CONTINUATION) ==
+      static_cast<OpCode>(blink::mojom::WebSocketMessageType::CONTINUATION) ==
           net::WebSocketFrameHeader::kOpCodeContinuation,
       "enum values must match for opcode continuation");
   static_assert(
-      static_cast<OpCode>(mojom::WebSocketMessageType::TEXT) ==
+      static_cast<OpCode>(blink::mojom::WebSocketMessageType::TEXT) ==
           net::WebSocketFrameHeader::kOpCodeText,
       "enum values must match for opcode text");
   static_assert(
-      static_cast<OpCode>(mojom::WebSocketMessageType::BINARY) ==
+      static_cast<OpCode>(blink::mojom::WebSocketMessageType::BINARY) ==
           net::WebSocketFrameHeader::kOpCodeBinary,
       "enum values must match for opcode binary");
   return static_cast<OpCode>(type);
 }
 
-mojom::WebSocketMessageType OpCodeToMessageType(
+blink::mojom::WebSocketMessageType OpCodeToMessageType(
     net::WebSocketFrameHeader::OpCode opCode) {
   DCHECK(opCode == net::WebSocketFrameHeader::kOpCodeContinuation ||
          opCode == net::WebSocketFrameHeader::kOpCodeText ||
          opCode == net::WebSocketFrameHeader::kOpCodeBinary);
   // This cast is guaranteed valid by the static_assert() statements above.
-  return static_cast<mojom::WebSocketMessageType>(opCode);
+  return static_cast<blink::mojom::WebSocketMessageType>(opCode);
 }
 
 }  // namespace
 
 // Implementation of net::WebSocketEventInterface. Receives events from our
 // WebSocketChannel object.
 class WebSocketImpl::WebSocketEventHandler final
     : public net::WebSocketEventInterface {
  public:
   explicit WebSocketEventHandler(WebSocketImpl* impl);
@@ skipping 150 matching lines @@
   bool should_send =
       ChildProcessSecurityPolicyImpl::GetInstance()->CanReadRawCookies(
           impl_->delegate_->GetClientProcessId());
 
   DVLOG(3) << "WebSocketEventHandler::OnStartOpeningHandshake @"
            << reinterpret_cast<void*>(this) << " should_send=" << should_send;
 
   if (!should_send)
     return WebSocketEventInterface::CHANNEL_ALIVE;
 
-  mojom::WebSocketHandshakeRequestPtr request_to_pass(
-      mojom::WebSocketHandshakeRequest::New());
+  blink::mojom::WebSocketHandshakeRequestPtr request_to_pass(
+      blink::mojom::WebSocketHandshakeRequest::New());
   request_to_pass->url.Swap(&request->url);
   net::HttpRequestHeaders::Iterator it(request->headers);
   while (it.GetNext()) {
-    mojom::HttpHeaderPtr header(mojom::HttpHeader::New());
+    blink::mojom::HttpHeaderPtr header(blink::mojom::HttpHeader::New());
     header->name = it.name();
     header->value = it.value();
     request_to_pass->headers.push_back(std::move(header));
   }
   request_to_pass->headers_text =
       base::StringPrintf("GET %s HTTP/1.1\r\n",
                          request_to_pass->url.spec().c_str()) +
       request->headers.ToString();
 
   impl_->client_->OnStartOpeningHandshake(std::move(request_to_pass));
 
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketImpl::WebSocketEventHandler::OnFinishOpeningHandshake(
     std::unique_ptr<net::WebSocketHandshakeResponseInfo> response) {
   bool should_send =
       ChildProcessSecurityPolicyImpl::GetInstance()->CanReadRawCookies(
           impl_->delegate_->GetClientProcessId());
 
   DVLOG(3) << "WebSocketEventHandler::OnFinishOpeningHandshake "
            << reinterpret_cast<void*>(this) << " should_send=" << should_send;
 
   if (!should_send)
     return WebSocketEventInterface::CHANNEL_ALIVE;
 
-  mojom::WebSocketHandshakeResponsePtr response_to_pass(
-      mojom::WebSocketHandshakeResponse::New());
+  blink::mojom::WebSocketHandshakeResponsePtr response_to_pass(
+      blink::mojom::WebSocketHandshakeResponse::New());
   response_to_pass->url.Swap(&response->url);
   response_to_pass->status_code = response->status_code;
   response_to_pass->status_text = response->status_text;
   size_t iter = 0;
   std::string name, value;
   while (response->headers->EnumerateHeaderLines(&iter, &name, &value)) {
-    mojom::HttpHeaderPtr header(mojom::HttpHeader::New());
+    blink::mojom::HttpHeaderPtr header(blink::mojom::HttpHeader::New());
     header->name = name;
     header->value = value;
     response_to_pass->headers.push_back(std::move(header));
   }
   response_to_pass->headers_text =
       net::HttpUtil::ConvertHeadersBackToHTTPResponse(
           response->headers->raw_headers());
 
   impl_->client_->OnFinishOpeningHandshake(std::move(response_to_pass));
 
@@ skipping 45 matching lines @@
 }
 
 void WebSocketImpl::WebSocketEventHandler::SSLErrorHandlerDelegate::
     ContinueSSLRequest() {
   DVLOG(3) << "SSLErrorHandlerDelegate::ContinueSSLRequest";
   callbacks_->ContinueSSLRequest();
 }
 
 WebSocketImpl::WebSocketImpl(
     Delegate* delegate,
-    mojom::WebSocketRequest request,
+    blink::mojom::WebSocketRequest request,
     int frame_id,
     base::TimeDelta delay)
     : delegate_(delegate),
       binding_(this, std::move(request)),
       delay_(delay),
       pending_flow_control_quota_(0),
       frame_id_(frame_id),
       handshake_succeeded_(false),
       weak_ptr_factory_(this) {
   binding_.set_connection_error_handler(
       base::Bind(&WebSocketImpl::OnConnectionError, base::Unretained(this)));
 }
 
 WebSocketImpl::~WebSocketImpl() {}
 
 void WebSocketImpl::GoAway() {
   StartClosingHandshake(static_cast<uint16_t>(net::kWebSocketErrorGoingAway),
                         "");
 }
 
 void WebSocketImpl::AddChannelRequest(
     const GURL& socket_url,
-    mojo::Array<mojo::String> requested_protocols_mojo,
+    const std::vector<std::string>& requested_protocols,
     const url::Origin& origin,
     const GURL& first_party_for_cookies,
-    const mojo::String& user_agent_override,
-    mojom::WebSocketClientPtr client) {
-  // Convert to STL types.
-  std::vector<std::string> requested_protocols(
-      requested_protocols_mojo.begin(),
-      requested_protocols_mojo.end());
-
+    const std::string& user_agent_override,
+    blink::mojom::WebSocketClientPtr client) {
   DVLOG(3) << "WebSocketImpl::AddChannelRequest @"
            << reinterpret_cast<void*>(this)
            << " socket_url=\"" << socket_url << "\" requested_protocols=\""
            << base::JoinString(requested_protocols, ", ")
            << "\" origin=\"" << origin
            << "\" first_party_for_cookies=\"" << first_party_for_cookies
            << "\" user_agent_override=\"" << user_agent_override
            << "\"";
 
   if (client_ || !client) {
@@ skipping 16 matching lines @@
                    origin,
                    first_party_for_cookies,
                    user_agent_override),
         delay_);
   } else {
     AddChannel(socket_url, requested_protocols, origin, first_party_for_cookies,
                user_agent_override);
   }
 }
 
-void WebSocketImpl::SendFrame(bool fin, mojom::WebSocketMessageType type,
-                              mojo::Array<uint8_t> data) {
+void WebSocketImpl::SendFrame(bool fin, blink::mojom::WebSocketMessageType type,
+                              const std::vector<uint8_t>& data) {
   DVLOG(3) << "WebSocketImpl::SendFrame @"
            << reinterpret_cast<void*>(this) << " fin=" << fin
            << " type=" << type << " data is " << data.size() << " bytes";
 
   if (!channel_) {
     // The client should not be sending us frames until after we've informed
     // it that the channel has been opened (OnAddChannelResponse).
     if (handshake_succeeded_) {
       DVLOG(1) << "Dropping frame sent to closed websocket";
     } else {
@@ skipping 20 matching lines @@
     // per-renderer WebSocket throttling.
     // SendFlowControl() is called after WebSocketChannel is created.
     pending_flow_control_quota_ += quota;
     return;
   }
 
   ignore_result(channel_->SendFlowControl(quota));
 }
 
 void WebSocketImpl::StartClosingHandshake(uint16_t code,
-                                          const mojo::String& reason) {
+                                          const std::string& reason) {
   DVLOG(3) << "WebSocketImpl::StartClosingHandshake @"
            << reinterpret_cast<void*>(this)
            << " code=" << code << " reason=\"" << reason << "\"";
 
   if (!channel_) {
     // WebSocketChannel is not yet created due to the delay introduced by
     // per-renderer WebSocket throttling.
     if (client_)
       client_->OnDropChannel(false, net::kWebSocketErrorAbnormalClosure, "");
     return;
@@ skipping 51 matching lines @@
                                             net::HttpRequestHeaders::kUserAgent,
                                             user_agent_override.c_str());
   }
   channel_->SendAddChannelRequest(socket_url, requested_protocols, origin,
                                   first_party_for_cookies, additional_headers);
   if (quota > 0)
     SendFlowControl(quota);
 }
 
 }  // namespace content