[BrowserSwitcher] Add BrowserSwitcherPrefs class

This class can listen for prefs changes, and pre-compute/convert types
for the BrowserSwitcher prefs. It also checks whether the prefs are
managed or not, and offers getters to conveniently access the prefs.

Change-Id: I64a218f10e30193b8a322c49f1ae08feaf80a128
Reviewed-on: https://chromium-review.googlesource.com/c/1393450
Commit-Queue: Nicolas Ouellet-Payeur <nicolaso@chromium.org>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Reviewed-by: Julian Pastarmov <pastarmovj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#619993}

chrome/browser/browser_switcher/alternative_browser_driver.h

@@ -26,6 +26,8 @@ class AlternativeBrowserDriver {
  public:
   virtual ~AlternativeBrowserDriver();
 
+  // TODO(nicolaso): Remove SetBrowserPath() and SetBrowserParameters().
+
   // Updates the executable path that will be used for the browser when it is
   // launched. |path| is not necessarily a valid file path. It may be a
   // placeholder such as "${ie}".
@@ -35,13 +37,26 @@ class AlternativeBrowserDriver {
   // launched.
   virtual void SetBrowserParameters(const base::ListValue* parameters) = 0;
 
+  // Expands environment variables and possibly tildes (~) in the given
+  // string. On Windows, this should expand %VAR% to the var's value. On POSIX
+  // systems, this should expand $VAR and ${VAR}, and expand ~ to the home
+  // directory.
+  //
+  // "${url}" is special and is left as is in the string.
+  virtual void ExpandEnvVars(std::string* str) const = 0;
+
+  // If the string is a preset browser placeholder (e.g. ${ie}, ${firefox}),
+  // expands it to an executable path. The list of preset browsers is
+  // platform-specific.
+  virtual void ExpandPresetBrowsers(std::string* str) const = 0;
+
   // Tries to launch |browser| at the specified URL, using whatever
   // method is most appropriate.
   virtual bool TryLaunch(const GURL& url) = 0;
 };
 
-// Default concrete implementation for |AlternativeBrowserDriver|. This uses
-// Windows primitives to access
+// Default concrete implementation for |AlternativeBrowserDriver|. Uses a
+// platform-specific method to locate and launch the appropriate browser.
 class AlternativeBrowserDriverImpl : public AlternativeBrowserDriver {
  public:
   AlternativeBrowserDriverImpl();
@@ -50,6 +65,8 @@ class AlternativeBrowserDriverImpl : public AlternativeBrowserDriver {
   // AlternativeBrowserDriver
   void SetBrowserPath(base::StringPiece path) override;
   void SetBrowserParameters(const base::ListValue* parameters) override;
+  void ExpandEnvVars(std::string* str) const override;
+  void ExpandPresetBrowsers(std::string* str) const override;
   bool TryLaunch(const GURL& url) override;
 
   // Create the CommandLine object that would be used to launch an external

chrome/browser/browser_switcher/alternative_browser_driver_posix.cc

@@ -131,18 +131,7 @@ AlternativeBrowserDriverImpl::~AlternativeBrowserDriverImpl() {}
 
 void AlternativeBrowserDriverImpl::SetBrowserPath(base::StringPiece path) {
   browser_path_ = path.as_string();
-#if defined(OS_MACOSX)
-  // Unlike most POSIX platforms, MacOS always has another browser than Chrome,
-  // so admins don't have to explicitly configure one.
-  if (browser_path_.empty()) {
-    browser_path_ = kSafariExecutableName;
-  }
-#endif
-  for (const auto& mapping : kBrowserVarMappings) {
-    if (!browser_path_.compare(mapping.var_name)) {
-      browser_path_ = mapping.executable_name;
-    }
-  }
+  ExpandPresetBrowsers(&browser_path_);
 }
 
 void AlternativeBrowserDriverImpl::SetBrowserParameters(
@@ -155,6 +144,29 @@ void AlternativeBrowserDriverImpl::SetBrowserParameters(
   }
 }
 
+void AlternativeBrowserDriverImpl::ExpandPresetBrowsers(
+    std::string* str) const {
+#if defined(OS_MACOSX)
+  // Unlike most POSIX platforms, MacOS always has another browser than Chrome,
+  // so admins don't have to explicitly configure one.
+  if (str->empty()) {
+    *str = kSafariExecutableName;
+    return;
+  }
+#endif
+  for (const auto& mapping : kBrowserVarMappings) {
+    if (!str->compare(mapping.var_name)) {
+      *str = mapping.executable_name;
+      return;
+    }
+  }
+}
+
+void AlternativeBrowserDriverImpl::ExpandEnvVars(std::string* str) const {
+  ExpandTilde(str);
+  ExpandEnvironmentVariables(str);
+}
+
 bool AlternativeBrowserDriverImpl::TryLaunch(const GURL& url) {
   if (browser_path_.empty()) {
     LOG(ERROR) << "Alternative browser not configured. "

chrome/browser/browser_switcher/alternative_browser_driver_win.cc

@@ -171,6 +171,27 @@ bool AlternativeBrowserDriverImpl::TryLaunch(const GURL& url) {
   return (TryLaunchWithDde(url) || TryLaunchWithExec(url));
 }
 
+void AlternativeBrowserDriverImpl::ExpandEnvVars(std::string* str) const {
+  std::wstring wide = base::UTF8ToWide(*str);
+  ExpandEnvironmentVariables(&wide);
+  *str = base::WideToUTF8(wide);
+}
+
+void AlternativeBrowserDriverImpl::ExpandPresetBrowsers(
+    std::string* str) const {
+  if (str->empty()) {
+    *str = base::WideToUTF8(GetBrowserLocation(kIExploreKey));
+    return;
+  }
+  std::wstring wide = base::UTF8ToWide(*str);
+  for (const auto& mapping : kBrowserVarMappings) {
+    if (!wide.compare(mapping.var_name)) {
+      *str = base::WideToUTF8(GetBrowserLocation(mapping.registry_key));
+      return;
+    }
+  }
+}
+
 bool AlternativeBrowserDriverImpl::TryLaunchWithDde(const GURL& url) {
   if (dde_host_.empty())
     return false;

chrome/browser/browser_switcher/alternative_browser_launcher_unittest.cc

@@ -6,6 +6,7 @@
 
 #include "base/values.h"
 #include "chrome/browser/browser_switcher/browser_switcher_prefs.h"
+#include "chrome/browser/browser_switcher/mock_alternative_browser_driver.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/prefs/testing_pref_service.h"
@@ -23,15 +24,6 @@ namespace {
 
 const char kExampleDotCom[] = "http://example.com/";
 
-class MockAlternativeBrowserDriver : public AlternativeBrowserDriver {
- public:
-  MockAlternativeBrowserDriver() = default;
-  ~MockAlternativeBrowserDriver() override = default;
-
-  MOCK_METHOD1(SetBrowserPath, void(base::StringPiece));
-  MOCK_METHOD1(SetBrowserParameters, void(const base::ListValue*));
-  MOCK_METHOD1(TryLaunch, bool(const GURL&));
-};
 
 }  // namespace
 
@@ -40,7 +32,8 @@ class AlternativeBrowserLauncherTest : public testing::Test {
   void SetUp() override {
     prefs_.registry()->RegisterStringPref(prefs::kAlternativeBrowserPath, "");
     prefs_.registry()->RegisterListPref(prefs::kAlternativeBrowserParameters);
-    driver_ = new MockAlternativeBrowserDriver();
+    auto driver = std::make_unique<MockAlternativeBrowserDriver>();
+    driver_ = driver.get();
     EXPECT_CALL(*driver_, SetBrowserPath(_))
         .WillOnce(Invoke([](base::StringPiece path) { EXPECT_EQ("", path); }));
     EXPECT_CALL(*driver_, SetBrowserParameters(_))
@@ -48,7 +41,7 @@ class AlternativeBrowserLauncherTest : public testing::Test {
           EXPECT_TRUE(parameters->GetList().empty());
         }));
     launcher_ = std::make_unique<AlternativeBrowserLauncherImpl>(
-        &prefs_, std::unique_ptr<AlternativeBrowserDriver>(driver_));
+        &prefs_, std::move(driver));
   }
 
   TestingPrefServiceSimple* prefs() { return &prefs_; }

chrome/browser/browser_switcher/browser_switcher_prefs.cc

@@ -4,10 +4,157 @@
 
 #include "chrome/browser/browser_switcher/browser_switcher_prefs.h"
 
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/metrics/histogram_macros.h"
 #include "build/build_config.h"
+#include "chrome/browser/browser_switcher/alternative_browser_driver.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "components/prefs/pref_service.h"
 
 namespace browser_switcher {
+
+RuleSet::RuleSet() = default;
+RuleSet::~RuleSet() = default;
+
+BrowserSwitcherPrefs::BrowserSwitcherPrefs(PrefService* prefs,
+                                           AlternativeBrowserDriver* driver)
+    : prefs_(prefs), driver_(driver) {
+  DCHECK(prefs_);
+
+  change_registrar_.Init(prefs_);
+
+  const struct {
+    const char* pref_name;
+    void (BrowserSwitcherPrefs::*callback)();
+  } hooks[] = {
+      {prefs::kAlternativeBrowserPath,
+       &BrowserSwitcherPrefs::AlternativeBrowserPathChanged},
+      {prefs::kAlternativeBrowserParameters,
+       &BrowserSwitcherPrefs::AlternativeBrowserParametersChanged},
+      {prefs::kUrlList, &BrowserSwitcherPrefs::UrlListChanged},
+      {prefs::kUrlGreylist, &BrowserSwitcherPrefs::GreylistChanged},
+  };
+
+  // Listen for pref changes, and run all the hooks once to initialize state.
+  for (const auto& hook : hooks) {
+    change_registrar_.Add(
+        hook.pref_name,
+        base::BindRepeating(hook.callback, base::Unretained(this)));
+    (*this.*hook.callback)();
+  }
+}
+
+BrowserSwitcherPrefs::~BrowserSwitcherPrefs() = default;
+
+// static
+void BrowserSwitcherPrefs::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterStringPref(prefs::kAlternativeBrowserPath, "");
+  registry->RegisterListPref(prefs::kAlternativeBrowserParameters);
+  registry->RegisterListPref(prefs::kUrlList);
+  registry->RegisterListPref(prefs::kUrlGreylist);
+  registry->RegisterStringPref(prefs::kExternalSitelistUrl, "");
+#if defined(OS_WIN)
+  registry->RegisterBooleanPref(prefs::kUseIeSitelist, false);
+#endif
+}
+
+const std::string& BrowserSwitcherPrefs::GetAlternativeBrowserPath() {
+  return alt_browser_path_;
+}
+
+std::string BrowserSwitcherPrefs::GetAlternativeBrowserPathRaw() {
+  if (!prefs_->IsManagedPreference(prefs::kAlternativeBrowserPath))
+    return std::string();
+  return prefs_->GetString(prefs::kAlternativeBrowserPath);
+}
+
+const std::vector<std::string>&
+BrowserSwitcherPrefs::GetAlternativeBrowserParameters() {
+  return alt_browser_params_;
+}
+
+const RuleSet& BrowserSwitcherPrefs::GetRules() {
+  return rules_;
+}
+
+GURL BrowserSwitcherPrefs::GetExternalSitelistUrl() {
+  if (!prefs_->IsManagedPreference(prefs::kExternalSitelistUrl))
+    return GURL();
+  return GURL(prefs_->GetString(prefs::kExternalSitelistUrl));
+}
+
+#if defined(OS_WIN)
+bool BrowserSwitcherPrefs::UseIeSitelist() {
+  if (!prefs_->IsManagedPreference(prefs::kUseIeSitelist))
+    return false;
+  return prefs_->GetBoolean(prefs::kUseIeSitelist);
+}
+#endif
+
+void BrowserSwitcherPrefs::AlternativeBrowserPathChanged() {
+  alt_browser_path_.clear();
+  if (prefs_->IsManagedPreference(prefs::kAlternativeBrowserPath))
+    alt_browser_path_ = prefs_->GetString(prefs::kAlternativeBrowserPath);
+  driver_->ExpandPresetBrowsers(&alt_browser_path_);
+  driver_->ExpandEnvVars(&alt_browser_path_);
+}
+
+void BrowserSwitcherPrefs::AlternativeBrowserParametersChanged() {
+  alt_browser_params_.clear();
+  if (!prefs_->IsManagedPreference(prefs::kAlternativeBrowserParameters))
+    return;
+  const base::ListValue* params =
+      prefs_->GetList(prefs::kAlternativeBrowserParameters);
+  for (const auto& param : *params) {
+    std::string param_string = param.GetString();
+    driver_->ExpandEnvVars(&param_string);
+    alt_browser_params_.push_back(param_string);
+  }
+}
+
+void BrowserSwitcherPrefs::UrlListChanged() {
+  rules_.sitelist.clear();
+
+  if (!prefs_->IsManagedPreference(prefs::kUrlList))
+    return;
+
+  UMA_HISTOGRAM_COUNTS_100000(
+      "BrowserSwitcher.UrlListSize",
+      prefs_->GetList(prefs::kUrlList)->GetList().size());
+
+  bool has_wildcard = false;
+  for (const auto& url : *prefs_->GetList(prefs::kUrlList)) {
+    rules_.sitelist.push_back(url.GetString());
+    if (url.GetString() == "*")
+      has_wildcard = true;
+  }
+
+  UMA_HISTOGRAM_BOOLEAN("BrowserSwitcher.UrlListWildcard", has_wildcard);
+}
+
+void BrowserSwitcherPrefs::GreylistChanged() {
+  rules_.greylist.clear();
+
+  // This pref is sensitive. Only set through policies.
+  if (!prefs_->IsManagedPreference(prefs::kUrlGreylist))
+    return;
+
+  UMA_HISTOGRAM_COUNTS_100000(
+      "BrowserSwitcher.GreylistSize",
+      prefs_->GetList(prefs::kUrlGreylist)->GetList().size());
+
+  bool has_wildcard = false;
+  for (const auto& url : *prefs_->GetList(prefs::kUrlGreylist)) {
+    rules_.greylist.push_back(url.GetString());
+    if (url.GetString() == "*")
+      has_wildcard = true;
+  }
+
+  UMA_HISTOGRAM_BOOLEAN("BrowserSwitcher.UrlListWildcard", has_wildcard);
+}
+
 namespace prefs {
 
 // Path to the executable of the alternative browser, or one of "${chrome}",
@@ -35,14 +182,6 @@ const char kUseIeSitelist[] = "browser_switcher.use_ie_sitelist";
 #endif
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
-  registry->RegisterStringPref(prefs::kAlternativeBrowserPath, "");
-  registry->RegisterListPref(prefs::kAlternativeBrowserParameters);
-  registry->RegisterListPref(prefs::kUrlList);
-  registry->RegisterListPref(prefs::kUrlGreylist);
-  registry->RegisterStringPref(prefs::kExternalSitelistUrl, "");
-#if defined(OS_WIN)
-  registry->RegisterBooleanPref(prefs::kUseIeSitelist, false);
-#endif
 }
 
 }  // namespace prefs

chrome/browser/browser_switcher/browser_switcher_prefs.h

@@ -5,13 +5,93 @@
 #ifndef CHROME_BROWSER_BROWSER_SWITCHER_BROWSER_SWITCHER_PREFS_H_
 #define CHROME_BROWSER_BROWSER_SWITCHER_BROWSER_SWITCHER_PREFS_H_
 
+#include "base/macros.h"
 #include "build/build_config.h"
+#include "components/prefs/pref_change_registrar.h"
+#include "url/gurl.h"
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }  // namespace user_prefs
 
+class PrefService;
+
 namespace browser_switcher {
+
+class AlternativeBrowserDriver;
+
+// A named pair type.
+struct RuleSet {
+  RuleSet();
+  ~RuleSet();
+
+  std::vector<std::string> sitelist;
+  std::vector<std::string> greylist;
+};
+
+// Contains the current state of the prefs related to LBS. For sensitive prefs,
+// only respects managed prefs. Also does some type conversions and
+// transformations on the prefs (e.g. expanding preset values for
+// AlternativeBrowserPath).
+class BrowserSwitcherPrefs {
+ public:
+  BrowserSwitcherPrefs(PrefService* prefs, AlternativeBrowserDriver* driver);
+  virtual ~BrowserSwitcherPrefs();
+
+  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+
+  // Returns the path to the alternative browser to launch, after substitutions
+  // (preset browsers, environment variables, tildes). If the pref is not
+  // managed, returns the empty string.
+  const std::string& GetAlternativeBrowserPath();
+
+  // Same as above, but returns the value before substitutions. Still checks
+  // that the pref is managed.
+  std::string GetAlternativeBrowserPathRaw();
+
+  // Returns the arguments to pass to the alternative browser, after
+  // substitutions (environment variables, tildes). If the pref is not managed,
+  // returns the empty string.
+  const std::vector<std::string>& GetAlternativeBrowserParameters();
+
+  // Returns the sitelist + greylist configured directly through Chrome
+  // policies. If the pref is not managed, returns an empty vector.
+  const RuleSet& GetRules();
+
+  // Returns the URL to download for an external XML sitelist. If the pref is
+  // not managed, returns an invalid URL.
+  GURL GetExternalSitelistUrl();
+
+#if defined(OS_WIN)
+  // Returns true if Chrome should download and apply the XML sitelist from
+  // IEEM's SiteList policy. If the pref is not managed, returns false.
+  bool UseIeSitelist();
+#endif
+
+ private:
+  // Hooks for PrefChangeRegistrar.
+  void AlternativeBrowserPathChanged();
+  void AlternativeBrowserParametersChanged();
+  void UrlListChanged();
+  void GreylistChanged();
+
+  PrefService* prefs_;
+  PrefChangeRegistrar change_registrar_;
+
+  // Used to expand environment variables and platform-specific presets
+  // (e.g. ${ie}) in AlternativeBrowserPath.
+  AlternativeBrowserDriver* driver_;
+
+  // Type-converted and/or expanded pref values, updated by the
+  // PrefChangeRegistrar hooks.
+  std::string alt_browser_path_;
+  std::vector<std::string> alt_browser_params_;
+
+  RuleSet rules_;
+
+  DISALLOW_COPY_AND_ASSIGN(BrowserSwitcherPrefs);
+};
+
 namespace prefs {
 
 extern const char kAlternativeBrowserPath[];
@@ -24,9 +104,8 @@ extern const char kExternalSitelistUrl[];
 extern const char kUseIeSitelist[];
 #endif
 
-void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
-
 }  // namespace prefs
+
 }  // namespace browser_switcher
 
 #endif  // CHROME_BROWSER_BROWSER_SWITCHER_BROWSER_SWITCHER_PREFS_H_

chrome/browser/browser_switcher/browser_switcher_prefs_unittest.cc

+// Copyright 2018 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/browser_switcher/browser_switcher_sitelist.h"
+
+#include "base/values.h"
+#include "chrome/browser/browser_switcher/browser_switcher_prefs.h"
+#include "chrome/browser/browser_switcher/ieem_sitelist_parser.h"
+#include "chrome/browser/browser_switcher/mock_alternative_browser_driver.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/testing_pref_service.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+using testing::_;
+using testing::Invoke;
+
+namespace browser_switcher {
+
+namespace {
+
+std::unique_ptr<base::Value> StringArrayToValue(
+    const std::vector<const char*>& strings) {
+  std::vector<base::Value> values(strings.size());
+  std::transform(strings.begin(), strings.end(), values.begin(),
+                 [](const char* s) { return base::Value(s); });
+  return std::make_unique<base::Value>(values);
+}
+
+void SetStringToItWorked(std::string* str) {
+  *str = "it worked";
+}
+
+}  // namespace
+
+class BrowserSwitcherPrefsTest : public testing::Test {
+ public:
+  void SetUp() override {
+    BrowserSwitcherPrefs::RegisterProfilePrefs(prefs_backend_.registry());
+    prefs_ = std::make_unique<BrowserSwitcherPrefs>(&prefs_backend_, &driver_);
+  }
+
+  sync_preferences::TestingPrefServiceSyncable* prefs_backend() {
+    return &prefs_backend_;
+  }
+  MockAlternativeBrowserDriver& driver() { return driver_; }
+  BrowserSwitcherPrefs* prefs() { return prefs_.get(); }
+
+ private:
+  sync_preferences::TestingPrefServiceSyncable prefs_backend_;
+  MockAlternativeBrowserDriver driver_;
+  std::unique_ptr<BrowserSwitcherPrefs> prefs_;
+};
+
+TEST_F(BrowserSwitcherPrefsTest, ListensForPrefChanges) {
+  prefs_backend()->SetManagedPref(prefs::kAlternativeBrowserPath,
+                                  std::make_unique<base::Value>("notepad.exe"));
+  prefs_backend()->SetManagedPref(prefs::kAlternativeBrowserParameters,
+                                  StringArrayToValue({"a", "b", "c"}));
+  prefs_backend()->SetManagedPref(prefs::kUrlList,
+                                  StringArrayToValue({"example.com"}));
+  prefs_backend()->SetManagedPref(prefs::kUrlGreylist,
+                                  StringArrayToValue({"foo.example.com"}));
+
+  EXPECT_EQ("notepad.exe", prefs()->GetAlternativeBrowserPath());
+
+  EXPECT_EQ(3u, prefs()->GetAlternativeBrowserParameters().size());
+  EXPECT_EQ("a", prefs()->GetAlternativeBrowserParameters()[0]);
+  EXPECT_EQ("b", prefs()->GetAlternativeBrowserParameters()[1]);
+  EXPECT_EQ("c", prefs()->GetAlternativeBrowserParameters()[2]);
+
+  EXPECT_EQ(1u, prefs()->GetRules().sitelist.size());
+  EXPECT_EQ("example.com", prefs()->GetRules().sitelist[0]);
+
+  EXPECT_EQ(1u, prefs()->GetRules().greylist.size());
+  EXPECT_EQ("foo.example.com", prefs()->GetRules().greylist[0]);
+}
+
+TEST_F(BrowserSwitcherPrefsTest, ExpandsEnvironmentVariablesInPath) {
+  EXPECT_CALL(driver(), ExpandEnvVars(_))
+      .WillOnce(Invoke(&SetStringToItWorked));
+  prefs_backend()->SetManagedPref(
+      prefs::kAlternativeBrowserPath,
+      std::make_unique<base::Value>("it didn't work"));
+  EXPECT_EQ("it worked", prefs()->GetAlternativeBrowserPath());
+}
+
+TEST_F(BrowserSwitcherPrefsTest, ExpandsPresetBrowsersInPath) {
+  EXPECT_CALL(driver(), ExpandPresetBrowsers(_))
+      .WillOnce(Invoke(&SetStringToItWorked));
+  prefs_backend()->SetManagedPref(
+      prefs::kAlternativeBrowserPath,
+      std::make_unique<base::Value>("it didn't work"));
+  EXPECT_EQ("it worked", prefs()->GetAlternativeBrowserPath());
+}
+
+TEST_F(BrowserSwitcherPrefsTest, ExpandsEnvironmentVariablesInParameters) {
+  EXPECT_CALL(driver(), ExpandEnvVars(_))
+      .WillOnce(Invoke(&SetStringToItWorked));
+  prefs_backend()->SetManagedPref(prefs::kAlternativeBrowserParameters,
+                                  StringArrayToValue({"it didn't work"}));
+  EXPECT_EQ(1u, prefs()->GetAlternativeBrowserParameters().size());
+  EXPECT_EQ("it worked", prefs()->GetAlternativeBrowserParameters()[0]);
+}
+
+}  // namespace browser_switcher

chrome/browser/browser_switcher/browser_switcher_sitelist.cc

@@ -95,9 +95,6 @@ bool StringSizeCompare(const base::StringPiece& a, const base::StringPiece& b) {
 
 }  // namespace
 
-BrowserSwitcherSitelistImpl::RuleSet::RuleSet() = default;
-BrowserSwitcherSitelistImpl::RuleSet::~RuleSet() = default;
-
 BrowserSwitcherSitelist::~BrowserSwitcherSitelist() = default;
 
 BrowserSwitcherSitelistImpl::BrowserSwitcherSitelistImpl(PrefService* prefs)

chrome/browser/browser_switcher/browser_switcher_sitelist.h

@@ -6,6 +6,7 @@
 #define CHROME_BROWSER_BROWSER_SWITCHER_BROWSER_SWITCHER_SITELIST_H_
 
 #include "base/macros.h"
+#include "chrome/browser/browser_switcher/browser_switcher_prefs.h"
 #include "components/prefs/pref_change_registrar.h"
 
 class PrefService;
@@ -57,14 +58,6 @@ class BrowserSwitcherSitelistImpl : public BrowserSwitcherSitelist {
 
   bool ShouldSwitchImpl(const GURL& url) const;
 
-  struct RuleSet {
-    RuleSet();
-    ~RuleSet();
-
-    std::vector<std::string> sitelist;
-    std::vector<std::string> greylist;
-  };
-
   RuleSet chrome_policies_;
   RuleSet ieem_sitelist_;
   RuleSet external_sitelist_;

chrome/browser/browser_switcher/mock_alternative_browser_driver.cc

+// Copyright 2018 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/browser_switcher/mock_alternative_browser_driver.h"
+
+namespace browser_switcher {
+
+MockAlternativeBrowserDriver::MockAlternativeBrowserDriver() = default;
+
+MockAlternativeBrowserDriver::~MockAlternativeBrowserDriver() = default;
+
+}  // namespace browser_switcher

chrome/browser/browser_switcher/mock_alternative_browser_driver.h

+// Copyright 2018 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.
+
+#ifndef CHROME_BROWSER_BROWSER_SWITCHER_MOCK_ALTERNATIVE_BROWSER_DRIVER_H_
+#define CHROME_BROWSER_BROWSER_SWITCHER_MOCK_ALTERNATIVE_BROWSER_DRIVER_H_
+
+#include "chrome/browser/browser_switcher/alternative_browser_driver.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "url/gurl.h"
+
+namespace browser_switcher {
+
+class MockAlternativeBrowserDriver : public AlternativeBrowserDriver {
+ public:
+  MockAlternativeBrowserDriver();
+  ~MockAlternativeBrowserDriver() override;
+
+  MOCK_METHOD1(SetBrowserPath, void(base::StringPiece));
+  MOCK_METHOD1(SetBrowserParameters, void(const base::ListValue*));
+  MOCK_CONST_METHOD1(ExpandEnvVars, void(std::string*));
+  MOCK_CONST_METHOD1(ExpandPresetBrowsers, void(std::string*));
+  MOCK_METHOD1(TryLaunch, bool(const GURL&));
+};
+
+}  // namespace browser_switcher
+
+#endif  // CHROME_BROWSER_BROWSER_SWITCHER_MOCK_ALTERNATIVE_BROWSER_DRIVER_H_

chrome/browser/prefs/browser_prefs.cc

@@ -757,7 +757,7 @@ void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || \
     (defined(OS_LINUX) && !defined(OS_CHROMEOS))
-  browser_switcher::prefs::RegisterProfilePrefs(registry);
+  browser_switcher::BrowserSwitcherPrefs::RegisterProfilePrefs(registry);
 #endif
 
 #if defined(TOOLKIT_VIEWS)

chrome/test/BUILD.gn

@@ -4483,7 +4483,10 @@ test("unit_tests") {
       "../browser/browser_switcher/alternative_browser_driver_unittest.cc",
       "../browser/browser_switcher/alternative_browser_launcher_unittest.cc",
       "../browser/browser_switcher/browser_switcher_navigation_throttle_unittest.cc",
+      "../browser/browser_switcher/browser_switcher_prefs_unittest.cc",
       "../browser/browser_switcher/browser_switcher_sitelist_unittest.cc",
+      "../browser/browser_switcher/mock_alternative_browser_driver.cc",
+      "../browser/browser_switcher/mock_alternative_browser_driver.h",
       "../browser/password_manager/password_store_signin_notifier_impl_unittest.cc",
     ]
   }