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_pipelined_stream.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/strings/stringprintf.h"
      9 #include "net/base/net_errors.h"
     10 #include "net/http/http_pipelined_connection_impl.h"
     11 #include "net/http/http_request_headers.h"
     12 #include "net/http/http_request_info.h"
     13 #include "net/http/http_util.h"
     14 
     15 namespace net {
     16 
     17 HttpPipelinedStream::HttpPipelinedStream(HttpPipelinedConnectionImpl* pipeline,
     18                                          int pipeline_id)
     19     : pipeline_(pipeline),
     20       pipeline_id_(pipeline_id),
     21       request_info_(NULL) {
     22 }
     23 
     24 HttpPipelinedStream::~HttpPipelinedStream() {
     25   pipeline_->OnStreamDeleted(pipeline_id_);
     26 }
     27 
     28 int HttpPipelinedStream::InitializeStream(
     29     const HttpRequestInfo* request_info,
     30     RequestPriority priority,
     31     const BoundNetLog& net_log,
     32     const CompletionCallback& callback) {
     33   request_info_ = request_info;
     34   pipeline_->InitializeParser(pipeline_id_, request_info, net_log);
     35   return OK;
     36 }
     37 
     38 
     39 int HttpPipelinedStream::SendRequest(const HttpRequestHeaders& headers,
     40                                      HttpResponseInfo* response,
     41                                      const CompletionCallback& callback) {
     42   CHECK(pipeline_id_);
     43   CHECK(request_info_);
     44   // TODO(simonjam): Proxy support will be needed here.
     45   const std::string path = HttpUtil::PathForRequest(request_info_->url);
     46   std::string request_line_ = base::StringPrintf("%s %s HTTP/1.1\r\n",
     47                                                  request_info_->method.c_str(),
     48                                                  path.c_str());
     49   return pipeline_->SendRequest(pipeline_id_, request_line_, headers, response,
     50                                 callback);
     51 }
     52 
     53 UploadProgress HttpPipelinedStream::GetUploadProgress() const {
     54   return pipeline_->GetUploadProgress(pipeline_id_);
     55 }
     56 
     57 int HttpPipelinedStream::ReadResponseHeaders(
     58     const CompletionCallback& callback) {
     59   return pipeline_->ReadResponseHeaders(pipeline_id_, callback);
     60 }
     61 
     62 const HttpResponseInfo* HttpPipelinedStream::GetResponseInfo() const {
     63   return pipeline_->GetResponseInfo(pipeline_id_);
     64 }
     65 
     66 int HttpPipelinedStream::ReadResponseBody(IOBuffer* buf, int buf_len,
     67                                           const CompletionCallback& callback) {
     68   return pipeline_->ReadResponseBody(pipeline_id_, buf, buf_len, callback);
     69 }
     70 
     71 void HttpPipelinedStream::Close(bool not_reusable) {
     72   pipeline_->Close(pipeline_id_, not_reusable);
     73 }
     74 
     75 HttpStream* HttpPipelinedStream::RenewStreamForAuth() {
     76   if (pipeline_->usable()) {
     77     return pipeline_->CreateNewStream();
     78   }
     79   return NULL;
     80 }
     81 
     82 bool HttpPipelinedStream::IsResponseBodyComplete() const {
     83   return pipeline_->IsResponseBodyComplete(pipeline_id_);
     84 }
     85 
     86 bool HttpPipelinedStream::CanFindEndOfResponse() const {
     87   return pipeline_->CanFindEndOfResponse(pipeline_id_);
     88 }
     89 
     90 bool HttpPipelinedStream::IsConnectionReused() const {
     91   return pipeline_->IsConnectionReused(pipeline_id_);
     92 }
     93 
     94 void HttpPipelinedStream::SetConnectionReused() {
     95   pipeline_->SetConnectionReused(pipeline_id_);
     96 }
     97 
     98 bool HttpPipelinedStream::IsConnectionReusable() const {
     99   return pipeline_->usable();
    100 }
    101 
    102 bool HttpPipelinedStream::GetLoadTimingInfo(
    103     LoadTimingInfo* load_timing_info) const {
    104   return pipeline_->GetLoadTimingInfo(pipeline_id_, load_timing_info);
    105 }
    106 
    107 void HttpPipelinedStream::GetSSLInfo(SSLInfo* ssl_info) {
    108   pipeline_->GetSSLInfo(pipeline_id_, ssl_info);
    109 }
    110 
    111 void HttpPipelinedStream::GetSSLCertRequestInfo(
    112     SSLCertRequestInfo* cert_request_info) {
    113   pipeline_->GetSSLCertRequestInfo(pipeline_id_, cert_request_info);
    114 }
    115 
    116 bool HttpPipelinedStream::IsSpdyHttpStream() const {
    117   return false;
    118 }
    119 
    120 void HttpPipelinedStream::Drain(HttpNetworkSession* session) {
    121   pipeline_->Drain(this, session);
    122 }
    123 
    124 const SSLConfig& HttpPipelinedStream::used_ssl_config() const {
    125   return pipeline_->used_ssl_config();
    126 }
    127 
    128 const ProxyInfo& HttpPipelinedStream::used_proxy_info() const {
    129   return pipeline_->used_proxy_info();
    130 }
    131 
    132 const BoundNetLog& HttpPipelinedStream::net_log() const {
    133   return pipeline_->net_log();
    134 }
    135 
    136 bool HttpPipelinedStream::was_npn_negotiated() const {
    137   return pipeline_->was_npn_negotiated();
    138 }
    139 
    140 NextProto HttpPipelinedStream::protocol_negotiated() const {
    141   return pipeline_->protocol_negotiated();
    142 }
    143 
    144 }  // namespace net
    145