Port some importer unit tests to browser tests to be able to fully exercise the ExternalProcessImpo…

chrome/browser/importer/ie_importer_browsertest_win.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 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 "testing/gtest/include/gtest/gtest.h"
-
 // The order of these includes is important.
 #include <windows.h>
 #include <unknwn.h>
 #include <intshcut.h>
 #include <shlguid.h>
 #include <urlhist.h>
 #include <shlobj.h>
 #include <propvarutil.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
+#include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
-#include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/importer/ie_importer.h"
 #include "chrome/browser/importer/importer_bridge.h"
 #include "chrome/browser/importer/importer_data_types.h"
 #include "chrome/browser/importer/importer_host.h"
 #include "chrome/browser/importer/importer_progress_observer.h"
 #include "chrome/browser/importer/importer_unittest_utils.h"
 #include "chrome/browser/importer/pstore_declarations.h"
 #include "chrome/browser/search_engines/template_url.h"
+#include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/testing_profile.h"
-#include "components/webdata/encryptor/ie7_password.h"
 #include "content/public/common/password_form.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char16 kUnitTestRegistrySubKey[] = L"SOFTWARE\\Chromium Unit Tests";
 const char16 kUnitTestUserOverrideSubKey[] =
     L"SOFTWARE\\Chromium Unit Tests\\HKCU Override";
 
 const BookmarkInfo kIEBookmarks[] = {
   {true, 2, {L"Links", L"SubFolderOfLinks"},
    L"SubLink",
@@ skipping 102 matching lines @@
     return false;
   }
   if (key.WriteValue(L"Order", &blob[0], blob.size(), REG_BINARY) !=
       ERROR_SUCCESS) {
     return false;
   }
   return true;
 }
 
 bool CreateUrlFileWithFavicon(const base::FilePath& file,
-                              const std::wstring& url,
-                              const std::wstring& favicon_url) {
+                              const string16& url,
+                              const string16& favicon_url) {
   base::win::ScopedComPtr<IUniformResourceLocator> locator;
   HRESULT result = locator.CreateInstance(CLSID_InternetShortcut, NULL,
                                           CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return false;
   base::win::ScopedComPtr<IPersistFile> persist_file;
   result = persist_file.QueryFrom(locator);
   if (FAILED(result))
     return false;
   result = locator->SetURL(url.c_str(), 0);
@@ skipping 26 matching lines @@
   result = persist_file->Save(file.value().c_str(), TRUE);
   if (FAILED(result))
     return false;
 
   // Write dummy favicon image data in NTFS alternate data stream.
   return favicon_url.empty() || (file_util::WriteFile(
       file.ReplaceExtension(kFaviconStreamSuffix), kDummyFaviconImageData,
       sizeof kDummyFaviconImageData) != -1);
 }
 
-bool CreateUrlFile(const base::FilePath& file, const std::wstring& url) {
-  return CreateUrlFileWithFavicon(file, url, std::wstring());
+bool CreateUrlFile(const base::FilePath& file, const string16& url) {
+  return CreateUrlFileWithFavicon(file, url, string16());
 }
 
 void ClearPStoreType(IPStore* pstore, const GUID* type, const GUID* subtype) {
   base::win::ScopedComPtr<IEnumPStoreItems, NULL> item;
   HRESULT result = pstore->EnumItems(0, type, subtype, 0, item.Receive());
   if (result == PST_E_OK) {
     char16* item_name;
     while (SUCCEEDED(item->Next(1, &item_name, 0))) {
       pstore->DeleteItem(0, type, subtype, item_name, NULL, 0);
       CoTaskMemFree(item_name);
@@ skipping 81 matching lines @@
     }
     EXPECT_EQ(history::SOURCE_IE_IMPORTED, visit_source);
   }
 
   virtual void AddBookmarks(const std::vector<BookmarkEntry>& bookmarks,
                             const string16& top_level_folder_name) OVERRIDE {
     ASSERT_LE(bookmark_count_ + bookmarks.size(), arraysize(kIEBookmarks));
     // Importer should import the IE Favorites folder the same as the list,
     // in the same order.
     for (size_t i = 0; i < bookmarks.size(); ++i) {
-      EXPECT_TRUE(EqualBookmarkEntry(bookmarks[i],
-                                     kIEBookmarks[bookmark_count_]));
+      EXPECT_NO_FATAL_FAILURE(
+          TestEqualBookmarkEntry(bookmarks[i],
+                                 kIEBookmarks[bookmark_count_])) << i;
       ++bookmark_count_;
     }
   }
 
   virtual void AddKeyword(std::vector<TemplateURL*> template_url,
                           int default_keyword_index) {
     // TODO(jcampan): bug 1169230: we should test keyword importing for IE.
     // In order to do that we'll probably need to mock the Windows registry.
     NOTREACHED();
     STLDeleteContainerPointers(template_url.begin(), template_url.end());
@@ skipping 56 matching lines @@
   virtual void AddPasswordForm(const content::PasswordForm& form) {}
   virtual void AddHistoryPage(const history::URLRows& page,
                               history::VisitSource visit_source) {}
   virtual void AddKeyword(std::vector<TemplateURL*> template_url,
                           int default_keyword_index) {}
   virtual void AddBookmarks(const std::vector<BookmarkEntry>& bookmarks,
                             const string16& top_level_folder_name) OVERRIDE {
     ASSERT_LE(bookmark_count_ + bookmarks.size(),
               arraysize(kIESortedBookmarks));
     for (size_t i = 0; i < bookmarks.size(); ++i) {
-      EXPECT_TRUE(EqualBookmarkEntry(bookmarks[i],
-                                     kIESortedBookmarks[bookmark_count_]));
+      EXPECT_NO_FATAL_FAILURE(
+          TestEqualBookmarkEntry(bookmarks[i],
+                                 kIESortedBookmarks[bookmark_count_])) << i;
       ++bookmark_count_;
     }
   }
 
  private:
   ~MalformedFavoritesRegistryTestObserver() {}
 
   size_t bookmark_count_;
 };
 
 }  // namespace
 
-class IEImporterTest : public ImporterTest {
+// These tests need to be browser tests in order to be able to run the OOP
+// import (via ExternalProcessImporterHost) which launches a utility process.
+class IEImporterBrowserTest : public InProcessBrowserTest {
  protected:
   virtual void SetUp() OVERRIDE {
-    ImporterTest::SetUp();
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     StartRegistryOverride();
+
+    // This will launch the browser test and thus needs to happen last.
+    InProcessBrowserTest::SetUp();
   }
 
   virtual void TearDown() OVERRIDE {
     EndRegistryOverride();
   }
 
   void StartRegistryOverride() {
     EXPECT_EQ(ERROR_SUCCESS, RegOverridePredefKey(HKEY_CURRENT_USER, NULL));
     temp_hkcu_hive_key_.Create(HKEY_CURRENT_USER,
                                kUnitTestUserOverrideSubKey,
                                KEY_ALL_ACCESS);
     EXPECT_TRUE(temp_hkcu_hive_key_.Valid());
     EXPECT_EQ(ERROR_SUCCESS,
               RegOverridePredefKey(HKEY_CURRENT_USER,
                                    temp_hkcu_hive_key_.Handle()));
   }
 
   void EndRegistryOverride() {
     EXPECT_EQ(ERROR_SUCCESS, RegOverridePredefKey(HKEY_CURRENT_USER, NULL));
     temp_hkcu_hive_key_.Close();
     base::win::RegKey key(HKEY_CURRENT_USER, kUnitTestRegistrySubKey,
                           KEY_ALL_ACCESS);
     key.DeleteKey(L"");
   }
 
+  base::ScopedTempDir temp_dir_;
   base::win::RegKey temp_hkcu_hive_key_;
 };
 
-TEST_F(IEImporterTest, IEImporter) {
+IN_PROC_BROWSER_TEST_F(IEImporterBrowserTest, IEImporter) {
   // Sets up a favorites folder.
-  base::win::ScopedCOMInitializer com_init;
   base::FilePath path = temp_dir_.path().AppendASCII("Favorites");
   CreateDirectory(path.value().c_str(), NULL);
   CreateDirectory(path.AppendASCII("SubFolder").value().c_str(), NULL);
   base::FilePath links_path = path.AppendASCII("Links");
   CreateDirectory(links_path.value().c_str(), NULL);
   CreateDirectory(links_path.AppendASCII("SubFolderOfLinks").value().c_str(),
                   NULL);
   CreateDirectory(path.AppendASCII("\x0061").value().c_str(), NULL);
   ASSERT_TRUE(CreateUrlFileWithFavicon(path.AppendASCII("Google Home Page.url"),
                                        L"http://www.google.com/",
@@ skipping 39 matching lines @@
 
   // Sets up a special history link.
   base::win::ScopedComPtr<IUrlHistoryStg2> url_history_stg2;
   res = url_history_stg2.CreateInstance(CLSID_CUrlHistory, NULL,
                                         CLSCTX_INPROC_SERVER);
   ASSERT_TRUE(res == S_OK);
   res = url_history_stg2->AddUrl(kIEIdentifyUrl, kIEIdentifyTitle, 0);
   ASSERT_TRUE(res == S_OK);
 
   // Starts to import the above settings.
-  MessageLoop* loop = MessageLoop::current();
+  // TODO(gab): Use ExternalProcessImporterHost on Windows.
   scoped_refptr<ImporterHost> host(new ImporterHost);
-
   TestObserver* observer = new TestObserver();
   host->SetObserver(observer);
+
   importer::SourceProfile source_profile;
   source_profile.importer_type = importer::TYPE_IE;
   source_profile.source_path = temp_dir_.path();
 
   // IUrlHistoryStg2::AddUrl seems to reset the override. Ensure it here.
   StartRegistryOverride();
 
-  loop->PostTask(FROM_HERE, base::Bind(
-      &ImporterHost::StartImportSettings,
-      host.get(),
+  host->StartImportSettings(
       source_profile,
-      profile_.get(),
+      browser()->profile(),
       importer::HISTORY | importer::PASSWORDS | importer::FAVORITES,
-      observer));
-  loop->Run();
+      observer);
+  MessageLoop::current()->Run();
 
   // Cleans up.
   url_history_stg2->DeleteUrl(kIEIdentifyUrl, 0);
   url_history_stg2.Release();
 }
 
-TEST_F(IEImporterTest, IEImporterMalformedFavoritesRegistry) {
+IN_PROC_BROWSER_TEST_F(IEImporterBrowserTest,
+                       IEImporterMalformedFavoritesRegistry) {
   // Sets up a favorites folder.
-  base::win::ScopedCOMInitializer com_init;
   base::FilePath path = temp_dir_.path().AppendASCII("Favorites");
   CreateDirectory(path.value().c_str(), NULL);
   CreateDirectory(path.AppendASCII("b").value().c_str(), NULL);
   ASSERT_TRUE(CreateUrlFile(path.AppendASCII("a.url"),
                             L"http://www.google.com/0"));
   ASSERT_TRUE(CreateUrlFile(path.AppendASCII("b").AppendASCII("a.url"),
                             L"http://www.google.com/1"));
   ASSERT_TRUE(CreateUrlFile(path.AppendASCII("b").AppendASCII("b.url"),
                             L"http://www.google.com/2"));
   ASSERT_TRUE(CreateUrlFile(path.AppendASCII("c.url"),
@@ skipping 31 matching lines @@
   // sort is performed.
   for (size_t i = 0; i < arraysize(kBadBinary); ++i) {
     base::win::RegKey key;
     ASSERT_EQ(ERROR_SUCCESS,
               key.Create(HKEY_CURRENT_USER, kIEFavoritesOrderKey, KEY_WRITE));
     ASSERT_EQ(ERROR_SUCCESS,
               key.WriteValue(L"Order", kBadBinary[i].data, kBadBinary[i].length,
                              REG_BINARY));
 
     // Starts to import the above settings.
-    MessageLoop* loop = MessageLoop::current();
+    // TODO(gab): Use ExternalProcessImporterHost on Windows.
     scoped_refptr<ImporterHost> host(new ImporterHost);
-
     MalformedFavoritesRegistryTestObserver* observer =
         new MalformedFavoritesRegistryTestObserver();
     host->SetObserver(observer);
+
     importer::SourceProfile source_profile;
     source_profile.importer_type = importer::TYPE_IE;
     source_profile.source_path = temp_dir_.path();
 
-    loop->PostTask(FROM_HERE, base::Bind(
-        &ImporterHost::StartImportSettings,
-        host.get(),
+    host->StartImportSettings(
         source_profile,
-        profile_.get(),
+        browser()->profile(),
         importer::FAVORITES,
-        observer));
-    loop->Run();
+        observer);
+    MessageLoop::current()->Run();
   }
 }
-
-TEST_F(IEImporterTest, IE7Importer) {
-  // This is the unencrypted values of my keys under Storage2.
-  // The passwords have been manually changed to abcdef... but the size remains
-  // the same.
-  unsigned char data1[] = "\x0c\x00\x00\x00\x38\x00\x00\x00\x2c\x00\x00\x00"
-                          "\x57\x49\x43\x4b\x18\x00\x00\x00\x02\x00\x00\x00"
-                          "\x67\x00\x72\x00\x01\x00\x00\x00\x00\x00\x00\x00"
-                          "\x00\x00\x00\x00\x4e\xfa\x67\x76\x22\x94\xc8\x01"
-                          "\x08\x00\x00\x00\x12\x00\x00\x00\x4e\xfa\x67\x76"
-                          "\x22\x94\xc8\x01\x0c\x00\x00\x00\x61\x00\x62\x00"
-                          "\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00"
-                          "\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00"
-                          "\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00"
-                          "\x6c\x00\x00\x00";
-
-  unsigned char data2[] = "\x0c\x00\x00\x00\x38\x00\x00\x00\x24\x00\x00\x00"
-                          "\x57\x49\x43\x4b\x18\x00\x00\x00\x02\x00\x00\x00"
-                          "\x67\x00\x72\x00\x01\x00\x00\x00\x00\x00\x00\x00"
-                          "\x00\x00\x00\x00\xa8\xea\xf4\xe5\x9f\x9a\xc8\x01"
-                          "\x09\x00\x00\x00\x14\x00\x00\x00\xa8\xea\xf4\xe5"
-                          "\x9f\x9a\xc8\x01\x07\x00\x00\x00\x61\x00\x62\x00"
-                          "\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00"
-                          "\x69\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00"
-                          "\x65\x00\x66\x00\x67\x00\x00\x00";
-
-
-
-  std::vector<unsigned char> decrypted_data1;
-  decrypted_data1.resize(arraysize(data1));
-  memcpy(&decrypted_data1.front(), data1, sizeof(data1));
-
-  std::vector<unsigned char> decrypted_data2;
-  decrypted_data2.resize(arraysize(data2));
-  memcpy(&decrypted_data2.front(), data2, sizeof(data2));
-
-  string16 password;
-  string16 username;
-  ASSERT_TRUE(ie7_password::GetUserPassFromData(decrypted_data1, &username,
-                                                &password));
-  EXPECT_EQ(L"abcdefgh", username);
-  EXPECT_EQ(L"abcdefghijkl", password);
-
-  ASSERT_TRUE(ie7_password::GetUserPassFromData(decrypted_data2, &username,
-                                                &password));
-  EXPECT_EQ(L"abcdefghi", username);
-  EXPECT_EQ(L"abcdefg", password);
-}