[CUPS] WebUI handler for CUPS printing: Retrieve the printer list from user preference.

url/url_util.cc

 // Copyright 2013 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 "url/url_util.h"
 
 #include <stddef.h>
 #include <string.h>
 #include <vector>
 
@@ skipping 22 matching lines @@
   {kWssScheme, SCHEME_WITH_PORT},   // WebSocket secure.
   {kFileSystemScheme, SCHEME_WITHOUT_AUTHORITY},
 };
 
 const int kNumReferrerURLSchemes = 2;
 const SchemeWithType kReferrerURLSchemes[kNumReferrerURLSchemes] = {
   {kHttpScheme, SCHEME_WITH_PORT},
   {kHttpsScheme, SCHEME_WITH_PORT},
 };
 
+const int kNumPrinterURLSchemes = 4;
+const SchemeWithType kPrinterURLSchemes[kNumPrinterURLSchemes] = {
+    {kPrinterIppScheme, SCHEME_WITH_PORT},
+    {kPrinterIppsScheme, SCHEME_WITH_PORT},
+    {kPrinterLpdScheme, SCHEME_WITH_PORT},
+    {kPrinterSocketScheme, SCHEME_WITH_PORT},
+};
+
 // Lists of the currently installed standard and referrer schemes. These lists
 // are lazily initialized by InitStandardSchemes and InitReferrerSchemes and are
 // leaked on shutdown to prevent any destructors from being called that will
 // slow us down or cause problems.
 std::vector<SchemeWithType>* standard_schemes = nullptr;
 std::vector<SchemeWithType>* referrer_schemes = nullptr;
+std::vector<SchemeWithType>* printer_schemes = nullptr;
 
 // See the LockSchemeRegistries declaration in the header.
 bool scheme_registries_locked = false;
 
 // This template converts a given character type to the corresponding
 // StringPiece type.
 template<typename CHAR> struct CharToStringPiece {
 };
 template<> struct CharToStringPiece<char> {
   typedef base::StringPiece Piece;
@@ skipping 18 matching lines @@
 void InitStandardSchemes() {
   InitSchemes(&standard_schemes, kStandardURLSchemes, kNumStandardURLSchemes);
 }
 
 // Ensures that the referrer_schemes list is initialized, does nothing if
 // it already has values.
 void InitReferrerSchemes() {
   InitSchemes(&referrer_schemes, kReferrerURLSchemes, kNumReferrerURLSchemes);
 }
 
+// Ensures that the printer_schemes list is initialized, does nothing if it
+// already has values.
+void InitPrinterSchemes() {
+  InitSchemes(&printer_schemes, kPrinterURLSchemes, kNumPrinterURLSchemes);
+}
+
 // Given a string and a range inside the string, compares it to the given
 // lower-case |compare_to| buffer.
 template<typename CHAR>
 inline bool DoCompareSchemeComponent(const CHAR* spec,
                                      const Component& component,
                                      const char* compare_to) {
   if (!component.is_nonempty())
     return compare_to[0] == 0;  // When component is empty, match empty scheme.
   return base::LowerCaseEqualsASCII(
       typename CharToStringPiece<CHAR>::Piece(
@@ skipping 21 matching lines @@
   }
   return false;
 }
 
 template<typename CHAR>
 bool DoIsStandard(const CHAR* spec, const Component& scheme, SchemeType* type) {
   InitStandardSchemes();
   return DoIsInSchemes(spec, scheme, type, *standard_schemes);
 }
 
+template <typename CHAR>
+bool IsPrinterScheme(const CHAR* spec,
+                     const Component& scheme,
+                     SchemeType* type) {
+  InitPrinterSchemes();
+  return DoIsInSchemes(spec, scheme, type, *printer_schemes);
+}
 
 template<typename CHAR>
 bool DoFindAndCompareScheme(const CHAR* str,
                             int str_len,
                             const char* compare,
                             Component* found_scheme) {
   // Before extracting scheme, canonicalize the URL to remove any whitespace.
   // This matches the canonicalization done in DoCanonicalize function.
   RawCanonOutputT<CHAR> whitespace_buffer;
   int spec_len;
@@ skipping 59 matching lines @@
     ParseFileURL(spec, spec_len, &parsed_input);
     success = CanonicalizeFileURL(spec, spec_len, parsed_input,
                                   charset_converter, output, output_parsed);
   } else if (DoCompareSchemeComponent(spec, scheme, url::kFileSystemScheme)) {
     // Filesystem URLs are special.
     ParseFileSystemURL(spec, spec_len, &parsed_input);
     success = CanonicalizeFileSystemURL(spec, spec_len, parsed_input,
                                         charset_converter, output,
                                         output_parsed);
 
-  } else if (DoIsStandard(spec, scheme, &unused_scheme_type)) {
+  } else if (DoIsStandard(spec, scheme, &unused_scheme_type) ||
+             IsPrinterScheme(spec, scheme, &unused_scheme_type)) {
     // All "normal" URLs.
     ParseStandardURL(spec, spec_len, &parsed_input);
     success = CanonicalizeStandardURL(spec, spec_len, parsed_input,
                                       charset_converter, output, output_parsed);
 
   } else if (DoCompareSchemeComponent(spec, scheme, url::kMailToScheme)) {
     // Mailto URLs are treated like standard URLs, with only a scheme, path,
     // and query.
     ParseMailtoURL(spec, spec_len, &parsed_input);
     success = CanonicalizeMailtoURL(spec, spec_len, parsed_input, output,
@@ skipping 404 matching lines @@
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 bool CompareSchemeComponent(const base::char16* spec,
                             const Component& component,
                             const char* compare_to) {
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 }  // namespace url