DevTools: always use 16bit strings for inspector protocol.

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

 // Copyright 2016 The Chromium 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 "platform/v8_inspector/V8HeapProfilerAgentImpl.h"
 
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InjectedScriptManager.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8RuntimeAgentImpl.h"
@@ skipping 24 matching lines @@
         }
         m_frontend->flush();
         return kContinue;
     }
 private:
     protocol::Frontend::HeapProfiler* m_frontend;
 };
 
 class GlobalObjectNameResolver final : public v8::HeapProfiler::ObjectNameResolver {
 public:
-    explicit GlobalObjectNameResolver(V8RuntimeAgentImpl* runtimeAgent) : m_runtimeAgent(runtimeAgent) { }
+    explicit GlobalObjectNameResolver(V8RuntimeAgentImpl* runtimeAgent) : m_offset(0), m_runtimeAgent(runtimeAgent)
+    {
+        m_strings.resize(10000);
+    }
+
     const char* GetName(v8::Local<v8::Object> object) override
     {
         int contextId = V8Debugger::contextId(object->CreationContext());
         if (!contextId)
             return "";
         InjectedScript* injectedScript = m_runtimeAgent->getInjectedScriptManager()->findInjectedScript(contextId);
         if (!injectedScript)
             return "";
-        String16 name = injectedScript->origin().latin1Data();
-        m_strings.append(name);
-        return reinterpret_cast<const char *>(name.characters8());
+        String16 name = injectedScript->origin();
+        size_t length = name.length();
+        if (m_offset + length + 1 >= m_strings.size())
+            return "";
+        for (size_t i = 0; i < length; ++i) {
+            UChar ch = name[i];
+            m_strings[m_offset + i] = ch > 0xff ? '?' : static_cast<char>(ch);
+        }
+        m_strings[m_offset + length] = '\0';
+        char* result = &*m_strings.begin() + m_offset;
+        m_offset += length + 1;
+        return result;
     }
 
 private:
-    protocol::Vector<String16> m_strings;
+    size_t m_offset;
+    protocol::Vector<char> m_strings;
     V8RuntimeAgentImpl* m_runtimeAgent;
 };
 
 class HeapSnapshotOutputStream final : public v8::OutputStream {
 public:
     HeapSnapshotOutputStream(protocol::Frontend::HeapProfiler* frontend)
         : m_frontend(frontend) { }
     void EndOfStream() override { }
     int GetChunkSize() override { return 102400; }
     WriteResult WriteAsciiChunk(char* data, int size) override
     {
         m_frontend->addHeapSnapshotChunk(String16(data, size));
         m_frontend->flush();
         return kContinue;
     }
 private:
     protocol::Frontend::HeapProfiler* m_frontend;
 };
 
-v8::Local<v8::Object> objectByHeapObjectId(v8::Isolate* isolate, unsigned id)
+v8::Local<v8::Object> objectByHeapObjectId(v8::Isolate* isolate, int id)
 {
     v8::HeapProfiler* profiler = isolate->GetHeapProfiler();
     v8::Local<v8::Value> value = profiler->FindObjectById(id);
     if (value.IsEmpty() || !value->IsObject())
         return v8::Local<v8::Object>();
     return value.As<v8::Object>();
 }
 
 class InspectableHeapObject final : public V8RuntimeAgent::Inspectable {
 public:
-    explicit InspectableHeapObject(unsigned heapObjectId) : m_heapObjectId(heapObjectId) { }
+    explicit InspectableHeapObject(int heapObjectId) : m_heapObjectId(heapObjectId) { }
     v8::Local<v8::Value> get(v8::Local<v8::Context> context) override
     {
         return objectByHeapObjectId(context->GetIsolate(), m_heapObjectId);
     }
 private:
-    unsigned m_heapObjectId;
+    int m_heapObjectId;
 };
 
 class HeapStatsStream final : public v8::OutputStream {
 public:
     HeapStatsStream(protocol::Frontend::HeapProfiler* frontend)
         : m_frontend(frontend)
     {
     }
 
     void EndOfStream() override { }
@@ skipping 113 matching lines @@
         return;
     }
     HeapSnapshotOutputStream stream(m_frontend);
     snapshot->Serialize(&stream);
     const_cast<v8::HeapSnapshot*>(snapshot)->Delete();
 }
 
 void V8HeapProfilerAgentImpl::getObjectByHeapObjectId(ErrorString* error, const String16& heapSnapshotObjectId, const protocol::Maybe<String16>& objectGroup, OwnPtr<protocol::Runtime::RemoteObject>* result)
 {
     bool ok;
-    unsigned id = heapSnapshotObjectId.toUInt(&ok);
+    int id = heapSnapshotObjectId.toInt(&ok);
     if (!ok) {
         *error = "Invalid heap snapshot object id";
         return;
     }
 
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Object> heapObject = objectByHeapObjectId(m_isolate, id);
     if (heapObject.IsEmpty()) {
         *error = "Object is not available";
         return;
     }
     *result = m_runtimeAgent->wrapObject(heapObject->CreationContext(), heapObject, objectGroup.fromMaybe(""));
     if (!result)
         *error = "Object is not available";
 }
 
 void V8HeapProfilerAgentImpl::addInspectedHeapObject(ErrorString* errorString, const String16& inspectedHeapObjectId)
 {
     bool ok;
-    unsigned id = inspectedHeapObjectId.toUInt(&ok);
+    int id = inspectedHeapObjectId.toInt(&ok);
     if (!ok) {
         *errorString = "Invalid heap snapshot object id";
         return;
     }
     m_runtimeAgent->addInspectedObject(adoptPtr(new InspectableHeapObject(id)));
 }
 
 void V8HeapProfilerAgentImpl::getHeapObjectId(ErrorString* errorString, const String16& objectId, String16* heapSnapshotObjectId)
 {
     v8::HandleScope handles(m_isolate);
@@ skipping 74 matching lines @@
     if (!v8Profile) {
         *errorString = "Cannot access v8 sampled heap profile.";
         return;
     }
     v8::AllocationProfile::Node* root = v8Profile->GetRootNode();
     *profile = protocol::HeapProfiler::SamplingHeapProfile::create()
         .setHead(buildSampingHeapProfileNode(root)).build();
 }
 
 } // namespace blink