Extract BookmarksFileImporter from Firefox2Importer.

chrome/browser/importer/ie_importer.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/ie_importer.h"
 
 #include <ole2.h>
 #include <intshcut.h>
 #include <shlobj.h>
 #include <urlhist.h>
@@ skipping 10 matching lines @@
 #include "base/string_util.h"
 #include "base/strings/string_split.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/windows_version.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_data_types.h"
-#include "chrome/browser/importer/importer_util.h"
 #include "chrome/browser/importer/pstore_declarations.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_prepopulate_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/time_format.h"
 #include "chrome/common/url_constants.h"
 #include "components/webdata/encryptor/ie7_password.h"
 #include "content/public/common/password_form.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
@@ skipping 66 matching lines @@
     if (id_cb == 0)
       break;
     head += id_cb;
   }
   return reinterpret_cast<LPCITEMIDLIST>(&blob[offset]);
 }
 
 // Compares the two bookmarks in the order of IE's Favorites menu.
 // Returns true if rhs should come later than lhs (lhs < rhs).
 struct IEOrderBookmarkComparator {
-  bool operator()(const ProfileWriter::BookmarkEntry& lhs,
-                  const ProfileWriter::BookmarkEntry& rhs) const {
+  bool operator()(const ImportedBookmarkEntry& lhs,
+                  const ImportedBookmarkEntry& rhs) const {
     static const uint32 kNotSorted = 0xfffffffb; // IE uses this magic value.
     base::FilePath lhs_prefix;
     base::FilePath rhs_prefix;
     for (size_t i = 0; i <= lhs.path.size() && i <= rhs.path.size(); ++i) {
       const base::FilePath::StringType lhs_i =
         (i < lhs.path.size() ? lhs.path[i] : lhs.title + L".url");
       const base::FilePath::StringType rhs_i =
         (i < rhs.path.size() ? rhs.path[i] : rhs.title + L".url");
       lhs_prefix = lhs_prefix.Append(lhs_i);
       rhs_prefix = rhs_prefix.Append(rhs_i);
@@ skipping 122 matching lines @@
   if (!key.Valid())
     return false;
   return ParseFavoritesOrderRegistryTree(importer, key, base::FilePath(),
                                          sort_index);
 }
 
 // Reads the sort order from registry. If failed, we don't touch the list
 // and use the default (alphabetical) order.
 void SortBookmarksInIEOrder(
     const Importer* importer,
-    std::vector<ProfileWriter::BookmarkEntry>* bookmarks) {
+    std::vector<ImportedBookmarkEntry>* bookmarks) {
   std::map<base::FilePath, uint32> sort_index;
   if (!ParseFavoritesOrderInfo(importer, &sort_index))
     return;
   IEOrderBookmarkComparator compare = {&sort_index};
   std::sort(bookmarks->begin(), bookmarks->end(), compare);
 }
 
 // Reads an internet shortcut (*.url) |file| and returns a COM object
 // representing it.
 bool LoadInternetShortcut(
@@ skipping 85 matching lines @@
                               const GURL& favicon_url,
                               std::vector<unsigned char>* data) {
   std::string image_data;
   if (!ReadFaviconDataFromInternetShortcut(file, &image_data) &&
       !ReadFaviconDataFromCache(favicon_url, &image_data)) {
     return false;
   }
 
   const unsigned char* ptr =
       reinterpret_cast<const unsigned char*>(image_data.c_str());
-  return importer::ReencodeFavicon(ptr, image_data.size(), data);
+  return FaviconUtil::ReencodeFavicon(ptr, image_data.size(), data);
 }
 
 // Loads favicon image data and registers to |favicon_map|.
 void UpdateFaviconMap(
     const string16& url_file,
     const GURL& url,
     IUniformResourceLocator* url_locator,
-    std::map<GURL, history::ImportedFaviconUsage>* favicon_map) {
+    std::map<GURL, ImportedFaviconUsage>* favicon_map) {
   GURL favicon_url = ReadFaviconURLFromInternetShortcut(url_locator);
   if (!favicon_url.is_valid())
     return;
 
-  std::map<GURL, history::ImportedFaviconUsage>::iterator it =
+  std::map<GURL, ImportedFaviconUsage>::iterator it =
     favicon_map->find(favicon_url);
   if (it != favicon_map->end()) {
     // Known favicon URL.
     it->second.urls.insert(url);
   } else {
     // New favicon URL. Read the image data and store.
-    history::ImportedFaviconUsage usage;
+    ImportedFaviconUsage usage;
     if (ReadReencodedFaviconData(url_file, favicon_url, &usage.png_data)) {
       usage.favicon_url = favicon_url;
       usage.urls.insert(url);
       favicon_map->insert(std::make_pair(favicon_url, usage));
     }
   }
 }
 
 }  // namespace
 
@@ skipping 60 matching lines @@
 
 IEImporter::~IEImporter() {
 }
 
 void IEImporter::ImportFavorites() {
   FavoritesInfo info;
   if (!GetFavoritesInfo(&info))
     return;
 
   BookmarkVector bookmarks;
-  std::vector<history::ImportedFaviconUsage> favicons;
+  std::vector<ImportedFaviconUsage> favicons;
   ParseFavoritesFolder(info, &bookmarks, &favicons);
 
   if (!bookmarks.empty() && !cancelled()) {
     const string16& first_folder_name =
         l10n_util::GetStringUTF16(IDS_BOOKMARK_GROUP_FROM_IE);
     bridge_->AddBookmarks(bookmarks, first_folder_name);
   }
   if (!favicons.empty() && !cancelled())
     bridge_->SetFavicons(favicons);
 }
@@ skipping 320 matching lines @@
   } else {
     info->links_folder = L"Links";
   }
 
   return true;
 }
 
 void IEImporter::ParseFavoritesFolder(
     const FavoritesInfo& info,
     BookmarkVector* bookmarks,
-    std::vector<history::ImportedFaviconUsage>* favicons) {
+    std::vector<ImportedFaviconUsage>* favicons) {
   base::FilePath file;
   std::vector<base::FilePath::StringType> file_list;
   base::FilePath favorites_path(info.path);
   // Favorites path length.  Make sure it doesn't include the trailing \.
   size_t favorites_path_len =
       favorites_path.StripTrailingSeparators().value().size();
   file_util::FileEnumerator file_enumerator(
       favorites_path, true, file_util::FileEnumerator::FILES);
   while (!(file = file_enumerator.Next()).value().empty() && !cancelled())
     file_list.push_back(file.value());
 
   // Keep the bookmarks in alphabetical order.
   std::sort(file_list.begin(), file_list.end());
 
   // Map from favicon URLs to the favicon data (the binary image data and the
   // set of bookmark URLs referring to the favicon).
-  typedef std::map<GURL, history::ImportedFaviconUsage> FaviconMap;
+  typedef std::map<GURL, ImportedFaviconUsage> FaviconMap;
   FaviconMap favicon_map;
 
   for (std::vector<base::FilePath::StringType>::iterator it = file_list.begin();
        it != file_list.end(); ++it) {
     base::FilePath shortcut(*it);
     if (!LowerCaseEqualsASCII(shortcut.Extension(), ".url"))
       continue;
 
     // Skip the bookmark with invalid URL.
     base::win::ScopedComPtr<IUniformResourceLocator> url_locator;
@@ skipping 16 matching lines @@
     // ex. Suppose that the Favorites folder is C:\Users\Foo\Favorites.
     //   C:\Users\Foo\Favorites\Foo.url -> ""
     //   C:\Users\Foo\Favorites\Links\Bar\Baz.url -> "Links\Bar"
     base::FilePath::StringType relative_string =
         shortcut.DirName().value().substr(favorites_path_len);
     if (!relative_string.empty() &&
         base::FilePath::IsSeparator(relative_string[0]))
       relative_string = relative_string.substr(1);
     base::FilePath relative_path(relative_string);
 
-    ProfileWriter::BookmarkEntry entry;
+    ImportedBookmarkEntry entry;
     // Remove the dot, the file extension, and the directory path.
     entry.title = shortcut.RemoveExtension().BaseName().value();
     entry.url = url;
     entry.creation_time = GetFileCreationTime(*it);
     if (!relative_path.empty())
       relative_path.GetComponents(&entry.path);
 
     // Add the bookmark.
     if (!entry.path.empty() && entry.path[0] == info.links_folder) {
       // Bookmarks in the Link folder should be imported to the toolbar.
@@ skipping 15 matching lines @@
   static int version = -1;
   if (version < 0) {
     wchar_t buffer[128];
     DWORD buffer_length = sizeof(buffer);
     base::win::RegKey reg_key(HKEY_LOCAL_MACHINE, kIEVersionKey, KEY_READ);
     LONG result = reg_key.ReadValue(L"Version", buffer, &buffer_length, NULL);
     version = ((result == ERROR_SUCCESS)? _wtoi(buffer) : 0);
   }
   return version;
 }