Make importer.cc compile on Posix.

chrome/browser/importer/importer.cc

 // Copyright (c) 2006-2008 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/importer.h"
 
 #include <map>
 #include <set>
 
 #include "base/file_util.h"
 #include "base/gfx/png_encoder.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/first_run.h"
 #include "chrome/browser/importer/firefox2_importer.h"
 #include "chrome/browser/importer/firefox3_importer.h"
 #include "chrome/browser/importer/firefox_importer_utils.h"
 #include "chrome/browser/importer/firefox_profile_lock.h"
+#if defined(OS_WIN)
 #include "chrome/browser/importer/ie_importer.h"
+#endif
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/tab_contents/site_instance.h"
-#include "chrome/browser/views/importer_lock_view.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/gfx/favicon_size.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
-#include "chrome/common/win_util.h"
-#include "chrome/views/window.h"
 #include "grit/generated_resources.h"
 #include "skia/ext/image_operations.h"
 #include "webkit/glue/image_decoder.h"
 
+// TODO(port): Port these files.
+#if defined(OS_WIN)
+#include "chrome/browser/views/importer_lock_view.h"
+#include "chrome/common/win_util.h"
+#include "chrome/views/window.h"
+#endif
+
 // ProfileWriter.
 
 bool ProfileWriter::BookmarkModelIsLoaded() const {
   return profile_->GetBookmarkModel()->IsLoaded();
 }
 
 void ProfileWriter::AddBookmarkModelObserver(BookmarkModelObserver* observer) {
   profile_->GetBookmarkModel()->AddObserver(observer);
 }
 
 bool ProfileWriter::TemplateURLModelIsLoaded() const {
   return profile_->GetTemplateURLModel()->loaded();
 }
 
 void ProfileWriter::AddTemplateURLModelObserver(
     NotificationObserver* observer) {
   TemplateURLModel* model = profile_->GetTemplateURLModel();
   NotificationService::current()->AddObserver(
       observer, NotificationType::TEMPLATE_URL_MODEL_LOADED,
       Source<TemplateURLModel>(model));
   model->Load();
 }
 
 void ProfileWriter::AddPasswordForm(const PasswordForm& form) {
   profile_->GetWebDataService(Profile::EXPLICIT_ACCESS)->AddLogin(form);
 }
 
+#if defined(OS_WIN)
 void ProfileWriter::AddIE7PasswordInfo(const IE7PasswordInfo& info) {
   profile_->GetWebDataService(Profile::EXPLICIT_ACCESS)->AddIE7Login(info);
 }
+#endif
 
 void ProfileWriter::AddHistoryPage(const std::vector<history::URLRow>& page) {
   profile_->GetHistoryService(Profile::EXPLICIT_ACCESS)->
       AddPagesWithDetails(page);
 }
 
 void ProfileWriter::AddHomepage(const GURL& home_page) {
   DCHECK(profile_);
 
   PrefService* prefs = profile_->GetPrefs();
@@ skipping 183 matching lines @@
         if (turl_with_host_path)
           model->SetDefaultSearchProvider(turl_with_host_path);
         else
           NOTREACHED();  // BuildHostPathMap should only insert non-null values.
       }
       delete t_url;
       continue;
     }
     if (t_url->url() && t_url->url()->IsValid()) {
       model->Add(t_url);
-      if (default_keyword && t_url->url() && 
+      if (default_keyword && t_url->url() &&
           t_url->url()->SupportsReplacement())
         model->SetDefaultSearchProvider(t_url);
     } else {
       // Don't add invalid TemplateURLs to the model.
       delete t_url;
     }
   }
 }
 
 void ProfileWriter::ShowBookmarkBar() {
@@ skipping 39 matching lines @@
 
 bool ProfileWriter::DoesBookmarkExist(
     BookmarkModel* model,
     const BookmarkEntry& entry,
     const std::wstring& first_folder_name,
     bool first_run) {
   std::vector<BookmarkNode*> nodes_with_same_url;
   model->GetNodesByURL(entry.url, &nodes_with_same_url);
   if (nodes_with_same_url.empty())
     return false;
-  
+
   for (size_t i = 0; i < nodes_with_same_url.size(); ++i) {
     BookmarkNode* node = nodes_with_same_url[i];
     if (entry.title != node->GetTitle())
       continue;
 
     // Does the path match?
     bool found_match = true;
     BookmarkNode* parent = node->GetParent();
     for (std::vector<std::wstring>::const_reverse_iterator path_it =
              entry.path.rbegin();
@@ skipping 97 matching lines @@
       this, NotificationType::TEMPLATE_URL_MODEL_LOADED,
       Source<TemplateURLModel>(model));
   waiting_for_template_url_model_ = false;
   InvokeTaskIfDone();
 }
 
 void ImporterHost::ShowWarningDialog() {
   if (headless_) {
     OnLockViewEnd(false);
   } else {
+#if defined(OS_WIN)
     views::Window::CreateChromeWindow(GetActiveWindow(), gfx::Rect(),
                                       new ImporterLockView(this))->Show();
+#else
+    // TODO(port): Need CreateChromeWindow.
+    NOTIMPLEMENTED();
+#endif
   }
 }
 
 void ImporterHost::OnLockViewEnd(bool is_continue) {
   if (is_continue) {
     // User chose to continue, then we check the lock again to make
     // sure that Firefox has been closed. Try to import the settings
     // if successful. Otherwise, show a warning dialog.
     firefox_lock_->Lock();
     if (firefox_lock_->HasAcquired()) {
@@ skipping 92 matching lines @@
 
 void ImporterHost::ImportEnded() {
   firefox_lock_.reset();  // Release the Firefox profile lock.
   if (observer_)
     observer_->ImportEnded();
   Release();
 }
 
 Importer* ImporterHost::CreateImporterByType(ProfileType type) {
   switch (type) {
+#if defined(OS_WIN)
     case MS_IE:
       return new IEImporter();
+#endif
     case BOOKMARKS_HTML:
     case FIREFOX2:
       return new Firefox2Importer();
     case FIREFOX3:
       return new Firefox3Importer();
   }
   NOTREACHED();
   return NULL;
 }
 
 int ImporterHost::GetAvailableProfileCount() {
   return static_cast<int>(source_profiles_.size());
 }
 
 std::wstring ImporterHost::GetSourceProfileNameAt(int index) const {
   DCHECK(index < static_cast<int>(source_profiles_.size()));
   return source_profiles_[index]->description;
 }
 
 const ProfileInfo& ImporterHost::GetSourceProfileInfoAt(int index) const {
   DCHECK(index < static_cast<int>(source_profiles_.size()));
   return *source_profiles_[index];
 }
 
 void ImporterHost::DetectSourceProfiles() {
+#if defined(OS_WIN)
   // The order in which detect is called determines the order
   // in which the options appear in the dropdown combo-box
   if (ShellIntegration::IsFirefoxDefaultBrowser()) {
     DetectFirefoxProfiles();
     DetectIEProfiles();
   } else {
     DetectIEProfiles();
     DetectFirefoxProfiles();
   }
+#else
+  DetectFirefoxProfiles();
+#endif
 }
 
+
+#if defined(OS_WIN)
 void ImporterHost::DetectIEProfiles() {
   // IE always exists and don't have multiple profiles.
   ProfileInfo* ie = new ProfileInfo();
   ie->description = l10n_util::GetString(IDS_IMPORT_FROM_IE);
   ie->browser_type = MS_IE;
   ie->source_path.clear();
   ie->app_path.clear();
   ie->services_supported = HISTORY | FAVORITES | COOKIES | PASSWORDS |
       SEARCH_ENGINES;
   source_profiles_.push_back(ie);
 }
+#endif
 
 void ImporterHost::DetectFirefoxProfiles() {
   // Detects which version of Firefox is installed.
   int version = GetCurrentFirefoxMajorVersion();
   ProfileType firefox_type;
   if (version == 2) {
     firefox_type = FIREFOX2;
   } else if (version == 3) {
     firefox_type = FIREFOX3;
   } else {
@@ skipping 46 matching lines @@
     ProfileInfo* firefox = new ProfileInfo();
     firefox->description = l10n_util::GetString(IDS_IMPORT_FROM_FIREFOX);
     firefox->browser_type = firefox_type;
     firefox->source_path = source_path;
     firefox->app_path = GetFirefoxInstallPath();
     firefox->services_supported = HISTORY | FAVORITES | COOKIES | PASSWORDS |
         SEARCH_ENGINES;
     source_profiles_.push_back(firefox);
   }
 }