// Copyright 2017 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_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_CONTROLLER_IMPL_WIN_H_
#define CHROME_BROWSER_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_CONTROLLER_IMPL_WIN_H_

#include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_win.h"

#include <memory>
#include <set>
#include <vector>

#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/threading/thread_checker.h"
#include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_runner_win.h"
#include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_scanner_results_win.h"
#include "components/component_updater/component_updater_service.h"

namespace safe_browsing {

// Delegate class that provides services to the ChromeCleanerController class
// and can be overridden by tests via
// SetChromeCleanerControllerDelegateForTesting().
class ChromeCleanerControllerDelegate {
 public:
  using FetchedCallback = base::OnceCallback<void(base::FilePath)>;

  ChromeCleanerControllerDelegate();
  virtual ~ChromeCleanerControllerDelegate();

  // Fetches and verifies the Chrome Cleaner binary and passes the name of the
  // executable to |fetched_callback|. The file name will have the ".exe"
  // extension. If the operation fails, the file name passed to
  // |fetched_callback| will be empty.
  virtual void FetchAndVerifyChromeCleaner(FetchedCallback fetched_callback);
  virtual bool IsMetricsAndCrashReportingEnabled();

  // Auxiliary methods for tagging and resetting open profiles.
  virtual void TagForResetting(Profile* profile);
  virtual void ResetTaggedProfiles(std::vector<Profile*> profiles,
                                   base::OnceClosure continuation);

  // Starts the reboot prompt flow if a cleanup requires a machine restart.
  virtual void StartRebootPromptFlow(ChromeCleanerController* controller);
};

class ChromeCleanerControllerImpl : public ChromeCleanerController {
 public:
  // Returns the global controller object.
  static ChromeCleanerControllerImpl* GetInstance();

  // ChromeCleanerController overrides.
  State state() const override;
  IdleReason idle_reason() const override;
  void SetLogsEnabled(Profile* profile, bool logs_enabled) override;
  bool logs_enabled(Profile* profile) const override;
  void ResetIdleState() override;
  void AddObserver(Observer* observer) override;
  void RemoveObserver(Observer* observer) override;
  void OnReporterSequenceStarted() override;
  void OnReporterSequenceDone(SwReporterInvocationResult result) override;
  void RequestUserInitiatedScan(Profile* profile) override;
  void OnSwReporterReady(SwReporterInvocationSequence&& invocations) override;
  void Scan(const SwReporterInvocation& reporter_invocation) override;
  void ReplyWithUserResponse(Profile* profile,
                             extensions::ExtensionService* extension_service,
                             UserResponse user_response) override;
  void Reboot() override;
  bool IsAllowedByPolicy() override;
  bool IsReportingManagedByPolicy(Profile* profile) override;

  static void ResetInstanceForTesting();
  // Passing in a nullptr as |delegate| resets the delegate to a default
  // production version.
  void SetDelegateForTesting(ChromeCleanerControllerDelegate* delegate);

  // Force the current controller's state for tests that check the effect of
  // starting and completing reporter runs.
  void SetStateForTesting(State state);

 private:
  ChromeCleanerControllerImpl();
  ~ChromeCleanerControllerImpl() override;

  void NotifyObserver(Observer* observer) const;
  void SetStateAndNotifyObservers(State state);
  // Used to invalidate weak pointers and reset accumulated data that is no
  // longer needed when entering the kIdle or kRebootRequired states.
  void ResetCleanerDataAndInvalidateWeakPtrs();

  // Callback that is called when the Chrome Cleaner binary has been fetched and
  // verified. An empty |executable_path| signals failure. A non-empty
  // |executable_path| must have the '.exe' file extension.
  void OnChromeCleanerFetchedAndVerified(base::FilePath executable_path);

  // Callback that checks if the weak pointer |controller| is still valid, and
  // if so will call OnPromptuser(). If |controller| is no longer valid, will
  // immediately send a Mojo response denying the cleanup operation.
  //
  // The other Mojo callbacks below do not need corresponding "weak" callbacks,
  // because for those cases nothing needs to be done if the weak pointer
  // referencing the controller instance is no longer valid (Chrome's Callback
  // objects become no-ops if the bound weak pointer is not valid).
  static void WeakOnPromptUser(
      const base::WeakPtr<ChromeCleanerControllerImpl>& controller,
      ChromeCleanerScannerResults&& reported_results,
      chrome_cleaner::mojom::ChromePrompt::PromptUserCallback
          prompt_user_callback);

  void OnPromptUser(ChromeCleanerScannerResults&& reported_results,
                    chrome_cleaner::mojom::ChromePrompt::PromptUserCallback
                        prompt_user_callback);
  void OnConnectionClosed();
  void OnCleanerProcessDone(ChromeCleanerRunner::ProcessStatus process_status);
  void InitiateReboot();

  std::unique_ptr<ChromeCleanerControllerDelegate> real_delegate_;
  // Pointer to either real_delegate_ or one set by tests.
  ChromeCleanerControllerDelegate* delegate_;

  extensions::ExtensionService* extension_service_;

  State state_ = State::kIdle;
  // Whether Cleanup is powered by an external partner.
  bool powered_by_partner_ = false;
  IdleReason idle_reason_ = IdleReason::kInitial;
  std::unique_ptr<SwReporterInvocation> reporter_invocation_;
  ChromeCleanerScannerResults scanner_results_;
  // The Mojo callback that should be called to send a response to the Chrome
  // Cleaner process. This must be posted to run on the IO thread.
  chrome_cleaner::mojom::ChromePrompt::PromptUserCallback prompt_user_callback_;

  // For metrics reporting.
  base::Time time_scanning_started_;
  base::Time time_cleanup_started_;

  base::ObserverList<Observer>::Unchecked observer_list_;

  // Mutex that guards |pending_invocation_type_|,
  // |on_demand_sw_reporter_fetcher_| and |cached_reporter_invocations_|.
  mutable base::Lock lock_;
  SwReporterInvocationType pending_invocation_type_ =
      SwReporterInvocationType::kPeriodicRun;
  std::unique_ptr<component_updater::SwReporterOnDemandFetcher>
      on_demand_sw_reporter_fetcher_;
  // Note: SwReporterInvocationSequence is mutable and should not be used more
  // than once. Special care must be taken that the invocations are not sent
  // to a |ReporterRunner| more than once.
  std::unique_ptr<SwReporterInvocationSequence> cached_reporter_invocations_;

  THREAD_CHECKER(thread_checker_);

  base::WeakPtrFactory<ChromeCleanerControllerImpl> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(ChromeCleanerControllerImpl);
};

}  // namespace safe_browsing

#endif  // CHROME_BROWSER_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_CONTROLLER_IMPL_WIN_H_