Detect debugging target crash.

content/browser/devtools/devtools_protocol.cc

 // Copyright (c) 2013 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 "content/browser/devtools/devtools_protocol.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 
 namespace content {
@@ skipping 91 matching lines @@
       params_(params) {
 }
 
 DevToolsProtocol::Notification::~Notification() {
 }
 
 std::string DevToolsProtocol::Notification::Serialize() {
   DictionaryValue response;
 
   base::DictionaryValue notification;
-  notification.SetString("method", method_);
+  notification.SetString(kMethodParam, method_);
   if (params_.get())
-    notification.Set("params", params_->DeepCopy());
+    notification.Set(kParamsParam, params_->DeepCopy());
 
   std::string json_notification;
   base::JSONWriter::Write(&notification, &json_notification);
   return json_notification;
 }
 
+DevToolsProtocol::Event::~Event() {
+}
+
+std::string DevToolsProtocol::Event::Serialize() {
+  DictionaryValue dictionary;
+
+  dictionary.SetString(kMethodParam, method_);
+  if (params_)
+    dictionary.Set(kParamsParam, params_->DeepCopy());
+
+  std::string result;
+  base::JSONWriter::Write(&dictionary, &result);
+  return result;
+}
+
+DevToolsProtocol::Event::Event(const std::string& method,
+                               DictionaryValue* params)
+    : method_(method),
+      params_(params) {
+}
+
 DevToolsProtocol::Handler::~Handler() {
 }
 
 scoped_ptr<DevToolsProtocol::Response>
 DevToolsProtocol::Handler::HandleCommand(
     DevToolsProtocol::Command* command) {
   CommandHandlers::iterator it = command_handlers_.find(command->method());
   if (it == command_handlers_.end())
     return scoped_ptr<DevToolsProtocol::Response>();
   return (it->second).Run(command);
@@ skipping 35 matching lines @@
     *error_response = response.Serialize();
     return NULL;
   }
 
   base::DictionaryValue* command_dict = NULL;
   command->GetAsDictionary(&command_dict);
 
   int id;
   std::string method;
   bool ok = true;
-  ok &= command_dict->GetInteger("id", &id);
+  ok &= command_dict->GetInteger(kIdParam, &id);
   ok &= id >= 0;
-  ok &= command_dict->GetString("method", &method);
+  ok &= command_dict->GetString(kMethodParam, &method);
   if (!ok) {
     Response response(kNoId, kErrorInvalidRequest, "Invalid request");
     *error_response = response.Serialize();
     return NULL;
   }
 
   size_t pos = method.find(".");
   if (pos == std::string::npos || pos == 0) {
     Response response(id, kErrorNoSuchMethod, "No such method");
     *error_response = response.Serialize();
     return NULL;
   }
 
   std::string domain = method.substr(0, pos);
 
   base::DictionaryValue* params = NULL;
-  command_dict->GetDictionary("params", &params);
+  command_dict->GetDictionary(kParamsParam, &params);
   return new Command(id, domain, method, params ? params->DeepCopy() : NULL);
 }
 
+//static
+DevToolsProtocol::Event* DevToolsProtocol::CreateEvent(

[pfeldman, 2013/03/21 06:30:08]

Make sure order of implementation matches order of declaration.

[Vladislav Kaznacheev, 2013/03/21 07:24:02]

I believe it does.
On 2013/03/21 06:30:08, pfeldman wrote:

+    const std::string& method,
+    base::DictionaryValue* params) {
+  return new Event(method, params);
+}
+
 }  // namespace content