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