No longer relaunch into metro mode by default on touch devices.

chrome/browser/ui/webui/set_as_default_browser_ui.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/ui/webui/set_as_default_browser_ui.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
-#include "base/win/win_util.h"
-#include "chrome/browser/first_run/first_run.h"
-#include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/singleton_tabs.h"
@@ skipping 18 matching lines @@
 #include "ui/web_dialogs/web_dialog_delegate.h"
 
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 namespace {
 
 const char kSetAsDefaultBrowserHistogram[] = "DefaultBrowser.InteractionResult";
 
-// The enum permits registering in UMA the three possible outcomes.
+// The enum permits registering in UMA the three possible outcomes (do not
+// reorder these).
 // ACCEPTED: user pressed Next and made Chrome default.
 // DECLINED: user simply closed the dialog without making Chrome default.
 // REGRETTED: user pressed Next but then elected a different default browser.
-// ACCEPTED_IMMERSE: as above with a switch to metro mode.
 enum MakeChromeDefaultResult {
-  MAKE_CHROME_DEFAULT_ACCEPTED,
-  MAKE_CHROME_DEFAULT_DECLINED,
-  MAKE_CHROME_DEFAULT_REGRETTED,
-  MAKE_CHROME_DEFAULT_ACCEPTED_IMMERSE,
+  MAKE_CHROME_DEFAULT_ACCEPTED = 0,
+  MAKE_CHROME_DEFAULT_DECLINED = 1,
+  MAKE_CHROME_DEFAULT_REGRETTED = 2,
+  // MAKE_CHROME_DEFAULT_ACCEPTED_IMMERSE = 3,  // Deprecated.
   MAKE_CHROME_DEFAULT_MAX
 };
 
 content::WebUIDataSource* CreateSetAsDefaultBrowserUIHTMLSource() {
   content::WebUIDataSource* data_source = content::WebUIDataSource::Create(
       chrome::kChromeUIMetroFlowHost);
   data_source->AddLocalizedString("page-title", IDS_METRO_FLOW_TAB_TITLE);
   data_source->AddLocalizedString("flowTitle", IDS_METRO_FLOW_TITLE_SHORT);
   data_source->AddLocalizedString("flowDescription",
                                   IDS_METRO_FLOW_DESCRIPTION);
@@ skipping 39 matching lines @@
   virtual void OnSetAsDefaultConcluded(bool close_chrome)  OVERRIDE;
   virtual bool IsInteractiveSetDefaultPermitted() OVERRIDE;
 
  private:
   // Handler for the 'Next' (or 'make Chrome the Metro browser') button.
   void HandleLaunchSetDefaultBrowserFlow(const base::ListValue* args);
 
   // Close this web ui.
   void ConcludeInteraction(MakeChromeDefaultResult interaction_result);
 
-  // Returns true if Chrome should be restarted in immersive mode upon being
-  // made the default browser.
-  bool ShouldAttemptImmersiveRestart();
-
   scoped_refptr<ShellIntegration::DefaultBrowserWorker> default_browser_worker_;
   bool set_default_returned_;
   bool set_default_result_;
   base::WeakPtr<ResponseDelegate> response_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(SetAsDefaultBrowserHandler);
 };
 
 SetAsDefaultBrowserHandler::SetAsDefaultBrowserHandler(
     const base::WeakPtr<ResponseDelegate>& response_delegate)
@@ skipping 19 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!set_default_returned_)
     return;
 
   if (state == ShellIntegration::STATE_NOT_DEFAULT && set_default_result_) {
     // The operation concluded, but Chrome is still not the default.
     // If the call has succeeded, this suggests user has decided not to make
     // chrome the default.
     ConcludeInteraction(MAKE_CHROME_DEFAULT_REGRETTED);
   } else if (state == ShellIntegration::STATE_IS_DEFAULT) {
-    ConcludeInteraction(ShouldAttemptImmersiveRestart() ?
-        MAKE_CHROME_DEFAULT_ACCEPTED_IMMERSE : MAKE_CHROME_DEFAULT_ACCEPTED);
+    ConcludeInteraction(MAKE_CHROME_DEFAULT_ACCEPTED);
   }
 
   // Otherwise, keep the dialog open since the user probably didn't make a
   // choice.
 }
 
 void SetAsDefaultBrowserHandler::OnSetAsDefaultConcluded(bool call_result) {
   set_default_returned_ = true;
   set_default_result_ = call_result;
 }
@@ skipping 18 matching lines @@
 
   WebContents* contents = web_ui()->GetWebContents();
 
   if (contents) {
     content::WebContentsDelegate* delegate = contents->GetDelegate();
     if (delegate)
       delegate->CloseContents(contents);
   }
 }
 
-bool SetAsDefaultBrowserHandler::ShouldAttemptImmersiveRestart() {
-  return (base::win::IsTouchEnabledDevice() &&
-          !Profile::FromWebUI(web_ui())->GetPrefs()->GetBoolean(
-              prefs::kSuppressSwitchToMetroModeOnSetDefault));
-}
-
 // A web dialog delegate implementation for when 'Make Chrome Metro' UI
 // is displayed on a dialog.
 class SetAsDefaultBrowserDialogImpl : public ui::WebDialogDelegate,
                                       public ResponseDelegate,
                                       public chrome::BrowserListObserver {
  public:
   SetAsDefaultBrowserDialogImpl(Profile* profile, Browser* browser);
   virtual ~SetAsDefaultBrowserDialogImpl();
   // Show a modal web dialog with kChromeUIMetroFlowURL page.
   void ShowDialog();
@@ skipping 14 matching lines @@
   virtual bool HandleContextMenu(
       const content::ContextMenuParams& params) OVERRIDE;
 
   // Overridden from ResponseDelegate:
   virtual void SetDialogInteractionResult(MakeChromeDefaultResult result);
 
   // Overridden from BrowserListObserver:
   virtual void OnBrowserRemoved(Browser* browser) OVERRIDE;
 
  private:
-  // Reset the first-run sentinel file, so must be called on the FILE thread.
-  // This is needed if the browser should be restarted in immersive mode.
-  // The method is static because the dialog could be destroyed
-  // before the task arrives on the FILE thread.
-  static void AttemptImmersiveFirstRunRestartOnFileThread();
-
   Profile* profile_;
   Browser* browser_;
   mutable bool owns_handler_;
   base::WeakPtrFactory<ResponseDelegate> response_delegate_ptr_factory_;
   SetAsDefaultBrowserHandler* handler_;
   MakeChromeDefaultResult dialog_interaction_result_;
 
   DISALLOW_COPY_AND_ASSIGN(SetAsDefaultBrowserDialogImpl);
 };
 
@@ skipping 60 matching lines @@
   return "[]";
 }
 
 void SetAsDefaultBrowserDialogImpl::OnDialogClosed(
     const std::string& json_retval) {
   // Register the user's response in UMA.
   UMA_HISTOGRAM_ENUMERATION(kSetAsDefaultBrowserHistogram,
                             dialog_interaction_result_,
                             MAKE_CHROME_DEFAULT_MAX);
 
-  if (dialog_interaction_result_ == MAKE_CHROME_DEFAULT_ACCEPTED_IMMERSE) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&SetAsDefaultBrowserDialogImpl::
-            AttemptImmersiveFirstRunRestartOnFileThread));
-  } else {
-    // If the user explicitly elected *not to* make Chrome default, we won't
-    // ask again.
-    if (dialog_interaction_result_ == MAKE_CHROME_DEFAULT_REGRETTED) {
-      PrefService* prefs = profile_->GetPrefs();
-      prefs->SetBoolean(prefs::kCheckDefaultBrowser, false);
-    }
+  // If the user explicitly elected *not to* make Chrome default, we won't
+  // ask again.
+  if (dialog_interaction_result_ == MAKE_CHROME_DEFAULT_REGRETTED) {
+    PrefService* prefs = profile_->GetPrefs();
+    prefs->SetBoolean(prefs::kCheckDefaultBrowser, false);
+  }
 
-    // Carry on with a normal chrome session. For the purpose of surfacing this
-    // dialog the actual browser window had to remain hidden. Now it's time to
-    // show it.
-    if (browser_) {
-      BrowserWindow* window = browser_->window();
-      WebContents* contents =
-          browser_->tab_strip_model()->GetActiveWebContents();
-      window->Show();
-      if (contents)
-        contents->SetInitialFocus();
-    }
+  // Carry on with a normal chrome session. For the purpose of surfacing this
+  // dialog the actual browser window had to remain hidden. Now it's time to
+  // show it.
+  if (browser_) {
+    BrowserWindow* window = browser_->window();
+    WebContents* contents = browser_->tab_strip_model()->GetActiveWebContents();
+    window->Show();
+    if (contents)
+      contents->SetInitialFocus();
   }
 
   delete this;
 }
 
 void SetAsDefaultBrowserDialogImpl::OnCloseContents(WebContents* source,
                                                     bool* out_close_dialog) {
   *out_close_dialog = true;
 }
 
@@ skipping 11 matching lines @@
   dialog_interaction_result_ = result;
 }
 
 void SetAsDefaultBrowserDialogImpl::OnBrowserRemoved(Browser* browser) {
   if (browser_ == browser) {
     browser_ = NULL;
     BrowserList::RemoveObserver(this);
   }
 }
 
-void SetAsDefaultBrowserDialogImpl::
-    AttemptImmersiveFirstRunRestartOnFileThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-
-  // If the sentinel was created for this launch, remove it before restarting
-  // in immersive mode so that the user is taken through the full first-run
-  // flow there.
-  if (first_run::IsChromeFirstRun())
-    first_run::RemoveSentinel();
-
-  // Do a straight-up restart rather than a mode-switch restart.
-  // delegate_execute.exe will choose an immersive launch on the basis of the
-  // same IsTouchEnabledDevice check, but will not store this as the user's
-  // choice.
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(&chrome::AttemptRestart));
-}
-
 }  // namespace
 
 SetAsDefaultBrowserUI::SetAsDefaultBrowserUI(content::WebUI* web_ui)
     : ui::WebDialogUI(web_ui) {
   content::WebUIDataSource::Add(
       Profile::FromWebUI(web_ui), CreateSetAsDefaultBrowserUIHTMLSource());
 }
 
 // static
 void SetAsDefaultBrowserUI::Show(Profile* profile, Browser* browser) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SetAsDefaultBrowserDialogImpl* dialog =
       new SetAsDefaultBrowserDialogImpl(profile, browser);
   dialog->ShowDialog();
 }