DevTools: generate string16-based handlers for v8_inspector.

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 33 matching lines @@
 public:
     explicit GlobalObjectNameResolver(V8RuntimeAgentImpl* runtimeAgent) : m_runtimeAgent(runtimeAgent) { }
     const char* GetName(v8::Local<v8::Object> object) override
     {
         int contextId = V8Debugger::contextId(object->CreationContext());
         if (!contextId)
             return "";
         InjectedScript* injectedScript = m_runtimeAgent->injectedScriptManager()->findInjectedScript(contextId);
         if (!injectedScript)
             return "";
-        CString name = injectedScript->origin().utf8();
+        String name = injectedScript->origin().latin1();

[dgozman, 2016/03/08 01:35:12]

String16

         m_strings.append(name);
-        return name.data();
+        return reinterpret_cast<const char *>(name.characters8());

[dgozman, 2016/03/08 01:35:12]

Is characters8 null-terminated?

[pfeldman, 2016/03/08 02:24:59]

YES!

     }
 
 private:
-    protocol::Vector<CString> m_strings;
+    protocol::Vector<String> m_strings;

[dgozman, 2016/03/08 01:35:12]

String16

     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(String(data, size));
+        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::HeapProfiler* profiler = isolate->GetHeapProfiler();
@@ skipping 135 matching lines @@
     const v8::HeapSnapshot* snapshot = profiler->TakeHeapSnapshot(progress.get(), &resolver);
     if (!snapshot) {
         *errorString = "Failed to take heap snapshot";
         return;
     }
     HeapSnapshotOutputStream stream(m_frontend);
     snapshot->Serialize(&stream);
     const_cast<v8::HeapSnapshot*>(snapshot)->Delete();
 }
 
-void V8HeapProfilerAgentImpl::getObjectByHeapObjectId(ErrorString* error, const String& heapSnapshotObjectId, const protocol::Maybe<String>& objectGroup, OwnPtr<protocol::Runtime::RemoteObject>* result)
+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);
     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 String& inspectedHeapObjectId)
+void V8HeapProfilerAgentImpl::addInspectedHeapObject(ErrorString* errorString, const String16& inspectedHeapObjectId)
 {
     bool ok;
     unsigned id = inspectedHeapObjectId.toUInt(&ok);
     if (!ok) {
         *errorString = "Invalid heap snapshot object id";
         return;
     }
     m_runtimeAgent->addInspectedObject(adoptPtr(new InspectableHeapObject(id)));
 }
 
-void V8HeapProfilerAgentImpl::getHeapObjectId(ErrorString* errorString, const String& objectId, String* heapSnapshotObjectId)
+void V8HeapProfilerAgentImpl::getHeapObjectId(ErrorString* errorString, const String16& objectId, String16* heapSnapshotObjectId)
 {
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Value> value = m_runtimeAgent->findObject(objectId);
     if (value.IsEmpty() || value->IsUndefined()) {
         *errorString = "Object with given id not found";
         return;
     }
 
     v8::SnapshotObjectId id = m_isolate->GetHeapProfiler()->GetObjectId(value);
-    *heapSnapshotObjectId = String::number(id);
+    *heapSnapshotObjectId = String16::number(id);
 }
 
 void V8HeapProfilerAgentImpl::requestHeapStatsUpdate()
 {
     if (!m_frontend)
         return;
     HeapStatsStream stream(m_frontend);
     v8::SnapshotObjectId lastSeenObjectId = m_isolate->GetHeapProfiler()->GetHeapStats(&stream);
     m_frontend->lastSeenObjectId(lastSeenObjectId, m_runtimeAgent->debugger()->client()->currentTimeMS());
 }
@@ skipping 24 matching lines @@
 namespace {
 PassOwnPtr<protocol::HeapProfiler::SamplingHeapProfileNode> buildSampingHeapProfileNode(const v8::AllocationProfile::Node* node)
 {
     auto children = protocol::Array<protocol::HeapProfiler::SamplingHeapProfileNode>::create();
     for (const auto* child : node->children)
         children->addItem(buildSampingHeapProfileNode(child));
     size_t totalSize = 0;
     for (const auto& allocation : node->allocations)
         totalSize += allocation.size * allocation.count;
     OwnPtr<protocol::HeapProfiler::SamplingHeapProfileNode> result = protocol::HeapProfiler::SamplingHeapProfileNode::create()
-        .setFunctionName(toWTFString(node->name))
-        .setScriptId(String::number(node->script_id))
-        .setUrl(toWTFString(node->script_name))
+        .setFunctionName(toProtocolString(node->name))
+        .setScriptId(String16::number(node->script_id))
+        .setUrl(toProtocolString(node->script_name))
         .setLineNumber(node->line_number)
         .setColumnNumber(node->column_number)
         .setTotalSize(totalSize)
         .setChildren(children).build();
     return result.release();
 }
 } // namespace
 
 void V8HeapProfilerAgentImpl::stopSampling(ErrorString* errorString, OwnPtr<protocol::HeapProfiler::SamplingHeapProfile>* profile)
 {
     v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
     if (!profiler) {
         *errorString = "Cannot access v8 heap profiler";
         return;
     }
     v8::HandleScope scope(m_isolate); // Allocation profile contains Local handles.
     OwnPtr<v8::AllocationProfile> v8Profile = adoptPtr(profiler->GetAllocationProfile());
     profiler->StopSamplingHeapProfiler();
     m_state->setBoolean(HeapProfilerAgentState::samplingHeapProfilerEnabled, false);
     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