// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/downgrade/user_data_downgrade.h"

#include <memory>
#include <string>
#include <string_view>

#include "base/files/file_util.h"
#include "base/path_service.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/mock_callback.h"
#include "base/test/test_reg_util_win.h"
#include "base/threading/thread_restrictions.h"
#include "base/version.h"
#include "base/win/registry.h"
#include "chrome/browser/chrome_browser_main.h"
#include "chrome/browser/chrome_browser_main_extra_parts.h"
#include "chrome/browser/first_run/scoped_relaunch_chrome_browser_override.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_result_codes.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/install_static/install_util.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "components/version_info/version_info.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/test/browser_test.h"
#include "content/public/test/test_utils.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace downgrade {

// A basic test fixture for User Data downgrade tests that writes a test file
// and a "Last Version" file into User Data in the pre-relaunch case. The former
// is used to validate move-and-delete processing on downgrade, while the latter
// is to simulate a previous run of a higher version of the browser. The fixture
// is expected to be used in a PRE_ and a regular test, with IsPreTest used to
// distinguish these cases at runtime.
class UserDataDowngradeBrowserTestBase : public InProcessBrowserTest {
 public:
  UserDataDowngradeBrowserTestBase(const UserDataDowngradeBrowserTestBase&) =
      delete;
  UserDataDowngradeBrowserTestBase& operator=(
      const UserDataDowngradeBrowserTestBase&) = delete;

 protected:
  // Returns true if the PRE_ test is running, meaning that the test is in the
  // "before relaunch" stage.
  static bool IsPreTest() {
    const std::string_view test_name(
        ::testing::UnitTest::GetInstance()->current_test_info()->name());
    return test_name.find("PRE_") != std::string_view::npos;
  }

  // Returns the next Chrome milestone version.
  static std::string GetNextChromeVersion() {
    return base::NumberToString(version_info::GetVersion().components()[0] + 1);
  }

  UserDataDowngradeBrowserTestBase()
      : root_key_(install_static::IsSystemInstall() ? HKEY_LOCAL_MACHINE
                                                    : HKEY_CURRENT_USER) {}

  // Returns the registry hive into which the browser is registered.
  HKEY root_key() const { return root_key_; }

  // Returns the path to the User Data dir.
  const base::FilePath& user_data_dir() const { return user_data_dir_; }

  // Returns the destination path to which User Data may be or was moved.
  const base::FilePath& moved_user_data_dir() const {
    return moved_user_data_dir_;
  }

  // Returns the path to some generated file in User Data.
  const base::FilePath& other_file() const { return other_file_; }

  // InProcessBrowserTest:
  void SetUp() override {
    ASSERT_NO_FATAL_FAILURE(
        registry_override_manager_.OverrideRegistry(root_key_));
    ASSERT_TRUE(base::win::RegKey(
                    root_key_, install_static::GetClientStateKeyPath().c_str(),
                    KEY_SET_VALUE | KEY_WOW64_32KEY)
                    .Valid());
    InProcessBrowserTest::SetUp();
  }

  bool SetUpUserDataDirectory() override {
    if (!base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir_))
      return false;
    other_file_ = user_data_dir_.Append(FILE_PATH_LITERAL("Other File"));
    moved_user_data_dir_ = user_data_dir_.Append(user_data_dir_.BaseName())
                               .AddExtension(kDowngradeDeleteSuffix);
    if (IsPreTest()) {
      // Create some "other file" to be convinced that stuff is moved.
      if (!base::WriteFile(other_file_, "data"))
        return false;
      // Pretend that a higher version of Chrome previously wrote User Data.
      const std::string last_version = GetNextChromeVersion();
      base::WriteFile(user_data_dir_.Append(kDowngradeLastVersionFile),
                      last_version);
    }
    return true;
  }

 private:
  // The registry hive into which the browser is/will be registered.
  const HKEY root_key_;

  // The location of User Data.
  base::FilePath user_data_dir_;

  // The location into which the contents of User Data may be moved in case of
  // downgrade.
  base::FilePath moved_user_data_dir_;

  // The path to an arbitrary file in the user data dir that will be present
  // only when a reset does not take place.
  base::FilePath other_file_;

  registry_util::RegistryOverrideManager registry_override_manager_;
};

// A gMock matcher that is satisfied when its argument is a command line
// containing a given switch.
MATCHER_P(HasSwitch, switch_name, "") {
  return arg.HasSwitch(switch_name);
}

// A test fixture that triggers a downgrade, expects a relaunch, and verifies
// that User Data was moved and then subsequently deleted.
class UserDataDowngradeBrowserCopyAndCleanTest
    : public UserDataDowngradeBrowserTestBase {
 public:
  UserDataDowngradeBrowserCopyAndCleanTest(
      const UserDataDowngradeBrowserCopyAndCleanTest&) = delete;
  UserDataDowngradeBrowserCopyAndCleanTest& operator=(
      const UserDataDowngradeBrowserCopyAndCleanTest&) = delete;

 protected:
  using ParentClass = UserDataDowngradeBrowserTestBase;

  UserDataDowngradeBrowserCopyAndCleanTest() = default;

  // InProcessBrowserTest:
  void SetUpInProcessBrowserTestFixture() override {
    if (ParentClass::IsPreTest()) {
      // Pretend that a downgrade was performed via the installer.
      ASSERT_NO_FATAL_FAILURE(SetDowngradeVersion(GetNextChromeVersion()));

      // Expect a browser relaunch late in browser shutdown.
      mock_relaunch_callback_ = std::make_unique<::testing::StrictMock<
          base::MockCallback<upgrade_util::RelaunchChromeBrowserCallback>>>();
      EXPECT_CALL(*mock_relaunch_callback_,
                  Run(HasSwitch(switches::kUserDataMigrated)));
      relaunch_chrome_override_ =
          std::make_unique<upgrade_util::ScopedRelaunchChromeBrowserOverride>(
              mock_relaunch_callback_->Get());

      // Expect that browser startup short-circuits into a relaunch.
      set_expected_exit_code(CHROME_RESULT_CODE_DOWNGRADE_AND_RELAUNCH);

      // Prepare to check histograms during the restart.
      histogram_tester_ = std::make_unique<base::HistogramTester>();
    } else {
      // Verify the contents of the renamed user data directory.
      ASSERT_TRUE(base::DirectoryExists(moved_user_data_dir()));
      EXPECT_TRUE(base::PathExists(
          moved_user_data_dir().Append(other_file().BaseName())));
      EXPECT_EQ(GetNextChromeVersion(),
                GetLastVersion(moved_user_data_dir())->GetString());
    }
  }

  void CreatedBrowserMainParts(content::BrowserMainParts* parts) override {
    ParentClass::CreatedBrowserMainParts(parts);
    if (!ParentClass::IsPreTest()) {
      // Ensure that the after-startup task to delete User Data has a chance to
      // run.
      static_cast<ChromeBrowserMainParts*>(parts)->AddParts(
          std::make_unique<
              RunAllPendingTasksPostMainMessageLoopRunExtraParts>());
    }
  }

  void SetUpOnMainThread() override {
    // This is never reached in the pre test due to the relaunch.
    ASSERT_FALSE(ParentClass::IsPreTest());
    ParentClass::SetUpOnMainThread();
  }

  void TearDownInProcessBrowserTestFixture() override {
    if (!ParentClass::IsPreTest()) {
      // Verify the renamed user data directory has been deleted.
      EXPECT_FALSE(base::DirectoryExists(moved_user_data_dir()));
    }
  }

 private:
  // DeleteMovedUserDataSoon() is called after the test is run, and will post a
  // task to perform the actual deletion. Make sure this task gets a chance to
  // run, so that the check in TearDownInProcessBrowserTestFixture() works.
  class RunAllPendingTasksPostMainMessageLoopRunExtraParts
      : public ChromeBrowserMainExtraParts {
   public:
    void PostMainMessageLoopRun() override { content::RunAllTasksUntilIdle(); }
  };

  // Writes |downgrade_version| into the DowngradeVersion value in ClientState
  // so that the browser believes that a downgrade was driven by an
  // administrator rather than an accident of fate.
  void SetDowngradeVersion(std::string_view downgrade_version) {
    ASSERT_EQ(base::win::RegKey(root_key(),
                                install_static::GetClientStateKeyPath().c_str(),
                                KEY_SET_VALUE | KEY_WOW64_32KEY)
                  .WriteValue(L"DowngradeVersion",
                              base::ASCIIToWide(downgrade_version).c_str()),
              ERROR_SUCCESS);
  }

  std::unique_ptr<
      base::MockCallback<upgrade_util::RelaunchChromeBrowserCallback>>
      mock_relaunch_callback_;
  std::unique_ptr<upgrade_util::ScopedRelaunchChromeBrowserOverride>
      relaunch_chrome_override_;
  std::unique_ptr<base::HistogramTester> histogram_tester_;
};

// Verify the user data directory has been renamed and created again after
// downgrade.
IN_PROC_BROWSER_TEST_F(UserDataDowngradeBrowserCopyAndCleanTest, PRE_Test) {}

IN_PROC_BROWSER_TEST_F(UserDataDowngradeBrowserCopyAndCleanTest, Test) {
  base::ScopedAllowBlockingForTesting allow_blocking;
  base::ThreadPoolInstance::Get()->FlushForTesting();
  EXPECT_EQ(chrome::kChromeVersion,
            GetLastVersion(user_data_dir())->GetString());
  EXPECT_FALSE(base::PathExists(other_file()));
}

// A test fixture that launches the browser twice for a non-administrator
// driven downgrade and ensures that User Data is not moved aside and deleted.
class UserDataDowngradeBrowserNoResetTest
    : public UserDataDowngradeBrowserTestBase {
 public:
  UserDataDowngradeBrowserNoResetTest(
      const UserDataDowngradeBrowserNoResetTest&) = delete;
  UserDataDowngradeBrowserNoResetTest& operator=(
      const UserDataDowngradeBrowserNoResetTest&) = delete;

 protected:
  UserDataDowngradeBrowserNoResetTest() = default;
};

// Verify the user data directory will not be reset without downgrade.
IN_PROC_BROWSER_TEST_F(UserDataDowngradeBrowserNoResetTest, PRE_Test) {}

// TODO(crbug.com/40925550): Re-enable this test
IN_PROC_BROWSER_TEST_F(UserDataDowngradeBrowserNoResetTest, DISABLED_Test) {
  base::ScopedAllowBlockingForTesting allow_blocking;
  EXPECT_EQ(chrome::kChromeVersion,
            GetLastVersion(user_data_dir())->GetString());
  EXPECT_TRUE(base::PathExists(other_file()));
}

}  // namespace downgrade