root/chrome/browser/history/url_utils.cc

DEFINITIONS

1. GetURLCharPriority
2. CanonicalURLStringCompare
3. HaveSameSchemeHostAndPort
4. IsPathPrefix
5. ToggleHTTPAndHTTPS

// 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 "chrome/browser/history/url_utils.h"

#include <algorithm>

namespace history {

namespace {

// Comparator to enforce '\0' < '?' < '#' < '/' < other characters.
int GetURLCharPriority(char ch) {
  switch (ch) {
    case '\0': return 0;
    case '?': return 1;
    case '#': return 2;
    case '/': return 3;
  }
  return 4;
}

}  // namespace

// Instead of splitting URLs and extract path components, we can implement
// CanonicalURLStringCompare() using string operations only. The key idea is,
// treating '/' to be less than any valid path characters would make it behave
// as a separator, so e.g., "test" < "test-case" would be enforced by
// "test/..." < "test-case/...". We also force "?" < "/", so "test?query" <
// "test/stuff". Since the routine is merely lexicographical string comparison
// with remapping of chracter ordering, so it is a valid strict-weak ordering.
bool CanonicalURLStringCompare(const std::string& s1, const std::string& s2) {
  const std::string::value_type* ch1 = s1.c_str();
  const std::string::value_type* ch2 = s2.c_str();
  while (*ch1 && *ch2 && *ch1 == *ch2) {
    ++ch1;
    ++ch2;
  }
  int pri_diff = GetURLCharPriority(*ch1) - GetURLCharPriority(*ch2);
  // We want false to be returned if |pri_diff| > 0.
  return (pri_diff != 0) ? pri_diff < 0 : *ch1 < *ch2;
}

bool HaveSameSchemeHostAndPort(const GURL&url1, const GURL& url2) {
  return url1.scheme() == url2.scheme() && url1.host() == url2.host() &&
      url1.port() == url2.port();
}

bool IsPathPrefix(const std::string& p1, const std::string& p2) {
  if (p1.length() > p2.length())
    return false;
  std::pair<std::string::const_iterator, std::string::const_iterator>
      first_diff = std::mismatch(p1.begin(), p1.end(), p2.begin());
  // Necessary condition: |p1| is a string prefix of |p2|.
  if (first_diff.first != p1.end())
    return false;  // E.g.: (|p1| = "/test", |p2| = "/exam") => false.

  // |p1| is string prefix.
  if (first_diff.second == p2.end())  // Is exact match?
    return true;  // E.g.: ("/test", "/test") => true.
  // |p1| is strict string prefix, check full match of last path component.
  if (!p1.empty() && *p1.rbegin() == '/')  // Ends in '/'?
    return true;  // E.g.: ("/test/", "/test/stuff") => true.

  // Finally, |p1| does not end in "/": check first extra character in |p2|.
  // E.g.: ("/test", "/test/stuff") => true; ("/test", "/testing") => false.
  return *(first_diff.second) == '/';
}

GURL ToggleHTTPAndHTTPS(const GURL& url) {
  std::string new_scheme;
  if (url.SchemeIs("http"))
    new_scheme = "https";
  else if (url.SchemeIs("https"))
    new_scheme = "http";
  else
    return GURL::EmptyGURL();
  url_parse::Component comp;
  comp.len = new_scheme.length();
  GURL::Replacements replacement;
  replacement.SetScheme(new_scheme.c_str(), comp);
  return url.ReplaceComponents(replacement);
}

}  // namespace history