Switch on use_new_wrapper_types mode for content/common.

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 156 matching lines @@
 ChannelState WebSocketImpl::WebSocketEventHandler::OnDataFrame(
     bool fin,
     net::WebSocketFrameHeader::OpCode type,
     const std::vector<char>& data) {
   DVLOG(3) << "WebSocketEventHandler::OnDataFrame @"
            << reinterpret_cast<void*>(this)
            << " fin=" << fin
            << " type=" << type << " data is " << data.size() << " bytes";
 
   // TODO(darin): Avoid this copy.
-  mojo::Array<uint8_t> data_to_pass(data.size());
+  std::vector<uint8_t> data_to_pass(data.size());
   std::copy(data.begin(), data.end(), data_to_pass.begin());
 
-  impl_->client_->OnDataFrame(fin, OpCodeToMessageType(type),
-                              std::move(data_to_pass));
+  impl_->client_->OnDataFrame(fin, OpCodeToMessageType(type), data_to_pass);
 
   return net::WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketImpl::WebSocketEventHandler::OnClosingHandshake() {
   DVLOG(3) << "WebSocketEventHandler::OnClosingHandshake @"
            << reinterpret_cast<void*>(this);
 
   impl_->client_->OnClosingHandshake();
 
@@ skipping 175 matching lines @@
 
 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,
+    const std::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());
-
   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,
+                              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