[DevTools] Move getInternalProperties to native

third_party/WebKit/Source/platform/v8_inspector/V8RuntimeAgentImpl.cpp

 /*
  * Copyright (C) 2011 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 31 matching lines @@
 
 namespace blink {
 
 namespace V8RuntimeAgentImplState {
 static const char customObjectFormatterEnabled[] = "customObjectFormatterEnabled";
 };
 
 using protocol::Runtime::ExceptionDetails;
 using protocol::Runtime::RemoteObject;
 
+static bool checkInternalError(ErrorString* errorString, bool success)
+{
+    if (!success)
+        *errorString = "Internal error";
+    return success;
+}
+
 PassOwnPtr<V8RuntimeAgent> V8RuntimeAgent::create(V8Debugger* debugger, int contextGroupId)
 {
     return adoptPtr(new V8RuntimeAgentImpl(static_cast<V8DebuggerImpl*>(debugger), contextGroupId));
 }
 
 V8RuntimeAgentImpl::V8RuntimeAgentImpl(V8DebuggerImpl* debugger, int contextGroupId)
     : m_contextGroupId(contextGroupId)
     , m_state(nullptr)
     , m_frontend(nullptr)
     , m_injectedScriptManager(InjectedScriptManager::create(debugger))
@@ skipping 90 matching lines @@
     v8::HandleScope scope(injectedScript->isolate());
     v8::Local<v8::Context> localContext = injectedScript->context();
     v8::Context::Scope contextScope(localContext);
 
     if (!injectedScript->canAccessInspectedWindow()) {
         *errorString = "Can not access given context";
         return;
     }
 
     String16 objectGroupName = injectedScript->objectGroupName(*remoteId);
-    v8::Local<v8::Value> object = injectedScript->findObject(*remoteId);
-    if (object.IsEmpty()) {
-        *errorString = "Could not find object with given id";
+    v8::Local<v8::Value> object;
+    if (!injectedScript->findObject(errorString, *remoteId, &object))
         return;
-    }
     OwnPtr<v8::Local<v8::Value>[]> argv = nullptr;
     int argc = 0;
     if (optionalArguments.isJust()) {
         protocol::Array<protocol::Runtime::CallArgument>* arguments = optionalArguments.fromJust();
         argc = arguments->length();
         argv = adoptArrayPtr(new v8::Local<v8::Value>[argc]);
         for (int i = 0; i < argc; ++i) {
             v8::Local<v8::Value> argumentValue;
             if (!injectedScript->resolveCallArgument(errorString, arguments->get(i)).ToLocal(&argumentValue))
                 return;
@@ skipping 33 matching lines @@
 void V8RuntimeAgentImpl::getProperties(
     ErrorString* errorString,
     const String16& objectId,
     const Maybe<bool>& ownProperties,
     const Maybe<bool>& accessorPropertiesOnly,
     const Maybe<bool>& generatePreview,
     OwnPtr<protocol::Array<protocol::Runtime::PropertyDescriptor>>* result,
     Maybe<protocol::Array<protocol::Runtime::InternalPropertyDescriptor>>* internalProperties,
     Maybe<ExceptionDetails>* exceptionDetails)
 {
+    using protocol::Runtime::InternalPropertyDescriptor;
+
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(errorString, objectId);
     if (!remoteId)
         return;
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());
     if (!injectedScript)
         return;
 
     IgnoreExceptionsScope ignoreExceptionsScope(m_debugger);
 
+    v8::HandleScope handles(injectedScript->isolate());
+    v8::Context::Scope scope(injectedScript->context());
+    v8::Local<v8::Value> object;
+    if (!injectedScript->findObject(errorString, *remoteId, &object))
+        return;
+    String16 objectGroupName = injectedScript->objectGroupName(*remoteId);
+
     injectedScript->getProperties(errorString, objectId, ownProperties.fromMaybe(false), accessorPropertiesOnly.fromMaybe(false), generatePreview.fromMaybe(false), result, exceptionDetails);
-
-    if (errorString->isEmpty() && !exceptionDetails->isJust() && !accessorPropertiesOnly.fromMaybe(false))
-        injectedScript->getInternalProperties(errorString, objectId, internalProperties, exceptionDetails);
+    if (!errorString->isEmpty() || exceptionDetails->isJust() || accessorPropertiesOnly.fromMaybe(false))
+        return;
+    if (object->IsSymbol())
+        return;
+    v8::Local<v8::Array> propertiesArray;
+    if (!checkInternalError(errorString, v8::Debug::GetInternalProperties(injectedScript->isolate(), object).ToLocal(&propertiesArray)))
+        return;
+    OwnPtr<protocol::Array<InternalPropertyDescriptor>> propertiesProtocolArray = protocol::Array<InternalPropertyDescriptor>::create();
+    for (uint32_t i = 0; i < propertiesArray->Length(); i += 2) {
+        v8::Local<v8::Value> name;
+        if (!checkInternalError(errorString, propertiesArray->Get(injectedScript->context(), i).ToLocal(&name)) && name->IsString())
+            return;
+        v8::Local<v8::Value> value;
+        if (!checkInternalError(errorString, propertiesArray->Get(injectedScript->context(), i + 1).ToLocal(&value)))
+            return;
+        OwnPtr<RemoteObject> wrappedValue = injectedScript->wrapObject(errorString, value, objectGroupName);
+        if (!wrappedValue)
+            return;
+        propertiesProtocolArray->addItem(InternalPropertyDescriptor::create()
+            .setName(toProtocolString(name.As<v8::String>()))
+            .setValue(wrappedValue.release()).build());
+    }
+    if (!propertiesProtocolArray->length())
+        return;
+    *internalProperties = propertiesProtocolArray.release();
 }
 
 void V8RuntimeAgentImpl::releaseObject(ErrorString* errorString, const String16& objectId)
 {
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(errorString, objectId);
     if (!remoteId)
         return;
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());
     if (!injectedScript)
         return;
@@ skipping 204 matching lines @@
 }
 
 v8::Local<v8::Value> V8RuntimeAgentImpl::findObject(ErrorString* errorString, const String16& objectId, v8::Local<v8::Context>* context, String16* groupName)
 {
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(errorString, objectId);
     if (!remoteId)
         return v8::Local<v8::Value>();
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());
     if (!injectedScript)
         return v8::Local<v8::Value>();
+    v8::Local<v8::Value> objectValue;
+    injectedScript->findObject(errorString, *remoteId, &objectValue);
+    if (objectValue.IsEmpty())
+        return v8::Local<v8::Value>();
     if (context)
         *context = injectedScript->context();
     if (groupName)
         *groupName = injectedScript->objectGroupName(*remoteId);
-    return injectedScript->findObject(*remoteId);
+    return objectValue;
 }
 
 void V8RuntimeAgentImpl::addInspectedObject(PassOwnPtr<Inspectable> inspectable)
 {
     m_injectedScriptManager->injectedScriptHost()->addInspectedObject(inspectable);
 }
 
 void V8RuntimeAgentImpl::clearInspectedObjects()
 {
     m_injectedScriptManager->injectedScriptHost()->clearInspectedObjects();
@@ skipping 19 matching lines @@
 
 void V8RuntimeAgentImpl::reportExecutionContextDestroyed(v8::Local<v8::Context> context)
 {
     int contextId = m_injectedScriptManager->discardInjectedScriptFor(context);
     if (!m_enabled)
         return;
     m_frontend->executionContextDestroyed(contextId);
 }
 
 } // namespace blink