Cleanup HistoryService and HistoryBackend interface

chrome/browser/history/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 "chrome/browser/history/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 114 matching lines @@
 // base::WeakPtrFactory which will handle everything automatically (like we do
 // in ExpireHistoryBackend).
 class CommitLaterTask : public base::RefCounted<CommitLaterTask> {
  public:
   explicit CommitLaterTask(HistoryBackend* history_backend)
       : history_backend_(history_backend) {
   }
 
   // The backend will call this function if it is being destroyed so that we
   // release our reference.
-  void Cancel() {
-    history_backend_ = NULL;
-  }
+  void Cancel() { history_backend_ = nullptr; }
 
   void RunCommit() {
     if (history_backend_.get())
       history_backend_->Commit();
   }
 
  private:
   friend class base::RefCounted<CommitLaterTask>;
 
   ~CommitLaterTask() {}
@@ skipping 32 matching lines @@
   origin_loop_->PostTask(
       FROM_HERE,
       base::Bind(&RunUnlessCanceled,
                  base::Bind(&HistoryDBTask::DoneRunOnMainThread,
                             base::Unretained(task_.get())),
                  is_canceled_));
 }
 
 // HistoryBackend --------------------------------------------------------------
 
-HistoryBackend::HistoryBackend(const base::FilePath& history_dir,
-                               Delegate* delegate,
+HistoryBackend::HistoryBackend(Delegate* delegate,
                                HistoryClient* history_client)
     : delegate_(delegate),
-      history_dir_(history_dir),
       scheduled_kill_db_(false),
       expirer_(this, history_client),
       recent_redirects_(kMaxRedirectCount),
-      backend_destroy_message_loop_(NULL),
+      backend_destroy_message_loop_(nullptr),
       segment_queried_(false),
       history_client_(history_client) {
 }
 
 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();
 
@@ skipping 120 matching lines @@
   // a segment for that one as well. So we end up with google.net and google.com
   // in the segment table, showing as 2 entries in the NTP.
   // Note also that we should still be updating the visit count for that segment
   // which we are not doing now. It should be addressed when
   // http://crbug.com/96860 is fixed.
   if ((t == ui::PAGE_TRANSITION_TYPED ||
        t == ui::PAGE_TRANSITION_AUTO_BOOKMARK) &&
       (transition_type & ui::PAGE_TRANSITION_FORWARD_BACK) == 0) {
     // If so, create or get the segment.
     std::string segment_name = db_->ComputeSegmentName(url);
-    URLID url_id = db_->GetRowForURL(url, NULL);
+    URLID url_id = db_->GetRowForURL(url, nullptr);
     if (!url_id)
       return 0;
 
     segment_id = db_->GetSegmentNamed(segment_name);
     if (!segment_id) {
       segment_id = db_->CreateSegment(url_id, segment_name);
       if (!segment_id) {
         NOTREACHED();
         return 0;
       }
@@ skipping 226 matching lines @@
   ScheduleCommit();
 }
 
 void HistoryBackend::InitImpl(
     const std::string& languages,
     const HistoryDatabaseParams& history_database_params) {
   DCHECK(!db_) << "Initializing HistoryBackend twice";
   // In the rare case where the db fails to initialize a dialog may get shown
   // the blocks the caller, yet allows other messages through. For this reason
   // we only set db_ to the created database if creation is successful. That
-  // way other methods won't do anything as db_ is still NULL.
+  // way other methods won't do anything as db_ is still null.
 
   TimeTicks beginning_time = TimeTicks::Now();
 
   // Compute the file names.
-  DCHECK(history_dir_ == history_database_params.history_dir);
-  base::FilePath history_name =
-      history_database_params.history_dir.Append(history::kHistoryFilename);
+  history_dir_ = history_database_params.history_dir;
+  base::FilePath history_name = history_dir_.Append(history::kHistoryFilename);
   base::FilePath thumbnail_name = GetFaviconsFileName();
   base::FilePath archived_name = GetArchivedFileName();
 
   // Delete the old index database files which are no longer used.
   DeleteFTSIndexDatabases();
 
   // History database.
   db_.reset(new HistoryDatabase(
       history_database_params.download_interrupt_reason_none,
       history_database_params.download_interrupt_reason_crash));
 
   // Unretained to avoid a ref loop with db_.
   db_->set_error_callback(
       base::Bind(&HistoryBackend::DatabaseErrorCallback,
                  base::Unretained(this)));
 
   sql::InitStatus status = db_->Init(history_name);
   switch (status) {
     case sql::INIT_OK:
       break;
     case sql::INIT_FAILURE: {
-      // A NULL db_ will cause all calls on this object to notice this error
+      // A null db_ will cause all calls on this object to notice this error
       // and to not continue. If the error callback scheduled killing the
       // database, the task it posted has not executed yet. Try killing the
       // database now before we close it.
       bool kill_db = scheduled_kill_db_;
       if (kill_db)
         KillHistoryDatabase();
       UMA_HISTOGRAM_BOOLEAN("History.AttemptedToFixProfileError", kill_db);
       delegate_->NotifyProfileError(status);
       db_.reset();
       return;
@@ skipping 423 matching lines @@
     return;
 
   db_->DeleteAllSearchTermsForKeyword(keyword_id);
   ScheduleCommit();
 }
 
 void HistoryBackend::DeleteKeywordSearchTermForURL(const GURL& url) {
   if (!db_)
     return;
 
-  URLID url_id = db_->GetRowForURL(url, NULL);
+  URLID url_id = db_->GetRowForURL(url, nullptr);
   if (!url_id)
     return;
   db_->DeleteKeywordSearchTermForURL(url_id);
 
   if (delegate_)
     delegate_->NotifyKeywordSearchTermDeleted(url_id);
 
   ScheduleCommit();
 }
 
@@ skipping 182 matching lines @@
       options.begin_time <= first_recorded_time_)
     result->set_reached_beginning(true);
 }
 
 void HistoryBackend::QueryRedirectsFrom(const GURL& from_url,
                                         RedirectList* redirects) {
   redirects->clear();
   if (!db_)
     return;
 
-  URLID from_url_id = db_->GetRowForURL(from_url, NULL);
-  VisitID cur_visit = db_->GetMostRecentVisitForURL(from_url_id, NULL);
+  URLID from_url_id = db_->GetRowForURL(from_url, nullptr);
+  VisitID cur_visit = db_->GetMostRecentVisitForURL(from_url_id, nullptr);
   if (!cur_visit)
     return;  // No visits for URL.
 
   GetRedirectsFromSpecificVisit(cur_visit, redirects);
 }
 
 void HistoryBackend::QueryRedirectsTo(const GURL& to_url,
                                       RedirectList* redirects) {
   redirects->clear();
   if (!db_)
     return;
 
-  URLID to_url_id = db_->GetRowForURL(to_url, NULL);
-  VisitID cur_visit = db_->GetMostRecentVisitForURL(to_url_id, NULL);
+  URLID to_url_id = db_->GetRowForURL(to_url, nullptr);
+  VisitID cur_visit = db_->GetMostRecentVisitForURL(to_url_id, nullptr);
   if (!cur_visit)
     return;  // No visits for URL.
 
   GetRedirectsToSpecificVisit(cur_visit, redirects);
 }
 
 void HistoryBackend::GetVisibleVisitCountToHost(
     const GURL& url,
     VisibleVisitCountToHostResult* result) {
   result->count = 0;
@@ skipping 160 matching lines @@
   }
   UMA_HISTOGRAM_COUNTS("History.DeleteFTSIndexDatabases",
                        num_databases_deleted);
 }
 
 void HistoryBackend::GetFavicons(
     const std::vector<GURL>& icon_urls,
     int icon_types,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
-  UpdateFaviconMappingsAndFetchImpl(NULL, icon_urls, icon_types, desired_sizes,
-                                    bitmap_results);
+  UpdateFaviconMappingsAndFetchImpl(nullptr, icon_urls, icon_types,
+                                    desired_sizes, bitmap_results);
 }
 
 void HistoryBackend::GetLargestFaviconForURL(
     const GURL& page_url,
     const std::vector<int>& icon_types,
     int minimum_size_in_pixels,
     favicon_base::FaviconRawBitmapResult* favicon_bitmap_result) {
   DCHECK(favicon_bitmap_result);
 
   if (!db_ || !thumbnail_db_)
@@ skipping 121 matching lines @@
 void HistoryBackend::MergeFavicon(
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     const gfx::Size& pixel_size) {
   if (!thumbnail_db_ || !db_)
     return;
 
   favicon_base::FaviconID favicon_id =
-      thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, NULL);
+      thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, nullptr);
 
   if (!favicon_id) {
     // There is no favicon at |icon_url|, create it.
     favicon_id = thumbnail_db_->AddFavicon(icon_url, icon_type);
   }
 
   std::vector<FaviconBitmapIDSize> bitmap_id_sizes;
   thumbnail_db_->GetFaviconBitmapIDSizes(favicon_id, &bitmap_id_sizes);
 
   // If there is already a favicon bitmap of |pixel_size| at |icon_url|,
@@ skipping 124 matching lines @@
   if (!thumbnail_db_ || !db_)
     return;
 
   DCHECK_GE(kMaxFaviconBitmapsPerIconURL, bitmaps.size());
 
   // Track whether the method modifies or creates any favicon bitmaps, favicons
   // or icon mappings.
   bool data_modified = false;
 
   favicon_base::FaviconID icon_id =
-      thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, NULL);
+      thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, nullptr);
 
   if (!icon_id) {
     icon_id = thumbnail_db_->AddFavicon(icon_url, icon_type);
     data_modified = true;
   }
 
   data_modified |= SetFaviconBitmaps(icon_id, bitmaps);
 
   std::vector<favicon_base::FaviconID> icon_ids(1u, icon_id);
   data_modified |=
@@ skipping 41 matching lines @@
     return;
 
   Time now = Time::Now();
 
   // Track all URLs that had their favicons set or updated.
   std::set<GURL> favicons_changed;
 
   for (size_t i = 0; i < favicon_usage.size(); i++) {
     favicon_base::FaviconID favicon_id =
         thumbnail_db_->GetFaviconIDForFaviconURL(
-            favicon_usage[i].favicon_url, favicon_base::FAVICON, NULL);
+            favicon_usage[i].favicon_url, favicon_base::FAVICON, nullptr);
     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());
     }
@@ skipping 14 matching lines @@
           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 {
         if (!thumbnail_db_->GetIconMappingsForPageURL(
-                *url, favicon_base::FAVICON, NULL)) {
+                *url, favicon_base::FAVICON, nullptr)) {
           // URL is present in history, update the favicon *only* if it is not
           // set already.
           thumbnail_db_->AddIconMapping(*url, favicon_id);
           favicons_changed.insert(*url);
         }
       }
     }
   }
 
   if (!favicons_changed.empty()) {
@@ skipping 121 matching lines @@
   return favicon_bitmaps_changed;
 }
 
 bool HistoryBackend::IsFaviconBitmapDataEqual(
     FaviconBitmapID bitmap_id,
     const scoped_refptr<base::RefCountedMemory>& new_bitmap_data) {
   if (!new_bitmap_data.get())
     return false;
 
   scoped_refptr<base::RefCountedMemory> original_bitmap_data;
-  thumbnail_db_->GetFaviconBitmap(bitmap_id,
-                                  NULL,
-                                  &original_bitmap_data,
-                                  NULL);
+  thumbnail_db_->GetFaviconBitmap(bitmap_id, nullptr, &original_bitmap_data,
+                                  nullptr);
   return new_bitmap_data->Equals(original_bitmap_data);
 }
 
 bool HistoryBackend::GetFaviconsFromDB(
     const GURL& page_url,
     int icon_types,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* favicon_bitmap_results) {
   DCHECK(favicon_bitmap_results);
   favicon_bitmap_results->clear();
@@ skipping 228 matching lines @@
   scheduled_commit_ = new CommitLaterTask(this);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CommitLaterTask::RunCommit, scheduled_commit_.get()),
       base::TimeDelta::FromSeconds(kCommitIntervalSeconds));
 }
 
 void HistoryBackend::CancelScheduledCommit() {
   if (scheduled_commit_.get()) {
     scheduled_commit_->Cancel();
-    scheduled_commit_ = NULL;
+    scheduled_commit_ = nullptr;
   }
 }
 
 void HistoryBackend::ProcessDBTaskImpl() {
   if (!db_) {
     // db went away, release all the refs.
     STLDeleteContainerPointers(queued_history_db_tasks_.begin(),
                                queued_history_db_tasks_.end());
     queued_history_db_tasks_.clear();
     return;
@@ skipping 191 matching lines @@
   bool success = db_->Raze();
   UMA_HISTOGRAM_BOOLEAN("History.KillHistoryDatabaseResult", success);
 
 #if defined(OS_ANDROID)
   // Release AndroidProviderBackend before other objects.
   android_provider_backend_.reset();
 #endif
 
   // The expirer keeps tabs on the active databases. Tell it about the
   // databases which will be closed.
-  expirer_.SetDatabases(NULL, NULL);
+  expirer_.SetDatabases(nullptr, nullptr);
 
   // Reopen a new transaction for |db_| for the sake of CloseAllDatabases().
   db_->BeginTransaction();
   CloseAllDatabases();
 }
 
 void HistoryBackend::ProcessDBTask(
     scoped_ptr<HistoryDBTask> task,
     scoped_refptr<base::SingleThreadTaskRunner> origin_loop,
     const base::CancelableTaskTracker::IsCanceledCallback& is_canceled) {
@@ skipping 210 matching lines @@
   info.url_id = visit.url_id;
   info.time = visit.visit_time;
   info.transition = visit.transition;
   // If we don't have a delegate yet during setup or shutdown, we will drop
   // these notifications.
   if (delegate_)
     delegate_->NotifyAddVisit(info);
 }
 
 }  // namespace history