Don't use pref for IsTorDisabled()

To check whether tor is enabled or not, tor component registration is
used instead of pref value because user can change pref via settings.
With this, we don't need to another prefs to check user changed or not.

browser/brave_browser_process_impl.cc

@@ -57,7 +57,6 @@
 
 #if BUILDFLAG(ENABLE_TOR)
 #include "brave/browser/extensions/brave_tor_client_updater.h"
-#include "brave/browser/tor/tor_profile_service.h"
 #endif
 
 #if defined(OS_ANDROID)
@@ -101,10 +100,6 @@ BraveBrowserProcessImpl::BraveBrowserProcessImpl(StartupData* startup_data)
   brave_p3a_service();
   brave::SetupHistogramsBraveization();
 #endif  // BUILDFLAG(BRAVE_P3A_ENABLED)
-
-#if BUILDFLAG(ENABLE_TOR)
-  tor::TorProfileService::InitializeTorPrefs();
-#endif
 }
 
 brave_component_updater::BraveComponent::Delegate*

browser/brave_local_state_browsertest.cc

@@ -18,31 +18,31 @@ IN_PROC_BROWSER_TEST_F(BraveLocalStateBrowserTest, BasicTest) {
 #if BUILDFLAG(ENABLE_TOR)
     // Tor is enabled by default.
   EXPECT_FALSE(tor::TorProfileService::IsTorDisabled());
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabledAtNextLaunching());
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabledChanged());
 #endif
 }
 
 #if BUILDFLAG(ENABLE_TOR)
 IN_PROC_BROWSER_TEST_F(BraveLocalStateBrowserTest, PRE_TorDisabledTest) {
+  EXPECT_EQ(tor::TorProfileService::IsTorDisabled(),
+            tor::TorProfileService::GetTorDisabledPref());
+
   // Set to same value(enable) to next launching prefs, doesn't affect anything.
-  tor::TorProfileService::SetTorDisabledAtNextLaunching(false);
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabled());
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabledAtNextLaunching());
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabledChanged());
+  tor::TorProfileService::SetTorDisabledPref(false);
+  EXPECT_EQ(tor::TorProfileService::IsTorDisabled(),
+            tor::TorProfileService::GetTorDisabledPref());
 
   // Check setting to disable to next launching prefs doesn't affect
   // IsTorDisabled().
-  tor::TorProfileService::SetTorDisabledAtNextLaunching(true);
+  tor::TorProfileService::SetTorDisabledPref(true);
   EXPECT_FALSE(tor::TorProfileService::IsTorDisabled());
-  EXPECT_TRUE(tor::TorProfileService::IsTorDisabledAtNextLaunching());
-  EXPECT_TRUE(tor::TorProfileService::IsTorDisabledChanged());
+  EXPECT_NE(tor::TorProfileService::IsTorDisabled(),
+            tor::TorProfileService::GetTorDisabledPref());
 }
 
 IN_PROC_BROWSER_TEST_F(BraveLocalStateBrowserTest, TorDisabledTest) {
   // Check IsTorDisabled() is changed from previous test run.
   EXPECT_TRUE(tor::TorProfileService::IsTorDisabled());
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabledAtNextLaunching());
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabledChanged());
+  EXPECT_EQ(tor::TorProfileService::IsTorDisabled(),
+            tor::TorProfileService::GetTorDisabledPref());
 }
 #endif

browser/extensions/brave_tor_client_updater.cc

@@ -123,7 +123,7 @@ BraveTorClientUpdater::~BraveTorClientUpdater() {
 void BraveTorClientUpdater::Register() {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
-  if (tor::TorProfileService::IsTorDisabled() ||
+  if (tor::TorProfileService::GetTorDisabledPref() ||
       command_line.HasSwitch(switches::kDisableTorClientUpdaterExtension) ||
       registered_) {
     return;

browser/extensions/brave_tor_client_updater.h

@@ -61,6 +61,8 @@ class BraveTorClientUpdater : public BraveComponent {
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
+  bool registered() const { return registered_; }
+
  protected:
   void OnComponentReady(const std::string& component_id,
       const base::FilePath& install_dir,

browser/policy/brave_policy_browsertest.cc

@@ -62,7 +62,8 @@ class TorDisabledPolicyBrowserTest : public BravePolicyTest {
 IN_PROC_BROWSER_TEST_F(TorDisabledPolicyBrowserTest, TorDisabledPrefValueTest) {
   // When policy is set, explicit setting doesn't change its pref value.
   g_browser_process->local_state()->SetBoolean(tor::prefs::kTorDisabled, false);
-  EXPECT_TRUE(tor::TorProfileService::IsTorDisabled());
+  EXPECT_TRUE(
+      g_browser_process->local_state()->GetBoolean(tor::prefs::kTorDisabled));
 }
 
 class TorEnabledPolicyBrowserTest : public BravePolicyTest {
@@ -84,17 +85,8 @@ class TorEnabledPolicyBrowserTest : public BravePolicyTest {
 IN_PROC_BROWSER_TEST_F(TorEnabledPolicyBrowserTest, TorDisabledPrefValueTest) {
   // When policy is set, explicit setting doesn't change its pref value.
   g_browser_process->local_state()->SetBoolean(tor::prefs::kTorDisabled, true);
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabled());
-}
-
-// W/o TorDisabled group policy, kTorDisabled pref value should be false.
-IN_PROC_BROWSER_TEST_F(NoTorPolicyBrowserTest,
-                       DefaultTorDisabledPrefValueTest) {
-  EXPECT_FALSE(tor::TorProfileService::IsTorDisabled());
-
-  // If policy is not set, explicit setting change its pref value.
-  g_browser_process->local_state()->SetBoolean(tor::prefs::kTorDisabled, true);
-  EXPECT_TRUE(tor::TorProfileService::IsTorDisabled());
+  EXPECT_FALSE(
+      g_browser_process->local_state()->GetBoolean(tor::prefs::kTorDisabled));
 }
 #endif  // OS_WIN
 #endif  // ENABLE_TOR

browser/resources/settings/brave_default_extensions_page/brave_default_extensions_page.js

@@ -43,7 +43,7 @@ Polymer({
     this.addWebUIListener('brave-needs-restart-changed', (needsRestart) => {
       this.showRestartToast_ = needsRestart
     })
-    this.addWebUIListener('tor-enabled-changed', (enabled) => {
+    this.addWebUIListener('tor-enabled-pref-changed', (enabled) => {
       this.torEnabled_ = enabled
     })
 

browser/tor/tor_profile_service.cc

@@ -56,55 +56,33 @@ void TorProfileService::RegisterLocalStatePrefs(PrefRegistrySimple* registry) {
   const std::string tor_proxy_uri =
       std::string(kTorProxyScheme) + std::string(kTorProxyAddress) + ":" + port;
   registry->RegisterStringPref(prefs::kTorProxyString, tor_proxy_uri);
-  // kTorDisabled is managed prefs.
-  // User can only change it via settiongs option if it's not managed.
+  // This pref value and current tor enabled state might be different because
+  // user can change pref value. But, this pref changes doesn't affect current
+  // tor enabled state. Instead, this pref value uses whether tor component is
+  // registered or not at startup. Tor component is only registered if this has
+  // false.
+  // kTorDisabled could be managed. User can only change it via settings if it's
+  // not managed. For now, only Windows support tor group policy.
   registry->RegisterBooleanPref(prefs::kTorDisabled, false);
-  // kTorDisabledAtNextLaunching has the value that user changed via settings.
-  // If this value is changed, it is exposed to settings page. At the next
-  // launching, this value is copied to kTorDisabled.
-  registry->RegisterBooleanPref(prefs::kTorDisabledAtNextLaunching, false);
 }
 
 // static
-void TorProfileService::InitializeTorPrefs() {
-  auto* state = g_browser_process->local_state();
-  if (state->FindPreference(
-          prefs::kTorDisabledAtNextLaunching)->IsDefaultValue()) {
-    return;
+bool TorProfileService::IsTorDisabled() {
+  // In test, |g_brave_browser_process| could be null.
+  if (!g_brave_browser_process) {
+    return false;
   }
-
-  state->SetBoolean(prefs::kTorDisabled,
-                    state->GetBoolean(prefs::kTorDisabledAtNextLaunching));
-  state->ClearPref(prefs::kTorDisabledAtNextLaunching);
+  return !g_brave_browser_process->tor_client_updater()->registered();
 }
 
 // static
-bool TorProfileService::IsTorDisabled() {
+bool TorProfileService::GetTorDisabledPref() {
   return g_browser_process->local_state()->GetBoolean(prefs::kTorDisabled);
 }
 
 // static
-bool TorProfileService::IsTorDisabledAtNextLaunching() {
-  return g_browser_process->local_state()->GetBoolean(
-      prefs::kTorDisabledAtNextLaunching);
-}
-
-// static
-bool TorProfileService::IsTorDisabledChanged() {
-  auto* state = g_browser_process->local_state();
-  if (state->FindPreference(
-         prefs::kTorDisabledAtNextLaunching)->IsDefaultValue()) {
-    return false;
-  }
-
-  return state->GetBoolean(prefs::kTorDisabledAtNextLaunching) !=
-         state->GetBoolean(prefs::kTorDisabled);
-}
-
-// static
-void TorProfileService::SetTorDisabledAtNextLaunching(bool disabled) {
-  g_browser_process->local_state()->SetBoolean(
-      prefs::kTorDisabledAtNextLaunching, disabled);
+void TorProfileService::SetTorDisabledPref(bool disabled) {
+  g_browser_process->local_state()->SetBoolean(prefs::kTorDisabled, disabled);
 }
 
 std::string TorProfileService::GetTorProxyURI() {

browser/tor/tor_profile_service.h

@@ -28,6 +28,7 @@ class PrefRegistrySyncable;
 }
 
 class PrefRegistrySimple;
+class BraveAppMenuBrowserTestWithTorDisabled;
 
 namespace tor {
 
@@ -39,11 +40,9 @@ class TorProfileService : public KeyedService {
   ~TorProfileService() override;
 
   static void RegisterLocalStatePrefs(PrefRegistrySimple* registry);
-  static void SetTorDisabledAtNextLaunching(bool disabled);
+  static void SetTorDisabledPref(bool disabled);
+  static bool GetTorDisabledPref();
   static bool IsTorDisabled();
-  static bool IsTorDisabledAtNextLaunching();
-  static bool IsTorDisabledChanged();
-  static void InitializeTorPrefs();
 
   virtual void SetNewTorCircuit(content::WebContents* web_contents) = 0;
   virtual std::unique_ptr<net::ProxyConfigService>

browser/ui/toolbar/brave_app_menu_model_browsertest.cc

@@ -15,9 +15,7 @@
 #include "brave/components/brave_rewards/browser/buildflags/buildflags.h"
 #include "brave/components/brave_sync/buildflags/buildflags.h"
 #include "brave/components/brave_wallet/browser/buildflags/buildflags.h"
-#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_browser_main.h"
-#include "chrome/browser/chrome_browser_main_extra_parts.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_window.h"
@@ -29,6 +27,10 @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_utils.h"
 
+#if BUILDFLAG(ENABLE_TOR)
+#include "brave/browser/tor/tor_profile_service.h"
+#endif
+
 using BraveAppMenuBrowserTest = InProcessBrowserTest;
 
 IN_PROC_BROWSER_TEST_F(BraveAppMenuBrowserTest, BasicTest) {
@@ -135,32 +137,13 @@ IN_PROC_BROWSER_TEST_F(BraveAppMenuBrowserTest, BasicTest) {
 }
 
 #if BUILDFLAG(ENABLE_TOR)
-class ChromeBrowserMainExtraPartsTor : public ChromeBrowserMainExtraParts {
- public:
-  ChromeBrowserMainExtraPartsTor() = default;
-
-  // ChromeBrowserMainExtraParts:
-  void PostProfileInit() override {
-    g_browser_process->local_state()->SetBoolean(tor::prefs::kTorDisabled,
-                                                 true);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ChromeBrowserMainExtraPartsTor);
-};
-
-class BraveAppMenuBrowserTestWithTorDisabledPolicy
-    : public InProcessBrowserTest {
- public:
-  void CreatedBrowserMainParts(content::BrowserMainParts* parts) override {
-    static_cast<ChromeBrowserMainParts*>(parts)->AddParts(
-        new ChromeBrowserMainExtraPartsTor);
-  }
-};
+// Tor is enabled by default. Change pref to disable it at next test run.
+IN_PROC_BROWSER_TEST_F(BraveAppMenuBrowserTest, PRE_TorAppMenuTest) {
+  tor::TorProfileService::SetTorDisabledPref(true);
+}
 
 // If tor is disabled, corresponding menu and commands should be also disabled.
-IN_PROC_BROWSER_TEST_F(BraveAppMenuBrowserTestWithTorDisabledPolicy,
-                       TorDisabledTest) {
+IN_PROC_BROWSER_TEST_F(BraveAppMenuBrowserTest, TorAppMenuTest) {
   auto* browser_view = BrowserView::GetBrowserViewForBrowser(browser());
   BraveAppMenuModel normal_model(browser_view->toolbar(), browser());
   normal_model.Init();

browser/ui/webui/settings/brave_default_extensions_handler.cc

@@ -79,11 +79,11 @@ void BraveDefaultExtensionsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "setTorEnabled",
       base::BindRepeating(
-          &BraveDefaultExtensionsHandler::SetTorEnabledAtNextLaunching,
+          &BraveDefaultExtensionsHandler::SetTorEnabledPref,
           base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "getTorEnabled",
-      base::BindRepeating(&BraveDefaultExtensionsHandler::IsTorEnabled,
+      base::BindRepeating(&BraveDefaultExtensionsHandler::GetTorEnabledPref,
                           base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "isTorManaged",
@@ -109,8 +109,8 @@ void BraveDefaultExtensionsHandler::InitializePrefCallbacks() {
 #if BUILDFLAG(ENABLE_TOR)
   local_state_change_registrar_.Init(g_brave_browser_process->local_state());
   local_state_change_registrar_.Add(
-      tor::prefs::kTorDisabledAtNextLaunching,
-      base::Bind(&BraveDefaultExtensionsHandler::OnTorEnabledChanged,
+      tor::prefs::kTorDisabled,
+      base::Bind(&BraveDefaultExtensionsHandler::OnTorEnabledPrefChanged,
                  base::Unretained(this)));
 #endif
 }
@@ -128,7 +128,8 @@ bool BraveDefaultExtensionsHandler::IsRestartNeeded() {
     return true;
 
 #if BUILDFLAG(ENABLE_TOR)
-  if (tor::TorProfileService::IsTorDisabledChanged())
+  if (tor::TorProfileService::IsTorDisabled() !=
+      tor::TorProfileService::GetTorDisabledPref())
     return true;
 #endif
 
@@ -234,36 +235,31 @@ void BraveDefaultExtensionsHandler::SetMediaRouterEnabled(
 }
 
 #if BUILDFLAG(ENABLE_TOR)
-void BraveDefaultExtensionsHandler::SetTorEnabledAtNextLaunching(
+void BraveDefaultExtensionsHandler::SetTorEnabledPref(
     const base::ListValue* args) {
   CHECK_EQ(args->GetSize(), 1U);
   bool enabled;
   args->GetBoolean(0, &enabled);
-
   AllowJavascript();
-  tor::TorProfileService::SetTorDisabledAtNextLaunching(!enabled);
+  tor::TorProfileService::SetTorDisabledPref(!enabled);
 }
 
-void BraveDefaultExtensionsHandler::IsTorEnabled(
+void BraveDefaultExtensionsHandler::GetTorEnabledPref(
     const base::ListValue* args) {
   CHECK_EQ(args->GetSize(), 1U);
-  bool enabled = false;
-  if (tor::TorProfileService::IsTorDisabledChanged()) {
-    enabled = !tor::TorProfileService::IsTorDisabledAtNextLaunching();
-  } else {
-    enabled = !tor::TorProfileService::IsTorDisabled();
-  }
-
   AllowJavascript();
-  ResolveJavascriptCallback(args->GetList()[0], base::Value(enabled));
+  ResolveJavascriptCallback(
+      args->GetList()[0],
+      base::Value(!tor::TorProfileService::GetTorDisabledPref()));
 }
 
-void BraveDefaultExtensionsHandler::OnTorEnabledChanged() {
+void BraveDefaultExtensionsHandler::OnTorEnabledPrefChanged() {
   OnRestartNeededChanged();
 
   if (IsJavascriptAllowed()) {
-    FireWebUIListener("tor-enabled-changed",
-                      base::Value(!tor::TorProfileService::IsTorDisabled()));
+    FireWebUIListener(
+        "tor-enabled-pref-changed",
+        base::Value(!tor::TorProfileService::GetTorDisabledPref()));
   }
 }
 

browser/ui/webui/settings/brave_default_extensions_handler.h

@@ -35,9 +35,9 @@ class BraveDefaultExtensionsHandler : public settings::SettingsPageUIHandler {
   void SetMediaRouterEnabled(const base::ListValue* args);
   void SetBraveWalletEnabled(const base::ListValue* args);
 #if BUILDFLAG(ENABLE_TOR)
-  void SetTorEnabledAtNextLaunching(const base::ListValue* args);
-  void IsTorEnabled(const base::ListValue* args);
-  void OnTorEnabledChanged();
+  void SetTorEnabledPref(const base::ListValue* args);
+  void GetTorEnabledPref(const base::ListValue* args);
+  void OnTorEnabledPrefChanged();
   void IsTorManaged(const base::ListValue* args);
 #endif
 

common/tor/pref_names.cc

@@ -10,8 +10,6 @@ namespace prefs {
 
 const char kTorProxyString[] = "tor.tor_proxy_string";
 const char kTorDisabled[] = "tor.tor_disabled";
-const char kTorDisabledAtNextLaunching[] =
-    "tor.tor_disabled_at_next_launching";
 
 }  // namespace prefs
 }  // namespace tor

common/tor/pref_names.h

@@ -11,7 +11,6 @@ namespace prefs {
 
 extern const char kTorProxyString[];
 extern const char kTorDisabled[];
-extern const char kTorDisabledAtNextLaunching[];
 
 }  // namespace prefs
 }  // namespace tor