1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122
  123


ash / display / privacy_screen_controller.h [blame]

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

#ifndef ASH_DISPLAY_PRIVACY_SCREEN_CONTROLLER_H_
#define ASH_DISPLAY_PRIVACY_SCREEN_CONTROLLER_H_

#include <memory>

#include "ash/ash_export.h"
#include "ash/public/cpp/privacy_screen_dlp_helper.h"
#include "ash/public/cpp/session/session_observer.h"
#include "base/memory/raw_ptr.h"
#include "base/observer_list.h"
#include "ui/display/manager/display_configurator.h"

class PrefRegistrySimple;
class PrefService;
class PrefChangeRegistrar;

namespace ash {

// Controls the privacy screen feature.
class ASH_EXPORT PrivacyScreenController
    : public PrivacyScreenDlpHelper,
      public SessionObserver,
      display::DisplayConfigurator::Observer {
 public:
  class Observer : public base::CheckedObserver {
   public:
    // Called when the privacy screen setting is changed.
    virtual void OnPrivacyScreenSettingChanged(bool enabled, bool notify_ui) {}

   protected:
    ~Observer() override = default;
  };

  PrivacyScreenController();
  ~PrivacyScreenController() override;

  PrivacyScreenController(const PrivacyScreenController&) = delete;
  PrivacyScreenController& operator=(const PrivacyScreenController&) = delete;

  static void RegisterProfilePrefs(PrefRegistrySimple* registry);

  // Whether or not the privacy screen feature is enforced by policy.
  bool IsManaged() const;
  // Get the PrivacyScreen settings stored in the current active user prefs.
  bool GetEnabled() const;
  // Set the desired PrivacyScreen settings in the current active user prefs.
  void SetEnabled(bool enabled);

  void AddObserver(Observer* observer);
  void RemoveObserver(Observer* observer);

  // PrivacyScreenDlpHelper:
  bool IsSupported() const override;
  void SetEnforced(bool enforced) override;

  // SessionObserver:
  void OnActiveUserPrefServiceChanged(PrefService* pref_service) override;
  void OnSigninScreenPrefServiceInitialized(PrefService* pref_service) override;

  // DisplayConfigurator::Observer:
  void OnDisplayConfigurationChanged(
      const std::vector<raw_ptr<display::DisplaySnapshot, VectorExperimental>>&
          displays) override;

 private:
  // Calculates PrivacyScreen's logical status.
  bool CalculateCurrentStatus() const;

  // Called when the user pref or DLP enforcement for the state of PrivacyScreen
  // is changed.
  void OnStateChanged(bool notify_observers);

  // Called when GPU/DRM is done setting the privacy screen panel to
  // |requested_config|.
  void OnSetPrivacyScreenComplete(bool from_user_pref_init,
                                  bool requested_config,
                                  bool success);

  // Called when a change to |active_user_pref_service_| is detected (i.e. when
  // OnActiveUserPrefServiceChanged() is called.
  void InitFromUserPrefs();

  // Retrieves the current user's PrivacyScreen preference.
  bool GetStateFromActiveUserPreference() const;

  // Whether or not to alert observers about PrivacyScreen state change.
  bool ShouldNotifyObservers(bool from_user_pref_init) const;

  // The pref service of the currently active user. Can be null in
  // ash_unittests.
  raw_ptr<PrefService> active_user_pref_service_ = nullptr;

  // Set to true when entering the login screen. This should happen once per
  // Chrome restart.
  bool applying_login_screen_prefs_ = false;

  // Indicates if the PrivacyScreen is currently on or off.
  bool current_status_ = false;

  // Indicates whether PrivacyScreen is enforced by Data Leak Protection
  // feature.
  bool dlp_enforced_ = false;

  base::ObserverList<Observer> observers_;

  // The registrar used to watch privacy screen prefs changes in the above
  // |active_user_pref_service_| from outside ash.
  // NOTE: Prefs are how Chrome communicates changes to the
  // PrivacyScreenController settings controlled by this class from the WebUI
  // settings.
  std::unique_ptr<PrefChangeRegistrar> pref_change_registrar_;

  // This must be the last variable.
  base::WeakPtrFactory<PrivacyScreenController> weak_ptr_factory_{this};
};

}  // namespace ash

#endif  // ASH_DISPLAY_PRIVACY_SCREEN_CONTROLLER_H_