Spellchecker:...

chrome/browser/spellchecker.h

 // Copyright (c) 2006-2009 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 CHROME_BROWSER_SPELLCHECKER_H_
 #define CHROME_BROWSER_SPELLCHECKER_H_
 
+#include <queue>
+#include <string>
 #include <vector>
-#include <string>
 
 #include "app/l10n_util.h"
 #include "base/string_util.h"
+#include "base/task.h"
+#include "base/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/url_fetcher.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/spellcheck_worditerator.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_member.h"
-
-#include "base/task.h"
 #include "unicode/uscript.h"
 
 class FilePath;
 class Hunspell;
 class PrefService;
 class Profile;
 class MessageLoop;
 class URLRequestContext;
 class URLFetcher;
 
@@ skipping 77 matching lines @@
   // This function returns the corresponding language-region code for the
   // spell check language. For example, for hi, it returns hi-IN.
   static std::string GetSpellCheckLanguageRegion(std::string input_language);
 
   // This function returns ll (language code) from ll-RR where 'RR' (region
   // code) is redundant. However, if the region code matters, it's preserved.
   // That is, it returns 'hi' and 'en-GB' for 'hi-IN' and 'en-GB' respectively.
   static std::string GetLanguageFromLanguageRegion(std::string input_language);
 
  private:
+  friend class ReadDictionaryTask;
+
   // URLFetcher::Delegate implementation.  Called when we finish downloading the
   // spellcheck dictionary; saves the dictionary to disk.
-  // TODO(sidchat): Save to disk in the file thread instead of the IO thread.
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data);
 
   // When called, relays the request to check the spelling to the proper
   // backend, either hunspell or a platform-specific backend.
   bool CheckSpelling(const std::string& word_to_check, int tag);
 
   // When called, relays the request to fill the list with suggestions to
   // the proper backend, either hunspell or a platform-specific backend.
   void FillSuggestionList(const std::string& wrong_word,
                           std::vector<std::wstring>* optional_suggestions);
 
   // Initializes the Hunspell Dictionary.
   bool Initialize();
 
-  // After |hunspell_| is initialized, this function is called to add custom
-  // words from the custom dictionary to the |hunspell_|.
-  void AddCustomWordsToHunspell();
+  // Called when |hunspell| is done loading, succesfully or not. If |hunspell|
+  // and |bdict_file| are non-NULL, assume ownership.
+  void HunspellInited(Hunspell* hunspell,
+                      file_util::MemoryMappedFile* bdict_file,
+                      bool file_existed);
 
-  // Memory maps the given .bdic file. On success, it will return true and will
-  // place the data and length into the given out parameters.
-  bool MapBdictFile(const unsigned char** data, size_t* length);
+  // Either start downloading a dictionary if we have not already, or do nothing
+  // if we have already tried to download one.
+  void DoDictionaryDownload();
 
   // Returns whether or not the given word is a contraction of valid words
   // (e.g. "word:word").
   bool IsValidContraction(const string16& word, int tag);
 
   // Return the file name of the dictionary, including the path and the version
   // numbers.
   FilePath GetVersionedFileName(const std::string& language,
                                 const FilePath& dict_dir);
 
   static std::string GetCorrespondingSpellCheckLanguage(
       const std::string& language);
 
   // Start downloading a dictionary from the server.  On completion, the
   // OnURLFetchComplete() function is invoked.
   void StartDictionaryDownload(const FilePath& file_name);
 
   // This method is called in the IO thread after dictionary download has
   // completed in FILE thread.
-  void OnDictionarySaveComplete(){ obtaining_dictionary_ = false; }
+  void OnDictionarySaveComplete();
 
   // The given path to the directory whether SpellChecker first tries to
   // download the spellcheck bdic dictionary file.
   FilePath given_dictionary_directory_;
 
   // Path to the custom dictionary file.
   FilePath custom_dictionary_file_name_;
 
   // BDIC file name (e.g. en-US_1_1.bdic).
   FilePath bdic_file_name_;
 
   // We memory-map the BDict file.
   scoped_ptr<file_util::MemoryMappedFile> bdict_file_;
 
   // The hunspell dictionary in use.
   scoped_ptr<Hunspell> hunspell_;
 
   // Represents character attributes used for filtering out characters which
   // are not supported by this SpellChecker object.
   SpellcheckCharAttribute character_attributes_;
 
   // Flag indicating whether we've tried to initialize.  If we've already
   // attempted initialiation, we won't retry to avoid failure loops.
   bool tried_to_init_;
 
   // The language that this spellchecker works in.
   std::string language_;
 
-#ifndef NDEBUG
   // This object must only be used on the same thread. However, it is normally
   // created on the UI thread. This checks calls to SpellCheckWord and the
   // destructor to make sure we're only ever running on the same thread.
   //
   // This will be NULL if it is not initialized yet (not initialized in the
-  // constructor since that's on a different thread.
+  // constructor since that's on a different thread).
   MessageLoop* worker_loop_;
-#endif
 
   // Flag indicating whether we tried to download the dictionary file.
   bool tried_to_download_dictionary_file_;
 
   // File Thread Message Loop.
   MessageLoop* file_loop_;
 
-  // UI Thread Message Loop.
-  MessageLoop* ui_loop_;
-
   // Used for requests. MAY BE NULL which means don't try to download.
   URLRequestContext* url_request_context_;
 
   // True when we're downloading or saving a dictionary.
   bool obtaining_dictionary_;
 
   // Remember state for auto spell correct.
   bool auto_spell_correct_turned_on_;
 
   // True if a platform-specific spellchecking engine is being used,
   // and False if hunspell is being used.
   bool is_using_platform_spelling_engine_;
 
   // URLFetcher to download a file in memory.
   scoped_ptr<URLFetcher> fetcher_;
 
+  // While Hunspell is loading, we add any new custom words to this queue.
+  // We will add them to |hunspell_| when it is done loading.
+  std::queue<std::string> custom_words_;
+
   // Used for generating callbacks to spellchecker, since spellchecker is a
   // non-reference counted object.
-  ScopedRunnableMethodFactory<SpellChecker>
-      on_dictionary_save_complete_callback_factory_;
+  ScopedRunnableMethodFactory<SpellChecker> method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SpellChecker);
 };
 
 #endif  // CHROME_BROWSER_SPELLCHECKER_H_