Method ProcessRequest

net/http/client.cpp:95–160

    }

    bool ProcessRequest(const std::string& url,
                        const HttpClient::Options& options,
                        HttpRequest* request,
                        HttpResponse *response)
    {
        URI *uri = NULL;
        if (!m_uri.Parse(url)) {
            m_error_code = HttpClient::ERROR_INVALID_URI_ADDRESS;
            return false;
        }
        uri = &m_uri;

        // Apply HTTP HEADERS into request
        std::string path = uri->Path();
        AppendHeaderToRequest(path, options.Headers(), request);

        m_max_response_length = options.MaxResponseLength() ?
            options.MaxResponseLength() :
            kDefaultMaxResponseLength;

        std::string path_and_query = uri->PathAndQuery();
        std::string host = uri->Host();

        request->SetHeader("User-Agent", m_http_client->UserAgent());
        request->SetHeader("Host", host);

        if (!m_http_client->Proxy().empty()) {
            if (!m_proxy_uri.Parse(m_http_client->Proxy())) {
                m_error_code = HttpClient::ERROR_INVALID_PROXY_ADDRESS;
                return false;
            }
            uri = &m_proxy_uri;
            path_and_query = url;
        }

        request->SetUri(path_and_query.empty() ? kDefaultPath : path_and_query);

        std::string port_str;
        if (uri->HasPort()) {
            port_str = uri->Port();
        } else if (uri->Scheme().empty() || uri->Scheme() == kHttpScheme) {
            port_str = kDefaultHttpPort;
        } else {
            m_error_code = HttpClient::ERROR_PROTOCAL_NOT_SUPPORTED;
            return false;
        }

        uint32_t port;
        if (!StringToNumber(port_str, &port))
            return false;

        std::vector<SocketAddressInet4> sa;
        if (!ResolveAddress(host, port, &sa, &m_error_code)) {
            return false;
        }

        for (std::vector<SocketAddressInet4>::const_iterator it = sa.begin();
            it != sa.end();