Switch on use_new_wrapper_types mode for content/common.

content/renderer/websockethandle_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/renderer/websockethandle_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <string>
@@ skipping 65 matching lines @@
   // websocket_ to null.
   if (!did_initialize_)
     Initialize(blink::Platform::current()->interfaceProvider());
 
   DCHECK(websocket_);
 
   DCHECK(!client_);
   DCHECK(client);
   client_ = client;
 
-  mojo::Array<mojo::String> protocols_to_pass(protocols.size());
+  std::vector<std::string> protocols_to_pass(protocols.size());
   for (size_t i = 0; i < protocols.size(); ++i)
     protocols_to_pass[i] = protocols[i].utf8();
 
   websocket_->AddChannelRequest(
-      url,
-      std::move(protocols_to_pass),
-      origin,
-      first_party_for_cookies,
+      url, protocols_to_pass, origin, first_party_for_cookies,
       user_agent_override.latin1(),
       client_binding_.CreateInterfacePtrAndBind(task_runner_));
 }
 
 void WebSocketHandleImpl::send(bool fin,
                                WebSocketHandle::MessageType type,
                                const char* data,
                                size_t size) {
   DCHECK(websocket_);
 
@@ skipping 10 matching lines @@
       break;
     default:
       NOTREACHED();
       return;
   }
 
   DVLOG(1) << "WebSocketHandleImpl @" << reinterpret_cast<void*>(this)
            << " Send(" << fin << ", " << type_to_pass << ", "
            << "(data size = "  << size << "))";
 
-  mojo::Array<uint8_t> data_to_pass(size);
+  std::vector<uint8_t> data_to_pass(size);
   std::copy(data, data + size, data_to_pass.begin());
 
-  websocket_->SendFrame(fin, type_to_pass, std::move(data_to_pass));
+  websocket_->SendFrame(fin, type_to_pass, data_to_pass);
 }
 
 void WebSocketHandleImpl::flowControl(int64_t quota) {
   DCHECK(websocket_);
 
   DVLOG(1) << "WebSocketHandleImpl @" << reinterpret_cast<void*>(this)
            << " FlowControl(" << quota << ")";
 
   websocket_->SendFlowControl(quota);
 }
@@ skipping 26 matching lines @@
   // Our connection to the WebSocket was dropped. This could be due to
   // exceeding the maximum number of concurrent websockets from this process.
 
   // TODO(darin): This error message is overly specific. We don't know for sure
   // that this is the only reason we'd get here. This should be more generic or
   // we should figure out how to make it more specific.
   OnFailChannel("Error in connection establishment: "
                 "net::ERR_INSUFFICIENT_RESOURCES");
 }
 
-void WebSocketHandleImpl::OnFailChannel(const mojo::String& message) {
+void WebSocketHandleImpl::OnFailChannel(const std::string& message) {
   DVLOG(1) << "WebSocketHandleImpl @" << reinterpret_cast<void*>(this)
            << " OnFailChannel(" << message << ")";
 
   WebSocketHandleClient* client = client_;
   Disconnect();
   if (!client)
     return;
 
   client->didFail(this, WebString::fromUTF8(message));
   // |this| can be deleted here.
@@ skipping 27 matching lines @@
   for (size_t i = 0; i < response->headers.size(); ++i) {
     const mojom::HttpHeaderPtr& header = response->headers[i];
     response_to_pass.addHeaderField(WebString::fromLatin1(header->name),
                                     WebString::fromLatin1(header->value));
   }
   response_to_pass.setHeadersText(
       WebString::fromLatin1(response->headers_text));
   client_->didFinishOpeningHandshake(this, response_to_pass);
 }
 
-void WebSocketHandleImpl::OnAddChannelResponse(
-    const mojo::String& protocol,
-    const mojo::String& extensions) {
+void WebSocketHandleImpl::OnAddChannelResponse(const std::string& protocol,
+                                               const std::string& extensions) {
   DVLOG(1) << "WebSocketHandleImpl @" << reinterpret_cast<void*>(this)
            << " OnAddChannelResponse("
            << protocol << ", " << extensions << ")";
 
   if (!client_)
     return;
 
   client_->didConnect(this,
                       WebString::fromUTF8(protocol),
                       WebString::fromUTF8(extensions));
   // |this| can be deleted here.
 }
 
-void WebSocketHandleImpl::OnDataFrame(
-    bool fin, mojom::WebSocketMessageType type,
-    mojo::Array<uint8_t> data) {
+void WebSocketHandleImpl::OnDataFrame(bool fin,
+                                      mojom::WebSocketMessageType type,
+                                      const std::vector<uint8_t>& data) {
   DVLOG(1) << "WebSocketHandleImpl @" << reinterpret_cast<void*>(this)
            << " OnDataFrame(" << fin << ", " << type << ", "
            << "(data size = " << data.size() << "))";
   if (!client_)
     return;
 
   WebSocketHandle::MessageType type_to_pass =
       WebSocketHandle::MessageTypeContinuation;
   switch (type) {
     case mojom::WebSocketMessageType::CONTINUATION:
@@ skipping 15 matching lines @@
 void WebSocketHandleImpl::OnFlowControl(int64_t quota) {
   DVLOG(1) << "WebSocketHandleImpl @" << reinterpret_cast<void*>(this)
            << " OnFlowControl(" << quota << ")";
   if (!client_)
     return;
 
   client_->didReceiveFlowControl(this, quota);
   // |this| can be deleted here.
 }
 
-void WebSocketHandleImpl::OnDropChannel(bool was_clean, uint16_t code,
-                                        const mojo::String& reason) {
+void WebSocketHandleImpl::OnDropChannel(bool was_clean,
+                                        uint16_t code,
+                                        const std::string& reason) {
   DVLOG(1) << "WebSocketHandleImpl @" << reinterpret_cast<void*>(this)
            << " OnDropChannel(" << was_clean << ", " << code << ", "
            << reason << ")";
 
   WebSocketHandleClient* client = client_;
   Disconnect();
   if (!client)
     return;
 
   client->didClose(this, was_clean, code, WebString::fromUTF8(reason));
   // |this| can be deleted here.
 }
 
 void WebSocketHandleImpl::OnClosingHandshake() {
   DVLOG(1) << "WebSocketHandleImpl @" << reinterpret_cast<void*>(this)
            << " OnClosingHandshake()";
   if (!client_)
     return;
 
   client_->didStartClosingHandshake(this);
   // |this| can be deleted here.
 }
 
 }  // namespace content