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
20class ExternalProcessImporterClient;
21class FirefoxProfileLock;
22class Importer;
23class Profile;
24
25namespace importer {
26struct 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.
31class 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