Record the printer removal PrinterEvent.

This CL implements the infrastructure for logging PrinterEventProtos. Only
removals are logged right now.  Successful setup and setup abandonment will
be added in follow up CLs.

Bug: 647283
Change-Id: I9b3dbd37ee0db486d1c55686f729f65009d03cb8
Reviewed-on: https://chromium-review.googlesource.com/590584
Commit-Queue: Sean Kau <skau@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Reviewed-by: Steven Holte <holte@chromium.org>
Reviewed-by: Xiaoqian Dai <xdai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#491222}

chrome/browser/chromeos/BUILD.gn

@@ -89,6 +89,7 @@ source_set("chromeos") {
     "//components/login",
     "//components/metrics:serialization",
     "//components/metrics/leak_detector",
+    "//components/metrics/proto",
     "//components/onc",
     "//components/ownership",
     "//components/pairing",
@@ -1337,7 +1338,13 @@ source_set("chromeos") {
     "printing/printer_configurer.cc",
     "printing/printer_configurer.h",
     "printing/printer_detector.h",
+    "printing/printer_event_tracker.cc",
+    "printing/printer_event_tracker.h",
+    "printing/printer_event_tracker_factory.cc",
+    "printing/printer_event_tracker_factory.h",
     "printing/printer_info.h",
+    "printing/printer_metrics_provider.cc",
+    "printing/printer_metrics_provider.h",
     "printing/printers_sync_bridge.cc",
     "printing/printers_sync_bridge.h",
     "printing/specifics_translation.cc",
@@ -1861,6 +1868,7 @@ source_set("unit_tests") {
     "power/renderer_freezer_unittest.cc",
     "preferences_unittest.cc",
     "printing/combining_printer_detector_unittest.cc",
+    "printing/printer_event_tracker_unittest.cc",
     "printing/specifics_translation_unittest.cc",
     "printing/synced_printers_manager_unittest.cc",
     "profiles/profile_list_chromeos_unittest.cc",

chrome/browser/chromeos/printing/printer_event_tracker.cc

+// 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.
+
+#include "chrome/browser/chromeos/printing/printer_event_tracker.h"
+
+#include "components/keyed_service/core/keyed_service.h"
+#include "components/metrics/proto/printer_event.pb.h"
+
+namespace chromeos {
+namespace {
+
+// Set the event_type on |event| based on |mode|.
+void SetEventType(metrics::PrinterEventProto* event,
+                  PrinterEventTracker::SetupMode mode) {
+  switch (mode) {
+    case PrinterEventTracker::kUser:
+      event->set_event_type(metrics::PrinterEventProto::SETUP_MANUAL);
+      break;
+    case PrinterEventTracker::kAutomatic:
+      event->set_event_type(metrics::PrinterEventProto::SETUP_AUTOMATIC);
+      break;
+  }
+}
+
+// Populate PPD information in |event| based on |ppd|.
+void SetPpdInfo(metrics::PrinterEventProto* event,
+                const Printer::PpdReference& ppd) {
+  if (!ppd.user_supplied_ppd_url.empty()) {
+    event->set_user_ppd(true);
+  } else if (!ppd.effective_make_and_model.empty()) {
+    event->set_ppd_identifier(ppd.effective_make_and_model);
+  }
+  // PPD information is not populated for autoconfigured printers.
+}
+
+// Add information to |event| specific to |usb_printer|.
+void SetUsbInfo(metrics::PrinterEventProto* event,
+                const UsbPrinter& usb_printer) {
+  event->set_usb_vendor_id(usb_printer.vendor_id);
+  event->set_usb_model_id(usb_printer.model_id);
+  event->set_usb_printer_manufacturer(usb_printer.manufacturer);
+  event->set_usb_printer_model(usb_printer.model);
+}
+
+// Add information to the |event| that only network printers have.
+void SetNetworkPrinterInfo(metrics::PrinterEventProto* event,
+                           const Printer& printer) {
+  if (!printer.make_and_model().empty()) {
+    event->set_ipp_make_and_model(printer.make_and_model());
+  }
+}
+
+}  // namespace
+
+UsbPrinter::UsbPrinter() = default;
+UsbPrinter::~UsbPrinter() = default;
+
+PrinterEventTracker::PrinterEventTracker() = default;
+PrinterEventTracker::~PrinterEventTracker() = default;
+
+void PrinterEventTracker::set_logging(bool logging) {
+  logging_ = logging;
+}
+
+void PrinterEventTracker::RecordUsbPrinterInstalled(
+    const UsbPrinter& usb_printer,
+    SetupMode mode) {
+  if (!logging_) {
+    return;
+  }
+
+  const Printer& printer = usb_printer.printer;
+  metrics::PrinterEventProto event;
+  SetEventType(&event, mode);
+  SetPpdInfo(&event, printer.ppd_reference());
+  SetUsbInfo(&event, usb_printer);
+  events_.push_back(event);
+}
+
+void PrinterEventTracker::RecordIppPrinterInstalled(const Printer& printer,
+                                                    SetupMode mode) {
+  if (!logging_) {
+    return;
+  }
+
+  metrics::PrinterEventProto event;
+  SetEventType(&event, mode);
+  SetPpdInfo(&event, printer.ppd_reference());
+  SetNetworkPrinterInfo(&event, printer);
+  events_.push_back(event);
+}
+
+void PrinterEventTracker::RecordUsbSetupAbandoned(const UsbPrinter& printer) {
+  if (!logging_) {
+    return;
+  }
+
+  metrics::PrinterEventProto event;
+  event.set_event_type(metrics::PrinterEventProto::SETUP_ABANDONED);
+  SetUsbInfo(&event, printer);
+  events_.push_back(event);
+}
+
+void PrinterEventTracker::RecordSetupAbandoned(const Printer& printer) {
+  if (!logging_) {
+    return;
+  }
+
+  metrics::PrinterEventProto event;
+  event.set_event_type(metrics::PrinterEventProto::SETUP_ABANDONED);
+  SetNetworkPrinterInfo(&event, printer);
+  events_.push_back(event);
+}
+
+void PrinterEventTracker::RecordPrinterRemoved(const Printer& printer) {
+  if (!logging_) {
+    return;
+  }
+
+  metrics::PrinterEventProto event;
+  event.set_event_type(metrics::PrinterEventProto::PRINTER_DELETED);
+  SetNetworkPrinterInfo(&event, printer);
+  SetPpdInfo(&event, printer.ppd_reference());
+  events_.push_back(event);
+}
+
+void PrinterEventTracker::FlushPrinterEvents(
+    std::vector<metrics::PrinterEventProto>* events) {
+  events->swap(events_);
+  events_.clear();
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/printer_event_tracker.h

+// 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_CHROMEOS_PRINTING_PRINTER_EVENT_TRACKER_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_PRINTER_EVENT_TRACKER_H_
+
+#include "base/macros.h"
+#include "chromeos/printing/printer_configuration.h"
+#include "components/keyed_service/core/keyed_service.h"
+#include "components/metrics/proto/printer_event.pb.h"
+
+namespace chromeos {
+
+struct UsbPrinter {
+  UsbPrinter();
+  ~UsbPrinter();
+
+  // USB MFG string
+  std::string manufacturer;
+  // USB MDL string
+  std::string model;
+  // IEEE1284 Vendor ID
+  int32_t vendor_id;
+  // IEEE1284 Product ID
+  int32_t model_id;
+  // Printer configuration
+  Printer printer;
+};
+
+// Aggregates printer events for logging.
+class PrinterEventTracker : public KeyedService {
+ public:
+  enum SetupMode {
+    // Device configured by the user.
+    kUser,
+    // Configuration detected by the system.
+    kAutomatic
+  };
+
+  PrinterEventTracker();
+  ~PrinterEventTracker() override;
+
+  // If |logging| is true, logging is enabled. If |logging| is false, logging is
+  // disabled and the Record* functions are nops.
+  void set_logging(bool logging);
+
+  // Store a succesful USB printer installation. |mode| indicates if
+  // the PPD was selected automatically or chosen by the user.
+  void RecordUsbPrinterInstalled(const UsbPrinter& printer, SetupMode mode);
+
+  // Store a succesful network printer installation. |mode| indicates if
+  // the PPD was selected automatically or chosen by the user.
+  void RecordIppPrinterInstalled(const Printer& printer, SetupMode mode);
+
+  // Record an abandoned setup.
+  void RecordSetupAbandoned(const Printer& printer);
+
+  // Record an abandoned setup for a USB printer.
+  void RecordUsbSetupAbandoned(const UsbPrinter& printer);
+
+  // Store a printer removal.
+  void RecordPrinterRemoved(const Printer& printer);
+
+  // Writes stored events to |events|.
+  void FlushPrinterEvents(std::vector<metrics::PrinterEventProto>* events);
+
+ private:
+  // Records logs if true.  Discards logs if false.
+  bool logging_;
+  std::vector<metrics::PrinterEventProto> events_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrinterEventTracker);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_PRINTER_EVENT_TRACKER_H_

chrome/browser/chromeos/printing/printer_event_tracker_factory.cc

+// 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.
+
+#include "chrome/browser/chromeos/printing/printer_event_tracker_factory.h"
+
+#include "base/lazy_instance.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/printing/printer_event_tracker.h"
+#include "chrome/browser/profiles/incognito_helpers.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+namespace chromeos {
+namespace {
+base::LazyInstance<PrinterEventTrackerFactory>::DestructorAtExit
+    g_printer_tracker = LAZY_INSTANCE_INITIALIZER;
+}  // namespace
+
+// static
+PrinterEventTrackerFactory* PrinterEventTrackerFactory::GetInstance() {
+  return g_printer_tracker.Pointer();
+}
+
+// static
+PrinterEventTracker* PrinterEventTrackerFactory::GetForBrowserContext(
+    content::BrowserContext* browser_context) {
+  return static_cast<PrinterEventTracker*>(
+      GetInstance()->GetServiceForBrowserContext(browser_context, true));
+}
+
+PrinterEventTrackerFactory::PrinterEventTrackerFactory()
+    : BrowserContextKeyedServiceFactory(
+          "PrinterEventTracker",
+          BrowserContextDependencyManager::GetInstance()) {}
+PrinterEventTrackerFactory::~PrinterEventTrackerFactory() = default;
+
+void PrinterEventTrackerFactory::SetLogging(bool enabled) {
+  logging_enabled_ = enabled;
+  std::vector<Profile*> profiles =
+      g_browser_process->profile_manager()->GetLoadedProfiles();
+  for (Profile* profile : profiles) {
+    auto* tracker = static_cast<PrinterEventTracker*>(
+        GetServiceForBrowserContext(profile, false));
+    if (tracker) {
+      tracker->set_logging(logging_enabled_);
+    }
+  }
+}
+
+// BrowserContextKeyedServiceFactory:
+KeyedService* PrinterEventTrackerFactory::BuildServiceInstanceFor(
+    content::BrowserContext* context) const {
+  PrinterEventTracker* tracker = new PrinterEventTracker();
+  tracker->set_logging(logging_enabled_);
+  return tracker;
+}
+
+content::BrowserContext* PrinterEventTrackerFactory::GetBrowserContextToUse(
+    content::BrowserContext* context) const {
+  return chrome::GetBrowserContextOwnInstanceInIncognito(context);
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/printer_event_tracker_factory.h

+// 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_CHROMEOS_PRINTING_PRINTER_EVENT_TRACKER_FACTORY_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_PRINTER_EVENT_TRACKER_FACTORY_H_
+
+#include "base/macros.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+namespace chromeos {
+
+class PrinterEventTracker;
+
+class PrinterEventTrackerFactory : public BrowserContextKeyedServiceFactory {
+ public:
+  static PrinterEventTrackerFactory* GetInstance();
+  static PrinterEventTracker* GetForBrowserContext(
+      content::BrowserContext* browser_context);
+
+  PrinterEventTrackerFactory();
+  ~PrinterEventTrackerFactory() override;
+
+  // Enables/Disables logging for all trackers. Trackers created in the future
+  // are created with the current logging state. Logging is enabled if |enabled|
+  // is true.
+  void SetLogging(bool enabled);
+
+ private:
+  bool logging_enabled_ = true;
+
+  // BrowserContextKeyedServiceFactory:
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const override;
+  content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const override;
+
+  DISALLOW_COPY_AND_ASSIGN(PrinterEventTrackerFactory);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_PRINTER_EVENT_TRACKER_FACTORY_H_

chrome/browser/chromeos/printing/printer_event_tracker_unittest.cc

+// 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.
+
+#include "chrome/browser/chromeos/printing/printer_event_tracker.h"
+
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "chromeos/printing/printer_configuration.h"
+#include "components/metrics/proto/printer_event.pb.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace {
+
+constexpr int kVendorId = 0x3241;
+constexpr int kProductId = 0x1337;
+constexpr char kUsbManufacturer[] = "Usb MakesPrinters";
+constexpr char kUsbModel[] = "Printer ModelName";
+
+constexpr char kMakeAndModel[] = "Chromium RazLazer X4321er";
+constexpr char kEffectiveMakeAndModel[] = "Generic PostScript";
+
+class PrinterEventTrackerTest : public testing::Test {
+ public:
+  PrinterEventTrackerTest() = default;
+  ~PrinterEventTrackerTest() override = default;
+
+  // testing::Test overrides:
+  void SetUp() override {
+    // By default, turn recording on.
+    tracker_.set_logging(true);
+  }
+
+ protected:
+  PrinterEventTracker tracker_;
+
+  // Returns a copy of the first element recorded by the tracker.  Calls Flush
+  // on the |tracker_|.
+  std::vector<metrics::PrinterEventProto> GetEvents() {
+    std::vector<metrics::PrinterEventProto> events;
+    tracker_.FlushPrinterEvents(&events);
+    return events;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PrinterEventTrackerTest);
+};
+
+TEST_F(PrinterEventTrackerTest, RecordsWhenEnabled) {
+  tracker_.set_logging(true);
+
+  Printer test_printer;
+  test_printer.set_make_and_model(kMakeAndModel);
+  test_printer.mutable_ppd_reference()->effective_make_and_model =
+      kEffectiveMakeAndModel;
+
+  tracker_.RecordIppPrinterInstalled(test_printer, PrinterEventTracker::kUser);
+
+  auto events = GetEvents();
+  EXPECT_EQ(1U, events.size());
+}
+
+TEST_F(PrinterEventTrackerTest, DoesNotRecordWhileDisabled) {
+  tracker_.set_logging(false);
+
+  Printer test_printer;
+  test_printer.set_make_and_model(kMakeAndModel);
+  test_printer.mutable_ppd_reference()->effective_make_and_model =
+      kEffectiveMakeAndModel;
+
+  tracker_.RecordIppPrinterInstalled(test_printer,
+                                     PrinterEventTracker::kAutomatic);
+
+  auto events = GetEvents();
+  EXPECT_TRUE(events.empty());
+}
+
+TEST_F(PrinterEventTrackerTest, InstalledIppPrinter) {
+  Printer test_printer;
+  test_printer.set_make_and_model(kMakeAndModel);
+  test_printer.mutable_ppd_reference()->effective_make_and_model =
+      kEffectiveMakeAndModel;
+
+  tracker_.RecordIppPrinterInstalled(test_printer, PrinterEventTracker::kUser);
+
+  auto events = GetEvents();
+  ASSERT_FALSE(events.empty());
+  metrics::PrinterEventProto recorded_event = events.front();
+  EXPECT_EQ(metrics::PrinterEventProto::SETUP_MANUAL,
+            recorded_event.event_type());
+  EXPECT_EQ(kMakeAndModel, recorded_event.ipp_make_and_model());
+  EXPECT_EQ(kEffectiveMakeAndModel, recorded_event.ppd_identifier());
+
+  EXPECT_FALSE(recorded_event.has_usb_printer_manufacturer());
+  EXPECT_FALSE(recorded_event.has_usb_printer_model());
+  EXPECT_FALSE(recorded_event.has_usb_vendor_id());
+  EXPECT_FALSE(recorded_event.has_usb_model_id());
+  EXPECT_FALSE(recorded_event.user_ppd());
+}
+
+TEST_F(PrinterEventTrackerTest, InstalledPrinterAuto) {
+  Printer test_printer;
+  test_printer.set_make_and_model(kMakeAndModel);
+  test_printer.mutable_ppd_reference()->autoconf = true;
+
+  tracker_.RecordIppPrinterInstalled(
+      test_printer, PrinterEventTracker::SetupMode::kAutomatic);
+
+  auto events = GetEvents();
+  ASSERT_FALSE(events.empty());
+
+  metrics::PrinterEventProto recorded_event = events.front();
+  EXPECT_EQ(metrics::PrinterEventProto::SETUP_AUTOMATIC,
+            recorded_event.event_type());
+  EXPECT_EQ(kMakeAndModel, recorded_event.ipp_make_and_model());
+  // For autoconf printers, ppd identifier is blank but a successful setup is
+  // recorded.
+  EXPECT_FALSE(recorded_event.has_ppd_identifier());
+
+  EXPECT_FALSE(recorded_event.has_usb_printer_manufacturer());
+  EXPECT_FALSE(recorded_event.has_usb_printer_model());
+  EXPECT_FALSE(recorded_event.has_usb_vendor_id());
+  EXPECT_FALSE(recorded_event.has_usb_model_id());
+  EXPECT_FALSE(recorded_event.user_ppd());
+}
+
+TEST_F(PrinterEventTrackerTest, InstalledPrinterUserPpd) {
+  Printer test_printer;
+  test_printer.mutable_ppd_reference()->user_supplied_ppd_url =
+      "file:///i_dont_record_this_field/blah/blah/blah/some_ppd.ppd";
+
+  tracker_.RecordIppPrinterInstalled(test_printer,
+                                     PrinterEventTracker::SetupMode::kUser);
+
+  auto events = GetEvents();
+  ASSERT_FALSE(events.empty());
+
+  metrics::PrinterEventProto recorded_event = events.front();
+  EXPECT_EQ(metrics::PrinterEventProto::SETUP_MANUAL,
+            recorded_event.event_type());
+
+  // For user PPDs we just record that it was a user PPD, the value is not
+  // recorded.
+  EXPECT_TRUE(recorded_event.user_ppd());
+  EXPECT_FALSE(recorded_event.has_ppd_identifier());
+
+  // This is empty if it was not detected.
+  EXPECT_FALSE(recorded_event.has_ipp_make_and_model());
+
+  // Network printers do not have usb information.
+  EXPECT_FALSE(recorded_event.has_usb_printer_manufacturer());
+  EXPECT_FALSE(recorded_event.has_usb_printer_model());
+  EXPECT_FALSE(recorded_event.has_usb_vendor_id());
+  EXPECT_FALSE(recorded_event.has_usb_model_id());
+}
+
+TEST_F(PrinterEventTrackerTest, InstalledUsbPrinter) {
+  Printer test_printer;
+  test_printer.mutable_ppd_reference()->effective_make_and_model =
+      kEffectiveMakeAndModel;
+
+  UsbPrinter usb_printer;
+  usb_printer.vendor_id = kVendorId;
+  usb_printer.model_id = kProductId;
+  usb_printer.manufacturer = kUsbManufacturer;
+  usb_printer.model = kUsbModel;
+  usb_printer.printer = test_printer;
+
+  tracker_.RecordUsbPrinterInstalled(usb_printer,
+                                     PrinterEventTracker::SetupMode::kUser);
+
+  auto events = GetEvents();
+  ASSERT_FALSE(events.empty());
+
+  metrics::PrinterEventProto record = events.front();
+  EXPECT_EQ(metrics::PrinterEventProto::SETUP_MANUAL, record.event_type());
+  EXPECT_EQ(kVendorId, record.usb_vendor_id());
+  EXPECT_EQ(kProductId, record.usb_model_id());
+  EXPECT_EQ(kUsbManufacturer, record.usb_printer_manufacturer());
+  EXPECT_EQ(kUsbModel, record.usb_printer_model());
+
+  EXPECT_EQ(kEffectiveMakeAndModel, record.ppd_identifier());
+  EXPECT_FALSE(record.user_ppd());
+
+  // USB doesn't detect this field.
+  EXPECT_FALSE(record.has_ipp_make_and_model());
+}
+
+TEST_F(PrinterEventTrackerTest, AbandonedNetworkPrinter) {
+  Printer test_printer;
+  test_printer.set_make_and_model(kMakeAndModel);
+
+  tracker_.RecordSetupAbandoned(test_printer);
+
+  auto events = GetEvents();
+  ASSERT_FALSE(events.empty());
+
+  metrics::PrinterEventProto recorded_event = events.front();
+  EXPECT_EQ(metrics::PrinterEventProto::SETUP_ABANDONED,
+            recorded_event.event_type());
+  EXPECT_EQ(kMakeAndModel, recorded_event.ipp_make_and_model());
+
+  // Abandoned setups should not record a chosen PPD or user PPD.
+  EXPECT_FALSE(recorded_event.has_user_ppd());
+  EXPECT_FALSE(recorded_event.has_ppd_identifier());
+
+  EXPECT_FALSE(recorded_event.has_usb_printer_manufacturer());
+  EXPECT_FALSE(recorded_event.has_usb_printer_model());
+  EXPECT_FALSE(recorded_event.has_usb_vendor_id());
+  EXPECT_FALSE(recorded_event.has_usb_model_id());
+}
+
+TEST_F(PrinterEventTrackerTest, AbandonedUsbPrinter) {
+  UsbPrinter usb_printer;
+  usb_printer.vendor_id = kVendorId;
+  usb_printer.model_id = kProductId;
+  usb_printer.manufacturer = kUsbManufacturer;
+  usb_printer.model = kUsbModel;
+
+  tracker_.RecordUsbSetupAbandoned(usb_printer);
+
+  auto events = GetEvents();
+  ASSERT_FALSE(events.empty());
+
+  metrics::PrinterEventProto record = events.front();
+  EXPECT_EQ(metrics::PrinterEventProto::SETUP_ABANDONED, record.event_type());
+  EXPECT_EQ(kVendorId, record.usb_vendor_id());
+  EXPECT_EQ(kProductId, record.usb_model_id());
+  EXPECT_EQ(kUsbManufacturer, record.usb_printer_manufacturer());
+  EXPECT_EQ(kUsbModel, record.usb_printer_model());
+
+  EXPECT_FALSE(record.has_user_ppd());
+  EXPECT_FALSE(record.has_ppd_identifier());
+}
+
+TEST_F(PrinterEventTrackerTest, RemovedPrinter) {
+  Printer test_printer;
+  test_printer.set_make_and_model(kMakeAndModel);
+  test_printer.mutable_ppd_reference()->effective_make_and_model =
+      kEffectiveMakeAndModel;
+
+  tracker_.RecordPrinterRemoved(test_printer);
+
+  auto events = GetEvents();
+  ASSERT_FALSE(events.empty());
+
+  metrics::PrinterEventProto recorded_event = events.front();
+  EXPECT_EQ(metrics::PrinterEventProto::PRINTER_DELETED,
+            recorded_event.event_type());
+  // All printers record make and model information here.
+  EXPECT_EQ(kMakeAndModel, recorded_event.ipp_make_and_model());
+
+  // PPD info.
+  EXPECT_EQ(kEffectiveMakeAndModel, recorded_event.ppd_identifier());
+  EXPECT_FALSE(recorded_event.user_ppd());
+
+  // USB Info is not retained for removed printers.
+  EXPECT_FALSE(recorded_event.has_usb_printer_manufacturer());
+  EXPECT_FALSE(recorded_event.has_usb_printer_model());
+  EXPECT_FALSE(recorded_event.has_usb_vendor_id());
+  EXPECT_FALSE(recorded_event.has_usb_model_id());
+}
+
+}  // namespace
+}  // namespace chromeos

chrome/browser/chromeos/printing/printer_metrics_provider.cc

+// 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.
+
+#include "chrome/browser/chromeos/printing/printer_metrics_provider.h"
+
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/printing/printer_event_tracker.h"
+#include "chrome/browser/chromeos/printing/printer_event_tracker_factory.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
+#include "components/metrics/proto/printer_event.pb.h"
+
+namespace chromeos {
+
+PrinterMetricsProvider::PrinterMetricsProvider() = default;
+PrinterMetricsProvider::~PrinterMetricsProvider() = default;
+
+void PrinterMetricsProvider::OnRecordingEnabled() {
+  PrinterEventTrackerFactory::GetInstance()->SetLogging(true);
+}
+
+void PrinterMetricsProvider::OnRecordingDisabled() {
+  PrinterEventTrackerFactory::GetInstance()->SetLogging(false);
+}
+
+void PrinterMetricsProvider::ProvideCurrentSessionData(
+    metrics::ChromeUserMetricsExtension* uma_proto) {
+  PrinterEventTrackerFactory* factory =
+      PrinterEventTrackerFactory::GetInstance();
+  std::vector<Profile*> profiles =
+      g_browser_process->profile_manager()->GetLoadedProfiles();
+  std::vector<metrics::PrinterEventProto> events;
+  for (Profile* profile : profiles) {
+    factory->GetForBrowserContext(profile)->FlushPrinterEvents(&events);
+
+    for (metrics::PrinterEventProto& event : events) {
+      uma_proto->add_printer_event()->Swap(&event);
+    }
+    events.clear();
+  }
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/printer_metrics_provider.h

+// 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_CHROMEOS_PRINTING_PRINTER_METRICS_PROVIDER_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_PRINTER_METRICS_PROVIDER_H_
+
+#include "base/macros.h"
+#include "components/metrics/metrics_provider.h"
+
+namespace metrics {
+class ChromeUserMetricsExtension;
+}  // namespace metrics
+
+namespace chromeos {
+
+class PrinterMetricsProvider : public metrics::MetricsProvider {
+ public:
+  PrinterMetricsProvider();
+  ~PrinterMetricsProvider() override;
+
+  // metrics::MetricsProvider overrides:
+  void OnRecordingEnabled() override;
+  void OnRecordingDisabled() override;
+  void ProvideCurrentSessionData(
+      metrics::ChromeUserMetricsExtension* uma_proto) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PrinterMetricsProvider);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_PRINTER_METRICS_PROVIDER_H_

chrome/browser/metrics/chrome_metrics_service_client.cc

@@ -114,6 +114,7 @@
 #endif
 
 #if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/printing/printer_metrics_provider.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/metrics/chromeos_metrics_provider.h"
 #include "chrome/browser/signin/signin_status_metrics_provider_chromeos.h"
@@ -643,6 +644,9 @@ void ChromeMetricsServiceClient::RegisterMetricsServiceProviders() {
     metrics::RecordMetricsReportingDefaultState(
         local_state, metrics::EnableMetricsDefault::OPT_OUT);
   }
+
+  metrics_service_->RegisterMetricsProvider(
+      base::MakeUnique<chromeos::PrinterMetricsProvider>());
 #endif  // defined(OS_CHROMEOS)
 
 #if !defined(OS_CHROMEOS)

chrome/browser/ui/webui/settings/chromeos/cups_printers_handler.cc

@@ -20,6 +20,8 @@
 #include "chrome/browser/chromeos/printing/combining_printer_detector.h"
 #include "chrome/browser/chromeos/printing/ppd_provider_factory.h"
 #include "chrome/browser/chromeos/printing/printer_configurer.h"
+#include "chrome/browser/chromeos/printing/printer_event_tracker.h"
+#include "chrome/browser/chromeos/printing/printer_event_tracker_factory.h"
 #include "chrome/browser/chromeos/printing/printer_info.h"
 #include "chrome/browser/chromeos/printing/synced_printers_manager_factory.h"
 #include "chrome/browser/chromeos/printing/usb_printer_detector.h"
@@ -223,7 +225,12 @@ void CupsPrintersHandler::HandleRemoveCupsPrinter(const base::ListValue* args) {
   if (!printer)
     return;
 
+  // Record removal before the printer is deleted.
+  chromeos::PrinterEventTrackerFactory::GetForBrowserContext(profile_)
+      ->RecordPrinterRemoved(*printer);
+
   Printer::PrinterProtocol protocol = printer->GetProtocol();
+  // Printer is deleted here.  Do not access after this line.
   prefs->RemoveConfiguredPrinter(printer_id);
 
   DebugDaemonClient* client = DBusThreadManager::Get()->GetDebugDaemonClient();