DevTools: update backend state along with the command acks (Chromium side).

BUG=445587

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

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

2 files changed, 64 insertions, 38 deletions

diff --git a/content/renderer/devtools/devtools_agent.cc b/content/renderer/devtools/devtools_agent.cc
index c84cecd..780001c 100644
--- a/content/renderer/devtools/devtools_agent.cc
+++ b/content/renderer/devtools/devtools_agent.cc
@@ -118,21 +118,12 @@ bool DevToolsAgent::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
-void DevToolsAgent::sendMessageToInspectorFrontend(
-    const blink::WebString& message) {
-  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()));
-  }
+void DevToolsAgent::sendProtocolMessage(
+    int call_id,
+    const blink::WebString& message,
+    const blink::WebString& state_cookie) {
+  SendChunkedProtocolMessage(
+      this, routing_id(), call_id, message.utf8(), state_cookie.utf8());
 }
 
 long DevToolsAgent::processId() {
@@ -143,11 +134,6 @@ int DevToolsAgent::debuggerId() {
   return routing_id();
 }
 
-void DevToolsAgent::saveAgentRuntimeState(
-    const blink::WebString& state) {
-  Send(new DevToolsHostMsg_SaveAgentRuntimeState(routing_id(), state.utf8()));
-}
-
 blink::WebDevToolsAgentClient::WebKitClientMessageLoop*
     DevToolsAgent::createClientMessageLoop() {
   return new WebKitClientMessageLoopImpl();
@@ -275,6 +261,39 @@ DevToolsAgent* DevToolsAgent::FromRoutingId(int routing_id) {
   return NULL;
 }
 
+// static
+void DevToolsAgent::SendChunkedProtocolMessage(
+    IPC::Sender* sender,
+    int routing_id,
+    int call_id,
+    const std::string& message,
+    const std::string& post_state) {
+  DevToolsMessageChunk chunk;
+  chunk.message_size = message.size();
+  chunk.is_first = true;
+
+  if (message.length() < kMaxMessageChunkSize) {
+    chunk.data = message;
+    chunk.call_id = call_id;
+    chunk.post_state = post_state;
+    chunk.is_last = true;
+    sender->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
+                     routing_id, chunk));
+    return;
+  }
+
+  for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
+    chunk.is_last = pos + kMaxMessageChunkSize >= message.length();
+    chunk.call_id = chunk.is_last ? call_id : 0;
+    chunk.post_state = chunk.is_last ? post_state : std::string();
+    chunk.data = message.substr(pos, kMaxMessageChunkSize);
+    sender->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
+                     routing_id, chunk));
+    chunk.is_first = false;
+    chunk.message_size = 0;
+  }
+}
+
 void DevToolsAgent::OnAttach(const std::string& host_id) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
diff --git a/content/renderer/devtools/devtools_agent.h b/content/renderer/devtools/devtools_agent.h
index 8a8d998..5140a43 100644
--- a/content/renderer/devtools/devtools_agent.h
+++ b/content/renderer/devtools/devtools_agent.h
@@ -40,6 +40,13 @@ class DevToolsAgent : public RenderFrameObserver,
   // Returns agent instance for its routing id.
   static DevToolsAgent* FromRoutingId(int routing_id);
 
+  static void SendChunkedProtocolMessage(
+      IPC::Sender* sender,
+      int routing_id,
+      int call_id,
+      const std::string& message,
+      const std::string& post_state);
+
   blink::WebDevToolsAgent* GetWebAgent();
 
   bool IsAttached();
@@ -49,32 +56,32 @@ class DevToolsAgent : public RenderFrameObserver,
   bool OnMessageReceived(const IPC::Message& message) override;
 
   // WebDevToolsAgentClient implementation
-  virtual void sendMessageToInspectorFrontend(const blink::WebString& data);
-
-  virtual long processId() override;
-  virtual int debuggerId() override;
-  virtual void saveAgentRuntimeState(const blink::WebString& state) override;
-  virtual blink::WebDevToolsAgentClient::WebKitClientMessageLoop*
+  void sendProtocolMessage(int call_id,
+                           const blink::WebString& response,
+                           const blink::WebString& state) override;
+  long processId() override;
+  int debuggerId() override;
+  blink::WebDevToolsAgentClient::WebKitClientMessageLoop*
       createClientMessageLoop() override;
-  virtual void willEnterDebugLoop() override;
-  virtual void didExitDebugLoop() override;
+  void willEnterDebugLoop() override;
+  void didExitDebugLoop() override;
 
   typedef void (*TraceEventCallback)(
       char phase, const unsigned char*, const char* name, unsigned long long id,
       int numArgs, const char* const* argNames, const unsigned char* argTypes,
       const unsigned long long* argValues,
       unsigned char flags, double timestamp);
-  virtual void resetTraceEventCallback() override;
-  virtual void setTraceEventCallback(const blink::WebString& category_filter,
-                                     TraceEventCallback cb) override;
-  virtual void enableTracing(const blink::WebString& category_filter) override;
-  virtual void disableTracing() override;
-  virtual void startGPUEventsRecording() override;
-  virtual void stopGPUEventsRecording() override;
-
-  virtual void enableDeviceEmulation(
+  void resetTraceEventCallback() override;
+  void setTraceEventCallback(const blink::WebString& category_filter,
+                             TraceEventCallback cb) override;
+  void enableTracing(const blink::WebString& category_filter) override;
+  void disableTracing() override;
+  void startGPUEventsRecording() override;
+  void stopGPUEventsRecording() override;
+
+  void enableDeviceEmulation(
       const blink::WebDeviceEmulationParams& params) override;
-  virtual void disableDeviceEmulation() override;
+  void disableDeviceEmulation() override;
 
   void OnAttach(const std::string& host_id);
   void OnReattach(const std::string& host_id,