md-settings: add reset request origin to reset feedback proto.

chrome/browser/ui/webui/settings/reset_settings_handler.cc

 // Copyright 2013 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/ui/webui/settings/reset_settings_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
 #include "chrome/browser/profile_resetter/brandcode_config_fetcher.h"
 #include "chrome/browser/profile_resetter/brandcoded_default_settings.h"
-#include "chrome/browser/profile_resetter/profile_reset_report.pb.h"
 #include "chrome/browser/profile_resetter/profile_resetter.h"
 #include "chrome/browser/profile_resetter/resettable_settings_snapshot.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/reset/metrics.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_manager/user_manager.h"
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(OS_WIN)
 #include "chrome/browser/profile_resetter/triggered_profile_resetter.h"
 #include "chrome/browser/profile_resetter/triggered_profile_resetter_factory.h"
 #endif  // defined(OS_WIN)
 
 namespace settings {
 
+namespace {
+
+reset_report::ChromeResetReport::ResetRequestOrigin
+ResetRequestOriginFromString(const std::string& request_origin) {
+  static const char kOriginUserClick[] = "userclick";
+  static const char kOriginTriggeredReset[] = "triggeredreset";
+
+  if (request_origin == ResetSettingsHandler::kCctResetSettingsHash)
+    return reset_report::ChromeResetReport::RESET_REQUEST_ORIGIN_CCT;
+  if (request_origin == kOriginUserClick)
+    return reset_report::ChromeResetReport::RESET_REQUEST_ORIGIN_USER_CLICK;
+  if (request_origin == kOriginTriggeredReset) {
+    return reset_report::ChromeResetReport::
+        RESET_REQUEST_ORIGIN_TRIGGERED_RESET;
+  }
+  if (!request_origin.empty())

[hcarmona, 2016/10/13 20:30:20]

Is an empty request_origin allowed?

[alito, 2016/10/13 21:27:28]

Yes. It signals that the origin is UNKNOWN.

[hcarmona, 2016/10/13 23:37:54]

Sounds good. :-)

+    NOTREACHED();
+
+  return reset_report::ChromeResetReport::RESET_REQUEST_ORIGIN_UNKNOWN;
+}
+
+}  // namespace
+
+const char ResetSettingsHandler::kCctResetSettingsHash[] = "cct";
+
 ResetSettingsHandler::ResetSettingsHandler(Profile* profile)
     : profile_(profile), weak_ptr_factory_(this) {
   google_brand::GetBrand(&brandcode_);
 }
 
 ResetSettingsHandler::~ResetSettingsHandler() {}
 
 ResetSettingsHandler* ResetSettingsHandler::Create(
     content::WebUIDataSource* html_source, Profile* profile) {
 #if defined(OS_CHROMEOS)
@@ skipping 43 matching lines @@
        "onPowerwashDialogShow",
        base::Bind(&ResetSettingsHandler::OnShowPowerwashDialog,
                   base::Unretained(this)));
 #endif  // defined(OS_CHROMEOS)
 }
 
 void ResetSettingsHandler::HandleResetProfileSettings(
     const base::ListValue* args) {
   AllowJavascript();
 
-  CHECK_EQ(2U, args->GetSize());
+  CHECK_EQ(3U, args->GetSize());
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
   bool send_settings = false;
   CHECK(args->GetBoolean(1, &send_settings));
+  std::string request_origin_string;
+  CHECK(args->GetString(2, &request_origin_string));
+  reset_report::ChromeResetReport::ResetRequestOrigin request_origin =
+      ResetRequestOriginFromString(request_origin_string);
 
   DCHECK(brandcode_.empty() || config_fetcher_);
   if (config_fetcher_ && config_fetcher_->IsActive()) {
     // Reset once the prefs are fetched.
-    config_fetcher_->SetCallback(
-        base::Bind(&ResetSettingsHandler::ResetProfile,
-                   base::Unretained(this),
-                   callback_id,
-                   send_settings));
+    config_fetcher_->SetCallback(base::Bind(&ResetSettingsHandler::ResetProfile,
+                                            base::Unretained(this), callback_id,
+                                            send_settings, request_origin));
   } else {
-    ResetProfile(callback_id, send_settings);
+    ResetProfile(callback_id, send_settings, request_origin);
   }
 }
 
 void ResetSettingsHandler::OnResetProfileSettingsDone(
-    std::string callback_id, bool send_feedback) {
+    std::string callback_id,
+    bool send_feedback,
+    reset_report::ChromeResetReport::ResetRequestOrigin request_origin) {
   ResolveJavascriptCallback(
       base::StringValue(callback_id), *base::Value::CreateNullValue());
   if (send_feedback && setting_snapshot_) {
     ResettableSettingsSnapshot current_snapshot(profile_);
     int difference = setting_snapshot_->FindDifferentFields(current_snapshot);
     if (difference) {
       setting_snapshot_->Subtract(current_snapshot);
       std::unique_ptr<reset_report::ChromeResetReport> report_proto =
           SerializeSettingsReportToProto(*setting_snapshot_, difference);
       if (report_proto) {
-        // The material design version of the settings page currently does not
-        // expose the alternative ways, made available by the old settings page,
-        // to get to the reset settings dialog. Until those are available, we
-        // can assume that all reset requests came directly from user
-        // navigation.
-        report_proto->set_reset_request_origin(
-            reset_report::ChromeResetReport::RESET_REQUEST_ORIGIN_USER_CLICK);
+        report_proto->set_reset_request_origin(request_origin);
         SendSettingsFeedbackProto(*report_proto, profile_);
       }
     }
   }
   setting_snapshot_.reset();
 }
 
 void ResetSettingsHandler::HandleGetReportedSettings(
     const base::ListValue* args) {
   AllowJavascript();
@@ skipping 39 matching lines @@
     const base::ListValue* args) {
   chrome_prefs::ClearResetTime(profile_);
 }
 
 void ResetSettingsHandler::OnSettingsFetched() {
   DCHECK(config_fetcher_);
   DCHECK(!config_fetcher_->IsActive());
   // The master prefs is fetched. We are waiting for user pressing 'Reset'.
 }
 
-void ResetSettingsHandler::ResetProfile(std::string callback_id,
-                                        bool send_settings) {
+void ResetSettingsHandler::ResetProfile(
+    std::string callback_id,
+    bool send_settings,
+    reset_report::ChromeResetReport::ResetRequestOrigin request_origin) {
   DCHECK(!GetResetter()->IsActive());
 
   std::unique_ptr<BrandcodedDefaultSettings> default_settings;
   if (config_fetcher_) {
     DCHECK(!config_fetcher_->IsActive());
     default_settings = config_fetcher_->GetSettings();
     config_fetcher_.reset();
   } else {
     DCHECK(brandcode_.empty());
   }
 
   // If failed to fetch BrandcodedDefaultSettings or this is an organic
   // installation, use default settings.
   if (!default_settings)
     default_settings.reset(new BrandcodedDefaultSettings);
 
   GetResetter()->Reset(
       ProfileResetter::ALL, std::move(default_settings),
       base::Bind(&ResetSettingsHandler::OnResetProfileSettingsDone,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback_id,
-                 send_settings));
+                 weak_ptr_factory_.GetWeakPtr(), callback_id, send_settings,
+                 request_origin));
   content::RecordAction(base::UserMetricsAction("ResetProfile"));
   UMA_HISTOGRAM_BOOLEAN("ProfileReset.SendFeedback", send_settings);
 }
 
 ProfileResetter* ResetSettingsHandler::GetResetter() {
   if (!resetter_)
     resetter_.reset(new ProfileResetter(profile_));
   return resetter_.get();
 }
 
@@ skipping 34 matching lines @@
 void ResetSettingsHandler::OnShowPowerwashDialog(
      const base::ListValue* args) {
   UMA_HISTOGRAM_ENUMERATION(
       "Reset.ChromeOS.PowerwashDialogShown",
       chromeos::reset::DIALOG_FROM_OPTIONS,
       chromeos::reset::DIALOG_VIEW_TYPE_SIZE);
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace settings