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

third_party/WebKit/Source/platform/inspector_protocol/ValueConversions.h

 // 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.
 
 #ifndef ValueConversions_h
 #define ValueConversions_h
 
 #include "platform/PlatformExport.h"
 #include "platform/inspector_protocol/ErrorSupport.h"
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 
 namespace blink {
 namespace protocol {
 
-PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(int value);
+PLATFORM_EXPORT std::unique_ptr<protocol::Value> toValue(int value);
 
-PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(double value);
+PLATFORM_EXPORT std::unique_ptr<protocol::Value> toValue(double value);
 
-PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(bool value);
+PLATFORM_EXPORT std::unique_ptr<protocol::Value> toValue(bool value);
 
-PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(const String16& param);
+PLATFORM_EXPORT std::unique_ptr<protocol::Value> toValue(const String16& param);
 
-PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(const String& param);
+PLATFORM_EXPORT std::unique_ptr<protocol::Value> toValue(const String& param);
 
-PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(protocol::Value* param);
+PLATFORM_EXPORT std::unique_ptr<protocol::Value> toValue(protocol::Value* param);
 
-PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(protocol::DictionaryValue* param);
+PLATFORM_EXPORT std::unique_ptr<protocol::Value> toValue(protocol::DictionaryValue* param);
 
-PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(protocol::ListValue* param);
+PLATFORM_EXPORT std::unique_ptr<protocol::Value> toValue(protocol::ListValue* param);
 
-template<typename T> PassOwnPtr<protocol::Value> toValue(T* param)
+template<typename T> std::unique_ptr<protocol::Value> toValue(T* param)
 {
     return param->serialize();
 }
 
-template<typename T> PassOwnPtr<protocol::Value> toValue(const OwnPtr<T>& param)
+template<typename T> std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<T>& param)
 {
     static_assert(sizeof(T) == 0, "use raw pointer version.");
     return nullptr;
 }
 
-template<typename T> PassOwnPtr<protocol::Value> toValue(PassOwnPtr<T> param)
+template<typename T> std::unique_ptr<protocol::Value> toValue(std::unique_ptr<T> param)
 {
     static_assert(sizeof(T) == 0, "use raw pointer version.");
     return nullptr;
 }
 
 template<typename T>
 struct FromValue {
-    static PassOwnPtr<T> parse(protocol::Value* value, ErrorSupport* errors)
+    static std::unique_ptr<T> parse(protocol::Value* value, ErrorSupport* errors)
     {
         return T::parse(value, errors);
     }
 };
 
 template<>
 struct FromValue<bool> {
     static bool parse(protocol::Value* value, ErrorSupport* errors)
     {
         bool result = false;
@@ skipping 47 matching lines @@
         String16 result;
         bool success = value ? value->asString(&result) : false;
         if (!success)
             errors->addError("string value expected");
         return result;
     }
 };
 
 template<>
 struct FromValue<Value> {
-    static PassOwnPtr<Value> parse(protocol::Value* value, ErrorSupport* errors)
+    static std::unique_ptr<Value> parse(protocol::Value* value, ErrorSupport* errors)
     {
         bool success = !!value;
         if (!success)
             errors->addError("value expected");
         return value->clone();
     }
 };
 
 template<>
 struct FromValue<DictionaryValue> {
-    static PassOwnPtr<DictionaryValue> parse(protocol::Value* value, ErrorSupport* errors)
+    static std::unique_ptr<DictionaryValue> parse(protocol::Value* value, ErrorSupport* errors)
     {
         bool success = value && value->type() == protocol::Value::TypeObject;
         if (!success)
             errors->addError("object expected");
         return DictionaryValue::cast(value->clone());
     }
 };
 
 template<>
 struct FromValue<ListValue> {
-    static PassOwnPtr<ListValue> parse(protocol::Value* value, ErrorSupport* errors)
+    static std::unique_ptr<ListValue> parse(protocol::Value* value, ErrorSupport* errors)
     {
         bool success = value && value->type() == protocol::Value::TypeArray;
         if (!success)
             errors->addError("list expected");
         return ListValue::cast(value->clone());
     }
 };
 
 template<typename T> class Array;
 
 template<typename T>
 struct FromValue<protocol::Array<T>> {
-    static PassOwnPtr<protocol::Array<T>> parse(protocol::Value* value, ErrorSupport* errors)
+    static std::unique_ptr<protocol::Array<T>> parse(protocol::Value* value, ErrorSupport* errors)
     {
         return protocol::Array<T>::parse(value, errors);
     }
 };
 
 } // namespace platform
 } // namespace blink
 
 #endif // !defined(ValueConversions_h)