Protector histograms for default search provider change added.

chrome/browser/protector/default_search_provider_change.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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "chrome/browser/protector/base_setting_change.h"
+#include "chrome/browser/protector/histograms.h"
 #include "chrome/browser/protector/protector.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_observer.h"
 #include "chrome/browser/webdata/keyword_table.h"
 #include "chrome/common/url_constants.h"
+#include "googleurl/src/gurl.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
-#include "googleurl/src/gurl.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace protector {
 
 namespace {
 
 // Maximum length of the search engine name to be displayed.
 const size_t kMaxDisplayedNameLength = 10;
 
 }  // namespace
 
 class DefaultSearchProviderChange : public BaseSettingChange,
                                     public TemplateURLServiceObserver {
  public:
   DefaultSearchProviderChange(const TemplateURL* old_url,
                               const TemplateURL* new_url);
 
   // BaseSettingChange overrides:
   virtual bool Init(Protector* protector) OVERRIDE;
   virtual void Apply() OVERRIDE;
   virtual void Discard() OVERRIDE;
+  virtual void Timeout() OVERRIDE;
   virtual void OnBeforeRemoved() OVERRIDE;
   virtual string16 GetBubbleTitle() const OVERRIDE;
   virtual string16 GetBubbleMessage() const OVERRIDE;
   virtual string16 GetApplyButtonText() const OVERRIDE;
   virtual string16 GetDiscardButtonText() const OVERRIDE;
 
   // TemplateURLServiceObserver overrides:
   virtual void OnTemplateURLServiceChanged() OVERRIDE;
 
  private:
@@ skipping 11 matching lines @@
 
   int64 old_id_;
   int64 new_id_;
   // ID of the search engine that we fall back to if the backup is lost.
   int64 fallback_id_;
   string16 old_name_;
   string16 new_name_;
   // Name of the search engine that we fall back to if the backup is lost.
   string16 fallback_name_;
   string16 product_name_;
+  // Histogram ID of the new search provider.
+  int new_histogram_id_;
   // Default search provider set by |Init| for the period until user makes a
   // choice and either |Apply| or |Discard| is performed. Should only be used
   // for comparison with the current default search provider and never
   // dereferenced other than in |Init| because it may be deallocated by
   // TemplateURLService at any time.
   const TemplateURL* default_search_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultSearchProviderChange);
 };
 
 DefaultSearchProviderChange::DefaultSearchProviderChange(
     const TemplateURL* old_url,
     const TemplateURL* new_url)
     : old_id_(0),
       new_id_(0),
       fallback_id_(0),
       product_name_(l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)),
+      new_histogram_id_(GetSearchProviderHistogramID(new_url)),
       default_search_provider_(NULL) {
   if (new_url) {
     new_id_ = new_url->id();
     new_name_ = new_url->short_name();
   }
   if (old_url) {
     old_id_ = old_url->id();
     old_name_ = old_url->short_name();
   }
 }
 
 DefaultSearchProviderChange::~DefaultSearchProviderChange() {
 }
 
 bool DefaultSearchProviderChange::Init(Protector* protector) {
   BaseSettingChange::Init(protector);
 
+  UMA_HISTOGRAM_ENUMERATION(
+      kProtectorHistogramNewSearchProvider,
+      new_histogram_id_,
+      kProtectorMaxSearchProviderID);
+
   // Initially reset the search engine to its previous setting.
   default_search_provider_ = SetDefaultSearchProvider(old_id_, true);
   if (!default_search_provider_)
     return false;
 
   if (!old_id_ || default_search_provider_->id() != old_id_) {
     // Old settings is lost or invalid, so we had to fall back to one of the
     // prepopulated search engines.
     fallback_id_ = default_search_provider_->id();
     fallback_name_ = default_search_provider_->short_name();
     VLOG(1) << "Fallback to " << fallback_name_;
   }
 
   protector->GetTemplateURLService()->AddObserver(this);
 
   return true;
 }
 
 void DefaultSearchProviderChange::Apply() {
-  // TODO(avayvod): Add histrogram.
+  UMA_HISTOGRAM_ENUMERATION(
+      kProtectorHistogramSearchProviderApplied,
+      new_histogram_id_,
+      kProtectorMaxSearchProviderID);
+
   if (!new_id_) {
     // Open settings page in case the new setting is invalid.
     OpenSearchEngineSettings();
   } else {
     SetDefaultSearchProvider(new_id_, false);
   }
 }
 
 void DefaultSearchProviderChange::Discard() {
-  // TODO(avayvod): Add histrogram.
+  UMA_HISTOGRAM_ENUMERATION(
+      kProtectorHistogramSearchProviderDiscarded,
+      new_histogram_id_,
+      kProtectorMaxSearchProviderID);
+
   if (!old_id_) {
     // Open settings page in case the old setting is invalid.
     OpenSearchEngineSettings();
   }
   // Nothing to do otherwise since we have already set the search engine
   // to |old_id_| in |Init|.
 }
 
+void DefaultSearchProviderChange::Timeout() {
+  UMA_HISTOGRAM_ENUMERATION(
+      kProtectorHistogramSearchProviderTimeout,
+      new_histogram_id_,
+      kProtectorMaxSearchProviderID);
+}
+
 void DefaultSearchProviderChange::OnBeforeRemoved() {
   protector()->GetTemplateURLService()->RemoveObserver(this);
 }
 
 string16 DefaultSearchProviderChange::GetBubbleTitle() const {
   return l10n_util::GetStringUTF16(IDS_SEARCH_ENGINE_CHANGE_TITLE);
 }
 
 string16 DefaultSearchProviderChange::GetBubbleMessage() const {
   if (fallback_name_.empty())
@@ skipping 83 matching lines @@
            chrome::kSearchEnginesSubPage));
 }
 
 BaseSettingChange* CreateDefaultSearchProviderChange(
     const TemplateURL* actual,
     const TemplateURL* backup) {
   return new DefaultSearchProviderChange(backup, actual);
 }
 
 }  // namespace protector