Replace SmartPointer<T> with unique_ptr<T>

test/cctest/interpreter/generate-bytecode-expectations.cc

 // Copyright 2016 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.
 
 #include <cstring>
 #include <fstream>
+#include <memory>
 #include <vector>
 
 #include "test/cctest/interpreter/bytecode-expectations-printer.h"
 
 #include "include/libplatform/libplatform.h"
 #include "include/v8.h"
 
 #include "src/base/logging.h"
-#include "src/base/smart-pointers.h"
 #include "src/compiler.h"
 #include "src/interpreter/interpreter.h"
 
 #ifdef V8_OS_POSIX
 #include <dirent.h>
 #endif
 
 using v8::internal::interpreter::BytecodeExpectationsPrinter;
 
 #define REPORT_ERROR(MESSAGE) (((std::cerr << "ERROR: ") << MESSAGE) << '\n')
@@ skipping 69 matching lines @@
 
 class V8InitializationScope final {
  public:
   explicit V8InitializationScope(const char* exec_path);
   ~V8InitializationScope();
 
   v8::Platform* platform() const { return platform_.get(); }
   v8::Isolate* isolate() const { return isolate_; }
 
  private:
-  v8::base::SmartPointer<v8::Platform> platform_;
-  v8::base::SmartPointer<v8::ArrayBuffer::Allocator> allocator_;
+  std::unique_ptr<v8::Platform> platform_;
+  std::unique_ptr<v8::ArrayBuffer::Allocator> allocator_;
   v8::Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(V8InitializationScope);
 };
 
 BytecodeExpectationsPrinter::ConstantPoolType ParseConstantPoolType(
     const char* type_string) {
   if (strcmp(type_string, "number") == 0) {
     return BytecodeExpectationsPrinter::ConstantPoolType::kNumber;
   } else if (strcmp(type_string, "string") == 0) {
@@ skipping 230 matching lines @@
   i::FLAG_ignition = true;
   i::FLAG_always_opt = false;
   i::FLAG_allow_natives_syntax = true;
 
   v8::V8::InitializeICUDefaultLocation(exec_path);
   v8::V8::InitializeExternalStartupData(exec_path);
   v8::V8::InitializePlatform(platform_.get());
   v8::V8::Initialize();
 
   v8::Isolate::CreateParams create_params;
-  allocator_.Reset(v8::ArrayBuffer::Allocator::NewDefaultAllocator());
+  allocator_.reset(v8::ArrayBuffer::Allocator::NewDefaultAllocator());
   create_params.array_buffer_allocator = allocator_.get();
 
   isolate_ = v8::Isolate::New(create_params);
 }
 
 V8InitializationScope::~V8InitializationScope() {
   isolate_->Dispose();
   v8::V8::Dispose();
   v8::V8::ShutdownPlatform();
 }
@@ skipping 197 matching lines @@
     }
   }
 
   if (!options.rebaseline()) {
     if (!WriteExpectationsFile(snippet_list, platform, options,
                                options.output_filename())) {
       return 3;
     }
   }
 }