Extract BookmarksFileImporter from Firefox2Importer.

chrome/browser/importer/safari_importer.mm

 // 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 <Cocoa/Cocoa.h>
 
 #include "chrome/browser/importer/safari_importer.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/mac/mac_util.h"
 #include "base/memory/scoped_nsobject.h"
 #include "base/string16.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/history/history_types.h"
+#include "chrome/browser/bookmarks/imported_bookmark_entry.h"
+#include "chrome/browser/favicon/favicon_util.h"
+#include "chrome/browser/favicon/imported_favicon_usage.h"
 #include "chrome/browser/importer/importer_bridge.h"
-#include "chrome/browser/importer/importer_util.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/base/data_url.h"
 #include "sql/statement.h"
 
 namespace {
 
 // A function like this is used by other importers in order to filter out
 // URLS we don't want to import.
@@ skipping 61 matching lines @@
     bridge_->NotifyItemStarted(importer::PASSWORDS);
     ImportPasswords();
     bridge_->NotifyItemEnded(importer::PASSWORDS);
   }
   bridge_->NotifyEnded();
 }
 
 void SafariImporter::ImportBookmarks() {
   string16 toolbar_name =
       bridge_->GetLocalizedString(IDS_BOOKMARK_BAR_FOLDER_NAME);
-  std::vector<ProfileWriter::BookmarkEntry> bookmarks;
+  std::vector<ImportedBookmarkEntry> bookmarks;
   ParseBookmarks(toolbar_name, &bookmarks);
 
   // Write bookmarks into profile.
   if (!bookmarks.empty() && !cancelled()) {
     const string16& first_folder_name =
         bridge_->GetLocalizedString(IDS_BOOKMARK_GROUP_FROM_SAFARI);
     bridge_->AddBookmarks(bookmarks, first_folder_name);
   }
 
   // Import favicons.
   sql::Connection db;
   if (!OpenDatabase(&db))
     return;
 
   FaviconMap favicon_map;
   ImportFaviconURLs(&db, &favicon_map);
   // Write favicons into profile.
   if (!favicon_map.empty() && !cancelled()) {
-    std::vector<history::ImportedFaviconUsage> favicons;
+    std::vector<ImportedFaviconUsage> favicons;
     LoadFaviconData(&db, favicon_map, &favicons);
     bridge_->SetFavicons(favicons);
   }
 }
 
 bool SafariImporter::OpenDatabase(sql::Connection* db) {
   // Construct ~/Library/Safari/WebIcons.db path.
   NSString* library_dir = [NSString
       stringWithUTF8String:library_dir_.value().c_str()];
   NSString* safari_dir = [library_dir
@@ skipping 13 matching lines @@
   while (s.Step() && !cancelled()) {
     int64 icon_id = s.ColumnInt64(0);
     GURL url = GURL(s.ColumnString(1));
     (*favicon_map)[icon_id].insert(url);
   }
 }
 
 void SafariImporter::LoadFaviconData(
     sql::Connection* db,
     const FaviconMap& favicon_map,
-    std::vector<history::ImportedFaviconUsage>* favicons) {
+    std::vector<ImportedFaviconUsage>* favicons) {
   const char* query = "SELECT i.url, d.data "
                       "FROM IconInfo i JOIN IconData d "
                       "ON i.iconID = d.iconID "
                       "WHERE i.iconID = ?;";
   sql::Statement s(db->GetUniqueStatement(query));
 
   for (FaviconMap::const_iterator i = favicon_map.begin();
        i != favicon_map.end(); ++i) {
     s.Reset(true);
     s.BindInt64(0, i->first);
     if (s.Step()) {
-      history::ImportedFaviconUsage usage;
+      ImportedFaviconUsage usage;
 
       usage.favicon_url = GURL(s.ColumnString(0));
       if (!usage.favicon_url.is_valid())
         continue;  // Don't bother importing favicons with invalid URLs.
 
       std::vector<unsigned char> data;
       s.ColumnBlobAsVector(1, &data);
       if (data.empty())
         continue;  // Data definitely invalid.
 
-      if (!importer::ReencodeFavicon(&data[0], data.size(), &usage.png_data))
+      if (!FaviconUtil::ReencodeFavicon(&data[0], data.size(), &usage.png_data))
         continue;  // Unable to decode.
 
       usage.urls = i->second;
       favicons->push_back(usage);
     }
   }
 }
 
 void SafariImporter::RecursiveReadBookmarksFolder(
     NSDictionary* bookmark_folder,
     const std::vector<string16>& parent_path_elements,
     bool is_in_toolbar,
     const string16& toolbar_name,
-    std::vector<ProfileWriter::BookmarkEntry>* out_bookmarks) {
+    std::vector<ImportedBookmarkEntry>* out_bookmarks) {
   DCHECK(bookmark_folder);
 
   NSString* type = [bookmark_folder objectForKey:@"WebBookmarkType"];
   NSString* title = [bookmark_folder objectForKey:@"Title"];
 
   // Are we the dictionary that contains all other bookmarks?
   // We need to know this so we don't add it to the path.
   bool is_top_level_bookmarks_container = [bookmark_folder
       objectForKey:@"WebBookmarkFileVersion"] != nil;
 
   // We're expecting a list of bookmarks here, if that isn't what we got, fail.
   if (!is_top_level_bookmarks_container) {
     // Top level containers sometimes don't have title attributes.
     if (![type isEqualToString:@"WebBookmarkTypeList"] || !title) {
       NOTREACHED() << "Type=("
                    << (type ? base::SysNSStringToUTF8(type) : "Null type")
                    << ") Title=("
                    << (title ? base::SysNSStringToUTF8(title) : "Null title")
                    << ")";
       return;
     }
   }
 
   NSArray* elements = [bookmark_folder objectForKey:@"Children"];
   if (!elements && (!parent_path_elements.empty() || !is_in_toolbar)) {
     // This is an empty folder, so add it explicitly; but don't add the toolbar
     // folder if it is empty.  Note that all non-empty folders are added
     // implicitly when their children are added.
-    ProfileWriter::BookmarkEntry entry;
+    ImportedBookmarkEntry entry;
     // Safari doesn't specify a creation time for the folder.
     entry.creation_time = base::Time::Now();
     entry.title = base::SysNSStringToUTF16(title);
     entry.path = parent_path_elements;
     entry.in_toolbar = is_in_toolbar;
     entry.is_folder = true;
 
     out_bookmarks->push_back(entry);
     return;
   }
@@ skipping 31 matching lines @@
       continue;
 
     NSString* url = [bookmark objectForKey:@"URLString"];
     NSString* title = [[bookmark objectForKey:@"URIDictionary"]
         objectForKey:@"title"];
 
     if (!url || !title)
       continue;
 
     // Output Bookmark.
-    ProfileWriter::BookmarkEntry entry;
+    ImportedBookmarkEntry entry;
     // Safari doesn't specify a creation time for the bookmark.
     entry.creation_time = base::Time::Now();
     entry.title = base::SysNSStringToUTF16(title);
     entry.url = GURL(base::SysNSStringToUTF8(url));
     entry.path = path_elements;
     entry.in_toolbar = is_in_toolbar;
 
     out_bookmarks->push_back(entry);
   }
 }
 
 void SafariImporter::ParseBookmarks(
     const string16& toolbar_name,
-    std::vector<ProfileWriter::BookmarkEntry>* bookmarks) {
+    std::vector<ImportedBookmarkEntry>* bookmarks) {
   DCHECK(bookmarks);
 
   // Construct ~/Library/Safari/Bookmarks.plist path
   NSString* library_dir = [NSString
       stringWithUTF8String:library_dir_.value().c_str()];
   NSString* safari_dir = [library_dir
       stringByAppendingPathComponent:@"Safari"];
   NSString* bookmarks_plist = [safari_dir
     stringByAppendingPathComponent:@"Bookmarks.plist"];
 
@@ skipping 90 matching lines @@
     if (!last_visit_str)
       continue;
 
     // Convert Safari's last visit time to Unix Epoch time.
     double seconds_since_unix_epoch = HistoryTimeToEpochTime(last_visit_str);
     row.set_last_visit(base::Time::FromDoubleT(seconds_since_unix_epoch));
 
     history_items->push_back(row);
   }
 }