[Mac] Ignore spell-checker exceptions.

chrome/browser/spellchecker/spellchecker_mac.mm

 // Copyright (c) 2011 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.
 
 // This file implements the interface defined in spellchecker_platform_engine.h
 // for the OS X platform.
 
 #include "chrome/browser/spellchecker/spellchecker_platform_engine.h"
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/logging.h"
+#include "base/mac/foundation_util.h"
+#include "base/mac/scoped_nsexception_enabler.h"
 #include "base/metrics/histogram.h"
 #include "base/sys_string_conversions.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "content/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingResult.h"
 
 using base::TimeTicks;
 using content::BrowserThread;
 
 namespace {
 // The number of characters in the first part of the language code.
 const unsigned int kShortLanguageCodeSize = 2;
 
+// +[NSSpellChecker sharedSpellChecker] can throw exceptions depending
+// on the state of the pasteboard, or possibly as a result of
+// third-party code (when setting up services entries).  The following
+// receives nil if an exception is thrown, in which case
+// spell-checking will not work, but it also will not crash the
+// browser.
+NSSpellChecker* SharedSpellChecker() {
+  return base::mac::ObjCCastStrict<NSSpellChecker>(
+      base::mac::PerformSelectorIgnoringExceptions(
+          [NSSpellChecker class],
+          @selector(sharedSpellChecker)));
+}

[Scott Hess - ex-Googler, 2011/12/09 01:46:28]

I don't _think_ it would be worth memo-izing this, but if you think it would be
worthwhile, that seems reasonable.  I also don't think it is worth histogramming
this, because as far as I can tell, there would be no action item.

+
 // TextCheckingTask is reserved for spell checking against large size
 // of text, which possible contains multiple paragrpahs.  Checking
 // that size of text might take time, and should be done as a task on
 // the FILE thread.
 //
 // The result of the check is returned back as a
 // SpellCheckMsg_RespondTextCheck message.
 class TextCheckingTask : public Task {
  public:
   TextCheckingTask(BrowserMessageFilter* destination,
                    int route_id,
                    int identifier,
                    const string16& text,
                    int document_tag)
       : destination_(destination),
         route_id_(route_id),
         identifier_(identifier),
         text_(text),
         document_tag_(document_tag) {
   }
 
   virtual void Run() {
     // TODO(morrita): Use [NSSpellChecker requestCheckingOfString]
     // when the build target goes up to 10.6
     std::vector<WebKit::WebTextCheckingResult> check_results;
     NSString* text_to_check = base::SysUTF16ToNSString(text_);
     size_t starting_at = 0;
     while (starting_at < text_.size()) {
-      NSRange range = [[NSSpellChecker sharedSpellChecker]
+      NSRange range = [SharedSpellChecker()
                          checkSpellingOfString:text_to_check
                                     startingAt:starting_at
                                       language:nil
                                           wrap:NO
                         inSpellDocumentWithTag:document_tag_
                                      wordCount:NULL];
       if (range.length == 0)
         break;
       check_results.push_back(WebKit::WebTextCheckingResult(
           WebKit::WebTextCheckingResult::ErrorSpelling,
@@ skipping 76 matching lines @@
                 [lang_code substringFromIndex:(kShortLanguageCodeSize + 1)]]);
   }
   return base::SysNSStringToUTF8(lang_code);
 }
 
 } // namespace
 
 namespace SpellCheckerPlatform {
 
 void GetAvailableLanguages(std::vector<std::string>* spellcheck_languages) {
-  NSArray* availableLanguages = [[NSSpellChecker sharedSpellChecker]
-                        availableLanguages];
+  NSArray* availableLanguages = [SharedSpellChecker() availableLanguages];
   for (NSString* lang_code in availableLanguages) {
     spellcheck_languages->push_back(
               ConvertLanguageCodeFromMac(lang_code));
   }
 }
 
 bool SpellCheckerAvailable() {
   // If this file was compiled, then we know that we are on OS X 10.5 at least
   // and can safely return true here.
   return true;
 }
 
 bool SpellCheckerProvidesPanel() {
   // OS X has a Spelling Panel, so we can return true here.
   return true;
 }
 
 bool SpellingPanelVisible() {
   // This should only be called from the main thread.
   DCHECK([NSThread currentThread] == [NSThread mainThread]);
-  return [[[NSSpellChecker sharedSpellChecker] spellingPanel] isVisible];
+  return [[SharedSpellChecker() spellingPanel] isVisible];
 }
 
 void ShowSpellingPanel(bool show) {
   if (show) {
-    [[[NSSpellChecker sharedSpellChecker] spellingPanel]
+    [[SharedSpellChecker() spellingPanel]
         performSelectorOnMainThread:@selector(makeKeyAndOrderFront:)
                          withObject:nil
                       waitUntilDone:YES];
   } else {
-    [[[NSSpellChecker sharedSpellChecker] spellingPanel]
+    [[SharedSpellChecker() spellingPanel]
         performSelectorOnMainThread:@selector(close)
                          withObject:nil
                       waitUntilDone:YES];
   }
 }
 
 void UpdateSpellingPanelWithMisspelledWord(const string16& word) {
   NSString * word_to_display = base::SysUTF16ToNSString(word);
-  [[NSSpellChecker sharedSpellChecker]
+  [SharedSpellChecker()
       performSelectorOnMainThread:
         @selector(updateSpellingPanelWithMisspelledWord:)
                        withObject:word_to_display
                     waitUntilDone:YES];
 }
 
 void Init() {
 }
 
 bool PlatformSupportsLanguage(const std::string& current_language) {
   // First, convert the language to an OS X language code.
   NSString* mac_lang_code = ConvertLanguageCodeToMac(current_language);
 
   // Then grab the languages available.
-  NSArray* availableLanguages;
-  availableLanguages = [[NSSpellChecker sharedSpellChecker]
-                        availableLanguages];
+  NSArray* availableLanguages = [SharedSpellChecker() availableLanguages];
 
   // Return true if the given language is supported by OS X.
   return [availableLanguages containsObject:mac_lang_code];
 }
 
 void SetLanguage(const std::string& lang_to_set) {
   NSString* NS_lang_to_set = ConvertLanguageCodeToMac(lang_to_set);
-  [[NSSpellChecker sharedSpellChecker] setLanguage:NS_lang_to_set];
+  [SharedSpellChecker() setLanguage:NS_lang_to_set];
 }
 
 static int last_seen_tag_;
 
 bool CheckSpelling(const string16& word_to_check, int tag) {

[Scott Hess - ex-Googler, 2011/12/09 01:46:28]

This function was a case where having SharedSpellChecker() return nil seems like
it does the wrong thing.  The length should be 0, so it says there is no
misspelled word, which is wrong.  OTOH, the only other option is to say all
words are misspelled, and I can't think of any reasonable way to message the
user about re-installing their OS or whatever...

   last_seen_tag_ = tag;
 
-  // [[NSSpellChecker sharedSpellChecker] checkSpellingOfString] returns an
-  // NSRange that we can look at to determine if a word is misspelled.
+  // -[NSSpellChecker checkSpellingOfString] returns an NSRange that
+  // we can look at to determine if a word is misspelled.
   NSRange spell_range = {0,0};
 
   // Convert the word to an NSString.
   NSString* NS_word_to_check = base::SysUTF16ToNSString(word_to_check);
   // Check the spelling, starting at the beginning of the word.
-  spell_range = [[NSSpellChecker sharedSpellChecker]
+  spell_range = [SharedSpellChecker()
                   checkSpellingOfString:NS_word_to_check startingAt:0
                   language:nil wrap:NO inSpellDocumentWithTag:tag
                   wordCount:NULL];
 
   // If the length of the misspelled word == 0,
   // then there is no misspelled word.
   bool word_correct = (spell_range.length == 0);
   return word_correct;
 }
 
 void FillSuggestionList(const string16& wrong_word,
                         std::vector<string16>* optional_suggestions) {
   NSString* NS_wrong_word = base::SysUTF16ToNSString(wrong_word);
   TimeTicks debug_begin_time = base::Histogram::DebugNow();
   // The suggested words for |wrong_word|.
-  NSArray* guesses =
-      [[NSSpellChecker sharedSpellChecker] guessesForWord:NS_wrong_word];
+  NSArray* guesses = [SharedSpellChecker() guessesForWord:NS_wrong_word];
   DHISTOGRAM_TIMES("Spellcheck.SuggestTime",
                    base::Histogram::DebugNow() - debug_begin_time);
 
   for (int i = 0; i < static_cast<int>([guesses count]); i++) {
     if (i < SpellCheckCommon::kMaxSuggestions) {
       optional_suggestions->push_back(base::SysNSStringToUTF16(
                                       [guesses objectAtIndex:i]));
     }
   }
 }
 
 void AddWord(const string16& word) {
     NSString* word_to_add = base::SysUTF16ToNSString(word);
-  [[NSSpellChecker sharedSpellChecker] learnWord:word_to_add];
+  [SharedSpellChecker() learnWord:word_to_add];
 }
 
 void RemoveWord(const string16& word) {
   NSString *word_to_remove = base::SysUTF16ToNSString(word);
-  [[NSSpellChecker sharedSpellChecker] unlearnWord:word_to_remove];
+  [SharedSpellChecker() unlearnWord:word_to_remove];
 }
 
 int GetDocumentTag() {
   NSInteger doc_tag = [NSSpellChecker uniqueSpellDocumentTag];
   return static_cast<int>(doc_tag);
 }
 
 void IgnoreWord(const string16& word) {
-  [[NSSpellChecker sharedSpellChecker] ignoreWord:base::SysUTF16ToNSString(word)
-                           inSpellDocumentWithTag:last_seen_tag_];
+  [SharedSpellChecker() ignoreWord:base::SysUTF16ToNSString(word)
+            inSpellDocumentWithTag:last_seen_tag_];
 }
 
 void CloseDocumentWithTag(int tag) {
-  [[NSSpellChecker sharedSpellChecker]
-    closeSpellDocumentWithTag:static_cast<NSInteger>(tag)];
+  [SharedSpellChecker() closeSpellDocumentWithTag:static_cast<NSInteger>(tag)];
 }
 
 void RequestTextCheck(int route_id,
                       int identifier,
                       int document_tag,
                       const string16& text, BrowserMessageFilter* destination) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       new TextCheckingTask(
           destination, route_id, identifier, text, document_tag));
 }
 
 }  // namespace SpellCheckerPlatform