Updating trunk VERSION from 2139.0 to 2140.0
[chromium-blink-merge.git] / net / tools / quic / quic_in_memory_cache.cc
blob15a783d9b502c8bd441dc0c5630878c747cd11be
1 // Copyright (c) 2012 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.
5 #include "net/tools/quic/quic_in_memory_cache.h"
7 #include "base/file_util.h"
8 #include "base/files/file_enumerator.h"
9 #include "base/stl_util.h"
10 #include "base/strings/string_number_conversions.h"
11 #include "net/tools/balsa/balsa_headers.h"
13 using base::FilePath;
14 using base::StringPiece;
15 using std::string;
17 // Specifies the directory used during QuicInMemoryCache
18 // construction to seed the cache. Cache directory can be
19 // generated using `wget -p --save-headers <url>
21 namespace net {
22 namespace tools {
24 std::string FLAGS_quic_in_memory_cache_dir = "";
26 namespace {
28 // BalsaVisitor implementation (glue) which caches response bodies.
29 class CachingBalsaVisitor : public NoOpBalsaVisitor {
30 public:
31 CachingBalsaVisitor() : done_framing_(false) {}
32 virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {
33 AppendToBody(input, size);
35 virtual void MessageDone() OVERRIDE {
36 done_framing_ = true;
38 virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE {
39 UnhandledError();
41 virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {
42 UnhandledError();
44 virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE {
45 UnhandledError();
47 virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE {
48 UnhandledError();
50 void UnhandledError() {
51 LOG(DFATAL) << "Unhandled error framing HTTP.";
53 void AppendToBody(const char* input, size_t size) {
54 body_.append(input, size);
56 bool done_framing() const { return done_framing_; }
57 const string& body() const { return body_; }
59 private:
60 bool done_framing_;
61 string body_;
64 } // namespace
66 // static
67 QuicInMemoryCache* QuicInMemoryCache::GetInstance() {
68 return Singleton<QuicInMemoryCache>::get();
71 const QuicInMemoryCache::Response* QuicInMemoryCache::GetResponse(
72 const BalsaHeaders& request_headers) const {
73 ResponseMap::const_iterator it = responses_.find(GetKey(request_headers));
74 if (it == responses_.end()) {
75 return NULL;
77 return it->second;
80 void QuicInMemoryCache::AddSimpleResponse(StringPiece method,
81 StringPiece path,
82 StringPiece version,
83 StringPiece response_code,
84 StringPiece response_detail,
85 StringPiece body) {
86 BalsaHeaders request_headers, response_headers;
87 request_headers.SetRequestFirstlineFromStringPieces(method,
88 path,
89 version);
90 response_headers.SetRequestFirstlineFromStringPieces(version,
91 response_code,
92 response_detail);
93 response_headers.AppendHeader("content-length",
94 base::IntToString(body.length()));
96 AddResponse(request_headers, response_headers, body);
99 void QuicInMemoryCache::AddResponse(const BalsaHeaders& request_headers,
100 const BalsaHeaders& response_headers,
101 StringPiece response_body) {
102 VLOG(1) << "Adding response for: " << GetKey(request_headers);
103 if (ContainsKey(responses_, GetKey(request_headers))) {
104 LOG(DFATAL) << "Response for given request already exists!";
105 return;
107 Response* new_response = new Response();
108 new_response->set_headers(response_headers);
109 new_response->set_body(response_body);
110 responses_[GetKey(request_headers)] = new_response;
113 void QuicInMemoryCache::AddSpecialResponse(StringPiece method,
114 StringPiece path,
115 StringPiece version,
116 SpecialResponseType response_type) {
117 BalsaHeaders request_headers, response_headers;
118 request_headers.SetRequestFirstlineFromStringPieces(method,
119 path,
120 version);
121 AddResponse(request_headers, response_headers, "");
122 responses_[GetKey(request_headers)]->response_type_ = response_type;
125 QuicInMemoryCache::QuicInMemoryCache() {
126 Initialize();
129 void QuicInMemoryCache::ResetForTests() {
130 STLDeleteValues(&responses_);
131 Initialize();
134 void QuicInMemoryCache::Initialize() {
135 // If there's no defined cache dir, we have no initialization to do.
136 if (FLAGS_quic_in_memory_cache_dir.empty()) {
137 VLOG(1) << "No cache directory found. Skipping initialization.";
138 return;
140 VLOG(1) << "Attempting to initialize QuicInMemoryCache from directory: "
141 << FLAGS_quic_in_memory_cache_dir;
143 FilePath directory(FLAGS_quic_in_memory_cache_dir);
144 base::FileEnumerator file_list(directory,
145 true,
146 base::FileEnumerator::FILES);
148 FilePath file = file_list.Next();
149 while (!file.empty()) {
150 // Need to skip files in .svn directories
151 if (file.value().find("/.svn/") != std::string::npos) {
152 file = file_list.Next();
153 continue;
156 BalsaHeaders request_headers, response_headers;
158 string file_contents;
159 base::ReadFileToString(file, &file_contents);
161 // Frame HTTP.
162 CachingBalsaVisitor caching_visitor;
163 BalsaFrame framer;
164 framer.set_balsa_headers(&response_headers);
165 framer.set_balsa_visitor(&caching_visitor);
166 size_t processed = 0;
167 while (processed < file_contents.length() &&
168 !caching_visitor.done_framing()) {
169 processed += framer.ProcessInput(file_contents.c_str() + processed,
170 file_contents.length() - processed);
173 if (!caching_visitor.done_framing()) {
174 LOG(DFATAL) << "Did not frame entire message from file: " << file.value()
175 << " (" << processed << " of " << file_contents.length()
176 << " bytes).";
178 if (processed < file_contents.length()) {
179 // Didn't frame whole file. Assume remainder is body.
180 // This sometimes happens as a result of incompatibilities between
181 // BalsaFramer and wget's serialization of HTTP sans content-length.
182 caching_visitor.AppendToBody(file_contents.c_str() + processed,
183 file_contents.length() - processed);
184 processed += file_contents.length();
187 StringPiece base = file.value();
188 if (response_headers.HasHeader("X-Original-Url")) {
189 base = response_headers.GetHeader("X-Original-Url");
190 response_headers.RemoveAllOfHeader("X-Original-Url");
191 // Remove the protocol so that the string is of the form host + path,
192 // which is parsed properly below.
193 if (StringPieceUtils::StartsWithIgnoreCase(base, "https://")) {
194 base.remove_prefix(8);
195 } else if (StringPieceUtils::StartsWithIgnoreCase(base, "http://")) {
196 base.remove_prefix(7);
199 int path_start = base.find_first_of('/');
200 DCHECK_LT(0, path_start);
201 StringPiece host(base.substr(0, path_start));
202 StringPiece path(base.substr(path_start));
203 if (path[path.length() - 1] == ',') {
204 path.remove_suffix(1);
206 // Set up request headers. Assume method is GET and protocol is HTTP/1.1.
207 request_headers.SetRequestFirstlineFromStringPieces("GET",
208 path,
209 "HTTP/1.1");
210 request_headers.ReplaceOrAppendHeader("host", host);
212 VLOG(1) << "Inserting 'http://" << GetKey(request_headers)
213 << "' into QuicInMemoryCache.";
215 AddResponse(request_headers, response_headers, caching_visitor.body());
217 file = file_list.Next();
221 QuicInMemoryCache::~QuicInMemoryCache() {
222 STLDeleteValues(&responses_);
225 string QuicInMemoryCache::GetKey(const BalsaHeaders& request_headers) const {
226 StringPiece uri = request_headers.request_uri();
227 if (uri.size() == 0) {
228 return "";
230 StringPiece host;
231 if (uri[0] == '/') {
232 host = request_headers.GetHeader("host");
233 } else if (StringPieceUtils::StartsWithIgnoreCase(uri, "https://")) {
234 uri.remove_prefix(8);
235 } else if (StringPieceUtils::StartsWithIgnoreCase(uri, "http://")) {
236 uri.remove_prefix(7);
238 return host.as_string() + uri.as_string();
241 } // namespace tools
242 } // namespace net