Rewrite std::string("") to std::string(), Linux edition.

ppapi/tests/test_websocket.cc

 // Copyright (c) 2012 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 "ppapi/tests/test_websocket.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 332 matching lines @@
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   ASSERT_TRUE(ws);
 
   uint64_t bufferedAmount = websocket_interface_->GetBufferedAmount(ws);
   ASSERT_EQ(0U, bufferedAmount);
 
   uint16_t close_code = websocket_interface_->GetCloseCode(ws);
   ASSERT_EQ(0U, close_code);
 
   PP_Var close_reason = websocket_interface_->GetCloseReason(ws);
-  ASSERT_TRUE(AreEqualWithString(close_reason, ""));
+  ASSERT_TRUE(AreEqualWithString(close_reason, std::string()));
   ReleaseVar(close_reason);
 
   PP_Bool close_was_clean = websocket_interface_->GetCloseWasClean(ws);
   ASSERT_EQ(PP_FALSE, close_was_clean);
 
   PP_Var extensions = websocket_interface_->GetExtensions(ws);
-  ASSERT_TRUE(AreEqualWithString(extensions, ""));
+  ASSERT_TRUE(AreEqualWithString(extensions, std::string()));
   ReleaseVar(extensions);
 
   PP_Var protocol = websocket_interface_->GetProtocol(ws);
-  ASSERT_TRUE(AreEqualWithString(protocol, ""));
+  ASSERT_TRUE(AreEqualWithString(protocol, std::string()));
   ReleaseVar(protocol);
 
   PP_WebSocketReadyState ready_state =
       websocket_interface_->GetReadyState(ws);
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID, ready_state);
 
   PP_Var url = websocket_interface_->GetURL(ws);
-  ASSERT_TRUE(AreEqualWithString(url, ""));
+  ASSERT_TRUE(AreEqualWithString(url, std::string()));
   ReleaseVar(url);
 
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestInvalidConnect() {
   PP_Var protocols[] = { PP_MakeUndefined() };
 
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   ASSERT_TRUE(ws);
 
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(websocket_interface_->Connect(
       ws, PP_MakeUndefined(), protocols, 1U,
       callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 
   callback.WaitForResult(websocket_interface_->Connect(
       ws, PP_MakeUndefined(), protocols, 1U,
       callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_ERROR_INPROGRESS, callback.result());
 
   core_interface_->ReleaseResource(ws);
 
   for (int i = 0; kInvalidURLs[i]; ++i) {
     int32_t result;
-    ws = Connect(kInvalidURLs[i], &result, "");
+    ws = Connect(kInvalidURLs[i], &result, std::string());
     ASSERT_TRUE(ws);
     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
 
     core_interface_->ReleaseResource(ws);
   }
 
   PASS();
 }
 
 std::string TestWebSocket::TestProtocols() {
@@ skipping 29 matching lines @@
     ReleaseVar(good_protocols[i]);
   }
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestGetURL() {
   for (int i = 0; kInvalidURLs[i]; ++i) {
     int32_t result;
-    PP_Resource ws = Connect(kInvalidURLs[i], &result, "");
+    PP_Resource ws = Connect(kInvalidURLs[i], &result, std::string());
     ASSERT_TRUE(ws);
     PP_Var url = websocket_interface_->GetURL(ws);
     ASSERT_TRUE(AreEqualWithString(url, kInvalidURLs[i]));
     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
 
     ReleaseVar(url);
     core_interface_->ReleaseResource(ws);
   }
 
   PASS();
 }
 
 std::string TestWebSocket::TestValidConnect() {
   int32_t result;
-  PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   PP_Var extensions = websocket_interface_->GetExtensions(ws);
-  ASSERT_TRUE(AreEqualWithString(extensions, ""));
+  ASSERT_TRUE(AreEqualWithString(extensions, std::string()));
   core_interface_->ReleaseResource(ws);
   ReleaseVar(extensions);
 
   PASS();
 }
 
 std::string TestWebSocket::TestInvalidClose() {
   PP_Var reason = CreateVarString("close for test");
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   TestCompletionCallback async_callback(instance_->pp_instance(), PP_REQUIRED);
 
   // Close before connect.
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   callback.WaitForResult(websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_ERROR_FAILED, callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close with bad arguments.
   int32_t result;
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   callback.WaitForResult(websocket_interface_->Close(
       ws, 1U, reason, callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_ERROR_NOACCESS, callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close with PP_VARTYPE_NULL.
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   callback.WaitForResult(websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeNull(),
       callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close with PP_VARTYPE_NULL and ongoing receive message.
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   PP_Var receive_message_var;
   result = websocket_interface_->ReceiveMessage(
       ws, &receive_message_var,
       async_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   callback.WaitForResult(websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeNull(),
       callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
   const char* send_message = "hi";
   PP_Var send_message_var = CreateVarString(send_message);
   result = websocket_interface_->SendMessage(ws, send_message_var);
   ReleaseVar(send_message_var);
   ASSERT_EQ(PP_OK, result);
   async_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(PP_OK, async_callback.result());
   ASSERT_TRUE(AreEqualWithString(receive_message_var, send_message));
   ReleaseVar(receive_message_var);
   core_interface_->ReleaseResource(ws);
 
   // Close twice.
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       async_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   // Call another Close() before previous one is in progress.
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       callback.GetCallback().pp_completion_callback());
@@ skipping 16 matching lines @@
 std::string TestWebSocket::TestValidClose() {
   PP_Var reason = CreateVarString("close for test");
   PP_Var url = CreateVarString(GetFullURL(kEchoServerURL).c_str());
   PP_Var protocols[] = { PP_MakeUndefined() };
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   TestCompletionCallback another_callback(
       instance_->pp_instance(), callback_type());
 
   // Close.
   int32_t result;
-  PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   callback.WaitForResult(websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       callback.GetCallback().pp_completion_callback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close without code and reason.
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   callback.WaitForResult(websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED, reason,
       callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_OK, callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close with PP_VARTYPE_UNDEFINED.
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   callback.WaitForResult(websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
       callback.GetCallback().pp_completion_callback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close in connecting.
   // The ongoing connect failed with PP_ERROR_ABORTED, then the close is done
   // successfully.
   ws = websocket_interface_->Create(instance_->pp_instance());
   result = websocket_interface_->Connect(
       ws, url, protocols, 0U, callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       another_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   callback.WaitForResult(PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
   another_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(PP_OK, another_callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close in closing.
   // The first close will be done successfully, then the second one failed with
   // with PP_ERROR_INPROGRESS immediately.
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       another_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_ERROR_INPROGRESS, result);
   callback.WaitForResult(PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(PP_OK, callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close with ongoing receive message.
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   PP_Var receive_message_var;
   result = websocket_interface_->ReceiveMessage(
       ws, &receive_message_var,
       callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
       another_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   callback.WaitForResult(PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
   another_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(PP_OK, another_callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Close with PP_VARTYPE_UNDEFINED and ongoing receive message.
-  ws = Connect(GetFullURL(kEchoServerURL), &result, "");
+  ws = Connect(GetFullURL(kEchoServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->ReceiveMessage(
       ws, &receive_message_var,
       callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
       another_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   callback.WaitForResult(PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
   another_callback.WaitForResult(PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(PP_OK, another_callback.result());
   core_interface_->ReleaseResource(ws);
 
   // Server initiated closing handshake.
-  ws = Connect(GetFullURL(kCloseWithCodeAndReasonServerURL), &result, "");
+  ws = Connect(
+      GetFullURL(kCloseWithCodeAndReasonServerURL), &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   // Text messsage "1000 bye" requests the server to initiate closing handshake
   // with code being 1000 and reason being "bye".
   PP_Var close_request_var = CreateVarString("1000 bye");
   result = websocket_interface_->SendMessage(ws, close_request_var);
   ReleaseVar(close_request_var);
   callback.WaitForResult(websocket_interface_->ReceiveMessage(
       ws, &receive_message_var,
       callback.GetCallback().pp_completion_callback()));
@@ skipping 26 matching lines @@
     ReleaseVar(protocol);
     core_interface_->ReleaseResource(ws);
   }
 
   PASS();
 }
 
 std::string TestWebSocket::TestTextSendReceive() {
   // Connect to test echo server.
   int32_t connect_result;
-  PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &connect_result, "");
+  PP_Resource ws =
+      Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, connect_result);
 
   // Send 'hello pepper' text message.
   const char* message = "hello pepper";
   PP_Var message_var = CreateVarString(message);
   int32_t result = websocket_interface_->SendMessage(ws, message_var);
   ReleaseVar(message_var);
   ASSERT_EQ(PP_OK, result);
 
   // Receive echoed 'hello pepper'.
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   PP_Var received_message;
   callback.WaitForResult(websocket_interface_->ReceiveMessage(
       ws, &received_message, callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_OK, callback.result());
   ASSERT_TRUE(AreEqualWithString(received_message, message));
   ReleaseVar(received_message);
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestBinarySendReceive() {
   // Connect to test echo server.
   int32_t connect_result;
-  PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &connect_result, "");
+  PP_Resource ws =
+      Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, connect_result);
 
   // Send binary message.
   std::vector<uint8_t> binary(256);
   for (uint32_t i = 0; i < binary.size(); ++i)
     binary[i] = i;
   PP_Var message_var = CreateVarBinary(binary);
   int32_t result = websocket_interface_->SendMessage(ws, message_var);
   ReleaseVar(message_var);
   ASSERT_EQ(PP_OK, result);
 
   // Receive echoed binary.
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   PP_Var received_message;
   callback.WaitForResult(websocket_interface_->ReceiveMessage(
       ws, &received_message, callback.GetCallback().pp_completion_callback()));
   ASSERT_EQ(PP_OK, callback.result());
   ASSERT_TRUE(AreEqualWithBinary(received_message, binary));
   ReleaseVar(received_message);
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestStressedSendReceive() {
   // Connect to test echo server.
   int32_t connect_result;
-  PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &connect_result, "");
+  PP_Resource ws =
+      Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, connect_result);
 
   // Prepare PP_Var objects to send.
   const char* text = "hello pepper";
   PP_Var text_var = CreateVarString(text);
   std::vector<uint8_t> binary(256);
   for (uint32_t i = 0; i < binary.size(); ++i)
     binary[i] = i;
   PP_Var binary_var = CreateVarBinary(binary);
@@ skipping 39 matching lines @@
     ReleaseVar(received_message);
   }
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
 
 std::string TestWebSocket::TestBufferedAmount() {
   // Connect to test echo server.
   int32_t connect_result;
-  PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &connect_result, "");
+  PP_Resource ws =
+      Connect(GetFullURL(kEchoServerURL), &connect_result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, connect_result);
 
   // Prepare a large message that is not aligned with the internal buffer
   // sizes.
   std::string message(8193, 'x');
   PP_Var message_var = CreateVarString(message);
 
   uint64_t buffered_amount = 0;
   int32_t result;
@@ skipping 19 matching lines @@
 
   callback.WaitForResult(result);
   ASSERT_EQ(PP_OK, callback.result());
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED,
       websocket_interface_->GetReadyState(ws));
 
   uint64_t base_buffered_amount = websocket_interface_->GetBufferedAmount(ws);
 
   // After connection closure, all sending requests fail and just increase
   // the bufferedAmount property.
-  PP_Var empty_string = CreateVarString("");
+  PP_Var empty_string = CreateVarString(std::string());
   result = websocket_interface_->SendMessage(ws, empty_string);
   ASSERT_EQ(PP_ERROR_FAILED, result);
   buffered_amount = websocket_interface_->GetBufferedAmount(ws);
   ASSERT_EQ(base_buffered_amount + kMessageFrameOverhead, buffered_amount);
   base_buffered_amount = buffered_amount;
 
   result = websocket_interface_->SendMessage(ws, reason);
   ASSERT_EQ(PP_ERROR_FAILED, result);
   buffered_amount = websocket_interface_->GetBufferedAmount(ws);
   uint64_t reason_frame_size = kMessageFrameOverhead + reason_str.length();
@@ skipping 22 matching lines @@
       instance_->pp_instance(), callback_type());
   int32_t result = websocket_interface_->Connect(
       ws, url_var, NULL, 0,
       connect_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   core_interface_->ReleaseResource(ws);
   connect_callback.WaitForResult(result);
   ASSERT_EQ(PP_ERROR_ABORTED, connect_callback.result());
 
   // Test the behavior for Close().
-  ws = Connect(url, &result, "");
+  ws = Connect(url, &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   PP_Var reason_var = CreateVarString("abort");
   TestCompletionCallback close_callback(
       instance_->pp_instance(), callback_type());
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason_var,
       close_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   core_interface_->ReleaseResource(ws);
   close_callback.WaitForResult(result);
   ASSERT_EQ(PP_ERROR_ABORTED, close_callback.result());
   ReleaseVar(reason_var);
 
   // Test the behavior for ReceiveMessage().
   // Make sure the simplest case to wait for data which never arrives, here.
-  ws = Connect(url, &result, "");
+  ws = Connect(url, &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   PP_Var receive_var;
   TestCompletionCallback receive_callback(
       instance_->pp_instance(), callback_type());
   result = websocket_interface_->ReceiveMessage(
       ws, &receive_var,
       receive_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   core_interface_->ReleaseResource(ws);
   receive_callback.WaitForResult(result);
   ASSERT_EQ(PP_ERROR_ABORTED, receive_callback.result());
 
   // Release the resource in the aborting receive completion callback which is
   // introduced by calling Close().
-  ws = Connect(url, &result, "");
+  ws = Connect(url, &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->ReceiveMessage(
       ws, &receive_var,
       receive_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   ReleaseResourceDelegate receive_delegate(core_interface_, ws);
   receive_callback.SetDelegate(&receive_delegate);
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
@@ skipping 13 matching lines @@
 
 std::string TestWebSocket::TestAbortSendMessageCall() {
   // Test the behavior for SendMessage().
   // This function doesn't require a callback, but operation will be done
   // asynchronously in WebKit and browser process.
   std::vector<uint8_t> large_binary(65 * 1024);
   PP_Var large_var = CreateVarBinary(large_binary);
 
   int32_t result;
   std::string url = GetFullURL(kEchoServerURL);
-  PP_Resource ws = Connect(url, &result, "");
+  PP_Resource ws = Connect(url, &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->SendMessage(ws, large_var);
   ASSERT_EQ(PP_OK, result);
   core_interface_->ReleaseResource(ws);
   ReleaseVar(large_var);
 
   PASS();
 }
 
 std::string TestWebSocket::TestAbortCloseCall() {
   // Release the resource in the close completion callback.
   int32_t result;
   std::string url = GetFullURL(kEchoServerURL);
-  PP_Resource ws = Connect(url, &result, "");
+  PP_Resource ws = Connect(url, &result, std::string());
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   TestCompletionCallback close_callback(
       instance_->pp_instance(), callback_type());
   result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, PP_MakeUndefined(),
       close_callback.GetCallback().pp_completion_callback());
   ReleaseResourceDelegate close_delegate(core_interface_, ws);
   close_callback.SetDelegate(&close_delegate);
   close_callback.WaitForResult(result);
@@ skipping 12 matching lines @@
 
   std::string url = GetFullURL(kEchoServerURL);
   int32_t result;
   PP_Resource ws;
 
   // Each trial sends |trial_count| + 1 messages and receives just |trial|
   // number of message(s) before releasing the WebSocket. The WebSocket is
   // released while the next message is going to be received.
   const int trial_count = 8;
   for (int trial = 1; trial <= trial_count; trial++) {
-    ws = Connect(url, &result, "");
+    ws = Connect(url, &result, std::string());
     ASSERT_TRUE(ws);
     ASSERT_EQ(PP_OK, result);
     for (int i = 0; i <= trial_count; ++i) {
       result = websocket_interface_->SendMessage(ws, text_var);
       ASSERT_EQ(PP_OK, result);
     }
     TestCompletionCallback callback(instance_->pp_instance(), callback_type());
     PP_Var var;
     for (int i = 0; i < trial; ++i) {
       callback.WaitForResult(websocket_interface_->ReceiveMessage(
           ws, &var, callback.GetCallback().pp_completion_callback()));
       ASSERT_EQ(PP_OK, callback.result());
       ASSERT_TRUE(AreEqualWithString(var, text));
       ReleaseVar(var);
     }
     result = websocket_interface_->ReceiveMessage(
         ws, &var, callback.GetCallback().pp_completion_callback());
     core_interface_->ReleaseResource(ws);
     if (result != PP_OK) {
       callback.WaitForResult(result);
       ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
     }
   }
   // Same test, but the last receiving message is large message over 64KiB.
   for (int trial = 1; trial <= trial_count; trial++) {
-    ws = Connect(url, &result, "");
+    ws = Connect(url, &result, std::string());
     ASSERT_TRUE(ws);
     ASSERT_EQ(PP_OK, result);
     for (int i = 0; i <= trial_count; ++i) {
       if (i == trial)
         result = websocket_interface_->SendMessage(ws, large_var);
       else
         result = websocket_interface_->SendMessage(ws, text_var);
       ASSERT_EQ(PP_OK, result);
     }
     TestCompletionCallback callback(instance_->pp_instance(), callback_type());
@@ skipping 21 matching lines @@
 }
 
 std::string TestWebSocket::TestCcInterfaces() {
   // C++ bindings is simple straightforward, then just verifies interfaces work
   // as a interface bridge fine.
   pp::WebSocket ws(instance_);
 
   // Check uninitialized properties access.
   ASSERT_EQ(0, ws.GetBufferedAmount());
   ASSERT_EQ(0, ws.GetCloseCode());
-  ASSERT_TRUE(AreEqualWithString(ws.GetCloseReason().pp_var(), ""));
+  ASSERT_TRUE(AreEqualWithString(ws.GetCloseReason().pp_var(), std::string()));
   ASSERT_EQ(false, ws.GetCloseWasClean());
-  ASSERT_TRUE(AreEqualWithString(ws.GetExtensions().pp_var(), ""));
-  ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), ""));
+  ASSERT_TRUE(AreEqualWithString(ws.GetExtensions().pp_var(), std::string()));
+  ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), std::string()));
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_INVALID, ws.GetReadyState());
-  ASSERT_TRUE(AreEqualWithString(ws.GetURL().pp_var(), ""));
+  ASSERT_TRUE(AreEqualWithString(ws.GetURL().pp_var(), std::string()));
 
   // Check communication interfaces (connect, send, receive, and close).
   TestCompletionCallback connect_callback(
       instance_->pp_instance(), callback_type());
   connect_callback.WaitForResult(ws.Connect(
       pp::Var(GetFullURL(kCloseServerURL)), NULL, 0U,
               connect_callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(connect_callback);
   ASSERT_EQ(PP_OK, connect_callback.result());
 
@@ skipping 35 matching lines @@
       close_callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(close_callback);
   ASSERT_EQ(PP_OK, close_callback.result());
 
   // Check initialized properties access.
   ASSERT_EQ(0, ws.GetBufferedAmount());
   ASSERT_EQ(PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, ws.GetCloseCode());
   ASSERT_TRUE(
       AreEqualWithString(ws.GetCloseReason().pp_var(), reason.c_str()));
   ASSERT_EQ(true, ws.GetCloseWasClean());
-  ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), ""));
+  ASSERT_TRUE(AreEqualWithString(ws.GetProtocol().pp_var(), std::string()));
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED, ws.GetReadyState());
   ASSERT_TRUE(AreEqualWithString(
       ws.GetURL().pp_var(), GetFullURL(kCloseServerURL).c_str()));
 
   PASS();
 }
 
 std::string TestWebSocket::TestUtilityInvalidConnect() {
   const pp::Var protocols[] = { pp::Var() };
 
@@ skipping 84 matching lines @@
 std::string TestWebSocket::TestUtilityValidConnect() {
   const pp::Var protocols[] = { pp::Var() };
   TestWebSocketAPI websocket(instance_);
   int32_t result = websocket.Connect(
       pp::Var(GetFullURL(kEchoServerURL)), protocols, 0U);
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   websocket.WaitForConnected();
   const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   ASSERT_EQ(1U, events.size());
   ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
-  ASSERT_TRUE(AreEqualWithString(websocket.GetExtensions().pp_var(), ""));
+  ASSERT_TRUE(
+      AreEqualWithString(websocket.GetExtensions().pp_var(), std::string()));
 
   PASS();
 }
 
 std::string TestWebSocket::TestUtilityInvalidClose() {
   const pp::Var reason = pp::Var(std::string("close for test"));
 
   // Close before connect.
   {
     TestWebSocketAPI websocket(instance_);
@@ skipping 207 matching lines @@
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var(reason));
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSING, websocket.GetReadyState());
   websocket.WaitForClosed();
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED, websocket.GetReadyState());
 
   uint64_t base_buffered_amount = websocket.GetBufferedAmount();
   size_t events_on_closed = websocket.GetSeenEvents().size();
 
   // After connection closure, all sending requests fail and just increase
   // the bufferedAmount property.
-  result = websocket.Send(pp::Var(std::string("")));
+  result = websocket.Send(pp::Var(std::string()));
   ASSERT_EQ(PP_ERROR_FAILED, result);
   buffered_amount = websocket.GetBufferedAmount();
   ASSERT_EQ(base_buffered_amount + kMessageFrameOverhead, buffered_amount);
   base_buffered_amount = buffered_amount;
 
   result = websocket.Send(pp::Var(reason));
   ASSERT_EQ(PP_ERROR_FAILED, result);
   buffered_amount = websocket.GetBufferedAmount();
   uint64_t reason_frame_size = kMessageFrameOverhead + reason.length();
   ASSERT_EQ(base_buffered_amount + reason_frame_size, buffered_amount);
 
   const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
   ASSERT_EQ(events_on_closed, events.size());
   ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[0].event_type);
   size_t last_event = events_on_closed - 1;
   for (uint32_t i = 1; i < last_event; ++i) {
     ASSERT_EQ(WebSocketEvent::EVENT_MESSAGE, events[i].event_type);
     ASSERT_TRUE(AreEqualWithString(events[i].var.pp_var(), message));
   }
   ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[last_event].event_type);
   ASSERT_TRUE(events[last_event].was_clean);
 
   PASS();
 }