Add a Proxy for CupsPrintersManager

Some subsystems don't have access to a profile but need to observe
CupsPrintersManager.  Build a Proxy object that can be observed and
will attach the primary user CupsPrintersManager when it's created.

Change-Id: I6b52d51740e7d72359030c7ab6551541d8b2d30c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2057859Reviewed-by: Luum Habtemariam <luum@chromium.org>
Commit-Queue: Sean Kau <skau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#743006}

chrome/browser/chromeos/BUILD.gn

@@ -2074,6 +2074,8 @@ source_set("chromeos") {
     "printing/cups_printers_manager.h",
     "printing/cups_printers_manager_factory.cc",
     "printing/cups_printers_manager_factory.h",
+    "printing/cups_printers_manager_proxy.cc",
+    "printing/cups_printers_manager_proxy.h",
     "printing/enterprise_printers_provider.cc",
     "printing/enterprise_printers_provider.h",
     "printing/history/print_job_database.h",

chrome/browser/chromeos/printing/cups_printers_manager_factory.cc

@@ -6,6 +6,7 @@
 
 #include "base/memory/singleton.h"
 #include "chrome/browser/chromeos/printing/cups_printers_manager.h"
+#include "chrome/browser/chromeos/printing/cups_printers_manager_proxy.h"
 #include "chrome/browser/chromeos/printing/synced_printers_manager_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
@@ -29,22 +30,41 @@ CupsPrintersManager* CupsPrintersManagerFactory::GetForBrowserContext(
 CupsPrintersManagerFactory::CupsPrintersManagerFactory()
     : BrowserContextKeyedServiceFactory(
           "CupsPrintersManagerFactory",
-          BrowserContextDependencyManager::GetInstance()) {
+          BrowserContextDependencyManager::GetInstance()),
+      proxy_(CupsPrintersManagerProxy::Create()) {
   DependsOn(chromeos::SyncedPrintersManagerFactory::GetInstance());
 }
 
 CupsPrintersManagerFactory::~CupsPrintersManagerFactory() = default;
 
+CupsPrintersManagerProxy* CupsPrintersManagerFactory::GetProxy() {
+  return proxy_.get();
+}
+
 KeyedService* CupsPrintersManagerFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   // We do not need an instance of CupsPrintersManager on the lockscreen.
-  if (ProfileHelper::IsLockScreenAppProfile(
-          Profile::FromBrowserContext(context)) ||
-      ProfileHelper::IsSigninProfile(Profile::FromBrowserContext(context))) {
+  auto* profile = Profile::FromBrowserContext(context);
+  if (ProfileHelper::IsLockScreenAppProfile(profile) ||
+      ProfileHelper::IsSigninProfile(profile)) {
     return nullptr;
   }
-  return CupsPrintersManager::Create(Profile::FromBrowserContext(context))
-      .release();
+  auto manager = CupsPrintersManager::Create(profile);
+  if (ProfileHelper::IsPrimaryProfile(profile)) {
+    proxy_->SetManager(manager.get());
+  }
+  return manager.release();
+}
+
+void CupsPrintersManagerFactory::BrowserContextShutdown(
+    content::BrowserContext* context) {
+  CupsPrintersManager* manager = static_cast<CupsPrintersManager*>(
+      GetServiceForBrowserContext(context, false));
+  if (manager) {
+    // Remove the manager from the proxy before the manager is deleted.
+    proxy_->RemoveManager(manager);
+  }
+  BrowserContextKeyedServiceFactory::BrowserContextShutdown(context);
 }
 
 content::BrowserContext* CupsPrintersManagerFactory::GetBrowserContextToUse(

chrome/browser/chromeos/printing/cups_printers_manager_factory.h

@@ -5,6 +5,7 @@
 #ifndef CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINTERS_MANAGER_FACTORY_H_
 #define CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINTERS_MANAGER_FACTORY_H_
 
+#include <memory>
 #include "components/keyed_service/content/browser_context_keyed_service_factory.h"
 
 namespace content {
@@ -19,6 +20,7 @@ struct DefaultSingletonTraits;
 namespace chromeos {
 
 class CupsPrintersManager;
+class CupsPrintersManagerProxy;
 
 class CupsPrintersManagerFactory : public BrowserContextKeyedServiceFactory {
  public:
@@ -26,6 +28,10 @@ class CupsPrintersManagerFactory : public BrowserContextKeyedServiceFactory {
   static CupsPrintersManager* GetForBrowserContext(
       content::BrowserContext* context);
 
+  // Returns the CupsPrintersManagerProxy object which is always attached to the
+  // primary profile.
+  CupsPrintersManagerProxy* GetProxy();
+
  private:
   friend struct base::DefaultSingletonTraits<CupsPrintersManagerFactory>;
 
@@ -35,11 +41,15 @@ class CupsPrintersManagerFactory : public BrowserContextKeyedServiceFactory {
   // BrowserContextKeyedServiceFactory overrides:
   KeyedService* BuildServiceInstanceFor(
       content::BrowserContext* context) const override;
+  void BrowserContextShutdown(content::BrowserContext* context) override;
   content::BrowserContext* GetBrowserContextToUse(
       content::BrowserContext* context) const override;
   bool ServiceIsCreatedWithBrowserContext() const override;
   bool ServiceIsNULLWhileTesting() const override;
 
+  // Proxy object always attached to the primary profile.
+  std::unique_ptr<CupsPrintersManagerProxy> proxy_;
+
   DISALLOW_COPY_AND_ASSIGN(CupsPrintersManagerFactory);
 };
 

chrome/browser/chromeos/printing/cups_printers_manager_proxy.cc

+// Copyright 2020 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/cups_printers_manager_proxy.h"
+
+#include <memory>
+
+#include "base/observer_list.h"
+#include "chrome/browser/chromeos/printing/cups_printers_manager.h"
+#include "chromeos/printing/printer_configuration.h"
+
+namespace chromeos {
+
+namespace {
+
+class ProxyImpl : public CupsPrintersManagerProxy,
+                  public CupsPrintersManager::Observer {
+ public:
+  ProxyImpl() = default;
+
+  ~ProxyImpl() override {
+    // Verify that the active manager has been unset when we're cleaned up.
+    DCHECK(active_manager_ == nullptr);
+  }
+
+  void AddObserver(CupsPrintersManager::Observer* observer) override {
+    observers_.AddObserver(observer);
+  }
+
+  void RemoveObserver(CupsPrintersManager::Observer* observer) override {
+    observers_.RemoveObserver(observer);
+  }
+
+  void SetManager(CupsPrintersManager* manager) override {
+    if (active_manager_ != nullptr) {
+      DVLOG(1) << "Discarding manager when one is already set.  This should "
+                  "only happen during testing.";
+      return;
+    }
+
+    active_manager_ = manager;
+    active_manager_->AddObserver(this);
+
+    // Emit a change event to wake up any observers.
+    // Emitting for saved printers is an arbitrary decision.
+    OnPrintersChanged(PrinterClass::kSaved,
+                      active_manager_->GetPrinters(PrinterClass::kSaved));
+  }
+
+  void RemoveManager(CupsPrintersManager* manager) override {
+    if (!active_manager_) {
+      // It's possible no manager was ever attached and we ignore it.
+      return;
+    }
+
+    if (manager != active_manager_) {
+      // Ignore removals of unattached managers.
+      return;
+    }
+
+    active_manager_->RemoveObserver(this);
+    active_manager_ = nullptr;
+  }
+
+  // CupsPrintersManager::Observer overrides
+  void OnPrintersChanged(PrinterClass printer_class,
+                         const std::vector<Printer>& printers) override {
+    for (auto& observer : observers_) {
+      observer.OnPrintersChanged(printer_class, printers);
+    }
+  }
+
+ private:
+  // The manager for which we are forwarding events.
+  CupsPrintersManager* active_manager_ = nullptr;
+  // TODO(skau): Change to CheckedObservers
+  base::ObserverList<CupsPrintersManager::Observer>::Unchecked observers_;
+};
+
+}  // namespace
+
+// static
+std::unique_ptr<CupsPrintersManagerProxy> CupsPrintersManagerProxy::Create() {
+  return std::make_unique<ProxyImpl>();
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/cups_printers_manager_proxy.h

+// Copyright 2020 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_CHROMEOS_PRINTING_CUPS_PRINTERS_MANAGER_PROXY_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINTERS_MANAGER_PROXY_H_
+
+#include <memory>
+#include <vector>
+
+#include "chrome/browser/chromeos/printing/cups_printers_manager.h"
+
+namespace chromeos {
+
+// A proxy for observers of CupsPrintersManager who do not have access to a
+// profile and always wish to observe the printers for the primary user profile.
+class CupsPrintersManagerProxy {
+ public:
+  static std::unique_ptr<CupsPrintersManagerProxy> Create();
+
+  CupsPrintersManagerProxy(const CupsPrintersManagerProxy&) = delete;
+  CupsPrintersManagerProxy& operator=(const CupsPrintersManagerProxy&) = delete;
+
+  virtual ~CupsPrintersManagerProxy() = default;
+
+  virtual void AddObserver(CupsPrintersManager::Observer*) = 0;
+  virtual void RemoveObserver(CupsPrintersManager::Observer*) = 0;
+
+  // Set the manager which supplies events.  As a sideeffect, this triggers
+  // observer calls to guarantee notification to observers.
+  //
+  // It is an error to set a manager when an active manager is present.
+  virtual void SetManager(CupsPrintersManager* manager) = 0;
+
+  // Resets the active manager if |manager| matches the current active manager.
+  virtual void RemoveManager(CupsPrintersManager* manager) = 0;
+
+ protected:
+  CupsPrintersManagerProxy() = default;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINTERS_MANAGER_PROXY_H_