DevTools: generate string16-based handlers for v8_inspector.

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"
-#include "wtf/text/WTFString.h"
 
 namespace blink {
 namespace protocol {
 
 PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(int value);
 
 PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(double value);
 
 PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(bool value);
 
+PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(const String16& param);
+
 PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(const String& param);
 
 PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(protocol::Value* param);
 
 PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(protocol::DictionaryValue* param);
 
 PLATFORM_EXPORT PassOwnPtr<protocol::Value> toValue(protocol::ListValue* param);
 
 template<typename T> PassOwnPtr<protocol::Value> toValue(T* param)
 {
@@ skipping 53 matching lines @@
         if (!success)
             errors->addError("double value expected");
         return result;
     }
 };
 
 template<>
 struct FromValue<String> {
     static String parse(protocol::Value* value, ErrorSupport* errors)
     {
-        String result;
+        String16 result;
         bool success = value ? value->asString(&result) : false;
         if (!success)
             errors->addError("string value expected");
+        return result;
+    }
+};
+
+template<>
+struct FromValue<String16> {
+    static String16 parse(protocol::Value* value, ErrorSupport* errors)
+    {
+        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)
     {
-        String result;
         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)
     {
-        String result;
         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)
     {
-        String result;
         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)
     {
         return protocol::Array<T>::parse(value, errors);
     }
 };
 
 } // namespace platform
 } // namespace blink
 
 #endif // !defined(ValueConversions_h)