0

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/+/2399566
Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Gavin Williams <gavinwill@chromium.org>
Cr-Commit-Position: refs/heads/master@{#805397}
This commit is contained in:
Gavin Williams
2020-09-09 18:05:50 +00:00
committed by Commit Bot
parent 4eb4ce4f3b
commit 9653f48f0f
10 changed files with 208 additions and 208 deletions

@ -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;
}
}

@ -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

@ -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.

@ -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;

@ -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);

@ -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));
}

@ -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),

@ -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,

@ -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

@ -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;