Rename third_party/hunspell_new back to third_party/hunspell.

third_party/hunspell_new/google.patch

-Index: src/hunspell/affixmgr.cxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/affixmgr.cxx,v
-retrieving revision 1.41
-diff -u -r1.41 affixmgr.cxx
---- src/hunspell/affixmgr.cxx   16 Dec 2011 09:15:34 -0000      1.41
-+++ src/hunspell/affixmgr.cxx   29 May 2014 01:05:07 -0000
-@@ -14,8 +14,14 @@
- 
- #include "csutil.hxx"
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+AffixMgr::AffixMgr(hunspell::BDictReader* reader, HashMgr** ptr, int * md)
-+{
-+  bdict_reader = reader;
-+#else
- AffixMgr::AffixMgr(const char * affpath, HashMgr** ptr, int * md, const char * key) 
- {
-+#endif
-   // register hash manager and load affix data from aff file
-   pHMgr = ptr[0];
-   alldic = ptr;
-@@ -107,9 +113,17 @@
-      sFlag[i] = NULL;
-   }
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // Define dummy parameters for parse_file() to avoid changing the parameters
-+  // of parse_file(). This may make it easier to merge the changes of the
-+  // original hunspell.
-+  const char* affpath = NULL;
-+  const char* key = NULL;
-+#else
-   for (int j=0; j < CONTSIZE; j++) {
-     contclasses[j] = 0;
-   }
-+#endif
- 
-   if (parse_file(affpath, key)) {
-      HUNSPELL_WARNING(stderr, "Failure loading aff file %s\n",affpath);
-@@ -269,6 +283,43 @@
-   char * line; // io buffers
-   char ft;     // affix type
-   
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // open the affix file
-+  // We're always UTF-8
-+  utf8 = 1;
-+
-+  // A BDICT file stores PFX and SFX lines in a special section and it provides
-+  // a special line iterator for reading PFX and SFX lines.
-+  // We create a FileMgr object from this iterator and parse PFX and SFX lines
-+  // before parsing other lines.
-+  hunspell::LineIterator affix_iterator = bdict_reader->GetAffixLineIterator();
-+  FileMgr* iterator = new FileMgr(&affix_iterator);
-+  if (!iterator) {
-+    HUNSPELL_WARNING(stderr,
-+        "error: could not create a FileMgr from an affix line iterator.\n");
-+    return 1;
-+  }
-+
-+  while ((line = iterator->getline())) {
-+    ft = ' ';
-+    if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';
-+    if (strncmp(line,"SFX",3) == 0) ft = complexprefixes ? 'P' : 'S';
-+    if (ft != ' ')
-+      parse_affix(line, ft, iterator, NULL);
-+  }
-+  delete iterator;
-+
-+  // Create a FileMgr object for reading lines except PFX and SFX lines.
-+  // We don't need to change the loop below since our FileMgr emulates the
-+  // original one.
-+  hunspell::LineIterator other_iterator = bdict_reader->GetOtherLineIterator();
-+  FileMgr * afflst = new FileMgr(&other_iterator);
-+  if (!afflst) {
-+    HUNSPELL_WARNING(stderr,
-+        "error: could not create a FileMgr from an other line iterator.\n");
-+    return 1;
-+  }
-+#else
-   // checking flag duplication
-   char dupflags[CONTSIZE];
-   char dupflags_ini = 1;
-@@ -282,6 +333,7 @@
-     HUNSPELL_WARNING(stderr, "error: could not open affix description file %s\n",affpath);
-     return 1;
-   }
-+#endif
- 
-   // step one is to parse the affix file building up the internal
-   // affix data structures
-@@ -291,6 +343,7 @@
-     while ((line = afflst->getline()) != NULL) {
-        mychomp(line);
- 
-+#ifndef HUNSPELL_CHROME_CLIENT
-        /* remove byte order mark */
-        if (firstline) {
-          firstline = 0;
-@@ -299,6 +352,7 @@
-             memmove(line, line+3, strlen(line+3)+1);
-          }
-        }
-+#endif
- 
-        /* parse in the keyboard string */
-        if (strncmp(line,"KEY",3) == 0) {
-@@ -545,6 +599,7 @@
-           }
-        }
- 
-+#ifndef HUNSPELL_CHROME_CLIENT
-        /* parse in the typical fault correcting table */
-        if (strncmp(line,"REP",3) == 0) {
-           if (parse_reptable(line, afflst)) {
-@@ -552,6 +607,7 @@
-              return 1;
-           }
-        }
-+#endif
- 
-        /* parse in the input conversion table */
-        if (strncmp(line,"ICONV",5) == 0) {
-@@ -699,6 +755,7 @@
-                    checksharps=1;
-        }
- 
-+#ifndef HUNSPELL_CHROME_CLIENT
-        /* parse this affix: P - prefix, S - suffix */
-        ft = ' ';
-        if (strncmp(line,"PFX",3) == 0) ft = complexprefixes ? 'S' : 'P';
-@@ -713,6 +770,7 @@
-              return 1;
-           }
-        }
-+#endif
-     }
- 
-     finishFileMgr(afflst);
-@@ -1307,6 +1365,26 @@
-   const char * r;
-   int lenr, lenp;
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  const char *pattern, *pattern2;
-+  hunspell::ReplacementIterator iterator = bdict_reader->GetReplacementIterator();
-+  while (iterator.GetNext(&pattern, &pattern2)) {
-+    r = word;
-+    lenr = strlen(pattern2);
-+    lenp = strlen(pattern);
-+
-+    // search every occurence of the pattern in the word
-+    while ((r=strstr(r, pattern)) != NULL) {
-+      strcpy(candidate, word);
-+      if (r-word + lenr + strlen(r+lenp) >= MAXLNLEN) break;
-+      strcpy(candidate+(r-word), pattern2);
-+      strcpy(candidate+(r-word)+lenr, r+lenp);
-+      if (candidate_check(candidate,strlen(candidate))) return 1;
-+      r++; // search for the next letter
-+    }
-+  }
-+
-+#else
-   if ((wl < 2) || !numrep) return 0;
- 
-   for (int i=0; i < numrep; i++ ) {
-@@ -1323,6 +1401,7 @@
-           r++; // search for the next letter
-       }
-    }
-+#endif
-    return 0;
- }
- 
-@@ -4219,6 +4298,7 @@
-              case 1: { 
-                     np++;
-                     aflag = pHMgr->decode_flag(piece);
-+#ifndef HUNSPELL_CHROME_CLIENT // We don't check for duplicates.
-                     if (((at == 'S') && (dupflags[aflag] & dupSFX)) ||
-                         ((at == 'P') && (dupflags[aflag] & dupPFX))) {
-                         HUNSPELL_WARNING(stderr, "error: line %d: multiple definitions of an affix flag\n",
-@@ -4226,6 +4306,7 @@
-                         // return 1; XXX permissive mode for bad dictionaries
-                     }
-                     dupflags[aflag] += (char) ((at == 'S') ? dupSFX : dupPFX);
-+#endif
-                     break; 
-                     }
-              // piece 3 - is cross product indicator 
-Index: src/hunspell/affixmgr.hxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/affixmgr.hxx,v
-retrieving revision 1.15
-diff -u -r1.15 affixmgr.hxx
---- src/hunspell/affixmgr.hxx   13 Oct 2011 13:41:54 -0000      1.15
-+++ src/hunspell/affixmgr.hxx   29 May 2014 01:05:07 -0000
-@@ -18,6 +18,40 @@
- class PfxEntry;
- class SfxEntry;
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+
-+#include <vector>
-+
-+// This class provides an implementation of the contclasses array in AffixMgr
-+// that is normally a large static array. We should almost never need more than
-+// 256 elements, so this class only allocates that much to start off with. If
-+// elements higher than that are actually used, we'll automatically expand.
-+class ContClasses {
-+ public:
-+  ContClasses() {
-+    // Pre-allocate a buffer so that typically, we'll never have to resize.
-+    EnsureSizeIs(256);
-+  }
-+
-+  char& operator[](size_t index) {
-+    EnsureSizeIs(index + 1);
-+    return data[index];
-+  }
-+
-+  void EnsureSizeIs(size_t new_size) {
-+    if (data.size() >= new_size)
-+      return;  // Nothing to do.
-+
-+    size_t old_size = data.size();
-+    data.resize(new_size);
-+    memset(&data[old_size], 0, new_size - old_size);
-+  }
-+
-+  std::vector<char> data;
-+};
-+
-+#endif  // HUNSPELL_CHROME_CLIENT
-+
- class LIBHUNSPELL_DLL_EXPORTED AffixMgr
- {
- 
-@@ -106,12 +140,20 @@
-   int                 fullstrip;
- 
-   int                 havecontclass; // boolean variable
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  ContClasses         contclasses;
-+#else
-   char                contclasses[CONTSIZE]; // flags of possible continuing classes (twofold affix)
-+#endif
- 
- public:
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  AffixMgr(hunspell::BDictReader* reader, HashMgr** ptr, int * md);
-+#else
-   AffixMgr(const char * affpath, HashMgr** ptr, int * md,
-     const char * key = NULL);
-+#endif
-   ~AffixMgr();
-   struct hentry *     affix_check(const char * word, int len,
-             const unsigned short needflag = (unsigned short) 0,
-@@ -218,6 +260,10 @@
-   int                 get_fullstrip() const;
- 
- private:
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // Not owned by us, owned by the Hunspell object.
-+  hunspell::BDictReader* bdict_reader;
-+#endif
-   int  parse_file(const char * affpath, const char * key);
-   int  parse_flag(char * line, unsigned short * out, FileMgr * af);
-   int  parse_num(char * line, int * out, FileMgr * af);
-@@ -249,4 +295,3 @@
- };
- 
- #endif
--
-Index: src/hunspell/filemgr.cxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/filemgr.cxx,v
-retrieving revision 1.5
-diff -u -r1.5 filemgr.cxx
---- src/hunspell/filemgr.cxx    23 Jun 2011 09:21:50 -0000      1.5
-+++ src/hunspell/filemgr.cxx    29 May 2014 01:05:07 -0000
-@@ -7,6 +7,32 @@
- 
- #include "filemgr.hxx"
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+#include "third_party/hunspell/google/bdict_reader.h"
-+
-+FileMgr::FileMgr(hunspell::LineIterator* iterator) : iterator_(iterator) {
-+}
-+
-+FileMgr::~FileMgr() {
-+}
-+
-+char * FileMgr::getline() {
-+  // Read one line from a BDICT file and store the line to our line buffer.
-+  // To emulate the original FileMgr::getline(), this function returns
-+  // the pointer to our line buffer if we can read a line without errors.
-+  // Otherwise, this function returns NULL.
-+  bool result = iterator_->AdvanceAndCopy(line_, BUFSIZE - 1);
-+  return result ? line_ : NULL;
-+}
-+
-+int FileMgr::getlinenum() {
-+  // This function is used only for displaying a line number that causes a
-+  // parser error. For a BDICT file, providing a line number doesn't help
-+  // identifying the place where causes a parser error so much since it is a
-+  // binary file. So, we just return 0.
-+  return 0;
-+}
-+#else
- int FileMgr::fail(const char * err, const char * par) {
-     fprintf(stderr, err, par);
-     return -1;
-@@ -47,3 +73,4 @@
- int FileMgr::getlinenum() {
-     return linenum;
- }
-+#endif
-Index: src/hunspell/filemgr.hxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/filemgr.hxx,v
-retrieving revision 1.3
-diff -u -r1.3 filemgr.hxx
---- src/hunspell/filemgr.hxx    15 Apr 2010 11:22:08 -0000      1.3
-+++ src/hunspell/filemgr.hxx    29 May 2014 01:05:07 -0000
-@@ -7,6 +7,30 @@
- #include "hunzip.hxx"
- #include <stdio.h>
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+namespace hunspell {
-+class LineIterator;
-+}  // namespace hunspell
-+
-+// A class which encapsulates operations of reading a BDICT file.
-+// Chrome uses a BDICT file to compress hunspell dictionaries. A BDICT file is
-+// a binary file converted from a DIC file and an AFF file. (See
-+// "bdict_reader.h" for its format.)
-+// This class encapsulates the operations of reading a BDICT file and emulates
-+// the original FileMgr operations for AffixMgr so that it can read a BDICT
-+// file without so many changes.
-+class FileMgr {
-+ public:
-+  FileMgr(hunspell::LineIterator* iterator);
-+  ~FileMgr();
-+  char* getline();
-+  int getlinenum();
-+
-+ protected:
-+  hunspell::LineIterator* iterator_;
-+  char line_[BUFSIZE + 50]; // input buffer
-+};
-+#else
- class LIBHUNSPELL_DLL_EXPORTED FileMgr
- {
- protected:
-@@ -23,3 +47,4 @@
-     int getlinenum();
- };
- #endif
-+#endif
-Index: src/hunspell/hashmgr.cxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/hashmgr.cxx,v
-retrieving revision 1.12
-diff -u -r1.12 hashmgr.cxx
---- src/hunspell/hashmgr.cxx    23 Jun 2011 09:21:50 -0000      1.12
-+++ src/hunspell/hashmgr.cxx    29 May 2014 01:05:07 -0000
-@@ -12,8 +12,14 @@
- 
- // build a hash table from a munched word list
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+HashMgr::HashMgr(hunspell::BDictReader* reader)
-+{
-+  bdict_reader = reader;
-+#else
- HashMgr::HashMgr(const char * tpath, const char * apath, const char * key)
- {
-+#endif
-   tablesize = 0;
-   tableptr = NULL;
-   flag_mode = FLAG_CHAR;
-@@ -31,8 +37,14 @@
-   numaliasm = 0;
-   aliasm = NULL;
-   forbiddenword = FORBIDDENWORD; // forbidden word signing flag
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // No tables to load, just the AF lines.
-+  load_config(NULL, NULL);
-+  int ec = LoadAFLines();
-+#else
-   load_config(apath, key);
-   int ec = load_tables(tpath, key);
-+#endif
-   if (ec) {
-     /* error condition - what should we do here */
-     HUNSPELL_WARNING(stderr, "Hash Manager Error : %d\n",ec);
-@@ -91,15 +103,58 @@
-   if (ignorechars) free(ignorechars);
-   if (ignorechars_utf16) free(ignorechars_utf16);
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  EmptyHentryCache();
-+  for (std::vector<std::string*>::iterator it = pointer_to_strings_.begin();
-+       it != pointer_to_strings_.end(); ++it) {
-+    delete *it;
-+  }
-+#endif
- #ifdef MOZILLA_CLIENT
-     delete [] csconv;
- #endif
- }
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+void HashMgr::EmptyHentryCache() {
-+  // We need to delete each cache entry, and each additional one in the linked
-+  // list of homonyms.
-+  for (HEntryCache::iterator i = hentry_cache.begin();
-+       i != hentry_cache.end(); ++i) {
-+    hentry* cur = i->second;
-+    while (cur) {
-+      hentry* next = cur->next_homonym;
-+      DeleteHashEntry(cur);
-+      cur = next;
-+    }
-+  }
-+  hentry_cache.clear();
-+}
-+#endif
-+
- // lookup a root word in the hashtable
- 
- struct hentry * HashMgr::lookup(const char *word) const
- {
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  int affix_ids[hunspell::BDict::MAX_AFFIXES_PER_WORD];
-+  int affix_count = bdict_reader->FindWord(word, affix_ids);
-+  if (affix_count == 0) { // look for custom added word
-+    std::map<base::StringPiece, int>::const_iterator iter = 
-+      custom_word_to_affix_id_map_.find(word);
-+    if (iter != custom_word_to_affix_id_map_.end()) {
-+      affix_count = 1;
-+      affix_ids[0] = iter->second;
-+    }
-+  }
-+
-+  static const int kMaxWordLen = 128;
-+  static char word_buf[kMaxWordLen];
-+  // To take account of null-termination, we use upto 127.
-+  strncpy(word_buf, word, kMaxWordLen - 1);
-+
-+  return AffixIDsToHentry(word_buf, affix_ids, affix_count);
-+#else
-     struct hentry * dp;
-     if (tableptr) {
-        dp = tableptr[hash(word)];
-@@ -109,12 +164,14 @@
-        }
-     }
-     return NULL;
-+#endif
- }
- 
- // add a word to the hash table (private)
- int HashMgr::add_word(const char * word, int wbl, int wcl, unsigned short * aff,
-     int al, const char * desc, bool onlyupcase)
- {
-+#ifndef HUNSPELL_CHROME_CLIENT
-     bool upcasehomonym = false;
-     int descl = desc ? (aliasm ? sizeof(short) : strlen(desc) + 1) : 0;
-     // variable-length hash record with word and optional fields
-@@ -206,6 +263,17 @@
-            if (hp->astr) free(hp->astr);
-            free(hp);
-        }
-+#else
-+    std::map<base::StringPiece, int>::iterator iter =
-+        custom_word_to_affix_id_map_.find(word);
-+    if(iter == custom_word_to_affix_id_map_.end()) {  // word needs to be added
-+      std::string* new_string_word = new std::string(word);
-+      pointer_to_strings_.push_back(new_string_word);
-+      base::StringPiece sp(*(new_string_word));
-+      custom_word_to_affix_id_map_[sp] = 0; // no affixes for custom words
-+      return 1;
-+    }
-+#endif
-     return 0;
- }     
- 
-@@ -256,6 +324,12 @@
- // remove word (personal dictionary function for standalone applications)
- int HashMgr::remove(const char * word)
- {
-+#ifdef HUNSPELL_CHROME_CLIENT
-+    std::map<base::StringPiece, int>::iterator iter =
-+        custom_word_to_affix_id_map_.find(word);
-+    if (iter != custom_word_to_affix_id_map_.end())
-+        custom_word_to_affix_id_map_.erase(iter);
-+#else
-     struct hentry * dp = lookup(word);
-     while (dp) {
-         if (dp->alen == 0 || !TESTAFF(dp->astr, forbiddenword, dp->alen)) {
-@@ -270,6 +344,7 @@
-         }
-         dp = dp->next_homonym;
-     }
-+#endif
-     return 0;
- }
- 
-@@ -339,6 +414,44 @@
- // initialize: col=-1; hp = NULL; hp = walk_hashtable(&col, hp);
- struct hentry * HashMgr::walk_hashtable(int &col, struct hentry * hp) const
- {  
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // Return NULL if dictionary is not valid.
-+  if (!bdict_reader->IsValid())
-+    return NULL;
-+
-+  // This function is only ever called by one place and not nested. We can
-+  // therefore keep static state between calls and use |col| as a "reset" flag
-+  // to avoid changing the API. It is set to -1 for the first call.
-+  // Allocate the iterator on the heap to prevent an exit time destructor.
-+  static hunspell::WordIterator& word_iterator =
-+      *new hunspell::WordIterator(bdict_reader->GetAllWordIterator());
-+  if (col < 0) {
-+    col = 1;
-+    word_iterator = bdict_reader->GetAllWordIterator();
-+  }
-+
-+  int affix_ids[hunspell::BDict::MAX_AFFIXES_PER_WORD];
-+  static const int kMaxWordLen = 128;
-+  static char word[kMaxWordLen];
-+  int affix_count = word_iterator.Advance(word, kMaxWordLen, affix_ids);
-+  if (affix_count == 0)
-+    return NULL;
-+  short word_len = static_cast<short>(strlen(word));
-+
-+  // Since hunspell 1.2.8, an hentry struct becomes a variable-length struct,
-+  // i.e. a struct which uses its array 'word[1]' as a variable-length array.
-+  // As noted above, this function is not nested. So, we just use a static
-+  // struct which consists of an hentry and a char[kMaxWordLen], and initialize
-+  // the static struct and return it for now.
-+  // No need to create linked lists for the extra affixes.
-+  static struct {
-+    hentry entry;
-+    char word[kMaxWordLen];
-+  } hash_entry;
-+
-+  return InitHashEntry(&hash_entry.entry, sizeof(hash_entry),
-+                       &word[0], word_len, affix_ids[0]);
-+#else
-   if (hp && hp->next != NULL) return hp->next;
-   for (col++; col < tablesize; col++) {
-     if (tableptr[col]) return tableptr[col];
-@@ -346,11 +459,13 @@
-   // null at end and reset to start
-   col = -1;
-   return NULL;
-+#endif
- }
- 
- // load a munched word list and build a hash table on the fly
- int HashMgr::load_tables(const char * tpath, const char * key)
- {
-+#ifndef HUNSPELL_CHROME_CLIENT
-   int al;
-   char * ap;
-   char * dp;
-@@ -471,6 +586,7 @@
-   }
- 
-   delete dict;
-+#endif
-   return 0;
- }
- 
-@@ -479,6 +595,9 @@
- 
- int HashMgr::hash(const char * word) const
- {
-+#ifdef HUNSPELL_CHROME_CLIENT
-+    return 0;
-+#else
-     long  hv = 0;
-     for (int i=0; i < 4  &&  *word != 0; i++)
-         hv = (hv << 8) | (*word++);
-@@ -487,6 +606,7 @@
-       hv ^= (*word++);
-     }
-     return (unsigned long) hv % tablesize;
-+#endif
- }
- 
- int HashMgr::decode_flags(unsigned short ** result, char * flags, FileMgr * af) {
-@@ -607,7 +727,12 @@
-   int firstline = 1;
-  
-   // open the affix file
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  hunspell::LineIterator iterator = bdict_reader->GetOtherLineIterator();
-+  FileMgr * afflst = new FileMgr(&iterator);
-+#else
-   FileMgr * afflst = new FileMgr(affpath, key);
-+#endif
-   if (!afflst) {
-     HUNSPELL_WARNING(stderr, "Error - could not open affix description file %s\n",affpath);
-     return 1;
-@@ -802,6 +927,121 @@
-    return 0;
- }
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+int HashMgr::LoadAFLines()
-+{
-+  utf8 = 1;  // We always use UTF-8.
-+
-+  // Read in all the AF lines which tell us the rules for each affix group ID.
-+  hunspell::LineIterator iterator = bdict_reader->GetAfLineIterator();
-+  FileMgr afflst(&iterator);
-+  while (char* line = afflst.getline()) {
-+    int rv = parse_aliasf(line, &afflst);
-+    if (rv)
-+      return rv;
-+  }
-+
-+  return 0;
-+}
-+
-+hentry* HashMgr::InitHashEntry(hentry* entry,
-+                               size_t item_size,
-+                               const char* word,
-+                               int word_length,
-+                               int affix_index) const {
-+  // Return if the given buffer doesn't have enough space for a hentry struct
-+  // or the given word is too long.
-+  // Our BDICT cannot handle words longer than (128 - 1) bytes. So, it is
-+  // better to return an error if the given word is too long and prevent
-+  // an unexpected result caused by a long word.
-+  const int kMaxWordLen = 128;
-+  if (item_size < sizeof(hentry) + word_length + 1 ||
-+      word_length >= kMaxWordLen)
-+    return NULL;
-+
-+  // Initialize a hentry struct with the given parameters, and
-+  // append the given string at the end of this hentry struct.
-+  memset(entry, 0, item_size);
-+  FileMgr af(NULL);
-+  entry->alen = static_cast<short>(
-+      const_cast<HashMgr*>(this)->get_aliasf(affix_index, &entry->astr, &af));
-+  entry->blen = static_cast<unsigned char>(word_length);
-+  memcpy(&entry->word, word, word_length);
-+
-+  return entry;
-+}
-+
-+hentry* HashMgr::CreateHashEntry(const char* word,
-+                                 int word_length,
-+                                 int affix_index) const {
-+  // Return if the given word is too long.
-+  // (See the comment in HashMgr::InitHashEntry().)
-+  const int kMaxWordLen = 128;
-+  if (word_length >= kMaxWordLen)
-+    return NULL;
-+
-+  const size_t kEntrySize = sizeof(hentry) + word_length + 1;
-+  struct hentry* entry = reinterpret_cast<hentry*>(malloc(kEntrySize));
-+  if (entry)
-+    InitHashEntry(entry, kEntrySize, word, word_length, affix_index);
-+
-+  return entry;
-+}
-+
-+void HashMgr::DeleteHashEntry(hentry* entry) const {
-+  free(entry);
-+}
-+
-+hentry* HashMgr::AffixIDsToHentry(char* word,
-+                                  int* affix_ids, 
-+                                  int affix_count) const
-+{
-+  if (affix_count == 0)
-+    return NULL;
-+
-+  HEntryCache& cache = const_cast<HashMgr*>(this)->hentry_cache;
-+  std::string std_word(word);
-+  HEntryCache::iterator found = cache.find(std_word);
-+  if (found != cache.end()) {
-+    // We must return an existing hentry for the same word if we've previously
-+    // handed one out. Hunspell will compare pointers in some cases to see if
-+    // two words it has found are the same.
-+    return found->second;
-+  }
-+
-+  short word_len = static_cast<short>(strlen(word));
-+
-+  // We can get a number of prefixes per word. There will normally be only one,
-+  // but if not, there will be a linked list of "hentry"s for the "homonym"s 
-+  // for the word.
-+  struct hentry* first_he = NULL;
-+  struct hentry* prev_he = NULL;  // For making linked list.
-+  for (int i = 0; i < affix_count; i++) {
-+    struct hentry* he = CreateHashEntry(word, word_len, affix_ids[i]);
-+    if (!he)
-+      break;
-+    if (i == 0)
-+      first_he = he;
-+    if (prev_he)
-+      prev_he->next_homonym = he;
-+    prev_he = he;
-+  }
-+
-+  cache[std_word] = first_he;  // Save this word in the cache for later.
-+  return first_he;
-+}
-+
-+hentry* HashMgr::GetHentryFromHEntryCache(char* word) {
-+  HEntryCache& cache = const_cast<HashMgr*>(this)->hentry_cache;
-+  std::string std_word(word);
-+  HEntryCache::iterator found = cache.find(std_word);
-+  if (found != cache.end())
-+    return found->second;
-+  else
-+    return NULL;
-+}
-+#endif
-+
- int HashMgr::is_aliasf() {
-     return (aliasf != NULL);
- }
-Index: src/hunspell/hashmgr.hxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/hashmgr.hxx,v
-retrieving revision 1.3
-diff -u -r1.3 hashmgr.hxx
---- src/hunspell/hashmgr.hxx    15 Apr 2010 11:22:08 -0000      1.3
-+++ src/hunspell/hashmgr.hxx    29 May 2014 01:05:07 -0000
-@@ -8,10 +8,25 @@
- #include "htypes.hxx"
- #include "filemgr.hxx"
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+#include <string>
-+#include <map>
-+
-+#include "base/stl_util.h"
-+#include "base/strings/string_piece.h"
-+#include "third_party/hunspell/google/bdict_reader.h"
-+#endif
-+
- enum flag { FLAG_CHAR, FLAG_LONG, FLAG_NUM, FLAG_UNI };
- 
- class LIBHUNSPELL_DLL_EXPORTED HashMgr
- {
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // Not owned by this class, owned by the Hunspell object.
-+  hunspell::BDictReader* bdict_reader;
-+  std::map<base::StringPiece, int> custom_word_to_affix_id_map_;
-+  std::vector<std::string*> pointer_to_strings_;
-+#endif
-   int               tablesize;
-   struct hentry **  tableptr;
-   int               userword;
-@@ -34,7 +49,23 @@
- 
- 
- public:
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  HashMgr(hunspell::BDictReader* reader);
-+
-+  // Return the hentry corresponding to the given word. Returns NULL if the
-+  // word is not there in the cache.
-+  hentry* GetHentryFromHEntryCache(char* word);
-+
-+  // Called before we do a new operation. This will empty the cache of pointers
-+  // to hentries that we have cached. In Chrome, we make these on-demand, but
-+  // they must live as long as the single spellcheck operation that they're part
-+  // of since Hunspell will save pointers to various ones as it works.
-+  //
-+  // This function allows that cache to be emptied and not grow infinitely.
-+  void EmptyHentryCache();
-+#else
-   HashMgr(const char * tpath, const char * apath, const char * key = NULL);
-+#endif
-   ~HashMgr();
- 
-   struct hentry * lookup(const char *) const;
-@@ -59,6 +90,40 @@
-     int al, const char * desc, bool onlyupcase);
-   int load_config(const char * affpath, const char * key);
-   int parse_aliasf(char * line, FileMgr * af);
-+
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // Loads the AF lines from a BDICT.
-+  // A BDICT file compresses its AF lines to save memory.
-+  // This function decompresses each AF line and call parse_aliasf().
-+  int LoadAFLines();
-+
-+  // Helper functions that create a new hentry struct, initialize it, and
-+  // delete it.
-+  // These functions encapsulate non-trivial operations in creating and
-+  // initializing a hentry struct from BDICT data to avoid changing code so much
-+  // even when a hentry struct is changed.
-+  hentry* InitHashEntry(hentry* entry,
-+                        size_t item_size,
-+                        const char* word,
-+                        int word_length,
-+                        int affix_index) const;
-+  hentry* CreateHashEntry(const char* word,
-+                          int word_length,
-+                          int affix_index) const;
-+  void DeleteHashEntry(hentry* entry) const;
-+
-+  // Converts the list of affix IDs to a linked list of hentry structures. The
-+  // hentry structures will point to the given word. The returned pointer will
-+  // be a statically allocated variable that will change for the next call. The
-+  // |word| buffer must be the same.
-+  hentry* AffixIDsToHentry(char* word, int* affix_ids, int affix_count) const;
-+
-+  // See EmptyHentryCache above. Note that each one is actually a linked list
-+  // followed by the homonym pointer.
-+  typedef std::map<std::string, hentry*> HEntryCache;
-+  HEntryCache hentry_cache;
-+#endif
-+
-   int add_hidden_capitalized_word(char * word, int wbl, int wcl,
-     unsigned short * flags, int al, char * dp, int captype);
-   int parse_aliasm(char * line, FileMgr * af);
-Index: src/hunspell/htypes.hxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/htypes.hxx,v
-retrieving revision 1.3
-diff -u -r1.3 htypes.hxx
---- src/hunspell/htypes.hxx     6 Sep 2010 07:58:53 -0000       1.3
-+++ src/hunspell/htypes.hxx     29 May 2014 01:05:07 -0000
-@@ -1,6 +1,16 @@
- #ifndef _HTYPES_HXX_
- #define _HTYPES_HXX_
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+// This is a workaround for preventing errors in parsing Turkish BDICs, which
-+// contain very long AF lines (~ 12,000 chars).
-+// TODO(hbono) change the HashMgr::parse_aliasf() function to be able to parse
-+// longer lines than MAXDELEN.
-+#define MAXDELEN    (8192 * 2)
-+#else
-+#define MAXDELEN    8192
-+#endif  // HUNSPELL_CHROME_CLIENT
-+
- #define ROTATE_LEN   5
- 
- #define ROTATE(v,q) \
-Index: src/hunspell/hunspell.cxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/hunspell.cxx,v
-retrieving revision 1.29
-diff -u -r1.29 hunspell.cxx
---- src/hunspell/hunspell.cxx   23 Jun 2011 09:21:50 -0000      1.29
-+++ src/hunspell/hunspell.cxx   29 May 2014 01:05:07 -0000
-@@ -7,20 +7,37 @@
- 
- #include "hunspell.hxx"
- #include "hunspell.h"
-+#ifndef HUNSPELL_CHROME_CLIENT
- #ifndef MOZILLA_CLIENT
- #    include "config.h"
- #endif
-+#endif
- #include "csutil.hxx"
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+Hunspell::Hunspell(const unsigned char* bdict_data, size_t bdict_length)
-+#else
- Hunspell::Hunspell(const char * affpath, const char * dpath, const char * key)
-+#endif
- {
-     encoding = NULL;
-     csconv = NULL;
-     utf8 = 0;
-     complexprefixes = 0;
-+#ifndef HUNSPELL_CHROME_CLIENT
-     affixpath = mystrdup(affpath);
-+#endif
-     maxdic = 0;
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+    bdict_reader = new hunspell::BDictReader;
-+    bdict_reader->Init(bdict_data, bdict_length);
-+
-+    pHMgr[0] = new HashMgr(bdict_reader);
-+    if (pHMgr[0]) maxdic = 1;
-+
-+    pAMgr = new AffixMgr(bdict_reader, pHMgr, &maxdic);
-+#else
-     /* first set up the hash manager */
-     pHMgr[0] = new HashMgr(dpath, affpath, key);
-     if (pHMgr[0]) maxdic = 1;
-@@ -28,6 +45,7 @@
-     /* next set up the affix manager */
-     /* it needs access to the hash manager lookup methods */
-     pAMgr = new AffixMgr(affpath, pHMgr, &maxdic, key);
-+#endif
- 
-     /* get the preferred try string and the dictionary */
-     /* encoding from the Affix Manager for that dictionary */
-@@ -41,7 +59,11 @@
-     wordbreak = pAMgr->get_breaktable();
- 
-     /* and finally set up the suggestion manager */
-+#ifdef HUNSPELL_CHROME_CLIENT
-+    pSMgr = new SuggestMgr(bdict_reader, try_string, MAXSUGGESTION, pAMgr);
-+#else
-     pSMgr = new SuggestMgr(try_string, MAXSUGGESTION, pAMgr);
-+#endif
-     if (try_string) free(try_string);
- }
- 
-@@ -59,10 +81,16 @@
-     csconv= NULL;
-     if (encoding) free(encoding);
-     encoding = NULL;
-+#ifdef HUNSPELL_CHROME_CLIENT
-+    if (bdict_reader) delete bdict_reader;
-+    bdict_reader = NULL;
-+#else
-     if (affixpath) free(affixpath);
-     affixpath = NULL;
-+#endif
- }
- 
-+#ifndef HUNSPELL_CHROME_CLIENT
- // load extra dictionaries
- int Hunspell::add_dic(const char * dpath, const char * key) {
-     if (maxdic == MAXDIC || !affixpath) return 1;
-@@ -70,6 +98,7 @@
-     if (pHMgr[maxdic]) maxdic++; else return 1;
-     return 0;
- }
-+#endif
- 
- // make a copy of src at destination while removing all leading
- // blanks and removing any trailing periods after recording
-@@ -322,6 +351,9 @@
- 
- int Hunspell::spell(const char * word, int * info, char ** root)
- {
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  if (pHMgr[0]) pHMgr[0]->EmptyHentryCache();
-+#endif
-   struct hentry * rv=NULL;
-   // need larger vector. For example, Turkish capital letter I converted a
-   // 2-byte UTF-8 character (dotless i) by mkallsmall.
-@@ -586,6 +618,13 @@
-   if (!len)
-       return NULL;
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // We need to check if the word length is valid to make coverity (Event
-+  // fixed_size_dest: Possible overrun of N byte fixed size buffer) happy.
-+  if ((utf8 && strlen(word) >= MAXWORDUTF8LEN) || (!utf8 && strlen(word) >= MAXWORDLEN))
-+    return NULL;
-+#endif
-+
-   // word reversing wrapper for complex prefixes
-   if (complexprefixes) {
-     if (word != w2) {
-@@ -675,6 +714,9 @@
- 
- int Hunspell::suggest(char*** slst, const char * word)
- {
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  if (pHMgr[0]) pHMgr[0]->EmptyHentryCache();
-+#endif
-   int onlycmpdsug = 0;
-   char cw[MAXWORDUTF8LEN];
-   char wspace[MAXWORDUTF8LEN];
-@@ -1921,13 +1963,21 @@
- 
- Hunhandle *Hunspell_create(const char * affpath, const char * dpath)
- {
-+#ifdef HUNSPELL_CHROME_CLIENT
-+        return NULL;
-+#else
-         return (Hunhandle*)(new Hunspell(affpath, dpath));
-+#endif
- }
- 
- Hunhandle *Hunspell_create_key(const char * affpath, const char * dpath,
-     const char * key)
- {
-+#ifdef HUNSPELL_CHROME_CLIENT
-+        return NULL;
-+#else
-         return (Hunhandle*)(new Hunspell(affpath, dpath, key));
-+#endif
- }
- 
- void Hunspell_destroy(Hunhandle *pHunspell)
-Index: src/hunspell/hunspell.hxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/hunspell.hxx,v
-retrieving revision 1.6
-diff -u -r1.6 hunspell.hxx
---- src/hunspell/hunspell.hxx   21 Jan 2011 17:30:41 -0000      1.6
-+++ src/hunspell/hunspell.hxx   29 May 2014 01:05:07 -0000
-@@ -5,6 +5,10 @@
- #include "suggestmgr.hxx"
- #include "langnum.hxx"
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+#include "third_party/hunspell/google/bdict_reader.h"
-+#endif
-+
- #define  SPELL_XML "<?xml?>"
- 
- #define MAXDIC 20
-@@ -23,7 +27,9 @@
-   HashMgr*        pHMgr[MAXDIC];
-   int             maxdic;
-   SuggestMgr*     pSMgr;
-+#ifndef HUNSPELL_CHROME_CLIENT // We are using BDict instead.
-   char *          affixpath;
-+#endif
-   char *          encoding;
-   struct cs_info * csconv;
-   int             langnum;
-@@ -31,17 +37,28 @@
-   int             complexprefixes;
-   char**          wordbreak;
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  // Not owned by us, owned by the Hunspell object.
-+  hunspell::BDictReader* bdict_reader;
-+#endif
-+
- public:
- 
-   /* Hunspell(aff, dic) - constructor of Hunspell class
-    * input: path of affix file and dictionary file
-    */
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  Hunspell(const unsigned char* bdict_data, size_t bdict_length);
-+#else
-   Hunspell(const char * affpath, const char * dpath, const char * key = NULL);
-+#endif
-   ~Hunspell();
- 
-+#ifndef HUNSPELL_CHROME_CLIENT
-   /* load extra dictionaries (only dic files) */
-   int add_dic(const char * dpath, const char * key = NULL);
-+#endif
- 
-   /* spell(word) - spellcheck word
-    * output: 0 = bad word, not 0 = good word
-Index: src/hunspell/replist.hxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/replist.hxx,v
-retrieving revision 1.2
-diff -u -r1.2 replist.hxx
---- src/hunspell/replist.hxx    15 Apr 2010 11:22:09 -0000      1.2
-+++ src/hunspell/replist.hxx    29 May 2014 01:05:07 -0000
-@@ -2,6 +2,12 @@
- #ifndef _REPLIST_HXX_
- #define _REPLIST_HXX_
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+// Compilation issues in spellchecker.cc think near is a macro, therefore
-+// removing it here solves that problem.
-+#undef near
-+#endif
-+
- #include "hunvisapi.h"
- 
- #include "w_char.hxx"
-Index: src/hunspell/suggestmgr.cxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/suggestmgr.cxx,v
-retrieving revision 1.24
-diff -u -r1.24 suggestmgr.cxx
---- src/hunspell/suggestmgr.cxx 14 Feb 2011 21:47:24 -0000      1.24
-+++ src/hunspell/suggestmgr.cxx 29 May 2014 01:05:07 -0000
-@@ -12,9 +12,114 @@
- 
- const w_char W_VLINE = { '\0', '|' };
- 
-+#ifdef HUNSPELL_CHROME_CLIENT
-+namespace {
-+// A simple class which creates temporary hentry objects which are available
-+// only in a scope. To conceal memory operations from SuggestMgr functions,
-+// this object automatically deletes all hentry objects created through
-+// CreateScopedHashEntry() calls in its destructor. So, the following snippet
-+// raises a memory error.
-+//
-+//   hentry* bad_copy = NULL;
-+//   {
-+//     ScopedHashEntryFactory factory;
-+//     hentry* scoped_copy = factory.CreateScopedHashEntry(0, source);
-+//     ...
-+//     bad_copy = scoped_copy;
-+//   }
-+//   if (bad_copy->word[0])  // memory for scoped_copy has been deleted!
-+//
-+// As listed in the above snippet, it is simple to use this class.
-+// 1. Declare an instance of this ScopedHashEntryFactory, and;
-+// 2. Call its CreateHashEntry() member instead of using 'new hentry' or
-+//    'operator='.
-+//
-+class ScopedHashEntryFactory {
-+ public:
-+  ScopedHashEntryFactory();
-+  ~ScopedHashEntryFactory();
-+
-+  // Creates a temporary copy of the given hentry struct.
-+  // The returned copy is available only while this object is available.
-+  // NOTE: this function just calls memcpy() in creating a copy of the given
-+  // hentry struct, i.e. it does NOT copy objects referred by pointers of the
-+  // given hentry struct.
-+  hentry* CreateScopedHashEntry(int index, const hentry* source);
-+
-+ private:
-+  // A struct which encapsulates the new hentry struct introduced in hunspell
-+  // 1.2.8. For a pointer to an hentry struct 'h', hunspell 1.2.8 stores a word
-+  // (including a NUL character) into 'h->word[0]',...,'h->word[h->blen]' even
-+  // though arraysize(h->word[]) is 1. Also, it changed 'astr' to a pointer so
-+  // it can store affix flags into 'h->astr[0]',...,'h->astr[alen-1]'. To handle
-+  // this new hentry struct, we define a struct which combines three values: an
-+  // hentry struct 'hentry'; a char array 'word[kMaxWordLen]', and; an unsigned
-+  // short array 'astr' so a hentry struct 'h' returned from
-+  // CreateScopedHashEntry() satisfies the following equations:
-+  //   hentry* h = factory.CreateScopedHashEntry(0, source);
-+  //   h->word[0] == ((HashEntryItem*)h)->entry.word[0].
-+  //   h->word[1] == ((HashEntryItem*)h)->word[0].
-+  //   ...
-+  //   h->word[h->blen] == ((HashEntryItem*)h)->word[h->blen-1].
-+  //   h->astr[0] == ((HashEntryItem*)h)->astr[0].
-+  //   h->astr[1] == ((HashEntryItem*)h)->astr[1].
-+  //   ...
-+  //   h->astr[h->alen-1] == ((HashEntryItem*)h)->astr[h->alen-1].
-+  enum {
-+    kMaxWordLen = 128,
-+    kMaxAffixLen = 8,
-+  };
-+  struct HashEntryItem {
-+    hentry entry;
-+    char word[kMaxWordLen];
-+    unsigned short astr[kMaxAffixLen];
-+  };
-+
-+  HashEntryItem hash_items_[MAX_ROOTS];
-+};
-+
-+ScopedHashEntryFactory::ScopedHashEntryFactory() {
-+  memset(&hash_items_[0], 0, sizeof(hash_items_));
-+}
-+
-+ScopedHashEntryFactory::~ScopedHashEntryFactory() {
-+}
-+
-+hentry* ScopedHashEntryFactory::CreateScopedHashEntry(int index,
-+                                                      const hentry* source) {
-+  if (index >= MAX_ROOTS || source->blen >= kMaxWordLen)
-+    return NULL;
-+
-+  // Retrieve a HashEntryItem struct from our spool, initialize it, and
-+  // returns the address of its 'hentry' member.
-+  size_t source_size = sizeof(hentry) + source->blen + 1;
-+  HashEntryItem* hash_item = &hash_items_[index];
-+  memcpy(&hash_item->entry, source, source_size);
-+  if (source->astr) {
-+    hash_item->entry.alen = source->alen;
-+    if (hash_item->entry.alen > kMaxAffixLen)
-+      hash_item->entry.alen = kMaxAffixLen;
-+    memcpy(hash_item->astr, source->astr, hash_item->entry.alen * sizeof(hash_item->astr[0]));
-+    hash_item->entry.astr = &hash_item->astr[0];
-+  }
-+  return &hash_item->entry;
-+}
-+
-+}  // namespace
-+#endif
-+
-+
-+#ifdef HUNSPELL_CHROME_CLIENT
-+SuggestMgr::SuggestMgr(hunspell::BDictReader* reader,
-+                       const char * tryme, int maxn, 
-+                       AffixMgr * aptr)
-+{
-+  bdict_reader = reader;
-+#else
- SuggestMgr::SuggestMgr(const char * tryme, int maxn, 
-                        AffixMgr * aptr)
- {
-+#endif
- 
-   // register affix manager and check in string of chars to 
-   // try when building candidate suggestions
-@@ -407,6 +512,49 @@
-   int lenr, lenp;
-   int wl = strlen(word);
-   if (wl < 2 || ! pAMgr) return ns;
-+  
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  const char *pattern, *pattern2;
-+  hunspell::ReplacementIterator iterator = bdict_reader->GetReplacementIterator();
-+  while (iterator.GetNext(&pattern, &pattern2)) {
-+      r = word;
-+      lenr = strlen(pattern2);
-+      lenp = strlen(pattern);
-+      
-+      // search every occurence of the pattern in the word
-+      while ((r=strstr(r, pattern)) != NULL) {
-+          strcpy(candidate, word);
-+          if (r-word + lenr + strlen(r+lenp) >= MAXLNLEN) break;
-+          strcpy(candidate+(r-word), pattern2);
-+          strcpy(candidate+(r-word)+lenr, r+lenp);
-+          ns = testsug(wlst, candidate, wl-lenp+lenr, ns, cpdsuggest, NULL, NULL);
-+          if (ns == -1) return -1;
-+          // check REP suggestions with space
-+          char * sp = strchr(candidate, ' ');
-+          if (sp) {
-+            char * prev = candidate;
-+            while (sp) {
-+              *sp = '\0';
-+              if (checkword(prev, strlen(prev), 0, NULL, NULL)) {
-+                int oldns = ns;
-+                *sp = ' ';
-+                ns = testsug(wlst, sp + 1, strlen(sp + 1), ns, cpdsuggest, NULL, NULL);
-+                if (ns == -1) return -1;
-+                if (oldns < ns) {
-+                  free(wlst[ns - 1]);
-+                  wlst[ns - 1] = mystrdup(candidate);
-+                  if (!wlst[ns - 1]) return -1;
-+                }
-+              }
-+              *sp = ' ';
-+              prev = sp + 1;
-+              sp = strchr(prev, ' ');
-+            }
-+          }
-+          r++; // search for the next letter
-+    }
-+  }
-+#else
-   int numrep = pAMgr->get_numrep();
-   struct replentry* reptable = pAMgr->get_reptable();
-   if (reptable==NULL) return ns;
-@@ -448,6 +596,7 @@
-           r++; // search for the next letter
-       }
-    }
-+#endif
-    return ns;
- }
- 
-@@ -678,7 +827,9 @@
- // error is missing a letter it needs
- int SuggestMgr::forgotchar(char ** wlst, const char * word, int ns, int cpdsuggest)
- {
--   char candidate[MAXSWUTF8L];
-+   // TODO(rouslan): Remove the interim change below when this patch lands:
-+   // http://sf.net/tracker/?func=detail&aid=3595024&group_id=143754&atid=756395
-+   char candidate[MAXSWUTF8L + 4];
-    char * p;
-    clock_t timelimit = clock();
-    int timer = MINTIMER;
-@@ -700,8 +851,10 @@
- // error is missing a letter it needs
- int SuggestMgr::forgotchar_utf(char ** wlst, const w_char * word, int wl, int ns, int cpdsuggest)
- {
--   w_char  candidate_utf[MAXSWL];
--   char    candidate[MAXSWUTF8L];
-+   // TODO(rouslan): Remove the interim change below when this patch lands:
-+   // http://sf.net/tracker/?func=detail&aid=3595024&group_id=143754&atid=756395
-+   w_char  candidate_utf[MAXSWL + 1];
-+   char    candidate[MAXSWUTF8L + 4];
-    w_char * p;
-    clock_t timelimit = clock();
-    int timer = MINTIMER;
-@@ -1057,6 +1210,9 @@
- 
-   struct hentry* hp = NULL;
-   int col = -1;
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  ScopedHashEntryFactory hash_entry_factory;
-+#endif
-   phonetable * ph = (pAMgr) ? pAMgr->get_phonetable() : NULL;
-   char target[MAXSWUTF8L];
-   char candidate[MAXSWUTF8L];
-@@ -1115,7 +1271,11 @@
- 
-     if (sc > scores[lp]) {
-       scores[lp] = sc;  
-+#ifdef HUNSPELL_CHROME_CLIENT
-+      roots[lp] = hash_entry_factory.CreateScopedHashEntry(lp, hp);
-+#else
-       roots[lp] = hp;
-+#endif
-       lval = sc;
-       for (j=0; j < MAX_ROOTS; j++)
-         if (scores[j] < lval) {
-@@ -1948,16 +2108,14 @@
-     m = strlen(s);
-     n = strlen(s2);
-   }
--  c = (char *) malloc((m + 1) * (n + 1));
--  b = (char *) malloc((m + 1) * (n + 1));
-+  c = (char *) calloc(m + 1, n + 1);
-+  b = (char *) calloc(m + 1, n + 1);
-   if (!c || !b) {
-     if (c) free(c);
-     if (b) free(b);
-     *result = NULL;
-     return;
-   }
--  for (i = 1; i <= m; i++) c[i*(n+1)] = 0;
--  for (j = 0; j <= n; j++) c[j] = 0;
-   for (i = 1; i <= m; i++) {
-     for (j = 1; j <= n; j++) {
-       if ( ((utf8) && (*((short *) su+i-1) == *((short *)su2+j-1)))
-Index: src/hunspell/suggestmgr.hxx
-===================================================================
-RCS file: /cvsroot/hunspell/hunspell/src/hunspell/suggestmgr.hxx,v
-retrieving revision 1.5
-diff -u -r1.5 suggestmgr.hxx
---- src/hunspell/suggestmgr.hxx 21 Jan 2011 22:10:24 -0000      1.5
-+++ src/hunspell/suggestmgr.hxx 29 May 2014 01:05:07 -0000
-@@ -52,7 +52,11 @@
- 
- 
- public:
-+#ifdef HUNSPELL_CHROME_CLIENT
-+  SuggestMgr(hunspell::BDictReader* reader, const char * tryme, int maxn, AffixMgr *aptr);
-+#else
-   SuggestMgr(const char * tryme, int maxn, AffixMgr *aptr);
-+#endif
-   ~SuggestMgr();
- 
-   int suggest(char*** slst, const char * word, int nsug, int * onlycmpdsug);
-@@ -66,6 +70,10 @@
-   char * suggest_morph_for_spelling_error(const char * word);
- 
- private:
-+#ifdef HUNSPELL_CHROME_CLIENT
-+   // Not owned by us, owned by the Hunspell object.
-+   hunspell::BDictReader* bdict_reader;
-+#endif
-    int testsug(char** wlst, const char * candidate, int wl, int ns, int cpdsuggest,
-      int * timer, clock_t * timelimit);
-    int checkword(const char *, int, int, int *, clock_t *);