LCOV - code coverage report
Current view: top level - out/Release/gen/src/inspector/protocol - Protocol.h (source / functions) Hit Total Coverage
Test: app.info Lines: 115 137 83.9 %
Date: 2017-04-26 Functions: 53 79 67.1 %

          Line data    Source code
       1             : // Copyright 2016 The Chromium Authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef v8_inspector_protocol_Collections_h
       6             : #define v8_inspector_protocol_Collections_h
       7             : 
       8             : #include "src/inspector/protocol/Forward.h"
       9             : #include <cstddef>
      10             : 
      11             : #if defined(__APPLE__) && !defined(_LIBCPP_VERSION)
      12             : #include <map>
      13             : #include <set>
      14             : 
      15             : namespace v8_inspector {
      16             : namespace protocol {
      17             : 
      18             : template <class Key, class T> using HashMap = std::map<Key, T>;
      19             : template <class Key> using HashSet = std::set<Key>;
      20             : 
      21             : } // namespace v8_inspector
      22             : } // namespace protocol
      23             : 
      24             : #else
      25             : #include <unordered_map>
      26             : #include <unordered_set>
      27             : 
      28             : namespace v8_inspector {
      29             : namespace protocol {
      30             : 
      31             : template <class Key, class T> using HashMap = std::unordered_map<Key, T>;
      32             : template <class Key> using HashSet = std::unordered_set<Key>;
      33             : 
      34             : } // namespace v8_inspector
      35             : } // namespace protocol
      36             : 
      37             : #endif // defined(__APPLE__) && !defined(_LIBCPP_VERSION)
      38             : 
      39             : #endif // !defined(v8_inspector_protocol_Collections_h)
      40             : 
      41             : 
      42             : // Copyright 2016 The Chromium Authors. All rights reserved.
      43             : // Use of this source code is governed by a BSD-style license that can be
      44             : // found in the LICENSE file.
      45             : 
      46             : #ifndef v8_inspector_protocol_ErrorSupport_h
      47             : #define v8_inspector_protocol_ErrorSupport_h
      48             : 
      49             : //#include "Forward.h"
      50             : 
      51             : namespace v8_inspector {
      52             : namespace protocol {
      53             : 
      54             : class  ErrorSupport {
      55             : public:
      56             :     ErrorSupport();
      57             :     ~ErrorSupport();
      58             : 
      59             :     void push();
      60             :     void setName(const String&);
      61             :     void pop();
      62             :     void addError(const String&);
      63             :     bool hasErrors();
      64             :     String errors();
      65             : 
      66             : private:
      67             :     std::vector<String> m_path;
      68             :     std::vector<String> m_errors;
      69             : };
      70             : 
      71             : } // namespace v8_inspector
      72             : } // namespace protocol
      73             : 
      74             : #endif // !defined(v8_inspector_protocol_ErrorSupport_h)
      75             : 
      76             : 
      77             : // Copyright 2016 The Chromium Authors. All rights reserved.
      78             : // Use of this source code is governed by a BSD-style license that can be
      79             : // found in the LICENSE file.
      80             : 
      81             : #ifndef v8_inspector_protocol_Values_h
      82             : #define v8_inspector_protocol_Values_h
      83             : 
      84             : //#include "Allocator.h"
      85             : //#include "Collections.h"
      86             : //#include "Forward.h"
      87             : 
      88             : namespace v8_inspector {
      89             : namespace protocol {
      90             : 
      91             : class ListValue;
      92             : class DictionaryValue;
      93             : class Value;
      94             : 
      95             : class  Value : public Serializable {
      96             :     PROTOCOL_DISALLOW_COPY(Value);
      97             : public:
      98    96417074 :     virtual ~Value() override { }
      99             : 
     100             :     static std::unique_ptr<Value> null()
     101             :     {
     102       10944 :         return std::unique_ptr<Value>(new Value());
     103             :     }
     104             : 
     105             :     enum ValueType {
     106             :         TypeNull = 0,
     107             :         TypeBoolean,
     108             :         TypeInteger,
     109             :         TypeDouble,
     110             :         TypeString,
     111             :         TypeObject,
     112             :         TypeArray,
     113             :         TypeSerialized
     114             :     };
     115             : 
     116             :     ValueType type() const { return m_type; }
     117             : 
     118             :     bool isNull() const { return m_type == TypeNull; }
     119             : 
     120             :     virtual bool asBoolean(bool* output) const;
     121             :     virtual bool asDouble(double* output) const;
     122             :     virtual bool asInteger(int* output) const;
     123             :     virtual bool asString(String* output) const;
     124             :     virtual bool asSerialized(String* output) const;
     125             : 
     126             :     virtual void writeJSON(StringBuilder* output) const;
     127             :     virtual std::unique_ptr<Value> clone() const;
     128             :     String serialize() override;
     129             : 
     130             : protected:
     131       10944 :     Value() : m_type(TypeNull) { }
     132    96395186 :     explicit Value(ValueType type) : m_type(type) { }
     133             : 
     134             : private:
     135             :     friend class DictionaryValue;
     136             :     friend class ListValue;
     137             : 
     138             :     ValueType m_type;
     139             : };
     140             : 
     141    64591338 : class  FundamentalValue : public Value {
     142             : public:
     143    28094440 :     static std::unique_ptr<FundamentalValue> create(bool value)
     144             :     {
     145    56188880 :         return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
     146             :     }
     147             : 
     148     4113927 :     static std::unique_ptr<FundamentalValue> create(int value)
     149             :     {
     150     8227854 :         return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
     151             :     }
     152             : 
     153       87302 :     static std::unique_ptr<FundamentalValue> create(double value)
     154             :     {
     155      174604 :         return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
     156             :     }
     157             : 
     158             :     bool asBoolean(bool* output) const override;
     159             :     bool asDouble(double* output) const override;
     160             :     bool asInteger(int* output) const override;
     161             :     void writeJSON(StringBuilder* output) const override;
     162             :     std::unique_ptr<Value> clone() const override;
     163             : 
     164             : private:
     165    28094440 :     explicit FundamentalValue(bool value) : Value(TypeBoolean), m_boolValue(value) { }
     166     4113927 :     explicit FundamentalValue(int value) : Value(TypeInteger), m_integerValue(value) { }
     167       87302 :     explicit FundamentalValue(double value) : Value(TypeDouble), m_doubleValue(value) { }
     168             : 
     169             :     union {
     170             :         bool m_boolValue;
     171             :         double m_doubleValue;
     172             :         int m_integerValue;
     173             :     };
     174             : };
     175             : 
     176    86624246 : class  StringValue : public Value {
     177             : public:
     178    43312123 :     static std::unique_ptr<StringValue> create(const String& value)
     179             :     {
     180    86624246 :         return std::unique_ptr<StringValue>(new StringValue(value));
     181             :     }
     182             : 
     183             :     static std::unique_ptr<StringValue> create(const char* value)
     184             :     {
     185             :         return std::unique_ptr<StringValue>(new StringValue(value));
     186             :     }
     187             : 
     188             :     bool asString(String* output) const override;
     189             :     void writeJSON(StringBuilder* output) const override;
     190             :     std::unique_ptr<Value> clone() const override;
     191             : 
     192             : private:
     193    43312123 :     explicit StringValue(const String& value) : Value(TypeString), m_stringValue(value) { }
     194             :     explicit StringValue(const char* value) : Value(TypeString), m_stringValue(value) { }
     195             : 
     196             :     String m_stringValue;
     197             : };
     198             : 
     199      816050 : class  SerializedValue : public Value {
     200             : public:
     201      408025 :     static std::unique_ptr<SerializedValue> create(const String& value)
     202             :     {
     203      816050 :         return std::unique_ptr<SerializedValue>(new SerializedValue(value));
     204             :     }
     205             : 
     206             :     bool asSerialized(String* output) const override;
     207             :     void writeJSON(StringBuilder* output) const override;
     208             :     std::unique_ptr<Value> clone() const override;
     209             : 
     210             : private:
     211      408025 :     explicit SerializedValue(const String& value) : Value(TypeSerialized), m_serializedValue(value) { }
     212             : 
     213             :     String m_serializedValue;
     214             : };
     215             : 
     216             : class  DictionaryValue : public Value {
     217             : public:
     218             :     using Entry = std::pair<String, Value*>;
     219    19499495 :     static std::unique_ptr<DictionaryValue> create()
     220             :     {
     221    38998990 :         return std::unique_ptr<DictionaryValue>(new DictionaryValue());
     222             :     }
     223             : 
     224     9513218 :     static DictionaryValue* cast(Value* value)
     225             :     {
     226    19103821 :         if (!value || value->type() != TypeObject)
     227             :             return nullptr;
     228             :         return static_cast<DictionaryValue*>(value);
     229             :     }
     230             : 
     231             :     static std::unique_ptr<DictionaryValue> cast(std::unique_ptr<Value> value)
     232             :     {
     233             :         return std::unique_ptr<DictionaryValue>(DictionaryValue::cast(value.release()));
     234             :     }
     235             : 
     236             :     void writeJSON(StringBuilder* output) const override;
     237             :     std::unique_ptr<Value> clone() const override;
     238             : 
     239             :     size_t size() const { return m_data.size(); }
     240             : 
     241             :     void setBoolean(const String& name, bool);
     242             :     void setInteger(const String& name, int);
     243             :     void setDouble(const String& name, double);
     244             :     void setString(const String& name, const String&);
     245             :     void setValue(const String& name, std::unique_ptr<Value>);
     246             :     void setObject(const String& name, std::unique_ptr<DictionaryValue>);
     247             :     void setArray(const String& name, std::unique_ptr<ListValue>);
     248             : 
     249             :     bool getBoolean(const String& name, bool* output) const;
     250             :     bool getInteger(const String& name, int* output) const;
     251             :     bool getDouble(const String& name, double* output) const;
     252             :     bool getString(const String& name, String* output) const;
     253             : 
     254             :     DictionaryValue* getObject(const String& name) const;
     255             :     ListValue* getArray(const String& name) const;
     256             :     Value* get(const String& name) const;
     257             :     Entry at(size_t index) const;
     258             : 
     259             :     bool booleanProperty(const String& name, bool defaultValue) const;
     260             :     int integerProperty(const String& name, int defaultValue) const;
     261             :     double doubleProperty(const String& name, double defaultValue) const;
     262             :     void remove(const String& name);
     263             : 
     264             :     ~DictionaryValue() override;
     265             : 
     266             : private:
     267             :     DictionaryValue();
     268             :     template<typename T>
     269    86329236 :     void set(const String& key, std::unique_ptr<T>& value)
     270             :     {
     271             :         DCHECK(value);
     272             :         bool isNew = m_data.find(key) == m_data.end();
     273             :         m_data[key] = std::move(value);
     274    86329236 :         if (isNew)
     275    86315727 :             m_order.push_back(key);
     276    86329236 :     }
     277             : 
     278             :     using Dictionary = protocol::HashMap<String, std::unique_ptr<Value>>;
     279             :     Dictionary m_data;
     280             :     std::vector<String> m_order;
     281             : };
     282             : 
     283             : class  ListValue : public Value {
     284             : public:
     285      879874 :     static std::unique_ptr<ListValue> create()
     286             :     {
     287     1759748 :         return std::unique_ptr<ListValue>(new ListValue());
     288             :     }
     289             : 
     290      375488 :     static ListValue* cast(Value* value)
     291             :     {
     292      750976 :         if (!value || value->type() != TypeArray)
     293             :             return nullptr;
     294             :         return static_cast<ListValue*>(value);
     295             :     }
     296             : 
     297             :     static std::unique_ptr<ListValue> cast(std::unique_ptr<Value> value)
     298             :     {
     299             :         return std::unique_ptr<ListValue>(ListValue::cast(value.release()));
     300             :     }
     301             : 
     302             :     ~ListValue() override;
     303             : 
     304             :     void writeJSON(StringBuilder* output) const override;
     305             :     std::unique_ptr<Value> clone() const override;
     306             : 
     307             :     void pushValue(std::unique_ptr<Value>);
     308             : 
     309             :     Value* at(size_t index);
     310     4532797 :     size_t size() const { return m_data.size(); }
     311             : 
     312             : private:
     313             :     ListValue();
     314             :     std::vector<std::unique_ptr<Value>> m_data;
     315             : };
     316             : 
     317             : } // namespace v8_inspector
     318             : } // namespace protocol
     319             : 
     320             : #endif // v8_inspector_protocol_Values_h
     321             : 
     322             : 
     323             : // Copyright 2016 The Chromium Authors. All rights reserved.
     324             : // Use of this source code is governed by a BSD-style license that can be
     325             : // found in the LICENSE file.
     326             : 
     327             : #ifndef v8_inspector_protocol_Object_h
     328             : #define v8_inspector_protocol_Object_h
     329             : 
     330             : //#include "ErrorSupport.h"
     331             : //#include "Forward.h"
     332             : //#include "Values.h"
     333             : 
     334             : namespace v8_inspector {
     335             : namespace protocol {
     336             : 
     337             : class  Object {
     338             : public:
     339             :     static std::unique_ptr<Object> fromValue(protocol::Value*, ErrorSupport*);
     340             :     ~Object();
     341             : 
     342             :     std::unique_ptr<protocol::DictionaryValue> toValue() const;
     343             :     std::unique_ptr<Object> clone() const;
     344             : private:
     345             :     explicit Object(std::unique_ptr<protocol::DictionaryValue>);
     346             :     std::unique_ptr<protocol::DictionaryValue> m_object;
     347             : };
     348             : 
     349             : } // namespace v8_inspector
     350             : } // namespace protocol
     351             : 
     352             : #endif // !defined(v8_inspector_protocol_Object_h)
     353             : 
     354             : 
     355             : // Copyright 2016 The Chromium Authors. All rights reserved.
     356             : // Use of this source code is governed by a BSD-style license that can be
     357             : // found in the LICENSE file.
     358             : 
     359             : #ifndef v8_inspector_protocol_ValueConversions_h
     360             : #define v8_inspector_protocol_ValueConversions_h
     361             : 
     362             : //#include "ErrorSupport.h"
     363             : //#include "Forward.h"
     364             : //#include "Values.h"
     365             : 
     366             : namespace v8_inspector {
     367             : namespace protocol {
     368             : 
     369             : template<typename T>
     370             : struct ValueConversions {
     371         594 :     static std::unique_ptr<T> fromValue(protocol::Value* value, ErrorSupport* errors)
     372             :     {
     373     9188106 :         return T::fromValue(value, errors);
     374             :     }
     375             : 
     376        2568 :     static std::unique_ptr<protocol::Value> toValue(T* value)
     377             :     {
     378    10820540 :         return value->toValue();
     379             :     }
     380             : 
     381             :     static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<T>& value)
     382             :     {
     383     8422836 :         return value->toValue();
     384             :     }
     385             : };
     386             : 
     387             : template<>
     388             : struct ValueConversions<bool> {
     389    13988980 :     static bool fromValue(protocol::Value* value, ErrorSupport* errors)
     390             :     {
     391    13988980 :         bool result = false;
     392    13988980 :         bool success = value ? value->asBoolean(&result) : false;
     393    13988980 :         if (!success)
     394           0 :             errors->addError("boolean value expected");
     395    13988980 :         return result;
     396             :     }
     397             : 
     398             :     static std::unique_ptr<protocol::Value> toValue(bool value)
     399             :     {
     400    27953536 :         return FundamentalValue::create(value);
     401             :     }
     402             : };
     403             : 
     404             : template<>
     405             : struct ValueConversions<int> {
     406     1289794 :     static int fromValue(protocol::Value* value, ErrorSupport* errors)
     407             :     {
     408     1289794 :         int result = 0;
     409     1289794 :         bool success = value ? value->asInteger(&result) : false;
     410     1289794 :         if (!success)
     411           0 :             errors->addError("integer value expected");
     412     1289794 :         return result;
     413             :     }
     414             : 
     415             :     static std::unique_ptr<protocol::Value> toValue(int value)
     416             :     {
     417     3196190 :         return FundamentalValue::create(value);
     418             :     }
     419             : };
     420             : 
     421             : template<>
     422             : struct ValueConversions<double> {
     423           0 :     static double fromValue(protocol::Value* value, ErrorSupport* errors)
     424             :     {
     425           0 :         double result = 0;
     426           0 :         bool success = value ? value->asDouble(&result) : false;
     427           0 :         if (!success)
     428           0 :             errors->addError("double value expected");
     429           0 :         return result;
     430             :     }
     431             : 
     432             :     static std::unique_ptr<protocol::Value> toValue(double value)
     433             :     {
     434       14920 :         return FundamentalValue::create(value);
     435             :     }
     436             : };
     437             : 
     438             : template<>
     439             : struct ValueConversions<String> {
     440    21196197 :     static String fromValue(protocol::Value* value, ErrorSupport* errors)
     441             :     {
     442             :         String result;
     443    21196197 :         bool success = value ? value->asString(&result) : false;
     444    21196197 :         if (!success)
     445          76 :             errors->addError("string value expected");
     446    21196197 :         return result;
     447             :     }
     448             : 
     449             :     static std::unique_ptr<protocol::Value> toValue(const String& value)
     450             :     {
     451    42854448 :         return StringValue::create(value);
     452             :     }
     453             : };
     454             : 
     455             : template<>
     456             : struct ValueConversions<Value> {
     457      318437 :     static std::unique_ptr<Value> fromValue(protocol::Value* value, ErrorSupport* errors)
     458             :     {
     459             :         bool success = !!value;
     460      318437 :         if (!success) {
     461           0 :             errors->addError("value expected");
     462             :             return nullptr;
     463             :         }
     464      318437 :         return value->clone();
     465             :     }
     466             : 
     467             :     static std::unique_ptr<protocol::Value> toValue(Value* value)
     468             :     {
     469      318291 :         return value->clone();
     470             :     }
     471             : 
     472             :     static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<Value>& value)
     473             :     {
     474             :         return value->clone();
     475             :     }
     476             : };
     477             : 
     478             : template<>
     479             : struct ValueConversions<DictionaryValue> {
     480           0 :     static std::unique_ptr<DictionaryValue> fromValue(protocol::Value* value, ErrorSupport* errors)
     481             :     {
     482           0 :         bool success = value && value->type() == protocol::Value::TypeObject;
     483           0 :         if (!success)
     484           0 :             errors->addError("object expected");
     485           0 :         return DictionaryValue::cast(value->clone());
     486             :     }
     487             : 
     488             :     static std::unique_ptr<protocol::Value> toValue(DictionaryValue* value)
     489             :     {
     490        2746 :         return value->clone();
     491             :     }
     492             : 
     493             :     static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<DictionaryValue>& value)
     494             :     {
     495             :         return value->clone();
     496             :     }
     497             : };
     498             : 
     499             : template<>
     500             : struct ValueConversions<ListValue> {
     501             :     static std::unique_ptr<ListValue> fromValue(protocol::Value* value, ErrorSupport* errors)
     502             :     {
     503             :         bool success = value && value->type() == protocol::Value::TypeArray;
     504             :         if (!success)
     505             :             errors->addError("list expected");
     506             :         return ListValue::cast(value->clone());
     507             :     }
     508             : 
     509             :     static std::unique_ptr<protocol::Value> toValue(ListValue* value)
     510             :     {
     511             :         return value->clone();
     512             :     }
     513             : 
     514             :     static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<ListValue>& value)
     515             :     {
     516             :         return value->clone();
     517             :     }
     518             : };
     519             : 
     520             : } // namespace v8_inspector
     521             : } // namespace protocol
     522             : 
     523             : #endif // !defined(v8_inspector_protocol_ValueConversions_h)
     524             : 
     525             : 
     526             : // Copyright 2016 The Chromium Authors. All rights reserved.
     527             : // Use of this source code is governed by a BSD-style license that can be
     528             : // found in the LICENSE file.
     529             : 
     530             : #ifndef v8_inspector_protocol_Maybe_h
     531             : #define v8_inspector_protocol_Maybe_h
     532             : 
     533             : //#include "Forward.h"
     534             : 
     535             : namespace v8_inspector {
     536             : namespace protocol {
     537             : 
     538             : template<typename T>
     539             : class Maybe {
     540             : public:
     541             :     Maybe() : m_value() { }
     542             :     Maybe(std::unique_ptr<T> value) : m_value(std::move(value)) { }
     543             :     Maybe(Maybe&& other) : m_value(std::move(other.m_value)) { }
     544             :     void operator=(std::unique_ptr<T> value) { m_value = std::move(value); }
     545             :     T* fromJust() const { DCHECK(m_value); return m_value.get(); }
     546             :     T* fromMaybe(T* defaultValue) const { return m_value ? m_value.get() : defaultValue; }
     547             :     bool isJust() const { return !!m_value; }
     548             :     std::unique_ptr<T> takeJust() { DCHECK(m_value); return std::move(m_value); }
     549             : private:
     550             :     std::unique_ptr<T> m_value;
     551             : };
     552             : 
     553             : template<typename T>
     554             : class MaybeBase {
     555             : public:
     556    29356988 :     MaybeBase() : m_isJust(false) { }
     557      183246 :     MaybeBase(T value) : m_isJust(true), m_value(value) { }
     558      170746 :     MaybeBase(MaybeBase&& other) : m_isJust(other.m_isJust), m_value(std::move(other.m_value)) { }
     559    19717898 :     void operator=(T value) { m_value = value; m_isJust = true; }
     560             :     T fromJust() const { DCHECK(m_isJust); return m_value; }
     561      548705 :     T fromMaybe(const T& defaultValue) const { return m_isJust ? m_value : defaultValue; }
     562             :     bool isJust() const { return m_isJust; }
     563             :     T takeJust() { DCHECK(m_isJust); return m_value; }
     564             : 
     565             : protected:
     566             :     bool m_isJust;
     567             :     T m_value;
     568             : };
     569             : 
     570             : template<>
     571             : class Maybe<bool> : public MaybeBase<bool> {
     572             : public:
     573             :     Maybe() { }
     574             :     Maybe(bool value) : MaybeBase(value) { }
     575             :     Maybe(Maybe&& other) : MaybeBase(std::move(other)) { }
     576             :     using MaybeBase::operator=;
     577             : };
     578             : 
     579             : template<>
     580             : class Maybe<int> : public MaybeBase<int> {
     581             : public:
     582             :     Maybe() { }
     583             :     Maybe(int value) : MaybeBase(value) { }
     584             :     Maybe(Maybe&& other) : MaybeBase(std::move(other)) { }
     585             :     using MaybeBase::operator=;
     586             : };
     587             : 
     588             : template<>
     589             : class Maybe<double> : public MaybeBase<double> {
     590             : public:
     591             :     Maybe() { }
     592             :     Maybe(double value) : MaybeBase(value) { }
     593             :     Maybe(Maybe&& other) : MaybeBase(std::move(other)) { }
     594             :     using MaybeBase::operator=;
     595             : };
     596             : 
     597             : template<>
     598             : class Maybe<String> : public MaybeBase<String> {
     599             : public:
     600             :     Maybe() { }
     601       73452 :     Maybe(const String& value) : MaybeBase(value) { }
     602             :     Maybe(Maybe&& other) : MaybeBase(std::move(other)) { }
     603             :     using MaybeBase::operator=;
     604             : };
     605             : 
     606             : } // namespace v8_inspector
     607             : } // namespace protocol
     608             : 
     609             : #endif // !defined(v8_inspector_protocol_Maybe_h)
     610             : 
     611             : 
     612             : // Copyright 2016 The Chromium Authors. All rights reserved.
     613             : // Use of this source code is governed by a BSD-style license that can be
     614             : // found in the LICENSE file.
     615             : 
     616             : #ifndef v8_inspector_protocol_Array_h
     617             : #define v8_inspector_protocol_Array_h
     618             : 
     619             : //#include "ErrorSupport.h"
     620             : //#include "Forward.h"
     621             : //#include "ValueConversions.h"
     622             : //#include "Values.h"
     623             : 
     624             : namespace v8_inspector {
     625             : namespace protocol {
     626             : 
     627             : template<typename T>
     628      532445 : class Array {
     629             : public:
     630             :     static std::unique_ptr<Array<T>> create()
     631             :     {
     632      157013 :         return std::unique_ptr<Array<T>>(new Array<T>());
     633             :     }
     634             : 
     635      375432 :     static std::unique_ptr<Array<T>> fromValue(protocol::Value* value, ErrorSupport* errors)
     636             :     {
     637             :         protocol::ListValue* array = ListValue::cast(value);
     638      375432 :         if (!array) {
     639           0 :             errors->addError("array expected");
     640             :             return nullptr;
     641             :         }
     642      375432 :         std::unique_ptr<Array<T>> result(new Array<T>());
     643      375432 :         errors->push();
     644     9065368 :         for (size_t i = 0; i < array->size(); ++i) {
     645     8314504 :             errors->setName(StringUtil::fromInteger(i));
     646     4157252 :             std::unique_ptr<T> item = ValueConversions<T>::fromValue(array->at(i), errors);
     647     4157252 :             result->m_vector.push_back(std::move(item));
     648             :         }
     649      375432 :         errors->pop();
     650      375432 :         if (errors->hasErrors())
     651             :             return nullptr;
     652             :         return result;
     653             :     }
     654             : 
     655             :     void addItem(std::unique_ptr<T> value)
     656             :     {
     657       54322 :         m_vector.push_back(std::move(value));
     658             :     }
     659             : 
     660             :     size_t length()
     661             :     {
     662      183734 :         return m_vector.size();
     663             :     }
     664             : 
     665             :     T* get(size_t index)
     666             :     {
     667      191374 :         return m_vector[index].get();
     668             :     }
     669             : 
     670      426513 :     std::unique_ptr<protocol::ListValue> toValue()
     671             :     {
     672      426513 :         std::unique_ptr<protocol::ListValue> result = ListValue::create();
     673     5064444 :         for (auto& item : m_vector)
     674     8422836 :             result->pushValue(ValueConversions<T>::toValue(item));
     675      426513 :         return result;
     676             :     }
     677             : 
     678             : private:
     679             :     std::vector<std::unique_ptr<T>> m_vector;
     680             : };
     681             : 
     682             : template<typename T>
     683       77116 : class ArrayBase {
     684             : public:
     685             :     static std::unique_ptr<Array<T>> create()
     686             :     {
     687       77183 :         return std::unique_ptr<Array<T>>(new Array<T>());
     688             :     }
     689             : 
     690          56 :     static std::unique_ptr<Array<T>> fromValue(protocol::Value* value, ErrorSupport* errors)
     691             :     {
     692             :         protocol::ListValue* array = ListValue::cast(value);
     693          56 :         if (!array) {
     694           0 :             errors->addError("array expected");
     695             :             return nullptr;
     696             :         }
     697          56 :         errors->push();
     698          56 :         std::unique_ptr<Array<T>> result(new Array<T>());
     699         226 :         for (size_t i = 0; i < array->size(); ++i) {
     700         114 :             errors->setName(StringUtil::fromInteger(i));
     701          57 :             T item = ValueConversions<T>::fromValue(array->at(i), errors);
     702          57 :             result->m_vector.push_back(item);
     703             :         }
     704          56 :         errors->pop();
     705          56 :         if (errors->hasErrors())
     706             :             return nullptr;
     707             :         return result;
     708             :     }
     709             : 
     710             :     void addItem(const T& value)
     711             :     {
     712        3088 :         m_vector.push_back(value);
     713             :     }
     714             : 
     715             :     size_t length()
     716             :     {
     717         113 :         return m_vector.size();
     718             :     }
     719             : 
     720             :     T get(size_t index)
     721             :     {
     722             :         return m_vector[index];
     723             :     }
     724             : 
     725       77183 :     std::unique_ptr<protocol::ListValue> toValue()
     726             :     {
     727       77183 :         std::unique_ptr<protocol::ListValue> result = ListValue::create();
     728      157454 :         for (auto& item : m_vector)
     729        6457 :             result->pushValue(ValueConversions<T>::toValue(item));
     730       77183 :         return result;
     731             :     }
     732             : 
     733             : private:
     734             :     std::vector<T> m_vector;
     735             : };
     736             : 
     737             : template<> class Array<String> : public ArrayBase<String> {};
     738             : template<> class Array<int> : public ArrayBase<int> {};
     739             : template<> class Array<double> : public ArrayBase<double> {};
     740             : template<> class Array<bool> : public ArrayBase<bool> {};
     741             : 
     742             : } // namespace v8_inspector
     743             : } // namespace protocol
     744             : 
     745             : #endif // !defined(v8_inspector_protocol_Array_h)
     746             : 
     747             : 
     748             : // Copyright 2016 The Chromium Authors. All rights reserved.
     749             : // Use of this source code is governed by a BSD-style license that can be
     750             : // found in the LICENSE file.
     751             : 
     752             : #ifndef v8_inspector_protocol_DispatcherBase_h
     753             : #define v8_inspector_protocol_DispatcherBase_h
     754             : 
     755             : //#include "Collections.h"
     756             : //#include "ErrorSupport.h"
     757             : //#include "Forward.h"
     758             : //#include "Values.h"
     759             : 
     760             : namespace v8_inspector {
     761             : namespace protocol {
     762             : 
     763             : class WeakPtr;
     764             : 
     765     1160202 : class  DispatchResponse {
     766             : public:
     767             :     enum Status {
     768             :         kSuccess = 0,
     769             :         kError = 1,
     770             :         kFallThrough = 2,
     771             :         kAsync = 3
     772             :     };
     773             : 
     774             :     enum ErrorCode {
     775             :         kParseError = -32700,
     776             :         kInvalidRequest = -32600,
     777             :         kMethodNotFound = -32601,
     778             :         kInvalidParams = -32602,
     779             :         kInternalError = -32603,
     780             :         kServerError = -32000,
     781             :     };
     782             : 
     783             :     Status status() const { return m_status; }
     784             :     const String& errorMessage() const { return m_errorMessage; }
     785             :     ErrorCode errorCode() const { return m_errorCode; }
     786             :     bool isSuccess() const { return m_status == kSuccess; }
     787             : 
     788             :     static DispatchResponse OK();
     789             :     static DispatchResponse Error(const String&);
     790             :     static DispatchResponse InternalError();
     791             :     static DispatchResponse InvalidParams(const String&);
     792             :     static DispatchResponse FallThrough();
     793             : 
     794             : private:
     795             :     Status m_status;
     796             :     String m_errorMessage;
     797             :     ErrorCode m_errorCode;
     798             : };
     799             : 
     800             : class  DispatcherBase {
     801             :     PROTOCOL_DISALLOW_COPY(DispatcherBase);
     802             : public:
     803             :     static const char kInvalidParamsString[];
     804             :     class  WeakPtr {
     805             :     public:
     806             :         explicit WeakPtr(DispatcherBase*);
     807             :         ~WeakPtr();
     808      344901 :         DispatcherBase* get() { return m_dispatcher; }
     809          12 :         void dispose() { m_dispatcher = nullptr; }
     810             : 
     811             :     private:
     812             :         DispatcherBase* m_dispatcher;
     813             :     };
     814             : 
     815        9898 :     class  Callback {
     816             :     public:
     817             :         Callback(std::unique_ptr<WeakPtr> backendImpl, int callId, int callbackId);
     818             :         virtual ~Callback();
     819             :         void dispose();
     820             : 
     821             :     protected:
     822             :         void sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const DispatchResponse& response);
     823             :         void fallThroughIfActive();
     824             : 
     825             :     private:
     826             :         std::unique_ptr<WeakPtr> m_backendImpl;
     827             :         int m_callId;
     828             :         int m_callbackId;
     829             :     };
     830             : 
     831             :     explicit DispatcherBase(FrontendChannel*);
     832             :     virtual ~DispatcherBase();
     833             : 
     834             :     static bool getCommandName(const String& message, String* result);
     835             : 
     836             :     virtual DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) = 0;
     837             : 
     838             :     void sendResponse(int callId, const DispatchResponse&, std::unique_ptr<protocol::DictionaryValue> result);
     839             :     void sendResponse(int callId, const DispatchResponse&);
     840             : 
     841             :     void reportProtocolError(int callId, DispatchResponse::ErrorCode, const String& errorMessage, ErrorSupport* errors);
     842             :     void clearFrontend();
     843             : 
     844             :     std::unique_ptr<WeakPtr> weakPtr();
     845             : 
     846             :     int nextCallbackId();
     847             :     void markFallThrough(int callbackId);
     848             :     bool lastCallbackFallThrough() { return m_lastCallbackFallThrough; }
     849             : 
     850             : private:
     851             :     FrontendChannel* m_frontendChannel;
     852             :     protocol::HashSet<WeakPtr*> m_weakPtrs;
     853             :     int m_lastCallbackId;
     854             :     bool m_lastCallbackFallThrough;
     855             : };
     856             : 
     857        9146 : class  UberDispatcher {
     858             :     PROTOCOL_DISALLOW_COPY(UberDispatcher);
     859             : public:
     860             :     explicit UberDispatcher(FrontendChannel*);
     861             :     void registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase>);
     862             :     DispatchResponse::Status dispatch(std::unique_ptr<Value> message);
     863             :     FrontendChannel* channel() { return m_frontendChannel; }
     864             :     bool fallThroughForNotFound() { return m_fallThroughForNotFound; }
     865             :     void setFallThroughForNotFound(bool);
     866             :     virtual ~UberDispatcher();
     867             : 
     868             : private:
     869             :     FrontendChannel* m_frontendChannel;
     870             :     bool m_fallThroughForNotFound;
     871             :     protocol::HashMap<String, std::unique_ptr<protocol::DispatcherBase>> m_dispatchers;
     872             : };
     873             : 
     874             : class InternalResponse : public Serializable {
     875             :     PROTOCOL_DISALLOW_COPY(InternalResponse);
     876             : public:
     877             :     static std::unique_ptr<InternalResponse> createResponse(int callId, std::unique_ptr<Serializable> params);
     878             :     static std::unique_ptr<InternalResponse> createNotification(const String& notification, std::unique_ptr<Serializable> params = nullptr);
     879             : 
     880             :     String serialize() override;
     881             : 
     882     1224075 :     ~InternalResponse() override {}
     883             : 
     884             : private:
     885             :     InternalResponse(int callId, const String& notification, std::unique_ptr<Serializable> params);
     886             : 
     887             :     int m_callId;
     888             :     String m_notification;
     889             :     std::unique_ptr<Serializable> m_params;
     890             : };
     891             : 
     892             : class InternalRawNotification : public Serializable {
     893             : public:
     894           0 :     static std::unique_ptr<InternalRawNotification> create(const String& notification)
     895             :     {
     896           0 :         return std::unique_ptr<InternalRawNotification>(new InternalRawNotification(notification));
     897             :     }
     898           0 :     ~InternalRawNotification() override {}
     899             : 
     900           0 :     String serialize() override
     901             :     {
     902           0 :         return m_notification;
     903             :     }
     904             : 
     905             : private:
     906             :   explicit InternalRawNotification(const String& notification)
     907           0 :     : m_notification(notification)
     908             :   {
     909             :   }
     910             : 
     911             :   String m_notification;
     912             : };
     913             : 
     914             : } // namespace v8_inspector
     915             : } // namespace protocol
     916             : 
     917             : #endif // !defined(v8_inspector_protocol_DispatcherBase_h)
     918             : 
     919             : 
     920             : // Copyright 2016 The Chromium Authors. All rights reserved.
     921             : // Use of this source code is governed by a BSD-style license that can be
     922             : // found in the LICENSE file.
     923             : 
     924             : #ifndef v8_inspector_protocol_Parser_h
     925             : #define v8_inspector_protocol_Parser_h
     926             : 
     927             : //#include "Forward.h"
     928             : //#include "Values.h"
     929             : 
     930             : namespace v8_inspector {
     931             : namespace protocol {
     932             : 
     933             :  std::unique_ptr<Value> parseJSONCharacters(const uint8_t*, unsigned);
     934             :  std::unique_ptr<Value> parseJSONCharacters(const uint16_t*, unsigned);
     935             : 
     936             : } // namespace v8_inspector
     937             : } // namespace protocol
     938             : 
     939             : #endif // !defined(v8_inspector_protocol_Parser_h)

Generated by: LCOV version 1.10