Revert 88309 - Introduced additional spellcheck related histograms.

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_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_count_ += delta;
-  RecordReplacedWordStats(0);
-}
-
 void SpellCheckHostImpl::RecordReplacedWordStats(int delta) {
   replaced_word_count_ += delta;
-
-  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);
+  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 (suggestion_count_) {
-    int percentage = (100 * replaced_word_count_) / suggestion_count_;
-    UMA_HISTOGRAM_PERCENTAGE("SpellCheck.SuggestionHitRatio", percentage);
-  }
+  int percentage = (100 * replaced_word_count_) / misspelled_word_count_;
+  UMA_HISTOGRAM_PERCENTAGE("SpellCheck.ReplaceRatio", 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.
-  bool verified = hunspell::BDict::Verify(data_.data(), data_.size());
-  RecordDictionaryCorruptionStats(!verified);
-  if (!verified) {
+  if (!hunspell::BDict::Verify(data_.data(), data_.size())) {
     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_;
 }