Remove use of void** from HttpResponseHeaders::EnumerateHeaderLines

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 295 matching lines @@
 
 void HttpResponseHeaders::RemoveHeaderLine(const std::string& name,
                                            const std::string& value) {
   std::string name_lowercase = base::ToLowerASCII(name);
 
   std::string new_raw_headers(GetStatusLine());
   new_raw_headers.push_back('\0');
 
   new_raw_headers.reserve(raw_headers_.size());
 
-  void* iter = NULL;
+  size_t iter = 0;
   std::string old_header_name;
   std::string old_header_value;
-  while (EnumerateHeaderLines(&iter, &old_header_name, &old_header_value)) {
+  while (EnumerateHeaderLines(iter, &old_header_name, &old_header_value)) {
     std::string old_header_name_lowercase = base::ToLowerASCII(old_header_name);
     if (name_lowercase == old_header_name_lowercase &&
         value == old_header_value)
       continue;
 
     new_raw_headers.append(old_header_name);
     new_raw_headers.push_back(':');
     new_raw_headers.push_back(' ');
     new_raw_headers.append(old_header_value);
     new_raw_headers.push_back('\0');
@@ skipping 212 matching lines @@
   CHECK(begin != end);
   // See if there is another space.
   begin = std::find(begin, end, ' ');
   if (begin == end)
     return std::string();
   ++begin;
   CHECK(begin != end);
   return std::string(begin, end);
 }
 
-bool HttpResponseHeaders::EnumerateHeaderLines(void** iter,
+bool HttpResponseHeaders::EnumerateHeaderLines(size_t& i,
                                                std::string* name,
                                                std::string* value) const {
-  size_t i = reinterpret_cast<size_t>(*iter);
   if (i == parsed_.size())
     return false;
 
   DCHECK(!parsed_[i].is_continuation());
 
   name->assign(parsed_[i].name_begin, parsed_[i].name_end);
 
   std::string::const_iterator value_begin = parsed_[i].value_begin;
   std::string::const_iterator value_end = parsed_[i].value_end;
   while (++i < parsed_.size() && parsed_[i].is_continuation())
     value_end = parsed_[i].value_end;
 
   value->assign(value_begin, value_end);
 
-  *iter = reinterpret_cast<void*>(i);
   return true;
 }
 
 bool HttpResponseHeaders::EnumerateHeader(void** iter,
                                           const base::StringPiece& name,
                                           std::string* value) const {
   size_t i;
   if (!iter || !*iter) {
     i = FindHeader(0, name);
   } else {
@@ skipping 806 matching lines @@
     return false;
 
   return true;
 }
 
 scoped_ptr<base::Value> HttpResponseHeaders::NetLogCallback(
     NetLogCaptureMode capture_mode) const {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   base::ListValue* headers = new base::ListValue();
   headers->Append(new base::StringValue(GetStatusLine()));
-  void* iterator = NULL;
+  size_t iterator = 0;
   std::string name;
   std::string value;
-  while (EnumerateHeaderLines(&iterator, &name, &value)) {
+  while (EnumerateHeaderLines(iterator, &name, &value)) {
     std::string log_value =
         ElideHeaderValueForNetLog(capture_mode, name, value);
     std::string escaped_name = EscapeNonASCII(name);
     std::string escaped_value = EscapeNonASCII(log_value);
     headers->Append(
       new base::StringValue(
           base::StringPrintf("%s: %s", escaped_name.c_str(),
                              escaped_value.c_str())));
   }
   dict->Set("headers", headers);
@@ skipping 31 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