Removed AttemptResult enum in favor of using DefaultWebClientState

chrome/browser/shell_integration.cc

 // Copyright (c) 2012 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/shell_integration.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 130 matching lines @@
 // DefaultWebClientWorker
 //
 
 DefaultWebClientWorker::DefaultWebClientWorker(
     const DefaultWebClientWorkerCallback& callback)
     : callback_(callback) {}
 
 void DefaultWebClientWorker::StartCheckIsDefault() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DefaultWebClientWorker::CheckIsDefault, this));
+      base::Bind(&DefaultWebClientWorker::CheckIsDefault, this, false));
 }
 
 void DefaultWebClientWorker::StartSetAsDefault() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DefaultWebClientWorker::SetAsDefault, this));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultWebClientWorker, private:
 
 DefaultWebClientWorker::~DefaultWebClientWorker() {}
 
 void DefaultWebClientWorker::OnCheckIsDefaultComplete(
-    DefaultWebClientState state) {
+    DefaultWebClientState state,
+    bool is_following_set_as_default) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   UpdateUI(state);
 
-  if (check_default_should_report_success_) {
-    check_default_should_report_success_ = false;
-
-    ReportAttemptResult(state == DefaultWebClientState::IS_DEFAULT
-                            ? AttemptResult::SUCCESS
-                            : AttemptResult::NO_ERRORS_NOT_DEFAULT);
-  }
+  if (is_following_set_as_default)
+    ReportSetDefaultResult(state);
 }
 
-void DefaultWebClientWorker::OnSetAsDefaultAttemptComplete(
-    AttemptResult result) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  // Report failures here. Successes are reported in
-  // OnCheckIsDefaultComplete() after checking that the change is verified.
-  check_default_should_report_success_ = result == AttemptResult::SUCCESS;
-  if (!check_default_should_report_success_)
-    ReportAttemptResult(result);
-
-  // Start the default browser check. The default state will be reported to
-  // the caller via the |callback_|.
-  StartCheckIsDefault();
-}
-
-void DefaultWebClientWorker::ReportAttemptResult(AttemptResult result) {
+void DefaultWebClientWorker::ReportSetDefaultResult(
+    DefaultWebClientState state) {
   base::LinearHistogram::FactoryGet(
-      base::StringPrintf("%s.SetDefaultResult", GetHistogramPrefix()), 1,
-      AttemptResult::NUM_ATTEMPT_RESULT_TYPES,
-      AttemptResult::NUM_ATTEMPT_RESULT_TYPES + 1,
+      base::StringPrintf("%s.SetDefaultResult2", GetHistogramPrefix()), 1,
+      DefaultWebClientState::NUM_DEFAULT_STATES,
+      DefaultWebClientState::NUM_DEFAULT_STATES + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag)
-      ->Add(result);
+      ->Add(state);
 }
 
 void DefaultWebClientWorker::UpdateUI(DefaultWebClientState state) {
   if (!callback_.is_null()) {
     switch (state) {
       case NOT_DEFAULT:
         callback_.Run(NOT_DEFAULT);
         break;
       case IS_DEFAULT:
         callback_.Run(IS_DEFAULT);
@@ skipping 14 matching lines @@
 
 DefaultBrowserWorker::DefaultBrowserWorker(
     const DefaultWebClientWorkerCallback& callback)
     : DefaultWebClientWorker(callback) {}
 
 DefaultBrowserWorker::~DefaultBrowserWorker() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultBrowserWorker, private:
 
-void DefaultBrowserWorker::CheckIsDefault() {
+void DefaultBrowserWorker::CheckIsDefault(bool is_following_set_as_default) {
   DefaultWebClientState state = GetDefaultBrowser();
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&DefaultBrowserWorker::OnCheckIsDefaultComplete, this, state));
+      base::Bind(&DefaultBrowserWorker::OnCheckIsDefaultComplete, this, state,
+                 is_following_set_as_default));
 }
 
 void DefaultBrowserWorker::SetAsDefault() {
-  AttemptResult result = AttemptResult::FAILURE;
   switch (CanSetAsDefaultBrowser()) {
     case SET_DEFAULT_NOT_ALLOWED:
       NOTREACHED();
       break;
     case SET_DEFAULT_UNATTENDED:
-      if (SetAsDefaultBrowser())
-        result = AttemptResult::SUCCESS;
+      SetAsDefaultBrowser();
       break;
     case SET_DEFAULT_INTERACTIVE:
-      if (interactive_permitted_ && SetAsDefaultBrowserInteractive())
-        result = AttemptResult::SUCCESS;
+      if (interactive_permitted_)
+        SetAsDefaultBrowserInteractive();
       break;
   }
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&DefaultBrowserWorker::OnSetAsDefaultAttemptComplete, this,
-                 result));
+  CheckIsDefault(true);
 }
 
 const char* DefaultBrowserWorker::GetHistogramPrefix() {
   return "DefaultBrowser";
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultProtocolClientWorker
 //
 
 DefaultProtocolClientWorker::DefaultProtocolClientWorker(
     const DefaultWebClientWorkerCallback& callback,
     const std::string& protocol)
     : DefaultWebClientWorker(callback), protocol_(protocol) {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultProtocolClientWorker, private:
 
 DefaultProtocolClientWorker::~DefaultProtocolClientWorker() {}
 
-void DefaultProtocolClientWorker::CheckIsDefault() {
+void DefaultProtocolClientWorker::CheckIsDefault(
+    bool is_following_set_as_default) {
   DefaultWebClientState state = IsDefaultProtocolClient(protocol_);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DefaultProtocolClientWorker::OnCheckIsDefaultComplete, this,
-                 state));
+                 state, is_following_set_as_default));
 }
 
 void DefaultProtocolClientWorker::SetAsDefault() {
-  AttemptResult result = AttemptResult::FAILURE;
   switch (CanSetAsDefaultProtocolClient()) {
     case SET_DEFAULT_NOT_ALLOWED:
       // Not allowed, do nothing.
       break;
     case SET_DEFAULT_UNATTENDED:
-      if (SetAsDefaultProtocolClient(protocol_))
-        result = AttemptResult::SUCCESS;
+      SetAsDefaultProtocolClient(protocol_);
       break;
     case SET_DEFAULT_INTERACTIVE:
-      if (interactive_permitted_ &&
-          SetAsDefaultProtocolClientInteractive(protocol_)) {
-        result = AttemptResult::SUCCESS;
+      if (interactive_permitted_) {
+        SetAsDefaultProtocolClientInteractive(protocol_);
       }
       break;
   }
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&DefaultProtocolClientWorker::OnSetAsDefaultAttemptComplete,
-                 this, result));
+  CheckIsDefault(true);
 }
 
 const char* DefaultProtocolClientWorker::GetHistogramPrefix() {
   return "DefaultProtocolClient";
 }
 
 }  // namespace shell_integration