Merge 151720 - net: workaround compression leaks

net/spdy/spdy_framer.h

 // Copyright (c) 2012 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.
 
 #ifndef NET_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 368 matching lines @@
   // On failure, returns NULL.
   SpdyFrame* CompressFrame(const SpdyFrame& frame);
 
   // Create a copy of a frame.
   // Returned frame must be freed with "delete".
   SpdyFrame* DuplicateFrame(const SpdyFrame& frame);
 
   // Returns true if a frame could be compressed.
   bool IsCompressible(const SpdyFrame& frame) const;
 
-  // Returns a new SpdyControlFrame with the compressed payload of |frame|.
-  SpdyControlFrame* CompressControlFrame(const SpdyControlFrame& frame);
-
   // Get the minimum size of the control frame for the given control frame
   // type. This is useful for validating frame blocks.
   static size_t GetMinimumControlFrameSize(int version, SpdyControlType type);
 
   // Get the stream ID for the given control frame (SYN_STREAM, SYN_REPLY, and
   // HEADERS). If the control frame is NULL or of another type, this
   // function returns kInvalidStream.
   static SpdyStreamId GetControlFrameStreamId(
       const SpdyControlFrame* control_frame);
 
@@ skipping 88 matching lines @@
   size_t UpdateCurrentFrameBuffer(const char** data, size_t* len,
                                   size_t max_bytes);
 
   // Retrieve serialized length of SpdyHeaderBlock.
   size_t GetSerializedLength(const SpdyHeaderBlock* headers) const;
 
   // Serializes a SpdyHeaderBlock.
   void WriteHeaderBlock(SpdyFrameBuilder* frame,
                         const SpdyHeaderBlock* headers) const;
 
+  void WriteHeaderBlockToZ(const SpdyHeaderBlock* headers,
+                           z_stream* out) const;
+
   // Set the error code and moves the framer into the error state.
   void set_error(SpdyError error);
 
   // Given a frame, breakdown the variable payload length, the static header
   // header length, and variable payload pointer.
   bool GetFrameBoundaries(const SpdyFrame& frame, int* payload_length,
                           int* header_length, const char** payload) const;
 
+  // Returns a new SpdyControlFrame with the compressed payload of |frame|.
+  SpdyControlFrame* CompressControlFrame(const SpdyControlFrame& frame,
+                                         const SpdyHeaderBlock* headers);
+
   // The size of the control frame buffer.
   // Since this is only used for control frame headers, the maximum control
   // frame header size (SYN_STREAM) is sufficient; all remaining control
   // frame data is streamed to the visitor.
   static const size_t kControlFrameBufferSize;
 
   // The maximum size of the control frames that we support.
   // This limit is arbitrary. We can enforce it here or at the application
   // layer. We chose the framing layer, but this can be changed (or removed)
   // if necessary later down the line.
@@ skipping 48 matching lines @@
   // starts with HTTP.  If it does, we likely have an HTTP response.   This
   // isn't guaranteed though: we could have gotten a settings frame and then
   // corrupt data that just looks like HTTP, but deterministic checking requires
   // a lot more state.
   bool probable_http_response_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_