Implement "open link as user" context menu entry

chrome/browser/renderer_context_menu/render_view_context_menu.cc

 // Copyright 2014 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/renderer_context_menu/render_view_context_menu.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 19 matching lines @@
 #include "chrome/browser/download/download_stats.h"
 #include "chrome/browser/extensions/devtools_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/media/router/media_router_dialog_controller.h"
 #include "chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.h"
 #include "chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings_factory.h"
 #include "chrome/browser/password_manager/chrome_password_manager_client.h"
 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_avatar_icon_util.h"
+#include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_io_data.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/renderer_context_menu/context_menu_content_type_factory.h"
 #include "chrome/browser/renderer_context_menu/spelling_menu_observer.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
 #include "chrome/browser/ssl/security_state_model.h"
 #include "chrome/browser/tab_contents/retargeting_details.h"
 #include "chrome/browser/translate/chrome_translate_client.h"
 #include "chrome/browser/translate/translate_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_restriction.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/url_constants.h"
@@ skipping 170 matching lines @@
     {59, -1, IDC_SPELLCHECK_ADD_TO_DICTIONARY},
     {60, -1, IDC_SPELLPANEL_TOGGLE},
     {61, -1, IDC_CONTENT_CONTEXT_OPEN_ORIGINAL_IMAGE_NEW_TAB},
     {62, -1, IDC_WRITING_DIRECTION_MENU},
     {63, -1, IDC_WRITING_DIRECTION_DEFAULT},
     {64, -1, IDC_WRITING_DIRECTION_LTR},
     {65, -1, IDC_WRITING_DIRECTION_RTL},
     {66, -1, IDC_CONTENT_CONTEXT_LOAD_ORIGINAL_IMAGE},
     {67, -1, IDC_CONTENT_CONTEXT_FORCESAVEPASSWORD},
     {68, -1, IDC_ROUTE_MEDIA},
+    {69, -1, IDC_OPEN_LINK_IN_PROFILE_FIRST},
     // Add new items here and use |enum_id| from the next line.
     // Also, add new items to RenderViewContextMenuItem enum in histograms.xml.
-    {69, -1, 0},  // Must be the last. Increment |enum_id| when new IDC
+    {70, -1, 0},  // Must be the last. Increment |enum_id| when new IDC
                   // was added.
 };
 
 // Collapses large ranges of ids before looking for UMA enum.
 int CollapseCommandsForUMA(int id) {
   DCHECK(!RenderViewContextMenu::IsContentCustomCommandId(id));
   DCHECK(!ContextMenuMatcher::IsExtensionsCustomCommandId(id));
 
   if (id >= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST &&
       id <= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_LAST) {
     return IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST;
   }
 
   if (id >= IDC_SPELLCHECK_LANGUAGES_FIRST &&
       id <= IDC_SPELLCHECK_LANGUAGES_LAST) {
     return IDC_SPELLCHECK_LANGUAGES_FIRST;
   }
 
   if (id >= IDC_SPELLCHECK_SUGGESTION_0 &&
       id <= IDC_SPELLCHECK_SUGGESTION_LAST) {
     return IDC_SPELLCHECK_SUGGESTION_0;
   }
 
+  if (id >= IDC_OPEN_LINK_IN_PROFILE_FIRST &&
+      id <= IDC_OPEN_LINK_IN_PROFILE_LAST) {
+    return IDC_OPEN_LINK_IN_PROFILE_FIRST;
+  }
+
   return id;
 }
 
 // Returns UMA enum value for command specified by |id| or -1 if not found.
 // |use_specific_context_enum| set to true returns the context_specific_enum_id.
 int FindUMAEnumValueForCommand(int id, UmaEnumIdLookupType enum_lookup_type) {
   if (RenderViewContextMenu::IsContentCustomCommandId(id))
     return 0;
 
   if (ContextMenuMatcher::IsExtensionsCustomCommandId(id))
@@ skipping 35 matching lines @@
   // No patterns means no restriction, so that implicitly matches.
   if (patterns.is_empty())
     return true;
   return patterns.MatchesURL(url);
 }
 
 const GURL& GetDocumentURL(const content::ContextMenuParams& params) {
   return params.frame_url.is_empty() ? params.page_url : params.frame_url;
 }
 
-content::Referrer CreateSaveAsReferrer(
-    const GURL& url,
-    const content::ContextMenuParams& params) {
+content::Referrer CreateReferrer(const GURL& url,
+                                 const content::ContextMenuParams& params) {
   const GURL& referring_url = GetDocumentURL(params);
   return content::Referrer::SanitizeForRequest(
       url,
       content::Referrer(referring_url.GetAsReferrer(), params.referrer_policy));
 }
 
 content::WebContents* GetWebContentsToUse(content::WebContents* web_contents) {
 #if defined(ENABLE_EXTENSIONS)
   // If we're viewing in a MimeHandlerViewGuest, use its embedder WebContents.
   if (extensions::MimeHandlerViewGuest::FromWebContents(web_contents)) {
@@ skipping 18 matching lines @@
           : url_formatter::FormatUrl(
                 url, languages, url_formatter::kFormatUrlOmitNothing,
                 net::UnescapeRule::NONE, nullptr, nullptr, nullptr);
 
   ui::ScopedClipboardWriter scw(ui::CLIPBOARD_TYPE_COPY_PASTE);
   scw.WriteURL(text);
 }
 
 bool g_custom_id_ranges_initialized = false;
 
+void AddIconToLastMenuItem(gfx::Image icon, ui::SimpleMenuModel* menu) {
+  int width = icon.Width();
+  int height = icon.Height();
+  gfx::CalculateFaviconTargetSize(&width, &height);
+  menu->SetIcon(menu->GetItemCount() - 1,
+                profiles::GetSizedAvatarIcon(icon, true, width, height));
+}
+
+void OnProfileCreated(chrome::HostDesktopType desktop_type,
+                      const GURL& link_url,
+                      const content::Referrer& referrer,
+                      Profile* profile,
+                      Profile::CreateStatus status) {
+  if (status == Profile::CREATE_STATUS_INITIALIZED) {
+    Browser* browser = chrome::FindLastActiveWithProfile(profile, desktop_type);
+    chrome::NavigateParams nav_params(browser, link_url,
+                                      ui::PAGE_TRANSITION_LINK);
+    nav_params.disposition = NEW_FOREGROUND_TAB;
+    nav_params.referrer = referrer;
+    nav_params.window_action = chrome::NavigateParams::SHOW_WINDOW;
+    chrome::Navigate(&nav_params);
+  }
+}
+
 }  // namespace
 
 // static
 gfx::Vector2d RenderViewContextMenu::GetOffset(
     RenderFrameHost* render_frame_host) {
   gfx::Vector2d offset;
 #if defined(ENABLE_EXTENSIONS)
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
   WebContents* top_level_web_contents =
@@ skipping 21 matching lines @@
 }
 
 RenderViewContextMenu::RenderViewContextMenu(
     content::RenderFrameHost* render_frame_host,
     const content::ContextMenuParams& params)
     : RenderViewContextMenuBase(render_frame_host, params),
       extension_items_(browser_context_,
                        this,
                        &menu_model_,
                        base::Bind(MenuItemMatchesParams, params_)),
+      profile_link_submenu_model_(this),
       protocol_handler_submenu_model_(this),
       protocol_handler_registry_(
           ProtocolHandlerRegistryFactory::GetForBrowserContext(GetProfile())),
       embedder_web_contents_(GetWebContentsToUse(source_web_contents_)) {
   if (!g_custom_id_ranges_initialized) {
     g_custom_id_ranges_initialized = true;
     SetContentCustomCommandIdRange(IDC_CONTENT_CONTEXT_CUSTOM_FIRST,
                                    IDC_CONTENT_CONTEXT_CUSTOM_LAST);
   }
   set_content_type(ContextMenuContentTypeFactory::Create(
@@ skipping 379 matching lines @@
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENLINKNEWTAB,
                                     IDS_CONTENT_CONTEXT_OPENLINKNEWTAB);
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENLINKNEWWINDOW,
                                     IDS_CONTENT_CONTEXT_OPENLINKNEWWINDOW);
     if (params_.link_url.is_valid()) {
       AppendProtocolHandlerSubMenu();
     }
 
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENLINKOFFTHERECORD,
                                     IDS_CONTENT_CONTEXT_OPENLINKOFFTHERECORD);
+
+    // g_browser_process->profile_manager() is null during unit tests.
+    if (g_browser_process->profile_manager() &&
+        GetProfile()->GetProfileType() == Profile::REGULAR_PROFILE) {
+      ProfileManager* profile_manager = g_browser_process->profile_manager();
+      const ProfileInfoCache& profile_info_cache =
+          profile_manager->GetProfileInfoCache();
+
+      // Find all regular profiles other than the current one which have at
+      // least one open window.
+      std::vector<size_t> target_profiles;
+      std::vector<size_t> all_target_profiles;
+      chrome::HostDesktopType desktop_type =
+          chrome::GetHostDesktopTypeForNativeView(
+              source_web_contents_->GetNativeView());
+
+      const size_t profile_count = profile_info_cache.GetNumberOfProfiles();
+      for (size_t profile_index = 0; profile_index < profile_count;
+           ++profile_index) {
+        base::FilePath profile_path =
+            profile_info_cache.GetPathOfProfileAtIndex(profile_index);
+        Profile* profile = profile_manager->GetProfileByPath(profile_path);
+        if ((profile != GetProfile()) &&
+            !profile_info_cache.IsOmittedProfileAtIndex(profile_index)) {
+          all_target_profiles.push_back(profile_index);
+          if (chrome::FindLastActiveWithProfile(profile, desktop_type))
+            target_profiles.push_back(profile_index);
+        }
+      }
+
+      if (target_profiles.size() == 1 ||
+          (target_profiles.size() == 2 && all_target_profiles.size() == 2)) {

[Peter Kasting, 2015/10/13 18:59:00]

This doesn't seem to match the slides.  Unless I'm confused, this implements:

  * If only one profile active, hide menu items.
  * If two profiles active, show top-level menu item.
  * If three profiles active and there are only three total profiles, show
top-level menu item.
  * Otherwise, show submenu.

I don't know why the third bullet is there.

[jochen (gone - plz use gerrit), 2015/10/13 19:07:30]

that's step 2 b i) in the slides

[Peter Kasting, 2015/10/13 19:16:38]

No, it's not 2bi.  2bi is the second bullet I wrote:

  if (target_profiles.size() == 1) ...

The problem is the size 2 case, which deals with having _3_ profiles.  That's
supposed to go in a submenu.

Unless the slides are incredibly confusing and "2 profiles active" and "only 2
profiles" are counting different things (active versus total profiles), in which
case (a) the slides need to be reworded, and (b) this code is wrong anyway
because you don't show both other profiles in the (target_profiles.size() == 1
&& all_target_profiles.size() == 2) case.

I think the rules on this are too complicated.  You should do the algorithm you
originally set out to do:
* Only show profiles from active windows.
* If one such profile, use a top-level slot.  Otherwise use a context menu.

This is simpler to implement, simpler to reason about as a user, and won't spam
you with tons of profile links you don't care about.  I don't find Alex' user
switcher argument compelling unless we want to show all other profiles all the
time.  The inconsistency of sometimes showing them all and sometimes not is a
much bigger disadvantage than the consistency with the switcher in some cases is
an advantage.  If you want to show all other profiles every time there's more
than one total profile currently open, I will support that.

+        for (size_t profile_index : target_profiles) {

[Peter Kasting, 2015/10/13 18:59:00]

In extreme edge cases, this might add more profiles than we have command IDs
reserved.

[jochen (gone - plz use gerrit), 2015/10/13 19:50:22]

added a bail-out

+          menu_model_.AddItem(
+              IDC_OPEN_LINK_IN_PROFILE_FIRST + profile_index,
+              l10n_util::GetStringFUTF16(
+                  IDS_CONTENT_CONTEXT_OPENLINKINPROFILE,
+                  profile_info_cache.GetNameOfProfileAtIndex(profile_index)));
+          AddIconToLastMenuItem(
+              profile_info_cache.GetAvatarIconOfProfileAtIndex(profile_index),
+              &menu_model_);
+        }
+      } else if (!target_profiles.empty()) {
+        for (size_t profile_index : all_target_profiles) {

[Peter Kasting, 2015/10/13 18:59:00]

I don't think we should do what this implements.

This basically says that at some point we should show targets for all profiles,
even ones that aren't open.  I don't think we should ever do that.  If we should
do that, we should do it all the time.  I really don't think we should switch to
this behavior once we reach some threshold number of open profiles.

[jochen (gone - plz use gerrit), 2015/10/13 19:07:30]

Alex' argument is that this matches what the user switcher menu will show. If
you only have one additional profile, the desire to not show too many entries
trumps being consistent with the user switcher menu.

+          profile_link_submenu_model_.AddItem(
+              IDC_OPEN_LINK_IN_PROFILE_FIRST + profile_index,
+              profile_info_cache.GetNameOfProfileAtIndex(profile_index));
+          AddIconToLastMenuItem(
+              profile_info_cache.GetAvatarIconOfProfileAtIndex(profile_index),
+              &profile_link_submenu_model_);
+        }
+        menu_model_.AddSubMenuWithStringId(
+            IDC_CONTENT_CONTEXT_OPENLINKINPROFILE,
+            IDS_CONTENT_CONTEXT_OPENLINKINPROFILES,
+            &profile_link_submenu_model_);
+      }
+    }
+    menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_SAVELINKAS,
                                     IDS_CONTENT_CONTEXT_SAVELINKAS);
   }
 
   menu_model_.AddItemWithStringId(
       IDC_CONTENT_CONTEXT_COPYLINKLOCATION,
       params_.link_url.SchemeIs(url::kMailToScheme) ?
           IDS_CONTENT_CONTEXT_COPYEMAILADDRESS :
           IDS_CONTENT_CONTEXT_COPYLINKLOCATION);
 }
@@ skipping 308 matching lines @@
 
   // Extension items.
   if (ContextMenuMatcher::IsExtensionsCustomCommandId(id))
     return extension_items_.IsCommandIdEnabled(id);
 
   if (id >= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST &&
       id <= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_LAST) {
     return true;
   }
 
+  if (id >= IDC_OPEN_LINK_IN_PROFILE_FIRST &&
+      id <= IDC_OPEN_LINK_IN_PROFILE_LAST) {
+    return params_.link_url.is_valid();
+  }
+
   IncognitoModePrefs::Availability incognito_avail =
       IncognitoModePrefs::GetAvailability(prefs);
   switch (id) {
     case IDC_BACK:
       return embedder_web_contents_->GetController().CanGoBack();
 
     case IDC_FORWARD:
       return embedder_web_contents_->GetController().CanGoForward();
 
     case IDC_RELOAD: {
@@ skipping 52 matching lines @@
              // There are some application locales which can't be used as a
              // target language for translation.
              translate::TranslateDownloadManager::IsSupportedLanguage(
                  target_lang) &&
              // Disable on the Instant Extended NTP.
              !search::IsInstantNTP(embedder_web_contents_);
     }
 
     case IDC_CONTENT_CONTEXT_OPENLINKNEWTAB:
     case IDC_CONTENT_CONTEXT_OPENLINKNEWWINDOW:
+    case IDC_CONTENT_CONTEXT_OPENLINKINPROFILE:
       return params_.link_url.is_valid();
 
     case IDC_CONTENT_CONTEXT_COPYLINKLOCATION:
       return params_.unfiltered_link_url.is_valid();
 
     case IDC_CONTENT_CONTEXT_SAVELINKAS: {
       PrefService* local_state = g_browser_process->local_state();
       DCHECK(local_state);
       // Test if file-selection dialogs are forbidden by policy.
       if (!local_state->GetBoolean(prefs::kAllowFileSelectionDialogs))
@@ skipping 254 matching lines @@
     int handlerIndex = id - IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST;
     WindowOpenDisposition disposition =
         ForceNewTabDispositionFromEventFlags(event_flags);
     OpenURL(handlers[handlerIndex].TranslateUrl(params_.link_url),
             GetDocumentURL(params_),
             disposition,
             ui::PAGE_TRANSITION_LINK);
     return;
   }
 
+  if (id >= IDC_OPEN_LINK_IN_PROFILE_FIRST &&
+      id <= IDC_OPEN_LINK_IN_PROFILE_LAST) {
+    ProfileManager* profile_manager = g_browser_process->profile_manager();
+    const ProfileInfoCache& profile_info_cache =
+        profile_manager->GetProfileInfoCache();
+
+    base::FilePath profile_path = profile_info_cache.GetPathOfProfileAtIndex(
+        id - IDC_OPEN_LINK_IN_PROFILE_FIRST);
+    chrome::HostDesktopType desktop_type =
+        chrome::GetHostDesktopTypeForNativeView(
+            source_web_contents_->GetNativeView());
+
+    profiles::SwitchToProfile(
+        profile_path, desktop_type, false /* always_create */,

[Peter Kasting, 2015/10/13 18:59:00]

Nit: Omit the param comment here; it actually misled me into thinking you were
doing the opposite of what you're doing, and there aren't multiple booleans here
so there's no need to distinguish them.

[jochen (gone - plz use gerrit), 2015/10/13 19:50:22]

done

+        base::Bind(OnProfileCreated, desktop_type, params_.link_url,
+                   CreateReferrer(params_.link_url, params_)),
+        ProfileMetrics::CONTEXT_MENU);
+    return;
+  }
+
   switch (id) {
     case IDC_CONTENT_CONTEXT_OPENLINKNEWTAB: {
       Browser* browser =
           chrome::FindBrowserWithWebContents(source_web_contents_);
       OpenURL(params_.link_url,
               GetDocumentURL(params_),
               !browser || browser->is_app() ?
                   NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB,
               ui::PAGE_TRANSITION_LINK);
       break;
     }
     case IDC_CONTENT_CONTEXT_OPENLINKNEWWINDOW:
       OpenURL(params_.link_url,
               GetDocumentURL(params_),
               NEW_WINDOW,
               ui::PAGE_TRANSITION_LINK);
       break;
 
     case IDC_CONTENT_CONTEXT_OPENLINKOFFTHERECORD:
       OpenURL(params_.link_url, GURL(), OFF_THE_RECORD,
               ui::PAGE_TRANSITION_LINK);
       break;
 
     case IDC_CONTENT_CONTEXT_SAVELINKAS: {
       RecordDownloadSource(DOWNLOAD_INITIATED_BY_CONTEXT_MENU);
       const GURL& url = params_.link_url;
-      content::Referrer referrer = CreateSaveAsReferrer(url, params_);
+      content::Referrer referrer = CreateReferrer(url, params_);
       DownloadManager* dlm =
           BrowserContext::GetDownloadManager(browser_context_);
       scoped_ptr<DownloadUrlParameters> dl_params(
           DownloadUrlParameters::FromWebContents(source_web_contents_, url));
       dl_params->set_referrer(referrer);
       dl_params->set_referrer_encoding(params_.frame_charset);
       dl_params->set_suggested_name(params_.suggested_filename);
       dl_params->set_prompt(true);
       dlm->DownloadUrl(dl_params.Pass());
       break;
     }
 
     case IDC_CONTENT_CONTEXT_SAVEAVAS:
     case IDC_CONTENT_CONTEXT_SAVEIMAGEAS: {
       bool is_large_data_url = params_.has_image_contents &&
           params_.src_url.is_empty();
       if (params_.media_type == WebContextMenuData::MediaTypeCanvas ||
           (params_.media_type == WebContextMenuData::MediaTypeImage &&
               is_large_data_url)) {
         source_web_contents_->GetRenderViewHost()->SaveImageAt(
           params_.x, params_.y);
       } else {
         RecordDownloadSource(DOWNLOAD_INITIATED_BY_CONTEXT_MENU);
         const GURL& url = params_.src_url;
-        content::Referrer referrer = CreateSaveAsReferrer(url, params_);
+        content::Referrer referrer = CreateReferrer(url, params_);
 
         std::string headers;
         DataReductionProxyChromeSettings* settings =
             DataReductionProxyChromeSettingsFactory::GetForBrowserContext(
                 browser_context_);
         if (params_.media_type == WebContextMenuData::MediaTypeImage &&
             settings && settings->CanUseDataReductionProxy(params_.src_url)) {
           headers = data_reduction_proxy::kDataReductionPassThroughHeader;
         }
 
@@ skipping 435 matching lines @@
   source_web_contents_->GetRenderViewHost()->
       ExecuteMediaPlayerActionAtLocation(location, action);
 }
 
 void RenderViewContextMenu::PluginActionAt(
     const gfx::Point& location,
     const WebPluginAction& action) {
   source_web_contents_->GetRenderViewHost()->
       ExecutePluginActionAtLocation(location, action);
 }