Add profiles to wrench menu

chrome/browser/ui/toolbar/wrench_menu_model.cc

 // 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.
 
 #include "chrome/browser/ui/toolbar/wrench_menu_model.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/i18n/number_formatting.h"
+#include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/toolbar/encoding_menu_controller.h"
 #include "chrome/browser/upgrade_detector.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/profiling.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "content/common/notification_type.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
@@ skipping 166 matching lines @@
   AddItemWithStringId(IDC_IMPORT_SETTINGS, IDS_IMPORT_SETTINGS_TITLE);
 #if defined(OS_MACOSX) || defined(TOOLKIT_VIEWS)
   AddSeparator();
 #else
   // TODO: add submenu for bookmarks themselves, restore separator.
 #endif
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
+// ProfilesSubMenuModel
+
+ProfilesSubMenuModel::ProfilesSubMenuModel(
+    ui::SimpleMenuModel::Delegate* delegate, Browser* browser)
+    : SimpleMenuModel(this),
+      browser_(browser),
+      delegate_(delegate) {
+  Build();
+}
+
+void ProfilesSubMenuModel::Build() {

[sky, 2011/06/10 16:24:14]

Rename this Init and have the caller invoke it
(http://www.corp.google.com/eng/doc/cppguide.xml#Doing_Work_in_Constructors)

[sail, 2011/06/11 01:27:37]

I agree but all the other classes in this file do the same thing so doing it
different here would be confusing.

+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  size_t count = profile_manager->GetNumberOfProfiles();
+  for (size_t i = 0; i < count; ++i) {
+    AddItem(COMMAND_SWITCH_TO_PROFILE + i,
+            profile_manager->GetNameOfProfileAtIndex(i));
+  }
+
+  AddSeparator();
+  AddItemWithStringId(IDC_CREATE_NEW_PROFILE,

[sky, 2011/06/10 16:24:14]

Are you sure you don't want this first? Having the new menu first then the list
of profiles better matches the bookmarks menu. The bookmarks menu has operations
related to the bookmarks first, then the bookmarks.

[sail, 2011/06/11 01:27:37]

This menu will mainly be used for switching between profiles so it makes sense
to put the "create new profile" command last.

For example, you look through all the profiles, if by the time you reach the end
and you haven't found the one you want yet then you choose "create new profile".

+                      IDS_PROFILES_CREATE_NEW_PROFILE_OPTION);
+}
+
+void ProfilesSubMenuModel::ExecuteCommand(int command_id) {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  size_t index = command_id;
+  if (index < profile_manager->GetNumberOfProfiles()) {
+    FilePath userDataFolder;
+    PathService::Get(chrome::DIR_USER_DATA, &userDataFolder);
+    FilePath profile_path =
+        profile_manager->GetFilePathOfProfileAtIndex(index, userDataFolder);
+
+    if (profile_manager->GetProfileByPath(profile_path)) {
+      OpenWindowWithProfile(profile_path);
+    } else {
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          NewRunnableMethod(this, &ProfilesSubMenuModel::GetProfileOnIOThread,
+                            profile_path));

[Miranda Callahan, 2011/06/11 15:09:08]

You don't want to do this on the IO Thread -- see below.  What you want is
something that launches an existing profile asynchronously, such that the stuff
that touches the File System in profile creation takes place on the file thread.
 This will be very similar to ProfileManager::CreateMultiProfileAsync -- except
that instead of observing with a NewProfileLauncher that opens the sync signin
dialog after launch, observe with some other kind of launcher that calls back to
the OpenWindowWithProfile task.

See my comment below on GetProfileOnIOThread.

[sail, 2011/06/13 19:00:01]

Done.

+    }
+  } else {
+    delegate_->ExecuteCommand(command_id);
+  }
+}
+
+void ProfilesSubMenuModel::GetProfileOnIOThread(FilePath profile_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ProfileManager* profile_manager = g_browser_process->profile_manager();

[sky, 2011/06/10 16:24:14]

Is ProfileManager, Profile and all the classes that Profile is going to create
really thread safe?

[sail, 2011/06/11 01:27:37]

The GetProfile() function is meant to be called on a IO thread. Miranda would
know more.

[Miranda Callahan, 2011/06/11 15:09:08]

I am trying to remember a discussion about this, but I don't remember this --
could you remind me if we ever decided this was going to be the case?  Certainly
at the moment GetProfile() should not be called on the IO Thread -- Scott is
correct that this is probably not thread safe.

See comment above for a suggestion on how to launch an existing profile that's
not currently loaded using asynchronous File Thread methods (and feel free to
steal from the code I wrote to do this from my menu CL from last week if you
want -- the LaunchExistingProfile code).

[sail, 2011/06/13 19:00:01]

Hey Miranda, we didn't discuss this. I just confused about what
ProfileManager::GetProfile() does. I switched the code to use
CreateProfileAsync() and it seems to work well. I'm testing on Windows right
now.

+  Profile* profile = profile_manager->GetProfile(profile_path);
+  if (profile) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(this, &ProfilesSubMenuModel::OpenWindowWithProfile,
+                          profile_path));
+  }
+}
+
+void ProfilesSubMenuModel::OpenWindowWithProfile(FilePath profile_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  Profile* profile = profile_manager->GetProfileByPath(profile_path);
+  if (!profile)
+    return;
+
+  Browser* browser = BrowserList::FindAnyBrowser(profile, false);

[sky, 2011/06/10 16:24:14]

Are you sure you don't want FindTabbedBrowser(profile, true)?

[sail, 2011/06/11 01:27:37]

Ahh, right. Switched to FindTabbedBrowser().
I don't think we want to match incognito windows. Incognito windows will have a
different avatar and it won't be clear that you actually switched to a different
profile.

[Miranda Callahan, 2011/06/11 15:09:08]

Could you rename this FindAnyBrowserWithProfile, to make absolutely clear what's
going on?

[Miranda Callahan, 2011/06/11 15:13:36]

nm -- I see that these are existing methods in BrowserList, and that you've
changed to FindTabbedProfile. Not a fan, but any change belongs in a different
CL.

+  if (browser) {
+    browser->window()->Activate();
+  } else {
+    Browser::NewWindowWithProfile(profile);
+  }
+}
+
+bool ProfilesSubMenuModel::IsCommandIdChecked(int command_id) const {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  size_t index = command_id;
+  if (index < profile_manager->GetNumberOfProfiles()) {
+    FilePath userDataFolder;
+    PathService::Get(chrome::DIR_USER_DATA, &userDataFolder);
+    FilePath profile_path =
+        profile_manager->GetFilePathOfProfileAtIndex(index, userDataFolder);
+
+    return browser_->GetProfile()->GetPath() == profile_path;
+  }
+  return delegate_->IsCommandIdChecked(command_id);
+}
+
+bool ProfilesSubMenuModel::IsCommandIdEnabled(int command_id) const {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  size_t index = command_id;
+  if (index < profile_manager->GetNumberOfProfiles())
+    return true;
+  return delegate_->IsCommandIdEnabled(command_id);
+}
+
+bool ProfilesSubMenuModel::GetAcceleratorForCommandId(
+    int command_id,
+    ui::Accelerator* accelerator) {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  size_t index = command_id;
+  if (index < profile_manager->GetNumberOfProfiles())
+    return false;
+  return delegate_->GetAcceleratorForCommandId(command_id, accelerator);
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // WrenchMenuModel
 
 WrenchMenuModel::WrenchMenuModel(ui::AcceleratorProvider* provider,
                                  Browser* browser)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::SimpleMenuModel(this)),
       provider_(provider),
       browser_(browser),
       tabstrip_model_(browser_->tabstrip_model()) {
   Build();
   UpdateZoomControls();
 
   tabstrip_model_->AddObserver(this);
 
   registrar_.Add(this, NotificationType::ZOOM_LEVEL_CHANGED,
                  Source<HostZoomMap>(browser_->profile()->GetHostZoomMap()));
   registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                  NotificationService::AllSources());
+  registrar_.Add(this, NotificationType::PROFILE_ADDED,
+                 NotificationService::AllSources());
 }
 
 WrenchMenuModel::~WrenchMenuModel() {
   if (tabstrip_model_)
     tabstrip_model_->RemoveObserver(this);
 }
 
 bool WrenchMenuModel::DoesCommandIdDismissMenu(int command_id) const {
   return command_id != IDC_ZOOM_MINUS && command_id != IDC_ZOOM_PLUS;
 }
@@ skipping 57 matching lines @@
         return true;
       }
     }
     default:
       break;
   }
   return false;
 }
 
 void WrenchMenuModel::ExecuteCommand(int command_id) {
-  browser_->ExecuteCommand(command_id);
+  switch (command_id) {
+    case IDC_CREATE_NEW_PROFILE:
+      ProfileManager::CreateMultiProfileAsync();
+      break;
+    default:
+      browser_->ExecuteCommand(command_id);
+      break;
+  }
 }
 
 bool WrenchMenuModel::IsCommandIdChecked(int command_id) const {
   if (command_id == IDC_SHOW_BOOKMARK_BAR) {
     return browser_->profile()->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
   } else if (command_id == IDC_PROFILING_ENABLED) {
     return Profiling::BeingProfiled();
   }
 
   return false;
 }
 
 bool WrenchMenuModel::IsCommandIdEnabled(int command_id) const {
-  if (command_id == IDC_SHOW_BOOKMARK_BAR) {
-    return !browser_->profile()->GetPrefs()->IsManagedPreference(
-        prefs::kEnableBookmarkBar);
+  switch (command_id) {
+    case IDC_SHOW_BOOKMARK_BAR:
+      return !browser_->profile()->GetPrefs()->IsManagedPreference(
+          prefs::kEnableBookmarkBar);
+    case IDC_CREATE_NEW_PROFILE:
+      return true;
+    default:
+      return browser_->command_updater()->IsCommandEnabled(command_id);
   }
-  return browser_->command_updater()->IsCommandEnabled(command_id);
 }
 
 bool WrenchMenuModel::IsCommandIdVisible(int command_id) const {
   if (command_id == IDC_UPGRADE_DIALOG) {
     return UpgradeDetector::GetInstance()->notify_upgrade();
   } else if (command_id == IDC_VIEW_INCOMPATIBILITIES) {
 #if defined(OS_WIN)
     EnumerateModulesModel* loaded_modules =
         EnumerateModulesModel::GetInstance();
     if (loaded_modules->confirmed_bad_modules_detected() <= 0)
@@ skipping 39 matching lines @@
 }
 
 void WrenchMenuModel::Observe(NotificationType type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::ZOOM_LEVEL_CHANGED:
     case NotificationType::NAV_ENTRY_COMMITTED:
       UpdateZoomControls();
       break;
+    case NotificationType::PROFILE_ADDED: {

[sky, 2011/06/10 16:24:14]

This will cause problems if the menu is showing. Seems like it would be better
to rebuild the model before showing and have the ProfilesMenuModel cache the
menu items.

[sail, 2011/06/11 01:27:37]

Agreed, removed.

+      int index = GetIndexOfCommandId(IDC_CREATE_NEW_PROFILE);
+      if (index == -1)
+        index = GetIndexOfCommandId(IDC_PROFILE_MENU);
+      if (index != -1) {
+        RemoveItemAt(index);
+        AddProfilesMenuItemAt(index);
+      }
+      break;
+    }
     default:
       NOTREACHED();
   }
 }
 
 // For testing.
 WrenchMenuModel::WrenchMenuModel()
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::SimpleMenuModel(this)),
       provider_(NULL),
       browser_(NULL),
@@ skipping 56 matching lines @@
 
   AddSeparator();
 
   bookmark_sub_menu_model_.reset(new BookmarkSubMenuModel(this, browser_));
   AddSubMenuWithStringId(IDC_BOOKMARKS_MENU, IDS_BOOKMARKS_MENU,
                          bookmark_sub_menu_model_.get());
   AddItemWithStringId(IDC_SHOW_HISTORY, IDS_SHOW_HISTORY);
   AddItemWithStringId(IDC_SHOW_DOWNLOADS, IDS_SHOW_DOWNLOADS);
   AddSeparator();
 
+#if !defined(OS_CHROMEOS)
+  AddProfilesMenuItemAt(GetItemCount());
+  AddSeparator();
+#endif
+
 #if defined(OS_CHROMEOS)
   AddItemWithStringId(IDC_OPTIONS, IDS_SETTINGS);
 #elif defined(OS_MACOSX)
   AddItemWithStringId(IDC_OPTIONS, IDS_PREFERENCES);
 #elif defined(TOOLKIT_USES_GTK)
   string16 preferences = gtk_util::GetStockPreferencesMenuLabel();
   if (!preferences.empty())
     AddItem(IDC_OPTIONS, preferences);
   else
     AddItemWithStringId(IDC_OPTIONS, IDS_PREFERENCES);
@@ skipping 72 matching lines @@
         &enable_increment, &enable_decrement);
   }
   zoom_label_ = l10n_util::GetStringFUTF16(
       IDS_ZOOM_PERCENT, base::IntToString16(zoom_percent));
 }
 
 string16 WrenchMenuModel::GetSyncMenuLabel() const {
   return sync_ui_util::GetSyncMenuLabel(
       browser_->profile()->GetOriginalProfile()->GetProfileSyncService());
 }
+
+void WrenchMenuModel::AddProfilesMenuItemAt(int index) {
+  if (g_browser_process->profile_manager()->GetNumberOfProfiles() > 1) {

[sky, 2011/06/10 16:24:14]

Seems weird to me to change the type based on contents. Did you run this by Glen
and company?

[sail, 2011/06/11 01:27:37]

Yea, we went through this UI in the profile meeting last week. We can definitely
tweak this once it's checked in.

+    profiles_sub_menu_model_.reset(new ProfilesSubMenuModel(this, browser_));
+    InsertSubMenuWithStringIdAt(index, IDC_PROFILE_MENU, IDS_PROFILES_MENU,
+                                profiles_sub_menu_model_.get());
+  } else {
+    profiles_sub_menu_model_.reset();
+    InsertItemWithStringIdAt(index, IDC_CREATE_NEW_PROFILE,
+                             IDS_PROFILES_CREATE_NEW_PROFILE_OPTION);
+  }
+}