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