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;
+      bool more_than_one_profile_open = false;
+      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)) {
+          target_profiles.push_back(profile_index);
+          if (chrome::FindLastActiveWithProfile(profile, desktop_type))
+            more_than_one_profile_open = true;
+        }
+      }
+
+      if (more_than_one_profile_open) {
+        if (target_profiles.size() == 1) {
+          size_t profile_index = target_profiles.at(0);

[Peter Kasting, 2015/10/13 20:23:53]

Nit: target_profiles[0]

YOu can inline this into the next statement too.

[jochen (gone - plz use gerrit), 2015/10/20 14:07:23]

done

+          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()) {

[Peter Kasting, 2015/10/13 20:23:53]

This condition can never fail.

The best thing to do is probably to replace this with "} else if
(more_than_one_profile_open) {" and remove the outer conditional here entirely.

[jochen (gone - plz use gerrit), 2015/10/20 14:07:23]

I replaced it with } else { - even if target_profiles.size() == 1, we only want
to show an entry if more than one profile is currently open.

+          for (size_t profile_index : target_profiles) {
+            // In extreme cases, we might have more profiles than available
+            // command ids. In that case, just stop creating new entries - the
+            // menu is probably useless at this point already.
+            if (IDC_OPEN_LINK_IN_PROFILE_FIRST + profile_index >
+                IDC_OPEN_LINK_IN_PROFILE_LAST)
+              break;
+            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,
+        base::Bind(OnProfileCreated, desktop_type, params_.link_url,
+                   CreateReferrer(params_.link_url, params_)),
+        ProfileMetrics::SWITCH_PROFILE_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);
 }