Updates SpellcheckWordIterator::GetNextWord to return an enum.

chrome/renderer/spellchecker/spellcheck_worditerator.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.
 
 // Implements a custom word iterator used for our spellchecker.
 
 #include "chrome/renderer/spellchecker/spellcheck_worditerator.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
 #include "third_party/icu/source/common/unicode/normlzr.h"
 #include "third_party/icu/source/common/unicode/schriter.h"
 #include "third_party/icu/source/common/unicode/uscript.h"
 #include "third_party/icu/source/i18n/unicode/ulocdata.h"
 
+using base::i18n::BreakIterator;
+
 // SpellcheckCharAttribute implementation:
 
 SpellcheckCharAttribute::SpellcheckCharAttribute()
     : script_code_(USCRIPT_LATIN) {
 }
 
 SpellcheckCharAttribute::~SpellcheckCharAttribute() {
 }
 
 void SpellcheckCharAttribute::SetDefaultLanguage(const std::string& language) {
@@ skipping 284 matching lines @@
     bool allow_contraction) {
   // Create a custom ICU break iterator with empty text used in this object. (We
   // allow setting text later so we can re-use this iterator.)
   DCHECK(attribute);
   const base::string16 rule(attribute->GetRuleSet(allow_contraction));
 
   // If there is no rule set, the attributes were invalid.
   if (rule.empty())
     return false;
 
-  scoped_ptr<base::i18n::BreakIterator> iterator(
-      new base::i18n::BreakIterator(base::string16(), rule));
+  scoped_ptr<BreakIterator> iterator(new BreakIterator(base::string16(), rule));
   if (!iterator->Init()) {
     // Since we're not passing in any text, the only reason this could fail
     // is if we fail to parse the rules. Since the rules are hardcoded,
     // that would be a bug in this class.
     NOTREACHED() << "failed to open iterator (broken rules)";
     return false;
   }
   iterator_ = iterator.Pass();
 
   // Set the character attributes so we can normalize the words extracted by
@@ skipping 13 matching lines @@
   // Set the text to be split by this iterator.
   if (!iterator_->SetText(text, length)) {
     LOG(ERROR) << "failed to set text";
     return false;
   }
 
   text_ = text;
   return true;
 }
 
-bool SpellcheckWordIterator::GetNextWord(base::string16* word_string,
-                                         int* word_start,
-                                         int* word_length) {
+SpellcheckWordIterator::WordIteratorStatus SpellcheckWordIterator::GetNextWord(
+    base::string16* word_string,
+    int* word_start,
+    int* word_length) {
   DCHECK(!!text_);
 
   word_string->clear();
   *word_start = 0;
   *word_length = 0;
 
   if (!text_) {
-    return false;
+    return IS_END_OF_TEXT;
   }
 
-  // Find a word that can be checked for spelling. Our rule sets filter out
-  // invalid words (e.g. numbers and characters not supported by the
-  // spellchecker language) so this ubrk_getRuleStatus() call returns
-  // UBRK_WORD_NONE when this iterator finds an invalid word. So, we skip such
-  // words until we can find a valid word or reach the end of the input string.
+  // Find a word that can be checked for spelling or a character that can be
+  // skipped over. Rather than moving past a skippable character this returns
+  // IS_SKIPPABLE and defers handling the character to the calling function.
   while (iterator_->Advance()) {
     const size_t start = iterator_->prev();
     const size_t length = iterator_->pos() - start;
-    if (iterator_->IsWord()) {
-      if (Normalize(start, length, word_string)) {
+    switch (iterator_->GetWordBreakStatus()) {
+      case BreakIterator::IS_WORD_BREAK: {
+        if (Normalize(start, length, word_string)) {
+          *word_start = start;
+          *word_length = length;
+          return IS_WORD;
+        }
+        break;
+      }
+      case BreakIterator::IS_SKIPPABLE_WORD: {
+        *word_string = iterator_->GetString();
         *word_start = start;
         *word_length = length;
-        return true;
+        return IS_SKIPPABLE;
+      }
+      // |iterator_| is RULE_BASED so the break status should never be
+      // IS_LINE_OR_CHAR_BREAK.
+      case BreakIterator::IS_LINE_OR_CHAR_BREAK: {
+        NOTREACHED();
+        break;
       }
     }
   }
 
   // There aren't any more words in the given text.
-  return false;
+  return IS_END_OF_TEXT;
 }
 
 void SpellcheckWordIterator::Reset() {
   iterator_.reset();
 }
 
 bool SpellcheckWordIterator::Normalize(int input_start,
                                        int input_length,
                                        base::string16* output_string) const {
   // We use NFKC (Normalization Form, Compatible decomposition, followed by
@@ skipping 10 matching lines @@
   if (status != U_ZERO_ERROR && status != U_STRING_NOT_TERMINATED_WARNING)
     return false;
 
   // Copy the normalized text to the output.
   icu::StringCharacterIterator it(output);
   for (UChar c = it.first(); c != icu::CharacterIterator::DONE; c = it.next())
     attribute_->OutputChar(c, output_string);
 
   return !output_string->empty();
 }