Replace base::str[n]casecmp with helper functions.

printing/backend/cups_helper.cc

 // Copyright (c) 2012 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 "printing/backend/cups_helper.h"
 
 #include <cups/ppd.h>
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
@@ skipping 31 matching lines @@
                     const std::string& printer_name,
                     int* num_options, cups_option_t** options) {
   std::string content;
   if (!base::ReadFileToString(filepath, &content))
     return;
 
   const char kDest[] = "dest";
   const char kDefault[] = "default";
   const size_t kDestLen = sizeof(kDest) - 1;
   const size_t kDefaultLen = sizeof(kDefault) - 1;
-  std::vector<std::string> lines;
-  base::SplitString(content, '\n', &lines);
 
-  for (size_t i = 0; i < lines.size(); ++i) {
-    std::string line = lines[i];
-    if (line.empty())
-      continue;
-
-    if (base::strncasecmp (line.c_str(), kDefault, kDefaultLen) == 0 &&
+  for (base::StringPiece line :
+       base::SplitStringPiece(content, "\n", base::KEEP_WHITESPACE,
+                              base::SPLIT_WANT_NONEMPTY)) {
+    if (base::StartsWith(line, base::StringPiece(kDefault, kDefaultLen),
+                         base::CompareCase::INSENSITIVE_ASCII) &&
         isspace(line[kDefaultLen])) {
       line = line.substr(kDefaultLen);
-    } else if (base::strncasecmp (line.c_str(), kDest, kDestLen) == 0 &&
+    } else if (base::StartsWith(line, base::StringPiece(kDest, kDestLen),
+                                base::CompareCase::INSENSITIVE_ASCII) &&
                isspace(line[kDestLen])) {
       line = line.substr(kDestLen);
     } else {
       continue;
     }
 
-    base::TrimWhitespaceASCII(line, base::TRIM_ALL, &line);
+    line = base::TrimWhitespaceASCII(line, base::TRIM_ALL);
     if (line.empty())
       continue;
 
     size_t space_found = line.find(' ');
-    if (space_found == std::string::npos)
+    if (space_found == base::StringPiece::npos)
       continue;
 
-    std::string name = line.substr(0, space_found);
+    base::StringPiece name = line.substr(0, space_found);
     if (name.empty())
       continue;
 
-    if (base::strncasecmp(printer_name.c_str(), name.c_str(),
-                          name.length()) != 0) {
+    if (!base::EqualsCaseInsensitiveASCII(printer_name, name))
       continue;  // This is not the required printer.
-    }
 
     line = line.substr(space_found + 1);
     // Remove extra spaces.
-    base::TrimWhitespaceASCII(line, base::TRIM_ALL, &line);
+    line = base::TrimWhitespaceASCII(line, base::TRIM_ALL);
     if (line.empty())
       continue;
-    // Parse the selected printer custom options.
-    *num_options = cupsParseOptions(line.c_str(), 0, options);
+    // Parse the selected printer custom options. Need to pass a
+    // null-terminated string.
+    *num_options = cupsParseOptions(line.as_string().c_str(), 0, options);
   }
 }
 
 void MarkLpOptions(const std::string& printer_name, ppd_file_t** ppd) {
   cups_option_t* options = NULL;
   int num_options = 0;
 
   const char kSystemLpOptionPath[] = "/etc/cups/lpoptions";
   const char kUserLpOptionPath[] = ".cups/lpoptions";
 
@@ skipping 46 matching lines @@
     *color_model_for_color = printing::KCMY;
   else if (ppdFindChoice(color_model, printing::kCMY_K))
     *color_model_for_color = printing::CMY_K;
 
   ppd_choice_t* marked_choice = ppdFindMarkedChoice(ppd, kColorModel);
   if (!marked_choice)
     marked_choice = ppdFindChoice(color_model, color_model->defchoice);
 
   if (marked_choice) {
     *color_is_default =
-        (base::strcasecmp(marked_choice->choice, printing::kBlack) != 0) &&
-        (base::strcasecmp(marked_choice->choice, printing::kGray) != 0) &&
-        (base::strcasecmp(marked_choice->choice, printing::kGrayscale) != 0);
+        !base::EqualsCaseInsensitiveASCII(marked_choice->choice,
+                                          printing::kBlack) &&
+        !base::EqualsCaseInsensitiveASCII(marked_choice->choice,
+                                          printing::kGray) &&
+        !base::EqualsCaseInsensitiveASCII(marked_choice->choice,
+                                          printing::kGrayscale);
   }
   return true;
 }
 
 bool GetPrintOutModeColorSettings(ppd_file_t* ppd,
                                   ColorModel* color_model_for_black,
                                   ColorModel* color_model_for_color,
                                   bool* color_is_default) {
   ppd_option_t* printout_mode = ppdFindOption(ppd, kPrintoutMode);
   if (!printout_mode)
@@ skipping 10 matching lines @@
     *color_model_for_black = printing::PRINTOUTMODE_NORMAL_GRAY;
 
   // Get the default marked choice to identify the default color setting
   // value.
   ppd_choice_t* printout_mode_choice = ppdFindMarkedChoice(ppd, kPrintoutMode);
   if (!printout_mode_choice) {
       printout_mode_choice = ppdFindChoice(printout_mode,
                                            printout_mode->defchoice);
   }
   if (printout_mode_choice) {
-    if ((base::strcasecmp(printout_mode_choice->choice,
-                          printing::kNormalGray) == 0) ||
-        (base::strcasecmp(printout_mode_choice->choice, kHighGray) == 0) ||
-        (base::strcasecmp(printout_mode_choice->choice, kDraftGray) == 0)) {
+    if (base::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
+                                         printing::kNormalGray) ||
+        base::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
+                                         kHighGray) ||
+        base::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
+                                          kDraftGray)) {
       *color_model_for_black = printing::PRINTOUTMODE_NORMAL_GRAY;
       *color_is_default = false;
     }
   }
   return true;
 }
 
 bool GetColorModeSettings(ppd_file_t* ppd,
                           ColorModel* color_model_for_black,
                           ColorModel* color_model_for_color,
                           bool* color_is_default) {
   // Samsung printers use "ColorMode" attribute in their ppds.
   ppd_option_t* color_mode_option = ppdFindOption(ppd, kColorMode);
   if (!color_mode_option)
     return false;
 
   if (ppdFindChoice(color_mode_option, printing::kColor))
     *color_model_for_color = printing::COLORMODE_COLOR;
 
   if (ppdFindChoice(color_mode_option, printing::kMonochrome))
     *color_model_for_black = printing::COLORMODE_MONOCHROME;
 
   ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kColorMode);
   if (!mode_choice) {
     mode_choice = ppdFindChoice(color_mode_option,
                                 color_mode_option->defchoice);
   }
 
   if (mode_choice) {
-    *color_is_default =
-        (base::strcasecmp(mode_choice->choice, printing::kColor) == 0);
+    *color_is_default = base::EqualsCaseInsensitiveASCII(
+        mode_choice->choice, printing::kColor);
   }
   return true;
 }
 
 bool GetHPColorSettings(ppd_file_t* ppd,
                         ColorModel* color_model_for_black,
                         ColorModel* color_model_for_color,
                         bool* color_is_default) {
   // HP printers use "Color/Color Model" attribute in their ppds.
   ppd_option_t* color_mode_option = ppdFindOption(ppd, printing::kColor);
   if (!color_mode_option)
     return false;
 
   if (ppdFindChoice(color_mode_option, printing::kColor))
     *color_model_for_color = printing::HP_COLOR_COLOR;
   if (ppdFindChoice(color_mode_option, printing::kBlack))
     *color_model_for_black = printing::HP_COLOR_BLACK;
 
   ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kColorMode);
   if (!mode_choice) {
     mode_choice = ppdFindChoice(color_mode_option,
                                 color_mode_option->defchoice);
   }
   if (mode_choice) {
-    *color_is_default =
-        (base::strcasecmp(mode_choice->choice, printing::kColor) == 0);
+    *color_is_default = base::EqualsCaseInsensitiveASCII(
+        mode_choice->choice, printing::kColor);
   }
   return true;
 }
 
 bool GetProcessColorModelSettings(ppd_file_t* ppd,
                                   ColorModel* color_model_for_black,
                                   ColorModel* color_model_for_color,
                                   bool* color_is_default) {
   // Canon printers use "ProcessColorModel" attribute in their ppds.
   ppd_option_t* color_mode_option =  ppdFindOption(ppd, kProcessColorModel);
   if (!color_mode_option)
     return false;
 
   if (ppdFindChoice(color_mode_option, printing::kRGB))
     *color_model_for_color = printing::PROCESSCOLORMODEL_RGB;
   else if (ppdFindChoice(color_mode_option, printing::kCMYK))
     *color_model_for_color = printing::PROCESSCOLORMODEL_CMYK;
 
   if (ppdFindChoice(color_mode_option, printing::kGreyscale))
     *color_model_for_black = printing::PROCESSCOLORMODEL_GREYSCALE;
 
   ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kProcessColorModel);
   if (!mode_choice) {
     mode_choice = ppdFindChoice(color_mode_option,
                                 color_mode_option->defchoice);
   }
 
   if (mode_choice) {
-    *color_is_default =
-        (base::strcasecmp(mode_choice->choice, printing::kGreyscale) != 0);
+    *color_is_default = !base::EqualsCaseInsensitiveASCII(
+        mode_choice->choice, printing::kGreyscale);
   }
   return true;
 }
 
 bool GetColorModelSettings(ppd_file_t* ppd,
                            ColorModel* cm_black,
                            ColorModel* cm_color,
                            bool* is_color) {
   bool is_color_device = false;
   ppd_attr_t* attr = ppdFindAttr(ppd, kColorDevice, NULL);
@@ skipping 82 matching lines @@
 
   ppd_choice_t* duplex_choice = ppdFindMarkedChoice(ppd, kDuplex);
   if (!duplex_choice) {
     ppd_option_t* option = ppdFindOption(ppd, kDuplex);
     if (option)
       duplex_choice = ppdFindChoice(option, option->defchoice);
   }
 
   if (duplex_choice) {
     caps.duplex_capable = true;
-    if (base::strcasecmp(duplex_choice->choice, kDuplexNone) != 0)
+    if (!base::EqualsCaseInsensitiveASCII(duplex_choice->choice, kDuplexNone))
       caps.duplex_default = printing::LONG_EDGE;
     else
       caps.duplex_default = printing::SIMPLEX;
   }
 
   bool is_color = false;
   ColorModel cm_color = UNKNOWN_COLOR_MODEL, cm_black = UNKNOWN_COLOR_MODEL;
   if (!GetColorModelSettings(ppd, &cm_black, &cm_color, &is_color)) {
     VLOG(1) << "Unknown printer color model";
   }
@@ skipping 34 matching lines @@
   }
 
   ppdClose(ppd);
   base::DeleteFile(ppd_file_path, false);
 
   *printer_info = caps;
   return true;
 }
 
 }  // namespace printing