Commit 9653f48f authored by Gavin Williams's avatar Gavin Williams Committed by Commit Bot

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: default avatarLei Zhang <thestig@chromium.org>
Commit-Queue: Gavin Williams <gavinwill@chromium.org>
Cr-Commit-Position: refs/heads/master@{#805397}
parent 4eb4ce4f
......@@ -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;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment