Reland r131019: Move most TemplateURL data members to a new struct, TemplateURLData. This allows us…

chrome/browser/search_engines/template_url_parser.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.
 
 #include "chrome/browser/search_engines/template_url_parser.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 127 matching lines @@
   static void StartElementImpl(void* ctx,
                                const xmlChar* name,
                                const xmlChar** atts);
   static void EndElementImpl(void* ctx, const xmlChar* name);
   static void CharactersImpl(void* ctx, const xmlChar* ch, int len);
 
   // Returns a heap-allocated TemplateURL representing the result of parsing.
   // This will be NULL if parsing failed or if the results were invalid for some
   // reason (e.g. the resulting URL was not HTTP[S], a name wasn't supplied,
   // etc.).
-  TemplateURL* GetTemplateURL(Profile* profile);
+  TemplateURL* GetTemplateURL(Profile* profile, bool show_in_default_list);
 
  private:
   // Key is UTF8 encoded.
   typedef std::map<std::string, ElementType> ElementNameToElementTypeMap;
 
   static void InitMapping();
 
   void ParseURL(const xmlChar** atts);
   void ParseImage(const xmlChar** atts);
   void ParseParam(const xmlChar** atts);
   void ProcessURLParams();
 
   // Returns the current ElementType.
   ElementType GetKnownType();
 
   static ElementNameToElementTypeMap* kElementNameToElementTypeMap;
 
-  scoped_ptr<TemplateURL> url_;
+  // Data that gets updated as we parse, and is converted to a TemplateURL by
+  // GetTemplateURL().
+  TemplateURLData data_;
 
   std::vector<ElementType> elements_;
   bool image_is_valid_for_favicon_;
 
   // Character content for the current element.
   string16 string_;
 
   TemplateURLParser::ParameterFilter* parameter_filter_;
 
   // The list of parameters parsed in the Param nodes of a Url node.
@@ skipping 13 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLParsingContext);
 };
 
 // static
 TemplateURLParsingContext::ElementNameToElementTypeMap*
     TemplateURLParsingContext::kElementNameToElementTypeMap = NULL;
 
 TemplateURLParsingContext::TemplateURLParsingContext(
     TemplateURLParser::ParameterFilter* parameter_filter)
-    : url_(new TemplateURL()),
-      image_is_valid_for_favicon_(false),
+    : image_is_valid_for_favicon_(false),
       parameter_filter_(parameter_filter),
       method_(GET),
       suggestion_method_(GET),
       is_suggest_url_(false),
       derive_image_from_url_(false) {
   if (kElementNameToElementTypeMap == NULL)
     InitMapping();
-  // When combined with proscriptions elsewhere against updating url_->url_ to
-  // the empty string, this call ensures url_->url() will never be NULL.
-  url_->SetURL("x");
+  // When combined with proscriptions elsewhere against updating data_->url_ to
+  // the empty string, this call ensures data_->url() will never be NULL.
+  data_.SetURL("x");
 }
 
 // static
 void TemplateURLParsingContext::StartElementImpl(void* ctx,
                                                  const xmlChar* name,
                                                  const xmlChar** atts) {
   // Remove the namespace from |name|, ex: os:Url -> Url.
   std::string node_name(XMLCharToString(name));
   size_t index = node_name.find_first_of(":");
   if (index != std::string::npos)
@@ skipping 20 matching lines @@
   }
   context->string_.clear();
 }
 
 // static
 void TemplateURLParsingContext::EndElementImpl(void* ctx, const xmlChar* name) {
   TemplateURLParsingContext* context =
       reinterpret_cast<TemplateURLParsingContext*>(ctx);
   switch (context->GetKnownType()) {
     case TemplateURLParsingContext::SHORT_NAME:
-      context->url_->short_name_ = context->string_;
+      context->data_.short_name = context->string_;
       break;
     case TemplateURLParsingContext::IMAGE: {
       GURL image_url(UTF16ToUTF8(context->string_));
       if (image_url.SchemeIs(chrome::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(chrome::kHttpScheme) ||
                   image_url.SchemeIs(chrome::kHttpsScheme))) {
-        context->url_->set_favicon_url(image_url);
+        context->data_.favicon_url = image_url;
       }
       context->image_is_valid_for_favicon_ = false;
       break;
     }
     case TemplateURLParsingContext::INPUT_ENCODING: {
       std::string input_encoding = UTF16ToASCII(context->string_);
       if (IsValidEncodingString(input_encoding))
-        context->url_->input_encodings_.push_back(input_encoding);
+        context->data_.input_encodings.push_back(input_encoding);
       break;
     }
     case TemplateURLParsingContext::URL:
       context->ProcessURLParams();
       break;
     default:
       break;
   }
   context->string_.clear();
   context->elements_.pop_back();
 }
 
 // static
 void TemplateURLParsingContext::CharactersImpl(void* ctx,
                                                const xmlChar* ch,
                                                int len) {
   reinterpret_cast<TemplateURLParsingContext*>(ctx)->string_ +=
       UTF8ToUTF16(std::string(reinterpret_cast<const char*>(ch), len));
 }
 
-TemplateURL* TemplateURLParsingContext::GetTemplateURL(Profile* profile) {
+TemplateURL* TemplateURLParsingContext::GetTemplateURL(
+    Profile* profile,
+    bool show_in_default_list) {
   // Basic legality checks.
-  if (url_->short_name_.empty() || !IsHTTPRef(url_->url()) ||
-      !IsHTTPRef(url_->suggestions_url()))
+  if (data_.short_name.empty() || !IsHTTPRef(data_.url()) ||
+      !IsHTTPRef(data_.suggestions_url))
     return NULL;
 
   // If the image was a data URL, use the favicon from the search URL instead.
   // (see TODO inEndElementImpl()).
-  GURL url(url_->url());
-  if (derive_image_from_url_ && url_->favicon_url().is_empty())
-    url_->set_favicon_url(TemplateURL::GenerateFaviconURL(url));
+  GURL url(data_.url());
+  if (derive_image_from_url_ && data_.favicon_url.is_empty())
+    data_.favicon_url = TemplateURL::GenerateFaviconURL(url);
 
   // TODO(jcampan): http://b/issue?id=1196285 we do not support search engines
   //                that use POST yet.
   if (method_ == TemplateURLParsingContext::POST)
     return NULL;
   if (suggestion_method_ == TemplateURLParsingContext::POST)
-    url_->SetSuggestionsURL(std::string());
+    data_.suggestions_url.clear();
 
   // Give this a keyword to facilitate tab-to-search.
   string16 keyword(TemplateURLService::GenerateKeyword(url, false));
   DCHECK(!keyword.empty());
-  url_->set_keyword(keyword);
-  return url_.release();
+  data_.SetKeyword(keyword);
+  data_.show_in_default_list = show_in_default_list;
+  return new TemplateURL(data_);
 }
 
 // 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] =
@@ skipping 19 matching lines @@
       is_html_url = (type == kHTMLType);
       is_suggest_url = (type == kSuggestionType);
     } else if (name == kURLTemplateAttribute) {
       template_url = XMLCharToString(value);
     } else if (name == kParamMethodAttribute) {
       is_post = LowerCaseEqualsASCII(XMLCharToString(value), "post");
     }
   }
 
   if (is_html_url && !template_url.empty()) {
-    url_->SetURL(template_url);
+    data_.SetURL(template_url);
     is_suggest_url_ = false;
     if (is_post)
       method_ = POST;
   } else if (is_suggest_url) {
-    url_->SetSuggestionsURL(template_url);
+    data_.suggestions_url = template_url;
     is_suggest_url_ = true;
     if (is_post)
       suggestion_method_ = POST;
   }
 }
 
 void TemplateURLParsingContext::ParseImage(const xmlChar** atts) {
   if (!atts)
     return;
 
@@ skipping 34 matching lines @@
 
   if (!key.empty() &&
       (!parameter_filter_ || parameter_filter_->KeepParameter(key, value)))
     extra_params_.push_back(Param(key, value));
 }
 
 void TemplateURLParsingContext::ProcessURLParams() {
   if (!parameter_filter_ && extra_params_.empty())
     return;
 
-  GURL url(is_suggest_url_ ? url_->suggestions_url() : url_->url());
+  GURL url(is_suggest_url_ ? data_.suggestions_url : data_.url());
   if (url.is_empty())
     return;
 
   // If there is a parameter filter, parse the existing URL and remove any
   // unwanted parameter.
   std::string new_query;
   bool modified = false;
   if (parameter_filter_) {
     url_parse::Component query = url.parsed_for_possibly_invalid_spec().query;
     url_parse::Component key, value;
@@ skipping 17 matching lines @@
     for (std::vector<Param>::const_iterator iter(extra_params_.begin());
          iter != extra_params_.end(); ++iter)
       AppendParamToQuery(iter->first, iter->second, &new_query);
   }
 
   if (modified) {
     GURL::Replacements repl;
     repl.SetQueryStr(new_query);
     url = url.ReplaceComponents(repl);
     if (is_suggest_url_)
-      url_->SetSuggestionsURL(url.spec());
+      data_.suggestions_url = url.spec();
     else if (url.is_valid())
-      url_->SetURL(url.spec());
+      data_.SetURL(url.spec());
   }
 }
 
 TemplateURLParsingContext::ElementType
     TemplateURLParsingContext::GetKnownType() {
   if (elements_.size() == 2 && elements_[0] == OPEN_SEARCH_DESCRIPTION)
     return elements_[1];
   // We only expect PARAM nodes under the URL node.
   return (elements_.size() == 3 && elements_[0] == OPEN_SEARCH_DESCRIPTION &&
       elements_[1] == URL && elements_[2] == PARAM) ? PARAM : UNKNOWN;
 }
 
 
 // TemplateURLParser ----------------------------------------------------------
 
 // static
 TemplateURL* TemplateURLParser::Parse(
     Profile* profile,
+    bool show_in_default_list,
     const char* data,
     size_t length,
     TemplateURLParser::ParameterFilter* param_filter) {
   // xmlSubstituteEntitiesDefault(1) makes it so that &amp; isn't mapped to
   // &#38; . Unfortunately xmlSubstituteEntitiesDefault affects global state.
   // If this becomes problematic we'll need to provide our own entity
   // type for &amp;, or strip out &#38; by hand after parsing.
   int last_sub_entities_value = xmlSubstituteEntitiesDefault(1);
   TemplateURLParsingContext context(param_filter);
   xmlSAXHandler sax_handler;
   memset(&sax_handler, 0, sizeof(sax_handler));
   sax_handler.startElement = &TemplateURLParsingContext::StartElementImpl;
   sax_handler.endElement = &TemplateURLParsingContext::EndElementImpl;
   sax_handler.characters = &TemplateURLParsingContext::CharactersImpl;
   xmlSAXUserParseMemory(&sax_handler, &context, data, static_cast<int>(length));
   xmlSubstituteEntitiesDefault(last_sub_entities_value);
 
-  return context.GetTemplateURL(profile);
+  return context.GetTemplateURL(profile, show_in_default_list);
 }