Remove OwnPtr::release() calls in modules/ (part 1).

third_party/WebKit/Source/modules/accessibility/InspectorAccessibilityAgent.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 "modules/accessibility/InspectorAccessibilityAgent.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Element.h"
@@ skipping 231 matching lines @@
     }
 
     if (roleAllowsSelected(role)) {
         properties->addItem(createProperty(AXWidgetStatesEnum::Selected, createBooleanValue(axObject->isSelected())));
     }
 }
 
 PassOwnPtr<AXProperty> createRelatedNodeListProperty(const String& key, AXRelatedObjectVector& nodes)
 {
     OwnPtr<AXValue> nodeListValue = createRelatedNodeListValue(nodes, AXValueTypeEnum::NodeList);
-    return createProperty(key, nodeListValue.release());
+    return createProperty(key, std::move(nodeListValue));
 }
 
 PassOwnPtr<AXProperty> createRelatedNodeListProperty(const String& key, AXObject::AXObjectVector& nodes, const QualifiedName& attr, AXObject* axObject)
 {
     OwnPtr<AXValue> nodeListValue = createRelatedNodeListValue(nodes);
     const AtomicString& attrValue = axObject->getAttribute(attr);
     nodeListValue->setValue(protocol::StringValue::create(attrValue));
-    return createProperty(key, nodeListValue.release());
+    return createProperty(key, std::move(nodeListValue));
 }
 
 void fillRelationships(AXObject* axObject, protocol::Array<AXProperty>* properties)
 {
     if (AXObject* activeDescendant = axObject->activeDescendant()) {
         properties->addItem(createProperty(AXRelationshipAttributesEnum::Activedescendant, createRelatedNodeListValue(activeDescendant)));
     }
 
     AXObject::AXObjectVector results;
     axObject->ariaFlowToElements(results);
@@ skipping 19 matching lines @@
 
 PassOwnPtr<AXValue> createRoleNameValue(AccessibilityRole role)
 {
     AtomicString roleName = AXObject::roleName(role);
     OwnPtr<AXValue> roleNameValue;
     if (!roleName.isNull()) {
         roleNameValue = createValue(roleName, AXValueTypeEnum::Role);
     } else {
         roleNameValue = createValue(AXObject::internalRoleName(role), AXValueTypeEnum::InternalRole);
     }
-    return roleNameValue.release();
+    return roleNameValue;
 }
 
 PassOwnPtr<AXNode> buildObjectForIgnoredNode(Node* node, AXObject* axObject, AXObjectCacheImpl* cacheImpl)
 {
     AXObject::IgnoredReasons ignoredReasons;
 
     AXID axID = 0;
     OwnPtr<AXNode> ignoredNodeObject = AXNode::create().setNodeId(String::number(axID)).setIgnored(true).build();
     if (axObject) {
         axObject->computeAccessibilityIsIgnored(&ignoredReasons);
         axID = axObject->axObjectID();
         AccessibilityRole role = axObject->roleValue();
         ignoredNodeObject->setRole(createRoleNameValue(role));
     } else if (!node->layoutObject()) {
         ignoredReasons.append(IgnoredReason(AXNotRendered));
     }
 
     OwnPtr<protocol::Array<AXProperty>> ignoredReasonProperties = protocol::Array<AXProperty>::create();
     for (size_t i = 0; i < ignoredReasons.size(); i++)
         ignoredReasonProperties->addItem(createProperty(ignoredReasons[i]));
-    ignoredNodeObject->setIgnoredReasons(ignoredReasonProperties.release());
+    ignoredNodeObject->setIgnoredReasons(std::move(ignoredReasonProperties));
 
-    return ignoredNodeObject.release();
+    return ignoredNodeObject;
 }
 
 PassOwnPtr<AXNode> buildObjectForNode(Node* node, AXObject* axObject, AXObjectCacheImpl* cacheImpl, PassOwnPtr<protocol::Array<AXProperty>> properties)
 {
     AccessibilityRole role = axObject->roleValue();
     OwnPtr<AXNode> nodeObject = AXNode::create().setNodeId(String::number(axObject->axObjectID())).setIgnored(false).build();
     nodeObject->setRole(createRoleNameValue(role));
 
     AXObject::NameSources nameSources;
     String computedName = axObject->name(&nameSources);
     if (!nameSources.isEmpty()) {
         OwnPtr<AXValue> name = createValue(computedName, AXValueTypeEnum::ComputedString);
         if (!nameSources.isEmpty()) {
             OwnPtr<protocol::Array<AXValueSource>> nameSourceProperties = protocol::Array<AXValueSource>::create();
             for (size_t i = 0; i < nameSources.size(); ++i) {
                 NameSource& nameSource = nameSources[i];
                 nameSourceProperties->addItem(createValueSource(nameSource));
                 if (nameSource.text.isNull() || nameSource.superseded)
                     continue;
                 if (!nameSource.relatedObjects.isEmpty()) {
                     properties->addItem(createRelatedNodeListProperty(AXRelationshipAttributesEnum::Labelledby, nameSource.relatedObjects));
                 }
             }
-            name->setSources(nameSourceProperties.release());
+            name->setSources(std::move(nameSourceProperties));
         }
         nodeObject->setProperties(std::move(properties));
-        nodeObject->setName(name.release());
+        nodeObject->setName(std::move(name));
     } else {
         nodeObject->setProperties(std::move(properties));
     }
 
     fillCoreProperties(axObject, nodeObject.get());
-    return nodeObject.release();
+    return nodeObject;
 }
 
 } // namespace
 
 InspectorAccessibilityAgent::InspectorAccessibilityAgent(Page* page, InspectorDOMAgent* domAgent)
     : InspectorBaseAgent<InspectorAccessibilityAgent, protocol::Frontend::Accessibility>("Accessibility")
     , m_page(page)
     , m_domAgent(domAgent)
 {
 }
@@ skipping 23 matching lines @@
         return;
     }
 
     OwnPtr<protocol::Array<AXProperty>> properties = protocol::Array<AXProperty>::create();
     fillLiveRegionProperties(axObject, properties.get());
     fillGlobalStates(axObject, properties.get());
     fillWidgetProperties(axObject, properties.get());
     fillWidgetStates(axObject, properties.get());
     fillRelationships(axObject, properties.get());
 
-    *accessibilityNode = buildObjectForNode(node, axObject, cacheImpl, properties.release());
+    *accessibilityNode = buildObjectForNode(node, axObject, cacheImpl, std::move(properties));
 }
 
 DEFINE_TRACE(InspectorAccessibilityAgent)
 {
     visitor->trace(m_page);
     visitor->trace(m_domAgent);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink