src/net/quic/quic_spdy_decompressor.cc

   1 // Copyright (c) 2013 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/quic/quic_spdy_decompressor.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10
  11 using base::StringPiece;
  12 using std::min;
  13
  14 namespace net {
  15
  16 class SpdyFramerVisitor : public SpdyFramerVisitorInterface {
  17  public:
  18   explicit SpdyFramerVisitor(QuicSpdyDecompressor::Visitor* visitor)
  19       : visitor_(visitor),
  20         error_(false) {
  21   }
  22
  23   virtual void OnError(SpdyFramer* framer) OVERRIDE {
  24     error_ = true;
  25   }
  26   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
  27                                  size_t length,
  28                                  bool fin) OVERRIDE {}
  29   virtual void OnStreamFrameData(SpdyStreamId stream_id,
  30                                  const char* data,
  31                                  size_t len,
  32                                  bool fin) OVERRIDE {}
  33   virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
  34                                         const char* header_data,
  35                                         size_t len) OVERRIDE;
  36   virtual void OnSynStream(SpdyStreamId stream_id,
  37                            SpdyStreamId associated_stream_id,
  38                            SpdyPriority priority,
  39                            uint8 credential_slot,
  40                            bool fin,
  41                            bool unidirectional) OVERRIDE {}
  42   virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {}
  43   virtual void OnRstStream(SpdyStreamId stream_id,
  44                            SpdyRstStreamStatus status) OVERRIDE {}
  45   virtual void OnSetting(SpdySettingsIds id,
  46                          uint8 flags,
  47                          uint32 value) OVERRIDE {}
  48   virtual void OnPing(uint32 unique_id) OVERRIDE {}
  49   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
  50                         SpdyGoAwayStatus status) OVERRIDE {}
  51   virtual void OnHeaders(SpdyStreamId stream_id, bool fin) OVERRIDE {}
  52   virtual void OnWindowUpdate(SpdyStreamId stream_id,
  53                               uint32 delta_window_size) OVERRIDE {}
  54   virtual void OnPushPromise(SpdyStreamId stream_id,
  55                              SpdyStreamId promised_stream_id) OVERRIDE {}
  56   void set_visitor(QuicSpdyDecompressor::Visitor* visitor) {
  57     DCHECK(visitor);
  58     visitor_ = visitor;
  59   }
  60
  61  private:
  62   QuicSpdyDecompressor::Visitor* visitor_;
  63   bool error_;
  64 };
  65
  66 bool SpdyFramerVisitor::OnControlFrameHeaderData(SpdyStreamId stream_id,
  67                                                  const char* header_data,
  68                                                  size_t len) {
  69   DCHECK(visitor_);
  70   return visitor_->OnDecompressedData(StringPiece(header_data, len));
  71 }
  72
  73 QuicSpdyDecompressor::QuicSpdyDecompressor()
  74     : spdy_framer_(SPDY3),
  75       spdy_visitor_(new SpdyFramerVisitor(NULL)),
  76       current_header_id_(1),
  77       has_current_compressed_size_(false),
  78       current_compressed_size_(0),
  79       compressed_bytes_consumed_(0) {
  80   spdy_framer_.set_visitor(spdy_visitor_.get());
  81 }
  82
  83 QuicSpdyDecompressor::~QuicSpdyDecompressor() {
  84 }
  85
  86 size_t QuicSpdyDecompressor::DecompressData(StringPiece data,
  87                                             Visitor* visitor) {
  88   spdy_visitor_->set_visitor(visitor);
  89   size_t bytes_consumed = 0;
  90
  91   if (!has_current_compressed_size_) {
  92     const size_t kCompressedBufferSizeSize = sizeof(uint32);
  93     DCHECK_GT(kCompressedBufferSizeSize, compressed_size_buffer_.length());
  94     size_t missing_size =
  95         kCompressedBufferSizeSize - compressed_size_buffer_.length();
  96     if (data.length() < missing_size) {
  97       data.AppendToString(&compressed_size_buffer_);
  98       return data.length();
  99     }
 100     bytes_consumed += missing_size;
 101     data.substr(0, missing_size).AppendToString(&compressed_size_buffer_);
 102     DCHECK_EQ(kCompressedBufferSizeSize, compressed_size_buffer_.length());
 103     memcpy(&current_compressed_size_, compressed_size_buffer_.data(),
 104            kCompressedBufferSizeSize);
 105     compressed_size_buffer_.clear();
 106     has_current_compressed_size_ = true;
 107     data = data.substr(missing_size);
 108     compressed_bytes_consumed_ = 0;
 109   }
 110
 111   size_t bytes_to_consume =
 112       min(current_compressed_size_ - compressed_bytes_consumed_,
 113           static_cast<uint32>(data.length()));
 114   if (bytes_to_consume > 0) {
 115     if (!spdy_framer_.IncrementallyDecompressControlFrameHeaderData(
 116             current_header_id_, data.data(), bytes_to_consume)) {
 117       visitor->OnDecompressionError();
 118       return bytes_consumed;
 119     }
 120     compressed_bytes_consumed_ += bytes_to_consume;
 121     bytes_consumed += bytes_to_consume;
 122   }
 123   if (current_compressed_size_ - compressed_bytes_consumed_ == 0) {
 124     ResetForNextHeaders();
 125   }
 126   return bytes_consumed;
 127 }
 128
 129 void QuicSpdyDecompressor::ResetForNextHeaders() {
 130   has_current_compressed_size_ = false;
 131   current_compressed_size_ = 0;
 132   compressed_bytes_consumed_ = 0;
 133   ++current_header_id_;
 134 }
 135
 136 }  // namespace net