Add LazyLineBreakIterator::Next/PreviousBreakOpportunity()

third_party/WebKit/Source/platform/text/TextBreakIterator.h

 /*
  * Copyright (C) 2006 Lars Knoll <lars@trolltech.com>
  * Copyright (C) 2007, 2011, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 62 matching lines @@
               // letters/numbers except some south east asians'.
 };
 
 class PLATFORM_EXPORT LazyLineBreakIterator final {
   STACK_ALLOCATED();
 
  public:
   LazyLineBreakIterator()
       : iterator_(0),
         cached_prior_context_(0),
-        cached_prior_context_length_(0) {
+        cached_prior_context_length_(0),
+        break_type_(LineBreakType::kNormal) {
     ResetPriorContext();
   }
 
   LazyLineBreakIterator(String string,
-                        const AtomicString& locale = AtomicString())
+                        const AtomicString& locale = AtomicString(),
+                        LineBreakType break_type = LineBreakType::kNormal)
       : string_(string),
         locale_(locale),
         iterator_(0),
         cached_prior_context_(0),
-        cached_prior_context_length_(0) {
+        cached_prior_context_length_(0),
+        break_type_(break_type) {
     ResetPriorContext();
   }
 
   ~LazyLineBreakIterator() {
     if (iterator_)
       ReleaseLineBreakIterator(iterator_);
   }
 
   String GetString() const { return string_; }
 
@@ skipping 39 matching lines @@
       if (prior_context_[0])
         ++prior_context_length;
     }
     return prior_context_length;
   }
 
   // Obtain text break iterator, possibly previously cached, where this iterator
   // is (or has been) initialized to use the previously stored string as the
   // primary breaking context and using previously stored prior context if
   // non-empty.
-  TextBreakIterator* Get(unsigned prior_context_length) {
+  TextBreakIterator* Get(unsigned prior_context_length) const {
     DCHECK(prior_context_length <= kPriorContextCapacity);
     const UChar* prior_context =
         prior_context_length
             ? &prior_context_[kPriorContextCapacity - prior_context_length]
             : 0;
     if (!iterator_) {
       if (string_.Is8Bit())
         iterator_ = AcquireLineBreakIterator(
             string_.Characters8(), string_.length(), locale_, prior_context,
             prior_context_length);
       else
         iterator_ = AcquireLineBreakIterator(
             string_.Characters16(), string_.length(), locale_, prior_context,
             prior_context_length);
       cached_prior_context_ = prior_context;
       cached_prior_context_length_ = prior_context_length;
     } else if (prior_context != cached_prior_context_ ||
                prior_context_length != cached_prior_context_length_) {
-      this->ResetStringAndReleaseIterator(string_, locale_);
-      return this->Get(prior_context_length);
+      ReleaseIterator();
+      return Get(prior_context_length);
     }
     return iterator_;
   }
 
   void ResetStringAndReleaseIterator(String string,
                                      const AtomicString& locale) {
-    if (iterator_)
-      ReleaseLineBreakIterator(iterator_);
-
     string_ = string;
     locale_ = locale;
-    iterator_ = 0;
-    cached_prior_context_ = 0;
-    cached_prior_context_length_ = 0;
+
+    ReleaseIterator();
   }
 
-  inline bool IsBreakable(
-      int pos,
-      int& next_breakable,
-      LineBreakType line_break_type = LineBreakType::kNormal) {
+  void SetLocale(const AtomicString& locale) {
+    if (locale == locale_)
+      return;
+    locale_ = locale;
+    ReleaseIterator();
+  }
+
+  void SetBreakType(LineBreakType break_type) { break_type_ = break_type; }
+
+  inline bool IsBreakable(int pos,
+                          int& next_breakable,
+                          LineBreakType line_break_type) const {
     if (pos > next_breakable) {
       switch (line_break_type) {
         case LineBreakType::kBreakAll:
           next_breakable = NextBreakablePositionBreakAll(pos);
           break;
         case LineBreakType::kKeepAll:
           next_breakable = NextBreakablePositionKeepAll(pos);
           break;
         default:
           next_breakable = NextBreakablePositionIgnoringNBSP(pos);
       }
     }
     return pos == next_breakable;
   }
 
+  inline bool IsBreakable(int pos, int& next_breakable) const {
+    return IsBreakable(pos, next_breakable, break_type_);
+  }
+
+  // Returns the break opportunity at or after |offset|.
+  unsigned NextBreakOpportunity(unsigned offset) const;
+
+  // Returns the break opportunity at or before |offset|.
+  unsigned PreviousBreakOpportunity(unsigned offset, unsigned min = 0) const;
+
  private:
-  int NextBreakablePositionIgnoringNBSP(int pos);
-  int NextBreakablePositionBreakAll(int pos);
-  int NextBreakablePositionKeepAll(int pos);
+  void ReleaseIterator() const {
+    if (iterator_)
+      ReleaseLineBreakIterator(iterator_);
+    iterator_ = 0;
+    cached_prior_context_ = 0;
+    cached_prior_context_length_ = 0;
+  }
+
+  int NextBreakablePositionIgnoringNBSP(int pos) const;
+  int NextBreakablePositionBreakAll(int pos) const;
+  int NextBreakablePositionKeepAll(int pos) const;
 
   static const unsigned kPriorContextCapacity = 2;
   String string_;
   AtomicString locale_;
-  TextBreakIterator* iterator_;
+  mutable TextBreakIterator* iterator_;
   UChar prior_context_[kPriorContextCapacity];
-  const UChar* cached_prior_context_;
-  unsigned cached_prior_context_length_;
+  mutable const UChar* cached_prior_context_;
+  mutable unsigned cached_prior_context_length_;
+  LineBreakType break_type_;
 };
 
 // Iterates over "extended grapheme clusters", as defined in UAX #29.
 // Note that platform implementations may be less sophisticated - e.g. ICU prior
 // to version 4.0 only supports "legacy grapheme clusters".  Use this for
 // general text processing, e.g. string truncation.
 
 class PLATFORM_EXPORT NonSharedCharacterBreakIterator final {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(NonSharedCharacterBreakIterator);
@@ skipping 45 matching lines @@
 };
 
 // Counts the number of grapheme clusters. A surrogate pair or a sequence
 // of a non-combining character and following combining characters is
 // counted as 1 grapheme cluster.
 PLATFORM_EXPORT unsigned NumGraphemeClusters(const String&);
 
 }  // namespace blink
 
 #endif