Split net/spdy into core and chromium subdirectories.

net/spdy/hpack/hpack_input_stream.cc

Index: net/spdy/hpack/hpack_input_stream.cc
diff --git a/net/spdy/hpack/hpack_input_stream.cc b/net/spdy/hpack/hpack_input_stream.cc
deleted file mode 100644
index 9cc27f5ae7e87a6d21ecef574bf02b4f5604bdc7..0000000000000000000000000000000000000000
--- a/net/spdy/hpack/hpack_input_stream.cc
+++ /dev/null
@@ -1,249 +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/spdy/hpack/hpack_input_stream.h"
-
-#include <algorithm>
-
-#include "base/logging.h"
-#include "net/spdy/hpack/hpack_huffman_decoder.h"
-#include "net/spdy/spdy_bug_tracker.h"
-
-namespace net {
-
-HpackInputStream::HpackInputStream(SpdyStringPiece buffer)
-    : buffer_(buffer),
-      bit_offset_(0),
-      parsed_bytes_(0),
-      parsed_bytes_current_(0),
-      need_more_data_(false) {}
-
-HpackInputStream::~HpackInputStream() {}
-
-bool HpackInputStream::HasMoreData() const {
-  return !buffer_.empty();
-}
-
-bool HpackInputStream::MatchPrefixAndConsume(HpackPrefix prefix) {
-  if (buffer_.empty()) {
-    need_more_data_ = true;
-    return false;
-  }
-
-  DCHECK_GT(prefix.bit_size, 0u);
-  DCHECK_LE(prefix.bit_size, 8u);
-
-  uint32_t peeked = 0;
-  size_t peeked_count = 0;
-
-  if (!PeekBits(&peeked_count, &peeked)) {
-    return false;
-  }
-
-  if ((peeked >> (32 - prefix.bit_size)) == prefix.bits) {
-    ConsumeBits(prefix.bit_size);
-    return true;
-  }
-  return false;
-}
-
-bool HpackInputStream::PeekNextOctet(uint8_t* next_octet) {
-  if (buffer_.empty()) {
-    need_more_data_ = true;
-    return false;
-  }
-  if ((bit_offset_ > 0)) {
-    DVLOG(1) << "HpackInputStream::PeekNextOctet bit_offset_=" << bit_offset_;
-    return false;
-  }
-
-  *next_octet = buffer_[0];
-  return true;
-}
-
-bool HpackInputStream::DecodeNextOctet(uint8_t* next_octet) {
-  if (!PeekNextOctet(next_octet)) {
-    return false;
-  }
-
-  buffer_.remove_prefix(1);
-  parsed_bytes_current_ += 1;
-  return true;
-}
-
-bool HpackInputStream::DecodeNextUint32(uint32_t* I) {
-  size_t N = 8 - bit_offset_;
-  DCHECK_GT(N, 0u);
-  DCHECK_LE(N, 8u);
-
-  bit_offset_ = 0;
-
-  *I = 0;
-
-  uint8_t next_marker = (1 << N) - 1;
-  uint8_t next_octet = 0;
-  if (!DecodeNextOctet(&next_octet)) {
-    if (!need_more_data_) {
-      DVLOG(1) << "HpackInputStream::DecodeNextUint32 initial octet error";
-    }
-    return false;
-  }
-  *I = next_octet & next_marker;
-
-  bool has_more = (*I == next_marker);
-  size_t shift = 0;
-  while (has_more && (shift < 32)) {
-    uint8_t next_octet = 0;
-    if (!DecodeNextOctet(&next_octet)) {
-      if (!need_more_data_) {
-        DVLOG(1) << "HpackInputStream::DecodeNextUint32 shift=" << shift;
-      }
-      return false;
-    }
-    has_more = (next_octet & 0x80) != 0;
-    next_octet &= 0x7f;
-    uint32_t addend = next_octet << shift;
-    // Check for overflow.
-    if ((addend >> shift) != next_octet) {
-      DVLOG(1) << "HpackInputStream::DecodeNextUint32 overflow";
-      return false;
-    }
-    *I += addend;
-    shift += 7;
-  }
-
-  return !has_more;
-}
-
-bool HpackInputStream::DecodeNextIdentityString(SpdyStringPiece* str) {
-  uint32_t size = 0;
-  if (!DecodeNextUint32(&size)) {
-    return false;
-  }
-
-  if (size > buffer_.size()) {
-    need_more_data_ = true;
-    return false;
-  }
-
-  *str = SpdyStringPiece(buffer_.data(), size);
-  buffer_.remove_prefix(size);
-  parsed_bytes_current_ += size;
-  return true;
-}
-
-bool HpackInputStream::DecodeNextHuffmanString(SpdyString* str) {
-  uint32_t encoded_size = 0;
-  if (!DecodeNextUint32(&encoded_size)) {
-    if (!need_more_data_) {
-      DVLOG(1) << "HpackInputStream::DecodeNextHuffmanString "
-               << "unable to decode size";
-    }
-    return false;
-  }
-
-  if (encoded_size > buffer_.size()) {
-    need_more_data_ = true;
-    DVLOG(1) << "HpackInputStream::DecodeNextHuffmanString " << encoded_size
-             << " > " << buffer_.size();
-    return false;
-  }
-
-  HpackInputStream bounded_reader(buffer_.substr(0, encoded_size));
-  buffer_.remove_prefix(encoded_size);
-  parsed_bytes_current_ += encoded_size;
-
-  return HpackHuffmanDecoder::DecodeString(&bounded_reader, str);
-}
-
-bool HpackInputStream::PeekBits(size_t* peeked_count, uint32_t* out) const {
-  size_t byte_offset = (bit_offset_ + *peeked_count) / 8;
-  size_t bit_offset = (bit_offset_ + *peeked_count) % 8;
-
-  if (*peeked_count >= 32 || byte_offset >= buffer_.size()) {
-    return false;
-  }
-  // We'll read the minimum of the current byte remainder,
-  // and the remaining unfilled bits of |out|.
-  size_t bits_to_read = std::min(32 - *peeked_count, 8 - bit_offset);
-
-  uint32_t new_bits = static_cast<uint32_t>(buffer_[byte_offset]);
-  // Shift byte remainder to most-signifcant bits of |new_bits|.
-  // This drops the leading |bit_offset| bits of the byte.
-  new_bits = new_bits << (24 + bit_offset);
-  // Shift bits to the most-significant open bits of |out|.
-  new_bits = new_bits >> *peeked_count;
-
-  CHECK_EQ(*out & new_bits, 0u);
-  *out |= new_bits;
-
-  *peeked_count += bits_to_read;
-  return true;
-}
-
-std::pair<size_t, uint32_t> HpackInputStream::InitializePeekBits() {
-  size_t peeked_count = 0;
-  uint32_t bits = 0;
-  if (bit_offset_ == 0) {
-    switch (buffer_.size()) {
-      default:
-        DCHECK_LE(4u, buffer_.size());
-        bits = static_cast<uint32_t>(static_cast<unsigned char>(buffer_[3]));
-        peeked_count += 8;
-      /* FALLTHROUGH */
-      case 3:
-        bits |= (static_cast<uint32_t>(static_cast<unsigned char>(buffer_[2]))
-                 << 8);
-        peeked_count += 8;
-      /* FALLTHROUGH */
-      case 2:
-        bits |= (static_cast<uint32_t>(static_cast<unsigned char>(buffer_[1]))
-                 << 16);
-        peeked_count += 8;
-      /* FALLTHROUGH */
-      case 1:
-        bits |= (static_cast<uint32_t>(static_cast<unsigned char>(buffer_[0]))
-                 << 24);
-        peeked_count += 8;
-        break;
-      case 0:
-        break;
-    }
-  } else {
-    SPDY_BUG << "InitializePeekBits called with non-zero bit_offset_: "
-             << bit_offset_;
-  }
-  return std::make_pair(peeked_count, bits);
-}
-
-void HpackInputStream::ConsumeBits(size_t bit_count) {
-  size_t byte_count = (bit_offset_ + bit_count) / 8;
-  bit_offset_ = (bit_offset_ + bit_count) % 8;
-  CHECK_GE(buffer_.size(), byte_count);
-  if (bit_offset_ != 0) {
-    CHECK_GT(buffer_.size(), 0u);
-  }
-  buffer_.remove_prefix(byte_count);
-  parsed_bytes_current_ += byte_count;
-}
-
-void HpackInputStream::ConsumeByteRemainder() {
-  if (bit_offset_ != 0) {
-    ConsumeBits(8 - bit_offset_);
-  }
-}
-
-uint32_t HpackInputStream::ParsedBytes() const {
-  return parsed_bytes_;
-}
-
-bool HpackInputStream::NeedMoreData() const {
-  return need_more_data_;
-}
-
-void HpackInputStream::MarkCurrentPosition() {
-  parsed_bytes_ = parsed_bytes_current_;
-}
-
-}  // namespace net