1 // Copyright (c) 2012 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 #ifndef CHROME_BROWSER_IMPORTER_EXTERNAL_PROCESS_IMPORTER_HOST_H_ 6 #define CHROME_BROWSER_IMPORTER_EXTERNAL_PROCESS_IMPORTER_HOST_H_ 7 8 #include "base/basictypes.h" 9 #include "base/compiler_specific.h" 10 #include "base/memory/ref_counted.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "base/memory/weak_ptr.h" 13 #include "chrome/browser/importer/importer_progress_observer.h" 14 #include "chrome/browser/importer/profile_writer.h" 15 #include "chrome/common/importer/importer_data_types.h" 16 #include "components/bookmarks/browser/base_bookmark_model_observer.h" 17 #include "components/search_engines/template_url_service.h" 18 #include "ui/gfx/native_widget_types.h" 19 20 class ExternalProcessImporterClient; 21 class FirefoxProfileLock; 22 class Importer; 23 class Profile; 24 25 namespace importer { 26 struct SourceProfile; 27 } 28 29 // This class manages the import process. It creates the in-process half of the 30 // importer bridge and the external process importer client. 31 class ExternalProcessImporterHost : public BaseBookmarkModelObserver { 32 public: 33 ExternalProcessImporterHost(); 34 35 void Cancel(); 36 37 // Starts the process of importing the settings and data depending on what the 38 // user selected. 39 // |source_profile| - importer profile to import. 40 // |target_profile| - profile to import into. 41 // |items| - specifies which data to import (bitmask of importer::ImportItem). 42 // |writer| - called to actually write data back to the profile. 43 virtual void StartImportSettings( 44 const importer::SourceProfile& source_profile, 45 Profile* target_profile, 46 uint16 items, 47 ProfileWriter* writer); 48 49 // When in headless mode, the importer will not show any warning dialog if 50 // a user action is required (e.g., Firefox profile is locked and user should 51 // close Firefox to continue) and the outcome is as if the user had canceled 52 // the import operation. 53 void set_headless() { headless_ = true; } 54 bool is_headless() const { return headless_; } 55 56 void set_parent_window(gfx::NativeWindow parent_window) { 57 parent_window_ = parent_window; 58 } 59 60 void set_observer(importer::ImporterProgressObserver* observer) { 61 observer_ = observer; 62 } 63 64 // A series of functions invoked at the start, during and end of the import 65 // process. The middle functions are notifications that the a harvesting of a 66 // particular source of data (specified by |item|) is under way. 67 void NotifyImportStarted(); 68 void NotifyImportItemStarted(importer::ImportItem item); 69 void NotifyImportItemEnded(importer::ImportItem item); 70 void NotifyImportEnded(); 71 72 private: 73 // ExternalProcessImporterHost deletes itself in OnImportEnded(). 74 virtual ~ExternalProcessImporterHost(); 75 76 // Launches the utility process that starts the import task, unless bookmark 77 // or template model are not yet loaded. If load is not detected, this method 78 // will be called when the loading observer sees that model loading is 79 // complete. 80 virtual void LaunchImportIfReady(); 81 82 // BaseBookmarkModelObserver: 83 virtual void BookmarkModelLoaded(BookmarkModel* model, 84 bool ids_reassigned) OVERRIDE; 85 virtual void BookmarkModelBeingDeleted(BookmarkModel* model) OVERRIDE; 86 virtual void BookmarkModelChanged() OVERRIDE; 87 88 // Called when TemplateURLService has been loaded. 89 void OnTemplateURLServiceLoaded(); 90 91 // ShowWarningDialog() asks user to close the application that is owning the 92 // lock. They can retry or skip the importing process. 93 // This method should not be called if the importer is in headless mode. 94 void ShowWarningDialog(); 95 96 // This is called when when user ends the lock dialog by clicking on either 97 // the "Skip" or "Continue" buttons. |is_continue| is true when user clicked 98 // the "Continue" button. 99 void OnImportLockDialogEnd(bool is_continue); 100 101 // Make sure that Firefox isn't running, if import browser is Firefox. Show 102 // to the user a dialog that notifies that is necessary to close Firefox 103 // prior to continue. 104 // |source_profile| - importer profile to import. 105 // Returns false iff import should be aborted. 106 bool CheckForFirefoxLock(const importer::SourceProfile& source_profile); 107 108 // Make sure BookmarkModel and TemplateURLService are loaded before import 109 // process starts, if bookmarks and/or search engines are among the items 110 // which are to be imported. 111 void CheckForLoadedModels(uint16 items); 112 113 // True if UI is not to be shown. 114 bool headless_; 115 116 // Parent window that we pass to the import lock dialog (i.e, the Firefox 117 // warning dialog). 118 gfx::NativeWindow parent_window_; 119 120 // The observer that we need to notify about changes in the import process. 121 importer::ImporterProgressObserver* observer_; 122 123 // Firefox profile lock. 124 scoped_ptr<FirefoxProfileLock> firefox_lock_; 125 126 // Profile we're importing from. 127 Profile* profile_; 128 129 // True if we're waiting for the model to finish loading. 130 bool waiting_for_bookmarkbar_model_; 131 132 // May contain a Subscription waiting for the TemplateURLService to finish 133 // loading. 134 scoped_ptr<TemplateURLService::Subscription> template_service_subscription_; 135 136 // Have we installed a listener on the bookmark model? 137 bool installed_bookmark_observer_; 138 139 // True if source profile is readable. 140 bool is_source_readable_; 141 142 // Writes data from the importer back to the profile. 143 scoped_refptr<ProfileWriter> writer_; 144 145 // Used to pass notifications from the browser side to the external process. 146 ExternalProcessImporterClient* client_; 147 148 // Information about a profile needed for importing. 149 importer::SourceProfile source_profile_; 150 151 // Bitmask of items to be imported (see importer::ImportItem enum). 152 uint16 items_; 153 154 // True if the import process has been cancelled. 155 bool cancelled_; 156 157 // Vends weak pointers for the importer to call us back. 158 base::WeakPtrFactory<ExternalProcessImporterHost> weak_ptr_factory_; 159 160 DISALLOW_COPY_AND_ASSIGN(ExternalProcessImporterHost); 161 }; 162 163 #endif // CHROME_BROWSER_IMPORTER_EXTERNAL_PROCESS_IMPORTER_HOST_H_ 164
