Split HistoryClient in two objects

components/history/core/browser/history_backend.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 "components/history/core/browser/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_enumerator.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/favicon_base/select_favicon_frames.h"
 #include "components/history/core/browser/download_constants.h"
 #include "components/history/core/browser/download_row.h"
+#include "components/history/core/browser/history_backend_client.h"
 #include "components/history/core/browser/history_backend_observer.h"
-#include "components/history/core/browser/history_client.h"
 #include "components/history/core/browser/history_constants.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/in_memory_history_backend.h"
 #include "components/history/core/browser/keyword_search_term.h"
 #include "components/history/core/browser/page_usage_data.h"
 #include "components/history/core/browser/typed_url_syncable_service.h"
 #include "components/history/core/browser/visit_filter.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
@@ skipping 150 matching lines @@
 HistoryBackendHelper::HistoryBackendHelper() {
 }
 
 HistoryBackendHelper::~HistoryBackendHelper() {
 }
 
 // HistoryBackend --------------------------------------------------------------
 
 HistoryBackend::HistoryBackend(
     Delegate* delegate,
-    HistoryClient* history_client,
+    scoped_ptr<HistoryBackendClient> backend_client,
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : delegate_(delegate),
       scheduled_kill_db_(false),
-      expirer_(this, history_client, task_runner),
+      expirer_(this, backend_client.get(), task_runner),
       recent_redirects_(kMaxRedirectCount),
       backend_destroy_message_loop_(nullptr),
       segment_queried_(false),
-      history_client_(history_client),
+      backend_client_(backend_client.Pass()),
       task_runner_(task_runner) {
 }
 
 HistoryBackend::~HistoryBackend() {
   DCHECK(!scheduled_commit_.get()) << "Deleting without cleanup";
   STLDeleteContainerPointers(queued_history_db_tasks_.begin(),
                              queued_history_db_tasks_.end());
   queued_history_db_tasks_.clear();
 
   // Release stashed embedder object before cleaning up the databases.
   supports_user_data_helper_.reset();
 
   // First close the databases before optionally running the "destroy" task.
   CloseAllDatabases();
 
   if (!backend_destroy_task_.is_null()) {
     // Notify an interested party (typically a unit test) that we're done.
     DCHECK(backend_destroy_message_loop_);
     backend_destroy_message_loop_->PostTask(FROM_HERE, backend_destroy_task_);
   }
 
-  if (history_client_ && !history_dir_.empty())
-    history_client_->OnHistoryBackendDestroyed(this, history_dir_);
+#if defined(OS_ANDROID)
+  if (backend_client_ && !history_dir_.empty())
+    backend_client_->OnHistoryBackendDestroyed(this, history_dir_);
+#endif
 }
 
 void HistoryBackend::Init(
     const std::string& languages,
     bool force_fail,
     const HistoryDatabaseParams& history_database_params) {
   // HistoryBackend is created on the UI thread by HistoryService, then the
   // HistoryBackend::Init() method is called on the DB thread. Create the
   // base::SupportsUserData on the DB thread since it is not thread-safe.
   supports_user_data_helper_.reset(new HistoryBackendHelper);
@@ skipping 406 matching lines @@
     if (mem_backend->Init(history_name))
       delegate_->SetInMemoryBackend(mem_backend.Pass());
   }
   db_->BeginExclusiveMode();  // Must be after the mem backend read the data.
 
   // Thumbnail database.
   // TODO(shess): "thumbnail database" these days only stores
   // favicons.  Thumbnails are stored in "top sites".  Consider
   // renaming "thumbnail" references to "favicons" or something of the
   // sort.
-  thumbnail_db_.reset(new ThumbnailDatabase(history_client_));
+  thumbnail_db_.reset(new ThumbnailDatabase(backend_client_.get()));
   if (thumbnail_db_->Init(thumbnail_name) != sql::INIT_OK) {
     // Unlike the main database, we don't error out when the database is too
     // new because this error is much less severe. Generally, this shouldn't
     // happen since the thumbnail and main database versions should be in sync.
     // We'll just continue without thumbnails & favicons in this case or any
     // other error.
     LOG(WARNING) << "Could not initialize the thumbnail database.";
     thumbnail_db_.reset();
   }
 
@@ skipping 18 matching lines @@
   db_->BeginTransaction();
   if (thumbnail_db_)
     thumbnail_db_->BeginTransaction();
 
   // Get the first item in our database.
   db_->GetStartDate(&first_recorded_time_);
 
   // Start expiring old stuff.
   expirer_.StartExpiringOldStuff(TimeDelta::FromDays(kExpireDaysThreshold));
 
-  if (history_client_) {
-    history_client_->OnHistoryBackendInitialized(
+#if defined(OS_ANDROID)
+  if (backend_client_) {
+    backend_client_->OnHistoryBackendInitialized(
         this, db_.get(), thumbnail_db_.get(), history_dir_);
   }
+#endif
 
   LOCAL_HISTOGRAM_TIMES("History.InitTime", TimeTicks::Now() - beginning_time);
 }
 
 void HistoryBackend::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   bool trim_aggressively =
       memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
   if (db_)
@@ skipping 1094 matching lines @@
     if (!favicon_id) {
       // This favicon doesn't exist yet, so we create it using the given data.
       // TODO(pkotwicz): Pass in real pixel size.
       favicon_id = thumbnail_db_->AddFavicon(
           favicon_usage[i].favicon_url, favicon_base::FAVICON,
           new base::RefCountedBytes(favicon_usage[i].png_data), now,
           gfx::Size());
     }
 
     // Save the mapping from all the URLs to the favicon.
-    HistoryClient* history_client = GetHistoryClient();
     for (std::set<GURL>::const_iterator url = favicon_usage[i].urls.begin();
          url != favicon_usage[i].urls.end(); ++url) {
       URLRow url_row;
       if (!db_->GetRowForURL(*url, &url_row)) {
         // If the URL is present as a bookmark, add the url in history to
         // save the favicon mapping. This will match with what history db does
         // for regular bookmarked URLs with favicons - when history db is
         // cleaned, we keep an entry in the db with 0 visits as long as that
         // url is bookmarked.
-        if (history_client && history_client->IsBookmarked(*url)) {
+        if (backend_client_ && backend_client_->IsBookmarked(*url)) {
           URLRow url_info(*url);
           url_info.set_visit_count(0);
           url_info.set_typed_count(0);
           url_info.set_last_visit(base::Time());
           url_info.set_hidden(false);
           db_->AddURL(url_info);
           thumbnail_db_->AddIconMapping(*url, favicon_id);
           favicons_changed.insert(*url);
         }
       } else {
@@ skipping 713 matching lines @@
   //     that any data we don't want to keep is now in an unused page.
   //  3. Renaming the temporary tables to match the original.
   //  4. Vacuuming the database to delete the unused pages.
   //
   // Since we are likely to have very few bookmarks and their dependencies
   // compared to all history, this is also much faster than just deleting from
   // the original tables directly.
 
   // Get the bookmarked URLs.
   std::vector<URLAndTitle> starred_url_and_titles;
-  HistoryClient* history_client = GetHistoryClient();
-  if (history_client)
-    history_client->GetBookmarks(&starred_url_and_titles);
+  if (backend_client_)
+    backend_client_->GetBookmarks(&starred_url_and_titles);
 
   URLRows kept_url_rows;
   std::vector<GURL> starred_urls;
   for (const URLAndTitle& url_and_title : starred_url_and_titles) {
     const GURL& url = url_and_title.url;
     starred_urls.push_back(url);
 
     URLRow row;
     if (db_->GetRowForURL(url, &row)) {
       // Clear the last visit time so when we write these rows they are "clean."
@@ skipping 89 matching lines @@
   // when there is no transaction open, and we assume that our long-running
   // transaction is currently open.
   db_->CommitTransaction();
   db_->Vacuum();
   db_->BeginTransaction();
   db_->GetStartDate(&first_recorded_time_);
 
   return true;
 }
 
-HistoryClient* HistoryBackend::GetHistoryClient() {
-  if (history_client_)
-    history_client_->BlockUntilBookmarksLoaded();
-  return history_client_;
-}
-
 }  // namespace history