Remove OwnPtr from Blink.

third_party/WebKit/Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 40 matching lines @@
 #include "core/inspector/ScriptArguments.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/v8_inspector/public/ConsoleTypes.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "wtf/AddressSanitizer.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/typed_arrays/ArrayBufferContents.h"
+#include <memory>
 #include <v8-debug.h>
 #include <v8-profiler.h>
 
 namespace blink {
 
 static Frame* findFrame(v8::Isolate* isolate, v8::Local<v8::Object> host, v8::Local<v8::Value> data)
 {
     const WrapperTypeInfo* type = WrapperTypeInfo::unwrap(data);
 
     if (V8Window::wrapperTypeInfo.equals(type)) {
@@ skipping 42 matching lines @@
 
     if (isolate->GetEnteredContext().IsEmpty())
         return;
 
     // If called during context initialization, there will be no entered context.
     ScriptState* scriptState = ScriptState::current(isolate);
     if (!scriptState->contextIsValid())
         return;
 
     ExecutionContext* context = scriptState->getExecutionContext();
-    OwnPtr<SourceLocation> location = SourceLocation::fromMessage(isolate, message, context);
+    std::unique_ptr<SourceLocation> location = SourceLocation::fromMessage(isolate, message, context);
 
     AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
     if (message->IsOpaque())
         accessControlStatus = OpaqueResource;
     else if (message->IsSharedCrossOrigin())
         accessControlStatus = SharableCrossOrigin;
 
     ErrorEvent* event = ErrorEvent::create(toCoreStringWithNullCheck(message->Get()), std::move(location), &scriptState->world());
 
     String messageForConsole = extractMessageForConsole(isolate, data);
@@ skipping 58 matching lines @@
         // Try to get the stack & location from a wrapped exception object (e.g. DOMException).
         ASSERT(exception->IsObject());
         v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(exception);
         v8::Local<v8::Value> error = V8HiddenValue::getHiddenValue(scriptState, obj, V8HiddenValue::error(isolate));
         if (!error.IsEmpty())
             exception = error;
     }
 
     String errorMessage;
     AccessControlStatus corsStatus = NotSharableCrossOrigin;
-    OwnPtr<SourceLocation> location;
+    std::unique_ptr<SourceLocation> location;
 
     v8::Local<v8::Message> message = v8::Exception::CreateMessage(isolate, exception);
     if (!message.IsEmpty()) {
         // message->Get() can be empty here. https://crbug.com/450330
         errorMessage = toCoreStringWithNullCheck(message->Get());
         location = SourceLocation::fromMessage(isolate, message, context);
         if (message->IsSharedCrossOrigin())
             corsStatus = SharableCrossOrigin;
     } else {
         location = SourceLocation::create(context->url().getString(), 0, 0, nullptr);
@@ skipping 139 matching lines @@
 
     initializeV8Common(isolate);
 
     isolate->SetFatalErrorHandler(reportFatalErrorInMainThread);
     isolate->AddMessageListener(messageHandlerInMainThread);
     isolate->SetFailedAccessCheckCallbackFunction(failedAccessCheckCallbackInMainThread);
     isolate->SetAllowCodeGenerationFromStringsCallback(codeGenerationCheckCallbackInMainThread);
 
     if (RuntimeEnabledFeatures::v8IdleTasksEnabled()) {
         WebScheduler* scheduler = Platform::current()->currentThread()->scheduler();
-        V8PerIsolateData::enableIdleTasks(isolate, adoptPtr(new V8IdleTaskRunner(scheduler)));
+        V8PerIsolateData::enableIdleTasks(isolate, wrapUnique(new V8IdleTaskRunner(scheduler)));
     }
 
     isolate->SetPromiseRejectCallback(promiseRejectHandlerInMainThread);
 
     if (v8::HeapProfiler* profiler = isolate->GetHeapProfiler())
         profiler->SetWrapperClassInfoProvider(WrapperTypeInfo::NodeClassId, &RetainedDOMInfo::createRetainedDOMInfo);
 
     ASSERT(ThreadState::mainThreadState());
-    ThreadState::mainThreadState()->addInterruptor(adoptPtr(new V8IsolateInterruptor(isolate)));
+    ThreadState::mainThreadState()->addInterruptor(wrapUnique(new V8IsolateInterruptor(isolate)));
     if (RuntimeEnabledFeatures::traceWrappablesEnabled()) {
         ThreadState::mainThreadState()->registerTraceDOMWrappers(isolate,
             V8GCController::traceDOMWrappers,
             ScriptWrappableVisitor::invalidateDeadObjectsInMarkingDeque);
     } else {
         ThreadState::mainThreadState()->registerTraceDOMWrappers(isolate,
             V8GCController::traceDOMWrappers,
             nullptr);
     }
 
-    V8PerIsolateData::from(isolate)->setThreadDebugger(adoptPtr(new MainThreadDebugger(isolate)));
+    V8PerIsolateData::from(isolate)->setThreadDebugger(wrapUnique(new MainThreadDebugger(isolate)));
 }
 
 void V8Initializer::shutdownMainThread()
 {
     ASSERT(isMainThread());
     v8::Isolate* isolate = V8PerIsolateData::mainThreadIsolate();
     V8PerIsolateData::willBeDestroyed(isolate);
     V8PerIsolateData::destroy(isolate);
 }
 
@@ skipping 14 matching lines @@
         return;
 
     // Exceptions that occur in error handler should be ignored since in that case
     // WorkerGlobalScope::reportException will send the exception to the worker object.
     if (perIsolateData->isReportingException())
         return;
 
     perIsolateData->setReportingException(true);
 
     ExecutionContext* context = scriptState->getExecutionContext();
-    OwnPtr<SourceLocation> location = SourceLocation::fromMessage(isolate, message, context);
+    std::unique_ptr<SourceLocation> location = SourceLocation::fromMessage(isolate, message, context);
     ErrorEvent* event = ErrorEvent::create(toCoreStringWithNullCheck(message->Get()), std::move(location), &scriptState->world());
 
     AccessControlStatus corsStatus = message->IsSharedCrossOrigin() ? SharableCrossOrigin : NotSharableCrossOrigin;
 
     // If execution termination has been triggered as part of constructing
     // the error event from the v8::Message, quietly leave.
     if (!isolate->IsExecutionTerminating()) {
         V8ErrorHandler::storeExceptionOnErrorEventWrapper(scriptState, event, data, scriptState->context()->Global());
         scriptState->getExecutionContext()->reportException(event, corsStatus);
     }
@@ skipping 13 matching lines @@
 
     isolate->AddMessageListener(messageHandlerInWorker);
     isolate->SetFatalErrorHandler(reportFatalErrorInWorker);
 
     uint32_t here;
     isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here - kWorkerMaxStackSize / sizeof(uint32_t*)));
     isolate->SetPromiseRejectCallback(promiseRejectHandlerInWorker);
 }
 
 } // namespace blink