1 // Copyright 2014 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 // SdchFilter applies open_vcdiff content decoding to a datastream. 6 // This decoding uses a pre-cached dictionary of text fragments to decode 7 // (expand) the stream back to its original contents. 8 // 9 // This SdchFilter internally uses open_vcdiff/vcdec library to do decoding. 10 // 11 // SdchFilter is also a subclass of Filter. See the latter's header file 12 // filter.h for sample usage. 13 14 #ifndef NET_FILTER_SDCH_FILTER_H_ 15 #define NET_FILTER_SDCH_FILTER_H_ 16 17 #include <string> 18 19 #include "base/memory/scoped_ptr.h" 20 #include "net/base/net_export.h" 21 #include "net/base/sdch_manager.h" 22 #include "net/filter/filter.h" 23 24 namespace open_vcdiff { 25 class VCDiffStreamingDecoder; 26 } 27 28 namespace net { 29 30 class NET_EXPORT_PRIVATE SdchFilter : public Filter { 31 public: 32 virtual ~SdchFilter(); 33 34 // Initializes filter decoding mode and internal control blocks. 35 bool InitDecoding(Filter::FilterType filter_type); 36 37 // Decode the pre-filter data and writes the output into |dest_buffer| 38 // The function returns FilterStatus. See filter.h for its description. 39 // 40 // Upon entry, *dest_len is the total size (in number of chars) of the 41 // destination buffer. Upon exit, *dest_len is the actual number of chars 42 // written into the destination buffer. 43 virtual FilterStatus ReadFilteredData(char* dest_buffer, 44 int* dest_len) OVERRIDE; 45 46 private: 47 // Internal status. Once we enter an error state, we stop processing data. 48 enum DecodingStatus { 49 DECODING_UNINITIALIZED, 50 WAITING_FOR_DICTIONARY_SELECTION, 51 DECODING_IN_PROGRESS, 52 DECODING_ERROR, 53 META_REFRESH_RECOVERY, // Decoding error being handled by a meta-refresh. 54 PASS_THROUGH, // Non-sdch content being passed without alteration. 55 }; 56 57 // Only to be instantiated by Filter::Factory. 58 explicit SdchFilter(const FilterContext& filter_context); 59 friend class Filter; 60 61 // Identify the suggested dictionary, and initialize underlying decompressor. 62 Filter::FilterStatus InitializeDictionary(); 63 64 // Move data that was internally buffered (after decompression) to the 65 // specified dest_buffer. 66 int OutputBufferExcess(char* const dest_buffer, size_t available_space); 67 68 // Context data from the owner of this filter. 69 const FilterContext& filter_context_; 70 71 // Tracks the status of decoding. 72 // This variable is initialized by InitDecoding and updated only by 73 // ReadFilteredData. 74 DecodingStatus decoding_status_; 75 76 // The underlying decoder that processes data. 77 // This data structure is initialized by InitDecoding and updated in 78 // ReadFilteredData. 79 scoped_ptr<open_vcdiff::VCDiffStreamingDecoder> vcdiff_streaming_decoder_; 80 81 // In case we need to assemble the hash piecemeal, we have a place to store 82 // a part of the hash until we "get all 8 bytes plus a null." 83 std::string dictionary_hash_; 84 85 // After assembling an entire dictionary hash (the first 9 bytes of the 86 // sdch payload, we check to see if it is plausible, meaning it has a null 87 // termination, and has 8 characters that are possible in a net-safe base64 88 // encoding. If the hash is not plausible, then the payload is probably not 89 // an SDCH encoded bundle, and various error recovery strategies can be 90 // attempted. 91 bool dictionary_hash_is_plausible_; 92 93 // We hold an in-memory copy of the dictionary during the entire decoding, as 94 // it is used directly by the VC-DIFF decoding system. 95 // That char* data is part of the dictionary_ we hold a reference to. 96 scoped_refptr<SdchManager::Dictionary> dictionary_; 97 98 // We keep a copy of the URLRequestContext for use in the destructor, (at 99 // which point GetURLRequestContext() will likely return null because of 100 // the disassociation of the URLRequest from the URLRequestJob). This is 101 // safe because the URLRequestJob (and any filters) are guaranteed to be 102 // deleted before the URLRequestContext is destroyed. 103 const URLRequestContext* const url_request_context_; 104 105 // The decoder may demand a larger output buffer than the target of 106 // ReadFilteredData so we buffer the excess output between calls. 107 std::string dest_buffer_excess_; 108 // To avoid moving strings around too much, we save the index into 109 // dest_buffer_excess_ that has the next byte to output. 110 size_t dest_buffer_excess_index_; 111 112 // To get stats on activities, we keep track of source and target bytes. 113 // Visit about:histograms/Sdch to see histogram data. 114 size_t source_bytes_; 115 size_t output_bytes_; 116 117 // Error recovery in content type may add an sdch filter type, in which case 118 // we should gracefully perform pass through if the format is incorrect, or 119 // an applicable dictionary can't be found. 120 bool possible_pass_through_; 121 122 // The URL that is currently being filtered. 123 // This is used to restrict use of a dictionary to a specific URL or path. 124 GURL url_; 125 126 // To facilitate error recovery, allow filter to know if content is text/html 127 // by checking within this mime type (we may do a meta-refresh via html). 128 std::string mime_type_; 129 130 DISALLOW_COPY_AND_ASSIGN(SdchFilter); 131 }; 132 133 } // namespace net 134 135 #endif // NET_FILTER_SDCH_FILTER_H_ 136