Convert a crash to a NOTREACHED.

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/common/render_messages.h"
@@ skipping 164 matching lines @@
         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);
+  } else {
+    NOTREACHED() << "Could not mmap spellchecker dictionary.";
   }
 }
 
 void SpellCheck::AddWordToHunspell(const std::string& word) {
   if (!word.empty() && word.length() < MAXWORDUTF8LEN)
     hunspell_->add(word.c_str());
 }
 
 bool SpellCheck::InitializeIfNeeded() {
   if (is_using_platform_spelling_engine_)
     return false;
 
   if (!initialized_) {
     RenderThread::current()->Send(
         new ViewHostMsg_SpellChecker_RequestDictionary);
     initialized_ = true;
     return true;
   }
 
-  // Check if the platform spellchecker is being used.
-  if (file_ != base::kInvalidPlatformFileValue) {
-    // If it isn't, init hunspell.
+  // Don't initialize if hunspell is disabled.
+  if (file_ != base::kInvalidPlatformFileValue)
     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) {
   bool word_correct = false;
 
   if (is_using_platform_spelling_engine_) {
     RenderThread::current()->Send(
         new ViewHostMsg_SpellChecker_PlatformCheckSpelling(word_to_check, tag,
                                                            &word_correct));
   } else {
     std::string word_to_check_utf8(UTF16ToUTF8(word_to_check));
     // Hunspell shouldn't let us exceed its max, but check just in case
     if (word_to_check_utf8.length() < MAXWORDUTF8LEN) {
-      // |hunspell_->spell| returns 0 if the word is spelled correctly and
-      // non-zero otherwsie.
-      word_correct = (hunspell_->spell(word_to_check_utf8.c_str()) != 0);
+      if (hunspell_.get()) {
+        // |hunspell_->spell| returns 0 if the word is spelled correctly and
+        // non-zero otherwsie.
+        word_correct = (hunspell_->spell(word_to_check_utf8.c_str()) != 0);
+      } else {
+        // If |hunspell_| is NULL here, an error has occurred, but it's better
+        // to check rather than crash.
+        word_correct = true;
+      }
     }
   }
 
   return word_correct;
 }
 
 void SpellCheck::FillSuggestionList(
     const string16& wrong_word,
     std::vector<string16>* optional_suggestions) {
   if (is_using_platform_spelling_engine_) {
     RenderThread::current()->Send(
         new ViewHostMsg_SpellChecker_PlatformFillSuggestionList(
             wrong_word, optional_suggestions));
     return;
   }
+
+  // If |hunspell_| is NULL here, an error has occurred, but it's better
+  // to check rather than crash.
+  if (!hunspell_.get())
+    return;
+
   char** suggestions;
   int number_of_suggestions =
       hunspell_->suggest(&suggestions, UTF16ToUTF8(wrong_word).c_str());
 
   // Populate the vector of WideStrings.
   for (int i = 0; i < number_of_suggestions; i++) {
     if (i < SpellCheckCommon::kMaxSuggestions)
       optional_suggestions->push_back(UTF8ToUTF16(suggestions[i]));
     free(suggestions[i]);
   }
@@ skipping 12 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;
 }