DevTools: Added error message when the command is invoked from the console with exception

Source/core/inspector/InjectedScriptBase.cpp

 /*
  * Copyright (C) 2012 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 21 matching lines @@
 
 
 #include "core/inspector/InjectedScriptBase.h"
 
 #include "bindings/core/v8/ScriptFunctionCall.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/JSONValues.h"
 #include "wtf/text/WTFString.h"
 
+using WebCore::TypeBuilder::Array;
 using WebCore::TypeBuilder::Runtime::RemoteObject;
 
 namespace WebCore {
 
 InjectedScriptBase::InjectedScriptBase(const String& name)
     : m_name(name)
     , m_inspectedStateAccessCheck(0)
 {
 }
 
@@ skipping 62 matching lines @@
     ASSERT(!hadException);
     if (!hadException) {
         *result = resultValue.toJSONValue(m_injectedScriptObject.scriptState());
         if (!*result)
             *result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
     } else {
         *result = JSONString::create("Exception while making a call.");
     }
 }
 
-void InjectedScriptBase::makeEvalCall(ErrorString* errorString, ScriptFunctionCall& function, RefPtr<TypeBuilder::Runtime::RemoteObject>* objectResult, TypeBuilder::OptOutput<bool>* wasThrown)
+void InjectedScriptBase::makeEvalCall(ErrorString* errorString, ScriptFunctionCall& function, RefPtr<TypeBuilder::Runtime::RemoteObject>* objectResult, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* objectExceptionDetails)
 {
     RefPtr<JSONValue> result;
     makeCall(function, &result);
     if (!result) {
         *errorString = "Internal error: result value is empty";
         return;
     }
     if (result->type() == JSONValue::TypeString) {
         result->asString(errorString);
         ASSERT(errorString->length());
         return;
     }
     RefPtr<JSONObject> resultPair = result->asObject();
     if (!resultPair) {
         *errorString = "Internal error: result is not an Object";
         return;
     }
     RefPtr<JSONObject> resultObj = resultPair->getObject("result");
     bool wasThrownVal = false;
     if (!resultObj || !resultPair->getBoolean("wasThrown", &wasThrownVal)) {
         *errorString = "Internal error: result is not a pair of value and wasThrown flag";
         return;
     }
+    if (wasThrownVal) {
+        RefPtr<JSONObject> exceptionDetails = resultPair->getObject("exceptionDetails");

[vsevik, 2014/07/15 16:14:33]

Let's extract a method.

[kozyatinskiy1, 2014/07/16 13:15:47]

Done.

+        if (objectExceptionDetails && exceptionDetails) {
+            String exceptionDetailsText;
+            if (exceptionDetails->getString("text", &exceptionDetailsText)) {
+                RefPtr<TypeBuilder::Debugger::ExceptionDetails> outputExceptionDetails = TypeBuilder::Debugger::ExceptionDetails::create().setText(exceptionDetailsText);
+                String url;
+                if (exceptionDetails->getString("url", &url))
+                    outputExceptionDetails->setUrl(url);
+                int line = 0;
+                if (exceptionDetails->getNumber("line", &line))
+                    outputExceptionDetails->setLine(line);
+                int column = 0;
+                if (exceptionDetails->getNumber("column", &column))
+                    outputExceptionDetails->setColumn(column);
+                RefPtr<JSONArray> stackTrace = exceptionDetails->getArray("stackTrace");
+                if (stackTrace && stackTrace->length() > 0) {
+                    RefPtr<TypeBuilder::Array<TypeBuilder::Console::CallFrame> > frames = TypeBuilder::Array<TypeBuilder::Console::CallFrame>::create();
+                    for (unsigned i = 0; i < stackTrace->length(); ++i) {
+                        RefPtr<JSONObject> stackFrame = stackTrace->get(i)->asObject();
+                        int lineNumber = 0;
+                        stackFrame->getNumber("lineNumber", &lineNumber);
+                        int column = 0;
+                        stackFrame->getNumber("column", &column);
+                        int scriptId = 0;
+                        stackFrame->getNumber("scriptId", &scriptId);
+                        String sourceURL;
+                        stackFrame->getString("scriptNameOrSourceURL", &sourceURL);
+                        String functionName;
+                        stackFrame->getString("functionName", &functionName);
+
+                        RefPtr<TypeBuilder::Console::CallFrame> callFrame = TypeBuilder::Console::CallFrame::create()
+                            .setFunctionName(functionName)
+                            .setScriptId(String::number(scriptId))
+                            .setUrl(sourceURL)
+                            .setLineNumber(lineNumber)
+                            .setColumnNumber(column);
+
+                        frames->addItem(callFrame);
+                    }
+                    outputExceptionDetails->setStackTrace(frames);
+                }
+                *objectExceptionDetails = outputExceptionDetails;
+            }
+        }
+    }
     *objectResult = TypeBuilder::Runtime::RemoteObject::runtimeCast(resultObj);
     *wasThrown = wasThrownVal;
 }
 
 } // namespace WebCore