DevTools: migrate remote debugging protocol generators to jinja2.

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/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "wtf/CurrentTime.h"
 #include <v8-profiler.h>
 
 namespace blink {
 
 namespace HeapProfilerAgentState {
 static const char heapProfilerEnabled[] = "heapProfilerEnabled";
 static const char heapObjectsTrackingEnabled[] = "heapObjectsTrackingEnabled";
 static const char allocationTrackingEnabled[] = "allocationTrackingEnabled";
 static const char samplingHeapProfilerEnabled[] = "samplingHeapProfilerEnabled";
 }
 
 namespace {
 
-bool asBool(const bool* value)
-{
-    return value && *value;
-}
-
 class HeapSnapshotProgress final : public v8::ActivityControl {
 public:
     HeapSnapshotProgress(protocol::Frontend::HeapProfiler* frontend)
         : m_frontend(frontend) { }
     ControlOption ReportProgressValue(int done, int total) override
     {
-        m_frontend->reportHeapSnapshotProgress(done, total, nullptr);
+        m_frontend->reportHeapSnapshotProgress(done, total, protocol::TypeBuilder::OptionalValue<bool>());

[dgozman, 2016/02/22 23:57:36]

We could use default parameters to simplify such calls.

         if (done >= total) {
-            const bool finished = true;
-            m_frontend->reportHeapSnapshotProgress(total, total, &finished);
+            m_frontend->reportHeapSnapshotProgress(total, total, protocol::TypeBuilder::OptionalValue<bool>(true));
         }
         m_frontend->flush();
         return kContinue;
     }
 private:
     protocol::Frontend::HeapProfiler* m_frontend;
 };
 
 class GlobalObjectNameResolver final : public v8::HeapProfiler::ObjectNameResolver {
 public:
@@ skipping 63 matching lines @@
 
     WriteResult WriteAsciiChunk(char* data, int size) override
     {
         ASSERT(false);
         return kAbort;
     }
 
     WriteResult WriteHeapStatsChunk(v8::HeapStatsUpdate* updateData, int count) override
     {
         ASSERT(count > 0);
-        RefPtr<protocol::TypeBuilder::Array<int>> statsDiff = protocol::TypeBuilder::Array<int>::create();
+        OwnPtr<protocol::TypeBuilder::Array<int>> statsDiff = protocol::TypeBuilder::Array<int>::create();
         for (int i = 0; i < count; ++i) {
             statsDiff->addItem(updateData[i].index);
             statsDiff->addItem(updateData[i].count);
             statsDiff->addItem(updateData[i].size);
         }
         m_frontend->heapStatsUpdate(statsDiff.release());
         return kContinue;
     }
 
 private:
@@ skipping 35 matching lines @@
         ErrorString error;
         startSampling(&error);
     }
 }
 
 void V8HeapProfilerAgentImpl::collectGarbage(ErrorString*)
 {
     m_isolate->LowMemoryNotification();
 }
 
-void V8HeapProfilerAgentImpl::startTrackingHeapObjects(ErrorString*, const bool* trackAllocations)
+void V8HeapProfilerAgentImpl::startTrackingHeapObjects(ErrorString*, const protocol::TypeBuilder::OptionalValue<bool>& trackAllocations)
 {
     m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled, true);
-    bool allocationTrackingEnabled = asBool(trackAllocations);
+    bool allocationTrackingEnabled = trackAllocations.get(false);
     m_state->setBoolean(HeapProfilerAgentState::allocationTrackingEnabled, allocationTrackingEnabled);
     startTrackingHeapObjectsInternal(allocationTrackingEnabled);
 }
 
-void V8HeapProfilerAgentImpl::stopTrackingHeapObjects(ErrorString* error, const bool* reportProgress)
+void V8HeapProfilerAgentImpl::stopTrackingHeapObjects(ErrorString* error, const protocol::TypeBuilder::OptionalValue<bool>& reportProgress)
 {
     requestHeapStatsUpdate();
     takeHeapSnapshot(error, reportProgress);
     stopTrackingHeapObjectsInternal();
 }
 
 void V8HeapProfilerAgentImpl::enable(ErrorString*)
 {
     m_state->setBoolean(HeapProfilerAgentState::heapProfilerEnabled, true);
 }
 
 void V8HeapProfilerAgentImpl::disable(ErrorString* error)
 {
     stopTrackingHeapObjectsInternal();
     if (m_state->booleanProperty(HeapProfilerAgentState::samplingHeapProfilerEnabled, false)) {
         v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
         if (profiler)
             profiler->StopSamplingHeapProfiler();
     }
     m_isolate->GetHeapProfiler()->ClearObjectIds();
     m_state->setBoolean(HeapProfilerAgentState::heapProfilerEnabled, false);
 }
 
-void V8HeapProfilerAgentImpl::takeHeapSnapshot(ErrorString* errorString, const bool* reportProgress)
+void V8HeapProfilerAgentImpl::takeHeapSnapshot(ErrorString* errorString, const protocol::TypeBuilder::OptionalValue<bool>& reportProgress)
 {
     v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
     if (!profiler) {
         *errorString = "Cannot access v8 heap profiler";
         return;
     }
     OwnPtr<HeapSnapshotProgress> progress;
-    if (asBool(reportProgress))
+    if (reportProgress.get(false))
         progress = adoptPtr(new HeapSnapshotProgress(m_frontend));
 
     GlobalObjectNameResolver resolver(static_cast<V8RuntimeAgentImpl*>(m_runtimeAgent));
     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 String* objectGroup, RefPtr<protocol::TypeBuilder::Runtime::RemoteObject>& result)
+void V8HeapProfilerAgentImpl::getObjectByHeapObjectId(ErrorString* error, const String& heapSnapshotObjectId, const protocol::TypeBuilder::OptionalValue<String>& objectGroup, OwnPtr<protocol::TypeBuilder::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 ? *objectGroup : "");
+    *result = m_runtimeAgent->wrapObject(heapObject->CreationContext(), heapObject, objectGroup.get(""));
     if (!result)
         *error = "Object is not available";
 }
 
 void V8HeapProfilerAgentImpl::addInspectedHeapObject(ErrorString* errorString, const String& inspectedHeapObjectId)
 {
     bool ok;
     unsigned id = inspectedHeapObjectId.toUInt(&ok);
     if (!ok) {
         *errorString = "Invalid heap snapshot object id";
@@ skipping 41 matching lines @@
     v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
     if (!profiler) {
         *errorString = "Cannot access v8 heap profiler";
         return;
     }
     m_state->setBoolean(HeapProfilerAgentState::samplingHeapProfilerEnabled, true);
     profiler->StartSamplingHeapProfiler();
 }
 
 namespace {
-PassRefPtr<protocol::TypeBuilder::HeapProfiler::SamplingHeapProfileNode> buildSampingHeapProfileNode(const v8::AllocationProfile::Node* node)
+PassOwnPtr<protocol::TypeBuilder::HeapProfiler::SamplingHeapProfileNode> buildSampingHeapProfileNode(const v8::AllocationProfile::Node* node)
 {
     auto children = protocol::TypeBuilder::Array<protocol::TypeBuilder::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;
-    RefPtr<protocol::TypeBuilder::HeapProfiler::SamplingHeapProfileNode> result = protocol::TypeBuilder::HeapProfiler::SamplingHeapProfileNode::create()
+    OwnPtr<protocol::TypeBuilder::HeapProfiler::SamplingHeapProfileNode> result = protocol::TypeBuilder::HeapProfiler::SamplingHeapProfileNode::create()
         .setFunctionName(toWTFString(node->name))
         .setScriptId(String::number(node->script_id))
         .setUrl(toWTFString(node->script_name))
         .setLineNumber(node->line_number)
         .setColumnNumber(node->column_number)
         .setTotalSize(totalSize)
-        .setChildren(children);
+        .setChildren(children).build();
     return result.release();
 }
 } // namespace
 
-void V8HeapProfilerAgentImpl::stopSampling(ErrorString* errorString, RefPtr<protocol::TypeBuilder::HeapProfiler::SamplingHeapProfile>& profile)
+void V8HeapProfilerAgentImpl::stopSampling(ErrorString* errorString, OwnPtr<protocol::TypeBuilder::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::TypeBuilder::HeapProfiler::SamplingHeapProfile::create()
-        .setHead(buildSampingHeapProfileNode(root));
+    *profile = protocol::TypeBuilder::HeapProfiler::SamplingHeapProfile::create()
+        .setHead(buildSampingHeapProfileNode(root)).build();
 }
 
 } // namespace blink