Refactor code to avoid direct dependency upon ICU: spellcheck_worditerator

base/i18n/break_iterator.h

 // 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.
 
 #ifndef BASE_I18N_BREAK_ITERATOR_H_
 #define BASE_I18N_BREAK_ITERATOR_H_
 
 #include "base/basictypes.h"
 #include "base/i18n/base_i18n_export.h"
 #include "base/strings/string16.h"
@@ skipping 48 matching lines @@
  public:
   enum BreakType {
     BREAK_WORD,
     BREAK_LINE,
     // TODO(jshin): Remove this after reviewing call sites.
     // If call sites really need break only on space-like characters
     // implement it separately.
     BREAK_SPACE = BREAK_LINE,
     BREAK_NEWLINE,
     BREAK_CHARACTER,
+    // But don't remove this one!
+    RULE_BASED,
   };
 
   // Requires |str| to live as long as the BreakIterator does.
   BreakIterator(const string16& str, BreakType break_type);
+  // Make a rule-based iterator. BreakType == RULE_BASED is implied.
+  // TODO(andrewhayden): This signature could easily be misinterpreted as
+  // "(const string16& str, const string16& locale)". We should do something
+  // better.
+  BreakIterator(const string16& str, const string16& rules);
   ~BreakIterator();
 
   // Init() must be called before any of the iterators are valid.
   // Returns false if ICU failed to initialize.
   bool Init();
 
   // Advance to the next break.  Returns false if we've run past the end of
   // the string.  (Note that the very last "break" is after the final
   // character in the string, and when we advance to that position it's the
   // last time Advance() returns true.)
   bool Advance();
 
+  // Updates the text used by the iterator, resetting the iterator as if
+  // if Init() had been called again. Any old state is lost. Returns true
+  // unless there is an error setting the text.
+  bool SetText(const base::char16* text, const size_t length);
+
   // Under BREAK_WORD mode, returns true if the break we just hit is the
   // end of a word. (Otherwise, the break iterator just skipped over e.g.
   // whitespace or punctuation.)  Under BREAK_LINE and BREAK_NEWLINE modes,
   // this distinction doesn't apply and it always returns false.
   bool IsWord() const;
 
   // Under BREAK_WORD mode, returns true if |position| is at the end of word or
   // at the start of word. It always returns false under BREAK_LINE and
   // BREAK_NEWLINE modes.
   bool IsEndOfWord(size_t position) const;
@@ skipping 16 matching lines @@
     return pos_ != static_cast<size_t>(-1);
   }
 
  private:
   // ICU iterator, avoiding ICU ubrk.h dependence.
   // This is actually an ICU UBreakiterator* type, which turns out to be
   // a typedef for a void* in the ICU headers. Using void* directly prevents
   // callers from needing access to the ICU public headers directory.
   void* iter_;
 
-  // The string we're iterating over.
+  // The string we're iterating over. Can be changed with SetText(...)
   const string16& string_;
 
-  // The breaking style (word/space/newline).
+  // Rules for our iterator. Mutually exclusive with break_type_.
+  const string16 rules_;
+
+  // The breaking style (word/space/newline). Mutually exclusive with rules_
   BreakType break_type_;
 
   // Previous and current iterator positions.
   size_t prev_, pos_;
 
   DISALLOW_COPY_AND_ASSIGN(BreakIterator);
 };
 
 }  // namespace i18n
 }  // namespace base
 
 #endif  // BASE_I18N_BREAK_ITERATOR_H_