In chromedriver, add /log url

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"

[Huyen, 2011/06/08 19:55:52]

Oh, did you forget to add webdriver_logging to this change?

 
 namespace webdriver {
 
 namespace {
 
 bool ForbidsMessageBody(const std::string& request_method,
                         const HttpResponse& response) {
   return request_method == "HEAD" ||
          response.status() == HttpResponse::kNoContent ||
          response.status() == HttpResponse::kNotModified ||
@@ skipping 19 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) {

[Huyen, 2011/06/08 19:17:54]

line up indentation of parameters.

[kkania, 2011/06/08 21:10:49]

Done.

+  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,

[Huyen, 2011/06/08 19:17:54]

line up indentation of parameters.

[kkania, 2011/06/08 21:10:49]

Done.

+                void* user_data) {
+  SendOkWithBody(connection, "ok");
+}
+
+void SendLog(struct mg_connection* connection,
+                const struct mg_request_info* request_info,

[Huyen, 2011/06/08 19:17:54]

line up indentation of parameters.

[kkania, 2011/06/08 21:10:49]

Done.

+                void* user_data) {
+  std::string content, log;
+  if (GetLogContents(&log)) {

[Huyen, 2011/06/08 19:17:54]

Does GetLogContents() get all the previous logs? Is there a limit on the size of
the body of the HTTP respond?

[kkania, 2011/06/08 21:10:49]

If I send a message over ~32MB, it fails quickly. Not sure exactly why, probably
because of mongoose. Added cap at 16MB.

+    // KIWI Another \n before END?

[Huyen, 2011/06/08 19:17:54]

Remove KIWI?

[kkania, 2011/06/08 21:10:49]

Done.

+    content = "START ChromeDriver log:\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 137 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;
     }
+    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());
   }
-  VLOG(1) << "Parsed " << method << " " << uri
-        << std::string(request_info->post_data, request_info->post_data_len);
   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