DevTools: consolidate protocol generators for front-end, backend and type builder.

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 131 matching lines @@
         m_frontend->heapStatsUpdate(std::move(statsDiff));
         return kContinue;
     }
 
 private:
     protocol::HeapProfiler::Frontend* m_frontend;
 };
 
 } // namespace
 
-V8HeapProfilerAgentImpl::V8HeapProfilerAgentImpl(V8InspectorSessionImpl* session, protocol::HeapProfiler::Frontend* frontend, protocol::DictionaryValue* state)
+V8HeapProfilerAgentImpl::V8HeapProfilerAgentImpl(V8InspectorSessionImpl* session, protocol::FrontendChannel* frontendChannel, protocol::DictionaryValue* state)
     : m_session(session)
     , m_isolate(session->debugger()->isolate())
-    , m_frontend(frontend)
+    , m_frontend(frontendChannel)
     , m_state(state)
     , m_hasTimer(false)
 {
 }
 
 V8HeapProfilerAgentImpl::~V8HeapProfilerAgentImpl()
 {
 }
 
 void V8HeapProfilerAgentImpl::restore()
 {
     if (m_state->booleanProperty(HeapProfilerAgentState::heapProfilerEnabled, false))
-        m_frontend->resetProfiles();
+        m_frontend.resetProfiles();
     if (m_state->booleanProperty(HeapProfilerAgentState::heapObjectsTrackingEnabled, false))
         startTrackingHeapObjectsInternal(m_state->booleanProperty(HeapProfilerAgentState::allocationTrackingEnabled, false));
 #if V8_MAJOR_VERSION >= 5
     if (m_state->booleanProperty(HeapProfilerAgentState::samplingHeapProfilerEnabled, false)) {
         ErrorString error;
         double samplingInterval = m_state->numberProperty(HeapProfilerAgentState::samplingHeapProfilerInterval, -1);
         DCHECK_GE(samplingInterval, 0);
         startSampling(&error, Maybe<double>(samplingInterval));
     }
 #endif
@@ skipping 40 matching lines @@
 
 void V8HeapProfilerAgentImpl::takeHeapSnapshot(ErrorString* errorString, const protocol::Maybe<bool>& reportProgress)
 {
     v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
     if (!profiler) {
         *errorString = "Cannot access v8 heap profiler";
         return;
     }
     std::unique_ptr<HeapSnapshotProgress> progress;
     if (reportProgress.fromMaybe(false))
-        progress = wrapUnique(new HeapSnapshotProgress(m_frontend));
+        progress = wrapUnique(new HeapSnapshotProgress(&m_frontend));
 
     GlobalObjectNameResolver resolver(m_session);
     const v8::HeapSnapshot* snapshot = profiler->TakeHeapSnapshot(progress.get(), &resolver);
     if (!snapshot) {
         *errorString = "Failed to take heap snapshot";
         return;
     }
-    HeapSnapshotOutputStream stream(m_frontend);
+    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, std::unique_ptr<protocol::Runtime::RemoteObject>* result)
 {
     bool ok;
     int id = heapSnapshotObjectId.toInt(&ok);
     if (!ok) {
         *error = "Invalid heap snapshot object id";
@@ skipping 47 matching lines @@
     v8::Local<v8::Value> value = m_session->findObject(errorString, objectId);
     if (value.IsEmpty() || value->IsUndefined())
         return;
 
     v8::SnapshotObjectId id = m_isolate->GetHeapProfiler()->GetObjectId(value);
     *heapSnapshotObjectId = String16::number(id);
 }
 
 void V8HeapProfilerAgentImpl::requestHeapStatsUpdate()
 {
-    if (!m_frontend)
-        return;
-    HeapStatsStream stream(m_frontend);
+    HeapStatsStream stream(&m_frontend);
     v8::SnapshotObjectId lastSeenObjectId = m_isolate->GetHeapProfiler()->GetHeapStats(&stream);
-    m_frontend->lastSeenObjectId(lastSeenObjectId, m_session->debugger()->client()->currentTimeMS());
+    m_frontend.lastSeenObjectId(lastSeenObjectId, m_session->debugger()->client()->currentTimeMS());
 }
 
 // static
 void V8HeapProfilerAgentImpl::onTimer(void* data)
 {
     reinterpret_cast<V8HeapProfilerAgentImpl*>(data)->requestHeapStatsUpdate();
 }
 
 void V8HeapProfilerAgentImpl::startTrackingHeapObjectsInternal(bool trackAllocations)
 {
@@ skipping 74 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