Move InMemoryURLIndex outside of history namespace

chrome/browser/autocomplete/in_memory_url_index.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 "chrome/browser/autocomplete/in_memory_url_index.h"
 
 #include "base/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/browser/autocomplete/url_index_private_data.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/common/url_constants.h"
 #include "components/history/core/browser/url_database.h"
 #include "content/public/browser/browser_thread.h"
 
 using in_memory_url_index::InMemoryURLIndexCacheItem;
 
-namespace history {
-
 // Called by DoSaveToCacheFile to delete any old cache file at |path| when
 // there is no private data to save. Runs on the FILE thread.
 void DeleteCacheFile(const base::FilePath& path) {
   DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   base::DeleteFile(path, false);
 }
 
 // Initializes a whitelist of URL schemes.
 void InitializeSchemeWhitelist(std::set<std::string>* whitelist) {
   DCHECK(whitelist);
@@ skipping 21 matching lines @@
         InMemoryURLIndex* index,
         const std::string& languages,
         const std::set<std::string>& scheme_whitelist)
     : index_(index),
       languages_(languages),
       scheme_whitelist_(scheme_whitelist),
       succeeded_(false) {
 }
 
 bool InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::RunOnDBThread(
-    HistoryBackend* backend,
-    HistoryDatabase* db) {
+    history::HistoryBackend* backend,
+    history::HistoryDatabase* db) {
   data_ = URLIndexPrivateData::RebuildFromHistory(db, languages_,
                                                   scheme_whitelist_);
   succeeded_ = data_.get() && !data_->Empty();
   if (!succeeded_ && data_.get())
     data_->Clear();
   return true;
 }
 
 void InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::
     DoneRunOnMainThread() {
@@ skipping 75 matching lines @@
 }
 
 // Updating --------------------------------------------------------------------
 
 void InMemoryURLIndex::DeleteURL(const GURL& url) {
   private_data_->DeleteURL(url);
 }
 
 void InMemoryURLIndex::OnURLVisited(HistoryService* history_service,
                                     ui::PageTransition transition,
-                                    const URLRow& row,
-                                    const RedirectList& redirects,
+                                    const history::URLRow& row,
+                                    const history::RedirectList& redirects,
                                     base::Time visit_time) {
   DCHECK_EQ(history_service_, history_service);
   needs_to_be_cached_ |= private_data_->UpdateURL(history_service_,
                                                   row,
                                                   languages_,
                                                   scheme_whitelist_,
                                                   &private_data_tracker_);
 }
 
 void InMemoryURLIndex::OnURLsModified(HistoryService* history_service,
-                                      const URLRows& changed_urls) {
+                                      const history::URLRows& changed_urls) {
   DCHECK_EQ(history_service_, history_service);
   for (const auto& row : changed_urls) {
     needs_to_be_cached_ |= private_data_->UpdateURL(history_service_,
                                                     row,
                                                     languages_,
                                                     scheme_whitelist_,
                                                     &private_data_tracker_);
   }
 }
 
 void InMemoryURLIndex::OnURLsDeleted(HistoryService* history_service,
                                      bool all_history,
                                      bool expired,
-                                     const URLRows& deleted_rows,
+                                     const history::URLRows& deleted_rows,
                                      const std::set<GURL>& favicon_urls) {
   if (all_history) {
     ClearPrivateData();
     needs_to_be_cached_ = true;
   } else {
     for (const auto& row : deleted_rows)
       needs_to_be_cached_ |= private_data_->DeleteURL(row.url());
   }
   // If we made changes, destroy the previous cache.  Otherwise, if we go
   // through an unclean shutdown (and therefore fail to write a new cache file),
@@ skipping 90 matching lines @@
   } else {
     private_data_->Clear();  // Dump the old private data.
     // There is no need to do anything with the cache file as it was deleted
     // when the rebuild from the history operation was kicked off.
   }
   restored_ = true;
   if (restore_cache_observer_)
     restore_cache_observer_->OnCacheRestoreFinished(succeeded);
 }
 
-void InMemoryURLIndex::RebuildFromHistory(HistoryDatabase* history_db) {
+void InMemoryURLIndex::RebuildFromHistory(
+    history::HistoryDatabase* history_db) {
   private_data_tracker_.TryCancelAll();
   private_data_ = URLIndexPrivateData::RebuildFromHistory(history_db,
                                                           languages_,
                                                           scheme_whitelist_);
 }
 
 // Saving to Cache -------------------------------------------------------------
 
 void InMemoryURLIndex::PostSaveToCacheFileTask() {
   base::FilePath path;
@@ skipping 16 matching lines @@
     content::BrowserThread::PostBlockingPoolTask(
         FROM_HERE,
         base::Bind(DeleteCacheFile, path));
   }
 }
 
 void InMemoryURLIndex::OnCacheSaveDone(bool succeeded) {
   if (save_cache_observer_)
     save_cache_observer_->OnCacheSaveFinished(succeeded);
 }
-
-}  // namespace history