Cleanup usage of history namespace in components/history

components/history/core/browser/url_database.cc

 // Copyright 2014 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 "components/history/core/browser/url_database.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
@@ skipping 40 matching lines @@
   // TODO(brettw): do something fancy here with encoding, etc.
 
   // Strip username and password from URL before sending to DB.
   GURL::Replacements replacements;
   replacements.ClearUsername();
   replacements.ClearPassword();
 
   return (gurl.ReplaceComponents(replacements)).spec();
 }
 
-// Convenience to fill a history::URLRow. Must be in sync with the fields in
+// Convenience to fill a URLRow. Must be in sync with the fields in
 // kURLRowFields.
-void URLDatabase::FillURLRow(sql::Statement& s, history::URLRow* i) {
+void URLDatabase::FillURLRow(sql::Statement& s, URLRow* i) {
   DCHECK(i);
   i->id_ = s.ColumnInt64(0);
   i->url_ = GURL(s.ColumnString(1));
   i->title_ = s.ColumnString16(2);
   i->visit_count_ = s.ColumnInt(3);
   i->typed_count_ = s.ColumnInt(4);
   i->last_visit_ = base::Time::FromInternalValue(s.ColumnInt64(5));
   i->hidden_ = s.ColumnInt(6) != 0;
 }
 
@@ skipping 18 matching lines @@
       "SELECT" HISTORY_URL_ROW_FIELDS "FROM urls WHERE typed_count > 0"));
 
   while (statement.Step()) {
     URLRow info;
     FillURLRow(statement, &info);
     urls->push_back(info);
   }
   return true;
 }
 
-URLID URLDatabase::GetRowForURL(const GURL& url, history::URLRow* info) {
+URLID URLDatabase::GetRowForURL(const GURL& url, URLRow* info) {
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT" HISTORY_URL_ROW_FIELDS "FROM urls WHERE url=?"));
   std::string url_string = GURLToDatabaseURL(url);
   statement.BindString(0, url_string);
 
   if (!statement.Step())
     return 0;  // no data
 
   if (info)
     FillURLRow(statement, info);
   return statement.ColumnInt64(0);
 }
 
-bool URLDatabase::UpdateURLRow(URLID url_id,
-                               const history::URLRow& info) {
+bool URLDatabase::UpdateURLRow(URLID url_id, const URLRow& info) {
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "UPDATE urls SET title=?,visit_count=?,typed_count=?,last_visit_time=?,"
         "hidden=?"
       "WHERE id=?"));
   statement.BindString16(0, info.title());
   statement.BindInt(1, info.visit_count());
   statement.BindInt(2, info.typed_count());
   statement.BindInt64(3, info.last_visit().ToInternalValue());
   statement.BindInt(4, info.hidden() ? 1 : 0);
   statement.BindInt64(5, url_id);
 
   return statement.Run() && GetDB().GetLastChangeCount() > 0;
 }
 
-URLID URLDatabase::AddURLInternal(const history::URLRow& info,
-                                  bool is_temporary) {
+URLID URLDatabase::AddURLInternal(const URLRow& info, bool is_temporary) {
   // This function is used to insert into two different tables, so we have to
   // do some shuffling. Unfortinately, we can't use the macro
   // HISTORY_URL_ROW_FIELDS because that specifies the table name which is
   // invalid in the insert syntax.
   #define ADDURL_COMMON_SUFFIX \
       " (url, title, visit_count, typed_count, "\
       "last_visit_time, hidden) "\
       "VALUES (?,?,?,?,?,?)"
   const char* statement_name;
   const char* statement_sql;
@@ skipping 16 matching lines @@
   statement.BindInt(5, info.hidden() ? 1 : 0);
 
   if (!statement.Run()) {
     VLOG(0) << "Failed to add url " << info.url().possibly_invalid_spec()
             << " to table history.urls.";
     return 0;
   }
   return GetDB().GetLastInsertRowId();
 }
 
-bool URLDatabase::InsertOrUpdateURLRowByID(const history::URLRow& info) {
+bool URLDatabase::InsertOrUpdateURLRowByID(const URLRow& info) {
   // SQLite does not support INSERT OR UPDATE, however, it does have INSERT OR
   // REPLACE, which is feasible to use, because of the following.
   //  * Before INSERTing, REPLACE will delete all pre-existing rows that cause
   //    constraint violations. Here, we only have a PRIMARY KEY constraint, so
   //    the only row that might get deleted is an old one with the same ID.
   //  * Another difference between the two flavors is that the latter actually
   //    deletes the old row, and thus the old values are lost in columns which
   //    are not explicitly assigned new values. This is not an issue, however,
   //    as we assign values to all columns.
   //  * When rows are deleted due to constraint violations, the delete triggers
@@ skipping 109 matching lines @@
   // 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 end_query(prefix);
   end_query.push_back(std::numeric_limits<unsigned char>::max());
 
   statement.BindString(0, prefix);
   statement.BindString(1, end_query);
   statement.BindInt(2, static_cast<int>(max_results));
 
   while (statement.Step()) {
-    history::URLRow info;
+    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[] = {
     url::kHttpScheme,
     url::kHttpsScheme,
     url::kFtpScheme
   };
   URLRows dummy;
   for (size_t i = 0; i < arraysize(schemes); ++i) {
     std::string scheme_and_host(schemes[i]);
     scheme_and_host += url::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) {
+                                          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"
   // characters that appear in URLs (% for LIKE, or *, ? for GLOB).
   std::string sql("SELECT ");
   sql.append(kURLRowFields);
   sql.append(" FROM urls WHERE url ");
   sql.append(allow_base ? ">=" : ">");
   sql.append(" ? AND url < :end AND url = substr(:end, 1, length(url)) "
@@ skipping 34 matching lines @@
       // |languages| to reduce dependency (no need to call PrefService).
       base::string16 ascii = base::ASCIIToUTF16(gurl.host());
       base::string16 utf = net::IDNToUnicode(gurl.host(), std::string());
       if (ascii != utf)
         query_parser_.ExtractQueryWords(utf, &query_words);
     }
     base::string16 title = base::i18n::ToLower(statement.ColumnString16(2));
     query_parser_.ExtractQueryWords(title, &query_words);
 
     if (query_parser_.DoesQueryMatch(query_words, query_nodes.get())) {
-      history::URLResult info;
+      URLResult info;
       FillURLRow(statement, &info);
       if (info.url().is_valid())
         results->push_back(info);
     }
   }
   return !results->empty();
 }
 
 bool URLDatabase::InitKeywordSearchTermsTable() {
   has_keyword_search_terms_ = true;
@@ skipping 232 matching lines @@
 bool RowQualifiesAsSignificant(const URLRow& row,
                                const base::Time& threshold) {
   const base::Time& real_threshold =
       threshold.is_null() ? AutocompleteAgeThreshold() : threshold;
   return (row.typed_count() >= kLowQualityMatchTypedLimit) ||
          (row.visit_count() >= kLowQualityMatchVisitLimit) ||
          (row.last_visit() >= real_threshold);
 }
 
 }  // namespace history