Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/bindings/core/v8/V8PerIsolateData.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 19 matching lines @@
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "bindings/core/v8/V8ObjectConstructor.h"
 #include "bindings/core/v8/V8PrivateProperty.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/frame/Deprecation.h"
 #include "core/inspector/MainThreadDebugger.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "public/platform/Platform.h"
 #include "wtf/LeakAnnotations.h"
-#include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 static V8PerIsolateData* mainThreadPerIsolateData = 0;
 
 static void beforeCallEnteredCallback(v8::Isolate* isolate)
 {
     RELEASE_ASSERT(!ScriptForbiddenScope::isScriptForbidden());
 }
 
 static void microtasksCompletedCallback(v8::Isolate* isolate)
 {
     V8PerIsolateData::from(isolate)->runEndOfScopeTasks();
 }
 
 V8PerIsolateData::V8PerIsolateData()
-    : m_isolateHolder(wrapUnique(new gin::IsolateHolder()))
-    , m_stringCache(wrapUnique(new StringCache(isolate())))
+    : m_isolateHolder(adoptPtr(new gin::IsolateHolder()))
+    , m_stringCache(adoptPtr(new StringCache(isolate())))
     , m_hiddenValue(V8HiddenValue::create())
     , m_privateProperty(V8PrivateProperty::create())
     , m_constructorMode(ConstructorMode::CreateNewObject)
     , m_useCounterDisabled(false)
     , m_isHandlingRecursionLevelError(false)
     , m_isReportingException(false)
 {
     // FIXME: Remove once all v8::Isolate::GetCurrent() calls are gone.
     isolate()->Enter();
     isolate()->AddBeforeCallEnteredCallback(&beforeCallEnteredCallback);
@@ skipping 14 matching lines @@
 }
 
 v8::Isolate* V8PerIsolateData::initialize()
 {
     V8PerIsolateData* data = new V8PerIsolateData();
     v8::Isolate* isolate = data->isolate();
     isolate->SetData(gin::kEmbedderBlink, data);
     return isolate;
 }
 
-void V8PerIsolateData::enableIdleTasks(v8::Isolate* isolate, std::unique_ptr<gin::V8IdleTaskRunner> taskRunner)
+void V8PerIsolateData::enableIdleTasks(v8::Isolate* isolate, PassOwnPtr<gin::V8IdleTaskRunner> taskRunner)
 {
-    from(isolate)->m_isolateHolder->EnableIdleTasks(std::unique_ptr<gin::V8IdleTaskRunner>(taskRunner.release()));
+    from(isolate)->m_isolateHolder->EnableIdleTasks(std::unique_ptr<gin::V8IdleTaskRunner>(taskRunner.leakPtr()));
 }
 
 void V8PerIsolateData::useCounterCallback(v8::Isolate* isolate, v8::Isolate::UseCounterFeature feature)
 {
     if (V8PerIsolateData::from(isolate)->m_useCounterDisabled)
         return;
 
     UseCounter::Feature blinkFeature;
     bool deprecated = false;
     switch (feature) {
@@ skipping 233 matching lines @@
 {
     if (value.IsEmpty() || !value->IsObject())
         return v8::Local<v8::Object>();
     auto result = map.find(info);
     if (result == map.end())
         return v8::Local<v8::Object>();
     v8::Local<v8::FunctionTemplate> templ = result->value.Get(isolate());
     return v8::Local<v8::Object>::Cast(value)->FindInstanceInPrototypeChain(templ);
 }
 
-void V8PerIsolateData::addEndOfScopeTask(std::unique_ptr<EndOfScopeTask> task)
+void V8PerIsolateData::addEndOfScopeTask(PassOwnPtr<EndOfScopeTask> task)
 {
     m_endOfScopeTasks.append(std::move(task));
 }
 
 void V8PerIsolateData::runEndOfScopeTasks()
 {
-    Vector<std::unique_ptr<EndOfScopeTask>> tasks;
+    Vector<OwnPtr<EndOfScopeTask>> tasks;
     tasks.swap(m_endOfScopeTasks);
     for (const auto& task : tasks)
         task->run();
     ASSERT(m_endOfScopeTasks.isEmpty());
 }
 
 void V8PerIsolateData::clearEndOfScopeTasks()
 {
     m_endOfScopeTasks.clear();
 }
 
-void V8PerIsolateData::setThreadDebugger(std::unique_ptr<ThreadDebugger> threadDebugger)
+void V8PerIsolateData::setThreadDebugger(PassOwnPtr<ThreadDebugger> threadDebugger)
 {
     ASSERT(!m_threadDebugger);
     m_threadDebugger = std::move(threadDebugger);
 }
 
 ThreadDebugger* V8PerIsolateData::threadDebugger()
 {
     return m_threadDebugger.get();
 }
 
 void V8PerIsolateData::addActiveScriptWrappable(ActiveScriptWrappable* wrappable)
 {
     if (!m_activeScriptWrappables)
         m_activeScriptWrappables = new ActiveScriptWrappableSet();
 
     m_activeScriptWrappables->add(wrappable);
 }
 
 } // namespace blink