[chromium-reviews] For system-level installs, if the spellcheck dictionary fails to get download...

chrome/browser/spellchecker.cc

 // 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.
 
 #include "app/l10n_util.h"
 #include "chrome/browser/spellchecker.h"
 #include "chrome/browser/spellchecker_common.h"
 #include "chrome/browser/spellchecker_platform_engine.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 59 matching lines @@
   {"sk", "sk-SK"},
   {"sl", "sl-SI"},
   {"ca", "ca-ES"},
   {"lv", "lv-LV"},
   // {"uk", "uk-UA"}, // Not to be included in Spellchecker as per B=1277824
   {"hi", "hi-IN"},
   {"et", "et-EE"},
   {"tr", "tr-TR"},
 };
 
+// Get the fallback folder (currently chrome::DIR_USER_DATA) where the
+// dictionary is downloaded in case of system-wide installations.
+FilePath GetFallbackDictionaryDownloadDirectory() {
+  FilePath dict_dir_userdata;
+  PathService::Get(chrome::DIR_USER_DATA, &dict_dir_userdata);
+  dict_dir_userdata = dict_dir_userdata.AppendASCII("Dictionaries");
+  return dict_dir_userdata;
+}
+
 }
 
 void SpellChecker::SpellCheckLanguages(std::vector<std::string>* languages) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
        ++i)
     languages->push_back(g_supported_spellchecker_languages[i].language);
 }
 
 // This function returns the language-region version of language name.
 // e.g. returns hi-IN for hi.
@@ skipping 146 matching lines @@
 // which obtains the IO thread independently and invokes the task in the IO
 // thread if it's not NULL. After the flags are cleared, a (final) attempt is
 // made to initialize hunspell_. If it fails even then (dictionary could not
 // download), no more attempts are made to initialize it.
 
 // ############################################################################
 
 // This object downloads the dictionary files asynchronously by first
 // fetching it to memory using URL fetcher and then writing it to
 // disk using file_util::WriteFile.
+
 class SpellChecker::DictionaryDownloadController
     : public URLFetcher::Delegate,
       public base::RefCountedThreadSafe<DictionaryDownloadController> {
  public:
   DictionaryDownloadController(
       Task* spellchecker_flag_set_task,
       const FilePath& dic_file_path,
       URLRequestContext* url_request_context,
       MessageLoop* ui_loop)
       : spellchecker_flag_set_task_(spellchecker_flag_set_task),
@@ skipping 13 matching lines @@
 
     GURL url = GURL(std::string(kDownloadServerUrl) + WideToUTF8(
                         l10n_util::ToLower(file_name_.ToWStringHack())));
     fetcher_.reset(new URLFetcher(url, URLFetcher::GET, this));
     fetcher_->set_request_context(url_request_context_);
     fetcher_->Start();
   }
 
  private:
   // The file has been downloaded in memory - need to write it down to file.
-  bool SaveBufferToFile(const std::string& data) {
-    FilePath file_to_write = dic_zip_file_path_.Append(file_name_);
+  bool SaveBufferToFile(const std::string& data,
+                        FilePath file_to_write) {
     int num_bytes = data.length();
     return file_util::WriteFile(file_to_write, data.data(), num_bytes) ==
         num_bytes;
   }
 
   // URLFetcher::Delegate interface.
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data) {
     DCHECK(source);
-    bool save_success = false;
     if ((response_code / 100) == 2 ||
         response_code == 401 ||
         response_code == 407) {
-      save_success = SaveBufferToFile(data);
+      FilePath file_to_write = dic_zip_file_path_.Append(file_name_);
+      if (!SaveBufferToFile(data, file_to_write)) {
+        // Try saving it to user data/Dictionaries, which almost surely has
+        // write permission. If even this fails, there is nothing to be done.
+        FilePath user_data_dir = GetFallbackDictionaryDownloadDirectory();
+
+        // Create the directory if it does not exist.
+        if (!file_util::PathExists(user_data_dir))
+          file_util::CreateDirectory(user_data_dir);
+
+        file_to_write = user_data_dir.Append(file_name_);
+        SaveBufferToFile(data.data(), file_to_write);
+      }
     }  // Unsuccessful save is taken care of in SpellChecker::Initialize().
 
     // Set Flag that dictionary is not downloading anymore.
     ui_loop_->PostTask(FROM_HERE,
                        new UIProxyForIOTask(spellchecker_flag_set_task_));
     fetcher_.reset(NULL);
   }
 
   // factory object to invokelater back to spellchecker in io thread on
   // download completion to change appropriate flags.
@@ skipping 70 matching lines @@
     }
   }
 
   return dict_dir.AppendASCII(versioned_bdict_file_name);
 }
 
 SpellChecker::SpellChecker(const FilePath& dict_dir,
                            const std::string& language,
                            URLRequestContext* request_context,
                            const FilePath& custom_dictionary_file_name)
-    : custom_dictionary_file_name_(custom_dictionary_file_name),
+    : given_dictionary_directory_(dict_dir),
+      custom_dictionary_file_name_(custom_dictionary_file_name),
       tried_to_init_(false),
+      language_(language),
 #ifndef NDEBUG
       worker_loop_(NULL),
 #endif
-      tried_to_download_(false),
+      tried_to_download_dictionary_file_(false),
       file_loop_(NULL),
       url_request_context_(request_context),
       dic_is_downloading_(false),
       auto_spell_correct_turned_on_(false),
       is_using_platform_spelling_engine_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           dic_download_state_changer_factory_(this)) {
   if (SpellCheckerPlatform::SpellCheckerAvailable()) {
     SpellCheckerPlatform::Init();
     if (SpellCheckerPlatform::PlatformSupportsLanguage(language)) {
       // If we have reached here, then we know that the current platform
       // supports the given language and we will use it instead of hunspell.
       SpellCheckerPlatform::SetLanguage(language);
       is_using_platform_spelling_engine_ = true;
     }
   }
 
   // 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);
-
   // Get the path to the custom dictionary file.
   if (custom_dictionary_file_name_.empty()) {
     FilePath personal_file_directory;
     PathService::Get(chrome::DIR_USER_DATA, &personal_file_directory);
     custom_dictionary_file_name_ =
         personal_file_directory.Append(chrome::kCustomDictionaryFileName);
   }
 
   // Use this dictionary language as the default one of the
   // SpellcheckCharAttribute object.
   character_attributes_.SetDefaultLanguage(language);
 }
 
 SpellChecker::~SpellChecker() {
 #ifndef NDEBUG
   // This must be deleted on the I/O thread (see the header). This is the same
   // thread thatSpellCheckWord is called on, so we verify that they were all the
   // same thread.
   if (worker_loop_)
     DCHECK(MessageLoop::current() == worker_loop_);
 #endif
 }
 
+void SpellChecker::StartDictionaryDownloadInFileThread(
+    const FilePath& file_name) {
+  Task* dic_task = dic_download_state_changer_factory_.NewRunnableMethod(
+      &SpellChecker::set_file_is_downloading, false);
+  ddc_dic_ = new DictionaryDownloadController(dic_task, file_name,
+      url_request_context_, ui_loop_);
+  set_file_is_downloading(true);
+  file_loop_->PostTask(FROM_HERE, NewRunnableMethod(ddc_dic_.get(),
+      &DictionaryDownloadController::StartDownload));
+}
+
 // Initialize SpellChecker. In this method, if the dicitonary is not present
 // in the local disk, it is fetched asynchronously.
 // TODO(sidchat): After dictionary is downloaded, initialize hunspell in
 // file loop - this is currently being done in the io loop.
 // Bug: http://b/issue?id=1123096
 bool SpellChecker::Initialize() {
   // Return false if the dictionary files are downloading.
   if (dic_is_downloading_)
     return false;
 
   // Return false if tried to init and failed - don't try multiple times in
   // this session.
   if (tried_to_init_)
     return hunspell_.get() != NULL;
 
   StatsScope<StatsCounterTimer> timer(chrome::Counters::spellcheck_init());
 
-  bool dic_exists = file_util::PathExists(bdict_file_name_);
-  if (!dic_exists) {
-    if (file_loop_ && !tried_to_download_ && url_request_context_) {
-      Task* dic_task = dic_download_state_changer_factory_.NewRunnableMethod(
-          &SpellChecker::set_file_is_downloading, false);
-      ddc_dic_ = new DictionaryDownloadController(dic_task, bdict_file_name_,
-          url_request_context_, ui_loop_);
-      set_file_is_downloading(true);
-      file_loop_->PostTask(FROM_HERE, NewRunnableMethod(ddc_dic_.get(),
-          &DictionaryDownloadController::StartDownload));
+  // The default place whether the spellcheck dictionary can reside is
+  // chrome::DIR_APP_DICTIONARIES. However, for systemwide installations,
+  // this directory may not have permissions for download. In that case, the
+  // alternate directory for download is chrome::DIR_USER_DATA. We have to check
+  // for the spellcheck dictionaries in both the directories. If not found in
+  // either one, it has to be downloaded in either of the two.
+  // TODO(sidchat): Some sort of UI to warn users that spellchecker is not
+  // working at all (due to failed dictionary download)?
+
+  // File name for downloading in DIR_APP_DICTIONARIES.
+  FilePath dictionary_file_name_app = GetVersionedFileName(language_,
+      given_dictionary_directory_);
+
+  // Filename for downloading in the fallback dictionary download directory,
+  // DIR_USER_DATA.
+  FilePath dict_dir_userdata = GetFallbackDictionaryDownloadDirectory();
+  FilePath dictionary_file_name_usr = GetVersionedFileName(language_,
+      dict_dir_userdata);
+
+  // Check in both the directories to see whether the spellcheck dictionary
+  // already resides in one of these.
+  FilePath bdic_file_name;
+  if (file_util::PathExists(dictionary_file_name_app)) {
+    bdic_file_name = dictionary_file_name_app;
+  } else if (file_util::PathExists(dictionary_file_name_usr)) {
+    bdic_file_name = dictionary_file_name_usr;
+  } else {
+    // Download the dictionary file.
+    if (file_loop_ && url_request_context_) {
+      if (!tried_to_download_dictionary_file_) {
+        StartDictionaryDownloadInFileThread(dictionary_file_name_app);
+        tried_to_download_dictionary_file_ = true;
+        return false;
+      } else {  // There is no dictionary even after trying to download it.
+        // Stop trying to download the dictionary in this session.
+        tried_to_init_ = true;
+        return false;
+      }
     }
   }
 
-  if (!dic_exists && !tried_to_download_) {
-    tried_to_download_ = true;
-    return false;
-  }
-
-  // Control has come so far - both files probably exist.
+  // Control has come so far - the BDIC dictionary file probably exists. Now try
+  // to initialize hunspell using the available bdic dictionary file.
   TimeTicks begin_time = TimeTicks::Now();
   bdict_file_.reset(new file_util::MemoryMappedFile());
-  if (bdict_file_->Initialize(bdict_file_name_)) {
+  if (bdict_file_->Initialize(bdic_file_name)) {
     hunspell_.reset(new Hunspell(bdict_file_->data(), bdict_file_->length()));
     AddCustomWordsToHunspell();
   }
   DHISTOGRAM_TIMES("Spellcheck.InitTime", TimeTicks::Now() - begin_time);
 
   tried_to_init_ = true;
   return false;
 }
 
 void SpellChecker::GetAutoCorrectionWord(const std::wstring& word,
@@ skipping 232 matching lines @@
 
   // Populate the vector of WideStrings.
   for (int i = 0; i < number_of_suggestions; i++) {
     if (i < kMaxSuggestions)
       optional_suggestions->push_back(UTF8ToWide(suggestions[i]));
     free(suggestions[i]);
   }
   if (suggestions != NULL)
     free(suggestions);
 }