// Copyright 2014 The Chromium OS 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 <brillo/http/http_connection_fake.h>
#include <base/logging.h>
#include <brillo/bind_lambda.h>
#include <brillo/http/http_request.h>
#include <brillo/mime_utils.h>
#include <brillo/streams/memory_stream.h>
#include <brillo/strings/string_utils.h>
namespace brillo {
namespace http {
namespace fake {
Connection::Connection(const std::string& url,
const std::string& method,
const std::shared_ptr<http::Transport>& transport)
: http::Connection(transport), request_(url, method) {
VLOG(1) << "fake::Connection created: " << method;
}
Connection::~Connection() {
VLOG(1) << "fake::Connection destroyed";
}
bool Connection::SendHeaders(const HeaderList& headers,
brillo::ErrorPtr* /* error */) {
request_.AddHeaders(headers);
return true;
}
bool Connection::SetRequestData(StreamPtr stream,
brillo::ErrorPtr* /* error */) {
request_.SetData(std::move(stream));
return true;
}
bool Connection::FinishRequest(brillo::ErrorPtr* /* error */) {
using brillo::string_utils::ToString;
request_.AddHeaders(
{{request_header::kContentLength, ToString(request_.GetData().size())}});
fake::Transport* transport = static_cast<fake::Transport*>(transport_.get());
CHECK(transport) << "Expecting a fake transport";
auto handler = transport->GetHandler(request_.GetURL(), request_.GetMethod());
if (handler.is_null()) {
LOG(ERROR) << "Received unexpected " << request_.GetMethod()
<< " request at " << request_.GetURL();
response_.ReplyText(status_code::NotFound,
"<html><body>Not found</body></html>",
brillo::mime::text::kHtml);
} else {
handler.Run(request_, &response_);
}
return true;
}
RequestID Connection::FinishRequestAsync(
const SuccessCallback& success_callback,
const ErrorCallback& error_callback) {
// Make sure the produced Closure holds a reference to the instance of this
// connection.
auto connection = std::static_pointer_cast<Connection>(shared_from_this());
auto callback = [](std::shared_ptr<Connection> connection,
const SuccessCallback& success_callback,
const ErrorCallback& error_callback) {
connection->FinishRequestAsyncHelper(success_callback, error_callback);
};
transport_->RunCallbackAsync(FROM_HERE,
base::Bind(callback,
base::Passed(&connection),
success_callback,
error_callback));
return 1;
}
void Connection::FinishRequestAsyncHelper(
const SuccessCallback& success_callback,
const ErrorCallback& error_callback) {
brillo::ErrorPtr error;
if (!FinishRequest(&error)) {
error_callback.Run(1, error.get());
} else {
std::unique_ptr<Response> response{new Response{shared_from_this()}};
success_callback.Run(1, std::move(response));
}
}
int Connection::GetResponseStatusCode() const {
return response_.GetStatusCode();
}
std::string Connection::GetResponseStatusText() const {
return response_.GetStatusText();
}
std::string Connection::GetProtocolVersion() const {
return response_.GetProtocolVersion();
}
std::string Connection::GetResponseHeader(
const std::string& header_name) const {
return response_.GetHeader(header_name);
}
StreamPtr Connection::ExtractDataStream(brillo::ErrorPtr* error) {
// HEAD requests must not return body.
if (request_.GetMethod() != request_type::kHead) {
return MemoryStream::OpenRef(response_.GetData(), error);
} else {
// Return empty data stream for HEAD requests.
return MemoryStream::OpenCopyOf(nullptr, 0, error);
}
}
} // namespace fake
} // namespace http
} // namespace brillo