Revert 31875 to see whether it fixes reliability bot.

chrome/renderer/spellchecker/spellcheck.cc

 // Copyright (c) 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.
 
 #include "chrome/renderer/spellchecker/spellcheck.h"
 
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/time.h"
 #include "chrome/renderer/render_thread.h"
 #include "third_party/hunspell/src/hunspell/hunspell.hxx"
 
 static const int kMaxAutoCorrectWordSize = 8;
 static const int kMaxSuggestions = 5;
 
 using base::TimeTicks;
 
 SpellCheck::SpellCheck()
-    : file_(base::kInvalidPlatformFileValue),
-      auto_spell_correct_turned_on_(false),
+    : auto_spell_correct_turned_on_(false),
       // TODO(estade): initialize this properly.
       is_using_platform_spelling_engine_(false),
       initialized_(false) {
   // Wait till we check the first word before doing any initializing.
 }
 
 SpellCheck::~SpellCheck() {
 }
 
-void SpellCheck::Init(base::PlatformFile file,
+void SpellCheck::Init(const base::FileDescriptor& fd,
                       const std::vector<std::string>& custom_words,
                       const std::string language) {
   initialized_ = true;
   hunspell_.reset();
   bdict_file_.reset();
-  file_ = file;
+  fd_ = fd;
   character_attributes_.SetDefaultLanguage(language);
 
   custom_words_.insert(custom_words_.end(),
                        custom_words.begin(), custom_words.end());
 
   // We delay the actual initialization of hunspell until it is needed.
 }
 
 bool SpellCheck::SpellCheckWord(
     const char16* in_word,
     int in_word_len,
     int tag,
     int* misspelling_start,
     int* misspelling_len,
     std::vector<string16>* optional_suggestions) {
   DCHECK(in_word_len >= 0);
   DCHECK(misspelling_start && misspelling_len) << "Out vars must be given.";
 
   // Do nothing if we need to delay initialization. (Rather than blocking,
   // report the word as correctly spelled.)
   if (InitializeIfNeeded())
     return true;
 
   // Do nothing if spell checking is disabled.
-  if (initialized_ && file_ == base::kInvalidPlatformFileValue)
+  if (initialized_ && fd_.fd == -1)
     return true;
 
   *misspelling_start = 0;
   *misspelling_len = 0;
   if (in_word_len == 0)
     return true;  // No input means always spelled correctly.
 
   SpellcheckWordIterator word_iterator;
   string16 word;
   int word_start;
@@ skipping 86 matching lines @@
     AddWordToHunspell(word);
   }
 }
 
 void SpellCheck::InitializeHunspell() {
   if (hunspell_.get())
     return;
 
   bdict_file_.reset(new file_util::MemoryMappedFile);
 
-  if (bdict_file_->Initialize(file_)) {
+  if (bdict_file_->Initialize(fd_)) {
     TimeTicks start_time = TimeTicks::Now();
 
     hunspell_.reset(
         new Hunspell(bdict_file_->data(), bdict_file_->length()));
 
     // Add custom words to Hunspell.
     for (std::vector<std::string>::iterator it = custom_words_.begin();
          it != custom_words_.end(); ++it) {
       AddWordToHunspell(*it);
     }
 
     DHISTOGRAM_TIMES("Spellcheck.InitTime",
                      TimeTicks::Now() - start_time);
   }
 }
 
 void SpellCheck::AddWordToHunspell(const std::string& word) {
   if (!word.empty() && word.length() < MAXWORDUTF8LEN)
     hunspell_->add(word.c_str());
 }
 
 bool SpellCheck::InitializeIfNeeded() {
   if (!initialized_) {
     RenderThread::current()->RequestSpellCheckDictionary();
     initialized_ = true;
     return true;
   }
 
   // Check if the platform spellchecker is being used.
-  if (!is_using_platform_spelling_engine_ &&
-      file_ != base::kInvalidPlatformFileValue) {
+  if (!is_using_platform_spelling_engine_ && fd_.fd != -1) {
     // If it isn't, init hunspell.
     InitializeHunspell();
   }
 
   return false;
 }
 
 // When called, relays the request to check the spelling to the proper
 // backend, either hunspell or a platform-specific backend.
 bool SpellCheck::CheckSpelling(const string16& word_to_check, int tag) {
@@ skipping 47 matching lines @@
 
   string16 word;
   int word_start;
   int word_length;
   while (word_iterator.GetNextWord(&word, &word_start, &word_length)) {
     if (!CheckSpelling(word, tag))
       return false;
   }
   return true;
 }