Parse out XSSI guards in Suggestion JSON response

chrome/browser/autocomplete/search_provider_unittest.cc

 // Copyright 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/autocomplete/search_provider.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 119 matching lines @@
   void QueryForInputAndSetWYTMatch(const string16& text,
                                    AutocompleteMatch* wyt_match);
 
   // Notifies the URLFetcher for the suggest query corresponding to the default
   // search provider that it's done.
   // Be sure and wrap calls to this in ASSERT_NO_FATAL_FAILURE.
   void FinishDefaultSuggestQuery();
 
   void ResetFieldTrialList();
 
+  void ClearAllResults();
+
   // See description above class for details of these fields.
   TemplateURL* default_t_url_;
   const string16 term1_;
   GURL term1_url_;
   TemplateURL* keyword_t_url_;
   const string16 keyword_term_;
   GURL keyword_url_;
 
   content::TestBrowserThreadBundle thread_bundle_;
 
@@ skipping 208 matching lines @@
   // a DCHECK.
   field_trial_list_.reset();
   field_trial_list_.reset(new base::FieldTrialList(
       new metrics::SHA1EntropyProvider("foo")));
   chrome_variations::testing::ClearAllVariationParams();
   base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
       "AutocompleteDynamicTrial_0", "DefaultGroup");
   trial->group();
 }
 
+void SearchProviderTest::ClearAllResults() {
+  provider_->ClearAllResults();
+}
+
 // Actual Tests ---------------------------------------------------------------
 
 // Make sure we query history for the default provider and a URLFetcher is
 // created for the default provider suggest results.
 TEST_F(SearchProviderTest, QueryDefaultProvider) {
   string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, false, false);
 
   // Make sure the default providers suggest service was queried.
   net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
@@ skipping 2483 matching lines @@
       EXPECT_EQ(cases[i].matches[j].contents, UTF16ToUTF8(matches[j].contents));
       EXPECT_EQ(cases[i].matches[j].allowed_to_be_prefetched,
                 SearchProvider::ShouldPrefetch(matches[j]));
       EXPECT_EQ(cases[i].matches[j].type, matches[j].type);
       EXPECT_EQ(cases[i].matches[j].from_keyword,
                 matches[j].keyword == ASCIIToUTF16("k"));
     }
   }
 }
 
+// A basic test that verifies that the XSSI guarded JSON response is parsed
+// correctly.
+TEST_F(SearchProviderTest, XSSIGuardedJSONParsing) {
+  struct Match {
+    std::string contents;
+    AutocompleteMatchType::Type type;
+  };
+  const Match kEmptyMatch = { kNotApplicable,
+                              AutocompleteMatchType::NUM_TYPES};
+
+  struct {
+    const std::string input_text;
+    const std::string default_provider_response_json;
+    const Match matches[4];
+  } cases[] = {
+    // No XSSI guard.
+    { "a",
+      "[\"a\",[\"b\", \"c\"],[],[],"
+      "{\"google:suggesttype\":[\"QUERY\",\"QUERY\"],"
+      "\"google:suggestrelevance\":[1, 2]}]",
+      { { "a", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
+        { "c", AutocompleteMatchType::SEARCH_SUGGEST },
+        { "b", AutocompleteMatchType::SEARCH_SUGGEST },
+        kEmptyMatch,
+      },
+    },
+    // Standard XSSI guard - )]}'\n.
+    { "a",
+      ")]}'\n[\"a\",[\"b\", \"c\"],[],[],"
+      "{\"google:suggesttype\":[\"QUERY\",\"QUERY\"],"
+      "\"google:suggestrelevance\":[1, 2]}]",
+      { { "a", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
+        { "c", AutocompleteMatchType::SEARCH_SUGGEST },
+        { "b", AutocompleteMatchType::SEARCH_SUGGEST },
+        kEmptyMatch,
+      },
+    },
+    // Modified XSSI guard - contains "[".
+    { "a",
+      ")]}'\n[)\"[\"a\",[\"b\", \"c\"],[],[],"
+      "{\"google:suggesttype\":[\"QUERY\",\"QUERY\"],"
+      "\"google:suggestrelevance\":[1, 2]}]",
+      { { "a", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
+        { "c", AutocompleteMatchType::SEARCH_SUGGEST },
+        { "b", AutocompleteMatchType::SEARCH_SUGGEST },
+        kEmptyMatch,
+      },
+    },
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+    ClearAllResults();
+    QueryForInput(ASCIIToUTF16(cases[i].input_text), false, false);
+
+    // Set up a default fetcher with provided results.
+    net::TestURLFetcher* fetcher =
+        test_factory_.GetFetcherByID(
+            SearchProvider::kDefaultProviderURLFetcherID);
+    ASSERT_TRUE(fetcher);
+    fetcher->set_response_code(200);
+    fetcher->SetResponseString(cases[i].default_provider_response_json);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+    RunTillProviderDone();
+
+    const ACMatches& matches = provider_->matches();
+    // The top match must inline and score as highly as calculated verbatim.
+    ASSERT_FALSE(matches.empty());
+    EXPECT_GE(matches[0].relevance, 1300);
+
+    SCOPED_TRACE("for case: " + base::IntToString(i));
+    size_t j = 0;
+    // Ensure that the returned matches equal the expectations.
+    for (; j < matches.size(); ++j) {
+      SCOPED_TRACE("and match: " + base::IntToString(j));
+      EXPECT_EQ(cases[i].matches[j].contents, UTF16ToUTF8(matches[j].contents));
+      EXPECT_EQ(cases[i].matches[j].type, matches[j].type);
+    }
+    for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j) {
+      SCOPED_TRACE("and match: " + base::IntToString(j));
+      EXPECT_EQ(cases[i].matches[j].contents, kNotApplicable);
+      EXPECT_EQ(cases[i].matches[j].type, AutocompleteMatchType::NUM_TYPES);
+    }
+  }
+}
+
+
 TEST_F(SearchProviderTest, ReflectsBookmarkBarState) {
   profile_.GetPrefs()->SetBoolean(prefs::kShowBookmarkBar, false);
   string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, true, false);
   ASSERT_FALSE(provider_->matches().empty());
   EXPECT_EQ(AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
             provider_->matches()[0].type);
   ASSERT_TRUE(provider_->matches()[0].search_terms_args != NULL);
   EXPECT_FALSE(provider_->matches()[0].search_terms_args->bookmark_bar_pinned);
 
   profile_.GetPrefs()->SetBoolean(prefs::kShowBookmarkBar, true);
   term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, true, false);
   ASSERT_FALSE(provider_->matches().empty());
   EXPECT_EQ(AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
             provider_->matches()[0].type);
   ASSERT_TRUE(provider_->matches()[0].search_terms_args != NULL);
   EXPECT_TRUE(provider_->matches()[0].search_terms_args->bookmark_bar_pinned);
 }