In chromedriver, add /log handler

chrome/test/webdriver/dispatch.cc

 // Copyright (c) 2011 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 "chrome/test/webdriver/dispatch.h"
 
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "base/format_macros.h"
+#include "base/json/json_reader.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "chrome/test/webdriver/http_response.h"
 #include "chrome/test/webdriver/commands/command.h"
 #include "chrome/test/webdriver/session_manager.h"
 #include "chrome/test/webdriver/utility_functions.h"
+#include "chrome/test/webdriver/webdriver_logging.h"
 
 namespace webdriver {
 
 namespace {
 
+// Maximum safe size of HTTP response message. Any larger than this,
+// the message may not be transferred at all.
+const size_t kMaxHttpMessageSize = 1024 * 1024 * 16;  // 16MB
+
 bool ForbidsMessageBody(const std::string& request_method,
                         const HttpResponse& response) {
   return request_method == "HEAD" ||
          response.status() == HttpResponse::kNoContent ||
          response.status() == HttpResponse::kNotModified ||
          (response.status() >= 100 && response.status() < 200);
 }
 
 void DispatchCommand(Command* const command,
                      const std::string& method,
@@ skipping 14 matching lines @@
 
 void Shutdown(struct mg_connection* connection,
               const struct mg_request_info* request_info,
               void* user_data) {
   base::WaitableEvent* shutdown_event =
       reinterpret_cast<base::WaitableEvent*>(user_data);
   mg_printf(connection, "HTTP/1.1 200 OK\r\n\r\n");
   shutdown_event->Signal();
 }
 
-void SendStatus(struct mg_connection* connection,
-                const struct mg_request_info* request_info,
-                void* user_data) {
-  std::string response = "HTTP/1.1 200 OK\r\n"
-                         "Content-Length:2\r\n\r\n"
-                         "ok";
+void SendOkWithBody(struct mg_connection* connection,
+                    const std::string& content) {
+  const char* response_fmt = "HTTP/1.1 200 OK\r\n"
+                             "Content-Length:%d\r\n\r\n"
+                             "%s";
+  std::string response = base::StringPrintf(
+      response_fmt, content.length(), content.c_str());
   mg_write(connection, response.data(), response.length());
 }
 
+void SendHealthz(struct mg_connection* connection,
+                 const struct mg_request_info* request_info,
+                 void* user_data) {
+  SendOkWithBody(connection, "ok");
+}
+
+void SendLog(struct mg_connection* connection,
+             const struct mg_request_info* request_info,
+             void* user_data) {
+  std::string content, log;
+  if (GetLogContents(&log)) {
+    content = "START ChromeDriver log";
+    const size_t kMaxSizeWithoutHeaders = kMaxHttpMessageSize - 10000;
+    if (log.size() > kMaxSizeWithoutHeaders) {
+      log = log.substr(log.size() - kMaxSizeWithoutHeaders);
+      content += " (only last several MB)";
+    }
+    content += ":\n" + log + "END ChromeDriver log";
+  } else {
+    content = "No ChromeDriver log found";
+  }
+  SendOkWithBody(connection, content);
+}
+
 void SendNoContentResponse(struct mg_connection* connection,
                            const struct mg_request_info* request_info,
                            void* user_data) {
   std::string response = "HTTP/1.1 204 No Content\r\n"
                          "Content-Length:0\r\n"
                          "\r\n";
   mg_write(connection, response.data(), response.length());
 }
 
 void SendForbidden(struct mg_connection* connection,
@@ skipping 11 matching lines @@
       "{\"status\":%d,\"value\":{\"message\":"
       "\"Command has not been implemented yet: %s %s\"}}",
       kUnknownCommand, request_info->request_method, request_info->uri);
 
   std::string header = base::StringPrintf(
       "HTTP/1.1 501 Not Implemented\r\n"
       "Content-Type:application/json\r\n"
       "Content-Length:%" PRIuS "\r\n"
       "\r\n", body.length());
 
-  LOG(ERROR) << header << body;
   mg_write(connection, header.data(), header.length());
   mg_write(connection, body.data(), body.length());
 }
 
 }  // namespace
 
 namespace internal {
 
 void PrepareHttpResponse(const Response& command_response,
                          HttpResponse* const http_response) {
@@ skipping 105 matching lines @@
   else if (*method == "PUT")
     *method = "POST";
 
   std::string uri(request_info->uri);
   SessionManager* manager = SessionManager::GetInstance();
   uri = uri.substr(manager->url_base().length());
 
   base::SplitString(uri, '/', path_segments);
 
   if (*method == "POST" && request_info->post_data_len > 0) {
-    VLOG(1) << "...parsing request body";
     std::string json(request_info->post_data, request_info->post_data_len);
-    std::string error;
-    if (!ParseJSONDictionary(json, parameters, &error)) {
+    std::string error_msg;
+    scoped_ptr<Value> params(base::JSONReader::ReadAndReturnError(
+        json, true, NULL, &error_msg));
+    if (!params.get()) {
       response->SetError(new Error(
           kBadRequest,
-          "Failed to parse command data: " + error + "\n  Data: " + json));
+          "Failed to parse command data: " + error_msg + "\n  Data: " + json));
       return false;
     }
-  }
-  VLOG(1) << "Parsed " << method << " " << uri
-        << std::string(request_info->post_data, request_info->post_data_len);
+    if (!params->IsType(Value::TYPE_DICTIONARY)) {
+      response->SetError(new Error(
+          kBadRequest,
+          "Data passed in URL must be a dictionary. Data: " + json));
+      return false;
+    }
+    *parameters = static_cast<DictionaryValue*>(params.release());
+  }
   return true;
 }
 
 void DispatchHelper(Command* command_ptr,
                     const std::string& method,
                     Response* response) {
   CHECK(method == "GET" || method == "POST" || method == "DELETE");
   scoped_ptr<Command> command(command_ptr);
 
   if ((method == "GET" && !command->DoesGet()) ||
@@ skipping 26 matching lines @@
 }
 
 Dispatcher::~Dispatcher() {}
 
 void Dispatcher::AddShutdown(const std::string& pattern,
                              base::WaitableEvent* shutdown_event) {
   mg_set_uri_callback(context_, (root_ + pattern).c_str(), &Shutdown,
                       shutdown_event);
 }
 
-void Dispatcher::AddStatus(const std::string& pattern) {
-  mg_set_uri_callback(context_, (root_ + pattern).c_str(), &SendStatus, NULL);
+void Dispatcher::AddHealthz(const std::string& pattern) {
+  mg_set_uri_callback(context_, (root_ + pattern).c_str(), &SendHealthz, NULL);
+}
+
+void Dispatcher::AddLog(const std::string& pattern) {
+  mg_set_uri_callback(context_, (root_ + pattern).c_str(), &SendLog, NULL);
 }
 
 void Dispatcher::SetNotImplemented(const std::string& pattern) {
   mg_set_uri_callback(context_, (root_ + pattern).c_str(),
                       &SendNotImplementedError, NULL);
 }
 
 void Dispatcher::ForbidAllOtherRequests() {
   mg_set_uri_callback(context_, "*", &SendForbidden, NULL);
 }
 
 }  // namespace webdriver