Extract BookmarksFileImporter from Firefox2Importer.

chrome/browser/importer/profile_writer.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/importer/profile_writer.h"
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/prefs/pref_service.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/bookmarks/imported_bookmark_entry.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
+#include "chrome/browser/favicon/imported_favicon_usage.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/password_manager/password_store.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 30 matching lines @@
   return folder_name;
 }
 
 // Shows the bookmarks toolbar.
 void ShowBookmarkBar(Profile* profile) {
   profile->GetPrefs()->SetBoolean(prefs::kShowBookmarkBar, true);
 }
 
 }  // namespace
 
-ProfileWriter::BookmarkEntry::BookmarkEntry()
-    : in_toolbar(false),
-      is_folder(false) {}
-
-ProfileWriter::BookmarkEntry::~BookmarkEntry() {}
-
-bool ProfileWriter::BookmarkEntry::operator==(
-    const ProfileWriter::BookmarkEntry& other) const {
-  return (in_toolbar == other.in_toolbar &&
-          is_folder == other.is_folder &&
-          url == other.url &&
-          path == other.path &&
-          title == other.title &&
-          creation_time == other.creation_time);
-}
-
 ProfileWriter::ProfileWriter(Profile* profile) : profile_(profile) {}
 
 bool ProfileWriter::BookmarkModelIsLoaded() const {
   return BookmarkModelFactory::GetForProfile(profile_)->loaded();
 }
 
 bool ProfileWriter::TemplateURLServiceIsLoaded() const {
   return TemplateURLServiceFactory::GetForProfile(profile_)->loaded();
 }
 
@@ skipping 18 matching lines @@
   DCHECK(profile_);
 
   PrefService* prefs = profile_->GetPrefs();
   // NOTE: We set the kHomePage value, but keep the NewTab page as the homepage.
   const PrefService::Preference* pref = prefs->FindPreference(prefs::kHomePage);
   if (pref && !pref->IsManaged()) {
     prefs->SetString(prefs::kHomePage, home_page.spec());
   }
 }
 
-void ProfileWriter::AddBookmarks(const std::vector<BookmarkEntry>& bookmarks,
-                                 const string16& top_level_folder_name) {
+void ProfileWriter::AddBookmarks(
+    const std::vector<ImportedBookmarkEntry>& bookmarks,
+    const string16& top_level_folder_name) {
   if (bookmarks.empty())
     return;
 
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile_);
   DCHECK(model->loaded());
 
   // If the bookmark bar is currently empty, we should import directly to it.
   // Otherwise, we should import everything to a subfolder.
   const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
   bool import_to_top_level = bookmark_bar->empty();
 
   // Reorder bookmarks so that the toolbar entries come first.
-  std::vector<BookmarkEntry> toolbar_bookmarks;
-  std::vector<BookmarkEntry> reordered_bookmarks;
-  for (std::vector<BookmarkEntry>::const_iterator it = bookmarks.begin();
+  std::vector<ImportedBookmarkEntry> toolbar_bookmarks;
+  std::vector<ImportedBookmarkEntry> reordered_bookmarks;
+  for (std::vector<ImportedBookmarkEntry>::const_iterator it =
+           bookmarks.begin();
        it != bookmarks.end(); ++it) {
     if (it->in_toolbar)
       toolbar_bookmarks.push_back(*it);
     else
       reordered_bookmarks.push_back(*it);
   }
   reordered_bookmarks.insert(reordered_bookmarks.begin(),
                              toolbar_bookmarks.begin(),
                              toolbar_bookmarks.end());
 
   // If the user currently has no bookmarks in the bookmark bar, make sure that
   // at least some of the imported bookmarks end up there.  Otherwise, we'll end
   // up with just a single folder containing the imported bookmarks, which makes
   // for unnecessary nesting.
   bool add_all_to_top_level = import_to_top_level && toolbar_bookmarks.empty();
 
   model->BeginExtensiveChanges();
 
   std::set<const BookmarkNode*> folders_added_to;
   const BookmarkNode* top_level_folder = NULL;
-  for (std::vector<BookmarkEntry>::const_iterator bookmark =
-         reordered_bookmarks.begin();
+  for (std::vector<ImportedBookmarkEntry>::const_iterator bookmark =
+           reordered_bookmarks.begin();
        bookmark != reordered_bookmarks.end(); ++bookmark) {
     // Disregard any bookmarks with invalid urls.
     if (!bookmark->is_folder && !bookmark->url.is_valid())
       continue;
 
     const BookmarkNode* parent = NULL;
     if (import_to_top_level && (add_all_to_top_level || bookmark->in_toolbar)) {
       // Add directly to the bookmarks bar.
       parent = bookmark_bar;
     } else {
@@ skipping 53 matching lines @@
   }
 
   model->EndExtensiveChanges();
 
   // If the user was previously using a toolbar, we should show the bar.
   if (import_to_top_level && !add_all_to_top_level)
     ShowBookmarkBar(profile_);
 }
 
 void ProfileWriter::AddFavicons(
-    const std::vector<history::ImportedFaviconUsage>& favicons) {
+    const std::vector<ImportedFaviconUsage>& favicons) {
   FaviconServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS)->
       SetImportedFavicons(favicons);
 }
 
 typedef std::map<std::string, TemplateURL*> HostPathMap;
 
 // Returns the key for the map built by BuildHostPathMap. If url_string is not
 // a valid URL, an empty string is returned, otherwise host+path is returned.
 static std::string HostPathKeyForURL(const GURL& url) {
   return url.is_valid() ? url.host() + url.path() : std::string();
@@ skipping 75 matching lines @@
 
     // Only add valid TemplateURLs to the model.
     if ((*i)->url_ref().IsValid()) {
       model->AddAndSetProfile(*i, profile_);  // Takes ownership.
       *i = NULL;  // Prevent the vector from deleting *i later.
     }
   }
 }
 
 ProfileWriter::~ProfileWriter() {}