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 JSONObjectBase;
-    friend class JSONArrayBase;
+    friend class JSONObject;
+    friend class JSONArray;
 
     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 JSONObjectBase : public JSONValue {
+class PLATFORM_EXPORT JSONObject : public JSONValue {
 private:
     typedef HashMap<String, RefPtr<JSONValue>> Dictionary;
 
 public:
     typedef Dictionary::iterator iterator;
     typedef Dictionary::const_iterator const_iterator;
 
-    PassRefPtr<JSONObject> asObject() override;
-    JSONObject* openAccessors();
+    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()));
+    }
 
     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:
-    JSONObjectBase();
+    void prettyWriteJSONInternal(StringBuilder* output, int depth) const override;
 
 private:
+    JSONObject();
+
     Dictionary m_data;
     Vector<String> m_order;
 };
 
-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 {
+class PLATFORM_EXPORT JSONArray : public JSONValue {
 public:
     typedef Vector<RefPtr<JSONValue>>::iterator iterator;
     typedef Vector<RefPtr<JSONValue>>::const_iterator const_iterator;
 
-    PassRefPtr<JSONArray> asArray() override;
+    static PassRefPtr<JSONArray> create()
+    {
+        return adoptRef(new JSONArray());
+    }
 
-    unsigned length() const { return m_data.size(); }
+    static PassRefPtr<JSONArray> cast(PassRefPtr<JSONValue> value)
+    {
+        if (!value || value->type() != TypeArray)
+            return nullptr;
+        return adoptRef(static_cast<JSONArray*>(value.leakRef()));
+    }
+
+    ~JSONArray() override;
 
     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);
-
-    void prettyWriteJSONInternal(StringBuilder* output, int depth) const override;
+    unsigned length() const { return m_data.size(); }
 
     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:
-    JSONArrayBase();
+    void prettyWriteJSONInternal(StringBuilder* output, int depth) const override;
 
 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