Support address detection

Change-Id: I88b6ebfb4c967e954a2420592a58af3ed188226d

4 files changed, 1159 insertions, 0 deletions

diff --git a/Source/WebKit/android/content/address_detector.cpp b/Source/WebKit/android/content/address_detector.cpp
new file mode 100644
index 0000000..d5ab6e8
--- /dev/null
+++ b/Source/WebKit/android/content/address_detector.cpp
@@ -0,0 +1,839 @@
+/*
+ * 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 "WebString.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
+};
+
+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::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())
+                return false;
+            } 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) {
+  // List of valid zip code ranges.
+  static const struct {
+    char low;
+    char high;
+    char exception1;
+    char exception2;
+  } zip_range[] = {
+    { 99, 99, -1, -1 }, // AK Alaska.
+    { 35, 36, -1, -1 }, // AL Alabama.
+    { 71, 72, -1, -1 }, // AR Arkansas.
+    { 96, 96, -1, -1 }, // AS American Samoa.
+    { 85, 86, -1, -1 }, // AZ Arizona.
+    { 90, 96, -1, -1 }, // CA California.
+    { 80, 81, -1, -1 }, // CO Colorado.
+    {  6,  6, -1, -1 }, // CT Connecticut.
+    { 20, 20, -1, -1 }, // DC District of Columbia.
+    { 19, 19, -1, -1 }, // DE Delaware.
+    { 32, 34, -1, -1 }, // FL Florida.
+    { 96, 96, -1, -1 }, // FM Federated States of Micronesia.
+    { 30, 31, -1, -1 }, // GA Georgia.
+    { 96, 96, -1, -1 }, // GU Guam.
+    { 96, 96, -1, -1 }, // HI Hawaii.
+    { 50, 52, -1, -1 }, // IA Iowa.
+    { 83, 83, -1, -1 }, // ID Idaho.
+    { 60, 62, -1, -1 }, // IL Illinois.
+    { 46, 47, -1, -1 }, // IN Indiana.
+    { 66, 67, 73, -1 }, // KS Kansas.
+    { 40, 42, -1, -1 }, // KY Kentucky.
+    { 70, 71, -1, -1 }, // LA Louisiana.
+    {  1,  2, -1, -1 }, // MA Massachusetts.
+    { 20, 21, -1, -1 }, // MD Maryland.
+    {  3,  4, -1, -1 }, // ME Maine.
+    { 96, 96, -1, -1 }, // MH Marshall Islands.
+    { 48, 49, -1, -1 }, // MI Michigan.
+    { 55, 56, -1, -1 }, // MN Minnesota.
+    { 63, 65, -1, -1 }, // MO Missouri.
+    { 96, 96, -1, -1 }, // MP Northern Mariana Islands.
+    { 38, 39, -1, -1 }, // MS Mississippi.
+    { 55, 56, -1, -1 }, // MT Montana.
+    { 27, 28, -1, -1 }, // NC North Carolina.
+    { 58, 58, -1, -1 }, // ND North Dakota.
+    { 68, 69, -1, -1 }, // NE Nebraska.
+    {  3,  4, -1, -1 }, // NH New Hampshire.
+    {  7,  8, -1, -1 }, // NJ New Jersey.
+    { 87, 88, 86, -1 }, // NM New Mexico.
+    { 88, 89, 96, -1 }, // NV Nevada.
+    { 10, 14,  0,  6 }, // NY New York.
+    { 43, 45, -1, -1 }, // OH Ohio.
+    { 73, 74, -1, -1 }, // OK Oklahoma.
+    { 97, 97, -1, -1 }, // OR Oregon.
+    { 15, 19, -1, -1 }, // PA Pennsylvania.
+    {  6,  6,  0,  9 }, // PR Puerto Rico.
+    { 96, 96, -1, -1 }, // PW Palau.
+    {  2,  2, -1, -1 }, // RI Rhode Island.
+    { 29, 29, -1, -1 }, // SC South Carolina.
+    { 57, 57, -1, -1 }, // SD South Dakota.
+    { 37, 38, -1, -1 }, // TN Tennessee.
+    { 75, 79, 87, 88 }, // TX Texas.
+    { 84, 84, -1, -1 }, // UT Utah.
+    { 22, 24, 20, -1 }, // VA Virginia.
+    {  6,  9, -1, -1 }, // VI Virgin Islands.
+    {  5,  5, -1, -1 }, // VT Vermont.
+    { 98, 99, -1, -1 }, // WA Washington.
+    { 53, 54, -1, -1 }, // WI Wisconsin.
+    { 24, 26, -1, -1 }, // WV West Virginia.
+    { 82, 83, -1, -1 }  // WY Wyoming.
+  };
+
+  // Zip numeric value for the first two characters.
+  DCHECK(word.begin != word.end);
+  DCHECK(IsAsciiDigit(*word.begin));
+  DCHECK(IsAsciiDigit(*(word.begin + 1)));
+  int zip_prefix = (*word.begin - '0') * 10 + (*(word.begin + 1) - '0');
+
+  if ((zip_prefix >= zip_range[state_index].low &&
+      zip_prefix <= zip_range[state_index].high) ||
+      zip_prefix == zip_range[state_index].exception1 ||
+      zip_prefix == zip_range[state_index].exception2) {
+    return true;
+  }
+  return false;
+}
+
+bool AddressDetector::IsValidLocationName(const Word& word) {
+  // Supported location names sorted alphabetically and grouped by first letter.
+  static const struct LocationNameInfo {
+    const char* string;
+    char length;
+    bool allow_plural;
+  } location_names[157] = {
+    { "alley", 5, false }, { "annex", 5, false }, { "arcade", 6, false },
+    { "ave", 3, false }, { "ave.", 4, false }, { "avenue", 6, false },
+    { "alameda", 7, false },
+    { "bayou", 5, false }, { "beach", 5, false }, { "bend", 4, false },
+    { "bluff", 5, true }, { "bottom", 6, false }, { "boulevard", 9, false },
+    { "branch", 6, false }, { "bridge", 6, false }, { "brook", 5, true },
+    { "burg", 4, true }, { "bypass", 6, false }, { "broadway", 8, false },
+    { "camino", 6, false }, { "camp", 4, false }, { "canyon", 6, false },
+    { "cape", 4, false }, { "causeway", 8, false }, { "center", 6, true },
+    { "circle", 6, true }, { "cliff", 5, true }, { "club", 4, false },
+    { "common", 6, false }, { "corner", 6, true }, { "course", 6, false },
+    { "court", 5, true }, { "cove", 4, true }, { "creek", 5, false },
+    { "crescent", 8, false }, { "crest", 5, false }, { "crossing", 8, false },
+    { "crossroad", 9, false }, { "curve", 5, false }, { "circulo", 7, false },
+    { "dale", 4, false }, { "dam", 3, false }, { "divide", 6, false },
+    { "drive", 5, true },
+    { "estate", 6, true }, { "expressway", 10, false },
+    { "extension", 9, true },
+    { "fall", 4, true }, { "ferry", 5, false }, { "field", 5, true },
+    { "flat", 4, true }, { "ford", 4, true }, { "forest", 6, false },
+    { "forge", 5, true }, { "fork", 4, true }, { "fort", 4, false },
+    { "freeway", 7, false },
+    { "garden", 6, true }, { "gateway", 7, false }, { "glen", 4, true },
+    { "green", 5, true }, { "grove", 5, true },
+    { "harbor", 6, true }, { "haven", 5, false }, { "heights", 7, false },
+    { "highway", 7, false }, { "hill", 4, true }, { "hollow", 6, false },
+    { "inlet", 5, false }, { "island", 6, true }, { "isle", 4, false },
+    { "junction", 8, true },
+    { "key", 3, true }, { "knoll", 5, true },
+    { "lake", 4, true }, { "land", 4, false }, { "landing", 7, false },
+    { "lane", 4, false }, { "light", 5, true }, { "loaf", 4, false },
+    { "lock", 4, true }, { "lodge", 5, false }, { "loop", 4, false },
+    { "mall", 4, false }, { "manor", 5, true }, { "meadow", 6, true },
+    { "mews", 4, false }, { "mill", 4, true }, { "mission", 7, false },
+    { "motorway", 8, false }, { "mount", 5, false }, { "mountain", 8, true },
+    { "neck", 4, false },
+    { "orchard", 7, false }, { "oval", 4, false }, { "overpass", 8, false },
+    { "park", 4, true }, { "parkway", 7, true }, { "pass", 4, false },
+    { "passage", 7, false }, { "path", 4, false }, { "pike", 4, false },
+    { "pine", 4, true }, { "plain", 5, true }, { "plaza", 5, false },
+    { "point", 5, true }, { "port", 4, true }, { "prairie", 7, false },
+    { "privada", 7, false },
+    { "radial", 6, false }, { "ramp", 4, false }, { "ranch", 5, false },
+    { "rapid", 5, true }, { "rest", 4, false }, { "ridge", 5, true },
+    { "river", 5, false }, { "road", 4, true }, { "route", 5, false },
+    { "row", 3, false }, { "rue", 3, false }, { "run", 3, false },
+    { "shoal", 5, true }, { "shore", 5, true }, { "skyway", 6, false },
+    { "spring", 6, true }, { "spur", 4, true }, { "square", 6, true },
+    { "station", 7, false }, { "stravenue", 9, false }, { "stream", 6, false },
+    { "st", 2, false }, { "st.", 3, false }, { "street", 6, true },
+    { "summit", 6, false }, { "speedway", 8, false },
+    { "terrace", 7, false }, { "throughway", 10, false }, { "trace", 5, false },
+    { "track", 5, false }, { "trafficway", 10, false }, { "trail", 5, false },
+    { "tunnel", 6, false }, { "turnpike", 8, false },
+    { "underpass", 9, false }, { "union", 5, true },
+    { "valley", 6, true }, { "viaduct", 7, false }, { "view", 4, true },
+    { "village", 7, true }, { "ville", 5, false }, { "vista", 5, false },
+    { "walk", 4, true }, { "wall", 4, false }, { "way", 3, true },
+    { "well", 4, true },
+    { "xing", 4, false }, { "xrd", 3, false }
+  };
+
+  // Accumulative number of location names for each starting letter.
+  static const int location_names_accumulative[25] = {
+      0,   7,  19,  40,  44,
+     47,  57,  62,  68,  71,
+     72,  74,  83,  92,  93,
+     96, 109, 109, 121, 135,
+    143, 145, 151, 155, 157
+  };
+
+  DCHECK_EQ(
+      location_names_accumulative[arraysize(location_names_accumulative) - 1],
+      static_cast<int>(ARRAYSIZE_UNSAFE(location_names)));
+
+  if (!IsAsciiAlpha(*word.begin))
+    return false;
+
+  // No location names start with y, z.
+  char16 first_letter = base::ToLowerASCII(*word.begin);
+  if (first_letter > 'x')
+    return false;
+
+  DCHECK(first_letter >= 'a');
+  int index = first_letter - 'a';
+  int length = std::distance(word.begin, word.end);
+  for (int i = location_names_accumulative[index];
+      i < location_names_accumulative[index + 1]; ++i) {
+    if (location_names[i].length != length &&
+        (location_names[i].allow_plural &&
+        location_names[i].length + 1 != length)) {
+      continue;
+    }
+
+    if (LowerCaseEqualsASCIIWithPlural(word.begin, word.end,
+        location_names[i].string, location_names[i].allow_plural)) {
+      return true;
+    }
+  }
+
+  return false;
+}
diff --git a/Source/WebKit/android/content/address_detector.h b/Source/WebKit/android/content/address_detector.h
new file mode 100644
index 0000000..4ba7b47
--- /dev/null
+++ b/Source/WebKit/android/content/address_detector.h
@@ -0,0 +1,131 @@
+/*
+ * 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.
+ */
+
+#ifndef CONTENT_RENDERER_ANDROID_ADDRESS_DETECTOR_H_
+#define CONTENT_RENDERER_ANDROID_ADDRESS_DETECTOR_H_
+#pragma once
+
+#include "build/build_config.h"  // Needed for OS_ANDROID
+
+#if defined(OS_ANDROID)
+
+#include <vector>
+
+#include "base/string_tokenizer.h"
+#include "base/string_util.h"
+#include "content/content_detector.h"
+
+// Finds a geographical address (currently US only) in the given text string.
+class AddressDetector : public ContentDetector {
+ public:
+  AddressDetector();
+  virtual ~AddressDetector();
+
+ private:
+  friend class AddressDetectorTest;
+
+  // Implementation of ContentDetector.
+  virtual bool FindContent(const string16::const_iterator& begin,
+                           const string16::const_iterator& end,
+                           size_t* start_pos,
+                           size_t* end_pos) OVERRIDE;
+
+  virtual std::string GetContentText(const WebKit::WebRange& range) OVERRIDE;
+  virtual GURL GetIntentURL(const std::string& content_text) OVERRIDE;
+  virtual size_t GetMaximumContentLength() OVERRIDE;
+
+  // Internal structs and classes. Required to be visible by the unit tests.
+  struct Word {
+    string16::const_iterator begin;
+    string16::const_iterator end;
+
+    Word() {}
+    Word(const string16::const_iterator& begin_it,
+         const string16::const_iterator& end_it)
+        : begin(begin_it),
+          end(end_it) {
+      DCHECK(begin_it <= end_it);
+    }
+  };
+
+  class HouseNumberParser {
+   public:
+    HouseNumberParser() {}
+
+    bool Parse(const string16::const_iterator& begin,
+               const string16::const_iterator& end,
+               Word* word);
+
+   private:
+    static inline bool IsPreDelimiter(char16 character);
+    static inline bool IsPostDelimiter(char16 character);
+    inline void RestartOnNextDelimiter();
+
+    inline bool CheckFinished(Word* word) const;
+    inline void AcceptChars(size_t num_chars);
+    inline void SkipChars(size_t num_chars);
+    inline void ResetState();
+
+    // Iterators to the beginning, current position and ending of the string
+    // being currently parsed.
+    string16::const_iterator begin_;
+    string16::const_iterator it_;
+    string16::const_iterator end_;
+
+    // Number of digits found in the current result candidate.
+    size_t num_digits_;
+
+    // Number of characters previous to the current iterator that belong
+    // to the current result candidate.
+    size_t result_chars_;
+
+    DISALLOW_COPY_AND_ASSIGN(HouseNumberParser);
+  };
+
+  typedef std::vector<Word> WordList;
+  typedef StringTokenizerT<string16, string16::const_iterator>
+      String16Tokenizer;
+
+  static bool FindStateStartingInWord(WordList* words,
+                                      size_t state_first_word,
+                                      size_t* state_last_word,
+                                      String16Tokenizer* tokenizer,
+                                      size_t* state_index);
+
+  static bool IsValidLocationName(const Word& word);
+  static bool IsZipValid(const Word& word, size_t state_index);
+  static bool IsZipValidForState(const Word& word, size_t state_index);
+
+  DISALLOW_COPY_AND_ASSIGN(AddressDetector);
+};
+
+#endif  // defined(OS_ANDROID)
+
+#endif  // CONTENT_RENDERER_ANDROID_ADDRESS_DETECTOR_H_
diff --git a/Source/WebKit/android/content/content_detector.cpp b/Source/WebKit/android/content/content_detector.cpp
new file mode 100644
index 0000000..b29a457
--- /dev/null
+++ b/Source/WebKit/android/content/content_detector.cpp
@@ -0,0 +1,86 @@
+/*
+ * 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/content_detector.h"
+
+#include "public/android/WebDOMTextContentWalker.h"
+#include "public/android/WebHitTestInfo.h"
+
+using WebKit::WebDOMTextContentWalker;
+using WebKit::WebRange;
+
+ContentDetector::Result ContentDetector::FindTappedContent(
+    const WebKit::WebHitTestInfo& hit_test) {
+  WebKit::WebRange range = FindContentRange(hit_test);
+  if (range.isNull())
+    return Result();
+
+  std::string text = GetContentText(range);
+  GURL intent_url = GetIntentURL(text);
+  return Result(range, text, intent_url);
+}
+
+WebRange ContentDetector::FindContentRange(
+    const WebKit::WebHitTestInfo& hit_test) {
+  WebDOMTextContentWalker content_walker(hit_test, GetMaximumContentLength());
+  string16 content = content_walker.content();
+  if (content.empty())
+    return WebRange();
+
+  size_t selected_offset = content_walker.hitOffsetInContent();
+  for (size_t start_offset = 0; start_offset < content.length();) {
+    size_t relative_start, relative_end;
+    if (!FindContent(content.begin() + start_offset,
+        content.end(), &relative_start, &relative_end)) {
+      break;
+    } else {
+      size_t content_start = start_offset + relative_start;
+      size_t content_end = start_offset + relative_end;
+      DCHECK(content_end <= content.length());
+
+      if (selected_offset >= content_start && selected_offset < content_end) {
+        WebRange range = content_walker.contentOffsetsToRange(
+            content_start, content_end);
+        DCHECK(!range.isNull());
+        return range;
+      } else {
+        start_offset += relative_end;
+      }
+    }
+  }
+
+  return WebRange();
+}
diff --git a/Source/WebKit/android/content/content_detector.h b/Source/WebKit/android/content/content_detector.h
new file mode 100644
index 0000000..041cbc9
--- /dev/null
+++ b/Source/WebKit/android/content/content_detector.h
@@ -0,0 +1,103 @@
+/*
+ * 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.
+ */
+
+#ifndef CONTENT_RENDERER_ANDROID_CONTENT_DETECTOR_H_
+#define CONTENT_RENDERER_ANDROID_CONTENT_DETECTOR_H_
+#pragma once
+
+#include "build/build_config.h"  // Needed for OS_ANDROID
+
+#if defined(OS_ANDROID)
+
+#include "base/string_util.h"
+#include "googleurl/src/gurl.h"
+#include "public/WebRange.h"
+
+namespace WebKit {
+class WebHitTestInfo;
+}
+
+// Base class for text-based content detectors.
+class ContentDetector {
+ public:
+
+  // Holds the content detection results.
+  struct Result {
+    bool valid; // Flag indicating if the result is valid.
+    WebKit::WebRange range; // Range describing the content boundaries.
+    std::string text; // Processed text of the content.
+    GURL intent_url; // URL of the intent that should process this content.
+
+    Result() : valid(false) {}
+
+    Result(const WebKit::WebRange& range,
+           const std::string& text,
+           const GURL& intent_url)
+        : valid(true),
+          range(range),
+          text(text),
+          intent_url(intent_url) {}
+  };
+
+  virtual ~ContentDetector() {}
+
+  // Returns a WebKit range delimiting the contents found around the tapped
+  // position. If no content is found a null range will be returned.
+  Result FindTappedContent(const WebKit::WebHitTestInfo& hit_test);
+
+ protected:
+  // Parses the input string defined by the begin/end iterators returning true
+  // if the desired content is found. The start and end positions relative to
+  // the input iterators are returned in start_pos and end_pos.
+  // The end position is assumed to be non-inclusive.
+  virtual bool FindContent(const string16::const_iterator& begin,
+                           const string16::const_iterator& end,
+                           size_t* start_pos,
+                           size_t* end_pos) = 0;
+
+  // Extracts and processes the text of the detected content.
+  virtual std::string GetContentText(const WebKit::WebRange& range) = 0;
+
+  // Returns the intent URL that should process the content, if any.
+  virtual GURL GetIntentURL(const std::string& content_text) = 0;
+
+  // Returns the maximum length of text to be extracted around the tapped
+  // position in order to search for content.
+  virtual size_t GetMaximumContentLength() = 0;
+
+  ContentDetector() {}
+  WebKit::WebRange FindContentRange(const WebKit::WebHitTestInfo& hit_test);
+
+  DISALLOW_COPY_AND_ASSIGN(ContentDetector);
+};
+
+#endif  // defined(OS_ANDROID)
+
+#endif  // CONTENT_RENDERER_ANDROID_CONTENT_DETECTOR_H_