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

third_party/WebKit/Source/platform/inspector_protocol/Dispatcher_cpp.template

 // This file is generated
 
 // Copyright (c) 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/inspector_protocol/{{class_name}}.h"
 
 #include "platform/inspector_protocol/Collections.h"
 #include "platform/inspector_protocol/FrontendChannel.h"
@@ skipping 49 matching lines @@
         m_frontendChannel = nullptr;
         for (auto& weak : m_weakPtrs)
             weak.first->dispose();
         m_weakPtrs.clear();
     }
 
     PassOwnPtr<DispatcherImplWeakPtr> weakPtr()
     {
         OwnPtr<DispatcherImplWeakPtr> weak = adoptPtr(new DispatcherImplWeakPtr(this));
         m_weakPtrs.add(weak.get());
-        return weak.release();
+        return weak;
     }
 
     virtual void dispatch(int sessionId, const String16& message);
     virtual void reportProtocolError(int sessionId, int callId, CommonErrorCode, const String16& errorMessage, ErrorSupport* errors) const;
     using Dispatcher::reportProtocolError;
 
     void sendResponse(int sessionId, int callId, const ErrorString& invocationError, ErrorSupport* errors, PassOwnPtr<protocol::DictionaryValue> result);
 
 {% for domain in api.domains %}
     virtual void registerAgent(blink::protocol::Backend::{{domain.domain}}* agent) { ASSERT(!m_{{domain.domain | lower}}Agent); m_{{domain.domain | lower}}Agent = agent; }
@@ skipping 90 matching lines @@
     {
         OwnPtr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
           {% for parameter in command.returns %}
             {% if "optional" in parameter %}
         if ({{parameter.name}}.isJust())
             resultObject->setValue("{{parameter.name}}", toValue({{parameter.name}}.fromJust()));
            {% else %}
         resultObject->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).to_raw_type % parameter.name}}));
             {% endif %}
           {% endfor %}
-        sendIfActive(resultObject.release(), ErrorString());
+        sendIfActive(std::move(resultObject), ErrorString());
     }
 
     void sendFailure(const ErrorString& error) override
     {
         ASSERT(error.length());
         sendIfActive(nullptr, error);
     }
 };
     {% endif %}
 
@@ skipping 49 matching lines @@
     ErrorString error;
     m_{{domain.domain | lower}}Agent->{{command.name}}(&error
       {%- for property in command.parameters -%}
         {%- if "optional" in property -%}
         , in_{{property.name}}
         {%- else -%}
         , {{resolve_type(property).to_pass_type % ("in_" + property.name)}}
         {%- endif -%}
       {%- endfor %}
       {%- if "async" in command -%}
-        , callback.release()
+        , std::move(callback)
       {%- elif "returns" in command %}
         {%- for property in command.returns -%}
           , &out_{{property.name}}
         {%- endfor %}
       {% endif %});
     {% if "returns" in command and not("async" in command) %}
     if (!error.length()) {
       {% for parameter in command.returns %}
         {% if "optional" in parameter %}
         if (out_{{parameter.name}}.isJust())
             result->setValue("{{parameter.name}}", toValue(out_{{parameter.name}}.fromJust()));
         {% else %}
         result->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).to_raw_type % ("out_" + parameter.name)}}));
         {% endif %}
       {% endfor %}
     }
     if (weak->get())
-        weak->get()->sendResponse(sessionId, callId, error, result.release());
+        weak->get()->sendResponse(sessionId, callId, error, std::move(result));
     {% elif not("async" in command) %}
     if (weak->get())
         weak->get()->sendResponse(sessionId, callId, error);
     {% endif %}
 }
   {% endfor %}
 {% endfor %}
 
 PassOwnPtr<Dispatcher> Dispatcher::create(FrontendChannel* frontendChannel)
 {
     return adoptPtr(new DispatcherImpl(frontendChannel));
 }
 
 void DispatcherImpl::dispatch(int sessionId, const String16& message)
 {
     int callId = 0;
     OwnPtr<protocol::Value> parsedMessage = parseJSON(message);
     ASSERT(parsedMessage);
-    OwnPtr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(parsedMessage.release());
+    OwnPtr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(std::move(parsedMessage));
     ASSERT(messageObject);
 
     protocol::Value* callIdValue = messageObject->get("id");
     bool success = callIdValue->asNumber(&callId);
     ASSERT_UNUSED(success, success);
 
     protocol::Value* methodValue = messageObject->get("method");
     String16 method;
     success = methodValue && methodValue->asString(&method);
     ASSERT_UNUSED(success, success);
 
     protocol::HashMap<String16, CallHandler>::iterator it = m_dispatchMap.find(method);
     if (it == m_dispatchMap.end()) {
         reportProtocolError(sessionId, callId, MethodNotFound, "'" + method + "' wasn't found");
         return;
     }
 
     protocol::ErrorSupport errors;
-    ((*this).*(*it->second))(sessionId, callId, messageObject.release(), &errors);
+    ((*this).*(*it->second))(sessionId, callId, std::move(messageObject), &errors);
 }
 
 void DispatcherImpl::sendResponse(int sessionId, int callId, const ErrorString& invocationError, ErrorSupport* errors, PassOwnPtr<protocol::DictionaryValue> result)
 {
     if (invocationError.length() || (errors && errors->hasErrors())) {
         reportProtocolError(sessionId, callId, ServerError, invocationError, errors);
         return;
     }
 
     OwnPtr<protocol::DictionaryValue> responseMessage = DictionaryValue::create();
     responseMessage->setNumber("id", callId);
     responseMessage->setObject("result", std::move(result));
     if (m_frontendChannel)
-        m_frontendChannel->sendProtocolResponse(sessionId, callId, responseMessage.release());
+        m_frontendChannel->sendProtocolResponse(sessionId, callId, std::move(responseMessage));
 }
 
 void Dispatcher::reportProtocolError(int sessionId, int callId, CommonErrorCode code, const String16& errorMessage) const
 {
     ErrorSupport errors;
     reportProtocolError(sessionId, callId, code, errorMessage, &errors);
 }
 
 void DispatcherImpl::reportProtocolError(int sessionId, int callId, CommonErrorCode code, const String16& errorMessage, ErrorSupport* errors) const
 {
     ASSERT(code >=0);
     ASSERT((unsigned)code < m_commonErrors.size());
     ASSERT(m_commonErrors[code]);
     OwnPtr<protocol::DictionaryValue> error = DictionaryValue::create();
     error->setNumber("code", m_commonErrors[code]);
     error->setString("message", errorMessage);
     ASSERT(error);
     if (errors && errors->hasErrors())
         error->setString("data", errors->errors());
     OwnPtr<protocol::DictionaryValue> message = DictionaryValue::create();
-    message->setObject("error", error.release());
+    message->setObject("error", std::move(error));
     message->setNumber("id", callId);
     if (m_frontendChannel)
-        m_frontendChannel->sendProtocolResponse(sessionId, callId, message.release());
+        m_frontendChannel->sendProtocolResponse(sessionId, callId, std::move(message));
 }
 
 bool Dispatcher::getCommandName(const String16& message, String16* result)
 {
     OwnPtr<protocol::Value> value = parseJSON(message);
     if (!value)
         return false;
 
     protocol::DictionaryValue* object = DictionaryValue::cast(value.get());
     if (!object)
         return false;
 
     if (!object->getString("method", result))
         return false;
 
     return true;
 }
 
 } // namespace protocol
 } // namespace blink