Port the spell checker to posix.

chrome/browser/spellchecker.cc

 // Copyright (c) 2006-2008 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.
 
-#include <io.h>
-
 #include "chrome/browser/spellchecker.h"
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/thread.h"
-#include "base/win_util.h"
 #include "chrome/app/locales/locale_settings.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/url_fetcher.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_counters.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
-#include "chrome/common/render_messages.h"
-#include "chrome/common/win_util.h"
 #include "chrome/third_party/hunspell/src/hunspell/hunspell.hxx"
 #include "net/url_request/url_request.h"
 
 #include "generated_resources.h"
 
 using base::TimeTicks;
 
 static const int kMaxSuggestions = 5;  // Max number of dictionary suggestions.
 
 namespace {
@@ skipping 37 matching lines @@
 }
 
 void SpellChecker::SpellCheckLanguages(Languages* languages) {
   for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages); ++i)
     languages->push_back(g_supported_spellchecker_languages[i]);
 }
 
 SpellChecker::Language SpellChecker::GetCorrespondingSpellCheckLanguage(
     const Language& language) {
   // Look for exact match in the Spell Check language list.
-  for (int i = 0; i < arraysize(g_supported_spellchecker_languages); ++i) {
+  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages); ++i) {
     Language spellcheck_language(g_supported_spellchecker_languages[i]);
     if (spellcheck_language == language)
       return language;
   }
 
   // Look for a match by comparing only language parts. All the 'en-RR'
   // except for 'en-GB' exactly matched in the above loop, will match 
   // 'en-US'. This is not ideal because 'en-AU', 'en-ZA', 'en-NZ' had 
   // better be matched with 'en-GB'. This does not handle cases like
   // 'az-Latn-AZ' vs 'az-Arab-AZ', either, but we don't use 3-part
   // locale ids with a script code in the middle, yet.
   // TODO(jungshik): Add a better fallback.
   Language language_part(language, 0, language.find(L'-'));
-  for (int i = 0; i < arraysize(g_supported_spellchecker_languages); ++i) {
+  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages); ++i) {
     Language spellcheck_language(g_supported_spellchecker_languages[i]);
     if (spellcheck_language.substr(0, spellcheck_language.find(L'-')) ==
         language_part)
       return spellcheck_language;
   } 
 
   // No match found - return blank.
   return Language();
 }
 
@@ skipping 95 matching lines @@
 // disk using file_util::WriteFile.
 class SpellChecker::DictionaryDownloadController
     : public URLFetcher::Delegate,
       public base::RefCountedThreadSafe<DictionaryDownloadController> {
  public:
   DictionaryDownloadController(
       Task* spellchecker_flag_set_task,
       const std::wstring& dic_file_path,
       URLRequestContext* url_request_context,
       MessageLoop* ui_loop)
-      : url_request_context_(url_request_context),
+      : spellchecker_flag_set_task_(spellchecker_flag_set_task),
+        url_request_context_(url_request_context),
         download_server_url_(
             L"http://cache.pack.google.com/chrome/dict/"),
-        ui_loop_(ui_loop),
-        spellchecker_flag_set_task_(spellchecker_flag_set_task) {
+        ui_loop_(ui_loop) {
     // Determine dictionary file path and name.
     fetcher_.reset(NULL);
     dic_zip_file_path_ = file_util::GetDirectoryFromPath(dic_file_path);
     file_name_ = file_util::GetFilenameFromPath(dic_file_path);
 
     name_of_file_to_download_ = l10n_util::ToLower(file_name_);
   }
 
   // Save the file in memory buffer to the designated dictionary file.
   // returns the number of bytes it could save.
@@ skipping 69 matching lines @@
 }
 
 // ################################################################
 // This part of the code is used for spell checking.
 // ################################################################
 
 std::wstring SpellChecker::GetVersionedFileName(const Language& language,
                                                 const std::wstring& dict_dir) {
   // The default version string currently in use.
   static const wchar_t kDefaultVersionString[] = L"-1-1";
-  
+
   // Use this struct to insert version strings for dictionary files which have
   // special version strings, other than the default version string.
   // For de-DE, we are currently using de-DE-1-1-1 for versioning, because
   // de-DE-1-1.bdic, in the download server, corresponds to a less used
   // dictionary. This version, i.e., de-DE-1-1-1.bdic, is actually renamed
   // from de-DE-neu-1-1.bic.
   static const struct {
     // The language input.
     const char* language;
 
     // The corresponding version.
     const char* version;
   } special_version_string[] = {
-    "de-DE", "-1-1-1",
+    {"de-DE", "-1-1-1"},
   };
-  
+
   // Generate the bdict file name using default version string or special 
   // version string, depending on the language.
   std::wstring versioned_bdict_file_name(language + kDefaultVersionString +
                                          L".bdic");
   std::string language_string(WideToUTF8(language));
-  for (int i = 0; i < arraysize(special_version_string); ++i) {
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(special_version_string); ++i) {
     if (language_string == special_version_string[i].language) {
       versioned_bdict_file_name = 
           language + UTF8ToWide(special_version_string[i].version) + L".bdic";
       break;
     }
   }
 
   std::wstring bdict_file_name(dict_dir);
   file_util::AppendToPath(&bdict_file_name, versioned_bdict_file_name);
   return bdict_file_name;
 }
 
 SpellChecker::SpellChecker(const std::wstring& dict_dir,
                            const std::wstring& language,
                            URLRequestContext* request_context,
                            const std::wstring& custom_dictionary_file_name)
     : custom_dictionary_file_name_(custom_dictionary_file_name),
       tried_to_init_(false),
 #ifndef NDEBUG
       worker_loop_(NULL),
 #endif
       tried_to_download_(false),
+      file_loop_(NULL),
       url_request_context_(request_context),
-      file_loop_(NULL),
-#pragma warning(suppress: 4355)  // Okay to pass "this" here.
-      dic_download_state_changer_factory_(this),
-      dic_is_downloading_(false) {
+      dic_is_downloading_(false),
+      ALLOW_THIS_IN_INTIALIZER_LIST(dic_download_state_changer_factory_(this)) {
   // Remember UI loop to later use this as a proxy to get IO loop.
   ui_loop_ = MessageLoop::current();
 
   // Get File Loop - hunspell gets initialized here.
   base::Thread* file_thread = g_browser_process->file_thread();
   if (file_thread)
     file_loop_ = file_thread->message_loop();
 
   // Get the path to the spellcheck file.
   bdict_file_name_ = GetVersionedFileName(language, dict_dir);
@@ skipping 84 matching lines @@
          it != list_of_words.end(); ++it) {
       hunspell_->put_word(it->c_str());
     }
   }
 }
 
 // Returns whether or not the given string is a valid contraction.
 // This function is a fall-back when the SpellcheckWordIterator class
 // returns a concatenated word which is not in the selected dictionary
 // (e.g. "in'n'out") but each word is valid.
-bool SpellChecker::IsValidContraction(const std::wstring& contraction) {
+bool SpellChecker::IsValidContraction(const string16& contraction) {
   SpellcheckWordIterator word_iterator;
   word_iterator.Initialize(&character_attributes_, contraction.c_str(),
                            contraction.length(), false);
 
-  std::wstring word;
+  string16 word;
   int word_start;
   int word_length;
   while (word_iterator.GetNextWord(&word, &word_start, &word_length)) {
-    if (!hunspell_->spell(WideToUTF8(word).c_str()))
+    if (!hunspell_->spell(UTF16ToUTF8(word).c_str()))
       return false;
   }
   return true;
 }
 
 bool SpellChecker::SpellCheckWord(
     const wchar_t* in_word,
     int in_word_len,
     int* misspelling_start,
     int* misspelling_len,
@@ skipping 15 matching lines @@
 
   *misspelling_start = 0;
   *misspelling_len = 0;
   if (in_word_len == 0)
     return true;  // no input means always spelled correctly
 
   if (!hunspell_.get())
     return true;  // unable to spellcheck, return word is OK
 
   SpellcheckWordIterator word_iterator;
-  std::wstring word;
+  string16 word;
+  string16 in_word_utf16;
+  WideToUTF16(in_word, in_word_len, &in_word_utf16);
   int word_start;
   int word_length;
-  word_iterator.Initialize(&character_attributes_, in_word, in_word_len, true);
+  word_iterator.Initialize(&character_attributes_, in_word_utf16.c_str(),
+                           in_word_len, true);
   while (word_iterator.GetNextWord(&word, &word_start, &word_length)) {
     // Found a word (or a contraction) that hunspell can check its spelling.
-    std::string encoded_word = WideToUTF8(word);
+    std::string encoded_word = UTF16ToUTF8(word);
 
     {
       TimeTicks begin_time = TimeTicks::Now();
       bool word_ok = !!hunspell_->spell(encoded_word.c_str());
       DHISTOGRAM_TIMES(L"Spellcheck.CheckTime", TimeTicks::Now() - begin_time);
       if (word_ok)
         continue;
     }
 
     // If the given word is a concatenated word of two or more valid words
@@ skipping 64 matching lines @@
     hunspell_->put_word(word_to_add.c_str());
 
   // Now add the word to the custom dictionary file.
   Task* write_word_task =
       new AddWordToCustomDictionaryTask(custom_dictionary_file_name_, word);
   if (file_loop_)
     file_loop_->PostTask(FROM_HERE, write_word_task);
   else
     write_word_task->Run();
 }