Add support for autofilling radio buttons and checkboxes.

chrome/browser/autofill/autofill_xml_parser.cc

 // Copyright (c) 2011 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.
 
 #include "chrome/browser/autofill/autofill_xml_parser.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "base/logging.h"
+#include "chrome/browser/autofill/autofill_server_field_info.h"
 #include "third_party/libjingle/source/talk/xmllite/qname.h"
 
 AutofillXmlParser::AutofillXmlParser()
     : succeeded_(true) {
 }
 
 void AutofillXmlParser::CharacterData(
     buzz::XmlParseContext* context, const char* text, int len) {
 }
 
 void AutofillXmlParser::EndElement(buzz::XmlParseContext* context,
                                    const char* name) {
 }
 
 void AutofillXmlParser::Error(buzz::XmlParseContext* context,
                               XML_Error error_code) {
   succeeded_ = false;
 }
 
 AutofillQueryXmlParser::AutofillQueryXmlParser(
-    std::vector<AutofillFieldType>* field_types,
+    std::vector<AutofillServerFieldInfo>* field_infos,
     UploadRequired* upload_required,
     std::string* experiment_id)
-    : field_types_(field_types),
+    : field_infos_(field_infos),
       upload_required_(upload_required),
       experiment_id_(experiment_id) {
   DCHECK(upload_required_);
   DCHECK(experiment_id_);
 }
 
 void AutofillQueryXmlParser::StartElement(buzz::XmlParseContext* context,
                                           const char* name,
                                           const char** attrs) {
   buzz::QName qname = context->ResolveQName(name, false);
@@ skipping 23 matching lines @@
     }
   } else if (element.compare("field") == 0) {
     if (!attrs[0]) {
       // Missing the "autofilltype" attribute, abort.
       context->RaiseError(XML_ERROR_ABORTED);
       return;
     }
 
     // Determine the field type from the attribute value.  There should be one
     // attribute (autofilltype) with an integer value.
-    AutofillFieldType field_type = UNKNOWN_TYPE;
-    buzz::QName attribute_qname = context->ResolveQName(attrs[0], true);
-    const std::string& attribute_name = attribute_qname.LocalPart();
+    AutofillServerFieldInfo field_info;
+    field_info.field_type = UNKNOWN_TYPE;
 
-    if (attribute_name.compare("autofilltype") == 0) {
-      int value = GetIntValue(context, attrs[1]);
-      field_type = static_cast<AutofillFieldType>(value);
-      if (field_type < 0 || field_type > MAX_VALID_FIELD_TYPE) {
-        field_type = NO_SERVER_DATA;
+    while (*attrs) {
+      buzz::QName attribute_qname = context->ResolveQName(attrs[0], true);
+      const std::string& attribute_name = attribute_qname.LocalPart();
+      if (attribute_name.compare("autofilltype") == 0) {
+        int value = GetIntValue(context, attrs[1]);
+        field_info.field_type = static_cast<AutofillFieldType>(value);
+        if (field_info.field_type < 0 ||
+            field_info.field_type > MAX_VALID_FIELD_TYPE)
+          field_info.field_type = NO_SERVER_DATA;
+      } else if (field_info.field_type == FIELD_WITH_DEFAULT_VALUE &&
+                 attribute_name.compare("defaultvalue") == 0) {
+        field_info.default_value.assign(attrs[1]);
       }
+
+      attrs +=2;

[Albert Bodenhamer, 2012/12/06 17:39:05]

This is awkward.

If you're going to do C-style pointer math you should use it consistently and
not mix with array-dereference (attrs[1]) syntax.

Generally, I prefer array syntax for readability.  I'd be ok with either, but
not both.

The cleanest approach would be to look into replacing char** with something more
structured, but that's probably overkill for this CL.

[Raman Kakilate, 2012/12/06 18:06:35]

I was trying to be consistent with lines 55-69. I would have to change those
lines as well. 

array syntax is more rigid towards order of attributes specified in XML element 
(autofillqueryresponse element might have its attributes specified in different
order).

I can change them all to c-style pointer math if you agree. 

[Albert Bodenhamer, 2012/12/06 23:15:45]

I was thinking more like:
  while (*attrs) {
      buzz::QName attribute_qname = context->ResolveQName(*attrs, true);
      const std::string& attribute_name = attribute_qname.LocalPart();
      attrs++;
      if (attribute_name.compare("autofilltype") == 0) {
        int value = GetIntValue(context, *attrs);
        field_info.field_type = static_cast<AutofillFieldType>(value);
        if (field_info.field_type < 0 ||
            field_info.field_type > MAX_VALID_FIELD_TYPE)
          field_info.field_type = NO_SERVER_DATA;
      } else if (field_info.field_type == FIELD_WITH_DEFAULT_VALUE &&
                 attribute_name.compare("defaultvalue") == 0) {
        field_info.default_value.assign(*attrs);
      }

      attrs++;
    }

     }
 
-    // Record this field type.
-    field_types_->push_back(field_type);
+    // Record this field type, default value pair.
+    field_infos_->push_back(field_info);
   }
 }
 
 int AutofillQueryXmlParser::GetIntValue(buzz::XmlParseContext* context,
                                         const char* attribute) {
   char* attr_end = NULL;
   int value = strtol(attribute, &attr_end, 10);
   if (attr_end != NULL && attr_end == attribute) {
     context->RaiseError(XML_ERROR_SYNTAX);
     return 0;
@@ skipping 33 matching lines @@
 double AutofillUploadXmlParser::GetDoubleValue(buzz::XmlParseContext* context,
                                                const char* attribute) {
   char* attr_end = NULL;
   double value = strtod(attribute, &attr_end);
   if (attr_end != NULL && attr_end == attribute) {
     context->RaiseError(XML_ERROR_SYNTAX);
     return 0.0;
   }
   return value;
 }