Headless: Support sending and receiving of raw protocol messages

headless/lib/browser/headless_devtools_client_impl.cc

 // 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 "headless/lib/browser/headless_devtools_client_impl.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
@@ skipping 13 matching lines @@
 // static
 HeadlessDevToolsClientImpl* HeadlessDevToolsClientImpl::From(
     HeadlessDevToolsClient* client) {
   // This downcast is safe because there is only one implementation of
   // HeadlessDevToolsClient.
   return static_cast<HeadlessDevToolsClientImpl*>(client);
 }
 
 HeadlessDevToolsClientImpl::HeadlessDevToolsClientImpl()
     : agent_host_(nullptr),
+      raw_protocol_listener_(nullptr),
       next_message_id_(0),
+      next_raw_message_id_(1),
       renderer_crashed_(false),
       accessibility_domain_(this),
       animation_domain_(this),
       application_cache_domain_(this),
       cache_storage_domain_(this),
       console_domain_(this),
       css_domain_(this),
       database_domain_(this),
       debugger_domain_(this),
       device_orientation_domain_(this),
@@ skipping 43 matching lines @@
 
 void HeadlessDevToolsClientImpl::DetachFromHost(
     content::DevToolsAgentHost* agent_host) {
   DCHECK_EQ(agent_host_, agent_host);
   if (!renderer_crashed_)
     agent_host_->DetachClient(this);
   agent_host_ = nullptr;
   pending_messages_.clear();
 }
 
+void HeadlessDevToolsClientImpl::SetRawProtocolListener(
+    RawProtocolListener* raw_protocol_listener) {
+  raw_protocol_listener_ = raw_protocol_listener;
+}
+
+int HeadlessDevToolsClientImpl::GetNextRawDevToolsMessageId() {
+  int id = next_raw_message_id_;
+  next_raw_message_id_ += 2;
+  return id;
+}
+
+void HeadlessDevToolsClientImpl::SendRawDevToolsMessage(
+    const std::string& json_message) {
+#ifndef NDEBUG
+  std::unique_ptr<base::Value> message =
+      base::JSONReader::Read(json_message, base::JSON_PARSE_RFC);
+  const base::DictionaryValue* message_dict;
+  int id = 0;
+  if (!message || !message->GetAsDictionary(&message_dict) ||
+      !message_dict->GetInteger("id", &id)) {
+    NOTREACHED() << "Badly formed message";
+    return;
+  }
+  DCHECK_EQ((id % 2), 1) << "Raw devtools messages must have an odd ID.";
+#endif
+
+  agent_host_->DispatchProtocolMessage(this, json_message);
+}
+
+void HeadlessDevToolsClientImpl::SendRawDevToolsMessage(
+    const base::DictionaryValue& message) {
+  std::string json_message;
+  base::JSONWriter::Write(message, &json_message);
+  SendRawDevToolsMessage(json_message);
+}
+
 void HeadlessDevToolsClientImpl::DispatchProtocolMessage(
     content::DevToolsAgentHost* agent_host,
     const std::string& json_message) {
   DCHECK_EQ(agent_host_, agent_host);
+
   std::unique_ptr<base::Value> message =
       base::JSONReader::Read(json_message, base::JSON_PARSE_RFC);
   const base::DictionaryValue* message_dict;
   if (!message || !message->GetAsDictionary(&message_dict)) {
     NOTREACHED() << "Badly formed reply";
     return;
   }
+
+  if (raw_protocol_listener_ &&
+      raw_protocol_listener_->OnProtocolMessage(agent_host->GetId(),
+                                                json_message, *message_dict)) {
+    return;
+  }
+
   if (!DispatchMessageReply(*message_dict) &&
       !DispatchEvent(std::move(message), *message_dict)) {
     DLOG(ERROR) << "Unhandled protocol message: " << json_message;
   }
 }
 
 bool HeadlessDevToolsClientImpl::DispatchMessageReply(
     const base::DictionaryValue& message_dict) {
   int id = 0;
   if (!message_dict.GetInteger("id", &id))
@@ skipping 188 matching lines @@
   return &tracing_domain_;
 }
 
 template <typename CallbackType>
 void HeadlessDevToolsClientImpl::FinalizeAndSendMessage(
     base::DictionaryValue* message,
     CallbackType callback) {
   if (renderer_crashed_)
     return;
   DCHECK(agent_host_);
-  int id = next_message_id_++;
+  int id = next_message_id_;
+  next_message_id_ += 2;  // We only send even numbered messages.
   message->SetInteger("id", id);
   std::string json_message;
   base::JSONWriter::Write(*message, &json_message);
   pending_messages_[id] = Callback(callback);
   agent_host_->DispatchProtocolMessage(this, json_message);
 }
 
 template <typename CallbackType>
 void HeadlessDevToolsClientImpl::SendMessageWithParams(
     const char* method,
@@ skipping 36 matching lines @@
 HeadlessDevToolsClientImpl::Callback::Callback(
     base::Callback<void(const base::Value&)> callback)
     : callback_with_result(callback) {}
 
 HeadlessDevToolsClientImpl::Callback::~Callback() {}
 
 HeadlessDevToolsClientImpl::Callback& HeadlessDevToolsClientImpl::Callback::
 operator=(Callback&& other) = default;
 
 }  // namespace headless