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"
+#include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/importer/firefox_importer_utils.h"
 #include "chrome/common/importer/firefox_importer_utils.h"
 #include "chrome/common/importer/imported_bookmark_entry.h"
 #include "chrome/common/importer/imported_favicon_usage.h"
 #include "chrome/common/importer/importer_bridge.h"
@@ skipping 355 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.
+    GetSearchEnginesXMLDataFromJSON(search_engine_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 67 matching lines @@
   // Get search engine definition from file system.
   base::FileEnumerator engines(app_path, false, base::FileEnumerator::FILES);
   for (base::FilePath engine_path = engines.Next();
        !engine_path.value().empty(); engine_path = engines.Next()) {
     std::string file_data;
     base::ReadFileToString(file, &file_data);
     search_engine_data->push_back(file_data);
   }
 }
 
+void FirefoxImporter::GetSearchEnginesXMLDataFromJSON(
+    std::vector<std::string>* search_engine_data) {
+  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));
+  const base::DictionaryValue* search_root = NULL;
+

[Ilya Sherman, 2014/05/01 21:37:02]

nit: I'd omit this blank line.

+  if (!root || !root->GetAsDictionary(&search_root))
+    return;
+
+  const std::string kDirectories("directories");
+  const base::DictionaryValue* search_directories = NULL;
+

[Ilya Sherman, 2014/05/01 21:37:02]

nit: I'd omit this blank line.

+  if (!search_root->GetDictionary(kDirectories, &search_directories))
+    return;
+
+  // Dictionary "search_directories" contains a list of search engines.

[Ilya Sherman, 2014/05/01 21:37:02]

nit: Rather than using quotation marks to denote variable names, Chromium code
generally uses pipes, i.e. we'd write """Dictionary |search_directories|
contains ..."""

+  // The 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

[Ilya Sherman, 2014/05/01 21:37:02]

nit: "by using iterator" -> "by searching."

+
+  base::DictionaryValue::Iterator it(*search_directories);
+  const std::string kEngines(it.key() + ".engines");
+  const base::ListValue* search_engines = NULL;
+
+  if (search_directories->GetList(kEngines, &search_engines)) {

[Ilya Sherman, 2014/05/01 21:37:02]

nit: I'd suggest reversing this condition and using an early return, as you do
above, to reduce the level of indentation.

+    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);
+        }
+      }
+    }
+  }
+}
+
 void FirefoxImporter::LoadRootNodeID(sql::Connection* db,
                                       int* toolbar_folder_id,
                                       int* menu_folder_id,
                                       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));
@@ skipping 122 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);
   }
 }