Roll third_party/inspector_protocol to 4ad35c45aca9834b67ec2cb152c816ea1b7ceb48

third_party/WebKit/Source/core/inspector/InspectorSession.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 "core/inspector/InspectorSession.h"
 
 #include "bindings/core/v8/ScriptController.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorBaseAgent.h"
@@ skipping 73 matching lines @@
     m_inspectorBackendDispatcher->dispatch(
         protocol::StringUtil::parseJSON(message));
   }
 }
 
 void InspectorSession::didCommitLoadForLocalFrame(LocalFrame* frame) {
   for (size_t i = 0; i < m_agents.size(); i++)
     m_agents[i]->didCommitLoadForLocalFrame(frame);
 }
 
+void InspectorSession::sendProtocolResponse(
+    int callId,
+    std::unique_ptr<protocol::Serializable> message) {
+  sendProtocolResponse(callId, message->serializeValue()->toJSONString());
+}
+
+void InspectorSession::sendProtocolResponse(
+    int callId,
+    const v8_inspector::StringView& message) {
+  // We can potentially avoid copies if WebString would convert to utf8 right
+  // from StringView, but it uses StringImpl itself, so we don't create any
+  // extra copies here.
+  sendProtocolResponse(callId, toCoreString(message));
+}
+
 void InspectorSession::sendProtocolResponse(int callId, const String& message) {
   if (m_disposed)
     return;
   flushProtocolNotifications();
   m_state->setString(kV8StateKey, toCoreString(m_v8Session->stateJSON()));
   String stateToSend = m_state->toJSONString();
   if (stateToSend == m_lastSentState)
     stateToSend = String();
   else
     m_lastSentState = stateToSend;
   m_client->sendProtocolMessage(m_sessionId, callId, message, stateToSend);
 }
 
-void InspectorSession::sendProtocolResponse(
-    int callId,
-    const v8_inspector::StringView& message) {
-  // We can potentially avoid copies if WebString would convert to utf8 right
-  // from StringView, but it uses StringImpl itself, so we don't create any
-  // extra copies here.
-  sendProtocolResponse(callId, toCoreString(message));
-}
+class InspectorSession::Notification {
+ public:
+  static std::unique_ptr<Notification> createForBlink(
+      std::unique_ptr<protocol::Serializable> notification) {
+    return std::unique_ptr<Notification>(
+        new Notification(std::move(notification)));
+  }
 
-void InspectorSession::sendProtocolNotification(const String& message) {
+  static std::unique_ptr<Notification> createForV8(
+      const v8_inspector::StringView& notification) {
+    return std::unique_ptr<Notification>(new Notification(notification));
+  }
+
+  String string() {
+    if (m_notification)
+      return m_notification->serializeValue()->toJSONString();

[dgozman, 2016/11/21 22:29:16]

Let's clear m_notification here to not store extra data?

[kozy, 2016/11/22 01:25:38]

Done.

+    return m_rawNotification;
+  }
+
+ private:
+  explicit Notification(std::unique_ptr<protocol::Serializable> notification)
+      : m_notification(std::move(notification)) {}
+
+  explicit Notification(const v8_inspector::StringView& notification)
+      : m_rawNotification(toCoreString(notification)) {}
+
+  std::unique_ptr<protocol::Serializable> m_notification;
+  String m_rawNotification;
+};
+
+void InspectorSession::sendProtocolNotification(
+    std::unique_ptr<protocol::Serializable> notification) {
   if (m_disposed)
     return;
-  m_notificationQueue.append(message);
+  m_notificationQueue.append(
+      Notification::createForBlink(std::move(notification)));
 }
 
 void InspectorSession::sendProtocolNotification(
-    const v8_inspector::StringView& message) {
-  sendProtocolNotification(toCoreString(message));
+    const v8_inspector::StringView& notification) {
+  if (m_disposed)
+    return;
+  m_notificationQueue.append(Notification::createForV8(notification));
 }
 
 void InspectorSession::flushProtocolNotifications() {
   if (m_disposed)
     return;
   for (size_t i = 0; i < m_agents.size(); i++)
     m_agents[i]->flushPendingProtocolNotifications();
-  for (size_t i = 0; i < m_notificationQueue.size(); ++i)
-    m_client->sendProtocolMessage(m_sessionId, 0, m_notificationQueue[i],
-                                  String());
+  for (size_t i = 0; i < m_notificationQueue.size(); ++i) {
+    m_client->sendProtocolMessage(m_sessionId, 0,
+                                  m_notificationQueue[i]->string(), String());
+  }
   m_notificationQueue.clear();
 }
 
 DEFINE_TRACE(InspectorSession) {
   visitor->trace(m_instrumentingAgents);
   visitor->trace(m_agents);
 }
 
 }  // namespace blink