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

minidump/minidump_thread_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_thread_writer.h"
 
 #include <windows.h>
 #include <dbghelp.h>
 #include <sys/types.h>
 
 #include <string>
+#include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_context_writer.h"
 #include "minidump/minidump_memory_writer.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/minidump_thread_id_map.h"
 #include "minidump/test/minidump_context_test_util.h"
 #include "minidump/test/minidump_memory_writer_test_util.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
 #include "snapshot/test/test_cpu_context.h"
 #include "snapshot/test/test_memory_snapshot.h"
 #include "snapshot/test/test_thread_snapshot.h"
 #include "test/gtest_death_check.h"
 #include "util/file/string_file.h"
-#include "util/stdlib/move.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 // This returns the MINIDUMP_THREAD_LIST stream in |thread_list|. If
 // |memory_list| is not nullptr, a MINIDUMP_MEMORY_LIST stream is also expected
 // in |file_contents|, and that stream will be returned in |memory_list|.
 void GetThreadListStream(const std::string& file_contents,
                          const MINIDUMP_THREAD_LIST** thread_list,
@@ skipping 26 matching lines @@
     *memory_list = MinidumpWritableAtLocationDescriptor<MINIDUMP_MEMORY_LIST>(
         file_contents, directory[1].Location);
     ASSERT_TRUE(*memory_list);
   }
 }
 
 TEST(MinidumpThreadWriter, EmptyThreadList) {
   MinidumpFileWriter minidump_file_writer;
   auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
 
-  minidump_file_writer.AddStream(crashpad::move(thread_list_writer));
+  minidump_file_writer.AddStream(std::move(thread_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST),
             string_file.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
@@ skipping 56 matching lines @@
 
   auto thread_writer = make_scoped_ptr(new MinidumpThreadWriter());
   thread_writer->SetThreadID(kThreadID);
   thread_writer->SetSuspendCount(kSuspendCount);
   thread_writer->SetPriorityClass(kPriorityClass);
   thread_writer->SetPriority(kPriority);
   thread_writer->SetTEB(kTEB);
 
   auto context_x86_writer = make_scoped_ptr(new MinidumpContextX86Writer());
   InitializeMinidumpContextX86(context_x86_writer->context(), kSeed);
-  thread_writer->SetContext(crashpad::move(context_x86_writer));
+  thread_writer->SetContext(std::move(context_x86_writer));
 
-  thread_list_writer->AddThread(crashpad::move(thread_writer));
-  minidump_file_writer.AddStream(crashpad::move(thread_list_writer));
+  thread_list_writer->AddThread(std::move(thread_writer));
+  minidump_file_writer.AddStream(std::move(thread_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextX86),
             string_file.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
@@ skipping 38 matching lines @@
 
   auto thread_writer = make_scoped_ptr(new MinidumpThreadWriter());
   thread_writer->SetThreadID(kThreadID);
   thread_writer->SetSuspendCount(kSuspendCount);
   thread_writer->SetPriorityClass(kPriorityClass);
   thread_writer->SetPriority(kPriority);
   thread_writer->SetTEB(kTEB);
 
   auto memory_writer = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kMemoryBase, kMemorySize, kMemoryValue));
-  thread_writer->SetStack(crashpad::move(memory_writer));
+  thread_writer->SetStack(std::move(memory_writer));
 
   MSVC_SUPPRESS_WARNING(4316);  // Object allocated on heap may not be aligned.
   auto context_amd64_writer = make_scoped_ptr(new MinidumpContextAMD64Writer());
   InitializeMinidumpContextAMD64(context_amd64_writer->context(), kSeed);
-  thread_writer->SetContext(crashpad::move(context_amd64_writer));
+  thread_writer->SetContext(std::move(context_amd64_writer));
 
-  thread_list_writer->AddThread(crashpad::move(thread_writer));
-  minidump_file_writer.AddStream(crashpad::move(thread_list_writer));
+  thread_list_writer->AddThread(std::move(thread_writer));
+  minidump_file_writer.AddStream(std::move(thread_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextAMD64) + kMemorySize,
             string_file.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
@@ skipping 49 matching lines @@
 
   auto thread_writer_0 = make_scoped_ptr(new MinidumpThreadWriter());
   thread_writer_0->SetThreadID(kThreadID0);
   thread_writer_0->SetSuspendCount(kSuspendCount0);
   thread_writer_0->SetPriorityClass(kPriorityClass0);
   thread_writer_0->SetPriority(kPriority0);
   thread_writer_0->SetTEB(kTEB0);
 
   auto memory_writer_0 = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kMemoryBase0, kMemorySize0, kMemoryValue0));
-  thread_writer_0->SetStack(crashpad::move(memory_writer_0));
+  thread_writer_0->SetStack(std::move(memory_writer_0));
 
   auto context_x86_writer_0 = make_scoped_ptr(new MinidumpContextX86Writer());
   InitializeMinidumpContextX86(context_x86_writer_0->context(), kSeed0);
-  thread_writer_0->SetContext(crashpad::move(context_x86_writer_0));
+  thread_writer_0->SetContext(std::move(context_x86_writer_0));
 
-  thread_list_writer->AddThread(crashpad::move(thread_writer_0));
+  thread_list_writer->AddThread(std::move(thread_writer_0));
 
   const uint32_t kThreadID1 = 2222222;
   const uint32_t kSuspendCount1 = 222222;
   const uint32_t kPriorityClass1 = 22222;
   const uint32_t kPriority1 = 2222;
   const uint64_t kTEB1 = 222;
   const uint64_t kMemoryBase1 = 0x2220;
   const size_t kMemorySize1 = 32;
   const uint8_t kMemoryValue1 = 22;
   const uint32_t kSeed1 = 2;
 
   auto thread_writer_1 = make_scoped_ptr(new MinidumpThreadWriter());
   thread_writer_1->SetThreadID(kThreadID1);
   thread_writer_1->SetSuspendCount(kSuspendCount1);
   thread_writer_1->SetPriorityClass(kPriorityClass1);
   thread_writer_1->SetPriority(kPriority1);
   thread_writer_1->SetTEB(kTEB1);
 
   auto memory_writer_1 = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kMemoryBase1, kMemorySize1, kMemoryValue1));
-  thread_writer_1->SetStack(crashpad::move(memory_writer_1));
+  thread_writer_1->SetStack(std::move(memory_writer_1));
 
   auto context_x86_writer_1 = make_scoped_ptr(new MinidumpContextX86Writer());
   InitializeMinidumpContextX86(context_x86_writer_1->context(), kSeed1);
-  thread_writer_1->SetContext(crashpad::move(context_x86_writer_1));
+  thread_writer_1->SetContext(std::move(context_x86_writer_1));
 
-  thread_list_writer->AddThread(crashpad::move(thread_writer_1));
+  thread_list_writer->AddThread(std::move(thread_writer_1));
 
   const uint32_t kThreadID2 = 3333333;
   const uint32_t kSuspendCount2 = 333333;
   const uint32_t kPriorityClass2 = 33333;
   const uint32_t kPriority2 = 3333;
   const uint64_t kTEB2 = 333;
   const uint64_t kMemoryBase2 = 0x3330;
   const size_t kMemorySize2 = 48;
   const uint8_t kMemoryValue2 = 33;
   const uint32_t kSeed2 = 3;
 
   auto thread_writer_2 = make_scoped_ptr(new MinidumpThreadWriter());
   thread_writer_2->SetThreadID(kThreadID2);
   thread_writer_2->SetSuspendCount(kSuspendCount2);
   thread_writer_2->SetPriorityClass(kPriorityClass2);
   thread_writer_2->SetPriority(kPriority2);
   thread_writer_2->SetTEB(kTEB2);
 
   auto memory_writer_2 = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kMemoryBase2, kMemorySize2, kMemoryValue2));
-  thread_writer_2->SetStack(crashpad::move(memory_writer_2));
+  thread_writer_2->SetStack(std::move(memory_writer_2));
 
   auto context_x86_writer_2 = make_scoped_ptr(new MinidumpContextX86Writer());
   InitializeMinidumpContextX86(context_x86_writer_2->context(), kSeed2);
-  thread_writer_2->SetContext(crashpad::move(context_x86_writer_2));
+  thread_writer_2->SetContext(std::move(context_x86_writer_2));
 
-  thread_list_writer->AddThread(crashpad::move(thread_writer_2));
+  thread_list_writer->AddThread(std::move(thread_writer_2));
 
-  minidump_file_writer.AddStream(crashpad::move(thread_list_writer));
-  minidump_file_writer.AddStream(crashpad::move(memory_list_writer));
+  minidump_file_writer.AddStream(std::move(thread_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) + 2 * sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 3 * sizeof(MINIDUMP_THREAD) +
                 sizeof(MINIDUMP_MEMORY_LIST) +
                 3 * sizeof(MINIDUMP_MEMORY_DESCRIPTOR) +
                 3 * sizeof(MinidumpContextX86) + kMemorySize0 + kMemorySize1 +
                 kMemorySize2 + 12,  // 12 for alignment
@@ skipping 216 matching lines @@
     thread_snapshot->SetSuspendCount(expect_threads[index].SuspendCount);
     thread_snapshot->SetPriority(expect_threads[index].Priority);
     thread_snapshot->SetThreadSpecificDataAddress(expect_threads[index].Teb);
 
     if (expect_threads[index].Stack.Memory.DataSize) {
       auto memory_snapshot = make_scoped_ptr(new TestMemorySnapshot());
       memory_snapshot->SetAddress(
           expect_threads[index].Stack.StartOfMemoryRange);
       memory_snapshot->SetSize(expect_threads[index].Stack.Memory.DataSize);
       memory_snapshot->SetValue(memory_values[index]);
-      thread_snapshot->SetStack(crashpad::move(memory_snapshot));
+      thread_snapshot->SetStack(std::move(memory_snapshot));
     }
 
     Traits::InitializeCPUContext(thread_snapshot->MutableContext(),
                                  context_seeds[index]);
 
     auto teb_snapshot = make_scoped_ptr(new TestMemorySnapshot());
     teb_snapshot->SetAddress(expect_threads[index].Teb);
     teb_snapshot->SetSize(kTebSize);
     teb_snapshot->SetValue(static_cast<char>('t' + index));
-    thread_snapshot->AddExtraMemory(crashpad::move(teb_snapshot));
+    thread_snapshot->AddExtraMemory(std::move(teb_snapshot));
 
     thread_snapshots.push_back(thread_snapshot);
   }
 
   auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
   thread_list_writer->SetMemoryListWriter(memory_list_writer.get());
   MinidumpThreadIDMap thread_id_map;
   thread_list_writer->InitializeFromSnapshot(thread_snapshots, &thread_id_map);
 
   MinidumpFileWriter minidump_file_writer;
-  minidump_file_writer.AddStream(crashpad::move(thread_list_writer));
-  minidump_file_writer.AddStream(crashpad::move(memory_list_writer));
+  minidump_file_writer.AddStream(std::move(thread_list_writer));
+  minidump_file_writer.AddStream(std::move(memory_list_writer));
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetThreadListStream(string_file.string(), &thread_list, &memory_list));
 
   ASSERT_EQ(3u, thread_list->NumberOfThreads);
@@ skipping 56 matching lines @@
 TEST(MinidumpThreadWriter, InitializeFromSnapshot_ThreadIDCollision) {
   RunInitializeFromSnapshotTest<InitializeFromSnapshotX86Traits>(true);
 }
 
 TEST(MinidumpThreadWriterDeathTest, NoContext) {
   MinidumpFileWriter minidump_file_writer;
   auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
 
   auto thread_writer = make_scoped_ptr(new MinidumpThreadWriter());
 
-  thread_list_writer->AddThread(crashpad::move(thread_writer));
-  minidump_file_writer.AddStream(crashpad::move(thread_list_writer));
+  thread_list_writer->AddThread(std::move(thread_writer));
+  minidump_file_writer.AddStream(std::move(thread_list_writer));
 
   StringFile string_file;
   ASSERT_DEATH_CHECK(minidump_file_writer.WriteEverything(&string_file),
                      "context_");
 }
 
 TEST(MinidumpThreadWriterDeathTest, InitializeFromSnapshot_NoContext) {
   ASSERT_DEATH_CHECK(
       RunInitializeFromSnapshotTest<InitializeFromSnapshotNoContextTraits>(
           false), "context_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad