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"
@@ skipping 10 matching lines @@
 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<AutofillFieldInfo>* 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 26 matching lines @@
       // 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();
+    std::string default_value;
 
     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;
       }
     }
 
-    // Record this field type.
-    field_types_->push_back(field_type);
+    // If default value is specified in the response, extract it.
+    if (field_type == FIELD_WITH_DEFAULT_VALUE && attrs[2]) {

[Albert Bodenhamer, 2012/11/30 19:01:08]

As the list of attributes gets longer the magic numbers for indexing |attrs|
become less clear.

Consider creating a enum for this?

[Raman Kakilate, 2012/11/30 22:36:53]

ATTRIBUTE_1_NAME, ATTRIBUTE_1_VALUE, ATTRIBUTE_2_NAME, ATTRIBUTE_2_VALUE are the
names I could come up with and I am not liking them.

[Ilya Sherman, 2012/12/01 00:54:12]

How about names like ATTRIBUTE_NAME_DEFAULT_FIELD_VALUE,
ATTRIBUTE_VALUE_DEFAULT_FIELD_VALUE?

[Raman Kakilate, 2012/12/06 01:54:05]

changed the implementation to loop over attribute and value pairs. Similar to
how we do for upload element.

+      buzz::QName attrib_qname = context->ResolveQName(attrs[2], true);
+      const std::string& attrib = attrib_qname.LocalPart();
+      if (attrib.compare("defaultvalue") == 0) {
+        default_value.assign(attrs[3]);
+      }
+    }
+
+    // Record this field type, default value pair.
+    field_infos_->push_back(AutofillFieldInfo(field_type, default_value));
   }
 }
 
 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;
 }