Use 'icu::' namespace explicitly

chrome/browser/history/snippet.cc

 // Copyright (c) 2006-2008 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/history/snippet.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
@@ skipping 100 matching lines @@
   while (*utf8_pos < offset) {
     U8_NEXT(utf8_string, *utf8_pos, utf8_length, wide_char);
     *wide_pos += (wide_char <= 0xFFFF) ? 1 : 2;
   }
   return *wide_pos;
 }
 
 // Given a character break iterator over a UTF-8 string, set the iterator
 // position to |*utf8_pos| and move by |count| characters. |count| can
 // be either positive or negative.
-void MoveByNGraphemes(BreakIterator* bi, int count, size_t* utf8_pos) {
+void MoveByNGraphemes(icu::BreakIterator* bi, int count, size_t* utf8_pos) {
   // Ignore the return value. A side effect of the current position
   // being set at or following |*utf8_pos| is exploited here.
   // It's simpler than calling following(n) and then previous().
   // isBoundary() is not very fast, but should be good enough for the
   // snippet generation. If not, revisit the way we scan in ComputeSnippet.
   bi->isBoundary(*utf8_pos);
   bi->next(count);
   *utf8_pos = static_cast<size_t>(bi->current());
 }
 
 // The amount of context to include for a given hit. Note that it's counted
 // in terms of graphemes rather than bytes.
 const int kSnippetContext = 50;
 
 // Returns true if next match falls within a snippet window
 // from the previous match. The window size is counted in terms
 // of graphemes rather than bytes in UTF-8.
-bool IsNextMatchWithinSnippetWindow(BreakIterator* bi,
+bool IsNextMatchWithinSnippetWindow(icu::BreakIterator* bi,
                                     size_t previous_match_end,
                                     size_t next_match_start) {
   // If it's within a window in terms of bytes, it's certain
   // that it's within a window in terms of graphemes as well.
   if (next_match_start < previous_match_end + kSnippetContext)
     return true;
   bi->isBoundary(previous_match_end);
   // An alternative to this is to call |bi->next()| at most
   // kSnippetContext times, compare |bi->current()| with |next_match_start|
   // after each call and return early if possible. There are other
   // heuristics to speed things up if necessary, but it's not likely that
   // we need to bother.
   bi->next(kSnippetContext);
   int64 current = bi->current();
   return (next_match_start < static_cast<uint64>(current) ||
-          current == BreakIterator::DONE);
+          current == icu::BreakIterator::DONE);
 }
 
 }  // namespace
 
 // static
 void Snippet::ExtractMatchPositions(const std::string& offsets_str,
                                     const std::string& column_num,
                                     MatchPositions* match_positions) {
   DCHECK(match_positions);
   if (offsets_str.empty())
@@ skipping 38 matching lines @@
   // We can generate longer snippets but stop once we cross kSnippetMaxLength.
   const size_t kSnippetMaxLength = 200;
   const std::wstring kEllipsis = L" ... ";
 
   UText* document_utext = NULL;
   UErrorCode status = U_ZERO_ERROR;
   document_utext = utext_openUTF8(document_utext, document.data(),
                                   document.size(), &status);
   // Locale does not matter because there's no per-locale customization
   // for character iterator.
-  scoped_ptr<BreakIterator> bi(
-    BreakIterator::createCharacterInstance(Locale::getDefault(), status));
+  scoped_ptr<icu::BreakIterator> bi(icu::BreakIterator::createCharacterInstance(
+      icu::Locale::getDefault(), status));
   bi->setText(document_utext, status);
   DCHECK(U_SUCCESS(status));
 
   // We build the snippet by iterating through the matches and then grabbing
   // context around each match.  If matches are near enough each other (within
   // kSnippetContext), we skip the "..." between them.
   std::wstring snippet;
   size_t start = 0;
   for (size_t i = 0; i < match_positions.size(); ++i) {
     // Some shorter names for the current match.
@@ skipping 49 matching lines @@
     start = end;
 
     // Stop here if we have enough snippet computed.
     if (snippet.size() >= kSnippetMaxLength)
       break;
   }
 
   utext_close(document_utext);
   swap(text_, snippet);
 }