Fixes the interactive default browser UX for policy setting

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 139 matching lines @@
 
 #if !defined(OS_WIN)
 base::string16 ShellIntegration::GetAppShortcutsSubdirName() {
   if (chrome::GetChannel() == version_info::Channel::CANARY)
     return l10n_util::GetStringUTF16(IDS_APP_SHORTCUTS_SUBDIR_NAME_CANARY);
   return l10n_util::GetStringUTF16(IDS_APP_SHORTCUTS_SUBDIR_NAME);
 }
 #endif  // !defined(OS_WIN)
 
 ///////////////////////////////////////////////////////////////////////////////
-// ShellIntegration::DefaultWebClientObserver
-//
-
-bool ShellIntegration::DefaultWebClientObserver::IsOwnedByWorker() {
-  return false;
-}
-
-bool ShellIntegration::DefaultWebClientObserver::
-    IsInteractiveSetDefaultPermitted() {
-  return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // ShellIntegration::DefaultWebClientWorker
 //
 
 ShellIntegration::DefaultWebClientWorker::DefaultWebClientWorker(
-    DefaultWebClientObserver* observer)
-    : observer_(observer) {}
+    DefaultWebClientObserver* observer,
+    bool delete_observer,
+    bool interactive_permitted)
+    : observer_(observer),
+      delete_observer_(delete_observer),
+      interactive_permitted_(interactive_permitted) {}
 
 void ShellIntegration::DefaultWebClientWorker::StartCheckIsDefault() {
   if (observer_)
     observer_->SetDefaultWebClientUIState(STATE_PROCESSING);
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DefaultWebClientWorker::CheckIsDefault, this));
 }
 
 void ShellIntegration::DefaultWebClientWorker::StartSetAsDefault() {
   // Cancel the already running process if another start is requested.
   if (set_as_default_in_progress_) {
     if (set_as_default_initialized_) {
       FinalizeSetAsDefault();
       set_as_default_initialized_ = false;
     }
 
     ReportAttemptResult(AttemptResult::RETRY);
   }
 
   set_as_default_in_progress_ = true;
-  bool interactive_permitted = true;
   if (observer_) {

[grt (UTC plus 2), 2016/02/02 17:28:22]

nit: omit braces

[Patrick Monette, 2016/02/02 22:24:15]

Done.

     observer_->SetDefaultWebClientUIState(STATE_PROCESSING);
-    interactive_permitted = observer_->IsInteractiveSetDefaultPermitted();
   }
 
   set_as_default_initialized_ = InitializeSetAsDefault();
 
   // Remember the start time.
   start_time_ = base::TimeTicks::Now();
 
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-                          base::Bind(&DefaultWebClientWorker::SetAsDefault,
-                                     this, interactive_permitted));
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&DefaultWebClientWorker::SetAsDefault, this));
 }
 
 void ShellIntegration::DefaultWebClientWorker::ObserverDestroyed() {
   // Our associated view has gone away, so we shouldn't call back to it if
   // our worker thread returns after the view is dead.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observer_ = nullptr;
 
   if (set_as_default_initialized_) {
     FinalizeSetAsDefault();
@@ skipping 17 matching lines @@
   if (check_default_should_report_success_) {
     check_default_should_report_success_ = false;
 
     ReportAttemptResult(state == DefaultWebClientState::IS_DEFAULT
                             ? AttemptResult::SUCCESS
                             : AttemptResult::NO_ERRORS_NOT_DEFAULT);
   }
 
   // The worker has finished everything it needs to do, so free the observer
   // if we own it.
-  if (observer_ && observer_->IsOwnedByWorker()) {
+  if (observer_ && delete_observer_) {
     delete observer_;
     observer_ = nullptr;
   }
 }
 
 void ShellIntegration::DefaultWebClientWorker::OnSetAsDefaultAttemptComplete(
     AttemptResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Hold on to a reference because if this was called via the default browser
   // callback in StartupBrowserCreator, clearing the callback in
@@ skipping 109 matching lines @@
   }
   NOTREACHED();
   return "";
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ShellIntegration::DefaultBrowserWorker
 //
 
 ShellIntegration::DefaultBrowserWorker::DefaultBrowserWorker(
-    DefaultWebClientObserver* observer)
-    : DefaultWebClientWorker(observer) {
+    DefaultWebClientObserver* observer,
+    bool delete_observer,
+    bool interactive_permitted)
+    : DefaultWebClientWorker(observer, delete_observer, interactive_permitted) {
 }
 
 ShellIntegration::DefaultBrowserWorker::~DefaultBrowserWorker() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultBrowserWorker, private:
 
 void ShellIntegration::DefaultBrowserWorker::CheckIsDefault() {
   DefaultWebClientState state = GetDefaultBrowser();
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DefaultBrowserWorker::OnCheckIsDefaultComplete, this, state));
 }
 
-void ShellIntegration::DefaultBrowserWorker::SetAsDefault(
-    bool interactive_permitted) {
+void ShellIntegration::DefaultBrowserWorker::SetAsDefault() {
   AttemptResult result = AttemptResult::FAILURE;
   switch (CanSetAsDefaultBrowser()) {
     case SET_DEFAULT_NOT_ALLOWED:
       NOTREACHED();
       break;
     case SET_DEFAULT_UNATTENDED:
       if (SetAsDefaultBrowser())
         result = AttemptResult::SUCCESS;
       break;
     case SET_DEFAULT_INTERACTIVE:
-      if (interactive_permitted && SetAsDefaultBrowserInteractive())
+      if (interactive_permitted_ && SetAsDefaultBrowserInteractive())
         result = AttemptResult::SUCCESS;
       break;
     case SET_DEFAULT_ASYNCHRONOUS:
 #if defined(OS_WIN)
-      if (!interactive_permitted)
+      if (!interactive_permitted_)
         break;
       if (GetDefaultBrowser() == IS_DEFAULT) {
         // Don't start the asynchronous operation since it could result in
         // losing the default browser status.
         result = AttemptResult::ALREADY_DEFAULT;
         break;
       }
       // This function will cause OnSetAsDefaultAttemptComplete() to be called
       // asynchronously via a filter established in InitializeSetAsDefault().
       if (!SetAsDefaultBrowserAsynchronous()) {
@@ skipping 14 matching lines @@
 
 const char* ShellIntegration::DefaultBrowserWorker::GetHistogramPrefix() {
   return "DefaultBrowser";
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ShellIntegration::DefaultProtocolClientWorker
 //
 
 ShellIntegration::DefaultProtocolClientWorker::DefaultProtocolClientWorker(
-    DefaultWebClientObserver* observer, const std::string& protocol)
-    : DefaultWebClientWorker(observer),
-      protocol_(protocol) {
-}
+    DefaultWebClientObserver* observer,
+    const std::string& protocol,
+    bool delete_observer,
+    bool interactive_permitted)
+    : DefaultWebClientWorker(observer, delete_observer, interactive_permitted),
+      protocol_(protocol) {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultProtocolClientWorker, private:
 
 ShellIntegration::DefaultProtocolClientWorker::~DefaultProtocolClientWorker() {}
 
 void ShellIntegration::DefaultProtocolClientWorker::CheckIsDefault() {
   DefaultWebClientState state = IsDefaultProtocolClient(protocol_);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DefaultProtocolClientWorker::OnCheckIsDefaultComplete, this,
                  state));
 }
 
-void ShellIntegration::DefaultProtocolClientWorker::SetAsDefault(
-    bool interactive_permitted) {
+void ShellIntegration::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;
       break;
     case SET_DEFAULT_INTERACTIVE:
-      if (interactive_permitted &&
+      if (interactive_permitted_ &&
           SetAsDefaultProtocolClientInteractive(protocol_)) {
         result = AttemptResult::SUCCESS;
       }
       break;
     case SET_DEFAULT_ASYNCHRONOUS:
       NOTREACHED();
       break;
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DefaultProtocolClientWorker::OnSetAsDefaultAttemptComplete,
                  this, result));
 }
 
 const char*
 ShellIntegration::DefaultProtocolClientWorker::GetHistogramPrefix() {
   return "DefaultProtocolClient";
 }