Move shared files in net/quic/ into net/quic/core/

net/quic/quic_client_session_base.cc

Index: net/quic/quic_client_session_base.cc
diff --git a/net/quic/quic_client_session_base.cc b/net/quic/quic_client_session_base.cc
deleted file mode 100644
index 7875c67cd8979deecd766b145ff7d4472f4f7c7b..0000000000000000000000000000000000000000
--- a/net/quic/quic_client_session_base.cc
+++ /dev/null
@@ -1,205 +0,0 @@
-// Copyright 2014 The Chromium 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 "net/quic/quic_client_session_base.h"
-
-#include "net/quic/quic_client_promised_info.h"
-#include "net/quic/quic_flags.h"
-#include "net/quic/spdy_utils.h"
-
-using base::StringPiece;
-using std::string;
-
-namespace net {
-
-QuicClientSessionBase::QuicClientSessionBase(
-    QuicConnection* connection,
-    QuicClientPushPromiseIndex* push_promise_index,
-    const QuicConfig& config)
-    : QuicSpdySession(connection, config),
-      push_promise_index_(push_promise_index),
-      largest_promised_stream_id_(kInvalidStreamId) {}
-
-QuicClientSessionBase::~QuicClientSessionBase() {
-  //  all promised streams for this session
-  for (auto& it : promised_by_id_) {
-    DVLOG(1) << "erase stream " << it.first << " url " << it.second->url();
-    push_promise_index_->promised_by_url()->erase(it.second->url());
-  }
-}
-
-void QuicClientSessionBase::OnConfigNegotiated() {
-  QuicSpdySession::OnConfigNegotiated();
-}
-
-void QuicClientSessionBase::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
-  QuicSession::OnCryptoHandshakeEvent(event);
-}
-
-void QuicClientSessionBase::OnPromiseHeaders(QuicStreamId stream_id,
-                                             StringPiece headers_data) {
-  QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
-  if (!stream) {
-    // It's quite possible to receive headers after a stream has been reset.
-    return;
-  }
-  stream->OnPromiseHeaders(headers_data);
-}
-
-void QuicClientSessionBase::OnInitialHeadersComplete(
-    QuicStreamId stream_id,
-    const SpdyHeaderBlock& response_headers) {
-  // Note that the strong ordering of the headers stream means that
-  // QuicSpdyClientStream::OnPromiseHeadersComplete must have already
-  // been called (on the associated stream) if this is a promised
-  // stream. However, this stream may not have existed at this time,
-  // hence the need to query the session.
-  QuicClientPromisedInfo* promised = GetPromisedById(stream_id);
-  if (!promised)
-    return;
-
-  promised->OnResponseHeaders(response_headers);
-}
-
-void QuicClientSessionBase::OnPromiseHeadersComplete(
-    QuicStreamId stream_id,
-    QuicStreamId promised_stream_id,
-    size_t frame_len) {
-  if (promised_stream_id != kInvalidStreamId &&
-      promised_stream_id <= largest_promised_stream_id_) {
-    connection()->CloseConnection(
-        QUIC_INVALID_STREAM_ID,
-        "Received push stream id lesser or equal to the"
-        " last accepted before",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-  largest_promised_stream_id_ = promised_stream_id;
-
-  QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
-  if (!stream) {
-    // It's quite possible to receive headers after a stream has been reset.
-    return;
-  }
-  stream->OnPromiseHeadersComplete(promised_stream_id, frame_len);
-}
-
-void QuicClientSessionBase::OnPromiseHeaderList(
-    QuicStreamId stream_id,
-    QuicStreamId promised_stream_id,
-    size_t frame_len,
-    const QuicHeaderList& header_list) {
-  if (promised_stream_id != kInvalidStreamId &&
-      promised_stream_id <= largest_promised_stream_id_) {
-    connection()->CloseConnection(
-        QUIC_INVALID_STREAM_ID,
-        "Received push stream id lesser or equal to the"
-        " last accepted before",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-  largest_promised_stream_id_ = promised_stream_id;
-
-  QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
-  if (!stream) {
-    // It's quite possible to receive headers after a stream has been reset.
-    return;
-  }
-  stream->OnPromiseHeaderList(promised_stream_id, frame_len, header_list);
-}
-
-void QuicClientSessionBase::HandlePromised(QuicStreamId /* associated_id */,
-                                           QuicStreamId id,
-                                           const SpdyHeaderBlock& headers) {
-  // Due to pathalogical packet re-ordering, it is possible that
-  // frames for the promised stream have already arrived, and the
-  // promised stream could be active or closed.
-  if (IsClosedStream(id)) {
-    // There was a RST on the data stream already, perhaps
-    // QUIC_REFUSED_STREAM?
-    DVLOG(1) << "Promise ignored for stream " << id
-             << " that is already closed";
-    return;
-  }
-
-  if (push_promise_index_->promised_by_url()->size() >= get_max_promises()) {
-    DVLOG(1) << "Too many promises, rejecting promise for stream " << id;
-    ResetPromised(id, QUIC_REFUSED_STREAM);
-    return;
-  }
-
-  const string url = SpdyUtils::GetUrlFromHeaderBlock(headers);
-  QuicClientPromisedInfo* old_promised = GetPromisedByUrl(url);
-  if (old_promised) {
-    DVLOG(1) << "Promise for stream " << id << " is duplicate URL " << url
-             << " of previous promise for stream " << old_promised->id();
-    ResetPromised(id, QUIC_DUPLICATE_PROMISE_URL);
-    return;
-  }
-
-  if (GetPromisedById(id)) {
-    // OnPromiseHeadersComplete() would have closed the connection if
-    // promised id is a duplicate.
-    QUIC_BUG << "Duplicate promise for id " << id;
-    return;
-  }
-
-  QuicClientPromisedInfo* promised = new QuicClientPromisedInfo(this, id, url);
-  std::unique_ptr<QuicClientPromisedInfo> promised_owner(promised);
-  promised->Init();
-  DVLOG(1) << "stream " << id << " emplace url " << url;
-  (*push_promise_index_->promised_by_url())[url] = promised;
-  promised_by_id_[id] = std::move(promised_owner);
-  promised->OnPromiseHeaders(headers);
-}
-
-QuicClientPromisedInfo* QuicClientSessionBase::GetPromisedByUrl(
-    const string& url) {
-  QuicPromisedByUrlMap::iterator it =
-      push_promise_index_->promised_by_url()->find(url);
-  if (it != push_promise_index_->promised_by_url()->end()) {
-    return it->second;
-  }
-  return nullptr;
-}
-
-QuicClientPromisedInfo* QuicClientSessionBase::GetPromisedById(
-    const QuicStreamId id) {
-  QuicPromisedByIdMap::iterator it = promised_by_id_.find(id);
-  if (it != promised_by_id_.end()) {
-    return it->second.get();
-  }
-  return nullptr;
-}
-
-QuicSpdyStream* QuicClientSessionBase::GetPromisedStream(
-    const QuicStreamId id) {
-  if (IsClosedStream(id)) {
-    return nullptr;
-  }
-  DynamicStreamMap::iterator it = dynamic_streams().find(id);
-  if (it != dynamic_streams().end()) {
-    return static_cast<QuicSpdyStream*>(it->second);
-  }
-  QUIC_BUG << "Open promised stream " << id << " is missing!";
-  return nullptr;
-}
-
-void QuicClientSessionBase::DeletePromised(QuicClientPromisedInfo* promised) {
-  push_promise_index_->promised_by_url()->erase(promised->url());
-  // Since promised_by_id_ contains the unique_ptr, this will destroy
-  // promised.
-  promised_by_id_.erase(promised->id());
-}
-
-void QuicClientSessionBase::ResetPromised(QuicStreamId id,
-                                          QuicRstStreamErrorCode error_code) {
-  SendRstStream(id, error_code, 0);
-  if (!IsOpenStream(id)) {
-    MaybeIncreaseLargestPeerStreamId(id);
-    InsertLocallyClosedStreamsHighestOffset(id, 0);
-  }
-}
-
-}  // namespace net