DefaultBrowserWorker now fully supports opening the settings for Win10

chrome/browser/shell_integration_win.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 <windows.h>
 #include <shlwapi.h>
 #include <shobjidl.h>
 #include <propkey.h>  // Needs to come after shobjidl.h.
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/timer/timer.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/shortcut.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/policy/policy_path_parser.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 174 matching lines @@
     case ShellUtil::NOT_DEFAULT:
       return DefaultWebClientState::NOT_DEFAULT;
     case ShellUtil::IS_DEFAULT:
       return DefaultWebClientState::IS_DEFAULT;
     default:
       DCHECK_EQ(ShellUtil::UNKNOWN_DEFAULT, default_state);
       return DefaultWebClientState::UNKNOWN_DEFAULT;
   }
 }
 
+bool IsSetAsDefaultUsingSystemSettings() {
+  return base::win::GetVersion() >= base::win::VERSION_WIN10;
+}
+
+// There is no way to make sure the user is done with the system settings, but a
+// signal that the interaction is finished is needed for UMA. A timer of 2
+// minutes is used as a substitute. The registry values for default browser is
+// also monitored (http and https association) to signal the end of the
+// interaction early when it is clear that the user made a choice.
+//
+// This helper class manages both the timer and the registry watchers and make

[grt (UTC plus 2), 2016/03/29 16:45:03]

nit: make -> makes

[Patrick Monette, 2016/03/29 17:43:08]

Done.

+// sure the callback for the end of the settings interaction is only run once.
+class OpenSystemSettingsHelper
+    : public base::RefCounted<OpenSystemSettingsHelper> {
+ public:
+  OpenSystemSettingsHelper() {}
+
+  // Initializes the timer and the registry watcher.
+  void Initialize(
+      base::Callback<void(bool)> conclude_settings_interaction_callback) {
+    const wchar_t url_association_format[] =
+        L"SOFTWARE\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\"
+        L"%ls\\UserChoice";
+    http_registry_key_ = CreateRegistryKeyWatcher(
+        base::StringPrintf(url_association_format, L"http").c_str(),
+        conclude_settings_interaction_callback);
+    https_registry_key_ = CreateRegistryKeyWatcher(
+        base::StringPrintf(url_association_format, L"https").c_str(),
+        conclude_settings_interaction_callback);
+
+    timer_.Start(FROM_HERE, base::TimeDelta::FromMinutes(2),
+                 base::Bind(conclude_settings_interaction_callback, false));
+  }
+
+  // Either the timer or the registry watcher signaled the end of the
+  // interaction. Make sure the other signal is ignored.
+  void Clear() {
+    run_once_ = false;
+    timer_.Reset();
+    http_registry_key_.reset();
+    https_registry_key_.reset();
+  }
+
+  void IncrementRegistryWatcherCount() { registry_watcher_count_++; }
+
+  const bool run_once() { return run_once_; }
+  const int get_registry_watcher_count() { return registry_watcher_count_; }
+
+ private:
+  scoped_ptr<base::win::RegKey> CreateRegistryKeyWatcher(
+      const wchar_t* registry_value,
+      base::Callback<void(bool)> conclude_settings_interaction_callback) {
+    scoped_ptr<base::win::RegKey> reg_key(
+        new base::win::RegKey(HKEY_CURRENT_USER, registry_value, KEY_READ));
+
+    if (reg_key && reg_key->Valid()) {

[grt (UTC plus 2), 2016/03/29 16:45:03]

no need to test reg_key alone since it will always be valid -- the process will
crash on out-of-memory.

[Patrick Monette, 2016/03/29 17:43:08]

Done.

+      reg_key->StartWatching(
+          base::Bind(conclude_settings_interaction_callback, true));
+    }
+    return reg_key;
+  }
+
+  base::OneShotTimer timer_;
+  scoped_ptr<base::win::RegKey> http_registry_key_;
+  scoped_ptr<base::win::RegKey> https_registry_key_;
+
+  // Used to make sure only one of the timer or the registry watcher's signal is
+  // taken in consideration.
+  bool run_once_ = true;
+
+  // The number of time a registry key watcher fired.
+  int registry_watcher_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(OpenSystemSettingsHelper);
+};
+
+void ConcludeOpenSystemSettingsToDefaultBrowser(

[grt (UTC plus 2), 2016/03/29 16:45:03]

this function is tightly coupled to the helper. can it be a private member
function of it?

[Patrick Monette, 2016/03/29 17:43:08]

Done.

+    scoped_refptr<OpenSystemSettingsHelper> helper,
+    base::Callback<void()> on_finished_callback,

[grt (UTC plus 2), 2016/03/29 16:45:03]

const base::Closure&

[Patrick Monette, 2016/03/29 17:43:08]

Done.

+    bool is_registry_watcher) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(helper);
+
+  // It is possible to get here if only one of the http/https url association
+  // was changed, which is not enough for GetDefaultBrowser() to return
+  // IS_DEFAULT.
+  if (is_registry_watcher) {
+    helper->IncrementRegistryWatcherCount();
+    if (helper->get_registry_watcher_count() != 2)
+      return;
+  }
+
+  if (!helper->run_once())
+    return;
+  helper->Clear();
+
+  on_finished_callback.Run();
+}
+
 }  // namespace
 
 bool SetAsDefaultBrowser() {
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     LOG(ERROR) << "Error getting app exe path";
     return false;
   }
 
   // From UI currently we only allow setting default browser for current user.
@@ skipping 18 matching lines @@
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (!ShellUtil::ShowMakeChromeDefaultSystemUI(dist, chrome_exe)) {
     LOG(ERROR) << "Failed to launch the set-default-browser Windows UI.";
     return false;
   }
 
   VLOG(1) << "Set-default-browser Windows UI completed.";
   return true;
 }
 
+void SetAsDefaultBrowserUsingSystemSettings(
+    base::Closure on_finished_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+
+  scoped_refptr<OpenSystemSettingsHelper> helper(new OpenSystemSettingsHelper);
+  helper->Initialize(base::Bind(&ConcludeOpenSystemSettingsToDefaultBrowser,
+                                helper, on_finished_callback));
+
+  base::FilePath chrome_exe;
+  if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
+    NOTREACHED() << "Error getting app exe path";
+    return;
+  }
+
+  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
+  ShellUtil::ShowMakeChromeDefaultSystemUI(dist, chrome_exe);
+}
+
 bool SetAsDefaultProtocolClient(const std::string& protocol) {
   if (protocol.empty())
     return false;
 
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     LOG(ERROR) << "Error getting app exe path";
     return false;
   }
 
@@ skipping 29 matching lines @@
   return true;
 }
 
 DefaultWebClientSetPermission CanSetAsDefaultBrowser() {
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
   if (distribution->GetDefaultBrowserControlPolicy() !=
           BrowserDistribution::DEFAULT_BROWSER_FULL_CONTROL)
     return SET_DEFAULT_NOT_ALLOWED;
   if (ShellUtil::CanMakeChromeDefaultUnattended())
     return SET_DEFAULT_UNATTENDED;
+  if (IsSetAsDefaultUsingSystemSettings())
+    return SET_DEFAULT_OPEN_SETTINGS;
   return SET_DEFAULT_INTERACTIVE;
 }
 
 bool IsElevationNeededForSettingDefaultProtocolClient() {
   return base::win::GetVersion() < base::win::VERSION_WIN8;
 }
 
 base::string16 GetApplicationNameForProtocol(const GURL& url) {
   // Windows 8 or above requires a new protocol association query.
   if (base::win::GetVersion() >= base::win::VERSION_WIN8)
@@ skipping 220 matching lines @@
 
     shortcut = programs_folder.Append(shortcut_name);
     if (base::PathExists(shortcut))
       return shortcut;
   }
 
   return base::FilePath();
 }
 
 }  // namespace shell_integration