Replace SmartArrayPointer<T> with unique_ptr<T[]>

src/wasm/wasm-result.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_WASM_RESULT_H_
 #define V8_WASM_RESULT_H_
 
+#include <memory>
+
 #include "src/base/compiler-specific.h"
 #include "src/base/smart-pointers.h"
 
 #include "src/handles.h"
 #include "src/globals.h"
 
 namespace v8 {
 namespace internal {
 
 class Isolate;
@@ skipping 14 matching lines @@
   kTypeError,             // type mismatch
   kInvalidLocalIndex,     // invalid local
   kInvalidGlobalIndex,    // invalid global
   kInvalidFunctionIndex,  // invalid function
   kInvalidMemType         // invalid memory type
 };
 
 // The overall result of decoding a function or a module.
 template <typename T>
 struct Result {
-  Result() : val(), error_code(kSuccess), start(nullptr), error_pc(nullptr) {
-    error_msg.Reset(nullptr);
+  Result() : val(), error_code(kSuccess), start(nullptr), error_pc(nullptr) {}
+  Result(Result&& other) { *this = std::move(other); }
+  Result& operator=(Result&& other) {
+    MoveFrom(other);
+    val = other.val;
+    return *this;
   }
 
   T val;
   ErrorCode error_code;
   const byte* start;
   const byte* error_pc;
   const byte* error_pt;
-  base::SmartArrayPointer<char> error_msg;
+  std::unique_ptr<char[]> error_msg;
 
   bool ok() const { return error_code == kSuccess; }
   bool failed() const { return error_code != kSuccess; }
 
   template <typename V>
-  void CopyFrom(Result<V>& that) {
+  void MoveFrom(Result<V>& that) {
     error_code = that.error_code;
     start = that.start;
     error_pc = that.error_pc;
     error_pt = that.error_pt;
-    error_msg = that.error_msg;
+    error_msg.swap(that.error_msg);

[Igor Sheludko, 2016/07/25 09:37:32]

Since "that" is probably going to live for a while
  error_msg = std::move(that.error_msg);
is more correct here.

[jochen (gone - plz use gerrit), 2016/07/25 10:35:08]

done

   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Result);
 };
 
 template <typename T>
 std::ostream& operator<<(std::ostream& os, const Result<T>& result) {
   os << "Result = ";
   if (result.ok()) {
     if (result.val != nullptr) {
       os << *result.val;
     } else {
       os << "success (no value)";
@@ skipping 41 matching lines @@
  private:
   Isolate* isolate_;
   const char* context_;
   i::Handle<i::String> message_;
 };
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif