DevTools: add support for chunked protocol messages.

TBR=jochen
BUG=423738

Review URL: https://codereview.chromium.org/656033005

Cr-Commit-Position: refs/heads/master@{#299896}

chrome/browser/devtools/devtools_ui_bindings.cc

@@ -66,6 +66,8 @@ static const char kFrontendHostMethod[] = "method";
 static const char kFrontendHostParams[] = "params";
 static const char kTitleFormat[] = "Developer Tools - %s";
 
+const size_t kMaxMessageChunkSize = IPC::Channel::kMaximumMessageSize / 4;
+
 typedef std::vector<DevToolsUIBindings*> DevToolsUIBindingsList;
 base::LazyInstance<DevToolsUIBindingsList>::Leaky g_instances =
     LAZY_INSTANCE_INITIALIZER;
@@ -437,9 +439,20 @@ void DevToolsUIBindings::HandleMessageFromDevToolsFrontendToBackend(
 void DevToolsUIBindings::DispatchProtocolMessage(
     content::DevToolsAgentHost* agent_host, const std::string& message) {
   DCHECK(agent_host == agent_host_.get());
-  base::StringValue message_value(message);
-  CallClientFunction("InspectorFrontendAPI.dispatchMessage",
-                     &message_value, NULL, NULL);
+
+  if (message.length() < kMaxMessageChunkSize) {
+    base::StringValue message_value(message);
+    CallClientFunction("InspectorFrontendAPI.dispatchMessage",
+                       &message_value, NULL, NULL);
+    return;
+  }
+
+  base::FundamentalValue total_size(static_cast<int>(message.length()));
+  for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
+    base::StringValue message_value(message.substr(pos, kMaxMessageChunkSize));
+    CallClientFunction("InspectorFrontendAPI.dispatchMessageChunk",
+                       &message_value, pos ? NULL : &total_size, NULL);
+  }
 }
 
 void DevToolsUIBindings::AgentHostClosed(

content/browser/devtools/embedded_worker_devtools_agent_host.cc

@@ -219,8 +219,12 @@ void EmbeddedWorkerDevToolsAgentHost::WorkerCreated() {
 }
 
 void EmbeddedWorkerDevToolsAgentHost::OnDispatchOnInspectorFrontend(
-    const std::string& message) {
-  SendMessageToClient(message);
+    const std::string& message,
+    uint32 total_size) {
+  if (!IsAttached())
+    return;
+
+  ProcessChunkedMessageFromAgent(message, total_size);
 }
 
 void EmbeddedWorkerDevToolsAgentHost::OnSaveAgentRuntimeState(

content/browser/devtools/embedded_worker_devtools_agent_host.h

@@ -68,7 +68,8 @@ class EmbeddedWorkerDevToolsAgentHost : public IPCDevToolsAgentHost,
   void AttachToWorker();
   void DetachFromWorker();
   void WorkerCreated();
-  void OnDispatchOnInspectorFrontend(const std::string& message);
+  void OnDispatchOnInspectorFrontend(const std::string& message,
+                                     uint32 total_size);
   void OnSaveAgentRuntimeState(const std::string& state);
 
   scoped_ptr<SharedWorkerInstance> shared_worker_;

content/browser/devtools/ipc_devtools_agent_host.cc

@@ -29,6 +29,10 @@ void IPCDevToolsAgentHost::InspectElement(int x, int y) {
                                                          GetId(), x, y));
 }
 
+IPCDevToolsAgentHost::IPCDevToolsAgentHost()
+    : message_buffer_size_(0) {
+}
+
 IPCDevToolsAgentHost::~IPCDevToolsAgentHost() {
 }
 
@@ -38,4 +42,29 @@ void IPCDevToolsAgentHost::Reattach(const std::string& saved_agent_state) {
   OnClientAttached();
 }
 
+void IPCDevToolsAgentHost::ProcessChunkedMessageFromAgent(
+    const std::string& message, uint32 total_size) {
+  if (total_size && total_size == message.length()) {
+    DCHECK(message_buffer_size_ == 0);
+    SendMessageToClient(message);
+    return;
+  }
+
+  if (total_size) {
+    DCHECK(message_buffer_size_ == 0);
+    message_buffer_ = std::string();
+    message_buffer_.reserve(total_size);
+    message_buffer_size_ = total_size;
+  }
+
+  message_buffer_.append(message);
+
+  if (message_buffer_.size() >= message_buffer_size_) {
+    DCHECK(message_buffer_.size() == message_buffer_size_);
+    SendMessageToClient(message_buffer_);
+    message_buffer_ = std::string();
+    message_buffer_size_ = 0;
+  }
+}
+
 }  // namespace content

content/browser/devtools/ipc_devtools_agent_host.h

@@ -22,13 +22,20 @@ class CONTENT_EXPORT IPCDevToolsAgentHost : public DevToolsAgentHostImpl {
   virtual void InspectElement(int x, int y) override;
 
  protected:
+  IPCDevToolsAgentHost();
   virtual ~IPCDevToolsAgentHost();
 
   void Reattach(const std::string& saved_agent_state);
+  void ProcessChunkedMessageFromAgent(const std::string& message,
+                                      uint32 total_size);
 
   virtual void SendMessageToAgent(IPC::Message* msg) = 0;
   virtual void OnClientAttached() = 0;
   virtual void OnClientDetached() = 0;
+
+ private:
+  std::string message_buffer_;
+  uint32 message_buffer_size_;
 };
 
 }  // namespace content

content/browser/devtools/render_view_devtools_agent_host.cc

@@ -124,7 +124,7 @@ RenderViewDevToolsAgentHost::RenderViewDevToolsAgentHost(RenderViewHost* rvh)
   handler_impl_->SetPowerHandler(power_handler_.get());
   SetRenderViewHost(rvh);
   DevToolsProtocol::Notifier notifier(base::Bind(
-      &RenderViewDevToolsAgentHost::OnDispatchOnInspectorFrontend,
+      &RenderViewDevToolsAgentHost::DispatchOnInspectorFrontend,
       base::Unretained(this)));
   handler_impl_->SetNotifier(notifier);
   tracing_handler_->SetNotifier(notifier);
@@ -164,7 +164,7 @@ void RenderViewDevToolsAgentHost::DispatchProtocolMessage(
       overridden_response = handler_impl_->HandleCommand(command);
     if (overridden_response.get()) {
       if (!overridden_response->is_async_promise())
-        OnDispatchOnInspectorFrontend(overridden_response->Serialize());
+        DispatchOnInspectorFrontend(overridden_response->Serialize());
       return;
     }
   }
@@ -494,8 +494,16 @@ void RenderViewDevToolsAgentHost::OnSaveAgentRuntimeState(
 }
 
 void RenderViewDevToolsAgentHost::OnDispatchOnInspectorFrontend(
+    const std::string& message,
+    uint32 total_size) {
+  if (!IsAttached() || !render_view_host_)
+    return;
+  ProcessChunkedMessageFromAgent(message, total_size);
+}
+
+void RenderViewDevToolsAgentHost::DispatchOnInspectorFrontend(
     const std::string& message) {
-  if (!render_view_host_)
+  if (!IsAttached() || !render_view_host_)
     return;
   SendMessageToClient(message);
 }

content/browser/devtools/render_view_devtools_agent_host.h

@@ -102,7 +102,9 @@ class CONTENT_EXPORT RenderViewDevToolsAgentHost
   void OnSwapCompositorFrame(const IPC::Message& message);
   bool OnSetTouchEventEmulationEnabled(const IPC::Message& message);
 
-  void OnDispatchOnInspectorFrontend(const std::string& message);
+  void OnDispatchOnInspectorFrontend(const std::string& message,
+                                     uint32 total_size);
+  void DispatchOnInspectorFrontend(const std::string& message);
   void OnSaveAgentRuntimeState(const std::string& state);
 
   void ClientDetachedFromRenderer();

content/child/shared_worker_devtools_agent.cc

@@ -6,6 +6,7 @@
 
 #include "content/child/child_thread.h"
 #include "content/common/devtools_messages.h"
+#include "ipc/ipc_channel.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebSharedWorker.h"
@@ -15,6 +16,9 @@ using blink::WebString;
 
 namespace content {
 
+static const size_t kMaxMessageChunkSize =
+    IPC::Channel::kMaximumMessageSize / 4;
+
 SharedWorkerDevToolsAgent::SharedWorkerDevToolsAgent(
     int route_id,
     WebSharedWorker* webworker)
@@ -43,9 +47,19 @@ bool SharedWorkerDevToolsAgent::OnMessageReceived(const IPC::Message& message) {
 
 void SharedWorkerDevToolsAgent::SendDevToolsMessage(
     const blink::WebString& message) {
+  std::string msg(message.utf8());
+  if (message.length() < kMaxMessageChunkSize) {
+    Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
+        route_id_, msg, msg.size()));
+    return;
+  }
+
+  for (size_t pos = 0; pos < msg.length(); pos += kMaxMessageChunkSize) {
     Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
         route_id_,
-        message.utf8()));
+        msg.substr(pos, kMaxMessageChunkSize),
+        pos ? 0 : msg.size()));
+  }
 }
 
 void SharedWorkerDevToolsAgent::SaveDevToolsAgentState(

content/common/devtools_messages.h

@@ -55,8 +55,13 @@
 // These are messages sent from DevToolsAgent to DevToolsClient through the
 // browser.
 // WebKit-level transport.
-IPC_MESSAGE_ROUTED1(DevToolsClientMsg_DispatchOnInspectorFrontend,
-                    std::string /* message */)
+
+// Sends response from the agent to the client. Supports chunked encoding.
+// First (the only) chunk arrives with the |total_size| != 0,
+// remaining chunks arrive with |total_size| == 0.
+IPC_MESSAGE_ROUTED2(DevToolsClientMsg_DispatchOnInspectorFrontend,
+                    std::string /* message */,
+                    uint32 /* total_size */)
 
 //-----------------------------------------------------------------------------
 // These are messages sent from DevToolsClient to DevToolsAgent through the

content/renderer/devtools/devtools_agent.cc

@@ -52,6 +52,8 @@ base::subtle::AtomicWord DevToolsAgent::event_callback_;
 
 namespace {
 
+const size_t kMaxMessageChunkSize = IPC::Channel::kMaximumMessageSize / 4;
+
 class WebKitClientMessageLoopImpl
     : public WebDevToolsAgentClient::WebKitClientMessageLoop {
  public:
@@ -116,8 +118,19 @@ bool DevToolsAgent::OnMessageReceived(const IPC::Message& message) {
 
 void DevToolsAgent::sendMessageToInspectorFrontend(
     const blink::WebString& message) {
-  Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(routing_id(),
-                                                         message.utf8()));
+  std::string msg(message.utf8());
+  if (msg.length() < kMaxMessageChunkSize) {
+    Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
+        routing_id(), msg, msg.size()));
+    return;
+  }
+
+  for (size_t pos = 0; pos < msg.length(); pos += kMaxMessageChunkSize) {
+    Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
+        routing_id(),
+        msg.substr(pos, kMaxMessageChunkSize),
+        pos ? 0 : msg.size()));
+  }
 }
 
 long DevToolsAgent::processId() {

content/renderer/devtools/devtools_client.h

@@ -41,7 +41,8 @@ class CONTENT_EXPORT DevToolsClient
 
   virtual bool isUnderTest() override;
 
-  void OnDispatchOnInspectorFrontend(const std::string& message);
+  void OnDispatchOnInspectorFrontend(const std::string& message,
+                                     uint32 total_size);
 
   scoped_ptr<blink::WebDevToolsFrontend> web_tools_frontend_;
 

content/renderer/service_worker/embedded_worker_context_client.cc

@@ -36,6 +36,8 @@ namespace content {
 
 namespace {
 
+const size_t kMaxMessageChunkSize = IPC::Channel::kMaximumMessageSize / 4;
+
 // For now client must be a per-thread instance.
 // TODO(kinuko): This needs to be refactored when we start using thread pool
 // or having multiple clients per one thread.
@@ -243,8 +245,20 @@ void EmbeddedWorkerContextClient::reportConsoleMessage(
 
 void EmbeddedWorkerContextClient::dispatchDevToolsMessage(
     const blink::WebString& message) {
-  sender_->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
-      worker_devtools_agent_route_id_, message.utf8()));
+  std::string msg(message.utf8());
+
+  if (msg.length() < kMaxMessageChunkSize) {
+    sender_->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
+        worker_devtools_agent_route_id_, msg, msg.size()));
+    return;
+  }
+
+  for (size_t pos = 0; pos < msg.length(); pos += kMaxMessageChunkSize) {
+    sender_->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
+        worker_devtools_agent_route_id_,
+        msg.substr(pos, kMaxMessageChunkSize),
+        pos ? 0 : msg.size()));
+  }
 }
 
 void EmbeddedWorkerContextClient::saveDevToolsAgentState(