Use mojo for Chrome Loading, Part 1

net/http/http_response_headers.cc

 // 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.
 
 // The rules for header parsing were borrowed from Firefox:
 // http://lxr.mozilla.org/seamonkey/source/netwerk/protocol/http/src/nsHttpResponseHead.cpp
 // The rules for parsing content-types were also borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_response_headers.h"
@@ skipping 150 matching lines @@
 HttpResponseHeaders::HttpResponseHeaders(base::PickleIterator* iter)
     : response_code_(-1) {
   std::string raw_input;
   if (iter->ReadString(&raw_input))
     Parse(raw_input);
 }
 
 void HttpResponseHeaders::Persist(base::Pickle* pickle,
                                   PersistOptions options) {
   if (options == PERSIST_RAW) {
+    // To avoid unnecessary copy, we don't call PersistTo here.
     pickle->WriteString(raw_headers_);
     return;  // Done.
   }
+  std::string blob;
+  PersistTo(options, &blob);
+  pickle->WriteString(blob);
+}
+
+void HttpResponseHeaders::PersistTo(PersistOptions options,
+                                    std::string* output) {
+  if (options == PERSIST_RAW) {
+    *output = raw_headers_;
+    return;  // Done.
+  }
 
   HeaderSet filter_headers;
 
   // Construct set of headers to filter out based on options.
   if ((options & PERSIST_SANS_NON_CACHEABLE) == PERSIST_SANS_NON_CACHEABLE)
     AddNonCacheableHeaders(&filter_headers);
 
   if ((options & PERSIST_SANS_COOKIES) == PERSIST_SANS_COOKIES)
     AddCookieHeaders(&filter_headers);
 
   if ((options & PERSIST_SANS_CHALLENGES) == PERSIST_SANS_CHALLENGES)
     AddChallengeHeaders(&filter_headers);
 
   if ((options & PERSIST_SANS_HOP_BY_HOP) == PERSIST_SANS_HOP_BY_HOP)
     AddHopByHopHeaders(&filter_headers);
 
   if ((options & PERSIST_SANS_RANGES) == PERSIST_SANS_RANGES)
     AddHopContentRangeHeaders(&filter_headers);
 
   if ((options & PERSIST_SANS_SECURITY_STATE) == PERSIST_SANS_SECURITY_STATE)
     AddSecurityStateHeaders(&filter_headers);
 
-  std::string blob;
-  blob.reserve(raw_headers_.size());
+  output->clear();
+  output->reserve(raw_headers_.size());
 
   // This copies the status line w/ terminator null.
   // Note raw_headers_ has embedded nulls instead of \n,
   // so this just copies the first header line.
-  blob.assign(raw_headers_.c_str(), strlen(raw_headers_.c_str()) + 1);
+  output->assign(raw_headers_.c_str(), strlen(raw_headers_.c_str()) + 1);
 
   for (size_t i = 0; i < parsed_.size(); ++i) {
     DCHECK(!parsed_[i].is_continuation());
 
     // Locate the start of the next header.
     size_t k = i;
     while (++k < parsed_.size() && parsed_[k].is_continuation()) {}
     --k;
 
     std::string header_name = base::ToLowerASCII(
         base::StringPiece(parsed_[i].name_begin, parsed_[i].name_end));
     if (filter_headers.find(header_name) == filter_headers.end()) {
       // Make sure there is a null after the value.
-      blob.append(parsed_[i].name_begin, parsed_[k].value_end);
-      blob.push_back('\0');
+      output->append(parsed_[i].name_begin, parsed_[k].value_end);
+      output->push_back('\0');
     }
 
     i = k;
   }
-  blob.push_back('\0');
-
-  pickle->WriteString(blob);
+  output->push_back('\0');
 }
 
 void HttpResponseHeaders::Update(const HttpResponseHeaders& new_headers) {
   DCHECK(new_headers.response_code() == 304 ||
          new_headers.response_code() == 206);
 
   // Copy up to the null byte.  This just copies the status line.
   std::string new_raw_headers(raw_headers_.c_str());
   new_raw_headers.push_back('\0');
 
@@ skipping 1230 matching lines @@
   return true;
 }
 
 bool HttpResponseHeaders::IsChunkEncoded() const {
   // Ignore spurious chunked responses from HTTP/1.0 servers and proxies.
   return GetHttpVersion() >= HttpVersion(1, 1) &&
       HasHeaderValue("Transfer-Encoding", "chunked");
 }
 
 }  // namespace net