HeadlessWebContents:Observer to observe render process exit status

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 14 matching lines @@
 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),
       next_message_id_(0),
+      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),
       dom_debugger_domain_(this),
@@ skipping 26 matching lines @@
 void HeadlessDevToolsClientImpl::AttachToHost(
     content::DevToolsAgentHost* agent_host) {
   DCHECK(!agent_host_);
   agent_host_ = agent_host;
   agent_host_->AttachClient(this);
 }
 
 void HeadlessDevToolsClientImpl::DetachFromHost(
     content::DevToolsAgentHost* agent_host) {
   DCHECK_EQ(agent_host_, agent_host);
-  agent_host_->DetachClient(this);
+  if (!renderer_crashed_)
+    agent_host_->DetachClient(this);
   agent_host_ = nullptr;
   pending_messages_.clear();
 }
 
 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);
@@ skipping 34 matching lines @@
 }
 
 bool HeadlessDevToolsClientImpl::DispatchEvent(
     std::unique_ptr<base::Value> owning_message,
     const base::DictionaryValue& message_dict) {
   std::string method;
   if (!message_dict.GetString("method", &method))
     return false;
   EventHandlerMap::const_iterator it = event_handlers_.find(method);
   if (it == event_handlers_.end()) {
+    // Silently swallow errors related to the target crashing. This can be
+    // observed via HeadlessWebContents::Observer::RenderProcessExited.
+    if (method == "Inspector.targetCrashed") {

[Sami, 2016/11/18 18:37:22]

Shouldn't we still emit this event in Headless Shell / chrome --headless?

Does the C++ notification give us something this event doesn't? I'm wondering
whether we should instead extend this event to do what we need?

[alex clarke (OOO till 29th), 2016/11/21 10:44:01]

Hmm so we do actually have an inspector domain - I hadn't appreciated that. 
Suggests that this bit of code is a mistake.

The C++ API does give us the base::TerminationStatus and platform specific exit
code.  Those might be useful still.

+      renderer_crashed_ = true;
+      return true;
+    }
+
     NOTREACHED() << "Unknown event: " << method;
     return false;
   }
   if (!it->second.is_null()) {
     const base::DictionaryValue* result_dict;
     if (!message_dict.GetDictionary("params", &result_dict)) {
       NOTREACHED() << "Badly formed event parameters";
       return false;
     }
     // DevTools assumes event handling is async so we must post a task here or
@@ skipping 139 matching lines @@
 }
 
 tracing::Domain* HeadlessDevToolsClientImpl::GetTracing() {
   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_++;
   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>
@@ skipping 58 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