path: root/Source/WebKit/android/content/address_detector.cpp

/*
 * Copyright (C) 2012 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *    * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *    * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"

// Magic pretend-to-be-a-chromium-build flags
#undef WEBKIT_IMPLEMENTATION
#undef LOG

#include "content/address_detector.h"

#include <bitset>

#include "base/utf_string_conversions.h"
#include "net/base/escape.h"
#include "Settings.h"
#include "WebString.h"

#include <wtf/HashSet.h>
#include <wtf/Noncopyable.h>
#include <wtf/text/StringHash.h>
#include <wtf/text/WTFString.h>

namespace {

// Prefix used for geographical address intent URIs.
static const char kAddressSchemaPrefix[] = "geo:0,0?q=";

// Maximum text length to be searched for address detection.
static const size_t kMaxAddressLength = 500;

// Minimum number of words in an address after the house number
// before a state is expected to be found.
// A value too high can miss short addresses.
const size_t kMinAddressWords = 3;

// Maximum number of words allowed in an address between the house number
// and the state, both not included.
const size_t kMaxAddressWords = 12;

// Maximum number of lines allowed in an address between the house number
// and the state, both not included.
const size_t kMaxAddressLines = 5;

// Maximum length allowed for any address word between the house number
// and the state, both not included.
const size_t kMaxAddressNameWordLength = 25;

// Maximum number of words after the house number in which the location name
// should be found.
const size_t kMaxLocationNameDistance = 4;

// Number of digits for a valid zip code.
const size_t kZipDigits = 5;

// Number of digits for a valid zip code in the Zip Plus 4 format.
const size_t kZipPlus4Digits = 9;

// Maximum number of digits of a house number, including possible hyphens.
const size_t kMaxHouseDigits = 5;

// Additional characters used as new line delimiters.
const char16 kNewlineDelimiters[] = {
  ',',
  '*',
  0x2022,  // Unicode bullet
  0,
};

char16 SafePreviousChar(const string16::const_iterator& it,
    const string16::const_iterator& begin) {
  if (it == begin)
    return ' ';
  return *(it - 1);
}

char16 SafeNextChar(const string16::const_iterator& it,
    const string16::const_iterator& end) {
  if (it == end)
    return ' ';
  return *(it + 1);
}

bool WordLowerCaseEqualsASCII(string16::const_iterator word_begin,
    string16::const_iterator word_end, const char* ascii_to_match) {
  for (string16::const_iterator it = word_begin; it != word_end;
      ++it, ++ascii_to_match) {
    if (!*ascii_to_match || base::ToLowerASCII(*it) != *ascii_to_match)
      return false;
  }
  return *ascii_to_match == 0 || *ascii_to_match == ' ';
}

bool LowerCaseEqualsASCIIWithPlural(string16::const_iterator word_begin,
    string16::const_iterator word_end, const char* ascii_to_match,
    bool allow_plural) {
  for (string16::const_iterator it = word_begin; it != word_end;
      ++it, ++ascii_to_match) {
    if (!*ascii_to_match && allow_plural && *it == 's' && it + 1 == word_end)
      return true;

    if (!*ascii_to_match || base::ToLowerASCII(*it) != *ascii_to_match)
      return false;
  }
  return *ascii_to_match == 0;
}

}  // anonymous namespace


AddressDetector::AddressDetector() {
}

AddressDetector::~AddressDetector() {
}

std::string AddressDetector::GetContentText(const WebKit::WebRange& range) {
  // Get the address and replace unicode bullets with commas.
  string16 address_16 = CollapseWhitespace(range.toPlainText(), false);
  std::replace(address_16.begin(), address_16.end(),
      static_cast<char16>(0x2022), static_cast<char16>(','));
  return UTF16ToUTF8(address_16);
}

GURL AddressDetector::GetIntentURL(const std::string& content_text) {
  return GURL(kAddressSchemaPrefix +
      EscapeQueryParamValue(content_text, true));
}

size_t AddressDetector::GetMaximumContentLength() {
  return kMaxAddressLength;
}

bool AddressDetector::IsEnabled(const WebKit::WebHitTestInfo& hit_test) {
  WebCore::Settings* settings = GetSettings(hit_test);
  return settings && settings->formatDetectionAddress();
}

bool AddressDetector::FindContent(const string16::const_iterator& begin,
    const string16::const_iterator& end, size_t* start_pos, size_t* end_pos) {
  HouseNumberParser house_number_parser;

  // Keep going through the input string until a potential house number is
  // detected. Start tokenizing the following words to find a valid
  // street name within a word range. Then, find a state name followed
  // by a valid zip code for that state. Also keep a look for any other
  // possible house numbers to continue from in case of no match and for
  // state names not followed by a zip code (e.g. New York, NY 10000).
  const string16 newline_delimiters = kNewlineDelimiters;
  const string16 delimiters = kWhitespaceUTF16 + newline_delimiters;
  for (string16::const_iterator it = begin; it != end; ) {
    Word house_number;
    if (!house_number_parser.Parse(it, end, &house_number))
      return false;

    String16Tokenizer tokenizer(house_number.end, end, delimiters);
    tokenizer.set_options(String16Tokenizer::RETURN_DELIMS);

    std::vector<Word> words;
    words.push_back(house_number);

    bool found_location_name = false;
    bool continue_on_house_number = true;
    size_t next_house_number_word = 0;
    size_t num_lines = 1;

    // Don't include the house number in the word count.
    size_t next_word = 1;
    for (; next_word <= kMaxAddressWords + 1; ++next_word) {

      // Extract a new word from the tokenizer.
      if (next_word == words.size()) {
        do {
          if (!tokenizer.GetNext())
            return false;

          // Check the number of address lines.
          if (tokenizer.token_is_delim() && newline_delimiters.find(
              *tokenizer.token_begin()) != string16::npos) {
            ++num_lines;
          }
        } while (tokenizer.token_is_delim());

        if (num_lines > kMaxAddressLines)
          break;

        words.push_back(Word(tokenizer.token_begin(), tokenizer.token_end()));
      }

      // Check the word length. If too long, don't try to continue from
      // the next house number as no address can hold this word.
      const Word& current_word = words[next_word];
      DCHECK_GT(std::distance(current_word.begin, current_word.end), 0);
      size_t current_word_length = std::distance(
          current_word.begin, current_word.end);
      if (current_word_length > kMaxAddressNameWordLength) {
        continue_on_house_number = false;
        break;
      }

      // Check if the new word is a valid house number.
      // This is used to properly resume parsing in case the maximum number
      // of words is exceeded.
      if (next_house_number_word == 0 &&
          house_number_parser.Parse(current_word.begin, current_word.end, NULL)) {
        next_house_number_word = next_word;
        continue;
      }

      // Look for location names in the words after the house number.
      // A range limitation is introduced to avoid matching
      // anything that starts with a number before a legitimate address.
      if (next_word <= kMaxLocationNameDistance &&
          IsValidLocationName(current_word)) {
        found_location_name = true;
        continue;
      }

      // Don't count the house number.
      if (next_word > kMinAddressWords) {
        // Looking for the state is likely to add new words to the list while
        // checking for multi-word state names.
        size_t state_first_word = next_word;
        size_t state_last_word, state_index;
        if (FindStateStartingInWord(&words, state_first_word, &state_last_word,
            &tokenizer, &state_index)) {

          // A location name should have been found at this point.
          if (!found_location_name)
            break;

          // Explicitly exclude "et al", as "al" is a valid state code.
          if (current_word_length == 2 && words.size() > 2) {
            const Word& previous_word = words[state_first_word - 1];
            if (previous_word.end - previous_word.begin == 2 &&
                LowerCaseEqualsASCII(previous_word.begin, previous_word.end,
                    "et") &&
                LowerCaseEqualsASCII(current_word.begin, current_word.end,
                    "al"))
              break;
          }

          // Extract one more word from the tokenizer if not already available.
          size_t zip_word = state_last_word + 1;
          if (zip_word == words.size()) {
            do {
              if (!tokenizer.GetNext()) {
                // Zip is optional
                *start_pos = words[0].begin - begin;
                *end_pos = words[state_last_word].end - begin;
                return true;
              }
            } while (tokenizer.token_is_delim());
            words.push_back(Word(tokenizer.token_begin(),
                tokenizer.token_end()));
          }

          // Check the parsing validity and state range of the zip code.
          next_word = state_last_word;
          if (!IsZipValid(words[zip_word], state_index))
            continue;

          *start_pos = words[0].begin - begin;
          *end_pos = words[zip_word].end - begin;
          return true;
        }
      }
    }

    // Avoid skipping too many words because of a non-address number
    // at the beginning of the contents to parse.
    if (continue_on_house_number && next_house_number_word > 0) {
      it = words[next_house_number_word].begin;
    } else {
      DCHECK(!words.empty());
      next_word = std::min(next_word, words.size() - 1);
      it = words[next_word].end;
    }
  }

  return false;
}

bool AddressDetector::HouseNumberParser::IsPreDelimiter(
    char16 character) {
  return character == ':' || IsPostDelimiter(character);
}

bool AddressDetector::HouseNumberParser::IsPostDelimiter(
    char16 character) {
  return IsWhitespace(character) || strchr(",\"'", character);
}

void AddressDetector::HouseNumberParser::RestartOnNextDelimiter() {
  ResetState();
  for (; it_ != end_ && !IsPreDelimiter(*it_); ++it_) {}
}

void AddressDetector::HouseNumberParser::AcceptChars(size_t num_chars) {
  size_t offset = std::min(static_cast<size_t>(std::distance(it_, end_)),
      num_chars);
  it_ += offset;
  result_chars_ += offset;
}

void AddressDetector::HouseNumberParser::SkipChars(size_t num_chars) {
  it_ += std::min(static_cast<size_t>(std::distance(it_, end_)), num_chars);
}

void AddressDetector::HouseNumberParser::ResetState() {
  num_digits_ = 0;
  result_chars_ = 0;
}

bool AddressDetector::HouseNumberParser::CheckFinished(Word* word) const {
  // There should always be a number after a hyphen.
  if (result_chars_ == 0 || SafePreviousChar(it_, begin_) == '-')
    return false;

  if (word) {
    word->begin = it_ - result_chars_;
    word->end = it_;
  }
  return true;
}

bool AddressDetector::HouseNumberParser::Parse(
    const string16::const_iterator& begin,
    const string16::const_iterator& end, Word* word) {
  it_ = begin_ = begin;
  end_ = end;
  ResetState();

  // Iterations only used as a fail-safe against any buggy infinite loops.
  size_t iterations = 0;
  size_t max_iterations = end - begin + 1;
  for (; it_ != end_ && iterations < max_iterations; ++iterations) {

    // Word finished case.
    if (IsPostDelimiter(*it_)) {
      if (CheckFinished(word))
        return true;
      else if (result_chars_)
        ResetState();

      SkipChars(1);
      continue;
    }

    // More digits. There should be no more after a letter was found.
    if (IsAsciiDigit(*it_)) {
      if (num_digits_ >= kMaxHouseDigits) {
        RestartOnNextDelimiter();
      } else {
        AcceptChars(1);
        ++num_digits_;
      }
      continue;
    }

    if (IsAsciiAlpha(*it_)) {
      // Handle special case 'one'.
      if (result_chars_ == 0) {
        if (it_ + 3 <= end_ && LowerCaseEqualsASCII(it_, it_ + 3, "one"))
          AcceptChars(3);
        else
          RestartOnNextDelimiter();
        continue;
      }

      // There should be more than 1 character because of result_chars.
      DCHECK_GT(result_chars_, 0U);
      DCHECK_NE(it_, begin_);
      char16 previous = SafePreviousChar(it_, begin_);
      if (IsAsciiDigit(previous)) {
        // Check cases like '12A'.
        char16 next = SafeNextChar(it_, end_);
        if (IsPostDelimiter(next)) {
          AcceptChars(1);
          continue;
        }

        // Handle cases like 12a, 1st, 2nd, 3rd, 7th.
        if (IsAsciiAlpha(next)) {
          char16 last_digit = previous;
          char16 first_letter = base::ToLowerASCII(*it_);
          char16 second_letter = base::ToLowerASCII(next);
          bool is_teen = SafePreviousChar(it_ - 1, begin_) == '1' &&
              num_digits_ == 2;

          switch (last_digit - '0') {
          case 1:
            if ((first_letter == 's' && second_letter == 't') ||
                (first_letter == 't' && second_letter == 'h' && is_teen)) {
              AcceptChars(2);
              continue;
            }
            break;

          case 2:
            if ((first_letter == 'n' && second_letter == 'd') ||
                (first_letter == 't' && second_letter == 'h' && is_teen)) {
              AcceptChars(2);
              continue;
            }
            break;

          case 3:
            if ((first_letter == 'r' && second_letter == 'd') ||
                (first_letter == 't' && second_letter == 'h' && is_teen)) {
              AcceptChars(2);
              continue;
            }
            break;

          case 0:
            // Explicitly exclude '0th'.
            if (num_digits_ == 1)
              break;

          case 4:
          case 5:
          case 6:
          case 7:
          case 8:
          case 9:
            if (first_letter == 't' && second_letter == 'h') {
              AcceptChars(2);
              continue;
            }
            break;

          default:
            NOTREACHED();
          }
        }
      }

      RestartOnNextDelimiter();
      continue;
    }

    if (*it_ == '-' && num_digits_ > 0) {
      AcceptChars(1);
      ++num_digits_;
      continue;
    }

    RestartOnNextDelimiter();
    SkipChars(1);
  }

  if (iterations >= max_iterations)
    return false;

  return CheckFinished(word);
}

bool AddressDetector::FindStateStartingInWord(WordList* words,
    size_t state_first_word, size_t* state_last_word,
    String16Tokenizer* tokenizer, size_t* state_index) {

  // Bitmasks containing the allowed suffixes for 2-letter state codes.
  static const int state_two_letter_suffix[23] = {
    0x02060c00,  // A followed by: [KLRSZ].
    0x00000000,  // B.
    0x00084001,  // C followed by: [AOT].
    0x00000014,  // D followed by: [CE].
    0x00000000,  // E.
    0x00001800,  // F followed by: [LM].
    0x00100001,  // G followed by: [AU].
    0x00000100,  // H followed by: [I].
    0x00002809,  // I followed by: [ADLN].
    0x00000000,  // J.
    0x01040000,  // K followed by: [SY].
    0x00000001,  // L followed by: [A].
    0x000ce199,  // M followed by: [ADEHINOPST].
    0x0120129c,  // N followed by: [CDEHJMVY].
    0x00020480,  // O followed by: [HKR].
    0x00420001,  // P followed by: [ARW].
    0x00000000,  // Q.
    0x00000100,  // R followed by: [I].
    0x0000000c,  // S followed by: [CD].
    0x00802000,  // T followed by: [NX].
    0x00080000,  // U followed by: [T].
    0x00080101,  // V followed by: [AIT].
    0x01200101   // W followed by: [AIVY].
  };

  // Accumulative number of states for the 2-letter code indexed by the first.
  static const int state_two_letter_accumulative[24] = {
     0,  5,  5,  8, 10, 10, 12, 14,
    15, 19, 19, 21, 22, 32, 40, 43,
    46, 46, 47, 49, 51, 52, 55, 59
  };

  // State names sorted alphabetically with their lengths.
  // There can be more than one possible name for a same state if desired.
  static const struct StateNameInfo {
    const char* string;
    char first_word_length;
    char length;
    char state_index; // Relative to two-character code alphabetical order.
  } state_names[59] = {
    { "alabama", 7, 7, 1 }, { "alaska", 6, 6, 0 },
    { "american samoa", 8, 14, 3 }, { "arizona", 7, 7, 4 },
    { "arkansas", 8, 8, 2 },
    { "california", 10, 10, 5 }, { "colorado", 8, 8, 6 },
    { "connecticut", 11, 11, 7 }, { "delaware", 8, 8, 9 },
    { "district of columbia", 8, 20, 8 },
    { "federated states of micronesia", 9, 30, 11 }, { "florida", 7, 7, 10 },
    { "guam", 4, 4, 13 }, { "georgia", 7, 7, 12 },
    { "hawaii", 6, 6, 14 },
    { "idaho", 5, 5, 16 }, { "illinois", 8, 8, 17 }, { "indiana", 7, 7, 18 },
    { "iowa", 4, 4, 15 },
    { "kansas", 6, 6, 19 }, { "kentucky", 8, 8, 20 },
    { "louisiana", 9, 9, 21 },
    { "maine", 5, 5, 24 }, { "marshall islands", 8, 16, 25 },
    { "maryland", 8, 8, 23 }, { "massachusetts", 13, 13, 22 },
    { "michigan", 8, 8, 26 }, { "minnesota", 9, 9, 27 },
    { "mississippi", 11, 11, 30 }, { "missouri", 8, 8, 28 },
    { "montana", 7, 7, 31 },
    { "nebraska", 8, 8, 34 }, { "nevada", 6, 6, 38 },
    { "new hampshire", 3, 13, 35 }, { "new jersey", 3, 10, 36 },
    { "new mexico", 3, 10, 37 }, { "new york", 3, 8, 39 },
    { "north carolina", 5, 14, 32 }, { "north dakota", 5, 12, 33 },
    { "northern mariana islands", 8, 24, 29 },
    { "ohio", 4, 4, 40 }, { "oklahoma", 8, 8, 41 }, { "oregon", 6, 6, 42 },
    { "palau", 5, 5, 45 }, { "pennsylvania", 12, 12, 43 },
    { "puerto rico", 6, 11, 44 },
    { "rhode island", 5, 5, 46 },
    { "south carolina", 5, 14, 47 }, { "south dakota", 5, 12, 48 },
    { "tennessee", 9, 9, 49 }, { "texas", 5, 5, 50 },
    { "utah", 4, 4, 51 },
    { "vermont", 7, 7, 54 }, { "virgin islands", 6, 14, 53 },
    { "virginia", 8, 8, 52 },
    { "washington", 10, 10, 55 }, { "west virginia", 4, 13, 57 },
    { "wisconsin", 9, 9, 56 }, { "wyoming", 7, 7, 58 }
  };

  // Accumulative number of states for sorted names indexed by the first letter.
  // Required a different one since there are codes that don't share their
  // first letter with the name of their state (MP = Northern Mariana Islands).
  static const int state_names_accumulative[24] = {
     0,  5,  5,  8, 10, 10, 12, 14,
    15, 19, 19, 21, 22, 31, 40, 43,
    46, 46, 47, 49, 51, 52, 55, 59
  };

  DCHECK_EQ(state_names_accumulative[arraysize(state_names_accumulative) - 1],
      static_cast<int>(ARRAYSIZE_UNSAFE(state_names)));

  const Word& first_word = words->at(state_first_word);
  int length = first_word.end - first_word.begin;
  if (length < 2 || !IsAsciiAlpha(*first_word.begin))
    return false;

  // No state names start with x, y, z.
  char16 first_letter = base::ToLowerASCII(*first_word.begin);
  if (first_letter > 'w')
    return false;

  DCHECK(first_letter >= 'a');
  int first_index = first_letter - 'a';

  // Look for two-letter state names.
  if (length == 2 && IsAsciiAlpha(*(first_word.begin + 1))) {
    char16 second_letter = base::ToLowerASCII(*(first_word.begin + 1));
    DCHECK(second_letter >= 'a');

    int second_index = second_letter - 'a';
    if (!(state_two_letter_suffix[first_index] & (1 << second_index)))
      return false;

    std::bitset<32> previous_suffixes = state_two_letter_suffix[first_index] &
        ((1 << second_index) - 1);
    *state_last_word = state_first_word;
    *state_index = state_two_letter_accumulative[first_index] +
        previous_suffixes.count();
    return true;
  }

  // Look for full state names by their first letter. Discard by length.
  for (int state = state_names_accumulative[first_index];
      state < state_names_accumulative[first_index + 1]; ++state) {
    if (state_names[state].first_word_length != length)
      continue;

    bool state_match = false;
    size_t state_word = state_first_word;
    for (int pos = 0; true; ) {
      if (!WordLowerCaseEqualsASCII(words->at(state_word).begin,
          words->at(state_word).end, &state_names[state].string[pos]))
        break;

      pos += words->at(state_word).end - words->at(state_word).begin + 1;
      if (pos >= state_names[state].length) {
        state_match = true;
        break;
      }

      // Ran out of words, extract more from the tokenizer.
      if (++state_word == words->size()) {
        do {
          if (!tokenizer->GetNext())
            break;
        } while (tokenizer->token_is_delim());
        words->push_back(Word(tokenizer->token_begin(), tokenizer->token_end()));
      }
    }

    if (state_match) {
      *state_last_word = state_word;
      *state_index = state_names[state].state_index;
      return true;
    }
  }

  return false;
}

bool AddressDetector::IsZipValid(const Word& word, size_t state_index) {
  size_t length = word.end - word.begin;
  if (length != kZipDigits && length != kZipPlus4Digits + 1)
    return false;

  for (string16::const_iterator it = word.begin; it != word.end; ++it) {
    size_t pos = it - word.begin;
    if (IsAsciiDigit(*it) || (*it == '-' && pos == kZipDigits))
      continue;
    return false;
  }
  return IsZipValidForState(word, state_index);
}

bool AddressDetector::IsZipValidForState(const Word& word, size_t state_index)
{
    enum USState {
        AP = -4, // AP (military base in the Pacific)
        AA = -3, // AA (military base inside the US)
        AE = -2, // AE (military base outside the US)
        XX = -1, // (not in use)
        AK =  0, // AK Alaska
        AL =  1, // AL Alabama
        AR =  2, // AR Arkansas
        AS =  3, // AS American Samoa
        AZ =  4, // AZ Arizona
        CA =  5, // CA California
        CO =  6, // CO Colorado
        CT =  7, // CT Connecticut
        DC =  8, // DC District of Columbia
        DE =  9, // DE Delaware
        FL = 10, // FL Florida
        FM = 11, // FM Federated States of Micronesia
        GA = 12, // GA Georgia
        GU = 13, // GU Guam
        HI = 14, // HI Hawaii
        IA = 15, // IA Iowa
        ID = 16, // ID Idaho
        IL = 17, // IL Illinois
        IN = 18, // IN Indiana
        KS = 19, // KS Kansas
        KY = 20, // KY Kentucky
        LA = 21, // LA Louisiana
        MA = 22, // MA Massachusetts
        MD = 23, // MD Maryland
        ME = 24, // ME Maine
        MH = 25, // MH Marshall Islands
        MI = 26, // MI Michigan
        MN = 27, // MN Minnesota
        MO = 28, // MO Missouri
        MP = 29, // MP Northern Mariana Islands
        MS = 30, // MS Mississippi
        MT = 31, // MT Montana
        NC = 32, // NC North Carolina
        ND = 33, // ND North Dakota
        NE = 34, // NE Nebraska
        NH = 35, // NH New Hampshire
        NJ = 36, // NJ New Jersey
        NM = 37, // NM New Mexico
        NV = 38, // NV Nevada
        NY = 39, // NY New York
        OH = 40, // OH Ohio
        OK = 41, // OK Oklahoma
        OR = 42, // OR Oregon
        PA = 43, // PA Pennsylvania
        PR = 44, // PR Puerto Rico
        PW = 45, // PW Palau
        RI = 46, // RI Rhode Island
        SC = 47, // SC South Carolina
        SD = 48, // SD South Dakota
        TN = 49, // TN Tennessee
        TX = 50, // TX Texas
        UT = 51, // UT Utah
        VA = 52, // VA Virginia
        VI = 53, // VI Virgin Islands
        VT = 54, // VT Vermont
        WA = 55, // WA Washington
        WI = 56, // WI Wisconsin
        WV = 57, // WV West Virginia
        WY = 58, // WY Wyoming
    };

    static const USState stateForZipPrefix[] = {
    //   0   1   2   3   4   5   6   7   8   9
        XX, XX, XX, XX, XX, NY, PR, PR, VI, PR, // 000-009
        MA, MA, MA, MA, MA, MA, MA, MA, MA, MA, // 010-019
        MA, MA, MA, MA, MA, MA, MA, MA, RI, RI, // 020-029
        NH, NH, NH, NH, NH, NH, NH, NH, NH, ME, // 030-039
        ME, ME, ME, ME, ME, ME, ME, ME, ME, ME, // 040-049
        VT, VT, VT, VT, VT, MA, VT, VT, VT, VT, // 050-059
        CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 060-069
        NJ, NJ, NJ, NJ, NJ, NJ, NJ, NJ, NJ, NJ, // 070-079
        NJ, NJ, NJ, NJ, NJ, NJ, NJ, NJ, NJ, NJ, // 080-089
        AE, AE, AE, AE, AE, AE, AE, AE, AE, XX, // 090-099
        NY, NY, NY, NY, NY, NY, NY, NY, NY, NY, // 100-109
        NY, NY, NY, NY, NY, NY, NY, NY, NY, NY, // 110-119
        NY, NY, NY, NY, NY, NY, NY, NY, NY, NY, // 120-129
        NY, NY, NY, NY, NY, NY, NY, NY, NY, NY, // 130-139
        NY, NY, NY, NY, NY, NY, NY, NY, NY, NY, // 140-149
        PA, PA, PA, PA, PA, PA, PA, PA, PA, PA, // 150-159
        PA, PA, PA, PA, PA, PA, PA, PA, PA, PA, // 160-169
        PA, PA, PA, PA, PA, PA, PA, PA, PA, PA, // 170-179
        PA, PA, PA, PA, PA, PA, PA, PA, PA, PA, // 180-189
        PA, PA, PA, PA, PA, PA, PA, DE, DE, DE, // 190-199
        DC, VA, DC, DC, DC, DC, MD, MD, MD, MD, // 200-209
        MD, MD, MD, XX, MD, MD, MD, MD, MD, MD, // 210-219
        VA, VA, VA, VA, VA, VA, VA, VA, VA, VA, // 220-229
        VA, VA, VA, VA, VA, VA, VA, VA, VA, VA, // 230-239
        VA, VA, VA, VA, VA, VA, VA, WV, WV, WV, // 240-249
        WV, WV, WV, WV, WV, WV, WV, WV, WV, WV, // 250-259
        WV, WV, WV, WV, WV, WV, WV, WV, WV, XX, // 260-269
        NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, // 270-279
        NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, // 280-289
        SC, SC, SC, SC, SC, SC, SC, SC, SC, SC, // 290-299
        GA, GA, GA, GA, GA, GA, GA, GA, GA, GA, // 300-309
        GA, GA, GA, GA, GA, GA, GA, GA, GA, GA, // 310-319
        FL, FL, FL, FL, FL, FL, FL, FL, FL, FL, // 320-329
        FL, FL, FL, FL, FL, FL, FL, FL, FL, FL, // 330-339
        AA, FL, FL, XX, FL, XX, FL, FL, XX, FL, // 340-349
        AL, AL, AL, XX, AL, AL, AL, AL, AL, AL, // 350-359
        AL, AL, AL, AL, AL, AL, AL, AL, AL, AL, // 360-369
        TN, TN, TN, TN, TN, TN, TN, TN, TN, TN, // 370-379
        TN, TN, TN, TN, TN, TN, MS, MS, MS, MS, // 380-389
        MS, MS, MS, MS, MS, MS, MS, MS, GA, GA, // 390-399
        KY, KY, KY, KY, KY, KY, KY, KY, KY, KY, // 400-409
        KY, KY, KY, KY, KY, KY, KY, KY, KY, XX, // 410-419
        KY, KY, KY, KY, KY, KY, KY, KY, XX, XX, // 420-429
        OH, OH, OH, OH, OH, OH, OH, OH, OH, OH, // 430-439
        OH, OH, OH, OH, OH, OH, OH, OH, OH, OH, // 440-449
        OH, OH, OH, OH, OH, OH, OH, OH, OH, OH, // 450-459
        IN, IN, IN, IN, IN, IN, IN, IN, IN, IN, // 460-469
        IN, IN, IN, IN, IN, IN, IN, IN, IN, IN, // 470-479
        MI, MI, MI, MI, MI, MI, MI, MI, MI, MI, // 480-489
        MI, MI, MI, MI, MI, MI, MI, MI, MI, MI, // 490-499
        IA, IA, IA, IA, IA, IA, IA, IA, IA, IA, // 500-509
        IA, IA, IA, IA, IA, IA, IA, XX, XX, XX, // 510-519
        IA, IA, IA, IA, IA, IA, IA, IA, IA, XX, // 520-529
        WI, WI, WI, XX, WI, WI, XX, WI, WI, WI, // 530-539
        WI, WI, WI, WI, WI, WI, WI, WI, WI, WI, // 540-549
        MN, MN, XX, MN, MN, MN, MN, MN, MN, MN, // 550-559
        MN, MN, MN, MN, MN, MN, MN, MN, XX, DC, // 560-569
        SD, SD, SD, SD, SD, SD, SD, SD, XX, XX, // 570-579
        ND, ND, ND, ND, ND, ND, ND, ND, ND, XX, // 580-589
        MT, MT, MT, MT, MT, MT, MT, MT, MT, MT, // 590-599
        IL, IL, IL, IL, IL, IL, IL, IL, IL, IL, // 600-609
        IL, IL, IL, IL, IL, IL, IL, IL, IL, IL, // 610-619
        IL, XX, IL, IL, IL, IL, IL, IL, IL, IL, // 620-629
        MO, MO, XX, MO, MO, MO, MO, MO, MO, MO, // 630-639
        MO, MO, XX, XX, MO, MO, MO, MO, MO, MO, // 640-649
        MO, MO, MO, MO, MO, MO, MO, MO, MO, XX, // 650-659
        KS, KS, KS, XX, KS, KS, KS, KS, KS, KS, // 660-669
        KS, KS, KS, KS, KS, KS, KS, KS, KS, KS, // 670-679
        NE, NE, XX, NE, NE, NE, NE, NE, NE, NE, // 680-689
        NE, NE, NE, NE, XX, XX, XX, XX, XX, XX, // 690-699
        LA, LA, XX, LA, LA, LA, LA, LA, LA, XX, // 700-709
        LA, LA, LA, LA, LA, XX, AR, AR, AR, AR, // 710-719
        AR, AR, AR, AR, AR, AR, AR, AR, AR, AR, // 720-729
        OK, OK, XX, TX, OK, OK, OK, OK, OK, OK, // 730-739
        OK, OK, XX, OK, OK, OK, OK, OK, OK, OK, // 740-749
        TX, TX, TX, TX, TX, TX, TX, TX, TX, TX, // 750-759
        TX, TX, TX, TX, TX, TX, TX, TX, TX, TX, // 760-769
        TX, XX, TX, TX, TX, TX, TX, TX, TX, TX, // 770-779
        TX, TX, TX, TX, TX, TX, TX, TX, TX, TX, // 780-789
        TX, TX, TX, TX, TX, TX, TX, TX, TX, TX, // 790-799
        CO, CO, CO, CO, CO, CO, CO, CO, CO, CO, // 800-809
        CO, CO, CO, CO, CO, CO, CO, XX, XX, XX, // 810-819
        WY, WY, WY, WY, WY, WY, WY, WY, WY, WY, // 820-829
        WY, WY, ID, ID, ID, ID, ID, ID, ID, XX, // 830-839
        UT, UT, UT, UT, UT, UT, UT, UT, XX, XX, // 840-849
        AZ, AZ, AZ, AZ, XX, AZ, AZ, AZ, XX, AZ, // 850-859
        AZ, XX, XX, AZ, AZ, AZ, XX, XX, XX, XX, // 860-869
        NM, NM, NM, NM, NM, NM, XX, NM, NM, NM, // 870-879
        NM, NM, NM, NM, NM, TX, XX, XX, XX, NV, // 880-889
        NV, NV, XX, NV, NV, NV, XX, NV, NV, XX, // 890-899
        CA, CA, CA, CA, CA, CA, CA, CA, CA, XX, // 900-909
        CA, CA, CA, CA, CA, CA, CA, CA, CA, CA, // 910-919
        CA, CA, CA, CA, CA, CA, CA, CA, CA, XX, // 920-929
        CA, CA, CA, CA, CA, CA, CA, CA, CA, CA, // 930-939
        CA, CA, CA, CA, CA, CA, CA, CA, CA, CA, // 940-949
        CA, CA, CA, CA, CA, CA, CA, CA, CA, CA, // 950-959
        CA, CA, AP, AP, AP, AP, AP, HI, HI, GU, // 960-969
        OR, OR, OR, OR, OR, OR, OR, OR, OR, OR, // 970-979
        WA, WA, WA, WA, WA, WA, WA, XX, WA, WA, // 980-989
        WA, WA, WA, WA, WA, AK, AK, AK, AK, AK, // 990-999
    };

    if (!word.begin || !word.end || (word.end - word.begin) < 3)
        return false;
    const char16* zipPtr = word.begin;
    if (zipPtr[0] < '0' || zipPtr[0] > '9' ||
        zipPtr[1] < '0' || zipPtr[1] > '9' ||
        zipPtr[2] < '0' || zipPtr[2] > '9')
        return false;

    int zip = zipPtr[0] - '0';
    zip *= 10;
    zip += zipPtr[1] - '0';
    zip *= 10;
    zip += zipPtr[2] - '0';
    return stateForZipPrefix[zip] == (int) state_index;
}

static const char* s_rawStreetSuffixes[] = {
    "allee", "alley", "ally", "aly",
    "anex", "annex", "anx", "arc", "arcade", "av", "ave", "aven", "avenu",
    "avenue", "avn", "avnue", "bayoo", "bayou", "bch", "beach", "bend",
    "bg", "bgs", "blf", "blfs", "bluf", "bluff", "bluffs", "blvd", "bnd",
    "bot", "bottm", "bottom", "boul", "boulevard", "boulv", "br", "branch",
    "brdge", "brg", "bridge", "brk", "brks", "brnch", "brook", "brooks",
    "btm", "burg", "burgs", "byp", "bypa", "bypas", "bypass", "byps", "byu",
    "camp", "canyn", "canyon", "cape", "causeway", "causway", "cen", "cent",
    "center", "centers", "centr", "centre", "cir", "circ", "circl",
    "circle", "circles", "cirs", "ck", "clb", "clf", "clfs", "cliff",
    "cliffs", "club", "cmn", "cmp", "cnter", "cntr", "cnyn", "common",
    "cor", "corner", "corners", "cors", "course", "court", "courts", "cove",
    "coves", "cp", "cpe", "cr", "crcl", "crcle", "crecent", "creek", "cres",
    "crescent", "cresent", "crest", "crk", "crossing", "crossroad",
    "crscnt", "crse", "crsent", "crsnt", "crssing", "crssng", "crst", "crt",
    "cswy", "ct", "ctr", "ctrs", "cts", "curv", "curve", "cv", "cvs", "cyn",
    "dale", "dam", "div", "divide", "dl", "dm", "dr", "driv", "drive",
    "drives", "drs", "drv", "dv", "dvd", "est", "estate", "estates", "ests",
    "exp", "expr", "express", "expressway", "expw", "expy", "ext",
    "extension", "extensions", "extn", "extnsn", "exts", "fall", "falls",
    "ferry", "field", "fields", "flat", "flats", "fld", "flds", "fls",
    "flt", "flts", "ford", "fords", "forest", "forests", "forg", "forge",
    "forges", "fork", "forks", "fort", "frd", "frds", "freeway", "freewy",
    "frg", "frgs", "frk", "frks", "frry", "frst", "frt", "frway", "frwy",
    "fry", "ft", "fwy", "garden", "gardens", "gardn", "gateway", "gatewy",
    "gatway", "gdn", "gdns", "glen", "glens", "gln", "glns", "grden",
    "grdn", "grdns", "green", "greens", "grn", "grns", "grov", "grove",
    "groves", "grv", "grvs", "gtway", "gtwy", "harb", "harbor", "harbors",
    "harbr", "haven", "havn", "hbr", "hbrs", "height", "heights", "hgts",
    "highway", "highwy", "hill", "hills", "hiway", "hiwy", "hl", "hllw",
    "hls", "hollow", "hollows", "holw", "holws", "hrbor", "ht", "hts",
    "hvn", "hway", "hwy", "inlet", "inlt", "is", "island", "islands",
    "isle", "isles", "islnd", "islnds", "iss", "jct", "jction", "jctn",
    "jctns", "jcts", "junction", "junctions", "junctn", "juncton", "key",
    "keys", "knl", "knls", "knol", "knoll", "knolls", "ky", "kys", "la",
    "lake", "lakes", "land", "landing", "lane", "lanes", "lck", "lcks",
    "ldg", "ldge", "lf", "lgt", "lgts", "light", "lights", "lk", "lks",
    "ln", "lndg", "lndng", "loaf", "lock", "locks", "lodg", "lodge", "loop",
    "loops", "mall", "manor", "manors", "mdw", "mdws", "meadow", "meadows",
    "medows", "mews", "mill", "mills", "mission", "missn", "ml", "mls",
    "mnr", "mnrs", "mnt", "mntain", "mntn", "mntns", "motorway", "mount",
    "mountain", "mountains", "mountin", "msn", "mssn", "mt", "mtin", "mtn",
    "mtns", "mtwy", "nck", "neck", "opas", "orch", "orchard", "orchrd",
    "oval", "overpass", "ovl", "park", "parks", "parkway", "parkways",
    "parkwy", "pass", "passage", "path", "paths", "pike", "pikes", "pine",
    "pines", "pk", "pkway", "pkwy", "pkwys", "pky", "pl", "place", "plain",
    "plaines", "plains", "plaza", "pln", "plns", "plz", "plza", "pne",
    "pnes", "point", "points", "port", "ports", "pr", "prairie", "prarie",
    "prk", "prr", "prt", "prts", "psge", "pt", "pts", "rad", "radial",
    "radiel", "radl", "ramp", "ranch", "ranches", "rapid", "rapids", "rd",
    "rdg", "rdge", "rdgs", "rds", "real", "rest", "ridge", "ridges", "riv", "river",
    "rivr", "rnch", "rnchs", "road", "roads", "route", "row", "rpd", "rpds",
    "rst", "rte", "rue", "run", "rvr", "shl", "shls", "shoal", "shoals",
    "shoar", "shoars", "shore", "shores", "shr", "shrs", "skwy", "skyway",
    "smt", "spg", "spgs", "spng", "spngs", "spring", "springs", "sprng",
    "sprngs", "spur", "spurs", "sq", "sqr", "sqre", "sqrs", "sqs", "squ",
    "square", "squares", "st", "sta", "station", "statn", "stn", "str",
    "stra", "strav", "strave", "straven", "stravenue", "stravn", "stream",
    "street", "streets", "streme", "strm", "strt", "strvn", "strvnue",
    "sts", "sumit", "sumitt", "summit", "ter", "terr", "terrace",
    "throughway", "tpk", "tpke", "tr", "trace", "traces", "track", "tracks",
    "trafficway", "trail", "trails", "trak", "trce", "trfy", "trk", "trks",
    "trl", "trls", "trnpk", "trpk", "trwy", "tunel", "tunl", "tunls",
    "tunnel", "tunnels", "tunnl", "turnpike", "turnpk", "un", "underpass",
    "union", "unions", "uns", "upas", "valley", "valleys", "vally", "vdct",
    "via", "viadct", "viaduct", "view", "views", "vill", "villag",
    "village", "villages", "ville", "villg", "villiage", "vis", "vist",
    "vista", "vl", "vlg", "vlgs", "vlly", "vly", "vlys", "vst", "vsta",
    "vw", "vws", "walk", "walks", "wall", "way", "ways", "well", "wells",
    "wl", "wls", "wy", "xing", "xrd",
    0,
};

bool AddressDetector::IsValidLocationName(const Word& word) {
    using namespace WTF;
    static HashSet<String> streetNames;
    if (!streetNames.size()) {
        const char** suffixes = s_rawStreetSuffixes;
        while (const char* suffix = *suffixes) {
            int index = suffix[0] - 'a';
            streetNames.add(suffix);
            suffixes++;
        }
    }
    char16 first_letter = base::ToLowerASCII(*word.begin);
    if (first_letter > 'z' || first_letter < 'a')
        return false;
    int index = first_letter - 'a';
    int length = std::distance(word.begin, word.end);
    if (*word.end == '.')
        length--;
    String value(word.begin, length);
    return streetNames.contains(value.lower());
}