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

minidump/minidump_thread_writer.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 <sys/types.h>
 
+#include <utility>
+
 #include "base/logging.h"
 #include "minidump/minidump_context_writer.h"
 #include "minidump/minidump_memory_writer.h"
 #include "snapshot/memory_snapshot.h"
 #include "snapshot/thread_snapshot.h"
 #include "util/file/file_writer.h"
-#include "util/stdlib/move.h"
 #include "util/numeric/safe_assignment.h"
 
 namespace crashpad {
 
 MinidumpThreadWriter::MinidumpThreadWriter()
     : MinidumpWritable(), thread_(), stack_(nullptr), context_(nullptr) {
 }
 
 MinidumpThreadWriter::~MinidumpThreadWriter() {
 }
@@ skipping 10 matching lines @@
   SetThreadID(thread_id_it->second);
 
   SetSuspendCount(thread_snapshot->SuspendCount());
   SetPriority(thread_snapshot->Priority());
   SetTEB(thread_snapshot->ThreadSpecificDataAddress());
 
   const MemorySnapshot* stack_snapshot = thread_snapshot->Stack();
   if (stack_snapshot && stack_snapshot->Size() > 0) {
     scoped_ptr<MinidumpMemoryWriter> stack =
         MinidumpMemoryWriter::CreateFromSnapshot(stack_snapshot);
-    SetStack(crashpad::move(stack));
+    SetStack(std::move(stack));
   }
 
   scoped_ptr<MinidumpContextWriter> context =
       MinidumpContextWriter::CreateFromSnapshot(thread_snapshot->Context());
-  SetContext(crashpad::move(context));
+  SetContext(std::move(context));
 }
 
 const MINIDUMP_THREAD* MinidumpThreadWriter::MinidumpThread() const {
   DCHECK_EQ(state(), kStateWritable);
 
   return &thread_;
 }
 
 void MinidumpThreadWriter::SetStack(scoped_ptr<MinidumpMemoryWriter> stack) {
   DCHECK_EQ(state(), kStateMutable);
 
-  stack_ = crashpad::move(stack);
+  stack_ = std::move(stack);
 }
 
 void MinidumpThreadWriter::SetContext(
     scoped_ptr<MinidumpContextWriter> context) {
   DCHECK_EQ(state(), kStateMutable);
 
-  context_ = crashpad::move(context);
+  context_ = std::move(context);
 }
 
 bool MinidumpThreadWriter::Freeze() {
   DCHECK_EQ(state(), kStateMutable);
   CHECK(context_);
 
   if (!MinidumpWritable::Freeze()) {
     return false;
   }
 
@@ skipping 51 matching lines @@
     const std::vector<const ThreadSnapshot*>& thread_snapshots,
     MinidumpThreadIDMap* thread_id_map) {
   DCHECK_EQ(state(), kStateMutable);
   DCHECK(threads_.empty());
 
   BuildMinidumpThreadIDMap(thread_snapshots, thread_id_map);
 
   for (const ThreadSnapshot* thread_snapshot : thread_snapshots) {
     auto thread = make_scoped_ptr(new MinidumpThreadWriter());
     thread->InitializeFromSnapshot(thread_snapshot, thread_id_map);
-    AddThread(crashpad::move(thread));
+    AddThread(std::move(thread));
   }
 
   // Do this in a separate loop to keep the thread stacks earlier in the dump,
   // and together.
   for (const ThreadSnapshot* thread_snapshot : thread_snapshots)
     memory_list_writer_->AddFromSnapshot(thread_snapshot->ExtraMemory());
 }
 
 void MinidumpThreadListWriter::SetMemoryListWriter(
     MinidumpMemoryListWriter* memory_list_writer) {
@@ skipping 65 matching lines @@
   }
 
   return file_writer->WriteIoVec(&iovecs);
 }
 
 MinidumpStreamType MinidumpThreadListWriter::StreamType() const {
   return kMinidumpStreamTypeThreadList;
 }
 
 }  // namespace crashpad