Removed restriction for {} so that javascript blocks can be used in the url....

chrome/browser/search_engines/template_url.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.
 
 #include "chrome/browser/search_engines/template_url.h"
 
 #include "app/gfx/favicon_size.h"
 #include "app/l10n_util.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
@@ skipping 79 matching lines @@
                                     Replacements* replacements) const {
   DCHECK(start != std::string::npos &&
          end != std::string::npos && end > start);
   size_t length = end - start - 1;
   bool optional = false;
   if ((*url)[end - 1] == kOptional) {
     optional = true;
     length--;
   }
   std::wstring parameter(url->substr(start + 1, length));
+  std::wstring full_parameter(url->substr(start, end - start + 1));
   // Remove the parameter from the string.
   url->erase(start, end - start + 1);
   if (parameter == kSearchTermsParameter) {
     replacements->push_back(Replacement(SEARCH_TERMS, static_cast<int>(start)));
   } else if (parameter == kCountParameter) {
     if (!optional)
       url->insert(start, kDefaultCount);
   } else if (parameter == kStartIndexParameter) {
     if (!optional) {
       url->insert(start, IntToWString(index_offset_));
@@ skipping 20 matching lines @@
     replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL,
                                         static_cast<int>(start)));
   } else if (parameter == kGoogleOriginalQueryForSuggestionParameter) {
     replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION,
                                         static_cast<int>(start)));
   } else if (parameter == kGoogleRLZParameter) {
     replacements->push_back(Replacement(GOOGLE_RLZ, static_cast<int>(start)));
   } else if (parameter == kGoogleUnescapedSearchTermsParameter) {
     replacements->push_back(Replacement(GOOGLE_UNESCAPED_SEARCH_TERMS,
                                         static_cast<int>(start)));
-  } else if (!optional) {
-    // Unknown required parameter. No idea what to replace this with,
-    // so fail.
+  } else {
+    // It can be some garbage but can also be a javascript block. Put it back.
+    url->insert(start, full_parameter);
     return false;
   }
   return true;
 }
 
 std::wstring TemplateURLRef::ParseURL(const std::wstring& url,
                                       Replacements* replacements,
                                       bool* valid) const {
   *valid = false;
   std::wstring parsed_url = url;
   for (size_t last = 0; last != std::string::npos; ) {
     last = parsed_url.find(kStartParameter, last);
     if (last != std::string::npos) {
-      size_t endTemplate = parsed_url.find(kEndParameter, last);
-      if (endTemplate != std::string::npos) {
-        if (!ParseParameter(last, endTemplate, &parsed_url, replacements)) {
-          // Not a valid parameter, return.
-          return std::wstring();
+      size_t template_end = parsed_url.find(kEndParameter, last);
+      if (template_end != std::string::npos) {
+        // Since we allow Javascript in the URL, {} pairs could be nested. Match
+        // only leaf pairs with supported parameters.
+        size_t next_template_start = parsed_url.find(kStartParameter, last + 1);
+        if (next_template_start == std::string::npos ||
+            next_template_start > template_end) {
+          // If successful, ParseParameter erases from the string as such no
+          // need to update |last|. If failed, move |last| to the end of pair.
+          if (!ParseParameter(last, template_end, &parsed_url, replacements)) {
+            // |template_end| + 1 may be beyond the end of the string.
+            last = template_end;
+          }
+        } else {
+          last = next_template_start;
         }
-        // ParseParamter erases from the string, as such we don't need
-        // to update last.
       } else {
         // Open brace without a closing brace, return.
         return std::wstring();
       }
     }
   }
   *valid = true;
   return parsed_url;
 }
 
@@ skipping 423 matching lines @@
   }
   return GURL();
 }
 
 void TemplateURL::InvalidateCachedValues() const {
   url_.InvalidateCachedValues();
   suggestions_url_.InvalidateCachedValues();
   if (autogenerate_keyword_)
     keyword_.clear();
 }