Revert of Handle typographical apostrophe with spelling service client

chrome/browser/spellchecker/spelling_service_client_unittest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 16 matching lines @@
 // verifies JSON-RPC requests when the SpellingServiceClient class sends them to
 // the Spelling service. This class also verifies the SpellingServiceClient
 // class does not either send cookies to the Spelling service or accept cookies
 // from it.
 class TestSpellingURLFetcher : public net::TestURLFetcher {
  public:
   TestSpellingURLFetcher(int id,
                          const GURL& url,
                          net::URLFetcherDelegate* d,
                          int version,
-                         const std::string& sanitized_text,
+                         const std::string& text,
                          const std::string& language,
                          int status,
                          const std::string& response)
       : net::TestURLFetcher(0, url, d),
         version_(base::StringPrintf("v%d", version)),
         language_(language.empty() ? std::string("en") : language),
-        sanitized_text_(sanitized_text) {
+        text_(text) {
     set_response_code(status);
     SetResponseString(response);
   }
   ~TestSpellingURLFetcher() override {}
 
   void SetUploadData(const std::string& upload_content_type,
                      const std::string& upload_content) override {
     // Verify the given content type is JSON. (The Spelling service returns an
     // internal server error when this content type is not JSON.)
     EXPECT_EQ("application/json", upload_content_type);
 
     // Parse the JSON to be sent to the service, and verify its parameters.
     scoped_ptr<base::DictionaryValue> value(
         static_cast<base::DictionaryValue*>(base::JSONReader::DeprecatedRead(
             upload_content, base::JSON_ALLOW_TRAILING_COMMAS)));
     ASSERT_TRUE(value.get());
     std::string method;
     EXPECT_TRUE(value->GetString("method", &method));
     EXPECT_EQ("spelling.check", method);
     std::string version;
     EXPECT_TRUE(value->GetString("apiVersion", &version));
     EXPECT_EQ(version_, version);
-    std::string sanitized_text;
-    EXPECT_TRUE(value->GetString("params.text", &sanitized_text));
-    EXPECT_EQ(sanitized_text_, sanitized_text);
+    std::string text;
+    EXPECT_TRUE(value->GetString("params.text", &text));
+    EXPECT_EQ(text_, text);
     std::string language;
     EXPECT_TRUE(value->GetString("params.language", &language));
     EXPECT_EQ(language_, language);
     ASSERT_TRUE(GetExpectedCountry(language, &country_));
     std::string country;
     EXPECT_TRUE(value->GetString("params.originCountry", &country));
     EXPECT_EQ(country_, country);
 
     net::TestURLFetcher::SetUploadData(upload_content_type, upload_content);
   }
@@ skipping 19 matching lines @@
         country->assign(kCountries[i].country);
         return true;
       }
     }
     return false;
   }
 
   std::string version_;
   std::string language_;
   std::string country_;
-  std::string sanitized_text_;
+  std::string text_;
 };
 
 // A class derived from the SpellingServiceClient class used by the
 // SpellingServiceClientTest class. This class overrides CreateURLFetcher so
 // this test can use TestSpellingURLFetcher. This class also lets tests access
 // the ParseResponse method.
 class TestingSpellingServiceClient : public SpellingServiceClient {
  public:
   TestingSpellingServiceClient()
       : request_type_(0),
         response_status_(0),
         success_(false),
         fetcher_(NULL) {
   }
   ~TestingSpellingServiceClient() override {}
 
   void SetHTTPRequest(int type,
-                      const std::string& sanitized_text,
+                      const std::string& text,
                       const std::string& language) {
     request_type_ = type;
-    sanitized_request_text_ = sanitized_text;
+    request_text_ = text;
     request_language_ = language;
   }
 
   void SetHTTPResponse(int status, const char* data) {
     response_status_ = status;
     response_data_.assign(data);
   }
 
   void SetExpectedTextCheckResult(bool success, const char* text) {
     success_ = success;
     corrected_text_.assign(base::UTF8ToUTF16(text));
   }
 
   void CallOnURLFetchComplete() {
     ASSERT_TRUE(fetcher_);
     fetcher_->delegate()->OnURLFetchComplete(fetcher_);
     fetcher_ = NULL;
   }
 
   void VerifyResponse(bool success,
                       const base::string16& request_text,
                       const std::vector<SpellCheckResult>& results) {
     EXPECT_EQ(success_, success);
-    base::string16 text(base::UTF8ToUTF16(sanitized_request_text_));
+    base::string16 text(base::UTF8ToUTF16(request_text_));
+    EXPECT_EQ(text, request_text);
     for (std::vector<SpellCheckResult>::const_iterator it = results.begin();
          it != results.end(); ++it) {
       text.replace(it->location, it->length, it->replacement);
     }
     EXPECT_EQ(corrected_text_, text);
   }
 
   bool ParseResponseSuccess(const std::string& data) {
     std::vector<SpellCheckResult> results;
     return ParseResponse(data, &results);
   }
 
  private:
   scoped_ptr<net::URLFetcher> CreateURLFetcher(const GURL& url) override {
     EXPECT_EQ("https://www.googleapis.com/rpc", url.spec());
-    fetcher_ = new TestSpellingURLFetcher(
-        0, url, this, request_type_, sanitized_request_text_, request_language_,
-        response_status_, response_data_);
+    fetcher_ = new TestSpellingURLFetcher(0, url, this,
+                                          request_type_, request_text_,
+                                          request_language_,
+                                          response_status_, response_data_);
     return scoped_ptr<net::URLFetcher>(fetcher_);
   }
 
   int request_type_;
-  std::string sanitized_request_text_;
+  std::string request_text_;
   std::string request_language_;
   int response_status_;
   std::string response_data_;
   bool success_;
   base::string16 corrected_text_;
   TestSpellingURLFetcher* fetcher_;  // weak
 };
 
 // A test class used for testing the SpellingServiceClient class. This class
 // implements a callback function used by the SpellingServiceClient class to
@@ skipping 20 matching lines @@
 // that it parses a JSON response from the service and calls the callback
 // function. To avoid sending JSON-RPC requests to the service, this test uses a
 // custom TestURLFecher class (TestSpellingURLFetcher) which calls
 // SpellingServiceClient::OnURLFetchComplete() with the parameters set by this
 // test. This test also uses a custom callback function that replaces all
 // misspelled words with ones suggested by the service so this test can compare
 // the corrected text with the expected results. (If there are not any
 // misspelled words, |corrected_text| should be equal to |request_text|.)
 TEST_F(SpellingServiceClientTest, RequestTextCheck) {
   static const struct {
-    const wchar_t* request_text;
-    const char* sanitized_request_text;
+    const char* request_text;
     SpellingServiceClient::ServiceType request_type;
     int response_status;
     const char* response_data;
     bool success;
     const char* corrected_text;
     const char* language;
   } kTests[] = {
     {
-      L"",
       "",
       SpellingServiceClient::SUGGEST,
       500,
       "",
       false,
       "",
       "af",
     }, {
-      L"chromebook",
       "chromebook",
       SpellingServiceClient::SUGGEST,
       200,
       "{}",
       true,
       "chromebook",
       "af",
     }, {
-      L"chrombook",
       "chrombook",
       SpellingServiceClient::SUGGEST,
       200,
       "{\n"
       "  \"result\": {\n"
       "    \"spellingCheckResponse\": {\n"
       "      \"misspellings\": [{\n"
       "        \"charStart\": 0,\n"
       "        \"charLength\": 9,\n"
       "        \"suggestions\": [{ \"suggestion\": \"chromebook\" }],\n"
       "        \"canAutoCorrect\": false\n"
       "      }]\n"
       "    }\n"
       "  }\n"
       "}",
       true,
       "chromebook",
       "af",
     }, {
-      L"",
       "",
       SpellingServiceClient::SPELLCHECK,
       500,
       "",
       false,
       "",
       "en",
     }, {
-      L"I have been to USA.",
       "I have been to USA.",
       SpellingServiceClient::SPELLCHECK,
       200,
       "{}",
       true,
       "I have been to USA.",
       "en",
     }, {
-      L"I have bean to USA.",
       "I have bean to USA.",
       SpellingServiceClient::SPELLCHECK,
       200,
       "{\n"
       "  \"result\": {\n"
       "    \"spellingCheckResponse\": {\n"
       "      \"misspellings\": [{\n"
       "        \"charStart\": 7,\n"
       "        \"charLength\": 4,\n"
       "        \"suggestions\": [{ \"suggestion\": \"been\" }],\n"
       "        \"canAutoCorrect\": false\n"
       "      }]\n"
       "    }\n"
       "  }\n"
       "}",
       true,
       "I have been to USA.",
       "en",
-    }, {
-      L"I\x2019mattheIn'n'Out.",
-      "I'mattheIn'n'Out.",
-      SpellingServiceClient::SPELLCHECK,
-      200,
-      "{\n"
-      "  \"result\": {\n"
-      "    \"spellingCheckResponse\": {\n"
-      "      \"misspellings\": [{\n"
-      "        \"charStart\": 0,\n"
-      "        \"charLength\": 16,\n"
-      "        \"suggestions\":"
-      " [{ \"suggestion\": \"I'm at the In'N'Out\" }],\n"
-      "        \"canAutoCorrect\": false\n"
-      "      }]\n"
-      "    }\n"
-      "  }\n"
-      "}",
-      true,
-      "I'm at the In'N'Out.",
-      "en",
     },
   };
 
   PrefService* pref = profile_.GetPrefs();
   pref->SetBoolean(prefs::kEnableContinuousSpellcheck, true);
   pref->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
 
   for (size_t i = 0; i < arraysize(kTests); ++i) {
-    client_.SetHTTPRequest(kTests[i].request_type,
-                           kTests[i].sanitized_request_text,
+    client_.SetHTTPRequest(kTests[i].request_type, kTests[i].request_text,
                            kTests[i].language);
     client_.SetHTTPResponse(kTests[i].response_status, kTests[i].response_data);
     client_.SetExpectedTextCheckResult(kTests[i].success,
                                        kTests[i].corrected_text);
     pref->SetString(prefs::kSpellCheckDictionary, kTests[i].language);
     client_.RequestTextCheck(
         &profile_,
         kTests[i].request_type,
-        base::WideToUTF16(kTests[i].request_text),
+        base::ASCIIToUTF16(kTests[i].request_text),
         base::Bind(&SpellingServiceClientTest::OnTextCheckComplete,
                    base::Unretained(this), 0));
     client_.CallOnURLFetchComplete();
   }
 }
 
 // Verify that SpellingServiceClient::IsAvailable() returns true only when it
 // can send suggest requests or spellcheck requests.
 TEST_F(SpellingServiceClientTest, AvailableServices) {
   const SpellingServiceClient::ServiceType kSuggest =
@@ skipping 49 matching lines @@
   }
 #endif  // !defined(OS_MACOSX)
 }
 
 // Verify that an error in JSON response from spelling service will result in
 // ParseResponse returning false.
 TEST_F(SpellingServiceClientTest, ResponseErrorTest) {
   EXPECT_TRUE(client_.ParseResponseSuccess("{\"result\": {}}"));
   EXPECT_FALSE(client_.ParseResponseSuccess("{\"error\": {}}"));
 }