Remove OwnPtr::release() calls in platform/ (part inspector).

third_party/WebKit/Source/platform/v8_inspector/V8StringUtil.cpp

 // Copyright 2016 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 "platform/v8_inspector/V8StringUtil.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8Regex.h"
@@ skipping 92 matching lines @@
     while (start < text.length()) {
         size_t lineEnd = text.find('\n', start);
         if (lineEnd == kNotFound)
             break;
 
         result->append(static_cast<unsigned>(lineEnd));
         start = lineEnd + 1;
     }
     result->append(text.length());
 
-    return result.release();
+    return result;
 }
 
 protocol::Vector<std::pair<int, String16>> scriptRegexpMatchesByLines(const V8Regex& regex, const String16& text)
 {
     protocol::Vector<std::pair<int, String16>> result;
     if (text.isEmpty())
         return result;
 
     OwnPtr<protocol::Vector<unsigned>> endings(lineEndings(text));
     unsigned size = endings->size();
@@ skipping 73 matching lines @@
 
 PassOwnPtr<protocol::Array<protocol::Debugger::SearchMatch>> searchInTextByLines(V8InspectorSession* session, const String16& text, const String16& query, const bool caseSensitive, const bool isRegex)
 {
     OwnPtr<protocol::Array<protocol::Debugger::SearchMatch>> result = protocol::Array<protocol::Debugger::SearchMatch>::create();
     OwnPtr<V8Regex> regex = createSearchRegex(static_cast<V8InspectorSessionImpl*>(session)->debugger(), query, caseSensitive, isRegex);
     protocol::Vector<std::pair<int, String16>> matches = scriptRegexpMatchesByLines(*regex.get(), text);
 
     for (const auto& match : matches)
         result->addItem(buildObjectForSearchMatch(match.first, match.second));
 
-    return result.release();
+    return result;
 }
 
 } // namespace V8ContentSearchUtil
 
 PassOwnPtr<protocol::Value> toProtocolValue(v8::Local<v8::Context> context, v8::Local<v8::Value> value, int maxDepth)
 {
     if (value.IsEmpty()) {
         ASSERT_NOT_REACHED();
         return nullptr;
     }
@@ skipping 14 matching lines @@
         v8::Local<v8::Array> array = value.As<v8::Array>();
         OwnPtr<protocol::ListValue> inspectorArray = protocol::ListValue::create();
         uint32_t length = array->Length();
         for (uint32_t i = 0; i < length; i++) {
             v8::Local<v8::Value> value;
             if (!array->Get(context, i).ToLocal(&value))
                 return nullptr;
             OwnPtr<protocol::Value> element = toProtocolValue(context, value, maxDepth);
             if (!element)
                 return nullptr;
-            inspectorArray->pushValue(element.release());
+            inspectorArray->pushValue(std::move(element));
         }
-        return inspectorArray.release();
+        return std::move(inspectorArray);
     }
     if (value->IsObject()) {
         OwnPtr<protocol::DictionaryValue> jsonObject = protocol::DictionaryValue::create();
         v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(value);
         v8::Local<v8::Array> propertyNames;
         if (!object->GetPropertyNames(context).ToLocal(&propertyNames))
             return nullptr;
         uint32_t length = propertyNames->Length();
         for (uint32_t i = 0; i < length; i++) {
             v8::Local<v8::Value> name;
             if (!propertyNames->Get(context, i).ToLocal(&name))
                 return nullptr;
             // FIXME(yurys): v8::Object should support GetOwnPropertyNames
             if (name->IsString()) {
                 v8::Maybe<bool> hasRealNamedProperty = object->HasRealNamedProperty(context, v8::Local<v8::String>::Cast(name));
                 if (!hasRealNamedProperty.IsJust() || !hasRealNamedProperty.FromJust())
                     continue;
             }
             v8::Local<v8::String> propertyName;
             if (!name->ToString(context).ToLocal(&propertyName))
                 continue;
             v8::Local<v8::Value> property;
             if (!object->Get(context, name).ToLocal(&property))
                 return nullptr;
             OwnPtr<protocol::Value> propertyValue = toProtocolValue(context, property, maxDepth);
             if (!propertyValue)
                 return nullptr;
-            jsonObject->setValue(toProtocolString(propertyName), propertyValue.release());
+            jsonObject->setValue(toProtocolString(propertyName), std::move(propertyValue));
         }
-        return jsonObject.release();
+        return std::move(jsonObject);
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 } // namespace blink