[DevTools] Remove reference to DebuggerAgent from ConsoleAgent

third_party/WebKit/Source/platform/v8_inspector/V8Console.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/V8Console.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/v8_inspector/InspectedContext.h"
+#include "platform/v8_inspector/V8DebuggerAgentImpl.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8ProfilerAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/ConsoleAPITypes.h"
 #include "platform/v8_inspector/public/ConsoleTypes.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 
 namespace blink {
@@ skipping 146 matching lines @@
 
     void setDoubleOnMap(v8::Local<v8::Map> map, const String16& key, double value)
     {
         v8::Local<v8::String> v8Key = toV8String(m_isolate, key);
         if (!map->Set(m_context, v8Key, v8::Number::New(m_isolate, value)).ToLocal(&map))
             return;
     }
 
     V8ProfilerAgentImpl* profilerAgent()
     {
-        InspectedContext* inspectedContext = ensureInspectedContext();
-        if (!inspectedContext)
-            return nullptr;
-        V8InspectorSessionImpl* session = inspectedContext->debugger()->sessionForContextGroup(inspectedContext->contextGroupId());
-        if (session && session->profilerAgentImpl()->enabled())
-            return session->profilerAgentImpl();
+        if (V8InspectorSessionImpl* session = currentSession()) {
+            if (session && session->profilerAgentImpl()->enabled())
+                return session->profilerAgentImpl();
+        }
+        return nullptr;
+    }
+
+    V8DebuggerAgentImpl* debuggerAgent()
+    {
+        if (V8InspectorSessionImpl* session = currentSession()) {
+            if (session && session->debuggerAgentImpl()->enabled())
+                return session->debuggerAgentImpl();
+        }
         return nullptr;
     }
 private:
     const v8::FunctionCallbackInfo<v8::Value>& m_info;
     v8::Isolate* m_isolate;
     v8::Local<v8::Context> m_context;
     v8::Local<v8::Object> m_console;
     InspectedContext* m_inspectedContext;
     V8DebuggerClient* m_debuggerClient;
 
     bool checkAndSetPrivateFlagOnConsole(const char* name, bool defaultValue)
     {
         v8::Local<v8::Object> console = ensureConsole();
         v8::Local<v8::Private> key = v8::Private::ForApi(m_isolate, toV8StringInternalized(m_isolate, name));
         v8::Local<v8::Value> flagValue;
         if (!console->GetPrivate(m_context, key).ToLocal(&flagValue))
             return defaultValue;
         ASSERT(flagValue->IsUndefined() || flagValue->IsBoolean());
         if (flagValue->IsBoolean()) {
             ASSERT(flagValue.As<v8::Boolean>()->Value());
             return true;
         }
         if (!console->SetPrivate(m_context, key, v8::True(m_isolate)).FromMaybe(false))
             return defaultValue;
         return false;
     }
+
+    V8InspectorSessionImpl* currentSession()
+    {
+        InspectedContext* inspectedContext = ensureInspectedContext();
+        if (!inspectedContext)
+            return nullptr;
+        return inspectedContext->debugger()->sessionForContextGroup(inspectedContext->contextGroupId());
+    }
 };
 
 v8::MaybeLocal<v8::Object> createObjectWithClassName(V8DebuggerImpl* debugger, v8::Local<v8::Context> context, const char* className)
 {
     v8::Isolate* isolate = debugger->isolate();
     v8::Local<v8::FunctionTemplate> functionTemplate;
     String16 functionTemplateName = String16("V8Console#") + className;
     if (!debugger->functionTemplate(functionTemplateName).ToLocal(&functionTemplate)) {
         functionTemplate = v8::FunctionTemplate::New(isolate);
         functionTemplate->SetClassName(toV8StringInternalized(isolate, className));
@@ skipping 104 matching lines @@
     helper.setIntOnMap(countMap, identifier, count);
     helper.addMessage(CountMessageType, DebugMessageLevel, title + ": " + String16::number(count));
 }
 
 void V8Console::assertCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ConsoleHelper helper(info);
     if (helper.firstArgToBoolean(false))
         return;
     helper.addMessage(AssertMessageType, ErrorMessageLevel, true, 1);
+    if (V8DebuggerAgentImpl* debuggerAgent = helper.debuggerAgent())
+        debuggerAgent->breakProgramOnException(protocol::Debugger::Paused::ReasonEnum::Assert, nullptr);
 }
 
 void V8Console::markTimelineCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ConsoleHelper(info).addDeprecationMessage("V8Console#markTimelineDeprecated", "'console.markTimeline' is deprecated. Please use 'console.timeStamp' instead.");
     timeStampCallback(info);
 }
 
 void V8Console::profileCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
@@ skipping 132 matching lines @@
         return v8::MaybeLocal<v8::Object>();
 
     if (hasMemoryAttribute)
         console->SetAccessorProperty(toV8StringInternalized(isolate, "memory"), v8::Function::New(isolate, V8Console::memoryGetterCallback, console), v8::Function::New(isolate, V8Console::memorySetterCallback), static_cast<v8::PropertyAttribute>(v8::None), v8::DEFAULT);
 
     console->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, inspectedContext));
     return console;
 }
 
 } // namespace blink