1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
// Copyright (c) 2011 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.
#ifndef CHROME_BROWSER_IMPORTER_IMPORTER_HOST_H_
#define CHROME_BROWSER_IMPORTER_IMPORTER_HOST_H_
#pragma once
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/browser/bookmarks/base_bookmark_model_observer.h"
#include "chrome/browser/importer/importer_data_types.h"
#include "chrome/browser/importer/profile_writer.h"
#include "chrome/browser/ui/browser_list.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "ui/gfx/native_widget_types.h"
class FirefoxProfileLock;
class Importer;
class Profile;
namespace importer {
class ImporterProgressObserver;
}
// This class hosts the importers. It enumerates profiles from other
// browsers dynamically, and controls the process of importing. When
// the import process is done, ImporterHost deletes itself.
class ImporterHost : public base::RefCountedThreadSafe<ImporterHost>,
public BaseBookmarkModelObserver,
public content::NotificationObserver,
public BrowserList::Observer {
public:
ImporterHost();
// ShowWarningDialog() asks user to close the application that is owning the
// lock. They can retry or skip the importing process.
void ShowWarningDialog();
// This is called when when user ends the lock dialog by clicking on either
// the "Skip" or "Continue" buttons. |is_continue| is true when user clicked
// the "Continue" button.
void OnImportLockDialogEnd(bool is_continue);
void SetObserver(importer::ImporterProgressObserver* observer);
// A series of functions invoked at the start, during and end of the import
// process. The middle functions are notifications that the a harvesting of a
// particular source of data (specified by |item|) is under way.
void NotifyImportStarted();
void NotifyImportItemStarted(importer::ImportItem item);
void NotifyImportItemEnded(importer::ImportItem item);
void NotifyImportEnded();
// When in headless mode, the importer will not show the warning dialog and
// the outcome is as if the user had canceled the import operation.
void set_headless() { headless_ = true; }
bool is_headless() const { return headless_; }
void set_parent_window(gfx::NativeWindow parent_window) {
parent_window_ = parent_window;
}
void set_browser(Browser* browser) { browser_ = browser; }
// Starts the process of importing the settings and data depending on what the
// user selected.
// |source_profile| - importer profile to import.
// |target_profile| - profile to import into.
// |items| - specifies which data to import (bitmask of importer::ImportItem).
// |writer| - called to actually write data back to the profile.
// |first_run| - true if this method is being called during first run.
virtual void StartImportSettings(
const importer::SourceProfile& source_profile,
Profile* target_profile,
uint16 items,
ProfileWriter* writer,
bool first_run);
// Cancels the import process.
virtual void Cancel();
protected:
virtual ~ImporterHost();
// Make sure that Firefox isn't running, if import browser is Firefox. Show
// to the user a dialog that notifies that is necessary to close Firefox
// prior to continue.
// |source_profile| - importer profile to import.
// |items| - specifies which data to import (bitmask of importer::ImportItem).
// |first_run| - true if this method is being called during first run.
void CheckForFirefoxLock(const importer::SourceProfile& source_profile,
uint16 items,
bool first_run);
// Make sure BookmarkModel and TemplateURLService are loaded before import
// process starts, if bookmarks and/or search engines are among the items
// which are to be imported.
void CheckForLoadedModels(uint16 items);
// Profile we're importing from.
Profile* profile_;
// True if we're waiting for the model to finish loading.
bool waiting_for_bookmarkbar_model_;
// Have we installed a listener on the bookmark model?
bool installed_bookmark_observer_;
// True if source profile is readable.
bool is_source_readable_;
// Receives notification when the TemplateURLService has loaded.
content::NotificationRegistrar registrar_;
// Writes data from the importer back to the profile.
scoped_refptr<ProfileWriter> writer_;
private:
friend class base::RefCountedThreadSafe<ImporterHost>;
// Launches the thread that starts the import task, unless bookmark or
// template model are not yet loaded. If load is not detected, this method
// will be called when the loading observer sees that model loading is
// complete.
virtual void InvokeTaskIfDone();
// Called when IsGoogleGAIACookieInstalled is done.
void OnGoogleGAIACookieChecked(bool result);
// BaseBookmarkModelObserver:
virtual void Loaded(BookmarkModel* model, bool ids_reassigned) OVERRIDE;
virtual void BookmarkModelBeingDeleted(BookmarkModel* model) OVERRIDE;
virtual void BookmarkModelChanged() OVERRIDE;
// content::NotificationObserver:
// Called when TemplateURLService has been loaded.
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE;
// BrowserList::Observer
virtual void OnBrowserRemoved(Browser* browser) OVERRIDE;
// The task is the process of importing settings from other browsers.
base::Closure task_;
// The importer used in the task.
Importer* importer_;
// True if UI is not to be shown.
bool headless_;
// Parent window that we pass to the import lock dialog (i.e, the Firefox
// warning dialog).
gfx::NativeWindow parent_window_;
// Used to add a new tab if we need the user to sign in.
Browser* browser_;
// The observer that we need to notify about changes in the import process.
importer::ImporterProgressObserver* observer_;
// Firefox profile lock.
scoped_ptr<FirefoxProfileLock> firefox_lock_;
DISALLOW_COPY_AND_ASSIGN(ImporterHost);
};
#endif // CHROME_BROWSER_IMPORTER_IMPORTER_HOST_H_
|
