[DevTools] Generate public versions of protocol classes to be exposed in v8_inspector/public.

third_party/WebKit/Source/platform/inspector_protocol/Values.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 Values_h
 #define Values_h
 
 #include "platform/inspector_protocol/Allocator.h"
 #include "platform/inspector_protocol/Collections.h"
 #include "platform/inspector_protocol/Platform.h"
@@ skipping 20 matching lines @@
         return wrapUnique(new Value());
     }
 
     enum ValueType {
         TypeNull = 0,
         TypeBoolean,
         TypeInteger,
         TypeDouble,
         TypeString,
         TypeObject,
-        TypeArray
+        TypeArray,
+        TypeSerialized
     };
 
     ValueType type() const { return m_type; }
 
     bool isNull() const { return m_type == TypeNull; }
 
     virtual bool asBoolean(bool* output) const;
     virtual bool asDouble(double* output) const;
     virtual bool asInteger(int* output) const;
     virtual bool asString(String16* output) const;
+    virtual bool asSerialized(String16* output) const;
 
     String16 toJSONString() const;
     virtual void writeJSON(String16Builder* output) const;
     virtual std::unique_ptr<Value> clone() const;
 
 protected:
     Value() : m_type(TypeNull) { }
     explicit Value(ValueType type) : m_type(type) { }
 
 private:
@@ skipping 54 matching lines @@
     void writeJSON(String16Builder* output) const override;
     std::unique_ptr<Value> clone() const override;
 
 private:
     explicit StringValue(const String16& value) : Value(TypeString), m_stringValue(value) { }
     explicit StringValue(const char* value) : Value(TypeString), m_stringValue(value) { }
 
     String16 m_stringValue;
 };
 
+class PLATFORM_EXPORT SerializedValue : public Value {
+public:
+    static std::unique_ptr<SerializedValue> create(const String16& value)
+    {
+        return wrapUnique(new SerializedValue(value));
+    }
+
+    bool asSerialized(String16* output) const override;
+    void writeJSON(String16Builder* output) const override;
+    std::unique_ptr<Value> clone() const override;
+
+private:
+    explicit SerializedValue(const String16& value) : Value(TypeSerialized), m_serializedValue(value) { }
+    explicit SerializedValue(const char* value) : Value(TypeSerialized), m_serializedValue(value) { }
+
+    String16 m_serializedValue;
+};
+
 class PLATFORM_EXPORT DictionaryValue : public Value {
 public:
     using Entry = std::pair<String16, Value*>;
     static std::unique_ptr<DictionaryValue> create()
     {
         return wrapUnique(new DictionaryValue());
     }
 
     static DictionaryValue* cast(Value* value)
     {
@@ skipping 85 matching lines @@
 
 private:
     ListValue();
     std::vector<std::unique_ptr<Value>> m_data;
 };
 
 } // namespace protocol
 } // namespace blink
 
 #endif // Values_h