Introduced additional spellcheck related histogram.

chrome/browser/spellcheck_host_impl.cc

 // 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.
 
 #include "chrome/browser/spellcheck_host_impl.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 73 matching lines @@
     const std::string& language,
     net::URLRequestContextGetter* request_context_getter)
     : observer_(observer),
       language_(language),
       file_(base::kInvalidPlatformFileValue),
       tried_to_download_(false),
       use_platform_spellchecker_(false),
       request_context_getter_(request_context_getter),
       misspelled_word_count_(0),
       spellchecked_word_count_(0),
+      suggestion_show_count_(0),
       replaced_word_count_(0) {
   DCHECK(observer_);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FilePath personal_file_directory;
   PathService::Get(chrome::DIR_USER_DATA, &personal_file_directory);
   custom_dictionary_file_ =
       personal_file_directory.Append(chrome::kCustomDictionaryFileName);
 
   registrar_.Add(this, NotificationType::RENDERER_PROCESS_CREATED,
@@ skipping 204 matching lines @@
     // the population.  So we ensure to instantiate the histogram
     // entries here at the first time.
     if (misspelled_word_count_ == 1)
       RecordReplacedWordStats(0);
   }
 
   int percentage = (100 * misspelled_word_count_) / spellchecked_word_count_;
   UMA_HISTOGRAM_PERCENTAGE("SpellCheck.MisspellRatio", percentage);
 }
 
+void SpellCheckHostImpl::RecordDictionaryCorruptionStats(bool corrupted) {
+  UMA_HISTOGRAM_BOOLEAN("SpellCheck.DictionaryCorrupted", corrupted);
+}
+
+void SpellCheckHostImpl::RecordSuggestionStats(int delta) {
+  suggestion_show_count_ += delta;
+  RecordReplacedWordStats(0);
+}
+
 void SpellCheckHostImpl::RecordReplacedWordStats(int delta) {
   replaced_word_count_ += delta;
-  if (!misspelled_word_count_) {
-    // This is possible when an extension gives the misspelling,
-    // which is not recorded as a part of this metrics.
-    return;
+
+  if (misspelled_word_count_) {
+    // zero |misspelled_word_count_| is possible when an extension
+    // gives the misspelling, which is not recorded as a part of this
+    // metrics.
+    int percentage = (100 * replaced_word_count_) / misspelled_word_count_;
+    UMA_HISTOGRAM_PERCENTAGE("SpellCheck.ReplaceRatio", percentage);
   }
 
-  int percentage = (100 * replaced_word_count_) / misspelled_word_count_;
-  UMA_HISTOGRAM_PERCENTAGE("SpellCheck.ReplaceRatio", percentage);
+  if (suggestion_show_count_) {
+    int percentage = (100 * replaced_word_count_) / suggestion_show_count_;
+    UMA_HISTOGRAM_PERCENTAGE("SpellCheck.SuggestionHitRatio", percentage);
+  }
 }
 
 void SpellCheckHostImpl::OnURLFetchComplete(const URLFetcher* source,
                                             const GURL& url,
                                             const net::URLRequestStatus& status,
                                             int response_code,
                                             const net::ResponseCookies& cookies,
                                             const std::string& data) {
   DCHECK(source);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 27 matching lines @@
   DCHECK(type == NotificationType::RENDERER_PROCESS_CREATED);
   RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
   InitForRenderer(process);
 }
 
 void SpellCheckHostImpl::SaveDictionaryData() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // To prevent corrupted dictionary data from causing a renderer crash, scan
   // the dictionary data and verify it is sane before save it to a file.
-  if (!hunspell::BDict::Verify(data_.data(), data_.size())) {
+  bool verified = hunspell::BDict::Verify(data_.data(), data_.size());
+  RecordDictionaryCorruptionStats(!verified);
+  if (!verified) {
     LOG(ERROR) << "Failure to verify the downloaded dictionary.";
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &SpellCheckHostImpl::InformObserverOfInitialization));
     return;
   }
 
   size_t bytes_written =
       file_util::WriteFile(bdict_file_path_, data_.data(), data_.length());
   if (bytes_written != data_.length()) {
@@ skipping 36 matching lines @@
   return custom_words_.back();
 }
 
 const std::string& SpellCheckHostImpl::GetLanguage() const {
   return language_;
 }
 
 bool SpellCheckHostImpl::IsUsingPlatformChecker() const {
   return use_platform_spellchecker_;
 }