chrome/browser/spellchecker/spellcheck_hunspell_dictionary.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/spellchecker/spellcheck_hunspell_dictionary.h"
   6
   7 #include "base/files/file_util.h"
   8 #include "base/files/memory_mapped_file.h"
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/path_service.h"
  12 #include "chrome/browser/spellchecker/spellcheck_platform.h"
  13 #include "chrome/browser/spellchecker/spellcheck_service.h"
  14 #include "chrome/common/chrome_paths.h"
  15 #include "chrome/common/spellcheck_common.h"
  16 #include "chrome/common/spellcheck_messages.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "content/public/browser/render_process_host.h"
  19 #include "net/base/load_flags.h"
  20 #include "net/url_request/url_fetcher.h"
  21 #include "net/url_request/url_request_context_getter.h"
  22 #include "third_party/hunspell/google/bdict.h"
  23 #include "url/gurl.h"
  24
  25 using content::BrowserThread;
  26
  27 namespace {
  28
  29 // Close the file.
  30 void CloseDictionary(base::File file) {
  31   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  32   file.Close();
  33 }
  34
  35 // Saves |data| to file at |path|. Returns true on successful save, otherwise
  36 // returns false.
  37 bool SaveDictionaryData(scoped_ptr<std::string> data,
  38                         const base::FilePath& path) {
  39   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  40
  41   size_t bytes_written =
  42       base::WriteFile(path, data->data(), data->length());
  43   if (bytes_written != data->length()) {
  44     bool success = false;
  45 #if defined(OS_WIN)
  46     base::FilePath dict_dir;
  47     PathService::Get(chrome::DIR_USER_DATA, &dict_dir);
  48     base::FilePath fallback_file_path =
  49         dict_dir.Append(path.BaseName());
  50     bytes_written =
  51         base::WriteFile(fallback_file_path, data->data(), data->length());
  52     if (bytes_written == data->length())
  53       success = true;
  54 #endif
  55
  56     if (!success) {
  57       base::DeleteFile(path, false);
  58       return false;
  59     }
  60   }
  61
  62   return true;
  63 }
  64
  65 }  // namespace
  66
  67 SpellcheckHunspellDictionary::DictionaryFile::DictionaryFile() {
  68 }
  69
  70  SpellcheckHunspellDictionary::DictionaryFile::~DictionaryFile() {
  71   if (file.IsValid()) {
  72     BrowserThread::PostTask(
  73         BrowserThread::FILE,
  74         FROM_HERE,
  75         base::Bind(&CloseDictionary, Passed(&file)));
  76   }
  77 }
  78
  79 SpellcheckHunspellDictionary::DictionaryFile::DictionaryFile(RValue other)
  80     : path(other.object->path),
  81       file(other.object->file.Pass()) {
  82 }
  83
  84 SpellcheckHunspellDictionary::DictionaryFile&
  85 SpellcheckHunspellDictionary::DictionaryFile::operator=(RValue other) {
  86   if (this != other.object) {
  87     path = other.object->path;
  88     file = other.object->file.Pass();
  89   }
  90   return *this;
  91 }
  92
  93 SpellcheckHunspellDictionary::SpellcheckHunspellDictionary(
  94     const std::string& language,
  95     net::URLRequestContextGetter* request_context_getter,
  96     SpellcheckService* spellcheck_service)
  97     : language_(language),
  98       use_platform_spellchecker_(false),
  99       request_context_getter_(request_context_getter),
 100       spellcheck_service_(spellcheck_service),
 101       download_status_(DOWNLOAD_NONE),
 102       weak_ptr_factory_(this) {
 103 }
 104
 105 SpellcheckHunspellDictionary::~SpellcheckHunspellDictionary() {
 106 }
 107
 108 void SpellcheckHunspellDictionary::Load() {
 109   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 110
 111 #if defined(USE_PLATFORM_SPELLCHECKER)
 112   if (spellcheck_platform::SpellCheckerAvailable() &&
 113       spellcheck_platform::PlatformSupportsLanguage(language_)) {
 114     use_platform_spellchecker_ = true;
 115     spellcheck_platform::SetLanguage(language_);
 116     base::MessageLoop::current()->PostTask(FROM_HERE,
 117         base::Bind(
 118             &SpellcheckHunspellDictionary::InformListenersOfInitialization,
 119             weak_ptr_factory_.GetWeakPtr()));
 120     return;
 121   }
 122 #endif  // USE_PLATFORM_SPELLCHECKER
 123
 124 // Mac falls back on hunspell if its platform spellchecker isn't available.
 125 // However, Android does not support hunspell.
 126 #if !defined(OS_ANDROID)
 127   BrowserThread::PostTaskAndReplyWithResult(
 128       BrowserThread::FILE,
 129       FROM_HERE,
 130       base::Bind(&InitializeDictionaryLocation, language_),
 131       base::Bind(
 132           &SpellcheckHunspellDictionary::InitializeDictionaryLocationComplete,
 133           weak_ptr_factory_.GetWeakPtr()));
 134 #endif // !OS_ANDROID
 135 }
 136
 137 void SpellcheckHunspellDictionary::RetryDownloadDictionary(
 138       net::URLRequestContextGetter* request_context_getter) {
 139   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 140   request_context_getter_ = request_context_getter;
 141   DownloadDictionary(GetDictionaryURL());
 142 }
 143
 144 bool SpellcheckHunspellDictionary::IsReady() const {
 145   return GetDictionaryFile().IsValid() || IsUsingPlatformChecker();
 146 }
 147
 148 const base::File& SpellcheckHunspellDictionary::GetDictionaryFile() const {
 149   return dictionary_file_.file;
 150 }
 151
 152 const std::string& SpellcheckHunspellDictionary::GetLanguage() const {
 153   return language_;
 154 }
 155
 156 bool SpellcheckHunspellDictionary::IsUsingPlatformChecker() const {
 157   return use_platform_spellchecker_;
 158 }
 159
 160 void SpellcheckHunspellDictionary::AddObserver(Observer* observer) {
 161   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 162   observers_.AddObserver(observer);
 163 }
 164
 165 void SpellcheckHunspellDictionary::RemoveObserver(Observer* observer) {
 166   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 167   observers_.RemoveObserver(observer);
 168 }
 169
 170 bool SpellcheckHunspellDictionary::IsDownloadInProgress() {
 171   return download_status_ == DOWNLOAD_IN_PROGRESS;
 172 }
 173
 174 bool SpellcheckHunspellDictionary::IsDownloadFailure() {
 175   return download_status_ == DOWNLOAD_FAILED;
 176 }
 177
 178 void SpellcheckHunspellDictionary::OnURLFetchComplete(
 179     const net::URLFetcher* source) {
 180   DCHECK(source);
 181   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 182   scoped_ptr<net::URLFetcher> fetcher_destructor(fetcher_.release());
 183
 184   if ((source->GetResponseCode() / 100) != 2) {
 185     // Initialize will not try to download the file a second time.
 186     InformListenersOfDownloadFailure();
 187     return;
 188   }
 189
 190   // Basic sanity check on the dictionary. There's a small chance of 200 status
 191   // code for a body that represents some form of failure.
 192   scoped_ptr<std::string> data(new std::string);
 193   source->GetResponseAsString(data.get());
 194   if (data->size() < 4 || data->compare(0, 4, "BDic") != 0) {
 195     InformListenersOfDownloadFailure();
 196     return;
 197   }
 198
 199   // To prevent corrupted dictionary data from causing a renderer crash, scan
 200   // the dictionary data and verify it is sane before save it to a file.
 201   // TODO(rlp): Adding metrics to RecordDictionaryCorruptionStats
 202   if (!hunspell::BDict::Verify(data->data(), data->size())) {
 203     // Let PostTaskAndReply caller send to InformListenersOfInitialization
 204     // through SaveDictionaryDataComplete().
 205     SaveDictionaryDataComplete(false);
 206     return;
 207   }
 208
 209   BrowserThread::PostTaskAndReplyWithResult<bool>(
 210       BrowserThread::FILE,
 211       FROM_HERE,
 212       base::Bind(&SaveDictionaryData,
 213                  base::Passed(&data),
 214                  dictionary_file_.path),
 215       base::Bind(&SpellcheckHunspellDictionary::SaveDictionaryDataComplete,
 216                  weak_ptr_factory_.GetWeakPtr()));
 217 }
 218
 219 GURL SpellcheckHunspellDictionary::GetDictionaryURL() {
 220   static const char kDownloadServerUrl[] =
 221       "https://redirector.gvt1.com/edgedl/chrome/dict/";
 222   std::string bdict_file = dictionary_file_.path.BaseName().MaybeAsASCII();
 223
 224   DCHECK(!bdict_file.empty());
 225
 226   return GURL(std::string(kDownloadServerUrl) +
 227               base::StringToLowerASCII(bdict_file));
 228 }
 229
 230 void SpellcheckHunspellDictionary::DownloadDictionary(GURL url) {
 231   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 232   DCHECK(request_context_getter_);
 233
 234   download_status_ = DOWNLOAD_IN_PROGRESS;
 235   FOR_EACH_OBSERVER(Observer, observers_, OnHunspellDictionaryDownloadBegin());
 236
 237   fetcher_ = net::URLFetcher::Create(url, net::URLFetcher::GET, this);
 238   fetcher_->SetRequestContext(request_context_getter_);
 239   fetcher_->SetLoadFlags(
 240       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
 241   fetcher_->Start();
 242   // Attempt downloading the dictionary only once.
 243   request_context_getter_ = NULL;
 244 }
 245
 246 // The default_dictionary_file can either come from the standard list of
 247 // hunspell dictionaries (determined in InitializeDictionaryLocation), or it
 248 // can be passed in via an extension. In either case, the file is checked for
 249 // existence so that it's not re-downloaded.
 250 // For systemwide installations on Windows, the default directory may not
 251 // have permissions for download. In that case, the alternate directory for
 252 // download is chrome::DIR_USER_DATA.
 253 SpellcheckHunspellDictionary::DictionaryFile
 254 SpellcheckHunspellDictionary::OpenDictionaryFile(const base::FilePath& path) {
 255   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 256   DictionaryFile dictionary;
 257
 258 #if defined(OS_WIN)
 259   // Check if the dictionary exists in the fallback location. If so, use it
 260   // rather than downloading anew.
 261   base::FilePath user_dir;
 262   PathService::Get(chrome::DIR_USER_DATA, &user_dir);
 263   base::FilePath fallback = user_dir.Append(path.BaseName());
 264   if (!base::PathExists(path) && base::PathExists(fallback))
 265     dictionary.path = fallback;
 266   else
 267     dictionary.path = path;
 268 #else
 269   dictionary.path = path;
 270 #endif
 271
 272   // Read the dictionary file and scan its data to check for corruption. The
 273   // scoping closes the memory-mapped file before it is opened or deleted.
 274   bool bdict_is_valid;
 275   {
 276     base::MemoryMappedFile map;
 277     bdict_is_valid =
 278         base::PathExists(dictionary.path) &&
 279         map.Initialize(dictionary.path) &&
 280         hunspell::BDict::Verify(reinterpret_cast<const char*>(map.data()),
 281                                 map.length());
 282   }
 283   if (bdict_is_valid) {
 284     dictionary.file.Initialize(dictionary.path,
 285                                base::File::FLAG_READ | base::File::FLAG_OPEN);
 286   } else {
 287     base::DeleteFile(dictionary.path, false);
 288   }
 289
 290   return dictionary.Pass();
 291 }
 292
 293 // The default place where the spellcheck dictionary resides is
 294 // chrome::DIR_APP_DICTIONARIES.
 295 SpellcheckHunspellDictionary::DictionaryFile
 296 SpellcheckHunspellDictionary::InitializeDictionaryLocation(
 297     const std::string& language) {
 298   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 299
 300   // Initialize the BDICT path. Initialization should be in the FILE thread
 301   // because it checks if there is a "Dictionaries" directory and create it.
 302   base::FilePath dict_dir;
 303   PathService::Get(chrome::DIR_APP_DICTIONARIES, &dict_dir);
 304   base::FilePath dict_path =
 305       chrome::spellcheck_common::GetVersionedFileName(language, dict_dir);
 306
 307   return OpenDictionaryFile(dict_path);
 308 }
 309
 310 void SpellcheckHunspellDictionary::InitializeDictionaryLocationComplete(
 311     DictionaryFile file) {
 312   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 313   dictionary_file_ = file.Pass();
 314
 315   if (!dictionary_file_.file.IsValid()) {
 316
 317     // Notify browser tests that this dictionary is corrupted. Skip downloading
 318     // the dictionary in browser tests.
 319     // TODO(rouslan): Remove this test-only case.
 320     if (spellcheck_service_->SignalStatusEvent(
 321           SpellcheckService::BDICT_CORRUPTED)) {
 322       request_context_getter_ = NULL;
 323     }
 324
 325     if (request_context_getter_) {
 326       // Download from the UI thread to check that |request_context_getter_| is
 327       // still valid.
 328       DownloadDictionary(GetDictionaryURL());
 329       return;
 330     }
 331   }
 332
 333   InformListenersOfInitialization();
 334 }
 335
 336 void SpellcheckHunspellDictionary::SaveDictionaryDataComplete(
 337     bool dictionary_saved) {
 338   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 339
 340   if (dictionary_saved) {
 341     download_status_ = DOWNLOAD_NONE;
 342     FOR_EACH_OBSERVER(Observer,
 343                       observers_,
 344                       OnHunspellDictionaryDownloadSuccess());
 345     Load();
 346   } else {
 347     InformListenersOfDownloadFailure();
 348     InformListenersOfInitialization();
 349   }
 350 }
 351
 352 void SpellcheckHunspellDictionary::InformListenersOfInitialization() {
 353   FOR_EACH_OBSERVER(Observer, observers_, OnHunspellDictionaryInitialized());
 354 }
 355
 356 void SpellcheckHunspellDictionary::InformListenersOfDownloadFailure() {
 357   download_status_ = DOWNLOAD_FAILED;
 358   FOR_EACH_OBSERVER(Observer,
 359                     observers_,
 360                     OnHunspellDictionaryDownloadFailure());
 361 }