Merge pull request #245 from brave/brave-profile-lock

BraveProfileLock

Author: darkdh

app/brave_generated_resources.grd

@@ -80,6 +80,12 @@
       <message name="IDS_CHROME_IMPORTER_LOCK_TEXT" desc="The message to be displayed in the Chrome importer lock dialog">
 	To finish importing, close all Chrome windows.
       </message>
+      <message name="IDS_BRAVE_IMPORTER_LOCK_TITLE" desc="Dialog title for Brave importer lock dialog">
+	Close Brave
+      </message>
+      <message name="IDS_BRAVE_IMPORTER_LOCK_TEXT" desc="The message to be displayed in the Brave importer lock dialog">
+	To finish importing, close all Brave windows.
+      </message>
       <message name="IDS_SETTINGS_IMPORT_COOKIES_CHECKBOX" desc="Checkbox for importing cookies">
         Cookies
       </message>

browser/BUILD.gn

@@ -35,6 +35,9 @@ source_set("browser_process") {
     "importer/brave_in_process_importer_bridge.h",
     "importer/brave_profile_writer.cc",
     "importer/brave_profile_writer.h",
+    "importer/brave_profile_lock.cc",
+    "importer/brave_profile_lock.h",
+    "importer/browser_profile_lock.h",
     "importer/chrome_profile_lock.cc",
     "importer/chrome_profile_lock.h",
     "sparkle_glue_mac.mm",

browser/importer/brave_external_process_importer_host.cc

@@ -4,6 +4,8 @@
 
 #include "brave/browser/importer/brave_external_process_importer_client.h"
 #include "brave/browser/importer/brave_external_process_importer_host.h"
+#include "brave/browser/importer/brave_profile_lock.h"
+#include "brave/browser/importer/chrome_profile_lock.h"
 #include "brave/browser/importer/brave_in_process_importer_bridge.h"
 
 #include "brave/browser/importer/brave_importer_lock_dialog.h"
@@ -33,7 +35,7 @@ void BraveExternalProcessImporterHost::StartImportSettings(
     return;
   }
 
-  if (!CheckForChromeLock(source_profile)) {
+  if (!CheckForChromeOrBraveLock()) {
     Cancel();
     return;
   }
@@ -65,17 +67,18 @@ void BraveExternalProcessImporterHost::ShowWarningDialog() {
   DCHECK(!headless_);
   brave::importer::ShowImportLockDialog(
       parent_window_,
+      source_profile_,
       base::Bind(&BraveExternalProcessImporterHost::OnImportLockDialogEnd,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BraveExternalProcessImporterHost::OnImportLockDialogEnd(bool is_continue) {
   if (is_continue) {
-    // User chose to continue, then we check the lock again to make
-    // sure that Chrome has been closed. Try to import the settings
-    // if successful. Otherwise, show a warning dialog.
-    chrome_lock_->Lock();
-    if (chrome_lock_->HasAcquired()) {
+    // User chose to continue, then we check the lock again to make sure that
+    // the other browser has been closed. Try to import the settings if
+    // successful. Otherwise, show a warning dialog.
+    browser_lock_->Lock();
+    if (browser_lock_->HasAcquired()) {
       is_source_readable_ = true;
       LaunchImportIfReady();
     } else {
@@ -86,19 +89,24 @@ void BraveExternalProcessImporterHost::OnImportLockDialogEnd(bool is_continue) {
   }
 }
 
-bool BraveExternalProcessImporterHost::CheckForChromeLock(
-    const importer::SourceProfile& source_profile) {
-  if (source_profile.importer_type != importer::TYPE_CHROME)
+bool BraveExternalProcessImporterHost::CheckForChromeOrBraveLock() {
+  if (!(source_profile_.importer_type == importer::TYPE_CHROME ||
+        source_profile_.importer_type == importer::TYPE_BRAVE))
     return true;
 
-  // Extract the user data directory from the path of the profile to be
-  // imported, because we can only lock/unlock the entire user directory with
-  // ProcessSingleton.
-  base::FilePath user_data_dir = source_profile.source_path.DirName();
+  DCHECK(!browser_lock_.get());
 
-  DCHECK(!chrome_lock_.get());
-  chrome_lock_.reset(new ChromeProfileLock(user_data_dir));
-  if (chrome_lock_->HasAcquired())
+  if (source_profile_.importer_type == importer::TYPE_CHROME) {
+    // Extract the user data directory from the path of the profile to be
+    // imported, because we can only lock/unlock the entire user directory with
+    // ProcessSingleton.
+    base::FilePath user_data_dir = source_profile_.source_path.DirName();
+    browser_lock_.reset(new ChromeProfileLock(user_data_dir));
+  } else {  // source_profile_.importer_type == importer::TYPE_BRAVE
+    browser_lock_.reset(new BraveProfileLock(source_profile_.source_path));
+  }
+
+  if (browser_lock_->HasAcquired())
     return true;
 
   // If fail to acquire the lock, we set the source unreadable and

browser/importer/brave_external_process_importer_host.h

@@ -6,7 +6,7 @@
 #define BRAVE_BROWSER_IMPORTER_BRAVE_EXTERNAL_PROCESS_IMPORTER_HOST_H_
 
 #include "base/memory/weak_ptr.h"
-#include "brave/browser/importer/chrome_profile_lock.h"
+#include "brave/browser/importer/browser_profile_lock.h"
 #include "chrome/browser/importer/external_process_importer_host.h"
 
 class BraveExternalProcessImporterHost : public ExternalProcessImporterHost {
@@ -28,12 +28,11 @@ class BraveExternalProcessImporterHost : public ExternalProcessImporterHost {
   // complete.
   void LaunchImportIfReady() override;
 
-  // Make sure that Chrome isn't running, if import browser is Chrome. Show
-  // to the user a dialog that notifies that is necessary to close Chrome
-  // prior to continuing the import.
-  // |source_profile| - importer profile to import.
-  // Returns false iff import should be aborted.
-  bool CheckForChromeLock(const importer::SourceProfile& source_profile);
+  // Make sure that Chrome or Brave isn't running, if import browser is Chrome
+  // or Brave. Show to the user a dialog that notifies that is necessary to
+  // close Chrome or Brave prior to continuing the import. Returns false iff
+  // import should be aborted.
+  bool CheckForChromeOrBraveLock();
 
   // ShowWarningDialog() asks user to close the application that is owning the
   // lock. They can retry or skip the importing process.
@@ -45,8 +44,8 @@ class BraveExternalProcessImporterHost : public ExternalProcessImporterHost {
   // the "Continue" button.
   void OnImportLockDialogEnd(bool is_continue);
 
-  // Chrome profile lock.
-  std::unique_ptr<ChromeProfileLock> chrome_lock_;
+  // Chrome or Brave profile lock.
+  std::unique_ptr<BrowserProfileLock> browser_lock_;
 
   // Vends weak pointers for the importer to call us back.
   base::WeakPtrFactory<BraveExternalProcessImporterHost> weak_ptr_factory_;

browser/importer/brave_importer_lock_dialog.h

@@ -6,6 +6,7 @@
 #define BRAVE_BROWSER_IMPORTER_BRAVE_IMPORTER_LOCK_DIALOG_H_
 
 #include "base/callback_forward.h"
+#include "chrome/common/importer/importer_data_types.h"
 #include "ui/gfx/native_widget_types.h"
 
 namespace brave {
@@ -15,6 +16,7 @@ namespace importer {
 // warning dialog. After closing the dialog, the ImportHost receives a callback
 // with the message either to skip the import, or to continue the process.
 void ShowImportLockDialog(gfx::NativeWindow parent,
+                          ::importer::SourceProfile source_profile,
                           const base::Callback<void(bool)>& callback);
 
 }  // namespace importer

browser/importer/brave_profile_lock.cc

@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "brave/browser/importer/brave_profile_lock.h"
+
+BraveProfileLock::BraveProfileLock(
+    const base::FilePath& user_data_dir)
+  : ChromeProfileLock(user_data_dir) {}
+
+BraveProfileLock::~BraveProfileLock() {}

browser/importer/brave_profile_lock.h

@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_BROWSER_IMPORTER_BRAVE_PROFILE_LOCK_H__
+#define BRAVE_BROWSER_IMPORTER_BRAVE_PROFILE_LOCK_H__
+
+#include "base/files/file_path.h"
+#include "brave/browser/importer/chrome_profile_lock.h"
+
+class BraveProfileLock : public ChromeProfileLock {
+ public:
+  explicit BraveProfileLock(const base::FilePath& user_data_dir);
+  ~BraveProfileLock() override;
+};
+
+#endif  // BRAVE_BROWSER_IMPORTER_BRAVE_PROFILE_LOCK_H__

browser/importer/browser_profile_lock.h

@@ -0,0 +1,20 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_BROWSER_IMPORTER_BROWSER_PROFILE_LOCK_H__
+#define BRAVE_BROWSER_IMPORTER_BROWSER_PROFILE_LOCK_H__
+
+class BrowserProfileLock {
+ public:
+  virtual ~BrowserProfileLock() {};
+
+  // Locks and releases the profile.
+  virtual void Lock() = 0;
+  virtual void Unlock() = 0;
+
+  // Returns true if we lock the profile successfully.
+  virtual bool HasAcquired() = 0;
+};
+
+#endif  // BRAVE_BROWSER_IMPORTER_BROWSER_PROFILE_LOCK_H__

browser/importer/chrome_profile_lock.h

@@ -7,27 +7,28 @@
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "brave/browser/importer/browser_profile_lock.h"
 #include "chrome/browser/process_singleton.h"
 
-class ChromeProfileLock {
+class ChromeProfileLock : public BrowserProfileLock {
  public:
   explicit ChromeProfileLock(const base::FilePath& user_data_dir);
-  ~ChromeProfileLock();
+  ~ChromeProfileLock() override;
 
   // Locks and releases the profile.
-  void Lock();
-  void Unlock();
+  void Lock() override;
+  void Unlock() override;
 
   // Returns true if we lock the profile successfully.
-  bool HasAcquired();
+  bool HasAcquired() override;
 
  private:
   bool lock_acquired_;
   base::FilePath user_data_dir_;
   std::unique_ptr<ProcessSingleton> process_singleton_;
 
   bool NotificationCallback(const base::CommandLine& command_line,
-			    const base::FilePath& current_directory);
+                            const base::FilePath& current_directory);
 
   DISALLOW_COPY_AND_ASSIGN(ChromeProfileLock);
 };

browser/ui/cocoa/importer/brave_import_lock_dialog_cocoa.mm

@@ -11,8 +11,8 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "brave/browser/importer/brave_importer_lock_dialog.h"
 #include "brave/browser/ui/views/importer/brave_import_lock_dialog_view.h"
-#include "brave/grit/brave_generated_resources.h"
 #include "chrome/browser/ui/cocoa/browser_dialogs_views_mac.h"
+#include "chrome/common/importer/importer_data_types.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/strings/grit/components_strings.h"
@@ -24,18 +24,27 @@
 namespace importer {
 
 void ShowImportLockDialog(gfx::NativeWindow parent,
+                          importer::SourceProfile source_profile,
                           const base::Callback<void(bool)>& callback) {
   if (chrome::ShowAllDialogsWithViewsToolkit())
-    return ImportLockDialogView::Show(parent, callback);
+    return ImportLockDialogView::Show(parent, source_profile, callback);
 
   base::scoped_nsobject<NSAlert> lock_alert([[NSAlert alloc] init]);
   [lock_alert addButtonWithTitle:l10n_util::GetNSStringWithFixup(
       IDS_IMPORTER_LOCK_OK)];
   [lock_alert addButtonWithTitle:l10n_util::GetNSStringWithFixup(IDS_CANCEL)];
-  [lock_alert setInformativeText:l10n_util::GetNSStringWithFixup(
-      IDS_CHROME_IMPORTER_LOCK_TEXT)];
-  [lock_alert setMessageText:l10n_util::GetNSStringWithFixup(
-      IDS_CHROME_IMPORTER_LOCK_TITLE)];
+
+  if (source_profile.importer_type == importer::TYPE_CHROME) {
+    [lock_alert setInformativeText:l10n_util::GetNSStringWithFixup(
+        IDS_CHROME_IMPORTER_LOCK_TEXT)];
+    [lock_alert setMessageText:l10n_util::GetNSStringWithFixup(
+        IDS_CHROME_IMPORTER_LOCK_TITLE)];
+  } else if (source_profile.importer_type == importer::TYPE_BRAVE) {
+    [lock_alert setInformativeText:l10n_util::GetNSStringWithFixup(
+        IDS_BRAVE_IMPORTER_LOCK_TEXT)];
+    [lock_alert setMessageText:l10n_util::GetNSStringWithFixup(
+        IDS_BRAVE_IMPORTER_LOCK_TITLE)];
+  }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,

browser/ui/views/importer/brave_import_lock_dialog_view.cc

@@ -32,27 +32,38 @@ namespace importer {
 
 #if !defined(OS_MACOSX) || BUILDFLAG(MAC_VIEWS_BROWSER)
 void ShowImportLockDialog(gfx::NativeWindow parent,
+                          ::importer::SourceProfile source_profile,
                           const base::Callback<void(bool)>& callback) {
-  ImportLockDialogView::Show(parent, callback);
+  ImportLockDialogView::Show(parent, source_profile, callback);
 }
 #endif  // !OS_MACOSX || MAC_VIEWS_BROWSER
 
 }  // namespace importer
 
 // static
 void ImportLockDialogView::Show(gfx::NativeWindow parent,
+                                ::importer::SourceProfile source_profile,
                                 const base::Callback<void(bool)>& callback) {
   views::DialogDelegate::CreateDialogWidget(
-      new ImportLockDialogView(callback), NULL, NULL)->Show();
+      new ImportLockDialogView(source_profile, callback), NULL, NULL)->Show();
   base::RecordAction(UserMetricsAction("ImportLockDialogView_Shown"));
 }
 
 ImportLockDialogView::ImportLockDialogView(
+    ::importer::SourceProfile source_profile,
     const base::Callback<void(bool)>& callback)
-    : callback_(callback) {
+  : source_profile_(source_profile),
+    callback_(callback) {
   SetLayoutManager(std::make_unique<views::FillLayout>());
-  views::Label* description_label =
+
+  views::Label* description_label;
+  if (source_profile_.importer_type == ::importer::TYPE_CHROME) {
+    description_label =
       new views::Label(l10n_util::GetStringUTF16(IDS_CHROME_IMPORTER_LOCK_TEXT));
+  } else {  // if (source_profile_.importer_type == ::importer::TYPE_BRAVE)
+    description_label =
+      new views::Label(l10n_util::GetStringUTF16(IDS_BRAVE_IMPORTER_LOCK_TEXT));
+  }
   description_label->SetBorder(views::CreateEmptyBorder(
       ChromeLayoutProvider::Get()->GetDialogInsetsForContentType(views::TEXT,
                                                                  views::TEXT)));
@@ -79,7 +90,11 @@ base::string16 ImportLockDialogView::GetDialogButtonLabel(
 }
 
 base::string16 ImportLockDialogView::GetWindowTitle() const {
-  return l10n_util::GetStringUTF16(IDS_CHROME_IMPORTER_LOCK_TITLE);
+  if (source_profile_.importer_type == ::importer::TYPE_CHROME) {
+    return l10n_util::GetStringUTF16(IDS_CHROME_IMPORTER_LOCK_TITLE);
+  } else {  // if (source_profile_.importer_type == ::importer::TYPE_BRAVE) {
+    return l10n_util::GetStringUTF16(IDS_BRAVE_IMPORTER_LOCK_TITLE);
+  }
 }
 
 bool ImportLockDialogView::Accept() {

browser/ui/views/importer/brave_import_lock_dialog_view.h

@@ -8,6 +8,7 @@
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "chrome/common/importer/importer_data_types.h"
 #include "ui/views/window/dialog_delegate.h"
 
 namespace brave {
@@ -17,10 +18,12 @@ namespace brave {
 class ImportLockDialogView : public views::DialogDelegateView {
  public:
   static void Show(gfx::NativeWindow parent,
+                   ::importer::SourceProfile source_profile,
                    const base::Callback<void(bool)>& callback);
 
  private:
-  explicit ImportLockDialogView(const base::Callback<void(bool)>& callback);
+  explicit ImportLockDialogView(::importer::SourceProfile source_profile,
+                                const base::Callback<void(bool)>& callback);
   ~ImportLockDialogView() override;
 
   // views::View:
@@ -36,6 +39,8 @@ class ImportLockDialogView : public views::DialogDelegateView {
   bool ShouldShowCloseButton() const override;
 
  private:
+  ::importer::SourceProfile source_profile_;
+
   // Called with the result of the dialog.
   base::Callback<void(bool)> callback_;
 

utility/importer/chrome_importer.cc

@@ -302,7 +302,7 @@ double ChromeImporter::chromeTimeToDouble(int64_t time) {
   return ((time * 10 - 0x19DB1DED53E8000) / 10000) / 1000;
 }
 
-void ChromeImporter::ImportPasswords(const base::FilePath& prefs) {
+void ChromeImporter::ImportPasswords(const base::FilePath& prefs_filename) {
   #if !defined(USE_X11)
     base::FilePath passwords_path =
       source_path_.Append(
@@ -329,7 +329,7 @@ void ChromeImporter::ImportPasswords(const base::FilePath& prefs) {
       }
     }
   #else
-    base::FilePath prefs_path = source_path_.Append(prefs);
+    base::FilePath prefs_path = source_path_.Append(prefs_filename);
     const base::Value *value;
     scoped_refptr<JsonPrefStore> prefs = new JsonPrefStore(prefs_path);
     int local_profile_id;

utility/importer/chrome_importer.h

@@ -45,7 +45,7 @@ class ChromeImporter : public Importer {
 
   virtual void ImportBookmarks();
   virtual void ImportHistory();
-  virtual void ImportPasswords(const base::FilePath& prefs);
+  virtual void ImportPasswords(const base::FilePath& prefs_filename);
   virtual void ImportCookies();
 
   double chromeTimeToDouble(int64_t time);