Use explicit WebString conversions in spellcheck

components/spellcheck/renderer/spellcheck_multilingual_unittest.cc

 // Copyright 2015 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 <stddef.h>
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 63 matching lines @@
  protected:
   void ExpectSpellCheckWordResults(const std::string& languages,
                                    const SpellcheckTestCase* test_cases,
                                    size_t num_test_cases) {
     ReinitializeSpellCheck(languages);
 
     for (size_t i = 0; i < num_test_cases; ++i) {
       int misspelling_start = 0;
       int misspelling_length = 0;
       static_cast<blink::WebSpellCheckClient*>(provider())
-          ->checkSpelling(
-              blink::WebString(base::WideToUTF16(test_cases[i].input)),
-              misspelling_start, misspelling_length, nullptr);
+          ->checkSpelling(blink::WebString::fromUTF16(
+                              base::WideToUTF16(test_cases[i].input)),
+                          misspelling_start, misspelling_length, nullptr);
 
       EXPECT_EQ(test_cases[i].expected_misspelling_start, misspelling_start)
           << "Improper misspelling location found with the languages "
           << languages << " when checking \"" << test_cases[i].input << "\".";
       EXPECT_EQ(test_cases[i].expected_misspelling_length, misspelling_length)
           << "Improper misspelling length found with the languages "
           << languages << " when checking \"" << test_cases[i].input << "\".";
     }
   }
 
   void ExpectSpellCheckParagraphResults(
       const base::string16& input,
       const std::vector<SpellCheckResult>& expected) {
     blink::WebVector<blink::WebTextCheckingResult> results;
-    spellcheck_->SpellCheckParagraph(blink::WebString(input), &results);
+    spellcheck_->SpellCheckParagraph(input, &results);
 
     EXPECT_EQ(expected.size(), results.size());
     size_t size = std::min(results.size(), expected.size());
     for (size_t i = 0; i < size; ++i) {
       EXPECT_EQ(blink::WebTextDecorationTypeSpelling, results[i].decoration);
       EXPECT_EQ(expected[i].location, results[i].location);
       EXPECT_EQ(expected[i].length, results[i].length);
     }
   }
 
@@ skipping 116 matching lines @@
       {L"jum", 0, 3, L"hum,jun,ju,um,juma"},
       {L"asdne", 0, 5, L"sadness,desasne"},
   };
 
   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     blink::WebVector<blink::WebString> suggestions;
     int misspelling_start;
     int misspelling_length;
     static_cast<blink::WebSpellCheckClient*>(provider())
         ->checkSpelling(
-            blink::WebString(base::WideToUTF16(kTestCases[i].input)),
+            blink::WebString::fromUTF16(base::WideToUTF16(kTestCases[i].input)),
             misspelling_start, misspelling_length, &suggestions);
 
     EXPECT_EQ(kTestCases[i].expected_misspelling_start, misspelling_start);
     EXPECT_EQ(kTestCases[i].expected_misspelling_length, misspelling_length);
     if (!kTestCases[i].expected_suggestions) {
       EXPECT_EQ(0UL, suggestions.size());
       continue;
     }
 
     std::vector<base::string16> expected_suggestions = base::SplitString(
         base::WideToUTF16(kTestCases[i].expected_suggestions),
         base::string16(1, ','), base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     EXPECT_EQ(expected_suggestions.size(), suggestions.size());
     for (size_t j = 0;
          j < std::min(expected_suggestions.size(), suggestions.size()); j++) {
-      EXPECT_EQ(expected_suggestions[j], base::string16(suggestions[j]));
+      EXPECT_EQ(expected_suggestions[j], suggestions[j].utf16());
     }
   }
 }