When users navigate to an intranet host that has not been previously typed, treat it as a typed n...

chrome/browser/history/url_database.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/history/url_database.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 273 matching lines @@
   enumerator->statement_.Assign(GetDB().GetUniqueStatement(
       "SELECT url, favicon_id FROM urls WHERE favicon_id <> 0"));
   if (!enumerator->statement_) {
     NOTREACHED() << GetDB().GetErrorMessage();
     return false;
   }
   enumerator->initialized_ = true;
   return true;
 }
 
-bool URLDatabase::AutocompleteForPrefix(const string16& prefix,
+bool URLDatabase::AutocompleteForPrefix(const std::string& prefix,
                                         size_t max_results,
                                         bool typed_only,
                                         std::vector<history::URLRow>* results) {
   // NOTE: this query originally sorted by starred as the second parameter. But
   // as bookmarks is no longer part of the db we no longer include the order
   // by clause.
   results->clear();
   const char* sql;
   int line;
   if (typed_only) {
@@ skipping 11 matching lines @@
   }
   sql::Statement statement(
       GetDB().GetCachedStatement(sql::StatementID(__FILE__, line), sql));
   if (!statement)
     return false;
 
   // We will find all strings between "prefix" and this string, which is prefix
   // followed by the maximum character size. Use 8-bit strings for everything
   // so we can be sure sqlite is comparing everything in 8-bit mode. Otherwise,
   // it will have to convert strings either to UTF-8 or UTF-16 for comparison.
-  std::string prefix_utf8(UTF16ToUTF8(prefix));
-  std::string end_query(prefix_utf8);
+  std::string end_query(prefix);
   end_query.push_back(std::numeric_limits<unsigned char>::max());
 
-  statement.BindString(0, prefix_utf8);
+  statement.BindString(0, prefix);
   statement.BindString(1, end_query);
   statement.BindInt(2, static_cast<int>(max_results));
 
   while (statement.Step()) {
     history::URLRow info;
     FillURLRow(statement, &info);
     if (info.url().is_valid())
       results->push_back(info);
   }
   return !results->empty();
 }
 
+bool URLDatabase::IsTypedHost(const std::string& host) {
+  const char* schemes[] = {
+    chrome::kHttpScheme,
+    chrome::kHttpsScheme,
+    chrome::kFtpScheme
+  };
+  std::vector<history::URLRow> dummy;
+  for (size_t i = 0; i < arraysize(schemes); ++i) {
+    std::string scheme_and_host(schemes[i]);
+    scheme_and_host += chrome::kStandardSchemeSeparator + host;
+    if (AutocompleteForPrefix(scheme_and_host + '/', 1, true, &dummy) ||
+        AutocompleteForPrefix(scheme_and_host + ':', 1, true, &dummy))
+      return true;
+  }
+  return false;
+}
+
 bool URLDatabase::FindShortestURLFromBase(const std::string& base,
                                           const std::string& url,
                                           int min_visits,
                                           int min_typed,
                                           bool allow_base,
                                           history::URLRow* info) {
   // Select URLs that start with |base| and are prefixes of |url|.  All parts
   // of this query except the substr() call can be done using the index.  We
   // could do this query with a couple of LIKE or GLOB statements as well, but
   // those wouldn't use the index, and would run into problems with "wildcard"
@@ skipping 200 matching lines @@
   return GetDB().Execute(sql.c_str());
 }
 
 void URLDatabase::CreateMainURLIndex() {
   // Index over URLs so we can quickly look up based on URL.  Ignore errors as
   // this likely already exists (and the same below).
   GetDB().Execute("CREATE INDEX urls_url_index ON urls (url)");
 }
 
 }  // namespace history