bookmarks: Get rid of the dependency on history_notifications.h

chrome/browser/history/android/android_provider_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/android/android_provider_backend.h"
 
 #include "base/i18n/case_conversion.h"
 #include "chrome/browser/bookmarks/bookmark_service.h"
+#include "chrome/browser/favicon/favicon_changed_details.h"
 #include "chrome/browser/history/android/android_time.h"
 #include "chrome/browser/history/android/android_urls_sql_handler.h"
 #include "chrome/browser/history/android/bookmark_model_sql_handler.h"
 #include "chrome/browser/history/android/favicon_sql_handler.h"
 #include "chrome/browser/history/android/urls_sql_handler.h"
 #include "chrome/browser/history/android/visit_sql_handler.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/thumbnail_database.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 132 matching lines @@
   return QueryHistoryAndBookmarksInternal(projections, selection,
                                           selection_args, sort_order);
 }
 
 bool AndroidProviderBackend::UpdateHistoryAndBookmarks(
     const HistoryAndBookmarkRow& row,
     const std::string& selection,
     const std::vector<string16>& selection_args,
     int* updated_count) {
   HistoryNotifications notifications;
+  FaviconNotifications favicon_notifications;
 
   ScopedTransaction transaction(history_db_, thumbnail_db_);
 
   if (!UpdateHistoryAndBookmarks(row, selection, selection_args, updated_count,
-                                 &notifications))
+                                 &notifications, &favicon_notifications))
     return false;
 
   transaction.Commit();
+  SendFaviconChangedNotifications(favicon_notifications);
   BroadcastNotifications(notifications);
   return true;
 }
 
 AndroidURLID AndroidProviderBackend::InsertHistoryAndBookmark(
     const HistoryAndBookmarkRow& values) {
   HistoryNotifications notifications;
+  FaviconNotifications favicon_notifications;
 
   ScopedTransaction transaction(history_db_, thumbnail_db_);
 
-  AndroidURLID id = InsertHistoryAndBookmark(values, &notifications, true);
+  AndroidURLID id = InsertHistoryAndBookmark(
+      values, &notifications, &favicon_notifications, true);
   if (id) {
     transaction.Commit();
     BroadcastNotifications(notifications);
+    SendFaviconChangedNotifications(favicon_notifications);
     return id;
   }
   return 0;
 }
 
 bool AndroidProviderBackend::DeleteHistoryAndBookmarks(
     const std::string& selection,
     const std::vector<string16>& selection_args,
     int* deleted_count) {
   HistoryNotifications notifications;
 
   ScopedTransaction transaction(history_db_, thumbnail_db_);
 
   if (!DeleteHistoryAndBookmarks(selection, selection_args, deleted_count,
                                  &notifications))
     return false;
 
   transaction.Commit();
   BroadcastNotifications(notifications);
   return true;
 }
 
 bool AndroidProviderBackend::DeleteHistory(
     const std::string& selection,
     const std::vector<string16>& selection_args,
     int* deleted_count) {
   HistoryNotifications notifications;
+  FaviconNotifications favicon_notifications;
 
   ScopedTransaction transaction(history_db_, thumbnail_db_);
 
   if (!DeleteHistory(selection, selection_args, deleted_count,
-                     &notifications))
+                     &notifications, &favicon_notifications))
     return false;
 
   transaction.Commit();
   BroadcastNotifications(notifications);
+  SendFaviconChangedNotifications(favicon_notifications);
   return true;
 }
 
 AndroidProviderBackend::HistoryNotification::HistoryNotification(
     int type,
     HistoryDetails* detail)
     : type(type),
       detail(detail) {
 }
 
@@ skipping 55 matching lines @@
   if (thumbnail_db_)
     thumbnail_db_->CommitTransaction();
   committed_ = true;
 }
 
 bool AndroidProviderBackend::UpdateHistoryAndBookmarks(
     const HistoryAndBookmarkRow& row,
     const std::string& selection,
     const std::vector<string16>& selection_args,
     int* updated_count,
-    HistoryNotifications* notifications) {
+    HistoryNotifications* notifications,
+    FaviconNotifications* favicon_notifications) {
   if (!IsHistoryAndBookmarkRowValid(row))
     return false;
 
   if (row.is_value_set_explicitly(HistoryAndBookmarkRow::ID))
     return false;
 
   if (!EnsureInitializedAndUpdated())
     return false;
 
   TableIDRows ids_set;
@@ skipping 22 matching lines @@
   for (std::vector<SQLHandler*>::iterator i =
        sql_handlers_.begin(); i != sql_handlers_.end(); ++i) {
     if ((*i)->HasColumnIn(row)) {
       if (!(*i)->Update(row, ids_set))
         return false;
     }
   }
   *updated_count = ids_set.size();
 
   scoped_ptr<URLsModifiedDetails> modified(new URLsModifiedDetails);
-  scoped_ptr<FaviconChangeDetails> favicon(new FaviconChangeDetails);
+  scoped_ptr<chrome::FaviconChangedDetails> favicon(
+      new chrome::FaviconChangedDetails);
 
   for (TableIDRows::const_iterator i = ids_set.begin(); i != ids_set.end();
        ++i) {
     if (row.is_value_set_explicitly(HistoryAndBookmarkRow::TITLE) ||
         row.is_value_set_explicitly(HistoryAndBookmarkRow::VISIT_COUNT) ||
         row.is_value_set_explicitly(HistoryAndBookmarkRow::LAST_VISIT_TIME)) {
       URLRow url_row;
       if (!history_db_->GetURLRow(i->url_id, &url_row))
         return false;
       modified->changed_urls.push_back(url_row);
     }
     if (thumbnail_db_ &&
         row.is_value_set_explicitly(HistoryAndBookmarkRow::FAVICON))
       favicon->urls.insert(i->url);
   }
 
   if (!modified->changed_urls.empty())
     notifications->push_back(HistoryNotification(
         chrome::NOTIFICATION_HISTORY_URLS_MODIFIED, modified.release()));
 
   if (!favicon->urls.empty())
-    notifications->push_back(HistoryNotification(
-        chrome::NOTIFICATION_FAVICON_CHANGED, favicon.release()));
+    favicon_notifications->push_back(favicon.release());
 
   return true;
 }
 
 AndroidURLID AndroidProviderBackend::InsertHistoryAndBookmark(
     const HistoryAndBookmarkRow& values,
     HistoryNotifications* notifications,
+    FaviconNotifications* favicon_notifications,
     bool ensure_initialized_and_updated) {
   if (!IsHistoryAndBookmarkRowValid(values))
     return false;
 
   if (ensure_initialized_and_updated && !EnsureInitializedAndUpdated())
     return 0;
 
   DCHECK(values.is_value_set_explicitly(HistoryAndBookmarkRow::URL));
   // Make a copy of values as we need change it during insert.
   HistoryAndBookmarkRow row = values;
   for (std::vector<SQLHandler*>::iterator i =
        sql_handlers_.begin(); i != sql_handlers_.end(); ++i) {
     if (!(*i)->Insert(&row))
       return 0;
   }
 
   URLRow url_row;
   if (!history_db_->GetURLRow(row.url_id(), &url_row))
     return false;
 
   scoped_ptr<URLsModifiedDetails> modified(new URLsModifiedDetails);
   if (!modified.get())
     return false;
   modified->changed_urls.push_back(url_row);
 
-  scoped_ptr<FaviconChangeDetails> favicon;
+  scoped_ptr<chrome::FaviconChangedDetails> favicon;
   // No favicon should be changed if the thumbnail_db_ is not available.
   if (row.is_value_set_explicitly(HistoryAndBookmarkRow::FAVICON) &&
       row.favicon_valid() && thumbnail_db_) {
-    favicon.reset(new FaviconChangeDetails);
+    favicon.reset(new chrome::FaviconChangedDetails);
     if (!favicon.get())
       return false;
     favicon->urls.insert(url_row.url());
   }
 
   notifications->push_back(HistoryNotification(
       chrome::NOTIFICATION_HISTORY_URLS_MODIFIED, modified.release()));
   if (favicon.get())
-    notifications->push_back(HistoryNotification(
-        chrome::NOTIFICATION_FAVICON_CHANGED, favicon.release()));
+    favicon_notifications->push_back(favicon.release());
 
   return row.id();
 }
 
 bool AndroidProviderBackend::DeleteHistoryAndBookmarks(
     const std::string& selection,
     const std::vector<string16>& selection_args,
     int * deleted_count,
     HistoryNotifications* notifications) {
   if (!EnsureInitializedAndUpdated())
@@ skipping 13 matching lines @@
 
   *deleted_count = ids_set.size();
 
   return true;
 }
 
 bool AndroidProviderBackend::DeleteHistory(
     const std::string& selection,
     const std::vector<string16>& selection_args,
     int* deleted_count,
-    HistoryNotifications* notifications) {
+    HistoryNotifications* notifications,
+    FaviconNotifications* favicon_notifications) {
   if (!EnsureInitializedAndUpdated())
     return false;
 
   TableIDRows ids_set;
   if (!GetSelectedURLs(selection, selection_args, &ids_set))
     return false;
 
   if (ids_set.empty()) {
     *deleted_count = 0;
     return true;
@@ skipping 25 matching lines @@
   // Don't delete the bookmark from bookmark model when deleting the history.
   if (!DeleteHistoryInternal(ids_set, false, notifications))
     return false;
 
   for (std::vector<HistoryAndBookmarkRow>::const_iterator i = bookmarks.begin();
        i != bookmarks.end(); ++i) {
     // Don't update the tables, otherwise, the bookmarks will be added to
     // database during UpdateBookmark(), then the insertion will fail.
     // We can't rely on UpdateBookmark() to insert the bookmarks into history
     // database as the raw_url will be lost.
-    if (!InsertHistoryAndBookmark(*i, notifications, false))
+    if (!InsertHistoryAndBookmark(
+            *i, notifications, favicon_notifications, false))
       return false;
   }
   return true;
 }
 
 AndroidStatement* AndroidProviderBackend::QuerySearchTerms(
     const std::vector<SearchRow::ColumnID>& projections,
     const std::string& selection,
     const std::vector<string16>& selection_args,
     const std::string& sort_order) {
@@ skipping 470 matching lines @@
 
   HistoryAndBookmarkRow new_row;
   new_row.set_last_visit_time(FromDatabaseTime(
       statement->statement()->ColumnInt64(0)));
   new_row.set_created(FromDatabaseTime(
       statement->statement()->ColumnInt64(1)));
   new_row.set_visit_count(statement->statement()->ColumnInt(2));
   new_row.set_title(statement->statement()->ColumnString16(3));
 
   scoped_ptr<URLsDeletedDetails> deleted_details(new URLsDeletedDetails);
-  scoped_ptr<FaviconChangeDetails> favicon_details(new FaviconChangeDetails);
+  scoped_ptr<chrome::FaviconChangedDetails> favicon_details(
+      new chrome::FaviconChangedDetails);
   scoped_ptr<URLsModifiedDetails> modified(new URLsModifiedDetails);
   URLRow old_url_row;
   if (!history_db_->GetURLRow(ids[0].url_id, &old_url_row))
     return false;
   deleted_details->rows.push_back(old_url_row);
 
   chrome::FaviconID favicon_id = statement->statement()->ColumnInt64(4);
   if (favicon_id) {
     std::vector<FaviconBitmap> favicon_bitmaps;
     if (!thumbnail_db_ ||
@@ skipping 61 matching lines @@
   URLRow new_url_row;
   if (!history_db_->GetURLRow(new_row.url_id(), &new_url_row))
     return false;
 
   modified->changed_urls.push_back(new_url_row);
 
   notifications->push_back(HistoryNotification(
       chrome::NOTIFICATION_HISTORY_URLS_DELETED,
       deleted_details.release()));
   if (favicon_details.get() && !favicon_details->urls.empty())
-    notifications->push_back(HistoryNotification(
-        chrome::NOTIFICATION_FAVICON_CHANGED, favicon_details.release()));
+    favicon_notifications->push_back(favicon_details.release());
   notifications->push_back(HistoryNotification(
       chrome::NOTIFICATION_HISTORY_URLS_MODIFIED, modified.release()));
 
   return true;
 }
 
 AndroidStatement* AndroidProviderBackend::QueryHistoryAndBookmarksInternal(
     const std::vector<HistoryAndBookmarkRow::ColumnID>& projections,
     const std::string& selection,
     const std::vector<string16>& selection_args,
@@ skipping 25 matching lines @@
   }
   sql::Statement* result = statement.release();
   return new AndroidStatement(result, replaced_index);
 }
 
 bool AndroidProviderBackend::DeleteHistoryInternal(
     const TableIDRows& urls,
     bool delete_bookmarks,
     HistoryNotifications* notifications) {
   scoped_ptr<URLsDeletedDetails> deleted_details(new URLsDeletedDetails);
-  scoped_ptr<FaviconChangeDetails> favicon(new FaviconChangeDetails);
+  scoped_ptr<chrome::FaviconChangedDetails> favicon(
+      new chrome::FaviconChangedDetails);
   for (TableIDRows::const_iterator i = urls.begin(); i != urls.end(); ++i) {
     URLRow url_row;
     if (!history_db_->GetURLRow(i->url_id, &url_row))
       return false;
     deleted_details->rows.push_back(url_row);
     if (thumbnail_db_ &&
         thumbnail_db_->GetIconMappingsForPageURL(url_row.url(), NULL))
       favicon->urls.insert(url_row.url());
   }
 
   // Only invoke Delete on the BookmarkModelHandler if we need
   // to delete bookmarks.
   for (std::vector<SQLHandler*>::iterator i =
        sql_handlers_.begin(); i != sql_handlers_.end(); ++i) {
     if ((*i) != bookmark_model_handler_.get() || delete_bookmarks)
       if (!(*i)->Delete(urls))
         return false;
   }
 
   notifications->push_back(HistoryNotification(
       chrome::NOTIFICATION_HISTORY_URLS_DELETED,
       deleted_details.release()));
   if (favicon.get() && !favicon->urls.empty())
-    notifications->push_back(HistoryNotification(
-        chrome::NOTIFICATION_FAVICON_CHANGED, favicon.release()));
+    favicon_notifications->push_back(favicon.release());
   return true;
 }
 
+void AndroidProviderBackend::SendFaviconChangedNotifications(
+    const FaviconNotifications& favicon_notifications) {
+  for (size_t i = 0; i < favicon_notifications.size(); ++i)
+    delegate_->SendFaviconChangedNotification(favicon_notifications[i]);
+}
+
 void AndroidProviderBackend::BroadcastNotifications(
     const HistoryNotifications& notifications) {
   for (HistoryNotifications::const_iterator i = notifications.begin();
        i != notifications.end(); ++i) {
     delegate_->BroadcastNotifications(i->type, i->detail);
   }
 }
 
 bool AndroidProviderBackend::AddSearchTerm(const SearchRow& values) {
   DCHECK(values.is_value_set_explicitly(SearchRow::SEARCH_TERM));
@@ skipping 40 matching lines @@
       return false;
 
     if (!history_db_->SetKeywordSearchTermsForURL(bookmark_row.url_id(),
                           values.template_url_id(), values.search_term()))
       return false;
   }
   return true;
 }
 
 }  // namespace history