chrome/browser/importer/external_process_importer_client.h

   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_CLIENT_H_
   6 #define CHROME_BROWSER_IMPORTER_EXTERNAL_PROCESS_IMPORTER_CLIENT_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/strings/string16.h"
  15 #include "chrome/browser/history/history_types.h"
  16 #include "chrome/common/importer/importer_data_types.h"
  17 #include "chrome/common/importer/importer_url_row.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/browser/utility_process_host_client.h"
  20
  21 class ExternalProcessImporterHost;
  22 struct ImportedBookmarkEntry;
  23 struct ImportedFaviconUsage;
  24 class InProcessImporterBridge;
  25
  26 namespace autofill {
  27 struct PasswordForm;
  28 }
  29
  30 namespace content{
  31 class UtilityProcessHost;
  32 }
  33
  34 namespace importer {
  35 #if defined(OS_WIN)
  36 struct ImporterIE7PasswordInfo;
  37 #endif
  38 struct URLKeywordInfo;
  39 }
  40
  41 // This class is the client for the out of process profile importing.  It
  42 // collects notifications from this process host and feeds data back to the
  43 // importer host, who actually does the writing.
  44 class ExternalProcessImporterClient : public content::UtilityProcessHostClient {
  45  public:
  46   ExternalProcessImporterClient(
  47       base::WeakPtr<ExternalProcessImporterHost> importer_host,
  48       const importer::SourceProfile& source_profile,
  49       uint16 items,
  50       InProcessImporterBridge* bridge);
  51
  52   // Launches the task to start the external process.
  53   void Start();
  54
  55   // Called by the ExternalProcessImporterHost on import cancel.
  56   void Cancel();
  57
  58   // UtilityProcessHostClient implementation:
  59   virtual void OnProcessCrashed(int exit_code) OVERRIDE;
  60   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
  61
  62   // Message handlers
  63   void OnImportStart();
  64   void OnImportFinished(bool succeeded, const std::string& error_msg);
  65   void OnImportItemStart(int item);
  66   void OnImportItemFinished(int item);
  67   void OnHistoryImportStart(size_t total_history_rows_count);
  68   void OnHistoryImportGroup(
  69       const std::vector<ImporterURLRow>& history_rows_group,
  70       int visit_source);
  71   void OnHomePageImportReady(const GURL& home_page);
  72   void OnBookmarksImportStart(const base::string16& first_folder_name,
  73                               size_t total_bookmarks_count);
  74   void OnBookmarksImportGroup(
  75       const std::vector<ImportedBookmarkEntry>& bookmarks_group);
  76   void OnFaviconsImportStart(size_t total_favicons_count);
  77   void OnFaviconsImportGroup(
  78       const std::vector<ImportedFaviconUsage>& favicons_group);
  79   void OnPasswordFormImportReady(const autofill::PasswordForm& form);
  80   void OnKeywordsImportReady(
  81       const std::vector<importer::URLKeywordInfo>& url_keywords,
  82       bool unique_on_host_and_path);
  83   void OnFirefoxSearchEngineDataReceived(
  84       const std::vector<std::string> search_engine_data);
  85 #if defined(OS_WIN)
  86   void OnIE7PasswordReceived(
  87         const importer::ImporterIE7PasswordInfo& importer_password_info);
  88 #endif
  89
  90  protected:
  91   virtual ~ExternalProcessImporterClient();
  92
  93  private:
  94   // Notifies the importerhost that import has finished, and calls Release().
  95   void Cleanup();
  96
  97   // Cancel import process on IO thread.
  98   void CancelImportProcessOnIOThread();
  99
 100   // Report item completely downloaded on IO thread.
 101   void NotifyItemFinishedOnIOThread(importer::ImportItem import_item);
 102
 103   // Creates a new UtilityProcessHost, which launches the import process.
 104   void StartProcessOnIOThread(content::BrowserThread::ID thread_id);
 105
 106   // These variables store data being collected from the importer until the
 107   // entire group has been collected and is ready to be written to the profile.
 108   std::vector<ImporterURLRow> history_rows_;
 109   std::vector<ImportedBookmarkEntry> bookmarks_;
 110   std::vector<ImportedFaviconUsage> favicons_;
 111
 112   // Usually some variation on IDS_BOOKMARK_GROUP_...; the name of the folder
 113   // under which imported bookmarks will be placed.
 114   base::string16 bookmarks_first_folder_name_;
 115
 116   // Total number of bookmarks to import.
 117   size_t total_bookmarks_count_;
 118
 119   // Total number of history items to import.
 120   size_t total_history_rows_count_;
 121
 122   // Total number of favicons to import.
 123   size_t total_favicons_count_;
 124
 125   // Notifications received from the ProfileImportProcessHost are passed back
 126   // to process_importer_host_, which calls the ProfileWriter to record the
 127   // import data.  When the import process is done, process_importer_host_
 128   // deletes itself. This is a weak ptr so that any messages received after
 129   // the host has deleted itself are ignored (e.g., it's possible to receive
 130   // OnProcessCrashed() after NotifyImportEnded()).
 131   base::WeakPtr<ExternalProcessImporterHost> process_importer_host_;
 132
 133   // Handles sending messages to the external process.  Deletes itself when
 134   // the external process dies (see
 135   // BrowserChildProcessHost::OnChildDisconnected).
 136   base::WeakPtr<content::UtilityProcessHost> utility_process_host_;
 137
 138   // Data to be passed from the importer host to the external importer.
 139   importer::SourceProfile source_profile_;
 140   uint16 items_;
 141
 142   // Takes import data coming over IPC and delivers it to be written by the
 143   // ProfileWriter.
 144   scoped_refptr<InProcessImporterBridge> bridge_;
 145
 146   // True if import process has been cancelled.
 147   bool cancelled_;
 148
 149   DISALLOW_COPY_AND_ASSIGN(ExternalProcessImporterClient);
 150 };
 151
 152 #endif  // CHROME_BROWSER_IMPORTER_EXTERNAL_PROCESS_IMPORTER_CLIENT_H_