Convert printing enums from snake case to camel case

Change enum values to camel case to match style guidance for enum
class members.

Bug: 1059607
Change-Id: Icf5884449d1ad71b761dba7d14a64a7e478b801c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2399566Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Gavin Williams <gavinwill@chromium.org>
Cr-Commit-Position: refs/heads/master@{#805397}

chrome/browser/chromeos/printing/cups_printer_status_creator.cc

@@ -27,55 +27,55 @@ CupsPrinterStatus PrinterStatusToCupsPrinterStatus(
 
 CupsReason PrinterReasonToCupsReason(const ReasonFromPrinter& reason) {
   switch (reason) {
-    case ReasonFromPrinter::FUSER_OVER_TEMP:
-    case ReasonFromPrinter::FUSER_UNDER_TEMP:
-    case ReasonFromPrinter::INTERPRETER_RESOURCE_UNAVAILABLE:
-    case ReasonFromPrinter::OPC_LIFE_OVER:
-    case ReasonFromPrinter::OPC_NEAR_EOL:
+    case ReasonFromPrinter::kFuserOverTemp:
+    case ReasonFromPrinter::kFuserUnderTemp:
+    case ReasonFromPrinter::kInterpreterResourceUnavailable:
+    case ReasonFromPrinter::kOpcLifeOver:
+    case ReasonFromPrinter::kOpcNearEol:
       return CupsReason::kDeviceError;
-    case ReasonFromPrinter::COVER_OPEN:
-    case ReasonFromPrinter::DOOR_OPEN:
-    case ReasonFromPrinter::INTERLOCK_OPEN:
+    case ReasonFromPrinter::kCoverOpen:
+    case ReasonFromPrinter::kDoorOpen:
+    case ReasonFromPrinter::kInterlockOpen:
       return CupsReason::kDoorOpen;
-    case ReasonFromPrinter::DEVELOPER_LOW:
-    case ReasonFromPrinter::MARKER_SUPPLY_LOW:
-    case ReasonFromPrinter::MARKER_WASTE_ALMOST_FULL:
-    case ReasonFromPrinter::TONER_LOW:
+    case ReasonFromPrinter::kDeveloperLow:
+    case ReasonFromPrinter::kMarkerSupplyLow:
+    case ReasonFromPrinter::kMarkerWasteAlmostFull:
+    case ReasonFromPrinter::kTonerLow:
       return CupsReason::kLowOnInk;
-    case ReasonFromPrinter::MEDIA_LOW:
+    case ReasonFromPrinter::kMediaLow:
       return CupsReason::kLowOnPaper;
-    case ReasonFromPrinter::NONE:
+    case ReasonFromPrinter::kNone:
       return CupsReason::kNoError;
-    case ReasonFromPrinter::DEVELOPER_EMPTY:
-    case ReasonFromPrinter::MARKER_SUPPLY_EMPTY:
-    case ReasonFromPrinter::MARKER_WASTE_FULL:
-    case ReasonFromPrinter::TONER_EMPTY:
+    case ReasonFromPrinter::kDeveloperEmpty:
+    case ReasonFromPrinter::kMarkerSupplyEmpty:
+    case ReasonFromPrinter::kMarkerWasteFull:
+    case ReasonFromPrinter::kTonerEmpty:
       return CupsReason::kOutOfInk;
-    case ReasonFromPrinter::MEDIA_EMPTY:
-    case ReasonFromPrinter::MEDIA_NEEDED:
+    case ReasonFromPrinter::kMediaEmpty:
+    case ReasonFromPrinter::kMediaNeeded:
       return CupsReason::kOutOfPaper;
-    case ReasonFromPrinter::OUTPUT_AREA_ALMOST_FULL:
+    case ReasonFromPrinter::kOutputAreaAlmostFull:
       return CupsReason::kOutputAreaAlmostFull;
-    case ReasonFromPrinter::OUTPUT_AREA_FULL:
+    case ReasonFromPrinter::kOutputAreaFull:
       return CupsReason::kOutputFull;
-    case ReasonFromPrinter::MEDIA_JAM:
+    case ReasonFromPrinter::kMediaJam:
       return CupsReason::kPaperJam;
-    case ReasonFromPrinter::MOVING_TO_PAUSED:
-    case ReasonFromPrinter::PAUSED:
+    case ReasonFromPrinter::kMovingToPaused:
+    case ReasonFromPrinter::kPaused:
       return CupsReason::kPaused;
-    case ReasonFromPrinter::SPOOL_AREA_FULL:
+    case ReasonFromPrinter::kSpoolAreaFull:
       return CupsReason::kPrinterQueueFull;
-    case ReasonFromPrinter::CONNECTING_TO_DEVICE:
-    case ReasonFromPrinter::SHUTDOWN:
-    case ReasonFromPrinter::TIMED_OUT:
+    case ReasonFromPrinter::kConnectingToDevice:
+    case ReasonFromPrinter::kShutdown:
+    case ReasonFromPrinter::kTimedOut:
       return CupsReason::kPrinterUnreachable;
-    case ReasonFromPrinter::STOPPED_PARTLY:
-    case ReasonFromPrinter::STOPPING:
+    case ReasonFromPrinter::kStoppedPartly:
+    case ReasonFromPrinter::kStopping:
       return CupsReason::kStopped;
-    case ReasonFromPrinter::INPUT_TRAY_MISSING:
-    case ReasonFromPrinter::OUTPUT_TRAY_MISSING:
+    case ReasonFromPrinter::kInputTrayMissing:
+    case ReasonFromPrinter::kOutputTrayMissing:
       return CupsReason::kTrayMissing;
-    case ReasonFromPrinter::UNKNOWN_REASON:
+    case ReasonFromPrinter::kUnknownReason:
       return CupsReason::kUnknownReason;
   }
 }
@@ -83,13 +83,13 @@ CupsReason PrinterReasonToCupsReason(const ReasonFromPrinter& reason) {
 CupsSeverity PrinterSeverityToCupsSeverity(
     const SeverityFromPrinter& severity) {
   switch (severity) {
-    case SeverityFromPrinter::UNKNOWN_SEVERITY:
+    case SeverityFromPrinter::kUnknownSeverity:
       return CupsSeverity::kUnknownSeverity;
-    case SeverityFromPrinter::REPORT:
+    case SeverityFromPrinter::kReport:
       return CupsSeverity::kReport;
-    case SeverityFromPrinter::WARNING:
+    case SeverityFromPrinter::kWarning:
       return CupsSeverity::kWarning;
-    case SeverityFromPrinter::ERROR:
+    case SeverityFromPrinter::kError:
       return CupsSeverity::kError;
   }
 }

chrome/browser/chromeos/printing/cups_printer_status_creator_unittest.cc

@@ -18,12 +18,12 @@ using SeverityFromPrinter = printing::PrinterStatus::PrinterReason::Severity;
 
 TEST(CupsPrinterStatusCreatorTest, PrinterStatusToCupsPrinterStatus) {
   printing::PrinterStatus::PrinterReason reason1;
-  reason1.reason = ReasonFromPrinter::NONE;
-  reason1.severity = SeverityFromPrinter::REPORT;
+  reason1.reason = ReasonFromPrinter::kNone;
+  reason1.severity = SeverityFromPrinter::kReport;
 
   printing::PrinterStatus::PrinterReason reason2;
-  reason2.reason = ReasonFromPrinter::COVER_OPEN;
-  reason2.severity = SeverityFromPrinter::WARNING;
+  reason2.reason = ReasonFromPrinter::kCoverOpen;
+  reason2.severity = SeverityFromPrinter::kWarning;
 
   printing::PrinterStatus printer_status;
   printer_status.reasons.push_back(reason1);
@@ -47,102 +47,102 @@ TEST(CupsPrinterStatusCreatorTest, PrinterStatusToCupsPrinterStatus) {
 TEST(CupsPrinterStatusCreatorTest, PrinterSeverityToCupsSeverity) {
   EXPECT_EQ(
       CupsSeverity::kUnknownSeverity,
-      PrinterSeverityToCupsSeverity(SeverityFromPrinter::UNKNOWN_SEVERITY));
+      PrinterSeverityToCupsSeverity(SeverityFromPrinter::kUnknownSeverity));
   EXPECT_EQ(CupsSeverity::kReport,
-            PrinterSeverityToCupsSeverity(SeverityFromPrinter::REPORT));
+            PrinterSeverityToCupsSeverity(SeverityFromPrinter::kReport));
   EXPECT_EQ(CupsSeverity::kWarning,
-            PrinterSeverityToCupsSeverity(SeverityFromPrinter::WARNING));
+            PrinterSeverityToCupsSeverity(SeverityFromPrinter::kWarning));
   EXPECT_EQ(CupsSeverity::kError,
-            PrinterSeverityToCupsSeverity(SeverityFromPrinter::ERROR));
+            PrinterSeverityToCupsSeverity(SeverityFromPrinter::kError));
 }
 
 TEST(CupsPrinterStatusCreatorTest, PrinterReasonToCupsReason) {
   EXPECT_EQ(CupsReason::kDeviceError,
-            PrinterReasonToCupsReason(ReasonFromPrinter::FUSER_OVER_TEMP));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kFuserOverTemp));
   EXPECT_EQ(CupsReason::kDeviceError,
-            PrinterReasonToCupsReason(ReasonFromPrinter::FUSER_UNDER_TEMP));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kFuserUnderTemp));
   EXPECT_EQ(CupsReason::kDeviceError,
             PrinterReasonToCupsReason(
-                ReasonFromPrinter::INTERPRETER_RESOURCE_UNAVAILABLE));
+                ReasonFromPrinter::kInterpreterResourceUnavailable));
   EXPECT_EQ(CupsReason::kDeviceError,
-            PrinterReasonToCupsReason(ReasonFromPrinter::OPC_LIFE_OVER));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kOpcLifeOver));
   EXPECT_EQ(CupsReason::kDeviceError,
-            PrinterReasonToCupsReason(ReasonFromPrinter::OPC_NEAR_EOL));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kOpcNearEol));
 
   EXPECT_EQ(CupsReason::kDoorOpen,
-            PrinterReasonToCupsReason(ReasonFromPrinter::COVER_OPEN));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kCoverOpen));
   EXPECT_EQ(CupsReason::kDoorOpen,
-            PrinterReasonToCupsReason(ReasonFromPrinter::DOOR_OPEN));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kDoorOpen));
   EXPECT_EQ(CupsReason::kDoorOpen,
-            PrinterReasonToCupsReason(ReasonFromPrinter::INTERLOCK_OPEN));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kInterlockOpen));
 
   EXPECT_EQ(CupsReason::kLowOnInk,
-            PrinterReasonToCupsReason(ReasonFromPrinter::DEVELOPER_LOW));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kDeveloperLow));
   EXPECT_EQ(CupsReason::kLowOnInk,
-            PrinterReasonToCupsReason(ReasonFromPrinter::MARKER_SUPPLY_LOW));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kMarkerSupplyLow));
   EXPECT_EQ(
       CupsReason::kLowOnInk,
-      PrinterReasonToCupsReason(ReasonFromPrinter::MARKER_WASTE_ALMOST_FULL));
+      PrinterReasonToCupsReason(ReasonFromPrinter::kMarkerWasteAlmostFull));
   EXPECT_EQ(CupsReason::kLowOnInk,
-            PrinterReasonToCupsReason(ReasonFromPrinter::TONER_LOW));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kTonerLow));
 
   EXPECT_EQ(CupsReason::kLowOnPaper,
-            PrinterReasonToCupsReason(ReasonFromPrinter::MEDIA_LOW));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kMediaLow));
 
   EXPECT_EQ(CupsReason::kNoError,
-            PrinterReasonToCupsReason(ReasonFromPrinter::NONE));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kNone));
 
   EXPECT_EQ(CupsReason::kOutOfInk,
-            PrinterReasonToCupsReason(ReasonFromPrinter::DEVELOPER_EMPTY));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kDeveloperEmpty));
   EXPECT_EQ(CupsReason::kOutOfInk,
-            PrinterReasonToCupsReason(ReasonFromPrinter::MARKER_SUPPLY_EMPTY));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kMarkerSupplyEmpty));
   EXPECT_EQ(CupsReason::kOutOfInk,
-            PrinterReasonToCupsReason(ReasonFromPrinter::MARKER_WASTE_FULL));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kMarkerWasteFull));
   EXPECT_EQ(CupsReason::kOutOfInk,
-            PrinterReasonToCupsReason(ReasonFromPrinter::TONER_EMPTY));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kTonerEmpty));
 
   EXPECT_EQ(CupsReason::kOutOfPaper,
-            PrinterReasonToCupsReason(ReasonFromPrinter::MEDIA_EMPTY));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kMediaEmpty));
   EXPECT_EQ(CupsReason::kOutOfPaper,
-            PrinterReasonToCupsReason(ReasonFromPrinter::MEDIA_NEEDED));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kMediaNeeded));
 
   EXPECT_EQ(
       CupsReason::kOutputAreaAlmostFull,
-      PrinterReasonToCupsReason(ReasonFromPrinter::OUTPUT_AREA_ALMOST_FULL));
+      PrinterReasonToCupsReason(ReasonFromPrinter::kOutputAreaAlmostFull));
 
   EXPECT_EQ(CupsReason::kOutputFull,
-            PrinterReasonToCupsReason(ReasonFromPrinter::OUTPUT_AREA_FULL));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kOutputAreaFull));
 
   EXPECT_EQ(CupsReason::kPaperJam,
-            PrinterReasonToCupsReason(ReasonFromPrinter::MEDIA_JAM));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kMediaJam));
 
   EXPECT_EQ(CupsReason::kPaused,
-            PrinterReasonToCupsReason(ReasonFromPrinter::MOVING_TO_PAUSED));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kMovingToPaused));
   EXPECT_EQ(CupsReason::kPaused,
-            PrinterReasonToCupsReason(ReasonFromPrinter::PAUSED));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kPaused));
 
   EXPECT_EQ(CupsReason::kPrinterQueueFull,
-            PrinterReasonToCupsReason(ReasonFromPrinter::SPOOL_AREA_FULL));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kSpoolAreaFull));
 
   EXPECT_EQ(CupsReason::kPrinterUnreachable,
-            PrinterReasonToCupsReason(ReasonFromPrinter::CONNECTING_TO_DEVICE));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kConnectingToDevice));
   EXPECT_EQ(CupsReason::kPrinterUnreachable,
-            PrinterReasonToCupsReason(ReasonFromPrinter::SHUTDOWN));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kShutdown));
   EXPECT_EQ(CupsReason::kPrinterUnreachable,
-            PrinterReasonToCupsReason(ReasonFromPrinter::TIMED_OUT));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kTimedOut));
 
   EXPECT_EQ(CupsReason::kStopped,
-            PrinterReasonToCupsReason(ReasonFromPrinter::STOPPED_PARTLY));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kStoppedPartly));
   EXPECT_EQ(CupsReason::kStopped,
-            PrinterReasonToCupsReason(ReasonFromPrinter::STOPPING));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kStopping));
 
   EXPECT_EQ(CupsReason::kTrayMissing,
-            PrinterReasonToCupsReason(ReasonFromPrinter::INPUT_TRAY_MISSING));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kInputTrayMissing));
   EXPECT_EQ(CupsReason::kTrayMissing,
-            PrinterReasonToCupsReason(ReasonFromPrinter::OUTPUT_TRAY_MISSING));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kOutputTrayMissing));
 
   EXPECT_EQ(CupsReason::kUnknownReason,
-            PrinterReasonToCupsReason(ReasonFromPrinter::UNKNOWN_REASON));
+            PrinterReasonToCupsReason(ReasonFromPrinter::kUnknownReason));
 }
 
 }  // namespace chromeos

chrome/browser/chromeos/printing/cups_printers_manager.cc

@@ -403,7 +403,7 @@ class CupsPrintersManagerImpl
     base::UmaHistogramEnumeration("Printing.CUPS.PrinterStatusQueryResult",
                                   result);
     switch (result) {
-      case PrinterQueryResult::UNREACHABLE: {
+      case PrinterQueryResult::kUnreachable: {
         PRINTER_LOG(ERROR)
             << "Printer status request failed. Could not reach printer "
             << printer_id;
@@ -415,7 +415,7 @@ class CupsPrintersManagerImpl
         std::move(cb).Run(std::move(error_printer_status));
         break;
       }
-      case PrinterQueryResult::UNKNOWN_FAILURE: {
+      case PrinterQueryResult::kUnknownFailure: {
         PRINTER_LOG(ERROR) << "Printer status request failed. Unknown failure "
                               "trying to reach printer "
                            << printer_id;
@@ -426,7 +426,7 @@ class CupsPrintersManagerImpl
         std::move(cb).Run(std::move(error_printer_status));
         break;
       }
-      case PrinterQueryResult::SUCCESS: {
+      case PrinterQueryResult::kSuccess: {
         // Record results from PrinterStatus before converting to
         // CupsPrinterStatus because the PrinterStatus enum contains more reason
         // buckets.

chrome/browser/chromeos/printing/printer_error_codes.cc

@@ -59,38 +59,38 @@ PrinterErrorCode PrinterErrorCodeFromPrinterStatusReasons(
     const ::printing::PrinterStatus& printer_status) {
   for (const auto& reason : printer_status.reasons) {
     switch (reason.reason) {
-      case PrinterReason::Reason::MEDIA_EMPTY:
-      case PrinterReason::Reason::MEDIA_NEEDED:
-      case PrinterReason::Reason::MEDIA_LOW:
+      case PrinterReason::Reason::kMediaEmpty:
+      case PrinterReason::Reason::kMediaNeeded:
+      case PrinterReason::Reason::kMediaLow:
         return PrinterErrorCode::OUT_OF_PAPER;
-      case PrinterReason::Reason::MEDIA_JAM:
+      case PrinterReason::Reason::kMediaJam:
         return PrinterErrorCode::PAPER_JAM;
-      case PrinterReason::Reason::TONER_EMPTY:
-      case PrinterReason::Reason::TONER_LOW:
-      case PrinterReason::Reason::DEVELOPER_EMPTY:
-      case PrinterReason::Reason::DEVELOPER_LOW:
-      case PrinterReason::Reason::MARKER_SUPPLY_EMPTY:
-      case PrinterReason::Reason::MARKER_SUPPLY_LOW:
-      case PrinterReason::Reason::MARKER_WASTE_FULL:
-      case PrinterReason::Reason::MARKER_WASTE_ALMOST_FULL:
+      case PrinterReason::Reason::kTonerEmpty:
+      case PrinterReason::Reason::kTonerLow:
+      case PrinterReason::Reason::kDeveloperEmpty:
+      case PrinterReason::Reason::kDeveloperLow:
+      case PrinterReason::Reason::kMarkerSupplyEmpty:
+      case PrinterReason::Reason::kMarkerSupplyLow:
+      case PrinterReason::Reason::kMarkerWasteFull:
+      case PrinterReason::Reason::kMarkerWasteAlmostFull:
         return PrinterErrorCode::OUT_OF_INK;
-      case PrinterReason::Reason::TIMED_OUT:
-      case PrinterReason::Reason::SHUTDOWN:
+      case PrinterReason::Reason::kTimedOut:
+      case PrinterReason::Reason::kShutdown:
         return PrinterErrorCode::PRINTER_UNREACHABLE;
-      case PrinterReason::Reason::DOOR_OPEN:
-      case PrinterReason::Reason::COVER_OPEN:
-      case PrinterReason::Reason::INTERLOCK_OPEN:
+      case PrinterReason::Reason::kDoorOpen:
+      case PrinterReason::Reason::kCoverOpen:
+      case PrinterReason::Reason::kInterlockOpen:
         return PrinterErrorCode::DOOR_OPEN;
-      case PrinterReason::Reason::INPUT_TRAY_MISSING:
-      case PrinterReason::Reason::OUTPUT_TRAY_MISSING:
+      case PrinterReason::Reason::kInputTrayMissing:
+      case PrinterReason::Reason::kOutputTrayMissing:
         return PrinterErrorCode::TRAY_MISSING;
-      case PrinterReason::Reason::OUTPUT_AREA_FULL:
-      case PrinterReason::Reason::OUTPUT_AREA_ALMOST_FULL:
+      case PrinterReason::Reason::kOutputAreaFull:
+      case PrinterReason::Reason::kOutputAreaAlmostFull:
         return PrinterErrorCode::OUTPUT_FULL;
-      case PrinterReason::Reason::STOPPING:
-      case PrinterReason::Reason::STOPPED_PARTLY:
-      case PrinterReason::Reason::PAUSED:
-      case PrinterReason::Reason::MOVING_TO_PAUSED:
+      case PrinterReason::Reason::kStopping:
+      case PrinterReason::Reason::kStoppedPartly:
+      case PrinterReason::Reason::kPaused:
+      case PrinterReason::Reason::kMovingToPaused:
         return PrinterErrorCode::STOPPED;
       default:
         break;

chrome/browser/chromeos/printing/printer_info_cups.cc

@@ -143,7 +143,7 @@ QueryResult QueryPrinterImpl(const std::string& host,
   result.result =
       ::printing::GetPrinterInfo(host, port, path, encrypted,
                                  &result.printer_info, &result.printer_status);
-  if (result.result != ::printing::PrinterQueryResult::SUCCESS) {
+  if (result.result != ::printing::PrinterQueryResult::kSuccess) {
     LOG(ERROR) << "Could not retrieve printer info";
   }
 
@@ -157,7 +157,7 @@ void OnPrinterQueried(chromeos::PrinterInfoCallback callback,
   const ::printing::PrinterQueryResult& result = query_result.result;
   const ::printing::PrinterInfo& printer_info = query_result.printer_info;
   const ::printing::PrinterStatus& printer_status = query_result.printer_status;
-  if (result != ::printing::PrinterQueryResult::SUCCESS) {
+  if (result != ::printing::PrinterQueryResult::kSuccess) {
     VLOG(1) << "Could not reach printer";
     std::move(callback).Run(result, ::printing::PrinterStatus(), std::string(),
                             std::string(), std::string(), {}, false);

chrome/browser/chromeos/printing/printer_info_stub.cc

@@ -21,7 +21,7 @@ void QueryIppPrinter(const std::string& host,
 
   base::SequencedTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(std::move(callback),
-                                printing::PrinterQueryResult::UNKNOWN_FAILURE,
+                                printing::PrinterQueryResult::kUnknownFailure,
                                 printing::PrinterStatus(), "Foo", "Bar",
                                 "Foo Bar", std::vector<std::string>{}, false));
 }

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

@@ -85,12 +85,12 @@ void OnRemovedPrinter(const Printer::PrinterProtocol& protocol, bool success) {
 
 // Log if the IPP attributes request was succesful.
 void RecordIppQueryResult(const PrinterQueryResult& result) {
-  bool reachable = (result != PrinterQueryResult::UNREACHABLE);
+  bool reachable = (result != PrinterQueryResult::kUnreachable);
   UMA_HISTOGRAM_BOOLEAN("Printing.CUPS.IppDeviceReachable", reachable);
 
   if (reachable) {
     // Only record whether the query was successful if we reach the printer.
-    bool query_success = (result == PrinterQueryResult::SUCCESS);
+    bool query_success = (result == PrinterQueryResult::kSuccess);
     UMA_HISTOGRAM_BOOLEAN("Printing.CUPS.IppAttributesSuccess", query_success);
   }
 }
@@ -480,7 +480,7 @@ void CupsPrintersHandler::HandleGetPrinterInfo(const base::ListValue* args) {
   if (uri.GetLastParsingError().status != Uri::ParserStatus::kNoErrors ||
       !IsValidPrinterUri(uri)) {
     // Run the failure callback.
-    OnAutoconfQueried(callback_id, PrinterQueryResult::UNKNOWN_FAILURE,
+    OnAutoconfQueried(callback_id, PrinterQueryResult::kUnknownFailure,
                       printing::PrinterStatus(), "", "", "", {}, false);
     return;
   }
@@ -502,7 +502,7 @@ void CupsPrintersHandler::OnAutoconfQueriedDiscovered(
     bool ipp_everywhere) {
   RecordIppQueryResult(result);
 
-  const bool success = result == PrinterQueryResult::SUCCESS;
+  const bool success = result == PrinterQueryResult::kSuccess;
   if (success) {
     // If we queried a valid make and model, use it.  The mDNS record isn't
     // guaranteed to have it.  However, don't overwrite it if the printer
@@ -548,9 +548,9 @@ void CupsPrintersHandler::OnAutoconfQueried(
     const std::vector<std::string>& document_formats,
     bool ipp_everywhere) {
   RecordIppQueryResult(result);
-  const bool success = result == PrinterQueryResult::SUCCESS;
+  const bool success = result == PrinterQueryResult::kSuccess;
 
-  if (result == PrinterQueryResult::UNREACHABLE) {
+  if (result == PrinterQueryResult::kUnreachable) {
     PRINTER_LOG(DEBUG) << "Could not reach printer";
     RejectJavascriptCallback(
         base::Value(callback_id),

printing/backend/cups_jobs.cc

@@ -147,40 +147,40 @@ CupsJob::JobState ToJobState(ipp_attribute_t* attr) {
 const std::map<base::StringPiece, PReason>& GetLabelToReason() {
   static const std::map<base::StringPiece, PReason> kLabelToReason =
       std::map<base::StringPiece, PReason>{
-        {kNone, PReason::NONE},
-        {kMediaNeeded, PReason::MEDIA_NEEDED},
-        {kMediaJam, PReason::MEDIA_JAM},
-        {kMovingToPaused, PReason::MOVING_TO_PAUSED},
-        {kPaused, PReason::PAUSED},
-        {kShutdown, PReason::SHUTDOWN},
-        {kConnectingToDevice, PReason::CONNECTING_TO_DEVICE},
-        {kTimedOut, PReason::TIMED_OUT},
-        {kStopping, PReason::STOPPING},
-        {kStoppedPartly, PReason::STOPPED_PARTLY},
-        {kTonerLow, PReason::TONER_LOW},
-        {kTonerEmpty, PReason::TONER_EMPTY},
-        {kSpoolAreaFull, PReason::SPOOL_AREA_FULL},
-        {kCoverOpen, PReason::COVER_OPEN},
-        {kInterlockOpen, PReason::INTERLOCK_OPEN},
-        {kDoorOpen, PReason::DOOR_OPEN},
-        {kInputTrayMissing, PReason::INPUT_TRAY_MISSING},
-        {kMediaLow, PReason::MEDIA_LOW},
-        {kMediaEmpty, PReason::MEDIA_EMPTY},
-        {kOutputTrayMissing, PReason::OUTPUT_TRAY_MISSING},
-        {kOutputAreaAlmostFull, PReason::OUTPUT_AREA_ALMOST_FULL},
-        {kOutputAreaFull, PReason::OUTPUT_AREA_FULL},
-        {kMarkerSupplyLow, PReason::MARKER_SUPPLY_LOW},
-        {kMarkerSupplyEmpty, PReason::MARKER_SUPPLY_EMPTY},
-        {kMarkerWasteAlmostFull, PReason::MARKER_WASTE_ALMOST_FULL},
-        {kMarkerWasteFull, PReason::MARKER_WASTE_FULL},
-        {kFuserOverTemp, PReason::FUSER_OVER_TEMP},
-        {kFuserUnderTemp, PReason::FUSER_UNDER_TEMP},
-        {kOpcNearEol, PReason::OPC_NEAR_EOL},
-        {kOpcLifeOver, PReason::OPC_LIFE_OVER},
-        {kDeveloperLow, PReason::DEVELOPER_LOW},
-        {kDeveloperEmpty, PReason::DEVELOPER_EMPTY},
-        {kInterpreterResourceUnavailable,
-          PReason::INTERPRETER_RESOURCE_UNAVAILABLE},
+          {kNone, PReason::kNone},
+          {kMediaNeeded, PReason::kMediaNeeded},
+          {kMediaJam, PReason::kMediaJam},
+          {kMovingToPaused, PReason::kMovingToPaused},
+          {kPaused, PReason::kPaused},
+          {kShutdown, PReason::kShutdown},
+          {kConnectingToDevice, PReason::kConnectingToDevice},
+          {kTimedOut, PReason::kTimedOut},
+          {kStopping, PReason::kStopping},
+          {kStoppedPartly, PReason::kStoppedPartly},
+          {kTonerLow, PReason::kTonerLow},
+          {kTonerEmpty, PReason::kTonerEmpty},
+          {kSpoolAreaFull, PReason::kSpoolAreaFull},
+          {kCoverOpen, PReason::kCoverOpen},
+          {kInterlockOpen, PReason::kInterlockOpen},
+          {kDoorOpen, PReason::kDoorOpen},
+          {kInputTrayMissing, PReason::kInputTrayMissing},
+          {kMediaLow, PReason::kMediaLow},
+          {kMediaEmpty, PReason::kMediaEmpty},
+          {kOutputTrayMissing, PReason::kOutputTrayMissing},
+          {kOutputAreaAlmostFull, PReason::kOutputAreaAlmostFull},
+          {kOutputAreaFull, PReason::kOutputAreaFull},
+          {kMarkerSupplyLow, PReason::kMarkerSupplyLow},
+          {kMarkerSupplyEmpty, PReason::kMarkerSupplyEmpty},
+          {kMarkerWasteAlmostFull, PReason::kMarkerWasteAlmostFull},
+          {kMarkerWasteFull, PReason::kMarkerWasteFull},
+          {kFuserOverTemp, PReason::kFuserOverTemp},
+          {kFuserUnderTemp, PReason::kFuserUnderTemp},
+          {kOpcNearEol, PReason::kOpcNearEol},
+          {kOpcLifeOver, PReason::kOpcLifeOver},
+          {kDeveloperLow, PReason::kDeveloperLow},
+          {kDeveloperEmpty, PReason::kDeveloperEmpty},
+          {kInterpreterResourceUnavailable,
+           PReason::kInterpreterResourceUnavailable},
       };
   return kLabelToReason;
 }
@@ -190,22 +190,22 @@ const std::map<base::StringPiece, PReason>& GetLabelToReason() {
 PrinterStatus::PrinterReason::Reason ToReason(base::StringPiece reason) {
   const auto& enum_map = GetLabelToReason();
   const auto& entry = enum_map.find(reason);
-  return entry != enum_map.end() ? entry->second : PReason::UNKNOWN_REASON;
+  return entry != enum_map.end() ? entry->second : PReason::kUnknownReason;
 }
 
 // Returns the Severity cooresponding to |severity|.  Returns UNKNOWN_SEVERITY
 // if the strin gis not recognized.
 PSeverity ToSeverity(base::StringPiece severity) {
   if (severity == kSeverityError)
-    return PSeverity::ERROR;
+    return PSeverity::kError;
 
   if (severity == kSeverityWarn)
-    return PSeverity::WARNING;
+    return PSeverity::kWarning;
 
   if (severity == kSeverityReport)
-    return PSeverity::REPORT;
+    return PSeverity::kReport;
 
-  return PSeverity::UNKNOWN_SEVERITY;
+  return PSeverity::kUnknownSeverity;
 }
 
 // Parses the |reason| string into a PrinterReason.  Splits the string based on
@@ -215,22 +215,22 @@ PrinterStatus::PrinterReason ToPrinterReason(base::StringPiece reason) {
   PrinterStatus::PrinterReason parsed;
 
   if (reason == kNone) {
-    parsed.reason = PReason::NONE;
-    parsed.severity = PSeverity::UNKNOWN_SEVERITY;
+    parsed.reason = PReason::kNone;
+    parsed.severity = PSeverity::kUnknownSeverity;
     return parsed;
   }
 
   size_t last_dash = reason.rfind('-');
-  auto severity = PSeverity::UNKNOWN_SEVERITY;
+  auto severity = PSeverity::kUnknownSeverity;
   if (last_dash != base::StringPiece::npos) {
     // try to parse the last part of the string as the severity.
     severity = ToSeverity(reason.substr(last_dash + 1));
   }
 
-  if (severity == PSeverity::UNKNOWN_SEVERITY) {
+  if (severity == PSeverity::kUnknownSeverity) {
     // Severity is unknown.  No severity in the reason.
     // Per spec, if there is no severity, severity is error.
-    parsed.severity = PSeverity::ERROR;
+    parsed.severity = PSeverity::kError;
     parsed.reason = ToReason(reason);
   } else {
     parsed.severity = severity;
@@ -468,7 +468,7 @@ PrinterQueryResult GetPrinterInfo(const std::string& address,
       kHttpConnectTimeoutMs, nullptr));
   if (!http) {
     LOG(WARNING) << "Could not connect to host";
-    return PrinterQueryResult::UNREACHABLE;
+    return PrinterQueryResult::kUnreachable;
   }
 
   // TODO(crbug.com/821497): Use a library to canonicalize the URL.
@@ -487,15 +487,15 @@ PrinterQueryResult GetPrinterInfo(const std::string& address,
       kPrinterInfoAndStatus.data(), &status);
   if (StatusError(status) || response.get() == nullptr) {
     LOG(WARNING) << "Get attributes failure: " << status;
-    return PrinterQueryResult::UNKNOWN_FAILURE;
+    return PrinterQueryResult::kUnknownFailure;
   }
 
   ParsePrinterStatus(response.get(), printer_status);
 
   if (ParsePrinterInfo(response.get(), printer_info)) {
-    return PrinterQueryResult::SUCCESS;
+    return PrinterQueryResult::kSuccess;
   }
-  return PrinterQueryResult::UNKNOWN_FAILURE;
+  return PrinterQueryResult::kUnknownFailure;
 }
 
 bool GetPrinterStatus(http_t* http,

printing/printer_query_result.h

@@ -14,10 +14,10 @@ namespace printing {
 // reordered. Please keep in sync with PrinterStatusQueryResult in
 // src/tools/metrics/histograms/enums.xml.
 enum class PRINTING_EXPORT PrinterQueryResult {
-  UNKNOWN_FAILURE = 0,  // catchall error
-  SUCCESS = 1,          // successful
-  UNREACHABLE = 2,      // failed to reach the host
-  kMaxValue = UNREACHABLE
+  kUnknownFailure = 0,  // catchall error
+  kSuccess = 1,         // successful
+  kUnreachable = 2,     // failed to reach the host
+  kMaxValue = kUnreachable
 };
 
 }  // namespace printing

printing/printer_status.h

@@ -22,49 +22,49 @@ struct PRINTING_EXPORT PrinterStatus {
     // reordered. Please keep in sync with PrinterStatusReasons in
     // src/tools/metrics/histograms/enums.xml.
     enum class Reason {
-      UNKNOWN_REASON = 0,
-      NONE = 1,
-      MEDIA_NEEDED = 2,
-      MEDIA_JAM = 3,
-      MOVING_TO_PAUSED = 4,
-      PAUSED = 5,
-      SHUTDOWN = 6,
-      CONNECTING_TO_DEVICE = 7,
-      TIMED_OUT = 8,
-      STOPPING = 9,
-      STOPPED_PARTLY = 10,
-      TONER_LOW = 11,
-      TONER_EMPTY = 12,
-      SPOOL_AREA_FULL = 13,
-      COVER_OPEN = 14,
-      INTERLOCK_OPEN = 15,
-      DOOR_OPEN = 16,
-      INPUT_TRAY_MISSING = 17,
-      MEDIA_LOW = 18,
-      MEDIA_EMPTY = 19,
-      OUTPUT_TRAY_MISSING = 20,
-      OUTPUT_AREA_ALMOST_FULL = 21,
-      OUTPUT_AREA_FULL = 22,
-      MARKER_SUPPLY_LOW = 23,
-      MARKER_SUPPLY_EMPTY = 24,
-      MARKER_WASTE_ALMOST_FULL = 25,
-      MARKER_WASTE_FULL = 26,
-      FUSER_OVER_TEMP = 27,
-      FUSER_UNDER_TEMP = 28,
-      OPC_NEAR_EOL = 29,
-      OPC_LIFE_OVER = 30,
-      DEVELOPER_LOW = 31,
-      DEVELOPER_EMPTY = 32,
-      INTERPRETER_RESOURCE_UNAVAILABLE = 33,
-      kMaxValue = INTERPRETER_RESOURCE_UNAVAILABLE
+      kUnknownReason = 0,
+      kNone = 1,
+      kMediaNeeded = 2,
+      kMediaJam = 3,
+      kMovingToPaused = 4,
+      kPaused = 5,
+      kShutdown = 6,
+      kConnectingToDevice = 7,
+      kTimedOut = 8,
+      kStopping = 9,
+      kStoppedPartly = 10,
+      kTonerLow = 11,
+      kTonerEmpty = 12,
+      kSpoolAreaFull = 13,
+      kCoverOpen = 14,
+      kInterlockOpen = 15,
+      kDoorOpen = 16,
+      kInputTrayMissing = 17,
+      kMediaLow = 18,
+      kMediaEmpty = 19,
+      kOutputTrayMissing = 20,
+      kOutputAreaAlmostFull = 21,
+      kOutputAreaFull = 22,
+      kMarkerSupplyLow = 23,
+      kMarkerSupplyEmpty = 24,
+      kMarkerWasteAlmostFull = 25,
+      kMarkerWasteFull = 26,
+      kFuserOverTemp = 27,
+      kFuserUnderTemp = 28,
+      kOpcNearEol = 29,
+      kOpcLifeOver = 30,
+      kDeveloperLow = 31,
+      kDeveloperEmpty = 32,
+      kInterpreterResourceUnavailable = 33,
+      kMaxValue = kInterpreterResourceUnavailable
     };
 
     // Severity of the state-reason.
     enum class Severity {
-      UNKNOWN_SEVERITY = 0,
-      REPORT = 1,
-      WARNING = 2,
-      ERROR = 3,
+      kUnknownSeverity = 0,
+      kReport = 1,
+      kWarning = 2,
+      kError = 3,
     };
 
     Reason reason;