Import keywords for search engines imported from Firefox

components/search_engines/template_url_parser.cc

 // Copyright 2014 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 "components/search_engines/template_url_parser.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 16 matching lines @@
 // having to convert to wide, then do comparisons.
 
 // Defines for element names of the OSD document:
 const char kURLElement[] = "Url";
 const char kParamElement[] = "Param";
 const char kShortNameElement[] = "ShortName";
 const char kImageElement[] = "Image";
 const char kOpenSearchDescriptionElement[] = "OpenSearchDescription";
 const char kFirefoxSearchDescriptionElement[] = "SearchPlugin";
 const char kInputEncodingElement[] = "InputEncoding";
+const char kAliasElement[] = "Alias";
 
 // Various XML attributes used.
 const char kURLTypeAttribute[] = "type";
 const char kURLTemplateAttribute[] = "template";
 const char kImageTypeAttribute[] = "type";
 const char kImageWidthAttribute[] = "width";
 const char kImageHeightAttribute[] = "height";
 const char kParamNameAttribute[] = "name";
 const char kParamValueAttribute[] = "value";
 const char kParamMethodAttribute[] = "method";
@@ skipping 61 matching lines @@
  public:
   // Enum of the known element types.
   enum ElementType {
     UNKNOWN,
     OPEN_SEARCH_DESCRIPTION,
     URL,
     PARAM,
     SHORT_NAME,
     IMAGE,
     INPUT_ENCODING,
+    ALIAS,
   };
 
   enum Method {
     GET,
     POST
   };
 
   // Key/value of a Param node.
   typedef std::pair<std::string, std::string> Param;
 
@@ skipping 45 matching lines @@
   std::vector<Param> extra_params_;
 
   // The HTTP methods used.
   Method method_;
   Method suggestion_method_;
 
   // If true, we are currently parsing a suggest URL, otherwise it is an HTML
   // search.  Note that we don't need a stack as URL nodes cannot be nested.
   bool is_suggest_url_;
 
+  // If true, the user has set a keyword and we should use it. Otherwise,
+  // we generate a keyword based on the URL.
+  bool has_custom_keyword_;
+
   // Whether we should derive the image from the URL (when images are data
   // URLs).
   bool derive_image_from_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLParsingContext);
 };
 
 // static
 TemplateURLParsingContext::ElementNameToElementTypeMap*
     TemplateURLParsingContext::kElementNameToElementTypeMap = NULL;
 
 TemplateURLParsingContext::TemplateURLParsingContext(
     TemplateURLParser::ParameterFilter* parameter_filter)
     : image_is_valid_for_favicon_(false),
       parameter_filter_(parameter_filter),
       method_(GET),
       suggestion_method_(GET),
       is_suggest_url_(false),
+      has_custom_keyword_(false),
       derive_image_from_url_(false) {
   if (kElementNameToElementTypeMap == NULL)
     InitMapping();
 }
 
 // static
 void TemplateURLParsingContext::StartElementImpl(void* ctx,
                                                  const xmlChar* name,
                                                  const xmlChar** atts) {
   // Remove the namespace from |name|, ex: os:Url -> Url.
@@ skipping 22 matching lines @@
       break;
   }
   context->string_.clear();
 }
 
 // static
 void TemplateURLParsingContext::EndElementImpl(void* ctx, const xmlChar* name) {
   TemplateURLParsingContext* context =
       reinterpret_cast<TemplateURLParsingContext*>(ctx);
   switch (context->GetKnownType()) {
+    case TemplateURLParsingContext::URL:
+      context->ProcessURLParams();
+      break;
     case TemplateURLParsingContext::SHORT_NAME:
       context->data_.short_name = context->string_;
       break;
     case TemplateURLParsingContext::IMAGE: {
       GURL image_url(base::UTF16ToUTF8(context->string_));
       if (image_url.SchemeIs(url::kDataScheme)) {
         // TODO (jcampan): bug 1169256: when dealing with data URL, we need to
         // decode the data URL in the renderer. For now, we'll just point to the
         // favicon from the URL.
         context->derive_image_from_url_ = true;
       } else if (context->image_is_valid_for_favicon_ && image_url.is_valid() &&
                  (image_url.SchemeIs(url::kHttpScheme) ||
                   image_url.SchemeIs(url::kHttpsScheme))) {
         context->data_.favicon_url = image_url;
       }
       context->image_is_valid_for_favicon_ = false;
       break;
     }
     case TemplateURLParsingContext::INPUT_ENCODING: {
       std::string input_encoding = base::UTF16ToASCII(context->string_);
       if (IsValidEncodingString(input_encoding))
         context->data_.input_encodings.push_back(input_encoding);
       break;
     }
-    case TemplateURLParsingContext::URL:
-      context->ProcessURLParams();
+    case TemplateURLParsingContext::ALIAS: {
+      context->data_.SetKeyword(context->string_);
+      context->has_custom_keyword_ = true;
       break;
+    }
     default:
       break;
   }
   context->string_.clear();
   context->elements_.pop_back();
 }
 
 // static
 void TemplateURLParsingContext::CharactersImpl(void* ctx,
                                                const xmlChar* ch,
@@ skipping 11 matching lines @@
     return NULL;
   if (suggestion_method_ == TemplateURLParsingContext::POST)
     data_.suggestions_url.clear();
 
   // If the image was a data URL, use the favicon from the search URL instead.
   // (see the TODO in EndElementImpl()).
   GURL search_url(data_.url());
   if (derive_image_from_url_ && data_.favicon_url.is_empty())
     data_.favicon_url = TemplateURL::GenerateFaviconURL(search_url);
 
-  data_.SetKeyword(TemplateURL::GenerateKeyword(search_url));
+  // Generate a keyword for this search engine if a custom one was not present
+  // in the imported data.
+  if (!has_custom_keyword_)
+    data_.SetKeyword(TemplateURL::GenerateKeyword(search_url));
+
   data_.show_in_default_list = show_in_default_list;
 
   // Bail if the search URL is empty or if either TemplateURLRef is invalid.
   scoped_ptr<TemplateURL> template_url(new TemplateURL(data_));
   if (template_url->url().empty() ||
       !template_url->url_ref().IsValid(search_terms_data) ||
       (!template_url->suggestions_url().empty() &&
        !template_url->suggestions_url_ref().IsValid(search_terms_data))) {
     return NULL;
   }
 
   return template_url.release();
 }
 
 // static
 void TemplateURLParsingContext::InitMapping() {
   kElementNameToElementTypeMap = new std::map<std::string, ElementType>;
   (*kElementNameToElementTypeMap)[kURLElement] = URL;
   (*kElementNameToElementTypeMap)[kParamElement] = PARAM;
   (*kElementNameToElementTypeMap)[kShortNameElement] = SHORT_NAME;
   (*kElementNameToElementTypeMap)[kImageElement] = IMAGE;
   (*kElementNameToElementTypeMap)[kOpenSearchDescriptionElement] =
       OPEN_SEARCH_DESCRIPTION;
   (*kElementNameToElementTypeMap)[kFirefoxSearchDescriptionElement] =
       OPEN_SEARCH_DESCRIPTION;
   (*kElementNameToElementTypeMap)[kInputEncodingElement] = INPUT_ENCODING;
+  (*kElementNameToElementTypeMap)[kAliasElement] = ALIAS;
 }
 
 void TemplateURLParsingContext::ParseURL(const xmlChar** atts) {
   if (!atts)
     return;
 
   std::string template_url;
   bool is_post = false;
   bool is_html_url = false;
   bool is_suggest_url = false;
@@ skipping 146 matching lines @@
   sax_handler.startElement = &TemplateURLParsingContext::StartElementImpl;
   sax_handler.endElement = &TemplateURLParsingContext::EndElementImpl;
   sax_handler.characters = &TemplateURLParsingContext::CharactersImpl;
   int error = xmlSAXUserParseMemory(&sax_handler, &context, data,
                                     static_cast<int>(length));
   xmlSubstituteEntitiesDefault(last_sub_entities_value);
 
   return error ?
       NULL : context.GetTemplateURL(search_terms_data, show_in_default_list);
 }