[DevTools] Rename V8Debugger to V8Inspector.

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/V8InspectorImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
-#include "platform/v8_inspector/public/V8DebuggerClient.h"
+#include "platform/v8_inspector/public/V8InspectorClient.h"
 #include <v8-profiler.h>
 #include <v8-version.h>
 
 namespace blink {
 
 namespace {
 
 namespace HeapProfilerAgentState {
 static const char heapProfilerEnabled[] = "heapProfilerEnabled";
 static const char heapObjectsTrackingEnabled[] = "heapObjectsTrackingEnabled";
@@ skipping 21 matching lines @@
     protocol::HeapProfiler::Frontend* m_frontend;
 };
 
 class GlobalObjectNameResolver final : public v8::HeapProfiler::ObjectNameResolver {
 public:
     explicit GlobalObjectNameResolver(V8InspectorSessionImpl* session)
         : m_offset(0), m_strings(10000), m_session(session) {}
 
     const char* GetName(v8::Local<v8::Object> object) override
     {
-        int contextId = V8DebuggerImpl::contextId(object->CreationContext());
+        int contextId = V8InspectorImpl::contextId(object->CreationContext());
         if (!contextId)
             return "";
         ErrorString errorString;
         InjectedScript* injectedScript = m_session->findInjectedScript(&errorString, contextId);
         if (!injectedScript)
             return "";
         String16 name = injectedScript->context()->origin();
         size_t length = name.length();
         if (m_offset + length + 1 >= m_strings.size())
             return "";
@@ skipping 78 matching lines @@
     }
 
 private:
     protocol::HeapProfiler::Frontend* m_frontend;
 };
 
 } // namespace
 
 V8HeapProfilerAgentImpl::V8HeapProfilerAgentImpl(V8InspectorSessionImpl* session, protocol::FrontendChannel* frontendChannel, protocol::DictionaryValue* state)
     : m_session(session)
-    , m_isolate(session->debugger()->isolate())
+    , m_isolate(session->inspector()->isolate())
     , m_frontend(frontendChannel)
     , m_state(state)
     , m_hasTimer(false)
 {
 }
 
 V8HeapProfilerAgentImpl::~V8HeapProfilerAgentImpl()
 {
 }
 
@@ skipping 83 matching lines @@
         return;
     }
 
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Object> heapObject = objectByHeapObjectId(m_isolate, id);
     if (heapObject.IsEmpty()) {
         *error = "Object is not available";
         return;
     }
 
-    if (!m_session->debugger()->client()->isInspectableHeapObject(heapObject)) {
+    if (!m_session->inspector()->client()->isInspectableHeapObject(heapObject)) {
         *error = "Object is not available";
         return;
     }
 
     *result = m_session->wrapObject(heapObject->CreationContext(), heapObject, objectGroup.fromMaybe(""), false);
     if (!result)
         *error = "Object is not available";
 }
 
 void V8HeapProfilerAgentImpl::addInspectedHeapObject(ErrorString* errorString, const String16& inspectedHeapObjectId)
 {
     bool ok;
     int id = inspectedHeapObjectId.toInt(&ok);
     if (!ok) {
         *errorString = "Invalid heap snapshot object id";
         return;
     }
 
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Object> heapObject = objectByHeapObjectId(m_isolate, id);
     if (heapObject.IsEmpty()) {
         *errorString = "Object is not available";
         return;
     }
 
-    if (!m_session->debugger()->client()->isInspectableHeapObject(heapObject)) {
+    if (!m_session->inspector()->client()->isInspectableHeapObject(heapObject)) {
         *errorString = "Object is not available";
         return;
     }
 
     m_session->addInspectedObject(wrapUnique(new InspectableHeapObject(id)));
 }
 
 void V8HeapProfilerAgentImpl::getHeapObjectId(ErrorString* errorString, const String16& objectId, String16* heapSnapshotObjectId)
 {
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Value> value;
     v8::Local<v8::Context> context;
     String16 objectGroup;
     if (!m_session->unwrapObject(errorString, objectId, &value, &context, &objectGroup) || value->IsUndefined())
         return;
 
     v8::SnapshotObjectId id = m_isolate->GetHeapProfiler()->GetObjectId(value);
     *heapSnapshotObjectId = String16::fromInteger(id);
 }
 
 void V8HeapProfilerAgentImpl::requestHeapStatsUpdate()
 {
     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->inspector()->client()->currentTimeMS());
 }
 
 // static
 void V8HeapProfilerAgentImpl::onTimer(void* data)
 {
     reinterpret_cast<V8HeapProfilerAgentImpl*>(data)->requestHeapStatsUpdate();
 }
 
 void V8HeapProfilerAgentImpl::startTrackingHeapObjectsInternal(bool trackAllocations)
 {
     m_isolate->GetHeapProfiler()->StartTrackingHeapObjects(trackAllocations);
     if (!m_hasTimer) {
         m_hasTimer = true;
-        m_session->debugger()->client()->startRepeatingTimer(0.05, &V8HeapProfilerAgentImpl::onTimer, reinterpret_cast<void*>(this));
+        m_session->inspector()->client()->startRepeatingTimer(0.05, &V8HeapProfilerAgentImpl::onTimer, reinterpret_cast<void*>(this));
     }
 }
 
 void V8HeapProfilerAgentImpl::stopTrackingHeapObjectsInternal()
 {
     if (m_hasTimer) {
-        m_session->debugger()->client()->cancelTimer(reinterpret_cast<void*>(this));
+        m_session->inspector()->client()->cancelTimer(reinterpret_cast<void*>(this));
         m_hasTimer = false;
     }
     m_isolate->GetHeapProfiler()->StopTrackingHeapObjects();
     m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled, false);
     m_state->setBoolean(HeapProfilerAgentState::allocationTrackingEnabled, false);
 }
 
 void V8HeapProfilerAgentImpl::startSampling(ErrorString* errorString, const Maybe<double>& samplingInterval)
 {
 #if V8_MAJOR_VERSION >= 5
@@ skipping 56 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