Introduce UsbPrinterNotification

- This notification is shown when a user plugs in a USB printer
- Notification is currently gated on the kStreamlinedUsbPrinterSetup
feature flag
- With this CL, notifications are only displayed for unsaved printers
- Subsequent CL will wire up a notification for a saved printer that
is plugged in

Bug: 951139
Change-Id: I10c6e5d3b41776b0ca79e07739c403732634569a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1594798Reviewed-by: Zentaro Kavanagh <zentaro@chromium.org>
Commit-Queue: Bailey Berro <baileyberro@chromium.org>
Cr-Commit-Position: refs/heads/master@{#658752}

chrome/app/chromeos_strings.grdp

@@ -3233,6 +3233,14 @@
     Get help
   </message>
 
+  <!-- USB Printer Installation Notification -->
+  <message name="IDS_USB_PRINTER_NOTIFICATION_CONNECTED_TITLE" desc="Title of the USB printer connected successfully notification.">
+    USB printer connected
+  </message>
+  <message name="IDS_USB_PRINTER_NOTIFICATION_CONNECTED_MESSAGE" desc="Message displayed when the USB printer is connected successfully.">
+    <ph name="PRINTER_NAME">$1<ex> Google InkJet 1234</ex></ph> is connected and ready
+  </message>
+
   <!-- RequestPin dialog messages -->
   <message name="IDS_REQUEST_PIN_DIALOG_HEADER" desc="The text displayed in the certificate provider PIN request dialog.">
     "<ph name="EXTENSION_NAME">$1<ex>My Extension</ex></ph>" is requesting your <ph name="CODE_TYPE">$2<ex>PIN</ex></ph>

chrome/browser/chromeos/BUILD.gn

@@ -1846,6 +1846,10 @@ source_set("chromeos") {
     "printing/synced_printers_manager_factory.h",
     "printing/usb_printer_detector.cc",
     "printing/usb_printer_detector.h",
+    "printing/usb_printer_notification.cc",
+    "printing/usb_printer_notification.h",
+    "printing/usb_printer_notification_controller.cc",
+    "printing/usb_printer_notification_controller.h",
     "printing/usb_printer_util.cc",
     "printing/usb_printer_util.h",
     "printing/zeroconf_printer_detector.cc",

chrome/browser/chromeos/printing/automatic_usb_printer_configurer.cc

@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/stl_util.h"
+#include "chrome/browser/chromeos/printing/usb_printer_notification_controller.h"
 #include "chrome/common/chrome_features.h"
 
 namespace chromeos {
@@ -26,9 +27,11 @@ bool IsInAutomaticList(const std::string& printer_id,
 
 AutomaticUsbPrinterConfigurer::AutomaticUsbPrinterConfigurer(
     std::unique_ptr<PrinterConfigurer> printer_configurer,
-    PrinterInstallationManager* installation_manager)
+    PrinterInstallationManager* installation_manager,
+    UsbPrinterNotificationController* notification_controller)
     : printer_configurer_(std::move(printer_configurer)),
       installation_manager_(installation_manager),
+      notification_controller_(notification_controller),
       weak_factory_(this) {
   DCHECK(installation_manager);
 }
@@ -85,6 +88,7 @@ void AutomaticUsbPrinterConfigurer::CompleteConfiguration(
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_);
   VLOG(1) << "Auto USB Printer setup successful for " << printer.id();
 
+  notification_controller_->ShowEphemeralNotification(printer);
   printers_.insert(printer.id());
 }
 
@@ -92,6 +96,7 @@ void AutomaticUsbPrinterConfigurer::PruneRemovedPrinters(
     const std::vector<Printer>& automatic_printers) {
   for (auto it = printers_.begin(); it != printers_.end();) {
     if (!IsInAutomaticList(*it, automatic_printers)) {
+      notification_controller_->RemoveNotification(*it);
       it = printers_.erase(it);
     } else {
       ++it;

chrome/browser/chromeos/printing/automatic_usb_printer_configurer.h

@@ -19,11 +19,14 @@
 
 namespace chromeos {
 
+class UsbPrinterNotificationController;
+
 class AutomaticUsbPrinterConfigurer : public CupsPrintersManager::Observer {
  public:
   AutomaticUsbPrinterConfigurer(
-      std::unique_ptr<PrinterConfigurer> printer_configurer_,
-      PrinterInstallationManager* installation_manager);
+      std::unique_ptr<PrinterConfigurer> printer_configurer,
+      PrinterInstallationManager* installation_manager,
+      UsbPrinterNotificationController* notification_controller);
 
   ~AutomaticUsbPrinterConfigurer() override;
 
@@ -54,6 +57,7 @@ class AutomaticUsbPrinterConfigurer : public CupsPrintersManager::Observer {
 
   std::unique_ptr<PrinterConfigurer> printer_configurer_;
   PrinterInstallationManager* installation_manager_;  // Not owned.
+  UsbPrinterNotificationController* notification_controller_;  // Not owned.
   base::flat_set<std::string> printers_;
 
   base::WeakPtrFactory<AutomaticUsbPrinterConfigurer> weak_factory_;

chrome/browser/chromeos/printing/automatic_usb_printer_configurer_unittest.cc

@@ -12,6 +12,7 @@
 #include "base/test/scoped_feature_list.h"
 #include "chrome/browser/chromeos/printing/cups_printers_manager.h"
 #include "chrome/browser/chromeos/printing/printers_map.h"
+#include "chrome/browser/chromeos/printing/usb_printer_notification_controller.h"
 #include "chrome/common/chrome_features.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -127,6 +128,28 @@ class FakePrinterConfigurer : public PrinterConfigurer {
   base::flat_set<std::string> configured_;
 };
 
+class FakeUsbPrinterNotificationController
+    : public UsbPrinterNotificationController {
+ public:
+  FakeUsbPrinterNotificationController() = default;
+  ~FakeUsbPrinterNotificationController() override = default;
+
+  void ShowEphemeralNotification(const Printer& printer) override {
+    open_notifications_.insert(printer.id());
+  }
+
+  void RemoveNotification(const std::string& printer_id) override {
+    open_notifications_.erase(printer_id);
+  }
+
+  bool IsNotification(const std::string& printer_id) const override {
+    return open_notifications_.contains(printer_id);
+  }
+
+ private:
+  base::flat_set<std::string> open_notifications_;
+};
+
 class AutomaticUsbPrinterConfigurerTest : public testing::Test {
  public:
   AutomaticUsbPrinterConfigurerTest() {
@@ -136,10 +159,13 @@ class AutomaticUsbPrinterConfigurerTest : public testing::Test {
         std::make_unique<FakePrinterInstallationManager>();
     auto printer_configurer = std::make_unique<FakePrinterConfigurer>();
     fake_printer_configurer_ = printer_configurer.get();
+    fake_notification_controller_ =
+        std::make_unique<FakeUsbPrinterNotificationController>();
 
     auto_usb_printer_configurer_ =
         std::make_unique<AutomaticUsbPrinterConfigurer>(
-            std::move(printer_configurer), fake_installation_manager_.get());
+            std::move(printer_configurer), fake_installation_manager_.get(),
+            fake_notification_controller_.get());
 
     fake_observable_printers_manager_.SetObserver(
         auto_usb_printer_configurer_.get());
@@ -151,6 +177,8 @@ class AutomaticUsbPrinterConfigurerTest : public testing::Test {
   FakeObservablePrintersManager fake_observable_printers_manager_;
   FakePrinterConfigurer* fake_printer_configurer_;  // not owned.
   std::unique_ptr<FakePrinterInstallationManager> fake_installation_manager_;
+  std::unique_ptr<FakeUsbPrinterNotificationController>
+      fake_notification_controller_;
   std::unique_ptr<AutomaticUsbPrinterConfigurer> auto_usb_printer_configurer_;
 
  private:
@@ -250,4 +278,41 @@ TEST_F(AutomaticUsbPrinterConfigurerTest, UsbPrinterRemovedFromSet) {
   EXPECT_EQ(0u, auto_usb_printer_configurer_->printers_.size());
 }
 
+TEST_F(AutomaticUsbPrinterConfigurerTest, NotificationOpenedForNewAutomatic) {
+  const std::string printer_id = "id";
+  const Printer printer = CreateUsbPrinter(printer_id);
+
+  fake_observable_printers_manager_.AddNearbyAutomaticPrinter(printer);
+
+  EXPECT_TRUE(fake_notification_controller_->IsNotification(printer_id));
+}
+
+TEST_F(AutomaticUsbPrinterConfigurerTest,
+       NotificationOpenedForPreviouslyConfigured) {
+  const std::string printer_id = "id";
+  const Printer printer = CreateUsbPrinter(printer_id);
+
+  // Mark the printer as configured.
+  fake_printer_configurer_->MarkConfigured(printer_id);
+
+  // Even though the printer is already configured, adding the printer should
+  // result in a notification being shown.
+  fake_observable_printers_manager_.AddNearbyAutomaticPrinter(printer);
+
+  EXPECT_TRUE(fake_notification_controller_->IsNotification(printer_id));
+}
+
+TEST_F(AutomaticUsbPrinterConfigurerTest, NotificationClosed) {
+  const std::string printer_id = "id";
+  const Printer printer = CreateUsbPrinter(printer_id);
+
+  fake_observable_printers_manager_.AddNearbyAutomaticPrinter(printer);
+
+  EXPECT_TRUE(fake_notification_controller_->IsNotification(printer_id));
+
+  fake_observable_printers_manager_.RemoveAutomaticPrinter(printer_id);
+
+  EXPECT_FALSE(fake_notification_controller_->IsNotification(printer_id));
+}
+
 }  // namespace chromeos

chrome/browser/chromeos/printing/cups_printers_manager.cc

@@ -27,6 +27,7 @@
 #include "chrome/browser/chromeos/printing/synced_printers_manager.h"
 #include "chrome/browser/chromeos/printing/synced_printers_manager_factory.h"
 #include "chrome/browser/chromeos/printing/usb_printer_detector.h"
+#include "chrome/browser/chromeos/printing/usb_printer_notification_controller.h"
 #include "chrome/browser/chromeos/printing/zeroconf_printer_detector.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
@@ -53,6 +54,8 @@ class CupsPrintersManagerImpl : public CupsPrintersManager,
                           std::unique_ptr<PrinterDetector> zeroconf_detector,
                           scoped_refptr<PpdProvider> ppd_provider,
                           std::unique_ptr<PrinterConfigurer> printer_configurer,
+                          std::unique_ptr<UsbPrinterNotificationController>
+                              usb_notification_controller,
                           PrinterEventTracker* event_tracker,
                           PrefService* pref_service)
       : synced_printers_manager_(synced_printers_manager),
@@ -60,7 +63,10 @@ class CupsPrintersManagerImpl : public CupsPrintersManager,
         usb_detector_(std::move(usb_detector)),
         zeroconf_detector_(std::move(zeroconf_detector)),
         ppd_provider_(std::move(ppd_provider)),
-        auto_usb_printer_configurer_(std::move(printer_configurer), this),
+        usb_notification_controller_(std::move(usb_notification_controller)),
+        auto_usb_printer_configurer_(std::move(printer_configurer),
+                                     this,
+                                     usb_notification_controller_.get()),
         event_tracker_(event_tracker),
         weak_ptr_factory_(this) {
     // Add the |auto_usb_printer_configurer_| as an observer.
@@ -454,6 +460,9 @@ class CupsPrintersManagerImpl : public CupsPrintersManager,
 
   scoped_refptr<PpdProvider> ppd_provider_;
 
+  std::unique_ptr<UsbPrinterNotificationController>
+      usb_notification_controller_;
+
   AutomaticUsbPrinterConfigurer auto_usb_printer_configurer_;
 
   // Not owned
@@ -496,6 +505,7 @@ std::unique_ptr<CupsPrintersManager> CupsPrintersManager::Create(
           profile),
       UsbPrinterDetector::Create(), ZeroconfPrinterDetector::Create(),
       CreatePpdProvider(profile), PrinterConfigurer::Create(profile),
+      UsbPrinterNotificationController::Create(profile),
       PrinterEventTrackerFactory::GetInstance()->GetForBrowserContext(profile),
       profile->GetPrefs());
 }
@@ -507,12 +517,15 @@ std::unique_ptr<CupsPrintersManager> CupsPrintersManager::CreateForTesting(
     std::unique_ptr<PrinterDetector> zeroconf_detector,
     scoped_refptr<PpdProvider> ppd_provider,
     std::unique_ptr<PrinterConfigurer> printer_configurer,
+    std::unique_ptr<UsbPrinterNotificationController>
+        usb_notification_controller,
     PrinterEventTracker* event_tracker,
     PrefService* pref_service) {
   return std::make_unique<CupsPrintersManagerImpl>(
       synced_printers_manager, std::move(usb_detector),
       std::move(zeroconf_detector), std::move(ppd_provider),
-      std::move(printer_configurer), event_tracker, pref_service);
+      std::move(printer_configurer), std::move(usb_notification_controller),
+      event_tracker, pref_service);
 }
 
 // static

chrome/browser/chromeos/printing/cups_printers_manager.h

@@ -28,6 +28,7 @@ class PrinterConfigurer;
 class PrinterDetector;
 class PrinterEventTracker;
 class SyncedPrintersManager;
+class UsbPrinterNotificationController;
 
 // Top level manager of available CUPS printers in ChromeOS.  All functions
 // in this class must be called from a sequenced context.
@@ -59,6 +60,8 @@ class CupsPrintersManager : public PrinterInstallationManager,
       std::unique_ptr<PrinterDetector> zeroconf_printer_detector,
       scoped_refptr<PpdProvider> ppd_provider,
       std::unique_ptr<PrinterConfigurer> printer_configurer,
+      std::unique_ptr<UsbPrinterNotificationController>
+          usb_notification_controller,
       PrinterEventTracker* event_tracker,
       PrefService* pref_service);
 

chrome/browser/chromeos/printing/cups_printers_manager_unittest.cc

@@ -22,6 +22,7 @@
 #include "chrome/browser/chromeos/printing/printers_map.h"
 #include "chrome/browser/chromeos/printing/synced_printers_manager.h"
 #include "chrome/browser/chromeos/printing/usb_printer_detector.h"
+#include "chrome/browser/chromeos/printing/usb_printer_notification_controller.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/common/pref_names.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
@@ -294,6 +295,24 @@ class FakePrinterConfigurer : public PrinterConfigurer {
   base::flat_set<std::string> configured_;
 };
 
+class FakeUsbPrinterNotificationController
+    : public UsbPrinterNotificationController {
+ public:
+  FakeUsbPrinterNotificationController() = default;
+  ~FakeUsbPrinterNotificationController() override = default;
+
+  void ShowEphemeralNotification(const Printer& printer) override {
+    NOTIMPLEMENTED();
+  }
+  void RemoveNotification(const std::string& printer_id) override {
+    NOTIMPLEMENTED();
+  }
+  bool IsNotification(const std::string& printer_id) const override {
+    NOTIMPLEMENTED();
+    return false;
+  }
+};
+
 class CupsPrintersManagerTest : public testing::Test,
                                 public CupsPrintersManager::Observer {
  public:
@@ -308,6 +327,9 @@ class CupsPrintersManagerTest : public testing::Test,
     usb_detector_ = usb_detector.get();
     auto printer_configurer = std::make_unique<FakePrinterConfigurer>();
     printer_configurer_ = printer_configurer.get();
+    auto usb_notif_controller =
+        std::make_unique<FakeUsbPrinterNotificationController>();
+    usb_notif_controller_ = usb_notif_controller.get();
 
     // Register the pref |UserNativePrintersAllowed|
     CupsPrintersManager::RegisterProfilePrefs(pref_service_.registry());
@@ -315,7 +337,8 @@ class CupsPrintersManagerTest : public testing::Test,
     manager_ = CupsPrintersManager::CreateForTesting(
         &synced_printers_manager_, std::move(usb_detector),
         std::move(zeroconf_detector), ppd_provider_,
-        std::move(printer_configurer), &event_tracker_, &pref_service_);
+        std::move(printer_configurer), std::move(usb_notif_controller),
+        &event_tracker_, &pref_service_);
     manager_->AddObserver(this);
   }
 
@@ -354,6 +377,7 @@ class CupsPrintersManagerTest : public testing::Test,
   FakePrinterDetector* usb_detector_;          // Not owned.
   FakePrinterDetector* zeroconf_detector_;     // Not owned.
   FakePrinterConfigurer* printer_configurer_;  // Not owned.
+  FakeUsbPrinterNotificationController* usb_notif_controller_;  // Not owned.
   scoped_refptr<FakePpdProvider> ppd_provider_;
 
   // This is unused, it's just here for memory ownership.

chrome/browser/chromeos/printing/usb_printer_notification.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/usb_printer_notification.h"
+
+#include "ash/public/cpp/notification_utils.h"
+#include "ash/public/cpp/vector_icons/vector_icons.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/notifications/notification_display_service.h"
+#include "chrome/browser/notifications/notification_handler.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/gfx/image/image.h"
+#include "ui/message_center/public/cpp/notification.h"
+#include "ui/message_center/public/cpp/notification_types.h"
+#include "url/gurl.h"
+
+namespace chromeos {
+
+namespace {
+
+const char kNotifierId[] = "printing.usb_printer";
+
+}  // namespace
+
+UsbPrinterNotification::UsbPrinterNotification(
+    const Printer& printer,
+    const std::string& notification_id,
+    Type type,
+    Profile* profile)
+    : printer_(printer),
+      notification_id_(notification_id),
+      type_(type),
+      profile_(profile),
+      weak_factory_(this) {
+  message_center::RichNotificationData rich_notification_data;
+  rich_notification_data.vector_small_image = &ash::kNotificationPrintingIcon;
+  rich_notification_data.accent_color = ash::kSystemNotificationColorNormal;
+
+  notification_ = std::make_unique<message_center::Notification>(
+      message_center::NOTIFICATION_TYPE_SIMPLE, notification_id_,
+      base::string16(),  // title
+      base::string16(),  // body
+      gfx::Image(),      // icon
+      l10n_util::GetStringUTF16(IDS_PRINT_JOB_NOTIFICATION_DISPLAY_SOURCE),
+      GURL(),  // origin_url
+      message_center::NotifierId(message_center::NotifierType::SYSTEM_COMPONENT,
+                                 kNotifierId),
+      rich_notification_data,
+      base::MakeRefCounted<message_center::ThunkNotificationDelegate>(
+          weak_factory_.GetWeakPtr()));
+
+  UpdateContents();
+
+  ShowNotification();
+}
+
+UsbPrinterNotification::~UsbPrinterNotification() = default;
+
+void UsbPrinterNotification::CloseNotification() {
+  NotificationDisplayService* display_service =
+      NotificationDisplayService::GetForProfile(profile_);
+  display_service->Close(NotificationHandler::Type::TRANSIENT,
+                         notification_id_);
+}
+
+void UsbPrinterNotification::Close(bool by_user) {
+  visible_ = false;
+}
+
+void UsbPrinterNotification::Click(
+    const base::Optional<int>& button_index,
+    const base::Optional<base::string16>& reply) {
+  if (!button_index) {
+    // Body of notification clicked.
+    visible_ = false;
+    return;
+  }
+
+  NOTREACHED();
+}
+
+void UsbPrinterNotification::ShowNotification() {
+  NotificationDisplayService* display_service =
+      NotificationDisplayService::GetForProfile(profile_);
+  display_service->Display(NotificationHandler::Type::TRANSIENT, *notification_,
+                           /*metadata=*/nullptr);
+  visible_ = true;
+}
+
+void UsbPrinterNotification::UpdateContents() {
+  switch (type_) {
+    case Type::kEphemeral:
+      notification_->set_title(l10n_util::GetStringUTF16(
+          IDS_USB_PRINTER_NOTIFICATION_CONNECTED_TITLE));
+      notification_->set_message(l10n_util::GetStringFUTF16(
+          IDS_USB_PRINTER_NOTIFICATION_CONNECTED_MESSAGE,
+          base::UTF8ToUTF16(printer_.display_name())));
+      return;
+  }
+  NOTREACHED();
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/usb_printer_notification.h

+// 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_PRINTING_USB_PRINTER_NOTIFICATION_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_USB_PRINTER_NOTIFICATION_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/memory/weak_ptr.h"
+#include "chrome/browser/chromeos/printing/printer_configurer.h"
+#include "ui/message_center/public/cpp/notification_delegate.h"
+
+class Profile;
+
+namespace message_center {
+class Notification;
+}
+
+namespace chromeos {
+
+// UsbPrinterNotification is used to update the notification of a print job
+// according to its state and respond to the user's action.
+class UsbPrinterNotification : public message_center::NotificationObserver {
+ public:
+  enum class Type { kEphemeral };
+
+  UsbPrinterNotification(const Printer& printer,
+                         const std::string& notification_id,
+                         Type type,
+                         Profile* profile);
+
+  virtual ~UsbPrinterNotification();
+
+  // Closes the notification, removing it from the notification tray.
+  void CloseNotification();
+
+  // message_center::NotificationObserver
+  void Close(bool by_user) override;
+  void Click(const base::Optional<int>& button_index,
+             const base::Optional<base::string16>& reply) override;
+
+ private:
+  void UpdateContents();
+
+  void ShowNotification();
+
+  const Printer printer_;
+  std::string notification_id_;
+  Type type_;
+  Profile* profile_;  // Not owned.
+  std::unique_ptr<message_center::Notification> notification_;
+  bool visible_;
+
+  base::WeakPtrFactory<UsbPrinterNotification> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(UsbPrinterNotification);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_USB_PRINTER_NOTIFICATION_H_

chrome/browser/chromeos/printing/usb_printer_notification_controller.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/usb_printer_notification_controller.h"
+
+#include "base/feature_list.h"
+#include "base/stl_util.h"
+#include "base/strings/stringprintf.h"
+#include "chrome/common/chrome_features.h"
+
+namespace chromeos {
+
+class UsbPrinterNotificationControllerImpl
+    : public UsbPrinterNotificationController {
+ public:
+  explicit UsbPrinterNotificationControllerImpl(Profile* profile)
+      : profile_(profile) {}
+  ~UsbPrinterNotificationControllerImpl() override = default;
+
+  void ShowEphemeralNotification(const Printer& printer) override {
+    if (!base::FeatureList::IsEnabled(features::kStreamlinedUsbPrinterSetup)) {
+      return;
+    }
+
+    if (base::ContainsKey(notifications_, printer.id())) {
+      return;
+    }
+
+    notifications_[printer.id()] = std::make_unique<UsbPrinterNotification>(
+        printer, GetUniqueNotificationId(),
+        UsbPrinterNotification::Type::kEphemeral, profile_);
+  }
+
+  void RemoveNotification(const std::string& printer_id) override {
+    if (!base::ContainsKey(notifications_, printer_id)) {
+      return;
+    }
+    notifications_[printer_id]->CloseNotification();
+    notifications_.erase(printer_id);
+  }
+
+  bool IsNotification(const std::string& printer_id) const override {
+    return base::ContainsKey(notifications_, printer_id);
+  }
+
+ private:
+  std::string GetUniqueNotificationId() {
+    return base::StringPrintf("usb_printer_notification_%d",
+                              next_notification_id_++);
+  }
+
+  std::map<std::string, std::unique_ptr<UsbPrinterNotification>> notifications_;
+  Profile* profile_;
+  int next_notification_id_ = 0;
+};
+
+std::unique_ptr<UsbPrinterNotificationController>
+UsbPrinterNotificationController::Create(Profile* profile) {
+  return std::make_unique<UsbPrinterNotificationControllerImpl>(profile);
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/usb_printer_notification_controller.h

+// 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_PRINTING_USB_PRINTER_NOTIFICATION_CONTROLLER_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_USB_PRINTER_NOTIFICATION_CONTROLLER_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "chrome/browser/chromeos/printing/usb_printer_notification.h"
+
+class Profile;
+
+namespace chromeos {
+
+class Printer;
+
+class UsbPrinterNotificationController {
+ public:
+  static std::unique_ptr<UsbPrinterNotificationController> Create(
+      Profile* profile);
+
+  virtual ~UsbPrinterNotificationController() = default;
+
+  // Creates a notification for an ephemeral printer. This is a no-op if there
+  // is already an existing notification for |printer|.
+  virtual void ShowEphemeralNotification(const Printer& printer) = 0;
+
+  // Closes the notification for |printer_id|. This is a no-op if the
+  // notification has already been closed by the user.
+  virtual void RemoveNotification(const std::string& printer_id) = 0;
+
+  // Returns true if there is an existing notification for |printer_id|.
+  virtual bool IsNotification(const std::string& printer_id) const = 0;
+
+ protected:
+  UsbPrinterNotificationController() = default;
+
+  DISALLOW_COPY_AND_ASSIGN(UsbPrinterNotificationController);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_USB_PRINTER_NOTIFICATION_CONTROLLER_H_