Revert of DevTools: simplify JSONValues API, prepare to the OwnPtr migration.

third_party/WebKit/Source/platform/JSONValues.h

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 38 matching lines @@
 
 namespace blink {
 
 class JSONArray;
 class JSONObject;
 
 class PLATFORM_EXPORT JSONValue : public RefCounted<JSONValue> {
 public:
     static const int maxDepth = 1000;
 
+    JSONValue() : m_type(TypeNull) { }
     virtual ~JSONValue() { }
 
     static PassRefPtr<JSONValue> null()
     {
         return adoptRef(new JSONValue());
     }
 
     typedef enum {
         TypeNull = 0,
         TypeBoolean,
         TypeNumber,
         TypeString,
         TypeObject,
         TypeArray
     } Type;
 
     Type type() const { return m_type; }
 
     bool isNull() const { return m_type == TypeNull; }
 
     virtual bool asBoolean(bool* output) const;
     virtual bool asNumber(double* output) const;
     virtual bool asNumber(long* output) const;
     virtual bool asNumber(int* output) const;
     virtual bool asNumber(unsigned long* output) const;
     virtual bool asNumber(unsigned* output) const;
     virtual bool asString(String* output) const;
+    virtual bool asObject(RefPtr<JSONObject>* output);
+    virtual bool asArray(RefPtr<JSONArray>* output);
+    virtual PassRefPtr<JSONObject> asObject();
+    virtual PassRefPtr<JSONArray> asArray();
 
     String toJSONString() const;
     String toPrettyJSONString() const;
     virtual void writeJSON(StringBuilder* output) const;
     virtual void prettyWriteJSON(StringBuilder* output) const;
 
     static String quoteString(const String&);
 
 protected:
-    JSONValue() : m_type(TypeNull) { }
     explicit JSONValue(Type type) : m_type(type) { }
     virtual void prettyWriteJSONInternal(StringBuilder* output, int depth) const;
 
 private:
-    friend class JSONObject;
-    friend class JSONArray;
+    friend class JSONObjectBase;
+    friend class JSONArrayBase;
 
     Type m_type;
 };
 
 class PLATFORM_EXPORT JSONBasicValue : public JSONValue {
 public:
 
     static PassRefPtr<JSONBasicValue> create(bool value)
     {
         return adoptRef(new JSONBasicValue(value));
@@ skipping 45 matching lines @@
 
     void writeJSON(StringBuilder* output) const override;
 
 private:
     explicit JSONString(const String& value) : JSONValue(TypeString), m_stringValue(value) { }
     explicit JSONString(const char* value) : JSONValue(TypeString), m_stringValue(value) { }
 
     String m_stringValue;
 };
 
-class PLATFORM_EXPORT JSONObject : public JSONValue {
+class PLATFORM_EXPORT JSONObjectBase : public JSONValue {
 private:
     typedef HashMap<String, RefPtr<JSONValue>> Dictionary;
 
 public:
     typedef Dictionary::iterator iterator;
     typedef Dictionary::const_iterator const_iterator;
 
-    static PassRefPtr<JSONObject> create()
-    {
-        return adoptRef(new JSONObject());
-    }
-
-    static PassRefPtr<JSONObject> cast(PassRefPtr<JSONValue> value)
-    {
-        if (!value || value->type() != TypeObject)
-            return nullptr;
-        return adoptRef(static_cast<JSONObject*>(value.leakRef()));
-    }
+    PassRefPtr<JSONObject> asObject() override;
+    JSONObject* openAccessors();
 
     void writeJSON(StringBuilder* output) const override;
 
     int size() const { return m_data.size(); }
 
+protected:
+    ~JSONObjectBase() override;
+
+    bool asObject(RefPtr<JSONObject>* output) override;
+
     void setBoolean(const String& name, bool);
     void setNumber(const String& name, double);
     void setString(const String& name, const String&);
     void setValue(const String& name, PassRefPtr<JSONValue>);
     void setObject(const String& name, PassRefPtr<JSONObject>);
     void setArray(const String& name, PassRefPtr<JSONArray>);
 
     iterator find(const String& name);
     const_iterator find(const String& name) const;
     bool getBoolean(const String& name, bool* output) const;
     template<class T> bool getNumber(const String& name, T* output) const
     {
         RefPtr<JSONValue> value = get(name);
         if (!value)
             return false;
         return value->asNumber(output);
     }
     bool getString(const String& name, String* output) const;
     PassRefPtr<JSONObject> getObject(const String& name) const;
     PassRefPtr<JSONArray> getArray(const String& name) const;
     PassRefPtr<JSONValue> get(const String& name) const;
 
     bool booleanProperty(const String& name, bool defaultValue) const;
 
     void remove(const String& name);
 
+    void prettyWriteJSONInternal(StringBuilder* output, int depth) const override;
+
     iterator begin() { return m_data.begin(); }
     iterator end() { return m_data.end(); }
     const_iterator begin() const { return m_data.begin(); }
     const_iterator end() const { return m_data.end(); }
-    ~JSONObject() override;
 
 protected:
-    void prettyWriteJSONInternal(StringBuilder* output, int depth) const override;
+    JSONObjectBase();
 
 private:
-    JSONObject();
-
     Dictionary m_data;
     Vector<String> m_order;
 };
 
-class PLATFORM_EXPORT JSONArray : public JSONValue {
+class PLATFORM_EXPORT JSONObject : public JSONObjectBase {
+public:
+    static PassRefPtr<JSONObject> create()
+    {
+        return adoptRef(new JSONObject());
+    }
+
+    using JSONObjectBase::asObject;
+
+    using JSONObjectBase::setBoolean;
+    using JSONObjectBase::setNumber;
+    using JSONObjectBase::setString;
+    using JSONObjectBase::setValue;
+    using JSONObjectBase::setObject;
+    using JSONObjectBase::setArray;
+
+    using JSONObjectBase::find;
+    using JSONObjectBase::getBoolean;
+    using JSONObjectBase::getNumber;
+    using JSONObjectBase::getString;
+    using JSONObjectBase::getObject;
+    using JSONObjectBase::getArray;
+    using JSONObjectBase::get;
+
+    using JSONObjectBase::booleanProperty;
+
+    using JSONObjectBase::remove;
+
+    using JSONObjectBase::begin;
+    using JSONObjectBase::end;
+
+    using JSONObjectBase::size;
+};
+
+
+class PLATFORM_EXPORT JSONArrayBase : public JSONValue {
 public:
     typedef Vector<RefPtr<JSONValue>>::iterator iterator;
     typedef Vector<RefPtr<JSONValue>>::const_iterator const_iterator;
 
-    static PassRefPtr<JSONArray> create()
-    {
-        return adoptRef(new JSONArray());
-    }
+    PassRefPtr<JSONArray> asArray() override;
 
-    static PassRefPtr<JSONArray> cast(PassRefPtr<JSONValue> value)
-    {
-        if (!value || value->type() != TypeArray)
-            return nullptr;
-        return adoptRef(static_cast<JSONArray*>(value.leakRef()));
-    }
-
-    ~JSONArray() override;
+    unsigned length() const { return m_data.size(); }
 
     void writeJSON(StringBuilder* output) const override;
 
+protected:
+    ~JSONArrayBase() override;
+
+    bool asArray(RefPtr<JSONArray>* output) override;
+
     void pushBoolean(bool);
     void pushInt(int);
     void pushNumber(double);
     void pushString(const String&);
     void pushValue(PassRefPtr<JSONValue>);
     void pushObject(PassRefPtr<JSONObject>);
     void pushArray(PassRefPtr<JSONArray>);
 
     PassRefPtr<JSONValue> get(size_t index);
-    unsigned length() const { return m_data.size(); }
+
+    void prettyWriteJSONInternal(StringBuilder* output, int depth) const override;
 
     iterator begin() { return m_data.begin(); }
     iterator end() { return m_data.end(); }
     const_iterator begin() const { return m_data.begin(); }
     const_iterator end() const { return m_data.end(); }
 
 protected:
-    void prettyWriteJSONInternal(StringBuilder* output, int depth) const override;
+    JSONArrayBase();
 
 private:
-    JSONArray();
     Vector<RefPtr<JSONValue>> m_data;
 };
 
+class PLATFORM_EXPORT JSONArray : public JSONArrayBase {
+public:
+    static PassRefPtr<JSONArray> create()
+    {
+        return adoptRef(new JSONArray());
+    }
+
+    using JSONArrayBase::asArray;
+
+    using JSONArrayBase::pushBoolean;
+    using JSONArrayBase::pushInt;
+    using JSONArrayBase::pushNumber;
+    using JSONArrayBase::pushString;
+    using JSONArrayBase::pushValue;
+    using JSONArrayBase::pushObject;
+    using JSONArrayBase::pushArray;
+
+    using JSONArrayBase::get;
+
+    using JSONArrayBase::begin;
+    using JSONArrayBase::end;
+};
+
 PLATFORM_EXPORT void escapeStringForJSON(const String&, StringBuilder*);
 void doubleQuoteStringForJSON(const String&, StringBuilder*);
 
 } // namespace blink
 
 #endif // JSONValues_h