base/i18n: Add namespace i18n to CharIterator.

chrome/browser/chromeos/login/wizard_accessibility_handler.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/chromeos/login/wizard_accessibility_handler.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/accessibility_events.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/speech_synthesis_library.h"
 #include "chrome/browser/extensions/extension_accessibility_api.h"
 #include "chrome/browser/extensions/extension_accessibility_api_constants.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/notification_details.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_source.h"
 #include "grit/generated_resources.h"
 
 namespace keys = extension_accessibility_api_constants;
 
 namespace {
 
 static std::string SubstringUTF8(std::string str, int start, int len) {
-  base::UTF8CharIterator iter(&str);
+  base::i18n::UTF8CharIterator iter(&str);
   for (int i = 0; i < start; i++) {
     if (!iter.Advance())
       return std::string();
   }
 
   int byte_start = iter.array_pos();
   for (int i = 0; i < len; i++) {
     if (!iter.Advance())
       break;
   }
@@ skipping 252 matching lines @@
   } else {
     DescribeTextContentsChanged(old_value, new_value,
                                 out_spoken_description);
   }
 }
 
 std::string WizardAccessibilityHandler::GetTextBoxValue(
     const AccessibilityTextBoxInfo* textbox_info) {
   std::string value = textbox_info->value();
   if (textbox_info->password()) {
-    base::UTF8CharIterator iter(&value);
+    base::i18n::UTF8CharIterator iter(&value);
     std::string obscured;
     while (!iter.end()) {
       obscured += "*";
       iter.Advance();
     }
     return obscured;
   } else {
     return value;
   }
 }
@@ skipping 56 matching lines @@
     const std::string& old_value,
     const std::string& new_value,
     std::string* out_spoken_description) {
   int old_array_len = old_value.size();
   int new_array_len = new_value.size();
 
   // Get the unicode characters and indices of the start of each
   // character's UTF8-encoded representation.
   scoped_array<int32> old_chars(new int32[old_array_len]);
   scoped_array<int> old_indices(new int[old_array_len + 1]);
-  base::UTF8CharIterator old_iter(&old_value);
+  base::i18n::UTF8CharIterator old_iter(&old_value);
   while (!old_iter.end()) {
     old_chars[old_iter.char_pos()] = old_iter.get();
     old_indices[old_iter.char_pos()] = old_iter.array_pos();
     old_iter.Advance();
   }
   int old_char_len = old_iter.char_pos();
   old_indices[old_char_len] = old_iter.array_pos();
 
   scoped_array<int32> new_chars(new int32[new_array_len]);
   scoped_array<int> new_indices(new int[new_array_len + 1]);
-  base::UTF8CharIterator new_iter(&new_value);
+  base::i18n::UTF8CharIterator new_iter(&new_value);
   while (!new_iter.end()) {
     new_chars[new_iter.char_pos()] = new_iter.get();
     new_indices[new_iter.char_pos()] = new_iter.array_pos();
     new_iter.Advance();
   }
   int new_char_len = new_iter.char_pos();
   new_indices[new_char_len] = new_iter.array_pos();
 
   // Find the common prefix of the two strings.
   int prefix_char_len = 0;
@@ skipping 35 matching lines @@
   } else if (inserted.size() > 0) {
     // Speak inserted text.
     AppendUtterance(inserted, out_spoken_description);
   } else if (deleted.size() > 0) {
     // Speak deleted text.
     AppendUtterance(deleted, out_spoken_description);
   }
 }
 
 }  // namespace chromeos