[inspector] fixed all deprecated calls

src/inspector/V8ConsoleMessage.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/V8ConsoleMessage.h"
 
 #include "src/inspector/InspectedContext.h"
 #include "src/inspector/StringUtil.h"
 #include "src/inspector/V8ConsoleAgentImpl.h"
 #include "src/inspector/V8InspectorImpl.h"
@@ skipping 45 matching lines @@
   }
   return protocol::Runtime::ConsoleAPICalled::TypeEnum::Log;
 }
 
 const unsigned maxConsoleMessageCount = 1000;
 const unsigned maxArrayItemsLimit = 10000;
 const unsigned maxStackDepthLimit = 32;
 
 class V8ValueStringBuilder {
  public:
-  static String16 toString(v8::Local<v8::Value> value, v8::Isolate* isolate) {
-    V8ValueStringBuilder builder(isolate);
+  static String16 toString(v8::Local<v8::Value> value,
+                           v8::Local<v8::Context> context) {
+    V8ValueStringBuilder builder(context);
     if (!builder.append(value)) return String16();
     return builder.toString();
   }
 
  private:
   enum {
     IgnoreNull = 1 << 0,
     IgnoreUndefined = 1 << 1,
   };
 
-  V8ValueStringBuilder(v8::Isolate* isolate)
+  V8ValueStringBuilder(v8::Local<v8::Context> context)
       : m_arrayLimit(maxArrayItemsLimit),
-        m_isolate(isolate),
-        m_tryCatch(isolate) {}
+        m_isolate(context->GetIsolate()),
+        m_tryCatch(context->GetIsolate()),
+        m_context(context) {}
 
   bool append(v8::Local<v8::Value> value, unsigned ignoreOptions = 0) {
     if (value.IsEmpty()) return true;
     if ((ignoreOptions & IgnoreNull) && value->IsNull()) return true;
     if ((ignoreOptions & IgnoreUndefined) && value->IsUndefined()) return true;
     if (value->IsString()) return append(v8::Local<v8::String>::Cast(value));
     if (value->IsStringObject())
       return append(v8::Local<v8::StringObject>::Cast(value)->ValueOf());
     if (value->IsSymbol()) return append(v8::Local<v8::Symbol>::Cast(value));
     if (value->IsSymbolObject())
@@ skipping 34 matching lines @@
     }
     uint32_t length = array->Length();
     if (length > m_arrayLimit) return false;
     if (m_visitedArrays.size() > maxStackDepthLimit) return false;
 
     bool result = true;
     m_arrayLimit -= length;
     m_visitedArrays.push_back(array);
     for (uint32_t i = 0; i < length; ++i) {
       if (i) m_builder.append(',');
-      if (!append(array->Get(i), IgnoreNull | IgnoreUndefined)) {
+      v8::Local<v8::Value> value;
+      if (!array->Get(m_context, i).ToLocal(&value)) continue;
+      if (!append(value, IgnoreNull | IgnoreUndefined)) {
         result = false;
         break;
       }
     }
     m_visitedArrays.pop_back();
     return result;
   }
 
   bool append(v8::Local<v8::Symbol> symbol) {
     m_builder.append("Symbol(");
@@ skipping 11 matching lines @@
   String16 toString() {
     if (m_tryCatch.HasCaught()) return String16();
     return m_builder.toString();
   }
 
   uint32_t m_arrayLimit;
   v8::Isolate* m_isolate;
   String16Builder m_builder;
   std::vector<v8::Local<v8::Array>> m_visitedArrays;
   v8::TryCatch m_tryCatch;
+  v8::Local<v8::Context> m_context;
 };
 
 }  // namespace
 
 V8ConsoleMessage::V8ConsoleMessage(V8MessageOrigin origin, double timestamp,
                                    const String16& message)
     : m_origin(origin),
       m_timestamp(timestamp),
       m_message(message),
       m_lineNumber(0),
@@ skipping 151 matching lines @@
 }
 
 V8MessageOrigin V8ConsoleMessage::origin() const { return m_origin; }
 
 ConsoleAPIType V8ConsoleMessage::type() const { return m_type; }
 
 // static
 std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForConsoleAPI(
     double timestamp, ConsoleAPIType type,
     const std::vector<v8::Local<v8::Value>>& arguments,
-    std::unique_ptr<V8StackTraceImpl> stackTrace, InspectedContext* context) {
-  v8::Isolate* isolate = context->isolate();
-  int contextId = context->contextId();
-  int contextGroupId = context->contextGroupId();
-  V8InspectorImpl* inspector = context->inspector();
+    std::unique_ptr<V8StackTraceImpl> stackTrace,
+    InspectedContext* inspectedContext) {
+  v8::Isolate* isolate = inspectedContext->isolate();
+  int contextId = inspectedContext->contextId();
+  int contextGroupId = inspectedContext->contextGroupId();
+  V8InspectorImpl* inspector = inspectedContext->inspector();
+  v8::Local<v8::Context> context = inspectedContext->context();
 
   std::unique_ptr<V8ConsoleMessage> message = wrapUnique(
       new V8ConsoleMessage(V8MessageOrigin::kConsole, timestamp, String16()));
   if (stackTrace && !stackTrace->isEmpty()) {
     message->m_url = toString16(stackTrace->topSourceURL());
     message->m_lineNumber = stackTrace->topLineNumber();
     message->m_columnNumber = stackTrace->topColumnNumber();
   }
   message->m_stackTrace = std::move(stackTrace);
   message->m_type = type;
   message->m_contextId = contextId;
   for (size_t i = 0; i < arguments.size(); ++i)
     message->m_arguments.push_back(
         wrapUnique(new v8::Global<v8::Value>(isolate, arguments.at(i))));
   if (arguments.size())
-    message->m_message = V8ValueStringBuilder::toString(arguments[0], isolate);
+    message->m_message = V8ValueStringBuilder::toString(arguments[0], context);
 
   V8ConsoleAPIType clientType = V8ConsoleAPIType::kLog;
   if (type == ConsoleAPIType::kDebug || type == ConsoleAPIType::kCount ||
       type == ConsoleAPIType::kTimeEnd)
     clientType = V8ConsoleAPIType::kDebug;
   else if (type == ConsoleAPIType::kError || type == ConsoleAPIType::kAssert)
     clientType = V8ConsoleAPIType::kError;
   else if (type == ConsoleAPIType::kWarning)
     clientType = V8ConsoleAPIType::kWarning;
   else if (type == ConsoleAPIType::kInfo)
@@ skipping 87 matching lines @@
           m_inspector->sessionForContextGroup(m_contextGroupId))
     session->releaseObjectGroup("console");
 }
 
 void V8ConsoleMessageStorage::contextDestroyed(int contextId) {
   for (size_t i = 0; i < m_messages.size(); ++i)
     m_messages[i]->contextDestroyed(contextId);
 }
 
 }  // namespace v8_inspector