Roll third_party/inspector_protocol to 4ad35c45aca9834b67ec2cb152c816ea1b7ceb48

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 108 matching lines @@
   protocol::DictionaryValue* state = m_state->getObject(name);
   if (!state) {
     std::unique_ptr<protocol::DictionaryValue> newState =
         protocol::DictionaryValue::create();
     state = newState.get();
     m_state->setObject(name, std::move(newState));
   }
   return state;
 }
 
-void V8InspectorSessionImpl::sendProtocolResponse(int callId,
-                                                  const String16& message) {
-  m_channel->sendProtocolResponse(callId, toStringView(message));
+namespace {
+
+class MessageBuffer : public StringBuffer {
+ public:
+  static std::unique_ptr<MessageBuffer> create(
+      std::unique_ptr<protocol::Serializable> message) {
+    return std::unique_ptr<MessageBuffer>(
+        new MessageBuffer(std::move(message)));
+  }
+
+  const StringView& string() override {
+    if (!m_serialized) {
+      m_serialized = StringBuffer::create(toStringView(m_message->serialize()));
+      m_message.reset(nullptr);
+    }
+    return m_serialized->string();
+  }
+
+ private:
+  explicit MessageBuffer(std::unique_ptr<protocol::Serializable> message)
+      : m_message(std::move(message)) {}
+
+  std::unique_ptr<protocol::Serializable> m_message;
+  std::unique_ptr<StringBuffer> m_serialized;
+};
+
+}  // namespace
+
+void V8InspectorSessionImpl::sendProtocolResponse(
+    int callId, std::unique_ptr<protocol::Serializable> message) {
+  m_channel->sendResponse(callId, MessageBuffer::create(std::move(message)));
 }
 
-void V8InspectorSessionImpl::sendProtocolNotification(const String16& message) {
-  m_channel->sendProtocolNotification(toStringView(message));
+void V8InspectorSessionImpl::sendProtocolNotification(
+    std::unique_ptr<protocol::Serializable> message) {
+  m_channel->sendNotification(MessageBuffer::create(std::move(message)));
 }
 
 void V8InspectorSessionImpl::flushProtocolNotifications() {
   m_channel->flushProtocolNotifications();
 }
 
 void V8InspectorSessionImpl::reset() {
   m_debuggerAgent->reset();
   m_runtimeAgent->reset();
   discardInjectedScripts();
@@ skipping 156 matching lines @@
   for (auto& idContext : *contexts)
     agent->reportExecutionContextCreated(idContext.second.get());
 }
 
 void V8InspectorSessionImpl::dispatchProtocolMessage(
     const StringView& message) {
   m_dispatcher.dispatch(protocol::StringUtil::parseJSON(message));
 }
 
 std::unique_ptr<StringBuffer> V8InspectorSessionImpl::stateJSON() {
-  String16 json = m_state->toJSONString();
+  String16 json = m_state->serialize();
   return StringBufferImpl::adopt(json);
 }
 
 std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
 V8InspectorSessionImpl::supportedDomains() {
   std::vector<std::unique_ptr<protocol::Schema::Domain>> domains =
       supportedDomainsImpl();
   std::vector<std::unique_ptr<protocol::Schema::API::Domain>> result;
   for (size_t i = 0; i < domains.size(); ++i)
     result.push_back(std::move(domains[i]));
@@ skipping 75 matching lines @@
   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