[Android] Split the address parser from AddressDetector for WebView use.

content/common/android/address_parser.cc

 // Copyright (c) 2012 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 "content/renderer/android/address_detector.h"
+#include "content/common/android/address_parser.h"
 
 #include <bitset>
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/platform/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 = 250;
-
 // 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
@@ skipping 61 matching lines @@
     if (!*ascii_to_match || base::ToLowerASCII(*it) != *ascii_to_match)
       return false;
   }
   return *ascii_to_match == 0;
 }
 
 }  // anonymous namespace
 
 namespace content {
 
-AddressDetector::AddressDetector() {
+AddressParser::AddressParser() {
 }
 
-AddressDetector::~AddressDetector() {
+bool AddressParser::FindAddress(const string16& text, string16* address) {
+  size_t start, end;
+  if (FindContent(text.begin(), text.end(), &start, &end)) {
+    address->assign(text.substr(start, end));
+    return true;
+  } else {
+    return false;
+  }
 }
 
-std::string AddressDetector::GetContentText(const string16& text) {
-  // Get the address and replace unicode bullets with commas.
-  string16 address_16 = CollapseWhitespace(text, 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 +
-      net::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,
-                                  std::string* content_text) {
+bool AddressParser::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;
+    WordList words;
     words.push_back(house_number);
 
     bool found_location_name = false;
     bool continue_on_house_number = true;
     bool consecutive_house_numbers = 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;
@@ skipping 95 matching lines @@
                             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;
-          content_text->assign(GetContentText(string16(words[0].begin,
-                                                       words[zip_word].end)));
           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;
 }
 
-AddressDetector::Word::Word(const string16::const_iterator& begin,
-                            const string16::const_iterator& end)
+AddressParser::Word::Word(const string16::const_iterator& begin,
+                          const string16::const_iterator& end)
     : begin(begin),
       end(end) {
   DCHECK(begin <= end);
 }
 
-bool AddressDetector::HouseNumberParser::IsPreDelimiter(
-    char16 character) {
+bool AddressParser::HouseNumberParser::IsPreDelimiter(char16 character) {
   return character == ':' || IsPostDelimiter(character);
 }
 
-bool AddressDetector::HouseNumberParser::IsPostDelimiter(
-    char16 character) {
+bool AddressParser::HouseNumberParser::IsPostDelimiter(char16 character) {
   return IsWhitespace(character) || strchr(",\"'", character);
 }
 
-void AddressDetector::HouseNumberParser::RestartOnNextDelimiter() {
+void AddressParser::HouseNumberParser::RestartOnNextDelimiter() {
   ResetState();
   for (; it_ != end_ && !IsPreDelimiter(*it_); ++it_) {}
 }
 
-void AddressDetector::HouseNumberParser::AcceptChars(size_t num_chars) {
+void AddressParser::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) {
+void AddressParser::HouseNumberParser::SkipChars(size_t num_chars) {
   it_ += std::min(static_cast<size_t>(std::distance(it_, end_)), num_chars);
 }
 
-void AddressDetector::HouseNumberParser::ResetState() {
+void AddressParser::HouseNumberParser::ResetState() {
   num_digits_ = 0;
   result_chars_ = 0;
 }
 
-bool AddressDetector::HouseNumberParser::CheckFinished(Word* word) const {
+bool AddressParser::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(
+bool AddressParser::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) {
@@ skipping 111 matching lines @@
     RestartOnNextDelimiter();
     SkipChars(1);
   }
 
   if (iterations >= max_iterations)
     return false;
 
   return CheckFinished(word);
 }
 
-bool AddressDetector::FindStateStartingInWord(
+bool AddressParser::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.
@@ skipping 146 matching lines @@
     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) {
+bool AddressParser::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) {
+bool AddressParser::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.
@@ skipping 63 matching lines @@
 
   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) {
+bool AddressParser::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 },
@@ skipping 91 matching lines @@
                                        location_names[i].string,
                                        location_names[i].allow_plural)) {
       return true;
     }
   }
 
   return false;
 }
 
 }  // namespace content