Printing API: Add chrome.printing API setup and event implementation

This CL adds:
* chrome.printing API setup including new "printing" permission and
printing.idl API description,
* One event: OnJobStatusChanged() and its implementation,
* Unit tests for this event,
* New print job source: EXTENSION. It's not used in print job creation
yet but is required for correct implementation of the event.

This CL doesn't add any API test since it's impossible yet to create
print job via API. API test covering this event will be added together
with submitJob() function implementation in follow-up CL.

Bug: 996785
Change-Id: I1708631caffdde2395a3d07f2ea7de392d09a63f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1824948Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Devlin <rdevlin.cronin@chromium.org>
Reviewed-by: Sean Kau <skau@chromium.org>
Commit-Queue: Nikita Podguzov <nikitapodguzov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#710698}

chrome/browser/chromeos/BUILD.gn

@@ -2273,6 +2273,8 @@ source_set("chromeos") {
     "extensions/login_screen/login_state/session_state_changed_event_dispatcher.h",
     "extensions/media_player_api.cc",
     "extensions/media_player_api.h",
+    "extensions/printing/printing_api_handler.cc",
+    "extensions/printing/printing_api_handler.h",
     "extensions/printing_metrics/print_job_finished_event_dispatcher.cc",
     "extensions/printing_metrics/print_job_finished_event_dispatcher.h",
     "extensions/printing_metrics/print_job_info_idl_conversions.cc",
@@ -2600,6 +2602,7 @@ source_set("unit_tests") {
     "extensions/login_screen/login_state/login_state_api_unittest.cc",
     "extensions/login_screen/login_state/session_state_changed_event_dispatcher_unittest.cc",
     "extensions/permissions_updater_delegate_chromeos_unittest.cc",
+    "extensions/printing/printing_api_handler_unittest.cc",
     "extensions/printing_metrics/print_job_finished_event_dispatcher_unittest.cc",
     "extensions/printing_metrics/print_job_info_idl_conversions_unittest.cc",
     "extensions/printing_metrics/printing_metrics_api_unittest.cc",

chrome/browser/chromeos/extensions/printing/OWNERS

+nikitapodguzov@chromium.org
+skau@chromium.org

chrome/browser/chromeos/extensions/printing/printing_api_handler.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/extensions/printing/printing_api_handler.h"
+
+#include "chrome/browser/chromeos/printing/cups_print_job.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "content/public/browser/browser_context.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_registry.h"
+
+namespace extensions {
+
+PrintingAPIHandler::PrintingAPIHandler(content::BrowserContext* browser_context)
+    : browser_context_(browser_context),
+      event_router_(EventRouter::Get(browser_context)),
+      extension_registry_(ExtensionRegistry::Get(browser_context)),
+      print_job_manager_(
+          chromeos::CupsPrintJobManagerFactory::GetForBrowserContext(
+              browser_context)),
+      print_job_manager_observer_(this) {
+  print_job_manager_observer_.Add(print_job_manager_);
+}
+
+PrintingAPIHandler::~PrintingAPIHandler() = default;
+
+// static
+BrowserContextKeyedAPIFactory<PrintingAPIHandler>*
+PrintingAPIHandler::GetFactoryInstance() {
+  static base::NoDestructor<BrowserContextKeyedAPIFactory<PrintingAPIHandler>>
+      instance;
+  return instance.get();
+}
+
+// static
+PrintingAPIHandler* PrintingAPIHandler::Get(
+    content::BrowserContext* browser_context) {
+  return BrowserContextKeyedAPIFactory<PrintingAPIHandler>::Get(
+      browser_context);
+}
+
+void PrintingAPIHandler::OnPrintJobCreated(
+    base::WeakPtr<chromeos::CupsPrintJob> job) {
+  DispatchJobStatusChangedEvent(api::printing::JOB_STATUS_PENDING, job);
+}
+
+void PrintingAPIHandler::OnPrintJobStarted(
+    base::WeakPtr<chromeos::CupsPrintJob> job) {
+  DispatchJobStatusChangedEvent(api::printing::JOB_STATUS_IN_PROGRESS, job);
+}
+
+void PrintingAPIHandler::OnPrintJobDone(
+    base::WeakPtr<chromeos::CupsPrintJob> job) {
+  DispatchJobStatusChangedEvent(api::printing::JOB_STATUS_PRINTED, job);
+}
+
+void PrintingAPIHandler::OnPrintJobError(
+    base::WeakPtr<chromeos::CupsPrintJob> job) {
+  DispatchJobStatusChangedEvent(api::printing::JOB_STATUS_FAILED, job);
+}
+
+void PrintingAPIHandler::OnPrintJobCancelled(
+    base::WeakPtr<chromeos::CupsPrintJob> job) {
+  DispatchJobStatusChangedEvent(api::printing::JOB_STATUS_CANCELED, job);
+}
+
+void PrintingAPIHandler::DispatchJobStatusChangedEvent(
+    api::printing::JobStatus job_status,
+    base::WeakPtr<chromeos::CupsPrintJob> job) {
+  if (!job || job->source() != printing::PrintJob::Source::EXTENSION)
+    return;
+
+  auto event =
+      std::make_unique<Event>(events::PRINTING_ON_JOB_STATUS_CHANGED,
+                              api::printing::OnJobStatusChanged::kEventName,
+                              api::printing::OnJobStatusChanged::Create(
+                                  job->GetUniqueId(), job_status));
+
+  if (extension_registry_->enabled_extensions().Contains(job->source_id()))
+    event_router_->DispatchEventToExtension(job->source_id(), std::move(event));
+}
+
+template <>
+KeyedService*
+BrowserContextKeyedAPIFactory<PrintingAPIHandler>::BuildServiceInstanceFor(
+    content::BrowserContext* context) const {
+  Profile* profile = Profile::FromBrowserContext(context);
+  // We do not want an instance of PrintingAPIHandler on the lock screen.
+  // This will lead to multiple printing notifications.
+  if (chromeos::ProfileHelper::IsLockScreenAppProfile(profile) ||
+      chromeos::ProfileHelper::IsSigninProfile(profile)) {
+    return nullptr;
+  }
+  return new PrintingAPIHandler(context);
+}
+
+}  // namespace extensions

chrome/browser/chromeos/extensions/printing/printing_api_handler.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_EXTENSIONS_PRINTING_PRINTING_API_HANDLER_H_
+#define CHROME_BROWSER_CHROMEOS_EXTENSIONS_PRINTING_PRINTING_API_HANDLER_H_
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/scoped_observer.h"
+#include "chrome/browser/chromeos/printing/cups_print_job_manager.h"
+#include "chrome/browser/chromeos/printing/cups_print_job_manager_factory.h"
+#include "chrome/common/extensions/api/printing.h"
+#include "extensions/browser/browser_context_keyed_api_factory.h"
+#include "extensions/browser/event_router_factory.h"
+
+namespace content {
+class BrowserContext;
+}  // namespace content
+
+namespace extensions {
+
+class ExtensionRegistry;
+
+// Observes CupsPrintJobManager and generates OnJobStatusChanged() events of
+// chrome.printing API.
+class PrintingAPIHandler : public BrowserContextKeyedAPI,
+                           public chromeos::CupsPrintJobManager::Observer {
+ public:
+  explicit PrintingAPIHandler(content::BrowserContext* browser_context);
+  ~PrintingAPIHandler() override;
+
+  // BrowserContextKeyedAPI:
+  static BrowserContextKeyedAPIFactory<PrintingAPIHandler>*
+  GetFactoryInstance();
+
+  // Returns the current instance for |browser_context|.
+  static PrintingAPIHandler* Get(content::BrowserContext* browser_context);
+
+ private:
+  // Needed for BrowserContextKeyedAPI implementation.
+  friend class BrowserContextKeyedAPIFactory<PrintingAPIHandler>;
+
+  // CupsPrintJobManager::Observer:
+  void OnPrintJobCreated(base::WeakPtr<chromeos::CupsPrintJob> job) override;
+  void OnPrintJobStarted(base::WeakPtr<chromeos::CupsPrintJob> job) override;
+  void OnPrintJobDone(base::WeakPtr<chromeos::CupsPrintJob> job) override;
+  void OnPrintJobError(base::WeakPtr<chromeos::CupsPrintJob> job) override;
+  void OnPrintJobCancelled(base::WeakPtr<chromeos::CupsPrintJob> job) override;
+
+  void DispatchJobStatusChangedEvent(api::printing::JobStatus job_status,
+                                     base::WeakPtr<chromeos::CupsPrintJob> job);
+
+  // BrowserContextKeyedAPI:
+  static const bool kServiceIsNULLWhileTesting = true;
+  static const char* service_name() { return "PrintingAPIHandler"; }
+
+  content::BrowserContext* const browser_context_;
+  EventRouter* const event_router_;
+  ExtensionRegistry* const extension_registry_;
+
+  chromeos::CupsPrintJobManager* print_job_manager_;
+  ScopedObserver<chromeos::CupsPrintJobManager,
+                 chromeos::CupsPrintJobManager::Observer>
+      print_job_manager_observer_;
+
+  base::WeakPtrFactory<PrintingAPIHandler> weak_ptr_factory_{this};
+
+  DISALLOW_COPY_AND_ASSIGN(PrintingAPIHandler);
+};
+
+template <>
+struct BrowserContextFactoryDependencies<PrintingAPIHandler> {
+  static void DeclareFactoryDependencies(
+      BrowserContextKeyedAPIFactory<PrintingAPIHandler>* factory) {
+    factory->DependsOn(EventRouterFactory::GetInstance());
+    factory->DependsOn(chromeos::CupsPrintJobManagerFactory::GetInstance());
+  }
+};
+
+template <>
+KeyedService*
+BrowserContextKeyedAPIFactory<PrintingAPIHandler>::BuildServiceInstanceFor(
+    content::BrowserContext* context) const;
+
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_PRINTING_PRINTING_API_HANDLER_H_

chrome/browser/chromeos/extensions/printing/printing_api_handler_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/extensions/printing/printing_api_handler.h"
+
+#include <memory>
+#include <string>
+
+#include "base/values.h"
+#include "chrome/browser/chromeos/printing/cups_print_job.h"
+#include "chrome/browser/chromeos/printing/test_cups_print_job_manager.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/extensions/api/printing.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
+#include "content/public/test/browser_task_environment.h"
+#include "content/public/test/test_service_manager_context.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/browser/event_router_factory.h"
+#include "extensions/browser/test_event_router.h"
+#include "extensions/common/extension_builder.h"
+#include "extensions/common/features/feature_channel.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace extensions {
+
+namespace {
+
+class PrintingEventObserver : public TestEventRouter::EventObserver {
+ public:
+  // The observer will only listen to events with the |event_name|.
+  PrintingEventObserver(TestEventRouter* event_router,
+                        const std::string& event_name)
+      : event_router_(event_router), event_name_(event_name) {
+    event_router_->AddEventObserver(this);
+  }
+
+  ~PrintingEventObserver() override {
+    event_router_->RemoveEventObserver(this);
+  }
+
+  // TestEventRouter::EventObserver:
+  void OnDispatchEventToExtension(const std::string& extension_id,
+                                  const Event& event) override {
+    if (event.event_name == event_name_) {
+      extension_id_ = extension_id;
+      event_args_ = event.event_args->Clone();
+    }
+  }
+
+  const std::string& extension_id() const { return extension_id_; }
+
+  const base::Value& event_args() const { return event_args_; }
+
+ private:
+  // Event router this class should observe.
+  TestEventRouter* const event_router_;
+
+  // The name of the observed event.
+  const std::string event_name_;
+
+  // The extension id passed for the last observed event.
+  std::string extension_id_;
+
+  // The arguments passed for the last observed event.
+  base::Value event_args_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintingEventObserver);
+};
+
+constexpr char kExtensionId[] = "abcdefghijklmnopqrstuvwxyzabcdef";
+constexpr char kPrinterId[] = "printer";
+constexpr int kJobId = 10;
+
+// Creates a new TestCupsPrintJobManager for the given |context|.
+std::unique_ptr<KeyedService> BuildCupsPrintJobManager(
+    content::BrowserContext* context) {
+  return std::make_unique<chromeos::TestCupsPrintJobManager>(
+      Profile::FromBrowserContext(context));
+}
+
+}  // namespace
+
+class PrintingAPIHandlerUnittest : public testing::Test {
+ public:
+  PrintingAPIHandlerUnittest()
+      : scoped_current_channel_(version_info::Channel::DEV) {}
+  ~PrintingAPIHandlerUnittest() override = default;
+
+  void SetUp() override {
+    profile_manager_ = std::make_unique<TestingProfileManager>(
+        TestingBrowserProcess::GetGlobal());
+    ASSERT_TRUE(profile_manager_->SetUp());
+    testing_profile_ =
+        profile_manager_->CreateTestingProfile(chrome::kInitialProfile);
+
+    chromeos::CupsPrintJobManagerFactory::GetInstance()->SetTestingFactory(
+        testing_profile_, base::BindRepeating(&BuildCupsPrintJobManager));
+    event_router_ = CreateAndUseTestEventRouter(testing_profile_);
+
+    const char kExtensionName[] = "Printing extension";
+    const char kPermissionName[] = "printing";
+    scoped_refptr<const Extension> extension =
+        ExtensionBuilder(kExtensionName)
+            .SetID(kExtensionId)
+            .AddPermission(kPermissionName)
+            .Build();
+    ExtensionRegistry::Get(testing_profile_)->AddEnabled(extension);
+
+    printing_api_handler_ =
+        std::make_unique<PrintingAPIHandler>(testing_profile_);
+  }
+
+  void TearDown() override {
+    printing_api_handler_.reset();
+
+    testing_profile_ = nullptr;
+    profile_manager_->DeleteTestingProfile(chrome::kInitialProfile);
+  }
+
+ protected:
+  content::BrowserTaskEnvironment task_environment_;
+  content::TestServiceManagerContext service_manager_context_;
+  TestingProfile* testing_profile_;
+  TestEventRouter* event_router_ = nullptr;
+
+ private:
+  // TODO(crbug.com/992889): Remove this once the API is launched for stable.
+  ScopedCurrentChannel scoped_current_channel_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<PrintingAPIHandler> printing_api_handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintingAPIHandlerUnittest);
+};
+
+// Test that |OnJobStatusChanged| is dispatched when the print job status is
+// changed.
+TEST_F(PrintingAPIHandlerUnittest, EventIsDispatched) {
+  PrintingEventObserver event_observer(
+      event_router_, api::printing::OnJobStatusChanged::kEventName);
+
+  chromeos::TestCupsPrintJobManager* print_job_manager =
+      static_cast<chromeos::TestCupsPrintJobManager*>(
+          chromeos::CupsPrintJobManagerFactory::GetForBrowserContext(
+              testing_profile_));
+  std::unique_ptr<chromeos::CupsPrintJob> print_job =
+      std::make_unique<chromeos::CupsPrintJob>(
+          chromeos::Printer(kPrinterId), kJobId, "title",
+          /*total_page_number=*/3, ::printing::PrintJob::Source::EXTENSION,
+          kExtensionId, chromeos::printing::proto::PrintSettings());
+  print_job_manager->CreatePrintJob(print_job.get());
+
+  EXPECT_EQ(kExtensionId, event_observer.extension_id());
+  const base::Value& event_args = event_observer.event_args();
+  ASSERT_TRUE(event_args.is_list());
+  ASSERT_EQ(2u, event_args.GetList().size());
+  base::Value job_id = event_args.GetList()[0].Clone();
+  ASSERT_TRUE(job_id.is_string());
+  EXPECT_EQ(chromeos::CupsPrintJob::CreateUniqueId(kPrinterId, kJobId),
+            job_id.GetString());
+  base::Value job_status = event_args.GetList()[1].Clone();
+  ASSERT_TRUE(job_status.is_string());
+  EXPECT_EQ(api::printing::JOB_STATUS_PENDING,
+            api::printing::ParseJobStatus(job_status.GetString()));
+}
+
+// Test that |OnJobStatusChanged| is not dispatched if the print job was created
+// on Print Preview page.
+TEST_F(PrintingAPIHandlerUnittest, PrintPreviewEventIsNotDispatched) {
+  PrintingEventObserver event_observer(
+      event_router_, api::printing::OnJobStatusChanged::kEventName);
+
+  chromeos::TestCupsPrintJobManager* print_job_manager =
+      static_cast<chromeos::TestCupsPrintJobManager*>(
+          chromeos::CupsPrintJobManagerFactory::GetForBrowserContext(
+              testing_profile_));
+  std::unique_ptr<chromeos::CupsPrintJob> print_job =
+      std::make_unique<chromeos::CupsPrintJob>(
+          chromeos::Printer(kPrinterId), kJobId, "title",
+          /*total_page_number=*/3, ::printing::PrintJob::Source::PRINT_PREVIEW,
+          /*source_id=*/"", chromeos::printing::proto::PrintSettings());
+  print_job_manager->CreatePrintJob(print_job.get());
+
+  // Check that the print job created on Print Preview doesn't show up.
+  EXPECT_EQ("", event_observer.extension_id());
+  EXPECT_TRUE(event_observer.event_args().is_none());
+}
+
+}  // namespace extensions

chrome/browser/printing/print_job.h

@@ -49,6 +49,7 @@ class PrintJob : public base::RefCountedThreadSafe<PrintJob>,
   enum class Source {
     PRINT_PREVIEW,
     ARC,
+    EXTENSION,
   };
 #endif  // defined(OS_CHROMEOS)
 

chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.cc

@@ -114,6 +114,7 @@
 #include "chrome/browser/chromeos/bluetooth/debug_logs_manager_factory.h"
 #include "chrome/browser/chromeos/crostini/crostini_registry_service_factory.h"
 #include "chrome/browser/chromeos/extensions/login_screen/login_state/session_state_changed_event_dispatcher.h"
+#include "chrome/browser/chromeos/extensions/printing/printing_api_handler.h"
 #include "chrome/browser/chromeos/extensions/printing_metrics/print_job_finished_event_dispatcher.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
 #include "chrome/browser/chromeos/plugin_vm/plugin_vm_engagement_metrics_service.h"
@@ -287,6 +288,7 @@ void ChromeBrowserMainExtraPartsProfiles::
   chromeos::smb_client::SmbServiceFactory::GetInstance();
   crostini::CrostiniRegistryServiceFactory::GetInstance();
   extensions::SessionStateChangedEventDispatcher::GetFactoryInstance();
+  extensions::PrintingAPIHandler::GetFactoryInstance();
   extensions::PrintJobFinishedEventDispatcher::GetFactoryInstance();
   extensions::VerifyTrustAPI::GetFactoryInstance();
   TetherServiceFactory::GetInstance();

chrome/common/extensions/api/_api_features.json

@@ -662,6 +662,10 @@
     "contexts": ["blessed_extension"],
     "disallow_for_service_workers": true
   }],
+  "printing": {
+    "dependencies": ["permission:printing"],
+    "contexts": ["blessed_extension"]
+  },
   "printingMetrics": {
     "dependencies": ["permission:printingMetrics"],
     "contexts": ["blessed_extension"]

chrome/common/extensions/api/_permission_features.json

@@ -617,6 +617,11 @@
     "channel": "stable",
     "extension_types": ["extension", "legacy_packaged_app"]
   },
+  "printing": {
+    "channel": "dev",
+    "platforms": ["chromeos"],
+    "extension_types": ["extension"]
+  },
   "printingMetrics": {
     "channel": "stable",
     "platforms": ["chromeos"],

chrome/common/extensions/api/api_sources.gni

@@ -103,6 +103,7 @@ if (is_chromeos) {
     "login_state.idl",
     "platform_keys.idl",
     "platform_keys_internal.idl",
+    "printing.idl",
     "printing_metrics.idl",
     "quick_unlock_private.idl",
     "terminal_private.json",

chrome/common/extensions/api/printing.idl

+// 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.
+
+// Use the <code>chrome.printing</code> API to send print jobs to printers
+// installed on Chromebook.
+[platforms=("chromeos")]
+namespace printing {
+  // Status of the print job.
+  enum JobStatus {
+    // Print job is received on Chrome side but was not processed yet.
+    PENDING,
+
+    // Print job is sent for printing.
+    IN_PROGRESS,
+
+    // Print job was interrupted due to some error.
+    FAILED,
+
+    // Print job was canceled by the user or via API.
+    CANCELED,
+
+    // Print job was printed without any errors.
+    PRINTED
+  };
+
+  interface Events {
+    // Event fired when the status of the job is changed.
+    // This is only fired for the jobs created by this extension.
+    static void onJobStatusChanged(DOMString jobId, JobStatus status);
+  };
+};

chrome/common/extensions/permissions/permission_set_unittest.cc

@@ -794,6 +794,9 @@ TEST(PermissionsTest, PermissionMessages) {
   // and don't require a prompt, i.e. they're restricted to location 'policy'.
   skip.insert(APIPermission::kEnterprisePlatformKeys);
   skip.insert(APIPermission::kEnterpriseDeviceAttributes);
+  // TODO (crbug/996785): Remove this when permission warning strings will be
+  // added.
+  skip.insert(APIPermission::kPrinting);
 
   // TODO(erikkay) add a string for this permission.
   skip.insert(APIPermission::kBackground);

extensions/browser/extension_event_histogram_value.h

@@ -464,6 +464,7 @@ enum HistogramValue {
   PRINTING_METRICS_ON_PRINT_JOB_FINISHED = 442,
   AUTOTESTPRIVATE_ON_CLIPBOARD_DATA_CHANGED = 443,
   AUTOFILL_PRIVATE_ON_PERSONAL_DATA_CHANGED = 444,
+  PRINTING_ON_JOB_STATUS_CHANGED = 445,
   // Last entry: Add new entries above, then run:
   // python tools/metrics/histograms/update_extension_histograms.py
   ENUM_BOUNDARY

extensions/common/permissions/api_permission.h

@@ -265,6 +265,7 @@ class APIPermission {
     kLoginScreenStorage = 221,
     kLoginState = 222,
     kPrintingMetrics = 223,
+    kPrinting = 224,
     // Last entry: Add new entries above and ensure to update the
     // "ExtensionPermission3" enum in tools/metrics/histograms/enums.xml
     // (by running update_extension_permission.py).

extensions/common/permissions/extensions_api_permissions.cc

@@ -92,6 +92,7 @@ constexpr APIPermissionInfo::InitInfo permissions_to_register[] = {
      APIPermissionInfo::kFlagCannotBeOptional},
     {APIPermission::kPower, "power"},
     {APIPermission::kPrinterProvider, "printerProvider"},
+    {APIPermission::kPrinting, "printing"},
     {APIPermission::kPrintingMetrics, "printingMetrics"},
     {APIPermission::kSerial, "serial"},
     {APIPermission::kSocket, "socket", APIPermissionInfo::kFlagCannotBeOptional,

tools/metrics/histograms/enums.xml

@@ -19691,6 +19691,7 @@ Called by update_net_error_codes.py.-->
   <int value="442" label="PRINTING_METRICS_ON_PRINT_JOB_FINISHED"/>
   <int value="443" label="AUTOTESTPRIVATE_ON_CLIPBOARD_DATA_CHANGED"/>
   <int value="444" label="AUTOFILL_PRIVATE_ON_PERSONAL_DATA_CHANGED"/>
+  <int value="445" label="PRINTING_ON_JOB_STATUS_CHANGED"/>
 </enum>
 
 <enum name="ExtensionFileWriteResult">
@@ -21700,6 +21701,7 @@ Called by update_net_error_codes.py.-->
   <int value="221" label="kLoginScreenStorage"/>
   <int value="222" label="kLoginState"/>
   <int value="223" label="kPrintingMetrics"/>
+  <int value="224" label="kPrinting"/>
 </enum>
 
 <enum name="ExtensionServiceVerifyAllSuccess">