Revert "Remove OwnPtr from Blink."

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

 // Copyright 2014 The Chromium 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 "bindings/core/v8/ScriptStreamer.h"
 
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/PendingScript.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/frame/Settings.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/WebScheduler.h"
 #include "wtf/Deque.h"
-#include "wtf/PtrUtil.h"
 #include "wtf/text/TextEncodingRegistry.h"
-#include <memory>
 
 namespace blink {
 
 namespace {
 
 void recordStartedStreamingHistogram(ScriptStreamer::Type scriptType, int reason)
 {
     switch (scriptType) {
     case ScriptStreamer::ParsingBlocking: {
         DEFINE_STATIC_LOCAL(EnumerationHistogram, parseBlockingHistogram, ("WebCore.Scripts.ParsingBlocking.StartedStreaming", 2));
@@ skipping 140 matching lines @@
     WTF_MAKE_NONCOPYABLE(SourceStream);
 public:
     explicit SourceStream(WebTaskRunner* loadingTaskRunner)
         : v8::ScriptCompiler::ExternalSourceStream()
         , m_cancelled(false)
         , m_finished(false)
         , m_queueLeadPosition(0)
         , m_queueTailPosition(0)
         , m_bookmarkPosition(0)
         , m_lengthOfBOM(0)
-        , m_loadingTaskRunner(wrapUnique(loadingTaskRunner->clone()))
+        , m_loadingTaskRunner(adoptPtr(loadingTaskRunner->clone()))
     {
     }
 
     virtual ~SourceStream() override { }
 
     // Called by V8 on a background thread. Should block until we can return
     // some data.
     size_t GetMoreData(const uint8_t** src) override
     {
         ASSERT(!isMainThread());
@@ skipping 187 matching lines @@
     //   (i.e., without BOM)
     // - m_queueTailPosition counts the bytes that Chrome has sent
     //   (i.e., with BOM)
     // So when resetting the bookmark, we have to adjust the lead position
     // to account for the BOM (which happens implicitly in the regular
     // streaming case).
     // We store this separately, to avoid having to guard all
     // m_queueLeadPosition references with a mutex.
     size_t m_lengthOfBOM; // Used by both threads; guarded by m_mutex.
 
-    std::unique_ptr<WebTaskRunner> m_loadingTaskRunner;
+    OwnPtr<WebTaskRunner> m_loadingTaskRunner;
 };
 
 size_t ScriptStreamer::s_smallScriptThreshold = 30 * 1024;
 
 void ScriptStreamer::startStreaming(PendingScript* script, Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
     // We don't yet know whether the script will really be streamed. E.g.,
     // suppressing streaming for short scripts is done later. Record only the
     // sure negative cases here.
     bool startedStreaming = startStreamingInternal(script, scriptType, settings, scriptState, loadingTaskRunner);
@@ skipping 92 matching lines @@
         // possible that resource->encoding() returns a different encoding
         // before the loading has started and after we got some data.  In
         // addition, check for byte order marks. Note that checking the byte
         // order mark might change the encoding. We cannot decode the full text
         // here, because it might contain incomplete UTF-8 characters. Also note
         // that have at least s_smallScriptThreshold worth of data, which is more
         // than enough for detecting a BOM.
         const char* data = 0;
         size_t length = resource->resourceBuffer()->getSomeData(data, static_cast<size_t>(0));
 
-        std::unique_ptr<TextResourceDecoder> decoder(TextResourceDecoder::create("application/javascript", resource->encoding()));
+        OwnPtr<TextResourceDecoder> decoder(TextResourceDecoder::create("application/javascript", resource->encoding()));
         lengthOfBOM = decoder->checkForBOM(data, length);
 
         // Maybe the encoding changed because we saw the BOM; get the encoding
         // from the decoder.
         if (!convertEncoding(decoder->encoding().name(), &m_encoding)) {
             suppressStreaming();
             recordNotStreamingReasonHistogram(m_scriptType, EncodingNotSupported);
             recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
@@ skipping 12 matching lines @@
             suppressStreaming();
             recordNotStreamingReasonHistogram(m_scriptType, ContextNotValid);
             recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
         ASSERT(!m_stream);
         ASSERT(!m_source);
         m_stream = new SourceStream(m_loadingTaskRunner.get());
         // m_source takes ownership of m_stream.
-        m_source = wrapUnique(new v8::ScriptCompiler::StreamedSource(m_stream, m_encoding));
+        m_source = adoptPtr(new v8::ScriptCompiler::StreamedSource(m_stream, m_encoding));
 
         ScriptState::Scope scope(m_scriptState.get());
-        std::unique_ptr<v8::ScriptCompiler::ScriptStreamingTask> scriptStreamingTask(wrapUnique(v8::ScriptCompiler::StartStreamingScript(m_scriptState->isolate(), m_source.get(), m_compileOptions)));
+        OwnPtr<v8::ScriptCompiler::ScriptStreamingTask> scriptStreamingTask(adoptPtr(v8::ScriptCompiler::StartStreamingScript(m_scriptState->isolate(), m_source.get(), m_compileOptions)));
         if (!scriptStreamingTask) {
             // V8 cannot stream the script.
             suppressStreaming();
             m_stream = 0;
             m_source.reset();
             recordNotStreamingReasonHistogram(m_scriptType, V8CannotStream);
             recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
@@ skipping 32 matching lines @@
     , m_loadingFinished(false)
     , m_parsingFinished(false)
     , m_haveEnoughDataForStreaming(false)
     , m_streamingSuppressed(false)
     , m_compileOptions(compileOptions)
     , m_scriptState(scriptState)
     , m_scriptType(scriptType)
     , m_scriptURLString(m_resource->url().copy().getString())
     , m_scriptResourceIdentifier(m_resource->identifier())
     , m_encoding(v8::ScriptCompiler::StreamedSource::TWO_BYTE) // Unfortunately there's no dummy encoding value in the enum; let's use one we don't stream.
-    , m_loadingTaskRunner(wrapUnique(loadingTaskRunner->clone()))
+    , m_loadingTaskRunner(adoptPtr(loadingTaskRunner->clone()))
 {
 }
 
 ScriptStreamer::~ScriptStreamer()
 {
 }
 
 DEFINE_TRACE(ScriptStreamer)
 {
     visitor->trace(m_pendingScript);
@@ skipping 69 matching lines @@
 
     // The Resource might go out of scope if the script is no longer
     // needed. This makes PendingScript notify the ScriptStreamer when it is
     // destroyed.
     script->setStreamer(ScriptStreamer::create(script, scriptType, scriptState, compileOption, loadingTaskRunner));
 
     return true;
 }
 
 } // namespace blink