Split CalculatorsPoliciesBinder into a Prefs class and a Settings class.

Refactor is necessary so that we can have more Prefs binders than Settings
binders when we have multi-profile.  Making this change removes the
refcounting logic that we had and allows the two binders to be owned
by different classes.

Bug: chromium:1015949
Change-Id: Icd341c511d31c7a2742bd50343726718262f5dad
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1935414Reviewed-by: Bailey Berro <baileyberro@chromium.org>
Commit-Queue: Sean Kau <skau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#720758}

chrome/browser/chromeos/BUILD.gn

@@ -2890,6 +2890,7 @@ source_set("unit_tests") {
     "preferences_unittest.cc",
     "printing/automatic_usb_printer_configurer_unittest.cc",
     "printing/bulk_printers_calculator_unittest.cc",
+    "printing/calculators_policies_binder_unittest.cc",
     "printing/cups_printers_manager_unittest.cc",
     "printing/history/mock_print_job_history_service.cc",
     "printing/history/mock_print_job_history_service.h",

chrome/browser/chromeos/printing/calculators_policies_binder.cc

@@ -9,7 +9,6 @@
 #include <string>
 #include <vector>
 
-#include "base/no_destructor.h"
 #include "chrome/browser/chromeos/printing/bulk_printers_calculator.h"
 #include "chrome/browser/chromeos/printing/bulk_printers_calculator_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
@@ -17,8 +16,8 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/settings/cros_settings_names.h"
-#include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_change_registrar.h"
+#include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/user_manager/user.h"
 
@@ -26,15 +25,6 @@ namespace chromeos {
 
 namespace {
 
-// It stores the number of bindings (instances of this class) connected to each
-// BulkPrintersCalculator object. It allows us to make sure, that every
-// BulkPrintersCalculator object is not binded more that once.
-std::map<BulkPrintersCalculator*, unsigned>& BindingsCount() {
-  static base::NoDestructor<std::map<BulkPrintersCalculator*, unsigned>>
-      bindings_count;
-  return *bindings_count;
-}
-
 BulkPrintersCalculator::AccessMode ConvertToAccessMode(int mode_val) {
   if (mode_val >= BulkPrintersCalculator::BLACKLIST_ONLY &&
       mode_val <= BulkPrintersCalculator::ALL_ACCESS) {
@@ -47,163 +37,92 @@ BulkPrintersCalculator::AccessMode ConvertToAccessMode(int mode_val) {
 
 std::vector<std::string> ConvertToVector(const base::ListValue* list) {
   std::vector<std::string> string_list;
-  if (list) {
-    for (const base::Value& value : *list) {
-      if (value.is_string()) {
-        string_list.push_back(value.GetString());
-      }
+  if (!list) {
+    return string_list;
+  }
+
+  for (const base::Value& value : *list) {
+    if (value.is_string()) {
+      string_list.push_back(value.GetString());
     }
   }
   return string_list;
 }
 
-class CalculatorsPoliciesBinderImpl : public CalculatorsPoliciesBinder {
+class PrefBinder : public CalculatorsPoliciesBinder {
  public:
-  CalculatorsPoliciesBinderImpl(CrosSettings* settings, Profile* profile)
-      : settings_(settings), profile_(profile) {
-    pref_change_registrar_.Init(profile->GetPrefs());
-    // Bind device policies to corresponding instance of BulkPrintersCalculator.
-    device_printers_ = BulkPrintersCalculatorFactory::Get()->GetForDevice();
-    if (device_printers_ && ++(BindingsCount()[device_printers_.get()]) == 1) {
-      BindSettings(kDeviceNativePrintersAccessMode,
-                   &CalculatorsPoliciesBinderImpl::UpdateDeviceAccessMode);
-      BindSettings(kDeviceNativePrintersBlacklist,
-                   &CalculatorsPoliciesBinderImpl::UpdateDeviceBlacklist);
-      BindSettings(kDeviceNativePrintersWhitelist,
-                   &CalculatorsPoliciesBinderImpl::UpdateDeviceWhitelist);
-    }
-    // Calculate account_id_.
-    const user_manager::User* user =
-        ProfileHelper::Get()->GetUserByProfile(profile);
-    if (user) {
-      account_id_ = user->GetAccountId();
-      user_printers_ =
-          BulkPrintersCalculatorFactory::Get()->GetForAccountId(account_id_);
-    }
-    // Bind user policies to corresponding instance of BulkPrintersCalculator.
-    if (user_printers_ && ++(BindingsCount()[user_printers_.get()]) == 1) {
-      BindPref(prefs::kRecommendedNativePrintersAccessMode,
-               &CalculatorsPoliciesBinderImpl::UpdateUserAccessMode);
-      BindPref(prefs::kRecommendedNativePrintersBlacklist,
-               &CalculatorsPoliciesBinderImpl::UpdateUserBlacklist);
-      BindPref(prefs::kRecommendedNativePrintersWhitelist,
-               &CalculatorsPoliciesBinderImpl::UpdateUserWhitelist);
-    }
+  PrefBinder(PrefService* pref_service,
+             base::WeakPtr<BulkPrintersCalculator> calculator)
+      : CalculatorsPoliciesBinder(prefs::kRecommendedNativePrintersAccessMode,
+                                  prefs::kRecommendedNativePrintersBlacklist,
+                                  prefs::kRecommendedNativePrintersWhitelist,
+                                  calculator),
+        prefs_(pref_service) {
+    pref_change_registrar_.Init(prefs_);
   }
 
-  ~CalculatorsPoliciesBinderImpl() override {
-    // We have to decrease counters in bindings_count.
-    if (device_printers_ && --(BindingsCount()[device_printers_.get()]) == 0) {
-      BindingsCount().erase(device_printers_.get());
-    }
-    if (user_printers_ && --(BindingsCount()[user_printers_.get()]) == 0) {
-      BindingsCount().erase(user_printers_.get());
-      BulkPrintersCalculatorFactory::Get()->RemoveForUserId(account_id_);
-    }
-  }
-
- private:
-  // Methods propagating values from policies to BulkPrintersCalculator.
-  void UpdateDeviceAccessMode() {
-    int mode_val;
-    if (!settings_->GetInteger(kDeviceNativePrintersAccessMode, &mode_val)) {
-      mode_val = BulkPrintersCalculator::AccessMode::UNSET;
-    }
-    if (device_printers_) {
-      device_printers_->SetAccessMode(ConvertToAccessMode(mode_val));
-    }
+ protected:
+  void Bind(const char* policy_name, base::RepeatingClosure closure) override {
+    DVLOG(1) << "Binding " << policy_name;
+    pref_change_registrar_.Add(policy_name, closure);
   }
 
-  void UpdateDeviceBlacklist() {
-    if (device_printers_) {
-      device_printers_->SetBlacklist(
-          FromSettings(kDeviceNativePrintersBlacklist));
-    }
+  int GetAccessMode(const char* name) const override {
+    return prefs_->GetInteger(name);
   }
 
-  void UpdateDeviceWhitelist() {
-    if (device_printers_) {
-      device_printers_->SetWhitelist(
-          FromSettings(kDeviceNativePrintersWhitelist));
-    }
+  std::vector<std::string> GetStringList(const char* name) const override {
+    return ConvertToVector(prefs_->GetList(name));
   }
 
-  void UpdateUserAccessMode() {
-    if (user_printers_) {
-      user_printers_->SetAccessMode(
-          ConvertToAccessMode(profile_->GetPrefs()->GetInteger(
-              prefs::kRecommendedNativePrintersAccessMode)));
-    }
-  }
+ private:
+  PrefService* prefs_;
+  PrefChangeRegistrar pref_change_registrar_;
+};
 
-  void UpdateUserBlacklist() {
-    if (user_printers_) {
-      user_printers_->SetBlacklist(
-          FromPrefs(prefs::kRecommendedNativePrintersBlacklist));
-    }
+class SettingsBinder : public CalculatorsPoliciesBinder {
+ public:
+  SettingsBinder(CrosSettings* settings,
+                 base::WeakPtr<BulkPrintersCalculator> calculator)
+      : CalculatorsPoliciesBinder(kDeviceNativePrintersAccessMode,
+                                  kDeviceNativePrintersBlacklist,
+                                  kDeviceNativePrintersWhitelist,
+                                  calculator),
+        settings_(settings) {}
+
+ protected:
+  void Bind(const char* policy_name, base::RepeatingClosure closure) override {
+    DVLOG(1) << "Bind device setting: " << policy_name;
+    subscriptions_.push_back(
+        settings_->AddSettingsObserver(policy_name, closure));
   }
 
-  void UpdateUserWhitelist() {
-    if (user_printers_) {
-      user_printers_->SetWhitelist(
-          FromPrefs(prefs::kRecommendedNativePrintersWhitelist));
+  int GetAccessMode(const char* name) const override {
+    int mode_val;
+    if (!settings_->GetInteger(kDeviceNativePrintersAccessMode, &mode_val)) {
+      mode_val = BulkPrintersCalculator::AccessMode::UNSET;
     }
+    return mode_val;
   }
 
-  typedef void (CalculatorsPoliciesBinderImpl::*SimpleMethod)();
-
-  // Binds given device policy to given method and calls this method once.
-  void BindPref(const char* policy_name, SimpleMethod method_to_call) {
-    pref_change_registrar_.Add(
-        policy_name,
-        base::BindRepeating(method_to_call, base::Unretained(this)));
-    (this->*method_to_call)();
-  }
-
-  // Binds given user policy to given method and calls this method once.
-  void BindSettings(const char* policy_name, SimpleMethod method_to_call) {
-    subscriptions_.push_back(settings_->AddSettingsObserver(
-        policy_name,
-        base::BindRepeating(method_to_call, base::Unretained(this))));
-    (this->*method_to_call)();
-  }
-
-  // Extracts the list of strings named |policy_name| from device policies.
-  std::vector<std::string> FromSettings(const std::string& policy_name) {
+  std::vector<std::string> GetStringList(const char* name) const override {
     const base::ListValue* list;
-    if (!settings_->GetList(policy_name, &list)) {
+    if (!settings_->GetList(name, &list)) {
       list = nullptr;
     }
     return ConvertToVector(list);
   }
 
-  // Extracts the list of strings named |policy_name| from user policies.
-  std::vector<std::string> FromPrefs(const std::string& policy_name) {
-    return ConvertToVector(profile_->GetPrefs()->GetList(policy_name));
-  }
-
-  // Device and user bulk printers calculator. Unowned. They both may be set to
-  // nullptr during system shutdown. The user bulk printers calculator is also
-  // set to nullptr when corresponding profile is being destroyed.
-  base::WeakPtr<BulkPrintersCalculator> device_printers_;
-  base::WeakPtr<BulkPrintersCalculator> user_printers_;
-
-  // Device and profile (user) settings.
+ private:
   CrosSettings* settings_;
   std::list<std::unique_ptr<CrosSettings::ObserverSubscription>> subscriptions_;
-  Profile* profile_;
-  AccountId account_id_;
-  PrefChangeRegistrar pref_change_registrar_;
-
-  SEQUENCE_CHECKER(sequence_checker_);
-  DISALLOW_COPY_AND_ASSIGN(CalculatorsPoliciesBinderImpl);
 };
 
 }  // namespace
 
 // static
 void CalculatorsPoliciesBinder::RegisterProfilePrefs(
-    user_prefs::PrefRegistrySyncable* registry) {
+    PrefRegistrySimple* registry) {
   // Default value for access mode is AllAccess.
   registry->RegisterIntegerPref(prefs::kRecommendedNativePrintersAccessMode,
                                 BulkPrintersCalculator::ALL_ACCESS);
@@ -212,10 +131,77 @@ void CalculatorsPoliciesBinder::RegisterProfilePrefs(
 }
 
 // static
-std::unique_ptr<CalculatorsPoliciesBinder> CalculatorsPoliciesBinder::Create(
+std::unique_ptr<CalculatorsPoliciesBinder>
+CalculatorsPoliciesBinder::DeviceBinder(
     CrosSettings* settings,
-    Profile* profile) {
-  return std::make_unique<CalculatorsPoliciesBinderImpl>(settings, profile);
+    base::WeakPtr<BulkPrintersCalculator> calculator) {
+  auto binder = std::make_unique<SettingsBinder>(settings, calculator);
+  binder->Init();
+  return binder;
+}
+
+// static
+std::unique_ptr<CalculatorsPoliciesBinder>
+CalculatorsPoliciesBinder::UserBinder(
+    PrefService* prefs,
+    base::WeakPtr<BulkPrintersCalculator> calculator) {
+  auto binder = std::make_unique<PrefBinder>(prefs, calculator);
+  binder->Init();
+  return binder;
+}
+
+CalculatorsPoliciesBinder::CalculatorsPoliciesBinder(
+    const char* access_mode_name,
+    const char* blacklist_name,
+    const char* whitelist_name,
+    base::WeakPtr<BulkPrintersCalculator> calculator)
+    : access_mode_name_(access_mode_name),
+      blacklist_name_(blacklist_name),
+      whitelist_name_(whitelist_name),
+      calculator_(calculator) {
+  DCHECK(access_mode_name);
+  DCHECK(blacklist_name);
+  DCHECK(whitelist_name);
+  DCHECK(calculator);
+}
+
+CalculatorsPoliciesBinder::~CalculatorsPoliciesBinder() = default;
+
+base::WeakPtr<CalculatorsPoliciesBinder>
+CalculatorsPoliciesBinder::GetWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
+void CalculatorsPoliciesBinder::Init() {
+  Bind(access_mode_name_,
+       base::BindRepeating(&CalculatorsPoliciesBinder::UpdateAccessMode,
+                           GetWeakPtr()));
+  Bind(blacklist_name_,
+       base::BindRepeating(&CalculatorsPoliciesBinder::UpdateBlacklist,
+                           GetWeakPtr()));
+  Bind(whitelist_name_,
+       base::BindRepeating(&CalculatorsPoliciesBinder::UpdateWhitelist,
+                           GetWeakPtr()));
+}
+
+void CalculatorsPoliciesBinder::UpdateAccessMode() {
+  DVLOG(1) << "Update access mode";
+  if (calculator_) {
+    calculator_->SetAccessMode(
+        ConvertToAccessMode(GetAccessMode(access_mode_name_)));
+  }
+}
+
+void CalculatorsPoliciesBinder::UpdateWhitelist() {
+  if (calculator_) {
+    calculator_->SetWhitelist(GetStringList(whitelist_name_));
+  }
+}
+
+void CalculatorsPoliciesBinder::UpdateBlacklist() {
+  if (calculator_) {
+    calculator_->SetBlacklist(GetStringList(blacklist_name_));
+  }
 }
 
 }  // namespace chromeos

chrome/browser/chromeos/printing/calculators_policies_binder.h

@@ -6,14 +6,15 @@
 #define CHROME_BROWSER_CHROMEOS_PRINTING_CALCULATORS_POLICIES_BINDER_H_
 
 #include <memory>
+#include <string>
+#include <vector>
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "chrome/browser/chromeos/printing/bulk_printers_calculator.h"
 
-class Profile;
-
-namespace user_prefs {
-class PrefRegistrySyncable;
-}
+class PrefService;
+class PrefRegistrySimple;
 
 namespace chromeos {
 
@@ -24,18 +25,58 @@ class CrosSettings;
 // profile. All methods must be called from the same sequence (UI).
 class CalculatorsPoliciesBinder {
  public:
-  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+  static void RegisterProfilePrefs(PrefRegistrySimple* registry);
 
-  // |settings| is the source of device policies. |profile| is a user profile.
-  static std::unique_ptr<CalculatorsPoliciesBinder> Create(
+  // Binds events from |settings| to the appropriate fields in |calculator|.
+  static std::unique_ptr<CalculatorsPoliciesBinder> DeviceBinder(
       CrosSettings* settings,
-      Profile* profile);
-  virtual ~CalculatorsPoliciesBinder() = default;
+      base::WeakPtr<BulkPrintersCalculator> calculator);
+
+  // Binds events from |profile| to the appropriate fields in |calculator|.
+  static std::unique_ptr<CalculatorsPoliciesBinder> UserBinder(
+      PrefService* prefs,
+      base::WeakPtr<BulkPrintersCalculator> calculator);
+
+  virtual ~CalculatorsPoliciesBinder();
 
  protected:
-  CalculatorsPoliciesBinder() = default;
+  // |access_mode_name| is the name of the access mode policy.  |blacklist_name|
+  // is the name of the blacklist policy.  |whitelist_name| is the name of the
+  // whitelist policy.  |calculator| will receive updates from the bound
+  // policies.
+  CalculatorsPoliciesBinder(const char* access_mode_name,
+                            const char* blacklist_name,
+                            const char* whitelist_name,
+                            base::WeakPtr<BulkPrintersCalculator> calculator);
+
+  // Returns a WeakPtr to the Derived class.
+  base::WeakPtr<CalculatorsPoliciesBinder> GetWeakPtr();
+
+  // Binds |policy_name| to |callback| for each policy name, using the
+  // appropriate preference system.
+  virtual void Bind(const char* policy_name,
+                    base::RepeatingClosure callback) = 0;
+
+  // Returns the access mode integer preference for |name|.
+  virtual int GetAccessMode(const char* name) const = 0;
+
+  // Returns a string list for the prefrence |name|.
+  virtual std::vector<std::string> GetStringList(const char* name) const = 0;
 
  private:
+  // Attaches bindings since they cannot be safely bound in the constructor.
+  void Init();
+
+  void UpdateAccessMode();
+  void UpdateWhitelist();
+  void UpdateBlacklist();
+
+  const char* access_mode_name_;
+  const char* blacklist_name_;
+  const char* whitelist_name_;
+  base::WeakPtr<BulkPrintersCalculator> calculator_;
+  base::WeakPtrFactory<CalculatorsPoliciesBinder> weak_ptr_factory_{this};
+
   DISALLOW_COPY_AND_ASSIGN(CalculatorsPoliciesBinder);
 };
 

chrome/browser/chromeos/printing/calculators_policies_binder_unittest.cc

+// Copyright 2019 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/chromeos/printing/calculators_policies_binder.h"
+
+#include <array>
+#include <string>
+
+#include "base/test/task_environment.h"
+#include "chrome/browser/chromeos/printing/bulk_printers_calculator.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/settings/scoped_testing_cros_settings.h"
+#include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
+#include "chrome/common/pref_names.h"
+#include "components/prefs/testing_pref_service.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+namespace {
+
+constexpr size_t kNumPrinters = 5;
+
+constexpr size_t kWhitelistPrinters = 4;
+constexpr std::array<const char*, kWhitelistPrinters> kWhitelistIds = {
+    "First", "Second", "Third", "Fifth"};
+
+constexpr std::array<const char*, 3> kBlacklistIds = {"Second", "Third",
+                                                      "Fourth"};
+// kNumPrinters - kBlacklistIds.size() = kBlacklistPrinters (2)
+constexpr size_t kBlacklistPrinters = 2;
+
+constexpr char kBulkPolicyContentsJson[] = R"json(
+[
+  {
+    "id": "First",
+    "display_name": "LexaPrint",
+    "description": "Laser on the test shelf",
+    "manufacturer": "LexaPrint, Inc.",
+    "model": "MS610de",
+    "uri": "ipp://192.168.1.5",
+    "ppd_resource": {
+      "effective_model": "MS610de"
+    }
+  }, {
+    "id": "Second",
+    "display_name": "Color Laser",
+    "description": "The printer next to the water cooler.",
+    "manufacturer": "Printer Manufacturer",
+    "model":"Color Laser 2004",
+    "uri":"ipps://print-server.intranet.example.com:443/ipp/cl2k4",
+    "uuid":"1c395fdb-5d93-4904-b246-b2c046e79d12",
+    "ppd_resource":{
+      "effective_manufacturer": "MakesPrinters",
+      "effective_model": "ColorLaser2k4"
+    }
+  }, {
+    "id": "Third",
+    "display_name": "YaLP",
+    "description": "Fancy Fancy Fancy",
+    "manufacturer": "LexaPrint, Inc.",
+    "model": "MS610de",
+    "uri": "ipp://192.168.1.8",
+    "ppd_resource": {
+      "effective_manufacturer": "LexaPrint",
+      "effective_model": "MS610de"
+    }
+  }, {
+    "id": "Fourth",
+    "display_name": "Yon",
+    "description": "Another printer",
+    "manufacturer": "CrosPrints",
+    "model": "1000d7",
+    "uri": "ipp://192.168.1.9",
+    "ppd_resource": {
+      "effective_manufacturer": "Printer",
+      "effective_model": "Model"
+    }
+  }, {
+    "id": "Fifth",
+    "display_name": "ABCDE",
+    "description": "Yep yep yep",
+    "manufacturer": "Ink and toner",
+    "model": "34343434l",
+    "uri": "ipp://192.168.1.10",
+    "ppd_resource": {
+      "effective_manufacturer": "Blah",
+      "effective_model": "Blah blah Blah"
+    }
+  }
+])json";
+
+template <class Container>
+std::unique_ptr<base::Value> StringsToList(Container container) {
+  auto first = container.begin();
+  auto last = container.end();
+  auto list = std::make_unique<base::Value>(base::Value::Type::LIST);
+
+  while (first != last) {
+    list->Append(*first);
+    first++;
+  }
+  return list;
+}
+
+class CalculatorsPoliciesBinderTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    CalculatorsPoliciesBinder::RegisterProfilePrefs(prefs_.registry());
+  }
+
+  std::unique_ptr<BulkPrintersCalculator> UserCalculator() {
+    auto calculator = BulkPrintersCalculator::Create();
+    binder_ =
+        CalculatorsPoliciesBinder::UserBinder(&prefs_, calculator->AsWeakPtr());
+
+    // Populate data
+    calculator->SetData(std::make_unique<std::string>(kBulkPolicyContentsJson));
+    return calculator;
+  }
+
+  std::unique_ptr<BulkPrintersCalculator> DeviceCalculator() {
+    auto calculator = BulkPrintersCalculator::Create();
+    binder_ = CalculatorsPoliciesBinder::DeviceBinder(CrosSettings::Get(),
+                                                      calculator->AsWeakPtr());
+
+    // Populate data
+    calculator->SetData(std::make_unique<std::string>(kBulkPolicyContentsJson));
+    return calculator;
+  }
+
+  void SetDeviceSetting(const std::string& path, const base::Value& value) {
+    testing_settings_.device_settings()->Set(path, value);
+  }
+
+  base::test::TaskEnvironment env_;
+  ScopedTestingCrosSettings testing_settings_;
+  TestingPrefServiceSimple prefs_;
+
+  // Class under test.  Expected to be destroyed first.
+  std::unique_ptr<CalculatorsPoliciesBinder> binder_;
+};
+
+TEST_F(CalculatorsPoliciesBinderTest, PrefsAllAccess) {
+  auto calculator = UserCalculator();
+
+  // Set prefs to complete computation
+  prefs_.SetManagedPref(prefs::kRecommendedNativePrintersAccessMode,
+                        std::make_unique<base::Value>(
+                            BulkPrintersCalculator::AccessMode::ALL_ACCESS));
+
+  env_.RunUntilIdle();
+  EXPECT_TRUE(calculator->IsComplete());
+  EXPECT_EQ(calculator->GetPrinters().size(), kNumPrinters);
+}
+
+TEST_F(CalculatorsPoliciesBinderTest, PrefsWhitelist) {
+  auto calculator = UserCalculator();
+
+  // Set prefs to complete computation
+  prefs_.SetManagedPref(
+      prefs::kRecommendedNativePrintersAccessMode,
+      std::make_unique<base::Value>(
+          BulkPrintersCalculator::AccessMode::WHITELIST_ONLY));
+  prefs_.SetManagedPref(prefs::kRecommendedNativePrintersWhitelist,
+                        StringsToList(kWhitelistIds));
+
+  env_.RunUntilIdle();
+  EXPECT_TRUE(calculator->IsComplete());
+  EXPECT_EQ(calculator->GetPrinters().size(), kWhitelistPrinters);
+}
+
+TEST_F(CalculatorsPoliciesBinderTest, PrefsBlacklist) {
+  auto calculator = UserCalculator();
+
+  // Set prefs to complete computation
+  prefs_.SetManagedPref(
+      prefs::kRecommendedNativePrintersAccessMode,
+      std::make_unique<base::Value>(
+          BulkPrintersCalculator::AccessMode::BLACKLIST_ONLY));
+  prefs_.SetManagedPref(prefs::kRecommendedNativePrintersBlacklist,
+                        StringsToList(kBlacklistIds));
+
+  env_.RunUntilIdle();
+  EXPECT_TRUE(calculator->IsComplete());
+  EXPECT_EQ(calculator->GetPrinters().size(), kBlacklistPrinters);
+}
+
+TEST_F(CalculatorsPoliciesBinderTest, SettingsAllAccess) {
+  auto calculator = DeviceCalculator();
+
+  SetDeviceSetting(kDeviceNativePrintersAccessMode,
+                   base::Value(BulkPrintersCalculator::AccessMode::ALL_ACCESS));
+  env_.RunUntilIdle();
+
+  EXPECT_TRUE(calculator->IsComplete());
+  EXPECT_EQ(calculator->GetPrinters().size(), kNumPrinters);
+}
+
+TEST_F(CalculatorsPoliciesBinderTest, SettingsWhitelist) {
+  auto calculator = DeviceCalculator();
+
+  SetDeviceSetting(
+      kDeviceNativePrintersAccessMode,
+      base::Value(BulkPrintersCalculator::AccessMode::WHITELIST_ONLY));
+  SetDeviceSetting(kDeviceNativePrintersWhitelist,
+                   *StringsToList(kWhitelistIds));
+
+  env_.RunUntilIdle();
+  EXPECT_TRUE(calculator->IsComplete());
+  EXPECT_EQ(calculator->GetPrinters().size(), kWhitelistPrinters);
+}
+
+TEST_F(CalculatorsPoliciesBinderTest, SettingsBlacklist) {
+  auto calculator = DeviceCalculator();
+
+  SetDeviceSetting(
+      kDeviceNativePrintersAccessMode,
+      base::Value(BulkPrintersCalculator::AccessMode::BLACKLIST_ONLY));
+  SetDeviceSetting(kDeviceNativePrintersBlacklist,
+                   *StringsToList(kBlacklistIds));
+
+  env_.RunUntilIdle();
+  EXPECT_TRUE(calculator->IsComplete());
+  EXPECT_EQ(calculator->GetPrinters().size(), kBlacklistPrinters);
+}
+
+}  // namespace
+}  // namespace chromeos

chrome/browser/chromeos/printing/enterprise_printers_provider.cc

@@ -48,11 +48,11 @@ class EnterprisePrintersProviderImpl : public EnterprisePrintersProvider,
     // initialization of pref_change_registrar
     pref_change_registrar_.Init(profile->GetPrefs());
 
-    // Binds instances of BulkPrintersCalculator to policies.
-    policies_binder_ = CalculatorsPoliciesBinder::Create(settings, profile);
     // Get instance of BulkPrintersCalculator for device policies.
     device_printers_ = BulkPrintersCalculatorFactory::Get()->GetForDevice();
     if (device_printers_) {
+      devices_binder_ =
+          CalculatorsPoliciesBinder::DeviceBinder(settings, device_printers_);
       device_printers_->AddObserver(this);
       RecalculateCompleteFlagForDevicePrinters();
     }
@@ -64,6 +64,8 @@ class EnterprisePrintersProviderImpl : public EnterprisePrintersProvider,
       account_id_ = user->GetAccountId();
       user_printers_ =
           BulkPrintersCalculatorFactory::Get()->GetForAccountId(account_id_);
+      profile_binder_ = CalculatorsPoliciesBinder::UserBinder(
+          profile->GetPrefs(), user_printers_);
       user_printers_->AddObserver(this);
       RecalculateCompleteFlagForUserPrinters();
     }
@@ -227,7 +229,8 @@ class EnterprisePrintersProviderImpl : public EnterprisePrintersProvider,
   base::WeakPtr<BulkPrintersCalculator> user_printers_;
 
   // Policies binder (bridge between policies and calculators). Owned.
-  std::unique_ptr<CalculatorsPoliciesBinder> policies_binder_;
+  std::unique_ptr<CalculatorsPoliciesBinder> devices_binder_;
+  std::unique_ptr<CalculatorsPoliciesBinder> profile_binder_;
 
   // Profile (user) settings.
   Profile* profile_;