DevTools: migrate from OwnPtr to std::unique_ptr for inspector protocol classes.

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 228 matching lines @@
             else
                 properties->addItem(createProperty(AXWidgetStatesEnum::Pressed, createValue("true", AXValueTypeEnum::Tristate)));
         }
     }
 
     if (roleAllowsSelected(role)) {
         properties->addItem(createProperty(AXWidgetStatesEnum::Selected, createBooleanValue(axObject->isSelected())));
     }
 }
 
-PassOwnPtr<AXProperty> createRelatedNodeListProperty(const String& key, AXRelatedObjectVector& nodes)
+std::unique_ptr<AXProperty> createRelatedNodeListProperty(const String& key, AXRelatedObjectVector& nodes)
 {
-    OwnPtr<AXValue> nodeListValue = createRelatedNodeListValue(nodes, AXValueTypeEnum::NodeList);
+    std::unique_ptr<AXValue> nodeListValue = createRelatedNodeListValue(nodes, AXValueTypeEnum::NodeList);
     return createProperty(key, std::move(nodeListValue));
 }
 
-PassOwnPtr<AXProperty> createRelatedNodeListProperty(const String& key, AXObject::AXObjectVector& nodes, const QualifiedName& attr, AXObject* axObject)
+std::unique_ptr<AXProperty> createRelatedNodeListProperty(const String& key, AXObject::AXObjectVector& nodes, const QualifiedName& attr, AXObject* axObject)
 {
-    OwnPtr<AXValue> nodeListValue = createRelatedNodeListValue(nodes);
+    std::unique_ptr<AXValue> nodeListValue = createRelatedNodeListValue(nodes);
     const AtomicString& attrValue = axObject->getAttribute(attr);
     nodeListValue->setValue(protocol::StringValue::create(attrValue));
     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)));
     }
@@ skipping 13 matching lines @@
     if (!results.isEmpty())
         properties->addItem(createRelatedNodeListProperty(AXRelationshipAttributesEnum::Describedby, results, aria_describedbyAttr, axObject));
     results.clear();
 
     axObject->ariaOwnsElements(results);
     if (!results.isEmpty())
         properties->addItem(createRelatedNodeListProperty(AXRelationshipAttributesEnum::Owns, results, aria_ownsAttr, axObject));
     results.clear();
 }
 
-PassOwnPtr<AXValue> createRoleNameValue(AccessibilityRole role)
+std::unique_ptr<AXValue> createRoleNameValue(AccessibilityRole role)
 {
     AtomicString roleName = AXObject::roleName(role);
-    OwnPtr<AXValue> roleNameValue;
+    std::unique_ptr<AXValue> roleNameValue;
     if (!roleName.isNull()) {
         roleNameValue = createValue(roleName, AXValueTypeEnum::Role);
     } else {
         roleNameValue = createValue(AXObject::internalRoleName(role), AXValueTypeEnum::InternalRole);
     }
     return roleNameValue;
 }
 
-PassOwnPtr<AXNode> buildObjectForIgnoredNode(Node* node, AXObject* axObject, AXObjectCacheImpl* cacheImpl)
+std::unique_ptr<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();
+    std::unique_ptr<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();
+    std::unique_ptr<protocol::Array<AXProperty>> ignoredReasonProperties = protocol::Array<AXProperty>::create();
     for (size_t i = 0; i < ignoredReasons.size(); i++)
         ignoredReasonProperties->addItem(createProperty(ignoredReasons[i]));
     ignoredNodeObject->setIgnoredReasons(std::move(ignoredReasonProperties));
 
     return ignoredNodeObject;
 }
 
-PassOwnPtr<AXNode> buildObjectForNode(Node* node, AXObject* axObject, AXObjectCacheImpl* cacheImpl, PassOwnPtr<protocol::Array<AXProperty>> properties)
+std::unique_ptr<AXNode> buildObjectForNode(Node* node, AXObject* axObject, AXObjectCacheImpl* cacheImpl, std::unique_ptr<protocol::Array<AXProperty>> properties)
 {
     AccessibilityRole role = axObject->roleValue();
-    OwnPtr<AXNode> nodeObject = AXNode::create().setNodeId(String::number(axObject->axObjectID())).setIgnored(false).build();
+    std::unique_ptr<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);
+        std::unique_ptr<AXValue> name = createValue(computedName, AXValueTypeEnum::ComputedString);
         if (!nameSources.isEmpty()) {
-            OwnPtr<protocol::Array<AXValueSource>> nameSourceProperties = protocol::Array<AXValueSource>::create();
+            std::unique_ptr<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(std::move(nameSourceProperties));
@@ skipping 35 matching lines @@
 
     Document& document = node->document();
     OwnPtr<ScopedAXObjectCache> cache = ScopedAXObjectCache::create(document);
     AXObjectCacheImpl* cacheImpl = toAXObjectCacheImpl(cache->get());
     AXObject* axObject = cacheImpl->getOrCreate(node);
     if (!axObject || axObject->accessibilityIsIgnored()) {
         *accessibilityNode = buildObjectForIgnoredNode(node, axObject, cacheImpl);
         return;
     }
 
-    OwnPtr<protocol::Array<AXProperty>> properties = protocol::Array<AXProperty>::create();
+    std::unique_ptr<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, std::move(properties));
 }
 
 DEFINE_TRACE(InspectorAccessibilityAgent)
 {
     visitor->trace(m_page);
     visitor->trace(m_domAgent);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink