Changes FormatURL to not strip http if the host starts with ftp or https[!a-z]. This...

net/base/net_util_unittest.cc

 // Copyright (c) 2010 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 "net/base/net_util.h"
 
 #include "base/file_path.h"
 #include "base/format_macros.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
@@ skipping 1371 matching lines @@
 
     {"omit http",
      "http://www.google.com/", L"en", net::kFormatUrlOmitHTTP,
      UnescapeRule::NORMAL, L"www.google.com/",
      0},
 
     {"omit http with https",
      "https://www.google.com/", L"en", net::kFormatUrlOmitHTTP,
      UnescapeRule::NORMAL, L"https://www.google.com/",
      8},
+
+    {"omit http starts with ftp.",
+     "http://ftp.google.com/", L"en", net::kFormatUrlOmitHTTP,
+     UnescapeRule::NORMAL, L"http://ftp.google.com/",
+     7},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     size_t prefix_len;
     std::wstring formatted = net::FormatUrl(
         GURL(tests[i].input), tests[i].languages, tests[i].format_types,
         tests[i].escape_rules, NULL, &prefix_len, NULL);
     EXPECT_EQ(tests[i].output, formatted) << tests[i].description;
     EXPECT_EQ(tests[i].prefix_len, prefix_len) << tests[i].description;
   }
@@ skipping 82 matching lines @@
       L"", net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
   EXPECT_EQ(L"host:8000/a?b=c#d", formatted);
   EXPECT_FALSE(parsed.scheme.is_valid());
   EXPECT_FALSE(parsed.username.is_valid());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_EQ(L"host", formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(L"8000", formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(L"/a", formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(L"b=c", formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(L"d", formatted.substr(parsed.ref.begin, parsed.ref.len));
+
+  // omit http starts with ftp case.
+  formatted = net::FormatUrl(
+      GURL("http://ftp.host:8000/a?b=c#d"),
+      L"", net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
+  EXPECT_EQ(L"http://ftp.host:8000/a?b=c#d", formatted);
+  EXPECT_TRUE(parsed.scheme.is_valid());
+  EXPECT_FALSE(parsed.username.is_valid());
+  EXPECT_FALSE(parsed.password.is_valid());
+  EXPECT_EQ(L"http", formatted.substr(parsed.scheme.begin, parsed.scheme.len));
+  EXPECT_EQ(L"ftp.host", formatted.substr(parsed.host.begin, parsed.host.len));
+  EXPECT_EQ(L"8000", formatted.substr(parsed.port.begin, parsed.port.len));
+  EXPECT_EQ(L"/a", formatted.substr(parsed.path.begin, parsed.path.len));
+  EXPECT_EQ(L"b=c", formatted.substr(parsed.query.begin, parsed.query.len));
+  EXPECT_EQ(L"d", formatted.substr(parsed.ref.begin, parsed.ref.len));
+
+  // omit http starts with 'f' case.
+  formatted = net::FormatUrl(
+      GURL("http://f/"),
+      L"", net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
+  EXPECT_EQ(L"f/", formatted);
+  EXPECT_FALSE(parsed.scheme.is_valid());
+  EXPECT_FALSE(parsed.username.is_valid());
+  EXPECT_FALSE(parsed.password.is_valid());
+  EXPECT_FALSE(parsed.port.is_valid());
+  EXPECT_TRUE(parsed.path.is_valid());
+  EXPECT_FALSE(parsed.query.is_valid());
+  EXPECT_FALSE(parsed.ref.is_valid());
+  EXPECT_EQ(L"f", formatted.substr(parsed.host.begin, parsed.host.len));
+  EXPECT_EQ(L"/", formatted.substr(parsed.path.begin, parsed.path.len));
 }
 
 TEST(NetUtilTest, FormatUrlAdjustOffset) {
   const AdjustOffsetCase basic_cases[] = {
     {0, 0},
     {3, 3},
     {5, 5},
     {6, 6},
     {13, 13},
     {21, 21},
@@ skipping 118 matching lines @@
     {7, 0},
     {8, 1},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(omit_http_cases); ++i) {
     size_t offset = omit_http_cases[i].input_offset;
     net::FormatUrl(GURL("http://www.google.com"), L"en",
         net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, NULL, NULL, &offset);
     EXPECT_EQ(omit_http_cases[i].output_offset, offset);
   }
 
+  const AdjustOffsetCase omit_http_start_with_ftp[] = {
+    {0, 0},
+    {3, 3},
+    {8, 8},
+  };
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(omit_http_start_with_ftp); ++i) {
+    size_t offset = omit_http_start_with_ftp[i].input_offset;
+    net::FormatUrl(GURL("http://ftp.google.com"), L"en",
+        net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, NULL, NULL, &offset);
+    EXPECT_EQ(omit_http_start_with_ftp[i].output_offset, offset);
+  }
+
   const AdjustOffsetCase omit_all_cases[] = {
     {12, 0},
     {13, 1},
     {0, std::wstring::npos},
     {3, std::wstring::npos},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(omit_all_cases); ++i) {
     size_t offset = omit_all_cases[i].input_offset;
     net::FormatUrl(GURL("http://user@foo.com/"), L"en", net::kFormatUrlOmitAll,
                    UnescapeRule::NORMAL, NULL, NULL, &offset);
@@ skipping 52 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(invalid); ++i) {
     net::SetExplicitlyAllowedPorts(invalid[i]);
     EXPECT_EQ(0, static_cast<int>(net::explicitly_allowed_ports.size()));
   }
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(valid); ++i) {
     net::SetExplicitlyAllowedPorts(valid[i]);
     EXPECT_EQ(i, net::explicitly_allowed_ports.size());
   }
 }