diff --git a/quic/quartc/quartc_session_test.cc b/quic/quartc/quartc_session_test.cc
index fad4a8f..fc80c8b 100644
--- a/quic/quartc/quartc_session_test.cc
+++ b/quic/quartc/quartc_session_test.cc
@@ -208,7 +208,7 @@
 
     // Send messages from peer 1 to peer 2 until required number of messages
     // are queued in unsent message queue.
-    std::vector<QuicString> sent_messages;
+    std::vector<std::string> sent_messages;
     while (peer_sending->send_message_queue_size() < queue_size) {
       sent_messages.push_back(
           QuicStrCat("Sending message, index=", sent_messages.size()));
@@ -229,13 +229,13 @@
     ASSERT_TRUE(client_peer_->CanSendMessage());
 
     // Send message of maximum allowed length.
-    QuicString message_max_long =
-        QuicString(server_peer_->GetLargestMessagePayload(), 'A');
+    std::string message_max_long =
+        std::string(server_peer_->GetLargestMessagePayload(), 'A');
     ASSERT_TRUE(server_peer_->SendOrQueueMessage(message_max_long));
 
     // Send long message which should fail.
-    QuicString message_too_long =
-        QuicString(server_peer_->GetLargestMessagePayload() + 1, 'B');
+    std::string message_too_long =
+        std::string(server_peer_->GetLargestMessagePayload() + 1, 'B');
     ASSERT_FALSE(server_peer_->SendOrQueueMessage(message_too_long));
 
     // Wait for peer 2 to receive message.
