Update some uses of UTF conversions in chrome/browser to use the base:: namespace.

chrome/browser/spellchecker/feedback_sender_unittest.cc

 // Copyright (c) 2013 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.
 //
 // Unit tests for |FeedbackSender| object.
 
 #include "chrome/browser/spellchecker/feedback_sender.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 23 matching lines @@
 const int kMisspellingLength = 6;
 const int kMisspellingStart = 0;
 const int kRendererProcessId = 0;
 const int kUrlFetcherId = 0;
 
 // Builds a simple spellcheck result.
 SpellCheckResult BuildSpellCheckResult() {
   return SpellCheckResult(SpellCheckResult::SPELLING,
                           kMisspellingStart,
                           kMisspellingLength,
-                          UTF8ToUTF16("Hello"));
+                          base::UTF8ToUTF16("Hello"));
 }
 
 // Returns the number of times that |needle| appears in |haystack| without
 // overlaps. For example, CountOccurences("bananana", "nana") returns 1.
 int CountOccurences(const std::string& haystack, const std::string& needle) {
   int number_of_occurrences = 0;
   for (size_t pos = haystack.find(needle);
        pos != std::string::npos;
        pos = haystack.find(needle, pos + needle.length())) {
     ++number_of_occurrences;
@@ skipping 34 matching lines @@
     field_trial_ = base::FieldTrialList::CreateFieldTrial(
         kFeedbackFieldTrialName, kFeedbackFieldTrialEnabledGroupName);
     field_trial_->group();
     feedback_.reset(new FeedbackSender(NULL, kLanguage, kCountry));
     feedback_->StartFeedbackCollection();
   }
 
   uint32 AddPendingFeedback() {
     std::vector<SpellCheckResult> results(1, BuildSpellCheckResult());
     feedback_->OnSpellcheckResults(kRendererProcessId,
-                                   UTF8ToUTF16(kText),
+                                   base::UTF8ToUTF16(kText),
                                    std::vector<SpellCheckMarker>(),
                                    &results);
     return results[0].hash;
   }
 
   void ExpireSession() {
     feedback_->session_start_ =
         base::Time::Now() -
         base::TimeDelta::FromHours(chrome::spellcheck_common::kSessionHours);
   }
@@ skipping 124 matching lines @@
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId,
                                       std::vector<uint32>());
   EXPECT_TRUE(UploadDataContains("\"actionType\":\"IGNORE\""));
 }
 
 // Send MANUALLY_CORRECTED feedback message if the user manually corrected the
 // misspelled word.
 TEST_F(FeedbackSenderTest, ManuallyCorrectedFeedback) {
   uint32 hash = AddPendingFeedback();
   static const std::string kManualCorrection = "Howdy";
-  feedback_->ManuallyCorrected(hash, ASCIIToUTF16(kManualCorrection));
+  feedback_->ManuallyCorrected(hash, base::ASCIIToUTF16(kManualCorrection));
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId,
                                       std::vector<uint32>());
   EXPECT_TRUE(UploadDataContains("\"actionType\":\"MANUALLY_CORRECTED\""));
   EXPECT_TRUE(UploadDataContains("\"actionTargetValue\":\"" +
                                  kManualCorrection + "\""));
 }
 
 // Send feedback messages in batch.
 TEST_F(FeedbackSenderTest, BatchFeedback) {
   std::vector<SpellCheckResult> results;
   results.push_back(SpellCheckResult(SpellCheckResult::SPELLING,
                                      kMisspellingStart,
                                      kMisspellingLength,
-                                     ASCIIToUTF16("Hello")));
+                                     base::ASCIIToUTF16("Hello")));
   static const int kSecondMisspellingStart = 7;
   static const int kSecondMisspellingLength = 5;
   results.push_back(SpellCheckResult(SpellCheckResult::SPELLING,
                                      kSecondMisspellingStart,
                                      kSecondMisspellingLength,
-                                     ASCIIToUTF16("world")));
+                                     base::ASCIIToUTF16("world")));
   feedback_->OnSpellcheckResults(kRendererProcessId,
-                                 UTF8ToUTF16(kText),
+                                 base::UTF8ToUTF16(kText),
                                  std::vector<SpellCheckMarker>(),
                                  &results);
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId,
                                       std::vector<uint32>());
   EXPECT_TRUE(UploadDataContains("\"actionType\":\"NO_ACTION\"", 2));
 }
 
 // Send a series of PENDING feedback messages and one final NO_ACTION feedback
 // message with the same hash identifier for a single misspelling.
 TEST_F(FeedbackSenderTest, SameHashFeedback) {
@@ skipping 26 matching lines @@
 // 1) Pending feedback is finalized and sent to the server in the last message
 //    batch in the session.
 // 2) No feedback is sent until a spellcheck request happens.
 // 3) Existing markers get new hash identifiers.
 TEST_F(FeedbackSenderTest, SessionExpirationFeedback) {
   std::vector<SpellCheckResult> results(
       1,
       SpellCheckResult(SpellCheckResult::SPELLING,
                        kMisspellingStart,
                        kMisspellingLength,
-                       ASCIIToUTF16("Hello")));
+                       base::ASCIIToUTF16("Hello")));
   feedback_->OnSpellcheckResults(kRendererProcessId,
-                                 UTF8ToUTF16(kText),
+                                 base::UTF8ToUTF16(kText),
                                  std::vector<SpellCheckMarker>(),
                                  &results);
   uint32 original_hash = results[0].hash;
   std::vector<uint32> remaining_markers(1, original_hash);
 
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId, remaining_markers);
   EXPECT_FALSE(UploadDataContains("\"actionType\":\"NO_ACTION\""));
   EXPECT_TRUE(UploadDataContains("\"actionType\":\"PENDING\""));
   std::string original_hash_string =
       base::StringPrintf("\"suggestionId\":\"%u\"", original_hash);
@@ skipping 14 matching lines @@
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId, remaining_markers);
   EXPECT_FALSE(IsUploadingData());
 
   // The first spellcheck request after session expiration creates different
   // document marker hash identifiers.
   std::vector<SpellCheckMarker> original_markers(
       1, SpellCheckMarker(results[0].hash, results[0].location));
   results[0] = SpellCheckResult(SpellCheckResult::SPELLING,
                                 kMisspellingStart,
                                 kMisspellingLength,
-                                ASCIIToUTF16("Hello"));
+                                base::ASCIIToUTF16("Hello"));
   feedback_->OnSpellcheckResults(
-      kRendererProcessId, UTF8ToUTF16(kText), original_markers, &results);
+      kRendererProcessId, base::UTF8ToUTF16(kText), original_markers, &results);
   uint32 updated_hash = results[0].hash;
   EXPECT_NE(updated_hash, original_hash);
   remaining_markers[0] = updated_hash;
 
   // The first feedback message batch in session |i + 1| has the new document
   // marker hash identifiers.
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId, remaining_markers);
   EXPECT_FALSE(UploadDataContains("\"actionType\":\"NO_ACTION\""));
   EXPECT_TRUE(UploadDataContains("\"actionType\":\"PENDING\""));
   EXPECT_FALSE(UploadDataContains(original_hash_string));
@@ skipping 136 matching lines @@
 }
 
 // Duplicate spellcheck results should be matched to the existing markers.
 TEST_F(FeedbackSenderTest, MatchDupliateResultsWithExistingMarkers) {
   uint32 hash = AddPendingFeedback();
   std::vector<SpellCheckResult> results(
       1,
       SpellCheckResult(SpellCheckResult::SPELLING,
                        kMisspellingStart,
                        kMisspellingLength,
-                       ASCIIToUTF16("Hello")));
+                       base::ASCIIToUTF16("Hello")));
   std::vector<SpellCheckMarker> markers(
       1, SpellCheckMarker(hash, results[0].location));
   EXPECT_EQ(static_cast<uint32>(0), results[0].hash);
   feedback_->OnSpellcheckResults(
-      kRendererProcessId, UTF8ToUTF16(kText), markers, &results);
+      kRendererProcessId, base::UTF8ToUTF16(kText), markers, &results);
   EXPECT_EQ(hash, results[0].hash);
 }
 
 // Adding a word to dictionary should trigger ADD_TO_DICT feedback for every
 // occurrence of that word.
 TEST_F(FeedbackSenderTest, MultipleAddToDictFeedback) {
   std::vector<SpellCheckResult> results;
   static const int kSentenceLength = 14;
   static const int kNumberOfSentences = 2;
   static const base::string16 kTextWithDuplicates =
-      ASCIIToUTF16("Helllo world. Helllo world.");
+      base::ASCIIToUTF16("Helllo world. Helllo world.");
   for (int i = 0; i < kNumberOfSentences; ++i) {
     results.push_back(SpellCheckResult(SpellCheckResult::SPELLING,
                                        kMisspellingStart + i * kSentenceLength,
                                        kMisspellingLength,
-                                       ASCIIToUTF16("Hello")));
+                                       base::ASCIIToUTF16("Hello")));
   }
   static const int kNumberOfRenderers = 2;
   int last_renderer_process_id = -1;
   for (int i = 0; i < kNumberOfRenderers; ++i) {
     feedback_->OnSpellcheckResults(kRendererProcessId + i,
                                    kTextWithDuplicates,
                                    std::vector<SpellCheckMarker>(),
                                    &results);
     last_renderer_process_id = kRendererProcessId + i;
   }
@@ skipping 23 matching lines @@
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId,
                                       std::vector<uint32>());
   EXPECT_TRUE(UploadDataContains("SELECT", 1));
   EXPECT_TRUE(UploadDataContains("ADD_TO_DICT", 2));
 }
 
 // Spellcheck results that are out-of-bounds are not added to feedback.
 TEST_F(FeedbackSenderTest, IgnoreOutOfBounds) {
   std::vector<SpellCheckResult> results;
   results.push_back(SpellCheckResult(
-      SpellCheckResult::SPELLING, 0, 100, UTF8ToUTF16("Hello")));
+      SpellCheckResult::SPELLING, 0, 100, base::UTF8ToUTF16("Hello")));
   results.push_back(SpellCheckResult(
-      SpellCheckResult::SPELLING, 100, 3, UTF8ToUTF16("world")));
-  results.push_back(
-      SpellCheckResult(SpellCheckResult::SPELLING, -1, 3, UTF8ToUTF16("how")));
-  results.push_back(
-      SpellCheckResult(SpellCheckResult::SPELLING, 0, 0, UTF8ToUTF16("are")));
-  results.push_back(
-      SpellCheckResult(SpellCheckResult::SPELLING, 2, -1, UTF8ToUTF16("you")));
+      SpellCheckResult::SPELLING, 100, 3, base::UTF8ToUTF16("world")));
+  results.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, -1, 3, base::UTF8ToUTF16("how")));
+  results.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 0, 0, base::UTF8ToUTF16("are")));
+  results.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 2, -1, base::UTF8ToUTF16("you")));
   feedback_->OnSpellcheckResults(kRendererProcessId,
-                                 UTF8ToUTF16(kText),
+                                 base::UTF8ToUTF16(kText),
                                  std::vector<SpellCheckMarker>(),
                                  &results);
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId,
                                       std::vector<uint32>());
   EXPECT_FALSE(IsUploadingData());
 }
 
 // FeedbackSender does not collect and upload feedback when instructed to stop.
 TEST_F(FeedbackSenderTest, CanStopFeedbackCollection) {
   feedback_->StopFeedbackCollection();
@@ skipping 20 matching lines @@
   AddPendingFeedback();
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId,
                                       std::vector<uint32>());
   feedback_->StartFeedbackCollection();
   feedback_->OnReceiveDocumentMarkers(kRendererProcessId,
                                       std::vector<uint32>());
   EXPECT_FALSE(IsUploadingData());
 }
 
 }  // namespace spellcheck