[DevTools] Migrate v8_inspector/public from String16 to String{View,Buffer}.

third_party/WebKit/Source/core/inspector/InspectorDOMDebuggerAgent.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 20 matching lines @@
 #include "core/inspector/InspectorDOMDebuggerAgent.h"
 
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "bindings/core/v8/V8EventTarget.h"
 #include "core/dom/Element.h"
 #include "core/dom/Node.h"
 #include "core/events/Event.h"
 #include "core/events/EventTarget.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/inspector/InspectorDOMAgent.h"
+#include "core/inspector/V8InspectorStringView.h"
 #include "platform/v8_inspector/public/V8InspectorSession.h"
 
 namespace {
 
 enum DOMBreakpointType {
     SubtreeModified = 0,
     AttributeModified,
     NodeRemoved,
     DOMBreakpointTypesCount
 };
@@ skipping 248 matching lines @@
     protocol::DictionaryValue* breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints(), eventName);
     if (targetName.isEmpty())
         breakpointsByTarget->remove(DOMDebuggerAgentState::eventTargetAny);
     else
         breakpointsByTarget->remove(targetName.lower());
     didRemoveBreakpoint();
 }
 
 void InspectorDOMDebuggerAgent::didInvalidateStyleAttr(Node* node)
 {
-    if (hasBreakpoint(node, AttributeModified)) {
-        std::unique_ptr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
-        descriptionForDOMEvent(node, AttributeModified, false, eventData.get());
-        m_v8Session->breakProgram(protocol::Debugger::API::Paused::ReasonEnum::DOM, eventData->toJSONString());
-    }
+    if (hasBreakpoint(node, AttributeModified))
+        breakProgramOnDOMEvent(node, AttributeModified, false);
 }
 
 void InspectorDOMDebuggerAgent::didInsertDOMNode(Node* node)
 {
     if (m_domBreakpoints.size()) {
         uint32_t mask = m_domBreakpoints.get(InspectorDOMAgent::innerParentNode(node));
         uint32_t inheritableTypesMask = (mask | (mask >> domBreakpointDerivedTypeShift)) & inheritableDOMBreakpointTypesMask;
         if (inheritableTypesMask)
             updateSubtreeBreakpoints(node, inheritableTypesMask, true);
     }
@@ skipping 80 matching lines @@
             updateSubtreeBreakpoints(child, rootBit, false);
     }
     didRemoveBreakpoint();
 }
 
 void InspectorDOMDebuggerAgent::getEventListeners(ErrorString* errorString, const String& objectId, std::unique_ptr<protocol::Array<protocol::DOMDebugger::EventListener>>* listenersArray)
 {
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Value> value;
     v8::Local<v8::Context> context;
-    String16 objectGroup;
-    if (!m_v8Session->unwrapObject(errorString, objectId, &value, &context, &objectGroup))
+    v8_inspector::StringView objectGroup;
+    if (!m_v8Session->unwrapObject(errorString, toV8InspectorStringView(objectId), &value, &context, &objectGroup))
         return;
     v8::Context::Scope scope(context);
     *listenersArray = protocol::Array<protocol::DOMDebugger::EventListener>::create();
-    eventListeners(context, value, objectGroup, listenersArray->get());
+    eventListeners(context, value, toCoreString(objectGroup), listenersArray->get());
 }
 
-void InspectorDOMDebuggerAgent::eventListeners(v8::Local<v8::Context> context, v8::Local<v8::Value> object, const String16& objectGroup, protocol::Array<protocol::DOMDebugger::EventListener>* listenersArray)
+void InspectorDOMDebuggerAgent::eventListeners(v8::Local<v8::Context> context, v8::Local<v8::Value> object, const String& objectGroup, protocol::Array<protocol::DOMDebugger::EventListener>* listenersArray)
 {
     V8EventListenerInfoList eventInformation;
     InspectorDOMDebuggerAgent::eventListenersInfoForTarget(context->GetIsolate(), object, eventInformation);
     for (const auto& info : eventInformation) {
         if (!info.useCapture)
             continue;
         std::unique_ptr<protocol::DOMDebugger::EventListener> listenerObject = buildObjectForEventListener(context, info, objectGroup);
         if (listenerObject)
             listenersArray->addItem(std::move(listenerObject));
     }
     for (const auto& info : eventInformation) {
         if (info.useCapture)
             continue;
         std::unique_ptr<protocol::DOMDebugger::EventListener> listenerObject = buildObjectForEventListener(context, info, objectGroup);
         if (listenerObject)
             listenersArray->addItem(std::move(listenerObject));
     }
 }
 
-std::unique_ptr<protocol::DOMDebugger::EventListener> InspectorDOMDebuggerAgent::buildObjectForEventListener(v8::Local<v8::Context> context, const V8EventListenerInfo& info, const String16& objectGroupId)
+std::unique_ptr<protocol::DOMDebugger::EventListener> InspectorDOMDebuggerAgent::buildObjectForEventListener(v8::Local<v8::Context> context, const V8EventListenerInfo& info, const String& objectGroupId)
 {
     if (info.handler.IsEmpty())
         return nullptr;
 
     v8::Isolate* isolate = context->GetIsolate();
     v8::Local<v8::Function> function = eventListenerEffectiveFunction(isolate, info.handler);
     if (function.IsEmpty())
         return nullptr;
 
     String scriptId;
     int lineNumber;
     int columnNumber;
     getFunctionLocation(function, scriptId, lineNumber, columnNumber);
 
     std::unique_ptr<protocol::DOMDebugger::EventListener> value = protocol::DOMDebugger::EventListener::create()
         .setType(info.eventType)
         .setUseCapture(info.useCapture)
         .setPassive(info.passive)
         .setScriptId(scriptId)
         .setLineNumber(lineNumber)
         .setColumnNumber(columnNumber).build();
     if (!objectGroupId.isEmpty()) {
-        value->setHandler(m_v8Session->wrapObject(context, function, objectGroupId));
-        value->setOriginalHandler(m_v8Session->wrapObject(context, info.handler, objectGroupId));
+        v8_inspector::StringView objectGroup = toV8InspectorStringView(objectGroupId);
+        value->setHandler(m_v8Session->wrapObject(context, function, objectGroup));
+        value->setOriginalHandler(m_v8Session->wrapObject(context, info.handler, objectGroup));
         v8::Local<v8::Function> removeFunction;
         if (info.removeFunction.ToLocal(&removeFunction))
-            value->setRemoveFunction(m_v8Session->wrapObject(context, removeFunction, objectGroupId));
+            value->setRemoveFunction(m_v8Session->wrapObject(context, removeFunction, objectGroup));
     }
     return value;
 }
 
 void InspectorDOMDebuggerAgent::allowNativeBreakpoint(const String& breakpointName, const String* targetName, bool sync)
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(breakpointName, targetName), sync);
 }
 
 void InspectorDOMDebuggerAgent::willInsertDOMNode(Node* parent)
 {
-    if (hasBreakpoint(parent, SubtreeModified)) {
-        std::unique_ptr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
-        descriptionForDOMEvent(parent, SubtreeModified, true, eventData.get());
-        m_v8Session->breakProgram(protocol::Debugger::API::Paused::ReasonEnum::DOM, eventData->toJSONString());
-    }
+    if (hasBreakpoint(parent, SubtreeModified))
+        breakProgramOnDOMEvent(parent, SubtreeModified, true);
 }
 
 void InspectorDOMDebuggerAgent::willRemoveDOMNode(Node* node)
 {
     Node* parentNode = InspectorDOMAgent::innerParentNode(node);
-    if (hasBreakpoint(node, NodeRemoved)) {
-        std::unique_ptr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
-        descriptionForDOMEvent(node, NodeRemoved, false, eventData.get());
-        m_v8Session->breakProgram(protocol::Debugger::API::Paused::ReasonEnum::DOM, eventData->toJSONString());
-    } else if (parentNode && hasBreakpoint(parentNode, SubtreeModified)) {
-        std::unique_ptr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
-        descriptionForDOMEvent(node, SubtreeModified, false, eventData.get());
-        m_v8Session->breakProgram(protocol::Debugger::API::Paused::ReasonEnum::DOM, eventData->toJSONString());
-    }
+    if (hasBreakpoint(node, NodeRemoved))
+        breakProgramOnDOMEvent(node, NodeRemoved, false);
+    else if (parentNode && hasBreakpoint(parentNode, SubtreeModified))
+        breakProgramOnDOMEvent(node, SubtreeModified, false);
     didRemoveDOMNode(node);
 }
 
 void InspectorDOMDebuggerAgent::willModifyDOMAttr(Element* element, const AtomicString&, const AtomicString&)
 {
-    if (hasBreakpoint(element, AttributeModified)) {
-        std::unique_ptr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
-        descriptionForDOMEvent(element, AttributeModified, false, eventData.get());
-        m_v8Session->breakProgram(protocol::Debugger::API::Paused::ReasonEnum::DOM, eventData->toJSONString());
-    }
+    if (hasBreakpoint(element, AttributeModified))
+        breakProgramOnDOMEvent(element, AttributeModified, false);
 }
 
-void InspectorDOMDebuggerAgent::descriptionForDOMEvent(Node* target, int breakpointType, bool insertion, protocol::DictionaryValue* description)
+void InspectorDOMDebuggerAgent::breakProgramOnDOMEvent(Node* target, int breakpointType, bool insertion)
 {
-    ASSERT(hasBreakpoint(target, breakpointType));
+    DCHECK(hasBreakpoint(target, breakpointType));
+    std::unique_ptr<protocol::DictionaryValue> description = protocol::DictionaryValue::create();
 
     Node* breakpointOwner = target;
     if ((1 << breakpointType) & inheritableDOMBreakpointTypesMask) {
         // For inheritable breakpoint types, target node isn't always the same as the node that owns a breakpoint.
         // Target node may be unknown to frontend, so we need to push it first.
         description->setInteger("targetNodeId", m_domAgent->pushNodePathToFrontend(target));
 
         // Find breakpoint owner node.
         if (!insertion)
             breakpointOwner = InspectorDOMAgent::innerParentNode(target);
         ASSERT(breakpointOwner);
         while (!(m_domBreakpoints.get(breakpointOwner) & (1 << breakpointType))) {
             Node* parentNode = InspectorDOMAgent::innerParentNode(breakpointOwner);
             if (!parentNode)
                 break;
             breakpointOwner = parentNode;
         }
 
         if (breakpointType == SubtreeModified)
             description->setBoolean("insertion", insertion);
     }
 
     int breakpointOwnerNodeId = m_domAgent->boundNodeId(breakpointOwner);
     ASSERT(breakpointOwnerNodeId);
     description->setInteger("nodeId", breakpointOwnerNodeId);
     description->setString("type", domTypeName(breakpointType));
+    String16 json = description->toJSONString();
+    m_v8Session->breakProgram(toV8InspectorStringView(protocol::Debugger::API::Paused::ReasonEnum::DOM), toV8InspectorStringView(json));
 }
 
 bool InspectorDOMDebuggerAgent::hasBreakpoint(Node* node, int type)
 {
     if (!m_domAgent->enabled())
         return false;
     uint32_t rootBit = 1 << type;
     uint32_t derivedBit = rootBit << domBreakpointDerivedTypeShift;
     return m_domBreakpoints.get(node) & (rootBit | derivedBit);
 }
@@ skipping 13 matching lines @@
         return;
 
     for (Node* child = InspectorDOMAgent::innerFirstChild(node); child; child = InspectorDOMAgent::innerNextSibling(child))
         updateSubtreeBreakpoints(child, newRootMask, set);
 }
 
 void InspectorDOMDebuggerAgent::pauseOnNativeEventIfNeeded(std::unique_ptr<protocol::DictionaryValue> eventData, bool synchronous)
 {
     if (!eventData)
         return;
+    String16 json = eventData->toJSONString();
     if (synchronous)
-        m_v8Session->breakProgram(protocol::Debugger::API::Paused::ReasonEnum::EventListener, eventData->toJSONString());
+        m_v8Session->breakProgram(toV8InspectorStringView(protocol::Debugger::API::Paused::ReasonEnum::EventListener), toV8InspectorStringView(json));
     else
-        m_v8Session->schedulePauseOnNextStatement(protocol::Debugger::API::Paused::ReasonEnum::EventListener, eventData->toJSONString());
+        m_v8Session->schedulePauseOnNextStatement(toV8InspectorStringView(protocol::Debugger::API::Paused::ReasonEnum::EventListener), toV8InspectorStringView(json));
 }
 
 std::unique_ptr<protocol::DictionaryValue> InspectorDOMDebuggerAgent::preparePauseOnNativeEventData(const String& eventName, const String* targetName)
 {
     String fullEventName = (targetName ? listenerEventCategoryType : instrumentationEventCategoryType) + eventName;
     protocol::DictionaryValue* breakpoints = eventListenerBreakpoints();
     protocol::Value* value = breakpoints->get(fullEventName);
     if (!value)
         return nullptr;
     bool match = false;
@@ skipping 81 matching lines @@
             }
         }
     }
 
     if (breakpointURL.isNull())
         return;
 
     std::unique_ptr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
     eventData->setString("breakpointURL", breakpointURL);
     eventData->setString("url", url);
-    m_v8Session->breakProgram(protocol::Debugger::API::Paused::ReasonEnum::XHR, eventData->toJSONString());
+    String16 json = eventData->toJSONString();
+    m_v8Session->breakProgram(toV8InspectorStringView(protocol::Debugger::API::Paused::ReasonEnum::XHR), toV8InspectorStringView(json));
 }
 
 void InspectorDOMDebuggerAgent::didAddBreakpoint()
 {
     if (m_state->booleanProperty(DOMDebuggerAgentState::enabled, false))
         return;
     setEnabled(true);
 }
 
 void InspectorDOMDebuggerAgent::didRemoveBreakpoint()
@@ skipping 19 matching lines @@
         m_instrumentingAgents->removeInspectorDOMDebuggerAgent(this);
     }
 }
 
 void InspectorDOMDebuggerAgent::didCommitLoadForLocalFrame(LocalFrame*)
 {
     m_domBreakpoints.clear();
 }
 
 } // namespace blink