nodejs
diff --git a/‎deps/v8_inspector/README.md‎
Lines changed: 1 addition & 0 deletions b/‎deps/v8_inspector/README.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎deps/v8_inspector/third_party/v8_inspector/platform/inspector_protocol/Array.h‎
Lines changed: 26 additions & 26 deletions b/‎deps/v8_inspector/third_party/v8_inspector/platform/inspector_protocol/Array.h‎
Lines changed: 26 additions & 26 deletions
@@ -7,4 +7,5 @@ Node.js support for the [Chrome Debug Protocol][https://developer.chrome.com/dev
 * third_party/v8_inspector/platform/v8_inspector: vendored from https://chromium.googlesource.com/chromium/src/third_party/WebKit/Source/platform/v8_inspector
 * third_party/v8_inspector/platform/inspector_protocol: vendored from https://chromium.googlesource.com/chromium/src/third_party/WebKit/Source/platform/inspector_protocol
 * third_party/jinja2: vendored from https://github.com/mitsuhiko/jinja2
+  * The `tests/` directory `ext/jinja.el` file have been deleted.
 * third_party/markupsafe: vendored from https://github.com/mitsuhiko/markupsafe
@@ -17,7 +17,7 @@ namespace blink {
 namespace protocol {
 
 template<typename T>
-class ArrayBase {
+class Array {
 public:
     static std::unique_ptr<Array<T>> create()
     {
@@ -31,54 +31,48 @@ class ArrayBase {
             errors->addError("array expected");
             return nullptr;
         }
-        errors->push();
         std::unique_ptr<Array<T>> result(new Array<T>());
+        errors->push();
         for (size_t i = 0; i < array->size(); ++i) {
             errors->setName(String16::fromInteger(i));
-            T item = FromValue<T>::parse(array->at(i), errors);
-            result->m_vector.push_back(item);
+            std::unique_ptr<T> item = ValueConversions<T>::parse(array->at(i), errors);
+            result->m_vector.push_back(std::move(item));
         }
         errors->pop();
         if (errors->hasErrors())
             return nullptr;
         return result;
     }
 
-    void addItem(const T& value)
+    void addItem(std::unique_ptr<T> value)
     {
-        m_vector.push_back(value);
+        m_vector.push_back(std::move(value));
     }
 
     size_t length()
     {
         return m_vector.size();
     }
 
-    T get(size_t index)
+    T* get(size_t index)
     {
-        return m_vector[index];
+        return m_vector[index].get();
     }
 
     std::unique_ptr<protocol::ListValue> serialize()
     {
         std::unique_ptr<protocol::ListValue> result = ListValue::create();
         for (auto& item : m_vector)
-            result->pushValue(toValue(item));
+            result->pushValue(ValueConversions<T>::serialize(item));
         return result;
     }
 
 private:
-    std::vector<T> m_vector;
+    std::vector<std::unique_ptr<T>> m_vector;
 };
 
-template<> class Array<String> : public ArrayBase<String> {};
-template<> class Array<String16> : public ArrayBase<String16> {};
-template<> class Array<int> : public ArrayBase<int> {};
-template<> class Array<double> : public ArrayBase<double> {};
-template<> class Array<bool> : public ArrayBase<bool> {};
-
 template<typename T>
-class Array {
+class ArrayBase {
 public:
     static std::unique_ptr<Array<T>> create()
     {
@@ -92,46 +86,52 @@ class Array {
             errors->addError("array expected");
             return nullptr;
         }
-        std::unique_ptr<Array<T>> result(new Array<T>());
         errors->push();
+        std::unique_ptr<Array<T>> result(new Array<T>());
         for (size_t i = 0; i < array->size(); ++i) {
             errors->setName(String16::fromInteger(i));
-            std::unique_ptr<T> item = FromValue<T>::parse(array->at(i), errors);
-            result->m_vector.push_back(std::move(item));
+            T item = ValueConversions<T>::parse(array->at(i), errors);
+            result->m_vector.push_back(item);
         }
         errors->pop();
         if (errors->hasErrors())
             return nullptr;
         return result;
     }
 
-    void addItem(std::unique_ptr<T> value)
+    void addItem(const T& value)
     {
-        m_vector.push_back(std::move(value));
+        m_vector.push_back(value);
     }
 
     size_t length()
     {
         return m_vector.size();
     }
 
-    T* get(size_t index)
+    T get(size_t index)
     {
-        return m_vector[index].get();
+        return m_vector[index];
     }
 
     std::unique_ptr<protocol::ListValue> serialize()
     {
         std::unique_ptr<protocol::ListValue> result = ListValue::create();
         for (auto& item : m_vector)
-            result->pushValue(toValue(item));
+            result->pushValue(ValueConversions<T>::serialize(item));
         return result;
     }
 
 private:
-    std::vector<std::unique_ptr<T>> m_vector;
+    std::vector<T> m_vector;
 };
 
+template<> class Array<String> : public ArrayBase<String> {};
+template<> class Array<String16> : public ArrayBase<String16> {};
+template<> class Array<int> : public ArrayBase<int> {};
+template<> class Array<double> : public ArrayBase<double> {};
+template<> class Array<bool> : public ArrayBase<bool> {};
+
 } // namespace platform
 } // namespace blink
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace blink {`
`17`	`17`	`namespace protocol {`
`18`	`18`
`19`	`19`	`template<typename T>`
`20`		`-class ArrayBase {`
	`20`	`+class Array {`
`21`	`21`	`public:`
`22`	`22`	`static std::unique_ptr<Array<T>> create()`
`23`	`23`	`{`
`@@ -31,54 +31,48 @@ class ArrayBase {`
`31`	`31`	`errors->addError("array expected");`
`32`	`32`	`return nullptr;`
`33`	`33`	`}`
`34`		`- errors->push();`
`35`	`34`	`std::unique_ptr<Array<T>> result(new Array<T>());`
	`35`	`+ errors->push();`
`36`	`36`	`for (size_t i = 0; i < array->size(); ++i) {`
`37`	`37`	`errors->setName(String16::fromInteger(i));`
`38`		`- T item = FromValue<T>::parse(array->at(i), errors);`
`39`		`- result->m_vector.push_back(item);`
	`38`	`+ std::unique_ptr<T> item = ValueConversions<T>::parse(array->at(i), errors);`
	`39`	`+ result->m_vector.push_back(std::move(item));`
`40`	`40`	`}`
`41`	`41`	`errors->pop();`
`42`	`42`	`if (errors->hasErrors())`
`43`	`43`	`return nullptr;`
`44`	`44`	`return result;`
`45`	`45`	`}`
`46`	`46`
`47`		`- void addItem(const T& value)`
	`47`	`+ void addItem(std::unique_ptr<T> value)`
`48`	`48`	`{`
`49`		`- m_vector.push_back(value);`
	`49`	`+ m_vector.push_back(std::move(value));`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`size_t length()`
`53`	`53`	`{`
`54`	`54`	`return m_vector.size();`
`55`	`55`	`}`
`56`	`56`
`57`		`- T get(size_t index)`
	`57`	`+ T* get(size_t index)`
`58`	`58`	`{`
`59`		`- return m_vector[index];`
	`59`	`+ return m_vector[index].get();`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`std::unique_ptr<protocol::ListValue> serialize()`
`63`	`63`	`{`
`64`	`64`	`std::unique_ptr<protocol::ListValue> result = ListValue::create();`
`65`	`65`	`for (auto& item : m_vector)`
`66`		`- result->pushValue(toValue(item));`
	`66`	`+ result->pushValue(ValueConversions<T>::serialize(item));`
`67`	`67`	`return result;`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`private:`
`71`		`- std::vector<T> m_vector;`
	`71`	`+ std::vector<std::unique_ptr<T>> m_vector;`
`72`	`72`	`};`
`73`	`73`
`74`		`-template<> class Array<String> : public ArrayBase<String> {};`
`75`		`-template<> class Array<String16> : public ArrayBase<String16> {};`
`76`		`-template<> class Array<int> : public ArrayBase<int> {};`
`77`		`-template<> class Array<double> : public ArrayBase<double> {};`
`78`		`-template<> class Array<bool> : public ArrayBase<bool> {};`
`79`		`-`
`80`	`74`	`template<typename T>`
`81`		`-class Array {`
	`75`	`+class ArrayBase {`
`82`	`76`	`public:`
`83`	`77`	`static std::unique_ptr<Array<T>> create()`
`84`	`78`	`{`
`@@ -92,46 +86,52 @@ class Array {`
`92`	`86`	`errors->addError("array expected");`
`93`	`87`	`return nullptr;`
`94`	`88`	`}`
`95`		`- std::unique_ptr<Array<T>> result(new Array<T>());`
`96`	`89`	`errors->push();`
	`90`	`+ std::unique_ptr<Array<T>> result(new Array<T>());`
`97`	`91`	`for (size_t i = 0; i < array->size(); ++i) {`
`98`	`92`	`errors->setName(String16::fromInteger(i));`
`99`		`- std::unique_ptr<T> item = FromValue<T>::parse(array->at(i), errors);`
`100`		`- result->m_vector.push_back(std::move(item));`
	`93`	`+ T item = ValueConversions<T>::parse(array->at(i), errors);`
	`94`	`+ result->m_vector.push_back(item);`
`101`	`95`	`}`
`102`	`96`	`errors->pop();`
`103`	`97`	`if (errors->hasErrors())`
`104`	`98`	`return nullptr;`
`105`	`99`	`return result;`
`106`	`100`	`}`
`107`	`101`
`108`		`- void addItem(std::unique_ptr<T> value)`
	`102`	`+ void addItem(const T& value)`
`109`	`103`	`{`
`110`		`- m_vector.push_back(std::move(value));`
	`104`	`+ m_vector.push_back(value);`
`111`	`105`	`}`
`112`	`106`
`113`	`107`	`size_t length()`
`114`	`108`	`{`
`115`	`109`	`return m_vector.size();`
`116`	`110`	`}`
`117`	`111`
`118`		`- T* get(size_t index)`
	`112`	`+ T get(size_t index)`
`119`	`113`	`{`
`120`		`- return m_vector[index].get();`
	`114`	`+ return m_vector[index];`
`121`	`115`	`}`
`122`	`116`
`123`	`117`	`std::unique_ptr<protocol::ListValue> serialize()`
`124`	`118`	`{`
`125`	`119`	`std::unique_ptr<protocol::ListValue> result = ListValue::create();`
`126`	`120`	`for (auto& item : m_vector)`
`127`		`- result->pushValue(toValue(item));`
	`121`	`+ result->pushValue(ValueConversions<T>::serialize(item));`
`128`	`122`	`return result;`
`129`	`123`	`}`
`130`	`124`
`131`	`125`	`private:`
`132`		`- std::vector<std::unique_ptr<T>> m_vector;`
	`126`	`+ std::vector<T> m_vector;`
`133`	`127`	`};`
`134`	`128`
	`129`	`+template<> class Array<String> : public ArrayBase<String> {};`
	`130`	`+template<> class Array<String16> : public ArrayBase<String16> {};`
	`131`	`+template<> class Array<int> : public ArrayBase<int> {};`
	`132`	`+template<> class Array<double> : public ArrayBase<double> {};`
	`133`	`+template<> class Array<bool> : public ArrayBase<bool> {};`
	`134`	`+`
`135`	`135`	`} // namespace platform`
`136`	`136`	`} // namespace blink`
`137`	`137`