[DevTools] Cleanup v8_inspector API part 1.

third_party/WebKit/Source/core/inspector/WorkerThreadDebugger.cpp

 /*
  * Copyright (c) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/inspector/WorkerThreadDebugger.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/inspector/ConsoleMessage.h"
+#include "core/inspector/IdentifiersFactory.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThread.h"
 #include <v8.h>
 
 namespace blink {
 
 static const int workerContextGroupId = 1;
 
 WorkerThreadDebugger* WorkerThreadDebugger::from(v8::Isolate* isolate)
 {
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     if (!data->threadDebugger())
         return nullptr;
     ASSERT(data->threadDebugger()->isWorker());
     return static_cast<WorkerThreadDebugger*>(data->threadDebugger());
 }
 
 WorkerThreadDebugger::WorkerThreadDebugger(WorkerThread* workerThread, v8::Isolate* isolate)
     : ThreadDebugger(isolate)
     , m_workerThread(workerThread)
+    , m_muteConsoleCount(0)
 {
 }
 
 WorkerThreadDebugger::~WorkerThreadDebugger()
 {
 }
 
 void WorkerThreadDebugger::contextCreated(v8::Local<v8::Context> context)
 {
     debugger()->contextCreated(V8ContextInfo(context, workerContextGroupId, true, m_workerThread->workerGlobalScope()->url().getString(), "", "", false));
 }
 
 void WorkerThreadDebugger::contextWillBeDestroyed(v8::Local<v8::Context> context)
 {
     debugger()->contextDestroyed(context);
 }
 
 void WorkerThreadDebugger::exceptionThrown(const String& errorMessage, std::unique_ptr<SourceLocation> location)
 {
+    if (m_muteConsoleCount)
+        return;
     debugger()->exceptionThrown(workerContextGroupId, errorMessage, location->url(), location->lineNumber(), location->columnNumber(), location->cloneStackTrace(), location->scriptId());
 }
 
+void WorkerThreadDebugger::addConsoleMessage(ConsoleMessage* consoleMessage)
+{
+    if (m_muteConsoleCount)
+        return;
+    debugger()->addConsoleMessage(
+        workerContextGroupId,
+        consoleMessage->source(),
+        consoleMessage->level(),
+        consoleMessage->message(),
+        consoleMessage->location()->url(),
+        consoleMessage->location()->lineNumber(),
+        consoleMessage->location()->columnNumber(),
+        consoleMessage->location()->cloneStackTrace(),
+        consoleMessage->location()->scriptId(),
+        IdentifiersFactory::requestId(consoleMessage->requestIdentifier()),
+        consoleMessage->workerId());
+}
+
 int WorkerThreadDebugger::contextGroupId()
 {
     return workerContextGroupId;
 }
 
 void WorkerThreadDebugger::runMessageLoopOnPause(int contextGroupId)
 {
     ASSERT(contextGroupId == workerContextGroupId);
     m_workerThread->startRunningDebuggerTasksOnPauseOnWorkerThread();
 }
 
 void WorkerThreadDebugger::quitMessageLoopOnPause()
 {
     m_workerThread->stopRunningDebuggerTasksOnPauseOnWorkerThread();
 }
 
+void WorkerThreadDebugger::muteWarningsAndDeprecations()
+{
+    m_muteConsoleCount++;
+}
+
+void WorkerThreadDebugger::unmuteWarningsAndDeprecations()
+{
+    m_muteConsoleCount--;
+}
+
 bool WorkerThreadDebugger::callingContextCanAccessContext(v8::Local<v8::Context> calling, v8::Local<v8::Context> target)
 {
     return true;
 }
 
 v8::Local<v8::Context> WorkerThreadDebugger::ensureDefaultContextInGroup(int contextGroupId)
 {
     ASSERT(contextGroupId == workerContextGroupId);
     ScriptState* scriptState = m_workerThread->workerGlobalScope()->scriptController()->getScriptState();
     return scriptState ? scriptState->context() : v8::Local<v8::Context>();
 }
 
 void WorkerThreadDebugger::messageAddedToConsole(int contextGroupId, MessageSource source, MessageLevel level, const String16& message, const String16& url, unsigned lineNumber, unsigned columnNumber, V8StackTrace* stackTrace)
 {
     DCHECK(contextGroupId == workerContextGroupId);
     ConsoleMessage* consoleMessage = ConsoleMessage::create(source, level, message, SourceLocation::create(url, lineNumber, columnNumber, stackTrace ? stackTrace->clone() : nullptr, 0));
     m_workerThread->workerReportingProxy().reportConsoleMessage(consoleMessage);
 }
 
 v8::MaybeLocal<v8::Value> WorkerThreadDebugger::memoryInfo(v8::Isolate*, v8::Local<v8::Context>)
 {
     ASSERT_NOT_REACHED();
     return v8::MaybeLocal<v8::Value>();
 }
 
 } // namespace blink