[inspector] provide more usefull error message for non serializable value

src/inspector/StringUtil.cpp

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/inspector/StringUtil.h"
 
 #include "src/inspector/protocol/Protocol.h"
 
 namespace v8_inspector {
 
@@ skipping 85 matching lines @@
   return protocol::parseJSON(string.characters16(), string.length());
 }
 
 std::unique_ptr<protocol::Value> parseJSON(const String16& string) {
   if (!string.length()) return nullptr;
   return protocol::parseJSON(string.characters16(), string.length());
 }
 
 }  // namespace protocol
 
-std::unique_ptr<protocol::Value> toProtocolValue(v8::Local<v8::Context> context,
+std::unique_ptr<protocol::Value> toProtocolValue(protocol::String* errorString,
+                                                 v8::Local<v8::Context> context,
                                                  v8::Local<v8::Value> value,
                                                  int maxDepth) {
   if (value.IsEmpty()) {
     UNREACHABLE();
     return nullptr;
   }
 
-  if (!maxDepth) return nullptr;
+  if (!maxDepth) {
+    *errorString = "Object has too long reference chain";
+    return nullptr;
+  }
   maxDepth--;
 
   if (value->IsNull() || value->IsUndefined()) return protocol::Value::null();
   if (value->IsBoolean())
     return protocol::FundamentalValue::create(value.As<v8::Boolean>()->Value());
   if (value->IsNumber()) {
     double doubleValue = value.As<v8::Number>()->Value();
     int intValue = static_cast<int>(doubleValue);
     if (intValue == doubleValue)
       return protocol::FundamentalValue::create(intValue);
     return protocol::FundamentalValue::create(doubleValue);
   }
   if (value->IsString())
     return protocol::StringValue::create(
         toProtocolString(value.As<v8::String>()));
   if (value->IsArray()) {
     v8::Local<v8::Array> array = value.As<v8::Array>();
     std::unique_ptr<protocol::ListValue> inspectorArray =
         protocol::ListValue::create();
     uint32_t length = array->Length();
     for (uint32_t i = 0; i < length; i++) {
       v8::Local<v8::Value> value;
-      if (!array->Get(context, i).ToLocal(&value)) return nullptr;
+      if (!array->Get(context, i).ToLocal(&value)) {
+        *errorString = "Internal error";
+        return nullptr;
+      }
       std::unique_ptr<protocol::Value> element =
-          toProtocolValue(context, value, maxDepth);
+          toProtocolValue(errorString, context, value, maxDepth);
       if (!element) return nullptr;
       inspectorArray->pushValue(std::move(element));
     }
     return std::move(inspectorArray);
   }
   if (value->IsObject()) {
     std::unique_ptr<protocol::DictionaryValue> jsonObject =
         protocol::DictionaryValue::create();
     v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(value);
     v8::Local<v8::Array> propertyNames;
-    if (!object->GetPropertyNames(context).ToLocal(&propertyNames))
+    if (!object->GetPropertyNames(context).ToLocal(&propertyNames)) {
+      *errorString = "Internal error";
       return nullptr;
+    }
     uint32_t length = propertyNames->Length();
     for (uint32_t i = 0; i < length; i++) {
       v8::Local<v8::Value> name;
-      if (!propertyNames->Get(context, i).ToLocal(&name)) return nullptr;
+      if (!propertyNames->Get(context, i).ToLocal(&name)) {
+        *errorString = "Internal error";
+        return nullptr;
+      }
       // FIXME(yurys): v8::Object should support GetOwnPropertyNames
       if (name->IsString()) {
         v8::Maybe<bool> hasRealNamedProperty = object->HasRealNamedProperty(
             context, v8::Local<v8::String>::Cast(name));
         if (!hasRealNamedProperty.IsJust() || !hasRealNamedProperty.FromJust())
           continue;
       }
       v8::Local<v8::String> propertyName;
       if (!name->ToString(context).ToLocal(&propertyName)) continue;
       v8::Local<v8::Value> property;
-      if (!object->Get(context, name).ToLocal(&property)) return nullptr;
+      if (!object->Get(context, name).ToLocal(&property)) {
+        *errorString = "Internal error";
+        return nullptr;
+      }
       std::unique_ptr<protocol::Value> propertyValue =
-          toProtocolValue(context, property, maxDepth);
+          toProtocolValue(errorString, context, property, maxDepth);
       if (!propertyValue) return nullptr;
       jsonObject->setValue(toProtocolString(propertyName),
                            std::move(propertyValue));
     }
     return std::move(jsonObject);
   }
-  UNREACHABLE();
+  *errorString = "Object couldn't be returned by value";
   return nullptr;
 }
 
 // static
 std::unique_ptr<StringBuffer> StringBuffer::create(const StringView& string) {
   String16 owner = toString16(string);
   return StringBufferImpl::adopt(owner);
 }
 
 // static
 std::unique_ptr<StringBufferImpl> StringBufferImpl::adopt(String16& string) {
   return wrapUnique(new StringBufferImpl(string));
 }
 
 StringBufferImpl::StringBufferImpl(String16& string) {
   m_owner.swap(string);
   m_string = toStringView(m_owner);
 }
 
 }  // namespace v8_inspector