[Linux] Add a People menu item to the global menu bar.

chrome/browser/ui/views/frame/global_menu_bar_x11.cc

 // Copyright 2013 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/views/frame/global_menu_bar_x11.h"
 
 #include <dlfcn.h>
 #include <glib-object.h>
 
 #include "base/debug/leak_annotations.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_info_cache.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tab_restore_service_delegate.h"
 #include "chrome/browser/ui/views/frame/browser_desktop_window_tree_host_x11.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/global_menu_bar_registrar_x11.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/notification_source.h"
 #include "ui/base/accelerators/menu_label_accelerator_util_linux.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
@@ skipping 71 matching lines @@
 const char kPropertyToggleType[] = "toggle-type";
 const char kPropertyToggleState[] = "toggle-state";
 const char kPropertyVisible[] = "visible";
 
 const char kTypeCheckmark[] = "checkmark";
 const char kTypeSeparator[] = "separator";
 
 // Data set on GObjectgs.
 const char kTypeTag[] = "type-tag";
 const char kHistoryItem[] = "history-item";
+const char kProfileId[] = "profile-id";
 
 // The maximum number of most visited items to display.
 const unsigned int kMostVisitedCount = 8;
 
 // The number of recently closed items to get.
 const unsigned int kRecentlyClosedCount = 8;
 
 // Menus more than this many chars long will get trimmed.
 const int kMaximumMenuWidthInChars = 50;
 
 // Constants used in menu definitions.
 const int MENU_SEPARATOR =-1;
 const int MENU_END = -2;
 const int MENU_DISABLED_ID = -3;
 
 // These tag values are used to refer to menu items.
 const int TAG_MOST_VISITED = 1;
 const int TAG_RECENTLY_CLOSED = 2;
 const int TAG_MOST_VISITED_HEADER = 3;
 const int TAG_RECENTLY_CLOSED_HEADER = 4;
+const int TAG_PROFILES = 5;
 
 GlobalMenuBarCommand file_menu[] = {
   { IDS_NEW_TAB, IDC_NEW_TAB },
   { IDS_NEW_WINDOW, IDC_NEW_WINDOW },
   { IDS_NEW_INCOGNITO_WINDOW, IDC_NEW_INCOGNITO_WINDOW },
   { IDS_REOPEN_CLOSED_TABS_LINUX, IDC_RESTORE_TAB },
   { IDS_OPEN_FILE_LINUX, IDC_OPEN_FILE },
   { IDS_OPEN_LOCATION_LINUX, IDC_FOCUS_LOCATION },
 
   { MENU_SEPARATOR, MENU_SEPARATOR },
@@ skipping 88 matching lines @@
 };
 
 GlobalMenuBarCommand help_menu[] = {
 #if defined(GOOGLE_CHROME_BUILD)
   { IDS_FEEDBACK, IDC_FEEDBACK },
 #endif
   { IDS_HELP_PAGE , IDC_HELP_PAGE_VIA_MENU },
   { MENU_END, MENU_END }
 };
 
+GlobalMenuBarCommand profiles_menu[] = {
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+  { MENU_END, MENU_END }
+};
+
 void EnsureMethodsLoaded() {
   static bool attempted_load = false;
   if (attempted_load)
     return;
   attempted_load = true;
 
   void* dbusmenu_lib = dlopen("libdbusmenu-glib.so", RTLD_LAZY);
   if (!dbusmenu_lib)
     dbusmenu_lib = dlopen("libdbusmenu-glib.so.4", RTLD_LAZY);
   if (!dbusmenu_lib)
@@ skipping 59 matching lines @@
 
 GlobalMenuBarX11::GlobalMenuBarX11(BrowserView* browser_view,
                                    BrowserDesktopWindowTreeHostX11* host)
     : browser_(browser_view->browser()),
       profile_(browser_->profile()),
       browser_view_(browser_view),
       host_(host),
       server_(NULL),
       root_item_(NULL),
       history_menu_(NULL),
+      profiles_menu_(NULL),
       top_sites_(NULL),
       tab_restore_service_(NULL),
       weak_ptr_factory_(this) {
   EnsureMethodsLoaded();
 
   if (server_new)
     host_->AddObserver(this);
+
+  avatar_menu_.reset(new AvatarMenu(
+      &g_browser_process->profile_manager()->GetProfileInfoCache(),
+      this,
+      NULL));
+  avatar_menu_->RebuildMenu();
+  BrowserList::AddObserver(this);
 }
 
 GlobalMenuBarX11::~GlobalMenuBarX11() {
   if (server_) {
     Disable();
 
     if (tab_restore_service_)
       tab_restore_service_->RemoveObserver(this);
 
     g_object_unref(server_);
     host_->RemoveObserver(this);
   }
+  BrowserList::RemoveObserver(this);
 }
 
 // static
 std::string GlobalMenuBarX11::GetPathForWindow(unsigned long xid) {
   return base::StringPrintf("/com/canonical/menu/%lX", xid);
 }
 
 DbusmenuMenuitem* GlobalMenuBarX11::BuildSeparator() {
   DbusmenuMenuitem* item = menuitem_new();
   menuitem_property_set(item, kPropertyType, kTypeSeparator);
@@ skipping 25 matching lines @@
   menuitem_property_set(root_item_, kPropertyLabel, "Root");
   menuitem_property_set_bool(root_item_, kPropertyVisible, true);
 
   // First build static menu content.
   BuildStaticMenu(root_item_, IDS_FILE_MENU_LINUX, file_menu);
   BuildStaticMenu(root_item_, IDS_EDIT_MENU_LINUX, edit_menu);
   BuildStaticMenu(root_item_, IDS_VIEW_MENU_LINUX, view_menu);
   history_menu_ = BuildStaticMenu(
       root_item_, IDS_HISTORY_MENU_LINUX, history_menu);
   BuildStaticMenu(root_item_, IDS_TOOLS_MENU_LINUX, tools_menu);
+  profiles_menu_ = BuildStaticMenu(
+      root_item_, IDS_PROFILES_OPTIONS_GROUP_NAME, profiles_menu);
   BuildStaticMenu(root_item_, IDS_HELP_MENU_LINUX, help_menu);
 
   // We have to connect to |history_menu_item|'s "activate" signal instead of
   // |history_menu|'s "show" signal because we are not supposed to modify the
   // menu during "show"
   g_signal_connect(history_menu_, "about-to-show",
                    G_CALLBACK(OnHistoryMenuAboutToShowThunk), this);
 
   for (CommandIDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
        it != id_to_menu_item_.end(); ++it) {
@@ skipping 17 matching lines @@
   top_sites_ = profile_->GetTopSites();
   if (top_sites_) {
     GetTopSitesData();
 
     // Register for notification when TopSites changes so that we can update
     // ourself.
     registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_CHANGED,
                    content::Source<history::TopSites>(top_sites_));
   }
 
+  RebuildProfilesMenu();
+
   server_set_root(server_, root_item_);
 }
 
 void GlobalMenuBarX11::Disable() {
   for (CommandIDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
        it != id_to_menu_item_.end(); ++it) {
     chrome::RemoveCommandObserver(browser_, it->first, this);
   }
   id_to_menu_item_.clear();
 
@@ skipping 146 matching lines @@
     PrefService* prefs = browser_->profile()->GetPrefs();
     // Note: Unlike the GTK version, we don't appear to need to do tricks where
     // we block activation while setting the toggle.
     menuitem_property_set_int(
         it->second,
         kPropertyToggleState,
         prefs->GetBoolean(bookmarks::prefs::kShowBookmarkBar));
   }
 }
 
+void GlobalMenuBarX11::RebuildProfilesMenu() {
+  ClearMenuSection(profiles_menu_, TAG_PROFILES);
+
+  // Don't call avatar_menu_->GetActiveProfileIndex() as the as the index might
+  // be incorrect if RebuildProfilesMenu() is called while we deleting the
+  // active profile and closing all its browser windows.
+  int active_profile_index = -1;
+
+  for (size_t i = 0; i < avatar_menu_->GetNumberOfItems(); ++i) {
+    const AvatarMenu::Item& item = avatar_menu_->GetItemAt(i);
+    base::string16 title = item.name;
+    gfx::ElideString(title, kMaximumMenuWidthInChars, &title);
+
+    DbusmenuMenuitem* menu_item = BuildMenuItem(
+        base::UTF16ToUTF8(title), TAG_PROFILES);
+    g_object_set_data(G_OBJECT(menu_item), kProfileId, GINT_TO_POINTER(i));
+    g_signal_connect(menu_item, "item-activated",
+                     G_CALLBACK(OnProfileItemActivatedThunk), this);
+    menuitem_property_set(menu_item, kPropertyToggleType, kTypeCheckmark);
+    menuitem_property_set_int(menu_item, kPropertyToggleState, item.active);
+
+    if (item.active)
+      active_profile_index = i;
+
+    menuitem_child_add_position(profiles_menu_, menu_item, i);
+    g_object_unref(menu_item);
+  }
+
+  // There is a separator between the list of profiles and the possible actions.
+  int index = avatar_menu_->GetNumberOfItems() + 1;
+
+  DbusmenuMenuitem* edit_profile_item = BuildMenuItem(
+      l10n_util::GetStringUTF8(IDS_PROFILES_MANAGE_BUTTON_LABEL), TAG_PROFILES);
+  DbusmenuMenuitem* create_profile_item = BuildMenuItem(
+      l10n_util::GetStringUTF8(IDS_PROFILES_CREATE_BUTTON_LABEL),
+      TAG_PROFILES);
+
+  // There is no active profile in Guest mode, in which case the action buttons
+  // should be disabled.

[Elliot Glaysher, 2014/10/01 20:27:52]

OK, so I have two windows: one of my normal profile, one with a guest profile. I
just want to verify that this is how this looks from the user point of view
since the menu bar is per window.

1) I have the normal profile active.
2) I click on the profiles menu bar item. Things aren't disabled and there's a
check mark.
3) I switch to the guest mode window.
4) I click on the profiles menu bar item. Things are disabled and there's no
check mark on any of the menu items.

[noms (inactive), 2014/10/01 20:34:14]

Yup, that's it. The checkmark is "which profile is active from this list of
profiles".

On 2014/10/01 20:27:52, Elliot Glaysher wrote:

+  if (active_profile_index >= 0) {
+    g_object_set_data(G_OBJECT(edit_profile_item), kProfileId,
+                      GINT_TO_POINTER(active_profile_index));
+    g_signal_connect(edit_profile_item, "item-activated",
+                     G_CALLBACK(OnEditProfileItemActivatedThunk), this);
+    g_signal_connect(create_profile_item, "item-activated",
+                     G_CALLBACK(OnCreateProfileItemActivatedThunk), this);
+  } else {
+    menuitem_property_set_bool(edit_profile_item, kPropertyEnabled, false);
+    menuitem_property_set_bool(create_profile_item, kPropertyEnabled, false);
+  }
+
+  menuitem_child_add_position(profiles_menu_, edit_profile_item, index++);
+  menuitem_child_add_position(profiles_menu_, create_profile_item, index);
+  g_object_unref(edit_profile_item);
+  g_object_unref(create_profile_item);
+}
+
 int GlobalMenuBarX11::GetIndexOfMenuItemWithTag(DbusmenuMenuitem* menu,
                                                 int tag_id) {
   GList* childs = menuitem_get_children(menu);
   int i = 0;
   for (; childs != NULL; childs = childs->next, i++) {
     int tag =
         GPOINTER_TO_INT(g_object_get_data(G_OBJECT(childs->data), kTypeTag));
     if (tag == tag_id)
       return i;
   }
@@ skipping 23 matching lines @@
   }
 }
 
 // static
 void GlobalMenuBarX11::DeleteHistoryItem(void* void_item) {
   HistoryItem* item =
       reinterpret_cast<GlobalMenuBarX11::HistoryItem*>(void_item);
   delete item;
 }
 
+void GlobalMenuBarX11::OnAvatarMenuChanged(AvatarMenu* avatar_menu) {
+  RebuildProfilesMenu();
+}
+
+void GlobalMenuBarX11::OnBrowserSetLastActive(Browser* browser) {
+  // Rebuild the avatar menu so that the items have the correct active state.
+  avatar_menu_->RebuildMenu();
+  avatar_menu_->ActiveBrowserChanged(browser);
+  RebuildProfilesMenu();
+}
+
 void GlobalMenuBarX11::EnabledStateChangedForCommand(int id, bool enabled) {
   CommandIDMenuItemMap::iterator it = id_to_menu_item_.find(id);
   if (it != id_to_menu_item_.end())
     menuitem_property_set_bool(it->second, kPropertyEnabled, enabled);
 }
 
 void GlobalMenuBarX11::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_TOP_SITES_CHANGED) {
@@ skipping 140 matching lines @@
       tab_restore_service_->LoadTabsFromLastSession();
       tab_restore_service_->AddObserver(this);
 
       // If LoadTabsFromLastSession doesn't load tabs, it won't call
       // TabRestoreServiceChanged(). This ensures that all new windows after
       // the first one will have their menus populated correctly.
       TabRestoreServiceChanged(tab_restore_service_);
     }
   }
 }
+
+void GlobalMenuBarX11::OnProfileItemActivated(DbusmenuMenuitem* sender,
+                                              unsigned int timestamp) {
+  int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(sender), "profile-id"));

[Elliot Glaysher, 2014/10/01 20:27:52]

kProfileId?

[noms (inactive), 2014/10/01 20:34:14]

Oh, of course. Done.
On 2014/10/01 20:27:52, Elliot Glaysher wrote:

+  avatar_menu_->SwitchToProfile(id, false, ProfileMetrics::SWITCH_PROFILE_MENU);
+}
+
+void GlobalMenuBarX11::OnEditProfileItemActivated(DbusmenuMenuitem* sender,
+                                                  unsigned int timestamp) {
+  int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(sender), "profile-id"));

[Elliot Glaysher, 2014/10/01 20:27:52]

kProfileId?

[noms (inactive), 2014/10/01 20:34:14]

Done.

+  avatar_menu_->EditProfile(id);
+}
+
+void GlobalMenuBarX11::OnCreateProfileItemActivated(DbusmenuMenuitem* sender,
+                                                    unsigned int timestamp) {
+  avatar_menu_->AddNewProfile(ProfileMetrics::ADD_NEW_USER_MENU);
+}