DevTools: generate frontend and backend interfaces under domains.

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/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
@@ skipping 10 matching lines @@
 static const char heapObjectsTrackingEnabled[] = "heapObjectsTrackingEnabled";
 static const char allocationTrackingEnabled[] = "allocationTrackingEnabled";
 #if V8_MAJOR_VERSION >= 5
 static const char samplingHeapProfilerEnabled[] = "samplingHeapProfilerEnabled";
 static const char samplingHeapProfilerInterval[] = "samplingHeapProfilerInterval";
 #endif
 }
 
 class HeapSnapshotProgress final : public v8::ActivityControl {
 public:
-    HeapSnapshotProgress(protocol::Frontend::HeapProfiler* frontend)
+    HeapSnapshotProgress(protocol::HeapProfiler::Frontend* frontend)
         : m_frontend(frontend) { }
     ControlOption ReportProgressValue(int done, int total) override
     {
         m_frontend->reportHeapSnapshotProgress(done, total, protocol::Maybe<bool>());
         if (done >= total) {
             m_frontend->reportHeapSnapshotProgress(total, total, true);
         }
         m_frontend->flush();
         return kContinue;
     }
 private:
-    protocol::Frontend::HeapProfiler* m_frontend;
+    protocol::HeapProfiler::Frontend* m_frontend;
 };
 
 class GlobalObjectNameResolver final : public v8::HeapProfiler::ObjectNameResolver {
 public:
     explicit GlobalObjectNameResolver(V8InspectorSessionImpl* session) : m_offset(0), m_session(session)
     {
         m_strings.resize(10000);
     }
 
     const char* GetName(v8::Local<v8::Object> object) override
@@ skipping 20 matching lines @@
     }
 
 private:
     size_t m_offset;
     protocol::Vector<char> m_strings;
     V8InspectorSessionImpl* m_session;
 };
 
 class HeapSnapshotOutputStream final : public v8::OutputStream {
 public:
-    HeapSnapshotOutputStream(protocol::Frontend::HeapProfiler* frontend)
+    HeapSnapshotOutputStream(protocol::HeapProfiler::Frontend* 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;
+    protocol::HeapProfiler::Frontend* m_frontend;
 };
 
 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 V8InspectorSession::Inspectable {
 public:
     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:
     int m_heapObjectId;
 };
 
 class HeapStatsStream final : public v8::OutputStream {
 public:
-    HeapStatsStream(protocol::Frontend::HeapProfiler* frontend)
+    HeapStatsStream(protocol::HeapProfiler::Frontend* frontend)
         : m_frontend(frontend)
     {
     }
 
     void EndOfStream() override { }
 
     WriteResult WriteAsciiChunk(char* data, int size) override
     {
         DCHECK(false);
         return kAbort;
     }
 
     WriteResult WriteHeapStatsChunk(v8::HeapStatsUpdate* updateData, int count) override
     {
         DCHECK_GT(count, 0);
         std::unique_ptr<protocol::Array<int>> statsDiff = protocol::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(std::move(statsDiff));
         return kContinue;
     }
 
 private:
-    protocol::Frontend::HeapProfiler* m_frontend;
+    protocol::HeapProfiler::Frontend* m_frontend;
 };
 
 } // namespace
 
-V8HeapProfilerAgentImpl::V8HeapProfilerAgentImpl(V8InspectorSessionImpl* session, protocol::Frontend::HeapProfiler* frontend, protocol::DictionaryValue* state)
+V8HeapProfilerAgentImpl::V8HeapProfilerAgentImpl(V8InspectorSessionImpl* session, protocol::HeapProfiler::Frontend* frontend, protocol::DictionaryValue* state)
     : m_session(session)
     , m_isolate(session->debugger()->isolate())
     , m_frontend(frontend)
     , m_state(state)
     , m_hasTimer(false)
 {
 }
 
 V8HeapProfilerAgentImpl::~V8HeapProfilerAgentImpl()
 {
@@ skipping 231 matching lines @@
         *errorString = "Cannot access v8 sampled heap profile.";
         return;
     }
     v8::AllocationProfile::Node* root = v8Profile->GetRootNode();
     *profile = protocol::HeapProfiler::SamplingHeapProfile::create()
         .setHead(buildSampingHeapProfileNode(root)).build();
 #endif
 }
 
 } // namespace blink