Home | History | Annotate | Download | only in http 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/http/http_basic_stream.h"
      6 
      7 #include "base/strings/stringprintf.h"
      8 #include "net/base/io_buffer.h"
      9 #include "net/base/net_errors.h"
     10 #include "net/http/http_request_headers.h"
     11 #include "net/http/http_request_info.h"
     12 #include "net/http/http_response_body_drainer.h"
     13 #include "net/http/http_stream_parser.h"
     14 #include "net/http/http_util.h"
     15 #include "net/socket/client_socket_handle.h"
     16 
     17 namespace net {
     18 
     19 HttpBasicStream::HttpBasicStream(ClientSocketHandle* connection,
     20                                  HttpStreamParser* parser,
     21                                  bool using_proxy)
     22     : read_buf_(new GrowableIOBuffer()),
     23       parser_(parser),
     24       connection_(connection),
     25       using_proxy_(using_proxy),
     26       request_info_(NULL) {
     27 }
     28 
     29 HttpBasicStream::~HttpBasicStream() {}
     30 
     31 int HttpBasicStream::InitializeStream(
     32     const HttpRequestInfo* request_info,
     33     RequestPriority priority,
     34     const BoundNetLog& net_log,
     35     const CompletionCallback& callback) {
     36   DCHECK(!parser_.get());
     37   request_info_ = request_info;
     38   parser_.reset(new HttpStreamParser(
     39       connection_.get(), request_info, read_buf_.get(), net_log));
     40   return OK;
     41 }
     42 
     43 
     44 int HttpBasicStream::SendRequest(const HttpRequestHeaders& headers,
     45                                  HttpResponseInfo* response,
     46                                  const CompletionCallback& callback) {
     47   DCHECK(parser_.get());
     48   DCHECK(request_info_);
     49   const std::string path = using_proxy_ ?
     50                            HttpUtil::SpecForRequest(request_info_->url) :
     51                            HttpUtil::PathForRequest(request_info_->url);
     52   request_line_ = base::StringPrintf("%s %s HTTP/1.1\r\n",
     53                                      request_info_->method.c_str(),
     54                                      path.c_str());
     55   return parser_->SendRequest(request_line_, headers, response, callback);
     56 }
     57 
     58 UploadProgress HttpBasicStream::GetUploadProgress() const {
     59   return parser_->GetUploadProgress();
     60 }
     61 
     62 int HttpBasicStream::ReadResponseHeaders(const CompletionCallback& callback) {
     63   return parser_->ReadResponseHeaders(callback);
     64 }
     65 
     66 const HttpResponseInfo* HttpBasicStream::GetResponseInfo() const {
     67   return parser_->GetResponseInfo();
     68 }
     69 
     70 int HttpBasicStream::ReadResponseBody(IOBuffer* buf, int buf_len,
     71                                       const CompletionCallback& callback) {
     72   return parser_->ReadResponseBody(buf, buf_len, callback);
     73 }
     74 
     75 void HttpBasicStream::Close(bool not_reusable) {
     76   parser_->Close(not_reusable);
     77 }
     78 
     79 HttpStream* HttpBasicStream::RenewStreamForAuth() {
     80   DCHECK(IsResponseBodyComplete());
     81   DCHECK(!parser_->IsMoreDataBuffered());
     82   parser_.reset();
     83   return new HttpBasicStream(connection_.release(), NULL, using_proxy_);
     84 }
     85 
     86 bool HttpBasicStream::IsResponseBodyComplete() const {
     87   return parser_->IsResponseBodyComplete();
     88 }
     89 
     90 bool HttpBasicStream::CanFindEndOfResponse() const {
     91   return parser_->CanFindEndOfResponse();
     92 }
     93 
     94 bool HttpBasicStream::IsConnectionReused() const {
     95   return parser_->IsConnectionReused();
     96 }
     97 
     98 void HttpBasicStream::SetConnectionReused() {
     99   parser_->SetConnectionReused();
    100 }
    101 
    102 bool HttpBasicStream::IsConnectionReusable() const {
    103   return parser_->IsConnectionReusable();
    104 }
    105 
    106 bool HttpBasicStream::GetLoadTimingInfo(
    107     LoadTimingInfo* load_timing_info) const {
    108   return connection_->GetLoadTimingInfo(IsConnectionReused(), load_timing_info);
    109 }
    110 
    111 void HttpBasicStream::GetSSLInfo(SSLInfo* ssl_info) {
    112   parser_->GetSSLInfo(ssl_info);
    113 }
    114 
    115 void HttpBasicStream::GetSSLCertRequestInfo(
    116     SSLCertRequestInfo* cert_request_info) {
    117   parser_->GetSSLCertRequestInfo(cert_request_info);
    118 }
    119 
    120 bool HttpBasicStream::IsSpdyHttpStream() const {
    121   return false;
    122 }
    123 
    124 void HttpBasicStream::Drain(HttpNetworkSession* session) {
    125   HttpResponseBodyDrainer* drainer = new HttpResponseBodyDrainer(this);
    126   drainer->Start(session);
    127   // |drainer| will delete itself.
    128 }
    129 
    130 }  // namespace net
    131