reland 57093: dom-ui options: record user metrics for pref changes....

chrome/browser/dom_ui/core_options_handler.cc

 // Copyright (c) 2010 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/dom_ui/core_options_handler.h"
 
 #include "app/l10n_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/metrics/user_metrics.h"
+#include "chrome/browser/pref_service.h"
+#include "chrome/browser/profile.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
-#include "chrome/browser/pref_service.h"
-#include "chrome/browser/profile.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 
 CoreOptionsHandler::CoreOptionsHandler() {
 }
 
 CoreOptionsHandler::~CoreOptionsHandler() {
@@ skipping 77 matching lines @@
   dom_ui_->RegisterMessageCallback("observePrefs",
       NewCallback(this, &CoreOptionsHandler::HandleObservePrefs));
   dom_ui_->RegisterMessageCallback("setBooleanPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetBooleanPref));
   dom_ui_->RegisterMessageCallback("setIntegerPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetIntegerPref));
   dom_ui_->RegisterMessageCallback("setStringPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetStringPref));
   dom_ui_->RegisterMessageCallback("setObjectPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetObjectPref));
+  dom_ui_->RegisterMessageCallback("coreOptionsUserMetricsAction",
+      NewCallback(this, &CoreOptionsHandler::HandleUserMetricsAction));
 }
 
 void CoreOptionsHandler::HandleInitialize(const ListValue* args) {
   static_cast<OptionsUI*>(dom_ui_)->InitializeHandlers();
 }
 
 Value* CoreOptionsHandler::FetchPref(const std::string& pref_name) {
   DCHECK(dom_ui_);
   PrefService* pref_service = dom_ui_->GetProfile()->GetPrefs();
 
@@ skipping 13 matching lines @@
 }
 
 void CoreOptionsHandler::ObservePref(const std::string& pref_name) {
   DCHECK(dom_ui_);
   PrefService* pref_service = dom_ui_->GetProfile()->GetPrefs();
   pref_service->AddPrefObserver(pref_name.c_str(), this);
 }
 
 void CoreOptionsHandler::SetPref(const std::string& pref_name,
                                  Value::ValueType pref_type,
-                                 const std::string& value_string) {
+                                 const std::string& value_string,
+                                 const std::string& metric) {
   DCHECK(dom_ui_);
   PrefService* pref_service = dom_ui_->GetProfile()->GetPrefs();
 
   switch (pref_type) {
     case Value::TYPE_BOOLEAN:
       pref_service->SetBoolean(pref_name.c_str(), value_string == "true");
       break;
     case Value::TYPE_INTEGER:
       int int_value;
       if (base::StringToInt(value_string, &int_value))
         pref_service->SetInteger(pref_name.c_str(), int_value);
       break;
     case Value::TYPE_STRING:
       pref_service->SetString(pref_name.c_str(), value_string);
       break;
     default:
       NOTREACHED();
   }
+
+  ProcessUserMetric(pref_type, value_string, metric);
+}
+
+void CoreOptionsHandler::ProcessUserMetric(Value::ValueType pref_type,
+                                           const std::string& value_string,
+                                           const std::string& metric) {
+  if (metric.empty())
+    return;
+
+  std::string metric_string = metric;
+  if (pref_type == Value::TYPE_BOOLEAN)
+    metric_string += (value_string == "true" ? "_Enable" : "_Disable");
+
+  UserMetricsRecordAction(UserMetricsAction(metric_string.c_str()),
+                          dom_ui_->GetProfile()->GetPrefs());
 }
 
 void CoreOptionsHandler::HandleFetchPrefs(const ListValue* args) {
   // First param is name of callback function, so, there needs to be at least
   // one more element for the actual preference identifier.
   const size_t kMinFetchPrefsParamCount = 2;
   if (args->GetSize() < kMinFetchPrefsParamCount)
     return;
 
   // Get callback JS function name.
@@ skipping 20 matching lines @@
     if (!list_member->GetAsString(&pref_name))
       continue;
 
     result_value.Set(pref_name.c_str(), FetchPref(pref_name));
   }
   dom_ui_->CallJavascriptFunction(UTF16ToWideHack(callback_function).c_str(),
                                   result_value);
 }
 
 void CoreOptionsHandler::HandleObservePrefs(const ListValue* args) {
-  DictionaryValue result_value;
-
   // First param is name is JS callback function name, the rest are pref
   // identifiers that we are observing.
   const size_t kMinObservePrefsParamCount = 2;
   if (args->GetSize() < kMinObservePrefsParamCount)
     return;
 
   // Get preference change callback function name.
   string16 callback_func_name;
   if (!args->GetString(0, &callback_func_name))
     return;
@@ skipping 30 matching lines @@
 void CoreOptionsHandler::HandleSetStringPref(const ListValue* args) {
   HandleSetPref(args, Value::TYPE_STRING);
 }
 
 void CoreOptionsHandler::HandleSetObjectPref(const ListValue* args) {
   HandleSetPref(args, Value::TYPE_NULL);
 }
 
 void CoreOptionsHandler::HandleSetPref(const ListValue* args,
                                        Value::ValueType type) {
-  if (args->GetSize() != 2)
+  if (args->GetSize() < 2)
     return;
 
   std::string pref_name;
   if (!args->GetString(0, &pref_name))
     return;
 
   std::string value_string;
   if (!args->GetString(1, &value_string))
     return;
 
-  SetPref(pref_name, type, value_string);
+  std::string metric;
+  if (args->GetSize() > 2)
+    args->GetString(2, &metric);
+
+  SetPref(pref_name, type, value_string, metric);
+}
+
+void CoreOptionsHandler::HandleUserMetricsAction(const ListValue* args) {
+  std::string metric = WideToUTF8(ExtractStringValue(args));
+  if (!metric.empty())
+    UserMetricsRecordAction(UserMetricsAction(metric.c_str()), NULL);
 }
 
 void CoreOptionsHandler::NotifyPrefChanged(const std::string* pref_name) {
   DCHECK(pref_name);
   DCHECK(dom_ui_);
   PrefService* pref_service = dom_ui_->GetProfile()->GetPrefs();
   const PrefService::Preference* pref =
       pref_service->FindPreference(pref_name->c_str());
   if (pref) {
     for (PreferenceCallbackMap::const_iterator iter =
         pref_callback_map_.find(*pref_name);
         iter != pref_callback_map_.end(); ++iter) {
       const std::wstring& callback_function = iter->second;
       ListValue result_value;
       result_value.Append(Value::CreateStringValue(pref_name->c_str()));
 
       DictionaryValue* dict = new DictionaryValue;
       dict->Set("value", pref->GetValue()->DeepCopy());
       dict->SetBoolean("managed", pref->IsManaged());
       result_value.Append(dict);
 
       dom_ui_->CallJavascriptFunction(callback_function, result_value);
     }
   }
 }