Parsed search.json for importing search engine settings from FireFox.

chrome/utility/importer/firefox_importer.cc

 // Copyright 2013 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/utility/importer/firefox_importer.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
@@ skipping 94 matching lines @@
 
 #if defined(OS_POSIX)
   locale_ = source_profile.locale;
 #endif
 
   // The order here is important!
   bridge_->NotifyStarted();
   if ((items & importer::HOME_PAGE) && !cancelled()) {
     bridge_->NotifyItemStarted(importer::HOME_PAGE);
     ImportHomepage();  // Doesn't have a UI item.
+    ImportHomepage();  // Doesn't have a UI item.

[tfarina, 2014/04/22 23:49:12]

I don't think you meant to call ImportHomepage() twice in a row. Please, remove
this duplicated code.

     bridge_->NotifyItemEnded(importer::HOME_PAGE);
   }
 
   // Note history should be imported before bookmarks because bookmark import
   // will also import favicons and we store favicon for a URL only if the URL
   // exist in history or bookmarks.
   if ((items & importer::HISTORY) && !cancelled()) {
     bridge_->NotifyItemStarted(importer::HISTORY);
     ImportHistory();
     bridge_->NotifyItemEnded(importer::HISTORY);
@@ skipping 251 matching lines @@
 
 void FirefoxImporter::ImportHomepage() {
   GURL home_page = GetHomepage(source_path_);
   if (home_page.is_valid() && !IsDefaultHomepage(home_page, app_path_)) {
     bridge_->AddHomePage(home_page);
   }
 }
 
 void FirefoxImporter::GetSearchEnginesXMLData(
     std::vector<std::string>* search_engine_data) {
-  // TODO(mpawlowski): This may no longer work, search engines are stored in
-  // search.json since Firefox 3.5, not in search.sqlite. XML definitions are
-  // still necessary. http://crbug.com/329175
+
   base::FilePath file = source_path_.AppendASCII("search.sqlite");
-  if (!base::PathExists(file))
+  if (!base::PathExists(file)) {
+    // since Firefox 3.5, search engines are no longer stored in search.sqlite.
+    // Instead, search.json is used for storing search engines.
+
+    base::FilePath search_json_file = source_path_.AppendASCII("search.json");
+    if (!base::PathExists(search_json_file))
+      return;
+
+    JSONFileValueSerializer serializer(search_json_file);
+    scoped_ptr<base::Value> root(serializer.Deserialize(NULL, NULL));
+
+    if (!root.get())
+      return;
+
+    base::DictionaryValue* search_root =
+        static_cast<base::DictionaryValue*>(root.release());
+    const std::string kDirectories("directories");
+    const base::DictionaryValue* search_directories = NULL;
+
+    if (!search_root->GetDictionary(kDirectories, &search_directories))
+      return;
+
+    // search engine list can be found from key <engines> of the dictionary.
+    // key <engines> is a grandchild of key <directories>.
+    // However, key <engines> parent's key is dynamic which
+    // depends on operating systems. For example,
+    // Ubuntu: /usr/lib/firefox/distribution/searchplugins/locale/en-US
+    // Windows: C:\\Program Files (x86)\\Mozilla Firefox\\browser\\searchplugins
+    // Therefore, it needs to be retrieved by using iterator
+
+    base::DictionaryValue::Iterator it(*search_directories);
+    const base::ListValue* search_engines = NULL;
+    const std::string kEngines(it.key() + ".engines");
+
+    if (search_directories->GetList(kEngines, &search_engines)) {
+      const std::string kFilePath("filePath");
+      for (size_t i = 0; i < search_engines->GetSize(); ++i) {
+        const base::DictionaryValue* engine_info = NULL;
+        if (search_engines->GetDictionary(i, &engine_info)) {
+          std::string file_path;
+          if (engine_info->GetString(kFilePath, &file_path)) {
+            std::string file_data;
+            base::FilePath xml_file = base::FilePath::FromUTF8Unsafe(file_path);
+            base::ReadFileToString(xml_file,  &file_data);
+            search_engine_data->push_back(file_data);
+          }
+        }
+      }
+    }
     return;
+  }
 
   sql::Connection db;
   if (!db.Open(file))
     return;
 
   const char* query = "SELECT engineid FROM engine_data "
                       "WHERE engineid NOT IN "
                       "(SELECT engineid FROM engine_data "
                       "WHERE name='hidden') "
                       "ORDER BY value ASC";
@@ skipping 80 matching lines @@
                                       int* unsorted_folder_id) {
   static const char* kToolbarFolderName = "toolbar";
   static const char* kMenuFolderName = "menu";
   static const char* kUnsortedFolderName = "unfiled";
 
   const char* query = "SELECT root_name, folder_id FROM moz_bookmarks_roots";
   sql::Statement s(db->GetUniqueStatement(query));
 
   while (s.Step()) {
     std::string folder = s.ColumnString(0);
-    int id = s.ColumnInt(1);
-    if (folder == kToolbarFolderName)
-      *toolbar_folder_id = id;
-    else if (folder == kMenuFolderName)
-      *menu_folder_id = id;
-    else if (folder == kUnsortedFolderName)
-      *unsorted_folder_id = id;
-  }
-}
-
-void FirefoxImporter::LoadLivemarkIDs(sql::Connection* db,
-                                       std::set<int>* livemark) {
-  static const char* kFeedAnnotation = "livemark/feedURI";
-  livemark->clear();
-
-  const char* query = "SELECT b.item_id "
-                      "FROM moz_anno_attributes a "
-                      "JOIN moz_items_annos b ON a.id = b.anno_attribute_id "
-                      "WHERE a.name = ? ";
-  sql::Statement s(db->GetUniqueStatement(query));
-  s.BindString(0, kFeedAnnotation);
-
-  while (s.Step() && !cancelled())
-    livemark->insert(s.ColumnInt(0));
-}
-
-void FirefoxImporter::GetTopBookmarkFolder(sql::Connection* db,
-                                            int folder_id,
-                                            BookmarkList* list) {
-  const char* query = "SELECT b.title "
-                     "FROM moz_bookmarks b "
-                     "WHERE b.type = 2 AND b.id = ? "
-                     "ORDER BY b.position";
-  sql::Statement s(db->GetUniqueStatement(query));
-  s.BindInt(0, folder_id);
-
-  if (s.Step()) {
-    BookmarkItem* item = new BookmarkItem;
-    item->parent = -1;  // The top level folder has no parent.
-    item->id = folder_id;
-    item->title = s.ColumnString16(0);
-    item->type = TYPE_FOLDER;
-    item->favicon = 0;
-    item->empty_folder = true;
-    list->push_back(item);
-  }
-}
-
 void FirefoxImporter::GetWholeBookmarkFolder(sql::Connection* db,
                                               BookmarkList* list,
                                               size_t position,
                                               bool* empty_folder) {
   if (position >= list->size()) {
     NOTREACHED();
     return;
   }
 
   const char* query = "SELECT b.id, h.url, COALESCE(b.title, h.title), "
@@ skipping 61 matching lines @@
 
       if (!importer::ReencodeFavicon(&data[0], data.size(), &usage.png_data))
         continue;  // Unable to decode.
 
       usage.urls = i->second;
       favicons->push_back(usage);
     }
     s.Reset(true);
   }
 }