Fix "unreachable code" warnings (MSVC warning 4702) in net/.

net/http/http_util.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 parsing content-types were borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_util.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 
-using std::string;

[Peter Kasting, 2014/03/18 03:02:51]

(Much of the file already used std:: explicitly, so I just made the rest
consistent.)

 
 namespace net {
 
-//-----------------------------------------------------------------------------
+// Helpers --------------------------------------------------------------------
 
-// Return the index of the closing quote of the string, if any.
-static size_t FindStringEnd(const string& line, size_t start, char delim) {
-  DCHECK(start < line.length() && line[start] == delim &&
-         (delim == '"' || delim == '\''));
+// Returns the index of the closing quote of the string, if any.  |start| points
+// at the opening quote.
+static size_t FindStringEnd(const std::string& line, size_t start, char delim) {
+  DCHECK_LT(start, line.length());
+  DCHECK_EQ(line[start], delim);
+  DCHECK((delim == '"') || (delim == '\''));
 
   const char set[] = { delim, '\\', '\0' };
-  for (;;) {
-    // start points to either the start quote or the last
-    // escaped char (the char following a '\\')
-
-    size_t end = line.find_first_of(set, start + 1);
-    if (end == string::npos)
-      return line.length();
-
-    if (line[end] == '\\') {
-      // Hit a backslash-escaped char.  Need to skip over it.
-      start = end + 1;
-      if (start == line.length())
-        return start;
-
-      // Go back to looking for the next escape or the string end
-      continue;
-    }
-
-    return end;
+  for (size_t end = line.find_first_of(set, start + 1);
+       end != std::string::npos; end = line.find_first_of(set, end + 2)) {

[Peter Kasting, 2014/03/18 03:02:51]

(This line relies on the fact that find_first_of() can take an offset beyond the
end of the string, and is guaranteed to return npos in that case.)

+    if (line[end] != '\\')
+      return end;
   }
-
-  NOTREACHED();
   return line.length();
 }
 
-//-----------------------------------------------------------------------------
+
+// HttpUtil -------------------------------------------------------------------
 
 // static
-size_t HttpUtil::FindDelimiter(const string& line, size_t search_start,
+size_t HttpUtil::FindDelimiter(const std::string& line,
+                               size_t search_start,
                                char delimiter) {
   do {
     // search_start points to the spot from which we should start looking
     // for the delimiter.
     const char delim_str[] = { delimiter, '"', '\'', '\0' };
     size_t cur_delim_pos = line.find_first_of(delim_str, search_start);
-    if (cur_delim_pos == string::npos)
+    if (cur_delim_pos == std::string::npos)
       return line.length();
 
     char ch = line[cur_delim_pos];
     if (ch == delimiter) {
       // Found delimiter
       return cur_delim_pos;
     }
 
     // We hit the start of a quoted string.  Look for its end.
     search_start = FindStringEnd(line, cur_delim_pos, ch);
     if (search_start == line.length())
       return search_start;
 
     ++search_start;
 
     // search_start now points to the first char after the end of the
     // string, so just go back to the top of the loop and look for
     // |delimiter| again.
   } while (true);
 
   NOTREACHED();
   return line.length();
 }
 
 // static
-void HttpUtil::ParseContentType(const string& content_type_str,
-                                string* mime_type,
-                                string* charset,
+void HttpUtil::ParseContentType(const std::string& content_type_str,
+                                std::string* mime_type,
+                                std::string* charset,
                                 bool* had_charset,
-                                string* boundary) {
-  const string::const_iterator begin = content_type_str.begin();
+                                std::string* boundary) {
+  const std::string::const_iterator begin = content_type_str.begin();
 
   // Trim leading and trailing whitespace from type.  We include '(' in
   // the trailing trim set to catch media-type comments, which are not at all
   // standard, but may occur in rare cases.
   size_t type_val = content_type_str.find_first_not_of(HTTP_LWS);
   type_val = std::min(type_val, content_type_str.length());
   size_t type_end = content_type_str.find_first_of(HTTP_LWS ";(", type_val);
-  if (string::npos == type_end)
+  if (type_end == std::string::npos)
     type_end = content_type_str.length();
 
   size_t charset_val = 0;
   size_t charset_end = 0;
   bool type_has_charset = false;
 
   // Iterate over parameters
   size_t param_start = content_type_str.find_first_of(';', type_end);
-  if (param_start != string::npos) {
+  if (param_start != std::string::npos) {
     base::StringTokenizer tokenizer(begin + param_start, content_type_str.end(),
                                     ";");
     tokenizer.set_quote_chars("\"");
     while (tokenizer.GetNext()) {
-      string::const_iterator equals_sign =
+      std::string::const_iterator equals_sign =
           std::find(tokenizer.token_begin(), tokenizer.token_end(), '=');
       if (equals_sign == tokenizer.token_end())
         continue;
 
-      string::const_iterator param_name_begin = tokenizer.token_begin();
-      string::const_iterator param_name_end = equals_sign;
+      std::string::const_iterator param_name_begin = tokenizer.token_begin();
+      std::string::const_iterator param_name_end = equals_sign;
       TrimLWS(&param_name_begin, &param_name_end);
 
-      string::const_iterator param_value_begin = equals_sign + 1;
-      string::const_iterator param_value_end = tokenizer.token_end();
+      std::string::const_iterator param_value_begin = equals_sign + 1;
+      std::string::const_iterator param_value_end = tokenizer.token_end();
       DCHECK(param_value_begin <= tokenizer.token_end());
       TrimLWS(&param_value_begin, &param_value_end);
 
       if (LowerCaseEqualsASCII(param_name_begin, param_name_end, "charset")) {
         // TODO(abarth): Refactor this function to consistently use iterators.
         charset_val = param_value_begin - begin;
         charset_end = param_value_end - begin;
         type_has_charset = true;
       } else if (LowerCaseEqualsASCII(param_name_begin, param_name_end,
                                       "boundary")) {
@@ skipping 23 matching lines @@
 
   // if the server sent "*/*", it is meaningless, so do not store it.
   // also, if type_val is the same as mime_type, then just update the
   // charset.  however, if charset is empty and mime_type hasn't
   // changed, then don't wipe-out an existing charset.  We
   // also want to reject a mime-type if it does not include a slash.
   // some servers give junk after the charset parameter, which may
   // include a comma, so this check makes us a bit more tolerant.
   if (content_type_str.length() != 0 &&
       content_type_str != "*/*" &&
-      content_type_str.find_first_of('/') != string::npos) {
+      content_type_str.find_first_of('/') != std::string::npos) {
     // Common case here is that mime_type is empty
     bool eq = !mime_type->empty() && LowerCaseEqualsASCII(begin + type_val,
                                                           begin + type_end,
                                                           mime_type->data());
     if (!eq) {
       mime_type->assign(begin + type_val, begin + type_end);
       StringToLowerASCII(mime_type);
     }
     if ((!eq && *had_charset) || type_has_charset) {
       *had_charset = true;
@@ skipping 98 matching lines @@
     if (!range.IsValid())
       return false;
     ranges->push_back(range);
   }
   return !ranges->empty();
 }
 
 // static
 bool HttpUtil::HasHeader(const std::string& headers, const char* name) {
   size_t name_len = strlen(name);
-  string::const_iterator it =
+  std::string::const_iterator it =
       std::search(headers.begin(),
                   headers.end(),
                   name,
                   name + name_len,
                   base::CaseInsensitiveCompareASCII<char>());
   if (it == headers.end())
     return false;
 
   // ensure match is prefixed by newline
   if (it != headers.begin() && it[-1] != '\n')
@@ skipping 67 matching lines @@
     if (!should_remove) {
       // Assume that name and values are on the same line.
       stripped_headers.append(it.name_begin(), it.values_end());
       stripped_headers.append("\r\n");
     }
   }
   return stripped_headers;
 }
 
 // static
-bool HttpUtil::IsNonCoalescingHeader(string::const_iterator name_begin,
-                                     string::const_iterator name_end) {
+bool HttpUtil::IsNonCoalescingHeader(std::string::const_iterator name_begin,
+                                     std::string::const_iterator name_end) {
   // NOTE: "set-cookie2" headers do not support expires attributes, so we don't
   // have to list them here.
   const char* kNonCoalescingHeaders[] = {
     "date",
     "expires",
     "last-modified",
     "location",  // See bug 1050541 for details
     "retry-after",
     "set-cookie",
     // The format of auth-challenges mixes both space separated tokens and
     // comma separated properties, so coalescing on comma won't work.
     "www-authenticate",
     "proxy-authenticate",
     // STS specifies that UAs must not process any STS headers after the first
     // one.
     "strict-transport-security"
   };
   for (size_t i = 0; i < arraysize(kNonCoalescingHeaders); ++i) {
     if (LowerCaseEqualsASCII(name_begin, name_end, kNonCoalescingHeaders[i]))
       return true;
   }
   return false;
 }
 
 bool HttpUtil::IsLWS(char c) {
   return strchr(HTTP_LWS, c) != NULL;
 }
 
-void HttpUtil::TrimLWS(string::const_iterator* begin,
-                       string::const_iterator* end) {
+void HttpUtil::TrimLWS(std::string::const_iterator* begin,
+                       std::string::const_iterator* end) {
   // leading whitespace
   while (*begin < *end && IsLWS((*begin)[0]))
     ++(*begin);
 
   // trailing whitespace
   while (*begin < *end && IsLWS((*end)[-1]))
     --(*end);
 }
 
 bool HttpUtil::IsQuote(char c) {
   // Single quote mark isn't actually part of quoted-text production,
   // but apparently some servers rely on this.
   return c == '"' || c == '\'';
 }
 
 // See RFC 2616 Sec 2.2 for the definition of |token|.
-bool HttpUtil::IsToken(string::const_iterator begin,
-                       string::const_iterator end) {
+bool HttpUtil::IsToken(std::string::const_iterator begin,
+                       std::string::const_iterator end) {
   if (begin == end)
     return false;
   for (std::string::const_iterator iter = begin; iter != end; ++iter) {
     unsigned char c = *iter;
     if (c >= 0x80 || c <= 0x1F || c == 0x7F ||
         c == '(' || c == ')' || c == '<' || c == '>' || c == '@' ||
         c == ',' || c == ';' || c == ':' || c == '\\' || c == '"' ||
         c == '/' || c == '[' || c == ']' || c == '?' || c == '=' ||
         c == '{' || c == '}' || c == ' ' || c == '\t')
       return false;
@@ skipping 315 matching lines @@
 // BNF from section 4.2 of RFC 2616:
 //
 //   message-header = field-name ":" [ field-value ]
 //   field-name     = token
 //   field-value    = *( field-content | LWS )
 //   field-content  = <the OCTETs making up the field-value
 //                     and consisting of either *TEXT or combinations
 //                     of token, separators, and quoted-string>
 //
 
-HttpUtil::HeadersIterator::HeadersIterator(string::const_iterator headers_begin,
-                                           string::const_iterator headers_end,
-                                           const std::string& line_delimiter)
+HttpUtil::HeadersIterator::HeadersIterator(
+    std::string::const_iterator headers_begin,
+    std::string::const_iterator headers_end,
+    const std::string& line_delimiter)
     : lines_(headers_begin, headers_end, line_delimiter) {
 }
 
 HttpUtil::HeadersIterator::~HeadersIterator() {
 }
 
 bool HttpUtil::HeadersIterator::GetNext() {
   while (lines_.GetNext()) {
     name_begin_ = lines_.token_begin();
     values_end_ = lines_.token_end();
 
-    string::const_iterator colon = std::find(name_begin_, values_end_, ':');
+    std::string::const_iterator colon(std::find(name_begin_, values_end_, ':'));
     if (colon == values_end_)
       continue;  // skip malformed header
 
     name_end_ = colon;
 
     // If the name starts with LWS, it is an invalid line.
     // Leading LWS implies a line continuation, and these should have
     // already been joined by AssembleRawHeaders().
     if (name_begin_ == name_end_ || IsLWS(*name_begin_))
       continue;
@@ skipping 19 matching lines @@
   while (GetNext()) {
     if (LowerCaseEqualsASCII(name_begin_, name_end_, name)) {
       return true;
     }
   }
 
   return false;
 }
 
 HttpUtil::ValuesIterator::ValuesIterator(
-    string::const_iterator values_begin,
-    string::const_iterator values_end,
+    std::string::const_iterator values_begin,
+    std::string::const_iterator values_end,
     char delimiter)
-    : values_(values_begin, values_end, string(1, delimiter)) {
+    : values_(values_begin, values_end, std::string(1, delimiter)) {
   values_.set_quote_chars("\'\"");
 }
 
 HttpUtil::ValuesIterator::~ValuesIterator() {
 }
 
 bool HttpUtil::ValuesIterator::GetNext() {
   while (values_.GetNext()) {
     value_begin_ = values_.token_begin();
     value_end_ = values_.token_end();
     TrimLWS(&value_begin_, &value_end_);
 
     // bypass empty values.
     if (value_begin_ != value_end_)
       return true;
   }
   return false;
 }
 
 HttpUtil::NameValuePairsIterator::NameValuePairsIterator(
-    string::const_iterator begin,
-    string::const_iterator end,
+    std::string::const_iterator begin,
+    std::string::const_iterator end,
     char delimiter)
     : props_(begin, end, delimiter),
       valid_(true),
       name_begin_(end),
       name_end_(end),
       value_begin_(end),
       value_end_(end),
       value_is_quoted_(false) {
 }
 
@@ skipping 54 matching lines @@
       value_is_quoted_ = true;
       // Do not store iterators into this. See declaration of unquoted_value_.
       unquoted_value_ = HttpUtil::Unquote(value_begin_, value_end_);
     }
   }
 
   return true;
 }
 
 }  // namespace net