net/http/http_basic_state.cc

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/http/http_basic_state.h"

#include <set>
#include <utility>

#include "base/check_op.h"
#include "base/no_destructor.h"
#include "net/base/io_buffer.h"
#include "net/base/ip_endpoint.h"
#include "net/base/load_timing_info.h"
#include "net/base/net_errors.h"
#include "net/http/http_request_info.h"
#include "net/http/http_response_body_drainer.h"
#include "net/http/http_stream_parser.h"
#include "net/http/http_util.h"
#include "net/socket/stream_socket.h"
#include "net/socket/stream_socket_handle.h"
#include "net/ssl/ssl_info.h"
#include "url/gurl.h"

namespace net {

HttpBasicState::HttpBasicState(std::unique_ptr<StreamSocketHandle> connection,
                               bool is_for_get_to_http_proxy)
    : read_buf_(base::MakeRefCounted<GrowableIOBuffer>()),
      connection_(std::move(connection)),
      is_for_get_to_http_proxy_(is_for_get_to_http_proxy) {
  CHECK(connection_) << "StreamSocketHandle passed to HttpBasicState must "
                        "not be NULL. See crbug.com/790776";
}

HttpBasicState::~HttpBasicState() = default;

void HttpBasicState::Initialize(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const NetLogWithSource& net_log) {
  DCHECK(!parser_.get());
  traffic_annotation_ = request_info->traffic_annotation;
  parser_ = std::make_unique<HttpStreamParser>(
      connection_->socket(),
      connection_->reuse_type() ==
          StreamSocketHandle::SocketReuseType::kReusedIdle,
      request_info->url, request_info->method, request_info->upload_data_stream,
      read_buf_.get(), net_log);
}

void HttpBasicState::Close(bool not_reusable) {
  // `parser_` is null if the owner of `this` is created by an orphaned
  // HttpStreamFactory::Job in which case InitializeStream() will not have been
  // called. This also protects against null dereference in the case where
  // ReleaseConnection() has been called.
  //
  // TODO(mmenke):  Can these cases be handled a bit more cleanly?
  if (!parser_) {
    return;
  }
  StreamSocket* socket = connection_->socket();
  if (not_reusable && socket) {
    socket->Disconnect();
  }
  parser()->OnConnectionClose();
  connection_->Reset();
}

std::unique_ptr<StreamSocketHandle> HttpBasicState::ReleaseConnection() {
  // The HttpStreamParser object still has a pointer to the connection. Just to
  // be extra-sure it doesn't touch the connection again, delete it here rather
  // than leaving it until the destructor is called.
  parser_.reset();
  return std::move(connection_);
}

scoped_refptr<GrowableIOBuffer> HttpBasicState::read_buf() const {
  return read_buf_;
}

std::string HttpBasicState::GenerateRequestLine() const {
  return HttpUtil::GenerateRequestLine(parser_->method(), parser_->url(),
                                       is_for_get_to_http_proxy_);
}

bool HttpBasicState::IsConnectionReused() const {
  return connection_->reuse_type() ==
             StreamSocketHandle::SocketReuseType::kReusedIdle ||
         connection_->reuse_type() ==
             StreamSocketHandle::SocketReuseType::kUnusedIdle;
}

void HttpBasicState::SetConnectionReused() {
  connection_->set_reuse_type(StreamSocketHandle::SocketReuseType::kReusedIdle);
}

bool HttpBasicState::CanReuseConnection() const {
  return parser_ && connection_->socket() && parser_->CanReuseConnection();
}

bool HttpBasicState::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
  return connection_->GetLoadTimingInfo(IsConnectionReused(), load_timing_info);
}

void HttpBasicState::GetSSLInfo(SSLInfo* ssl_info) {
  CHECK(connection_);
  if (!connection_->socket() || !connection_->socket()->GetSSLInfo(ssl_info)) {
    *ssl_info = SSLInfo();
  }
}

int HttpBasicState::GetRemoteEndpoint(IPEndPoint* endpoint) {
  if (!connection_ || !connection_->socket()) {
    return ERR_SOCKET_NOT_CONNECTED;
  }
  return connection_->socket()->GetPeerAddress(endpoint);
}

const std::set<std::string>& HttpBasicState::GetDnsAliases() const {
  static const base::NoDestructor<std::set<std::string>> emptyset_result;
  return (connection_ && connection_->socket())
             ? connection_->socket()->GetDnsAliases()
             : *emptyset_result;
}

}  // namespace net