remoting: Use stl utilities from the base namespace

remoting/host/security_key/security_key_message_writer_impl_unittest.cc

 // Copyright 2016 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 "remoting/host/security_key/security_key_message_writer_impl.h"
 
 #include <cstdint>
 #include <memory>
 #include <utility>
 
@@ skipping 48 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SecurityKeyMessageWriterImplTest);
 };
 
 SecurityKeyMessageWriterImplTest::SecurityKeyMessageWriterImplTest() {}
 
 SecurityKeyMessageWriterImplTest::~SecurityKeyMessageWriterImplTest() {}
 
 std::string SecurityKeyMessageWriterImplTest::ReadMessage(
     int payload_length_bytes) {
   std::string message_header(SecurityKeyMessage::kHeaderSizeBytes, '\0');
-  read_file_.ReadAtCurrentPos(string_as_array(&message_header),
+  read_file_.ReadAtCurrentPos(base::string_as_array(&message_header),
                               SecurityKeyMessage::kHeaderSizeBytes);
 
   std::string message_type(SecurityKeyMessage::kMessageTypeSizeBytes, '\0');
-  read_file_.ReadAtCurrentPos(string_as_array(&message_type),
+  read_file_.ReadAtCurrentPos(base::string_as_array(&message_type),
                               SecurityKeyMessage::kMessageTypeSizeBytes);
 
   std::string message_data(payload_length_bytes, '\0');
   if (payload_length_bytes) {
-    read_file_.ReadAtCurrentPos(string_as_array(&message_data),
+    read_file_.ReadAtCurrentPos(base::string_as_array(&message_data),
                                 payload_length_bytes);
   }
 
   return message_header + message_type + message_data;
 }
 
 void SecurityKeyMessageWriterImplTest::OnReadComplete(
     const base::Closure& done_callback,
     const std::string& result) {
   message_result_ = result;
@@ skipping 77 matching lines @@
 
   for (int i = 0; i < total_messages_to_write; i++) {
     // Retrieve and verify the message header.
     int length;
     ASSERT_EQ(SecurityKeyMessage::kHeaderSizeBytes,
               read_file_.ReadAtCurrentPos(reinterpret_cast<char*>(&length), 4));
     ASSERT_EQ(SecurityKeyMessage::kMessageTypeSizeBytes, length);
 
     // Retrieve and verify the message type.
     std::string message_type(length, '\0');
-    int bytes_read =
-        read_file_.ReadAtCurrentPos(string_as_array(&message_type), length);
+    int bytes_read = read_file_.ReadAtCurrentPos(
+        base::string_as_array(&message_type), length);
     ASSERT_EQ(length, bytes_read);
 
     SecurityKeyMessageType type =
         SecurityKeyMessage::MessageTypeFromValue(message_type[0]);
     if (i % 2 == 0) {
       ASSERT_EQ(SecurityKeyMessageType::CONNECT, type);
     } else {
       ASSERT_EQ(SecurityKeyMessageType::REQUEST, type);
     }
   }
 
   // Destroy the writer and verify the other end of the pipe is clean.
   writer_.reset();
   char unused;
   ASSERT_LE(read_file_.ReadAtCurrentPos(&unused, 1), 0);
 }
 
 TEST_F(SecurityKeyMessageWriterImplTest, EnsureWriteFailsWhenPipeClosed) {
   // Close the read end so that writing fails immediately.
   read_file_.Close();
 
   EXPECT_FALSE(writer_->WriteMessage(kTestMessageType));
 }
 
 }  // namespace remoting