Add q-values to languages in Accept-Language HTTP header to be compatible wit...

net/http/http_util.cc

 // Copyright (c) 2006-2008 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>
@@ skipping 39 matching lines @@
   return line.length();
 }
 
 //-----------------------------------------------------------------------------
 
 // static
 std::string HttpUtil::PathForRequest(const GURL& url) {
   DCHECK(url.is_valid() && (url.SchemeIs("http") || url.SchemeIs("https")));
   if (url.has_query())
     return url.path() + "?" + url.query();
-  return url.path(); 
+  return url.path();
 }
 
 // static
 std::string HttpUtil::SpecForRequest(const GURL& url) {
   DCHECK(url.is_valid() && (url.SchemeIs("http") || url.SchemeIs("https")));
   GURL::Replacements replacements;
   replacements.ClearUsername();
   replacements.ClearPassword();
   replacements.ClearRef();
   return url.ReplaceComponents(replacements).spec();
@@ skipping 352 matching lines @@
 
   // TODO(ericroman): is this too permissive? (delimits on [\r\n]+)
   CStringTokenizer lines(status_line_end, input_end, "\r\n");
 
   // This variable is true when the previous line was continuable.
   bool prev_line_continuable = false;
 
   while (lines.GetNext()) {
     const char* line_begin = lines.token_begin();
     const char* line_end = lines.token_end();
-     
+
     if (prev_line_continuable && IsLWS(*line_begin)) {
       // Join continuation; reduce the leading LWS to a single SP.
       raw_headers.push_back(' ');
       raw_headers.append(FindFirstNonLWS(line_begin, line_end), line_end);
     } else {
       // Terminate the previous line.
       raw_headers.push_back('\0');
 
       // Copy the raw data to output.
       raw_headers.append(line_begin, line_end);
 
       // Check if the current line can be continued.
       prev_line_continuable = IsLineSegmentContinuable(line_begin, line_end);
     }
   }
 
   raw_headers.append("\0\0", 2);
   return raw_headers;
 }
 
+// TODO(jungshik): 1. If the list is 'fr-CA,fr-FR,en,de', we have to add
+// 'fr' after 'fr-CA' with the same q-value as 'fr-CA' because
+// web servers, in general, do not fall back to 'fr' and may end up picking
+// 'en' which has a lower preference than 'fr-CA' and 'fr-FR'.
+// 2. This function assumes that the input is a comma separated list
+// without any whitespace. As long as it comes from the preference and
+// a user does not manually edit the preference file, it's the case. Still,
+// we may have to make it more robust.
+std::string HttpUtil::GenerateAcceptLanguageHeader(
+    const std::string& raw_language_list) {
+  // We use integers for qvalue and qvalue decrement that are 10 times
+  // larger than actual values to avoid a problem with comparing
+  // two floating point numbers.
+  const unsigned int kQvalueDecrement10 = 2;
+  unsigned int qvalue10 = 10;
+  StringTokenizer t(raw_language_list, ",");
+  std::string lang_list_with_q;
+  while (t.GetNext()) {
+    std::string language = t.token();
+    if (qvalue10 == 10) {
+      // q=1.0 is implicit.
+      lang_list_with_q = language;
+    } else {
+      DCHECK(qvalue10 >= 0 && qvalue10 < 10);
+      StringAppendF(&lang_list_with_q, ",%s;q=0.%d", language.c_str(),
+                    qvalue10);
+    }
+    // It does not make sense to have 'q=0'.
+    if (qvalue10 > kQvalueDecrement10)
+      qvalue10 -= kQvalueDecrement10;
+  }
+  return lang_list_with_q;
+}
+
+std::string HttpUtil::GenerateAcceptCharsetHeader(const std::string& charset) {
+  std::string charset_with_q = charset;
+  if (LowerCaseEqualsASCII(charset, "utf-8")) {
+    charset_with_q += ",*;q=0.5";
+  } else {
+    charset_with_q += ",utf-8;q=0.7,*;q=0.3";
+  }
+  return charset_with_q;
+}
+
 // 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>
 //
 
@@ skipping 49 matching lines @@
 
     // bypass empty values.
     if (value_begin_ != value_end_)
       return true;
   }
   return false;
 }
 
 }  // namespace net