chrome/utility/importer/firefox_importer.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/utility/importer/firefox_importer.h"
   6
   7 #include <set>
   8
   9 #include "base/files/file_enumerator.h"
  10 #include "base/files/file_util.h"
  11 #include "base/json/json_file_value_serializer.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/stl_util.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "chrome/common/importer/firefox_importer_utils.h"
  18 #include "chrome/common/importer/firefox_importer_utils.h"
  19 #include "chrome/common/importer/imported_bookmark_entry.h"
  20 #include "chrome/common/importer/imported_favicon_usage.h"
  21 #include "chrome/common/importer/importer_autofill_form_data_entry.h"
  22 #include "chrome/common/importer/importer_bridge.h"
  23 #include "chrome/common/importer/importer_url_row.h"
  24 #include "chrome/grit/generated_resources.h"
  25 #include "chrome/utility/importer/bookmark_html_reader.h"
  26 #include "chrome/utility/importer/favicon_reencode.h"
  27 #include "chrome/utility/importer/nss_decryptor.h"
  28 #include "components/autofill/core/common/password_form.h"
  29 #include "sql/connection.h"
  30 #include "sql/statement.h"
  31 #include "url/gurl.h"
  32
  33 namespace {
  34
  35 // Original definition is in http://mxr.mozilla.org/firefox/source/toolkit/
  36 //  components/places/public/nsINavBookmarksService.idl
  37 enum BookmarkItemType {
  38   TYPE_BOOKMARK = 1,
  39   TYPE_FOLDER = 2,
  40   TYPE_SEPARATOR = 3,
  41   TYPE_DYNAMIC_CONTAINER = 4
  42 };
  43
  44 // Loads the default bookmarks in the Firefox installed at |app_path|,
  45 // and stores their locations in |urls|.
  46 void LoadDefaultBookmarks(const base::FilePath& app_path,
  47                           std::set<GURL>* urls) {
  48   base::FilePath file = app_path.AppendASCII("defaults")
  49       .AppendASCII("profile")
  50       .AppendASCII("bookmarks.html");
  51   urls->clear();
  52
  53   std::vector<ImportedBookmarkEntry> bookmarks;
  54   bookmark_html_reader::ImportBookmarksFile(base::Callback<bool(void)>(),
  55                                             base::Callback<bool(const GURL&)>(),
  56                                             file,
  57                                             &bookmarks,
  58                                             NULL);
  59   for (size_t i = 0; i < bookmarks.size(); ++i)
  60     urls->insert(bookmarks[i].url);
  61 }
  62
  63 // Returns true if |url| has a valid scheme that we allow to import. We
  64 // filter out the URL with a unsupported scheme.
  65 bool CanImportURL(const GURL& url) {
  66   // The URL is not valid.
  67   if (!url.is_valid())
  68     return false;
  69
  70   // Filter out the URLs with unsupported schemes.
  71   const char* const kInvalidSchemes[] = {"wyciwyg", "place", "about", "chrome"};
  72   for (size_t i = 0; i < arraysize(kInvalidSchemes); ++i) {
  73     if (url.SchemeIs(kInvalidSchemes[i]))
  74       return false;
  75   }
  76
  77   return true;
  78 }
  79
  80 }  // namespace
  81
  82 struct FirefoxImporter::BookmarkItem {
  83   int parent;
  84   int id;
  85   GURL url;
  86   base::string16 title;
  87   BookmarkItemType type;
  88   std::string keyword;
  89   base::Time date_added;
  90   int64 favicon;
  91   bool empty_folder;
  92 };
  93
  94 FirefoxImporter::FirefoxImporter() {
  95 }
  96
  97 FirefoxImporter::~FirefoxImporter() {
  98 }
  99
 100 void FirefoxImporter::StartImport(
 101     const importer::SourceProfile& source_profile,
 102     uint16 items,
 103     ImporterBridge* bridge) {
 104   bridge_ = bridge;
 105   source_path_ = source_profile.source_path;
 106   app_path_ = source_profile.app_path;
 107
 108 #if defined(OS_POSIX)
 109   locale_ = source_profile.locale;
 110 #endif
 111
 112   // The order here is important!
 113   bridge_->NotifyStarted();
 114   if ((items & importer::HOME_PAGE) && !cancelled()) {
 115     bridge_->NotifyItemStarted(importer::HOME_PAGE);
 116     ImportHomepage();  // Doesn't have a UI item.
 117     bridge_->NotifyItemEnded(importer::HOME_PAGE);
 118   }
 119
 120   // Note history should be imported before bookmarks because bookmark import
 121   // will also import favicons and we store favicon for a URL only if the URL
 122   // exist in history or bookmarks.
 123   if ((items & importer::HISTORY) && !cancelled()) {
 124     bridge_->NotifyItemStarted(importer::HISTORY);
 125     ImportHistory();
 126     bridge_->NotifyItemEnded(importer::HISTORY);
 127   }
 128
 129   if ((items & importer::FAVORITES) && !cancelled()) {
 130     bridge_->NotifyItemStarted(importer::FAVORITES);
 131     ImportBookmarks();
 132     bridge_->NotifyItemEnded(importer::FAVORITES);
 133   }
 134   if ((items & importer::SEARCH_ENGINES) && !cancelled()) {
 135     bridge_->NotifyItemStarted(importer::SEARCH_ENGINES);
 136     ImportSearchEngines();
 137     bridge_->NotifyItemEnded(importer::SEARCH_ENGINES);
 138   }
 139   if ((items & importer::PASSWORDS) && !cancelled()) {
 140     bridge_->NotifyItemStarted(importer::PASSWORDS);
 141     ImportPasswords();
 142     bridge_->NotifyItemEnded(importer::PASSWORDS);
 143   }
 144   if ((items & importer::AUTOFILL_FORM_DATA) && !cancelled()) {
 145     bridge_->NotifyItemStarted(importer::AUTOFILL_FORM_DATA);
 146     ImportAutofillFormData();
 147     bridge_->NotifyItemEnded(importer::AUTOFILL_FORM_DATA);
 148   }
 149   bridge_->NotifyEnded();
 150 }
 151
 152 void FirefoxImporter::ImportHistory() {
 153   base::FilePath file = source_path_.AppendASCII("places.sqlite");
 154   if (!base::PathExists(file))
 155     return;
 156
 157   sql::Connection db;
 158   if (!db.Open(file))
 159     return;
 160
 161   // |visit_type| represent the transition type of URLs (typed, click,
 162   // redirect, bookmark, etc.) We eliminate some URLs like sub-frames and
 163   // redirects, since we don't want them to appear in history.
 164   // Firefox transition types are defined in:
 165   //   toolkit/components/places/public/nsINavHistoryService.idl
 166   const char* query = "SELECT h.url, h.title, h.visit_count, "
 167                       "h.hidden, h.typed, v.visit_date "
 168                       "FROM moz_places h JOIN moz_historyvisits v "
 169                       "ON h.id = v.place_id "
 170                       "WHERE v.visit_type <= 3";
 171
 172   sql::Statement s(db.GetUniqueStatement(query));
 173
 174   std::vector<ImporterURLRow> rows;
 175   while (s.Step() && !cancelled()) {
 176     GURL url(s.ColumnString(0));
 177
 178     // Filter out unwanted URLs.
 179     if (!CanImportURL(url))
 180       continue;
 181
 182     ImporterURLRow row(url);
 183     row.title = s.ColumnString16(1);
 184     row.visit_count = s.ColumnInt(2);
 185     row.hidden = s.ColumnInt(3) == 1;
 186     row.typed_count = s.ColumnInt(4);
 187     row.last_visit = base::Time::FromTimeT(s.ColumnInt64(5)/1000000);
 188
 189     rows.push_back(row);
 190   }
 191
 192   if (!rows.empty() && !cancelled())
 193     bridge_->SetHistoryItems(rows, importer::VISIT_SOURCE_FIREFOX_IMPORTED);
 194 }
 195
 196 void FirefoxImporter::ImportBookmarks() {
 197   base::FilePath file = source_path_.AppendASCII("places.sqlite");
 198   if (!base::PathExists(file))
 199     return;
 200
 201   sql::Connection db;
 202   if (!db.Open(file))
 203     return;
 204
 205   // Get the bookmark folders that we are interested in.
 206   int toolbar_folder_id = -1;
 207   int menu_folder_id = -1;
 208   int unsorted_folder_id = -1;
 209   LoadRootNodeID(&db, &toolbar_folder_id, &menu_folder_id, &unsorted_folder_id);
 210
 211   // Load livemark IDs.
 212   std::set<int> livemark_id;
 213   LoadLivemarkIDs(&db, &livemark_id);
 214
 215   // Load the default bookmarks.
 216   std::set<GURL> default_urls;
 217   LoadDefaultBookmarks(app_path_, &default_urls);
 218
 219   BookmarkList list;
 220   GetTopBookmarkFolder(&db, toolbar_folder_id, &list);
 221   GetTopBookmarkFolder(&db, menu_folder_id, &list);
 222   GetTopBookmarkFolder(&db, unsorted_folder_id, &list);
 223   size_t count = list.size();
 224   for (size_t i = 0; i < count; ++i)
 225     GetWholeBookmarkFolder(&db, &list, i, NULL);
 226
 227   std::vector<ImportedBookmarkEntry> bookmarks;
 228   std::vector<importer::URLKeywordInfo> url_keywords;
 229   FaviconMap favicon_map;
 230
 231   // TODO(jcampan): http://b/issue?id=1196285 we do not support POST based
 232   //                keywords yet.  We won't include them in the list.
 233   std::set<int> post_keyword_ids;
 234   const char* query = "SELECT b.id FROM moz_bookmarks b "
 235       "INNER JOIN moz_items_annos ia ON ia.item_id = b.id "
 236       "INNER JOIN moz_anno_attributes aa ON ia.anno_attribute_id = aa.id "
 237       "WHERE aa.name = 'bookmarkProperties/POSTData'";
 238   sql::Statement s(db.GetUniqueStatement(query));
 239
 240   if (!s.is_valid())
 241     return;
 242
 243   while (s.Step() && !cancelled())
 244     post_keyword_ids.insert(s.ColumnInt(0));
 245
 246   for (size_t i = 0; i < list.size(); ++i) {
 247     BookmarkItem* item = list[i];
 248
 249     if (item->type == TYPE_FOLDER) {
 250       // Folders are added implicitly on adding children, so we only explicitly
 251       // add empty folders.
 252       if (!item->empty_folder)
 253         continue;
 254     } else if (item->type == TYPE_BOOKMARK) {
 255       // Import only valid bookmarks
 256       if (!CanImportURL(item->url))
 257         continue;
 258     } else {
 259       continue;
 260     }
 261
 262     // Skip the default bookmarks and unwanted URLs.
 263     if (default_urls.find(item->url) != default_urls.end() ||
 264         post_keyword_ids.find(item->id) != post_keyword_ids.end())
 265       continue;
 266
 267     // Find the bookmark path by tracing their links to parent folders.
 268     std::vector<base::string16> path;
 269     BookmarkItem* child = item;
 270     bool found_path = false;
 271     bool is_in_toolbar = false;
 272     while (child->parent >= 0) {
 273       BookmarkItem* parent = list[child->parent];
 274       if (livemark_id.find(parent->id) != livemark_id.end()) {
 275         // Don't import live bookmarks.
 276         break;
 277       }
 278
 279       if (parent->id != menu_folder_id) {
 280         // To avoid excessive nesting, omit the name for the bookmarks menu
 281         // folder.
 282         path.insert(path.begin(), parent->title);
 283       }
 284
 285       if (parent->id == toolbar_folder_id)
 286         is_in_toolbar = true;
 287
 288       if (parent->id == toolbar_folder_id ||
 289           parent->id == menu_folder_id ||
 290           parent->id == unsorted_folder_id) {
 291         // We've reached a root node, hooray!
 292         found_path = true;
 293         break;
 294       }
 295
 296       child = parent;
 297     }
 298
 299     if (!found_path)
 300       continue;
 301
 302     ImportedBookmarkEntry entry;
 303     entry.creation_time = item->date_added;
 304     entry.title = item->title;
 305     entry.url = item->url;
 306     entry.path = path;
 307     entry.in_toolbar = is_in_toolbar;
 308     entry.is_folder = item->type == TYPE_FOLDER;
 309
 310     bookmarks.push_back(entry);
 311
 312     if (item->type == TYPE_BOOKMARK) {
 313       if (item->favicon)
 314         favicon_map[item->favicon].insert(item->url);
 315
 316       // This bookmark has a keyword, we should import it.
 317       if (!item->keyword.empty() && item->url.is_valid()) {
 318         importer::URLKeywordInfo url_keyword_info;
 319         url_keyword_info.url = item->url;
 320         url_keyword_info.keyword.assign(base::UTF8ToUTF16(item->keyword));
 321         url_keyword_info.display_name = item->title;
 322         url_keywords.push_back(url_keyword_info);
 323       }
 324     }
 325   }
 326
 327   STLDeleteElements(&list);
 328
 329   // Write into profile.
 330   if (!bookmarks.empty() && !cancelled()) {
 331     const base::string16& first_folder_name =
 332         bridge_->GetLocalizedString(IDS_BOOKMARK_GROUP_FROM_FIREFOX);
 333     bridge_->AddBookmarks(bookmarks, first_folder_name);
 334   }
 335   if (!url_keywords.empty() && !cancelled()) {
 336     bridge_->SetKeywords(url_keywords, false);
 337   }
 338   if (!favicon_map.empty() && !cancelled()) {
 339     std::vector<ImportedFaviconUsage> favicons;
 340     LoadFavicons(&db, favicon_map, &favicons);
 341     bridge_->SetFavicons(favicons);
 342   }
 343 }
 344
 345 void FirefoxImporter::ImportPasswords() {
 346   // Initializes NSS3.
 347   NSSDecryptor decryptor;
 348   if (!decryptor.Init(source_path_, source_path_) &&
 349       !decryptor.Init(app_path_, source_path_)) {
 350     return;
 351   }
 352
 353   std::vector<autofill::PasswordForm> forms;
 354   base::FilePath source_path = source_path_;
 355   base::FilePath file = source_path.AppendASCII("signons.sqlite");
 356   if (base::PathExists(file)) {
 357     // Since Firefox 3.1, passwords are in signons.sqlite db.
 358     decryptor.ReadAndParseSignons(file, &forms);
 359   } else {
 360     // Firefox 3.0 uses signons3.txt to store the passwords.
 361     file = source_path.AppendASCII("signons3.txt");
 362     if (!base::PathExists(file))
 363       file = source_path.AppendASCII("signons2.txt");
 364
 365     std::string content;
 366     base::ReadFileToString(file, &content);
 367     decryptor.ParseSignons(content, &forms);
 368   }
 369
 370   if (!cancelled()) {
 371     for (size_t i = 0; i < forms.size(); ++i) {
 372       bridge_->SetPasswordForm(forms[i]);
 373     }
 374   }
 375 }
 376
 377 void FirefoxImporter::ImportSearchEngines() {
 378   std::vector<std::string> search_engine_data;
 379   GetSearchEnginesXMLData(&search_engine_data);
 380
 381   bridge_->SetFirefoxSearchEnginesXMLData(search_engine_data);
 382 }
 383
 384 void FirefoxImporter::ImportHomepage() {
 385   GURL home_page = GetHomepage(source_path_);
 386   if (home_page.is_valid() && !IsDefaultHomepage(home_page, app_path_)) {
 387     bridge_->AddHomePage(home_page);
 388   }
 389 }
 390
 391 void FirefoxImporter::ImportAutofillFormData() {
 392   base::FilePath file = source_path_.AppendASCII("formhistory.sqlite");
 393   if (!base::PathExists(file))
 394     return;
 395
 396   sql::Connection db;
 397   if (!db.Open(file))
 398     return;
 399
 400   const char query[] =
 401       "SELECT fieldname, value, timesUsed, firstUsed, lastUsed FROM "
 402       "moz_formhistory";
 403
 404   sql::Statement s(db.GetUniqueStatement(query));
 405
 406   std::vector<ImporterAutofillFormDataEntry> form_entries;
 407   while (s.Step() && !cancelled()) {
 408     ImporterAutofillFormDataEntry form_entry;
 409     form_entry.name = s.ColumnString16(0);
 410     form_entry.value = s.ColumnString16(1);
 411     form_entry.times_used = s.ColumnInt(2);
 412     form_entry.first_used = base::Time::FromTimeT(s.ColumnInt64(3) / 1000000);
 413     form_entry.last_used = base::Time::FromTimeT(s.ColumnInt64(4) / 1000000);
 414
 415     // Don't import search bar history.
 416     if (base::UTF16ToUTF8(form_entry.name) == "searchbar-history")
 417       continue;
 418
 419     form_entries.push_back(form_entry);
 420   }
 421
 422   if (!form_entries.empty() && !cancelled())
 423     bridge_->SetAutofillFormData(form_entries);
 424 }
 425
 426 void FirefoxImporter::GetSearchEnginesXMLData(
 427     std::vector<std::string>* search_engine_data) {
 428   base::FilePath file = source_path_.AppendASCII("search.sqlite");
 429   if (!base::PathExists(file)) {
 430     // Since Firefox 3.5, search engines are no longer stored in search.sqlite.
 431     // Instead, search.json is used for storing search engines.
 432     GetSearchEnginesXMLDataFromJSON(search_engine_data);
 433     return;
 434   }
 435
 436   sql::Connection db;
 437   if (!db.Open(file))
 438     return;
 439
 440   const char* query = "SELECT engineid FROM engine_data "
 441                       "WHERE engineid NOT IN "
 442                       "(SELECT engineid FROM engine_data "
 443                       "WHERE name='hidden') "
 444                       "ORDER BY value ASC";
 445
 446   sql::Statement s(db.GetUniqueStatement(query));
 447   if (!s.is_valid())
 448     return;
 449
 450   const base::FilePath searchplugins_path(FILE_PATH_LITERAL("searchplugins"));
 451   // Search engine definitions are XMLs stored in two directories. Default
 452   // engines are in the app directory (app_path_) and custom engines are
 453   // in the profile directory (source_path_).
 454
 455   // Since Firefox 21, app_path_ engines are in 'browser' subdirectory:
 456   base::FilePath app_path =
 457       app_path_.AppendASCII("browser").Append(searchplugins_path);
 458   if (!base::PathExists(app_path)) {
 459     // This might be an older Firefox, try old location without the 'browser'
 460     // path component:
 461     app_path = app_path_.Append(searchplugins_path);
 462   }
 463
 464   base::FilePath profile_path = source_path_.Append(searchplugins_path);
 465
 466   // Firefox doesn't store a search engine in its sqlite database unless the
 467   // user has added a engine. So we get search engines from sqlite db as well
 468   // as from the file system.
 469   if (s.Step()) {
 470     const std::string kAppPrefix("[app]/");
 471     const std::string kProfilePrefix("[profile]/");
 472     do {
 473       base::FilePath file;
 474       std::string engine(s.ColumnString(0));
 475
 476       // The string contains [app]/<name>.xml or [profile]/<name>.xml where
 477       // the [app] and [profile] need to be replaced with the actual app or
 478       // profile path.
 479       size_t index = engine.find(kAppPrefix);
 480       if (index != std::string::npos) {
 481         // Remove '[app]/'.
 482         file = app_path.AppendASCII(engine.substr(index + kAppPrefix.length()));
 483       } else if ((index = engine.find(kProfilePrefix)) != std::string::npos) {
 484         // Remove '[profile]/'.
 485           file = profile_path.AppendASCII(
 486               engine.substr(index + kProfilePrefix.length()));
 487       } else {
 488         // Looks like absolute path to the file.
 489         file = base::FilePath::FromUTF8Unsafe(engine);
 490       }
 491       std::string file_data;
 492       base::ReadFileToString(file, &file_data);
 493       search_engine_data->push_back(file_data);
 494     } while (s.Step() && !cancelled());
 495   }
 496
 497 #if defined(OS_POSIX)
 498   // Ubuntu-flavored Firefox supports locale-specific search engines via
 499   // locale-named subdirectories. They fall back to en-US.
 500   // See http://crbug.com/53899
 501   // TODO(jshin): we need to make sure our locale code matches that of
 502   // Firefox.
 503   DCHECK(!locale_.empty());
 504   base::FilePath locale_app_path = app_path.AppendASCII(locale_);
 505   base::FilePath default_locale_app_path = app_path.AppendASCII("en-US");
 506   if (base::DirectoryExists(locale_app_path))
 507     app_path = locale_app_path;
 508   else if (base::DirectoryExists(default_locale_app_path))
 509     app_path = default_locale_app_path;
 510 #endif
 511
 512   // Get search engine definition from file system.
 513   base::FileEnumerator engines(app_path, false, base::FileEnumerator::FILES);
 514   for (base::FilePath engine_path = engines.Next();
 515        !engine_path.value().empty(); engine_path = engines.Next()) {
 516     std::string file_data;
 517     base::ReadFileToString(file, &file_data);
 518     search_engine_data->push_back(file_data);
 519   }
 520 }
 521
 522 void FirefoxImporter::GetSearchEnginesXMLDataFromJSON(
 523     std::vector<std::string>* search_engine_data) {
 524   // search-metadata.json contains keywords for search engines. This
 525   // file exists only if the user has set keywords for search engines.
 526   base::FilePath search_metadata_json_file =
 527       source_path_.AppendASCII("search-metadata.json");
 528   JSONFileValueSerializer metadata_serializer(search_metadata_json_file);
 529   scoped_ptr<base::Value> metadata_root(
 530       metadata_serializer.Deserialize(NULL, NULL));
 531   const base::DictionaryValue* search_metadata_root = NULL;
 532   if (metadata_root)
 533     metadata_root->GetAsDictionary(&search_metadata_root);
 534
 535   // search.json contains information about search engines to import.
 536   base::FilePath search_json_file = source_path_.AppendASCII("search.json");
 537   if (!base::PathExists(search_json_file))
 538     return;
 539
 540   JSONFileValueSerializer serializer(search_json_file);
 541   scoped_ptr<base::Value> root(serializer.Deserialize(NULL, NULL));
 542   const base::DictionaryValue* search_root = NULL;
 543   if (!root || !root->GetAsDictionary(&search_root))
 544     return;
 545
 546   const std::string kDirectories("directories");
 547   const base::DictionaryValue* search_directories = NULL;
 548   if (!search_root->GetDictionary(kDirectories, &search_directories))
 549     return;
 550
 551   // Dictionary |search_directories| contains a list of search engines
 552   // (default and installed). The list can be found from key <engines>
 553   // of the dictionary. Key <engines> is a grandchild of key <directories>.
 554   // However, key <engines> parent's key is dynamic which depends on
 555   // operating systems. For example,
 556   //   Ubuntu (for default search engine):
 557   //     /usr/lib/firefox/distribution/searchplugins/locale/en-US
 558   //   Ubuntu (for installed search engines):
 559   //     /home/<username>/.mozilla/firefox/lcd50n4n.default/searchplugins
 560   //   Windows (for default search engine):
 561   //     C:\\Program Files (x86)\\Mozilla Firefox\\browser\\searchplugins
 562   // Therefore, it needs to be retrieved by searching.
 563
 564   for (base::DictionaryValue::Iterator it(*search_directories); !it.IsAtEnd();
 565        it.Advance()) {
 566     // The key of |it| may contains dot (.) which cannot be used as <key>
 567     // for retrieving <engines>. Hence, it is needed to get |it| as dictionary.
 568     // The resulted dictionary can be used for retrieving <engines>.
 569     const std::string kEngines("engines");
 570     const base::DictionaryValue* search_directory = NULL;
 571     if (!it.value().GetAsDictionary(&search_directory))
 572       continue;
 573
 574     const base::ListValue* search_engines = NULL;
 575     if (!search_directory->GetList(kEngines, &search_engines))
 576       continue;
 577
 578     const std::string kFilePath("filePath");
 579     const std::string kHidden("_hidden");
 580     for (size_t i = 0; i < search_engines->GetSize(); ++i) {
 581       const base::DictionaryValue* engine_info = NULL;
 582       if (!search_engines->GetDictionary(i, &engine_info))
 583         continue;
 584
 585       bool is_hidden = false;
 586       std::string file_path;
 587       if (!engine_info->GetBoolean(kHidden, &is_hidden) ||
 588           !engine_info->GetString(kFilePath, &file_path))
 589         continue;
 590
 591       if (!is_hidden) {
 592         const std::string kAppPrefix("[app]/");
 593         const std::string kProfilePrefix("[profile]/");
 594         base::FilePath xml_file = base::FilePath::FromUTF8Unsafe(file_path);
 595
 596         // If |file_path| contains [app] or [profile] then they need to be
 597         // replaced with the actual app or profile path.
 598         size_t index = file_path.find(kAppPrefix);
 599         if (index != std::string::npos) {
 600           // Replace '[app]/' with actual app path.
 601           xml_file = app_path_.AppendASCII("searchplugins").AppendASCII(
 602               file_path.substr(index + kAppPrefix.length()));
 603         } else if ((index = file_path.find(kProfilePrefix)) !=
 604                    std::string::npos) {
 605           // Replace '[profile]/' with actual profile path.
 606           xml_file = source_path_.AppendASCII("searchplugins").AppendASCII(
 607               file_path.substr(index + kProfilePrefix.length()));
 608         }
 609
 610         std::string file_data;
 611         base::ReadFileToString(xml_file, &file_data);
 612
 613         // If a keyword is mentioned for this search engine, then add
 614         // it to the XML string as an <Alias> element and use this updated
 615         // string.
 616         const base::DictionaryValue* search_xml_path = NULL;
 617         if (search_metadata_root && search_metadata_root->HasKey(file_path) &&
 618             search_metadata_root->GetDictionaryWithoutPathExpansion(
 619                 file_path, &search_xml_path)) {
 620           std::string alias;
 621           search_xml_path->GetString("alias", &alias);
 622
 623           // Add <Alias> element as the last child element.
 624           size_t end_of_parent = file_data.find("</SearchPlugin>");
 625           if (end_of_parent != std::string::npos && !alias.empty())
 626             file_data.insert(end_of_parent, "<Alias>" + alias + "</Alias> \n");
 627         }
 628         search_engine_data->push_back(file_data);
 629       }
 630     }
 631   }
 632 }
 633
 634 void FirefoxImporter::LoadRootNodeID(sql::Connection* db,
 635                                       int* toolbar_folder_id,
 636                                       int* menu_folder_id,
 637                                       int* unsorted_folder_id) {
 638   static const char* kToolbarFolderName = "toolbar";
 639   static const char* kMenuFolderName = "menu";
 640   static const char* kUnsortedFolderName = "unfiled";
 641
 642   const char* query = "SELECT root_name, folder_id FROM moz_bookmarks_roots";
 643   sql::Statement s(db->GetUniqueStatement(query));
 644
 645   while (s.Step()) {
 646     std::string folder = s.ColumnString(0);
 647     int id = s.ColumnInt(1);
 648     if (folder == kToolbarFolderName)
 649       *toolbar_folder_id = id;
 650     else if (folder == kMenuFolderName)
 651       *menu_folder_id = id;
 652     else if (folder == kUnsortedFolderName)
 653       *unsorted_folder_id = id;
 654   }
 655 }
 656
 657 void FirefoxImporter::LoadLivemarkIDs(sql::Connection* db,
 658                                        std::set<int>* livemark) {
 659   static const char* kFeedAnnotation = "livemark/feedURI";
 660   livemark->clear();
 661
 662   const char* query = "SELECT b.item_id "
 663                       "FROM moz_anno_attributes a "
 664                       "JOIN moz_items_annos b ON a.id = b.anno_attribute_id "
 665                       "WHERE a.name = ? ";
 666   sql::Statement s(db->GetUniqueStatement(query));
 667   s.BindString(0, kFeedAnnotation);
 668
 669   while (s.Step() && !cancelled())
 670     livemark->insert(s.ColumnInt(0));
 671 }
 672
 673 void FirefoxImporter::GetTopBookmarkFolder(sql::Connection* db,
 674                                             int folder_id,
 675                                             BookmarkList* list) {
 676   const char* query = "SELECT b.title "
 677                      "FROM moz_bookmarks b "
 678                      "WHERE b.type = 2 AND b.id = ? "
 679                      "ORDER BY b.position";
 680   sql::Statement s(db->GetUniqueStatement(query));
 681   s.BindInt(0, folder_id);
 682
 683   if (s.Step()) {
 684     BookmarkItem* item = new BookmarkItem;
 685     item->parent = -1;  // The top level folder has no parent.
 686     item->id = folder_id;
 687     item->title = s.ColumnString16(0);
 688     item->type = TYPE_FOLDER;
 689     item->favicon = 0;
 690     item->empty_folder = true;
 691     list->push_back(item);
 692   }
 693 }
 694
 695 void FirefoxImporter::GetWholeBookmarkFolder(sql::Connection* db,
 696                                               BookmarkList* list,
 697                                               size_t position,
 698                                               bool* empty_folder) {
 699   if (position >= list->size()) {
 700     NOTREACHED();
 701     return;
 702   }
 703
 704   const char* query = "SELECT b.id, h.url, COALESCE(b.title, h.title), "
 705          "b.type, k.keyword, b.dateAdded, h.favicon_id "
 706          "FROM moz_bookmarks b "
 707          "LEFT JOIN moz_places h ON b.fk = h.id "
 708          "LEFT JOIN moz_keywords k ON k.id = b.keyword_id "
 709          "WHERE b.type IN (1,2) AND b.parent = ? "
 710          "ORDER BY b.position";
 711   sql::Statement s(db->GetUniqueStatement(query));
 712   s.BindInt(0, (*list)[position]->id);
 713
 714   BookmarkList temp_list;
 715   while (s.Step()) {
 716     BookmarkItem* item = new BookmarkItem;
 717     item->parent = static_cast<int>(position);
 718     item->id = s.ColumnInt(0);
 719     item->url = GURL(s.ColumnString(1));
 720     item->title = s.ColumnString16(2);
 721     item->type = static_cast<BookmarkItemType>(s.ColumnInt(3));
 722     item->keyword = s.ColumnString(4);
 723     item->date_added = base::Time::FromTimeT(s.ColumnInt64(5)/1000000);
 724     item->favicon = s.ColumnInt64(6);
 725     item->empty_folder = true;
 726
 727     temp_list.push_back(item);
 728     if (empty_folder != NULL)
 729       *empty_folder = false;
 730   }
 731
 732   // Appends all items to the list.
 733   for (BookmarkList::iterator i = temp_list.begin();
 734        i != temp_list.end(); ++i) {
 735     list->push_back(*i);
 736     // Recursive add bookmarks in sub-folders.
 737     if ((*i)->type == TYPE_FOLDER)
 738       GetWholeBookmarkFolder(db, list, list->size() - 1, &(*i)->empty_folder);
 739   }
 740 }
 741
 742 void FirefoxImporter::LoadFavicons(
 743     sql::Connection* db,
 744     const FaviconMap& favicon_map,
 745     std::vector<ImportedFaviconUsage>* favicons) {
 746   const char* query = "SELECT url, data FROM moz_favicons WHERE id=?";
 747   sql::Statement s(db->GetUniqueStatement(query));
 748
 749   if (!s.is_valid())
 750     return;
 751
 752   for (FaviconMap::const_iterator i = favicon_map.begin();
 753        i != favicon_map.end(); ++i) {
 754     s.BindInt64(0, i->first);
 755     if (s.Step()) {
 756       ImportedFaviconUsage usage;
 757
 758       usage.favicon_url = GURL(s.ColumnString(0));
 759       if (!usage.favicon_url.is_valid())
 760         continue;  // Don't bother importing favicons with invalid URLs.
 761
 762       std::vector<unsigned char> data;
 763       s.ColumnBlobAsVector(1, &data);
 764       if (data.empty())
 765         continue;  // Data definitely invalid.
 766
 767       if (!importer::ReencodeFavicon(&data[0], data.size(), &usage.png_data))
 768         continue;  // Unable to decode.
 769
 770       usage.urls = i->second;
 771       favicons->push_back(usage);
 772     }
 773     s.Reset(true);
 774   }
 775 }