Provide std::move() in compat instead of using crashpad::move()

minidump/minidump_memory_writer_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "minidump/minidump_memory_writer.h"
 
 #include <windows.h>
 #include <dbghelp.h>
 #include <stdint.h>
 
+#include <utility>
+
 #include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_extensions.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/minidump_stream_writer.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_memory_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
 #include "snapshot/test/test_memory_snapshot.h"
 #include "util/file/string_file.h"
-#include "util/stdlib/move.h"
 #include "util/stdlib/pointer_container.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 const MinidumpStreamType kBogusStreamType =
     static_cast<MinidumpStreamType>(1234);
 
 // expected_streams is the expected number of streams in the file. The memory
@@ skipping 30 matching lines @@
 
   *memory_list = MinidumpWritableAtLocationDescriptor<MINIDUMP_MEMORY_LIST>(
       file_contents, directory[directory_index].Location);
   ASSERT_TRUE(memory_list);
 }
 
 TEST(MinidumpMemoryWriter, EmptyMemoryList) {
   MinidumpFileWriter minidump_file_writer;
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
 
-  minidump_file_writer.AddStream(crashpad::move(memory_list_writer));
+  minidump_file_writer.AddStream(std::move(memory_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MEMORY_LIST),
             string_file.string().size());
 
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetMemoryListStream(string_file.string(), &memory_list, 1));
 
   EXPECT_EQ(0u, memory_list->NumberOfMemoryRanges);
 }
 
 TEST(MinidumpMemoryWriter, OneMemoryRegion) {
   MinidumpFileWriter minidump_file_writer;
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
 
   const uint64_t kBaseAddress = 0xfedcba9876543210;
   const uint64_t kSize = 0x1000;
   const uint8_t kValue = 'm';
 
   auto memory_writer = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress, kSize, kValue));
-  memory_list_writer->AddMemory(crashpad::move(memory_writer));
+  memory_list_writer->AddMemory(std::move(memory_writer));
 
-  minidump_file_writer.AddStream(crashpad::move(memory_list_writer));
+  minidump_file_writer.AddStream(std::move(memory_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetMemoryListStream(string_file.string(), &memory_list, 1));
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
   expected.StartOfMemoryRange = kBaseAddress;
@@ skipping 15 matching lines @@
 
   const uint64_t kBaseAddress0 = 0xc0ffee;
   const uint64_t kSize0 = 0x0100;
   const uint8_t kValue0 = '6';
   const uint64_t kBaseAddress1 = 0xfac00fac;
   const uint64_t kSize1 = 0x0200;
   const uint8_t kValue1 = '!';
 
   auto memory_writer_0 = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress0, kSize0, kValue0));
-  memory_list_writer->AddMemory(crashpad::move(memory_writer_0));
+  memory_list_writer->AddMemory(std::move(memory_writer_0));
   auto memory_writer_1 = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress1, kSize1, kValue1));
-  memory_list_writer->AddMemory(crashpad::move(memory_writer_1));
+  memory_list_writer->AddMemory(std::move(memory_writer_1));
 
-  minidump_file_writer.AddStream(crashpad::move(memory_list_writer));
+  minidump_file_writer.AddStream(std::move(memory_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetMemoryListStream(string_file.string(), &memory_list, 1));
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
@@ skipping 78 matching lines @@
 
   const uint64_t kBaseAddress0 = 0x1000;
   const size_t kSize0 = 0x0400;
   const uint8_t kValue0 = '1';
   auto test_memory_stream =
       make_scoped_ptr(new TestMemoryStream(kBaseAddress0, kSize0, kValue0));
 
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
   memory_list_writer->AddExtraMemory(test_memory_stream->memory());
 
-  minidump_file_writer.AddStream(crashpad::move(test_memory_stream));
+  minidump_file_writer.AddStream(std::move(test_memory_stream));
 
   const uint64_t kBaseAddress1 = 0x2000;
   const size_t kSize1 = 0x0400;
   const uint8_t kValue1 = 'm';
 
   auto memory_writer = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress1, kSize1, kValue1));
-  memory_list_writer->AddMemory(crashpad::move(memory_writer));
+  memory_list_writer->AddMemory(std::move(memory_writer));
 
-  minidump_file_writer.AddStream(crashpad::move(memory_list_writer));
+  minidump_file_writer.AddStream(std::move(memory_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetMemoryListStream(string_file.string(), &memory_list, 2));
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
@@ skipping 57 matching lines @@
         expect_memory_descriptors[index].StartOfMemoryRange);
     memory_snapshot->SetSize(expect_memory_descriptors[index].Memory.DataSize);
     memory_snapshot->SetValue(values[index]);
     memory_snapshots.push_back(memory_snapshot);
   }
 
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
   memory_list_writer->AddFromSnapshot(memory_snapshots);
 
   MinidumpFileWriter minidump_file_writer;
-  minidump_file_writer.AddStream(crashpad::move(memory_list_writer));
+  minidump_file_writer.AddStream(std::move(memory_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetMemoryListStream(string_file.string(), &memory_list, 1));
 
   ASSERT_EQ(3u, memory_list->NumberOfMemoryRanges);
 
   for (size_t index = 0; index < memory_list->NumberOfMemoryRanges; ++index) {
     SCOPED_TRACE(base::StringPrintf("index %" PRIuS, index));
     ExpectMinidumpMemoryDescriptorAndContents(
         &expect_memory_descriptors[index],
         &memory_list->MemoryRanges[index],
         string_file.string(),
         values[index],
         index == memory_list->NumberOfMemoryRanges - 1);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad