Roll third_party/inspector_protocol to 73028acaa3646789fd2a3bfd0d79eb2d91b696b3

src/inspector/v8-inspector-session-impl.cc

 // Copyright 2016 the V8 project 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 "src/inspector/v8-inspector-session-impl.h"
 
 #include "src/inspector/injected-script.h"
 #include "src/inspector/inspected-context.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/remote-object-id.h"
@@ skipping 22 matching lines @@
              method, protocol::HeapProfiler::Metainfo::commandPrefix) ||
          stringViewStartsWith(method,
                               protocol::Console::Metainfo::commandPrefix) ||
          stringViewStartsWith(method,
                               protocol::Schema::Metainfo::commandPrefix);
 }
 
 std::unique_ptr<V8InspectorSessionImpl> V8InspectorSessionImpl::create(
     V8InspectorImpl* inspector, int contextGroupId,
     V8Inspector::Channel* channel, const StringView& state) {
-  return wrapUnique(
+  return std::unique_ptr<V8InspectorSessionImpl>(
       new V8InspectorSessionImpl(inspector, contextGroupId, channel, state));
 }
 
 V8InspectorSessionImpl::V8InspectorSessionImpl(V8InspectorImpl* inspector,
                                                int contextGroupId,
                                                V8Inspector::Channel* channel,
                                                const StringView& savedState)
     : m_contextGroupId(contextGroupId),
       m_inspector(inspector),
       m_channel(channel),
       m_customObjectFormatterEnabled(false),
       m_dispatcher(this),
       m_state(nullptr),
       m_runtimeAgent(nullptr),
       m_debuggerAgent(nullptr),
       m_heapProfilerAgent(nullptr),
       m_profilerAgent(nullptr),
       m_consoleAgent(nullptr),
       m_schemaAgent(nullptr) {
   if (savedState.length()) {
     std::unique_ptr<protocol::Value> state =
-        protocol::parseJSON(toString16(savedState));
+        protocol::StringUtil::parseJSON(toString16(savedState));
     if (state) m_state = protocol::DictionaryValue::cast(std::move(state));
     if (!m_state) m_state = protocol::DictionaryValue::create();
   } else {
     m_state = protocol::DictionaryValue::create();
   }
 
-  m_runtimeAgent = wrapUnique(new V8RuntimeAgentImpl(
+  m_runtimeAgent = std::unique_ptr<V8RuntimeAgentImpl>(new V8RuntimeAgentImpl(

[dgozman, 2016/11/22 18:12:48]

.reset

[kozy, 2016/11/22 18:24:31]

Done.

       this, this, agentState(protocol::Runtime::Metainfo::domainName)));
   protocol::Runtime::Dispatcher::wire(&m_dispatcher, m_runtimeAgent.get());
 
-  m_debuggerAgent = wrapUnique(new V8DebuggerAgentImpl(
-      this, this, agentState(protocol::Debugger::Metainfo::domainName)));
+  m_debuggerAgent =
+      std::unique_ptr<V8DebuggerAgentImpl>(new V8DebuggerAgentImpl(
+          this, this, agentState(protocol::Debugger::Metainfo::domainName)));
   protocol::Debugger::Dispatcher::wire(&m_dispatcher, m_debuggerAgent.get());
 
-  m_profilerAgent = wrapUnique(new V8ProfilerAgentImpl(
-      this, this, agentState(protocol::Profiler::Metainfo::domainName)));
+  m_profilerAgent =
+      std::unique_ptr<V8ProfilerAgentImpl>(new V8ProfilerAgentImpl(
+          this, this, agentState(protocol::Profiler::Metainfo::domainName)));
   protocol::Profiler::Dispatcher::wire(&m_dispatcher, m_profilerAgent.get());
 
-  m_heapProfilerAgent = wrapUnique(new V8HeapProfilerAgentImpl(
-      this, this, agentState(protocol::HeapProfiler::Metainfo::domainName)));
+  m_heapProfilerAgent =
+      std::unique_ptr<V8HeapProfilerAgentImpl>(new V8HeapProfilerAgentImpl(
+          this, this,
+          agentState(protocol::HeapProfiler::Metainfo::domainName)));
   protocol::HeapProfiler::Dispatcher::wire(&m_dispatcher,
                                            m_heapProfilerAgent.get());
 
-  m_consoleAgent = wrapUnique(new V8ConsoleAgentImpl(
+  m_consoleAgent = std::unique_ptr<V8ConsoleAgentImpl>(new V8ConsoleAgentImpl(
       this, this, agentState(protocol::Console::Metainfo::domainName)));
   protocol::Console::Dispatcher::wire(&m_dispatcher, m_consoleAgent.get());
 
-  m_schemaAgent = wrapUnique(new V8SchemaAgentImpl(
+  m_schemaAgent = std::unique_ptr<V8SchemaAgentImpl>(new V8SchemaAgentImpl(
       this, this, agentState(protocol::Schema::Metainfo::domainName)));
   protocol::Schema::Dispatcher::wire(&m_dispatcher, m_schemaAgent.get());
 
   if (savedState.length()) {
     m_runtimeAgent->restore();
     m_debuggerAgent->restore();
     m_heapProfilerAgent->restore();
     m_profilerAgent->restore();
     m_consoleAgent->restore();
   }
@@ skipping 194 matching lines @@
 void V8InspectorSessionImpl::reportAllContexts(V8RuntimeAgentImpl* agent) {
   const V8InspectorImpl::ContextByIdMap* contexts =
       m_inspector->contextGroup(m_contextGroupId);
   if (!contexts) return;
   for (auto& idContext : *contexts)
     agent->reportExecutionContextCreated(idContext.second.get());
 }
 
 void V8InspectorSessionImpl::dispatchProtocolMessage(
     const StringView& message) {
-  m_dispatcher.dispatch(protocol::parseJSON(message));
+  m_dispatcher.dispatch(protocol::StringUtil::parseJSON(message));
 }
 
 std::unique_ptr<StringBuffer> V8InspectorSessionImpl::stateJSON() {
   String16 json = m_state->toJSONString();
   return StringBufferImpl::adopt(json);
 }
 
 std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
 V8InspectorSessionImpl::supportedDomains() {
   std::vector<std::unique_ptr<protocol::Schema::Domain>> domains =
@@ skipping 40 matching lines @@
 V8InspectorSession::Inspectable* V8InspectorSessionImpl::inspectedObject(
     unsigned num) {
   if (num >= m_inspectedObjects.size()) return nullptr;
   return m_inspectedObjects[num].get();
 }
 
 void V8InspectorSessionImpl::schedulePauseOnNextStatement(
     const StringView& breakReason, const StringView& breakDetails) {
   m_debuggerAgent->schedulePauseOnNextStatement(
       toString16(breakReason),
-      protocol::DictionaryValue::cast(protocol::parseJSON(breakDetails)));
+      protocol::DictionaryValue::cast(
+          protocol::StringUtil::parseJSON(breakDetails)));
 }
 
 void V8InspectorSessionImpl::cancelPauseOnNextStatement() {
   m_debuggerAgent->cancelPauseOnNextStatement();
 }
 
 void V8InspectorSessionImpl::breakProgram(const StringView& breakReason,
                                           const StringView& breakDetails) {
   m_debuggerAgent->breakProgram(
       toString16(breakReason),
-      protocol::DictionaryValue::cast(protocol::parseJSON(breakDetails)));
+      protocol::DictionaryValue::cast(
+          protocol::StringUtil::parseJSON(breakDetails)));
 }
 
 void V8InspectorSessionImpl::setSkipAllPauses(bool skip) {
   m_debuggerAgent->setSkipAllPauses(skip);
 }
 
 void V8InspectorSessionImpl::resume() { m_debuggerAgent->resume(); }
 
 void V8InspectorSessionImpl::stepOver() { m_debuggerAgent->stepOver(); }
 
 std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
 V8InspectorSessionImpl::searchInTextByLines(const StringView& text,
                                             const StringView& query,
                                             bool caseSensitive, bool isRegex) {
   // TODO(dgozman): search may operate on StringView and avoid copying |text|.
   std::vector<std::unique_ptr<protocol::Debugger::SearchMatch>> matches =
       searchInTextByLinesImpl(this, toString16(text), toString16(query),
                               caseSensitive, isRegex);
   std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>> result;
   for (size_t i = 0; i < matches.size(); ++i)
     result.push_back(std::move(matches[i]));
   return result;
 }
 
 }  // namespace v8_inspector