SSL in EmbeddedTestServer

net/test/embedded_test_server/http_request.cc

 // Copyright (c) 2012 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 "net/test/embedded_test_server/http_request.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "net/http/http_chunked_decoder.h"
+#include "url/gurl.h"
 
 namespace net {
 namespace test_server {
 
 namespace {
 
 size_t kRequestSizeLimit = 64 * 1024 * 1024;  // 64 mb.
 
 // Helper function used to trim tokens in http request headers.
 std::string Trim(const std::string& value) {
   std::string result;
   base::TrimString(value, " \t", &result);
   return result;
 }
 
 }  // namespace
 
 HttpRequest::HttpRequest() : method(METHOD_UNKNOWN),
                              has_content(false) {
 }
 
 HttpRequest::~HttpRequest() {
 }
 
+GURL HttpRequest::ToURL() const {
+  return GURL("http://localhost" + relative_url);

[mmenke, 2015/10/19 18:07:40]

Could you add a TODO to consider making this return the real URL, from the
embedded test server (Not suggesting you do it here because getting the
EmbeddedTestServer and the relative_url at the same time is a little ugly).

[svaldez, 2015/10/19 21:56:15]

Done.

+}
+
 HttpRequestParser::HttpRequestParser()
     : http_request_(new HttpRequest()),
       buffer_position_(0),
       state_(STATE_HEADERS),
       declared_content_length_(0) {
 }
 
 HttpRequestParser::~HttpRequestParser() {
 }
 
@@ skipping 43 matching lines @@
     std::vector<std::string> header_line_tokens = base::SplitString(
         header_line, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     DCHECK_EQ(3u, header_line_tokens.size());
     // Method.
     http_request_->method_string = header_line_tokens[0];
     http_request_->method =
         GetMethodType(base::ToLowerASCII(header_line_tokens[0]));
     // Address.
     // Don't build an absolute URL as the parser does not know (should not
     // know) anything about the server address.
-    http_request_->relative_url = header_line_tokens[1];
+    GURL url(header_line_tokens[1]);
+    if (url.is_valid()) {

[mmenke, 2015/10/19 18:07:40]

If we have a full URL, surely HttpRequest::ToURL should return it?  (And I'd
suggest renaming ToURL to just GetURL or URL()).

[svaldez, 2015/10/19 21:56:15]

There are cases where the "full URL" is actually not a valid URL pointing to the
ETS.

[mmenke, 2015/10/21 18:45:22]

Such as?

+      http_request_->relative_url = url.path();
+    } else {
+      if (header_line_tokens[1][0] == '/')

[mmenke, 2015/10/19 18:07:40]

else if {
} else {
}

[svaldez, 2015/10/19 21:56:15]

Done.

+        http_request_->relative_url = header_line_tokens[1];
+      else
+        http_request_->relative_url = "/" + header_line_tokens[1];
+    }
+
     // Protocol.
     const std::string protocol = base::ToLowerASCII(header_line_tokens[2]);
     CHECK(protocol == "http/1.0" || protocol == "http/1.1") <<
         "Protocol not supported: " << protocol;
   }
 
   // Parse further headers.
   {
     std::string header_name;
     while (true) {
@@ skipping 20 matching lines @@
     }
   }
 
   // Headers done. Is any content data attached to the request?
   declared_content_length_ = 0;
   if (http_request_->headers.count("Content-Length") > 0) {
     http_request_->has_content = true;
     const bool success = base::StringToSizeT(
         http_request_->headers["Content-Length"],
         &declared_content_length_);
-    DCHECK(success) << "Malformed Content-Length header's value.";
+    if (!success) {
+      declared_content_length_ = 0;
+      LOG(WARNING) << "Malformed Content-Length header's value.";

[mmenke, 2015/10/19 18:07:40]

We actually have tests that send invalid content-length headers?  ...Why?

[svaldez, 2015/10/19 21:56:15]

Some tests send Content-Length even if there isn't content or if its a body-less
request.

+    }
   } else if (http_request_->headers.count("Transfer-Encoding") > 0) {
     if (http_request_->headers["Transfer-Encoding"] == "chunked") {
       http_request_->has_content = true;
       chunked_decoder_.reset(new HttpChunkedDecoder());
       state_ = STATE_CONTENT;
       return WAITING;
     }
   }
   if (declared_content_length_ == 0) {
     // No content data, so parsing is finished.
@@ skipping 64 matching lines @@
   } else if (token == "head") {
     return METHOD_HEAD;
   } else if (token == "post") {
     return METHOD_POST;
   } else if (token == "put") {
     return METHOD_PUT;
   } else if (token == "delete") {
     return METHOD_DELETE;
   } else if (token == "patch") {
     return METHOD_PATCH;
+  } else if (token == "connect") {
+    return METHOD_CONNECT;
   }
-  NOTREACHED() << "Method not implemented: " << token;
-  return METHOD_UNKNOWN;
+  LOG(WARNING) << "Method not implemented: " << token;
+  return METHOD_GET;
 }
 
 }  // namespace test_server
 }  // namespace net