| // Copyright 2016 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/chromeos/arc/arc_external_protocol_dialog.h" |
| |
| #include <algorithm> |
| #include <map> |
| |
| #include "base/functional/bind.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/metrics/histogram_functions.h" |
| #include "chrome/app/vector_icons/vector_icons.h" |
| #include "chrome/browser/apps/link_capturing/link_capturing_navigation_throttle.h" |
| #include "chrome/browser/apps/link_capturing/metrics/intent_handling_metrics.h" |
| #include "chrome/browser/chromeos/arc/arc_web_contents_data.h" |
| #include "chrome/browser/sharing/click_to_call/click_to_call_metrics.h" |
| #include "chrome/browser/sharing/click_to_call/click_to_call_ui_controller.h" |
| #include "chrome/browser/sharing/click_to_call/click_to_call_utils.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "chrome/browser/ui/browser_finder.h" |
| #include "chrome/browser/ui/browser_window.h" |
| #include "chrome/browser/ui/intent_picker_tab_helper.h" |
| #include "chromeos/ash/experiences/arc/intent_helper/arc_intent_helper_package.h" |
| #include "components/sharing_message/sharing_target_device_info.h" |
| #include "components/sync/protocol/sync_enums.pb.h" |
| #include "components/sync_device_info/device_info.h" |
| #include "content/public/browser/browser_context.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/page_navigator.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/common/referrer.h" |
| #include "third_party/skia/include/core/SkColor.h" |
| #include "ui/base/models/image_model.h" |
| #include "ui/base/window_open_disposition.h" |
| #include "ui/color/color_id.h" |
| #include "ui/gfx/paint_vector_icon.h" |
| #include "url/gurl.h" |
| |
| using content::WebContents; |
| |
| namespace arc { |
| |
| namespace { |
| |
| // The proxy activity for launching an ARC IME's settings activity. These names |
| // have to be in sync with the ones used in ArcInputMethodManagerService.java on |
| // the container side. Otherwise, the picker dialog might pop up unexpectedly. |
| constexpr char kPackageForOpeningArcImeSettingsPage[] = |
| "org.chromium.arc.applauncher"; |
| constexpr char kActivityForOpeningArcImeSettingsPage[] = |
| "org.chromium.arc.applauncher.InputMethodSettingsActivity"; |
| |
| // Size of device icons in DIPs. |
| constexpr int kDeviceIconSize = 16; |
| |
| using IntentPickerResponseWithDevices = |
| base::OnceCallback<void(std::vector<SharingTargetDeviceInfo> devices, |
| apps::IntentPickerBubbleType intent_picker_type, |
| const std::string& launch_name, |
| apps::PickerEntryType entry_type, |
| apps::IntentPickerCloseReason close_reason, |
| bool should_persist)>; |
| |
| // Creates an icon for a specific |device_form_factor|. |
| ui::ImageModel CreateDeviceIcon( |
| const syncer::DeviceInfo::FormFactor device_form_factor) { |
| const gfx::VectorIcon& icon = |
| device_form_factor == syncer::DeviceInfo::FormFactor::kTablet |
| ? kTabletIcon |
| : kHardwareSmartphoneIcon; |
| return ui::ImageModel::FromVectorIcon(icon, ui::kColorIcon, kDeviceIconSize); |
| } |
| |
| // Adds |devices| to |picker_entries| and returns the new list. The devices are |
| // added to the beginning of the list. |
| std::vector<apps::IntentPickerAppInfo> AddDevices( |
| const std::vector<SharingTargetDeviceInfo>& devices, |
| std::vector<apps::IntentPickerAppInfo> picker_entries) { |
| DCHECK(!devices.empty()); |
| |
| // First add all devices to the list. |
| std::vector<apps::IntentPickerAppInfo> all_entries; |
| for (const SharingTargetDeviceInfo& device : devices) { |
| all_entries.emplace_back(apps::PickerEntryType::kDevice, |
| CreateDeviceIcon(device.form_factor()), |
| device.guid(), device.client_name()); |
| } |
| |
| // Append the previous list by moving its elements. |
| for (auto& entry : picker_entries) { |
| all_entries.emplace_back(std::move(entry)); |
| } |
| |
| return all_entries; |
| } |
| |
| // Adds remote devices to |app_info| and shows the intent picker dialog if there |
| // is at least one app or device to choose from. |
| bool MaybeAddDevicesAndShowPicker( |
| const GURL& url, |
| const std::optional<url::Origin>& initiating_origin, |
| WebContents* web_contents, |
| std::vector<apps::IntentPickerAppInfo> app_info, |
| bool stay_in_chrome, |
| bool show_remember_selection, |
| IntentPickerResponseWithDevices callback) { |
| Browser* browser = |
| web_contents ? chrome::FindBrowserWithTab(web_contents) : nullptr; |
| if (!browser) { |
| return false; |
| } |
| |
| bool has_apps = !app_info.empty(); |
| bool has_devices = false; |
| |
| auto bubble_type = apps::IntentPickerBubbleType::kExternalProtocol; |
| ClickToCallUiController* controller = nullptr; |
| std::vector<SharingTargetDeviceInfo> devices; |
| |
| if (ShouldOfferClickToCallForURL(web_contents->GetBrowserContext(), url)) { |
| bubble_type = apps::IntentPickerBubbleType::kClickToCall; |
| controller = |
| ClickToCallUiController::GetOrCreateFromWebContents(web_contents); |
| devices = controller->GetDevices(); |
| has_devices = !devices.empty(); |
| if (has_devices) { |
| app_info = AddDevices(devices, std::move(app_info)); |
| } |
| } |
| |
| if (app_info.empty()) { |
| return false; |
| } |
| |
| IntentPickerTabHelper::ShowOrHideIcon( |
| web_contents, |
| bubble_type == apps::IntentPickerBubbleType::kExternalProtocol); |
| browser->window()->ShowIntentPickerBubble( |
| std::move(app_info), stay_in_chrome, show_remember_selection, bubble_type, |
| initiating_origin, |
| base::BindOnce(std::move(callback), std::move(devices), bubble_type)); |
| |
| if (controller) { |
| controller->OnIntentPickerShown(has_devices, has_apps); |
| } |
| |
| return true; |
| } |
| |
| void CloseTabIfNeeded(base::WeakPtr<WebContents> web_contents, |
| bool safe_to_bypass_ui) { |
| if (!web_contents) { |
| return; |
| } |
| |
| if (web_contents->GetController().IsInitialNavigation() || |
| safe_to_bypass_ui) { |
| web_contents->ClosePage(); |
| } |
| } |
| |
| // Tells whether or not Chrome is an app candidate for the current navigation. |
| bool IsChromeAnAppCandidate( |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& |
| handlers) { |
| for (const auto& handler : handlers) { |
| if (handler.package_name == kArcIntentHelperPackageName) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // Returns true if |handlers| only contains Chrome as an app candidate for the |
| // current navigation. |
| bool IsChromeOnlyAppCandidate( |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& |
| handlers) { |
| return handlers.size() == 1 && IsChromeAnAppCandidate(handlers); |
| } |
| |
| // Returns true if the |handler| is for opening ARC IME settings page. |
| bool ForOpeningArcImeSettingsPage( |
| const ArcIntentHelperMojoDelegate::IntentHandlerInfo& handler) { |
| return (handler.package_name == kPackageForOpeningArcImeSettingsPage) && |
| (handler.activity_name == kActivityForOpeningArcImeSettingsPage); |
| } |
| |
| // Shows |url| in the current tab. |
| void OpenUrlInChrome(base::WeakPtr<WebContents> web_contents, const GURL& url) { |
| if (!web_contents) { |
| return; |
| } |
| |
| const ui::PageTransition page_transition_type = |
| ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK); |
| constexpr bool kIsRendererInitiated = false; |
| const content::OpenURLParams params( |
| url, |
| content::Referrer(web_contents->GetLastCommittedURL(), |
| network::mojom::ReferrerPolicy::kDefault), |
| WindowOpenDisposition::CURRENT_TAB, page_transition_type, |
| kIsRendererInitiated); |
| web_contents->OpenURL(params, /*navigation_handle_callback=*/{}); |
| } |
| |
| ArcIntentHelperMojoDelegate::IntentInfo CreateIntentInfo(const GURL& url, |
| bool ui_bypassed) { |
| // Create an intent with action VIEW, the |url| we are redirecting the user to |
| // and a flag that tells whether or not the user interacted with the picker UI |
| |
| constexpr char kArcIntentActionView[] = "org.chromium.arc.intent.action.VIEW"; |
| return ArcIntentHelperMojoDelegate::IntentInfo( |
| kArcIntentActionView, /*categories=*/std::nullopt, url.spec(), |
| /*type=*/std::nullopt, ui_bypassed, /*extras=*/std::nullopt); |
| } |
| |
| // Sends |url| to ARC. |
| void HandleUrlInArc(base::WeakPtr<WebContents> web_contents, |
| const GurlAndActivityInfo& url_and_activity, |
| bool ui_bypassed, |
| ArcIntentHelperMojoDelegate* mojo_delegate) { |
| // ArcIntentHelperMojoDelegate is already varified non-null. |
| DCHECK(mojo_delegate); |
| |
| // We want to inform ARC about whether or not the user interacted with the |
| // picker UI, also since we want to be more explicit about the package and |
| // activity we are using, we are relying in HandleIntent() to comunicate back |
| // to ARC. |
| if (mojo_delegate->HandleIntent( |
| CreateIntentInfo(url_and_activity.first, ui_bypassed), |
| ArcIntentHelperMojoDelegate::ActivityName( |
| std::move(url_and_activity.second.package_name), |
| std::move(url_and_activity.second.activity_name)))) { |
| CloseTabIfNeeded(web_contents, ui_bypassed); |
| } |
| } |
| |
| // A helper function called by GetAction(). |
| GetActionResult GetActionInternal( |
| const GURL& original_url, |
| const ArcIntentHelperMojoDelegate::IntentHandlerInfo& handler, |
| GurlAndActivityInfo* out_url_and_activity_name) { |
| if (handler.fallback_url.has_value()) { |
| *out_url_and_activity_name = |
| GurlAndActivityInfo(GURL(*handler.fallback_url), |
| ArcIntentHelperMojoDelegate::ActivityName( |
| handler.package_name, handler.activity_name)); |
| if (handler.package_name == kArcIntentHelperPackageName) { |
| // Since |package_name| is "Chrome", and |fallback_url| is not null, the |
| // URL must be either http or https. Check it just in case, and if not, |
| // fallback to HANDLE_URL_IN_ARC; |
| if (out_url_and_activity_name->first.SchemeIsHTTPOrHTTPS()) { |
| return GetActionResult::OPEN_URL_IN_CHROME; |
| } |
| |
| LOG(WARNING) << "Failed to handle " << out_url_and_activity_name->first |
| << " in Chrome. Falling back to ARC..."; |
| } |
| // |fallback_url| which Chrome doesn't support is passed (e.g. market:). |
| return GetActionResult::HANDLE_URL_IN_ARC; |
| } |
| |
| // Unlike |handler->fallback_url|, the |original_url| should always be handled |
| // in ARC since it's external to Chrome. |
| *out_url_and_activity_name = GurlAndActivityInfo( |
| original_url, ArcIntentHelperMojoDelegate::ActivityName( |
| handler.package_name, handler.activity_name)); |
| return GetActionResult::HANDLE_URL_IN_ARC; |
| } |
| |
| // Gets an action that should be done when ARC has the |handlers| for the |
| // |original_url| and the user selects |selected_app_index|. When the user |
| // hasn't selected any app, |selected_app_index| must be set to |
| // |handlers.size()|. |
| // |
| // When the returned action is either OPEN_URL_IN_CHROME or HANDLE_URL_IN_ARC, |
| // |out_url_and_activity_name| is filled accordingly. |
| // |
| // |in_out_safe_to_bypass_ui| is used to reflect whether or not we should |
| // display the UI: it initially informs whether or not this navigation was |
| // initiated within ARC, and then gets double-checked and used to store whether |
| // or not the user can safely bypass the UI. |
| GetActionResult GetAction( |
| const GURL& original_url, |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& handlers, |
| size_t selected_app_index, |
| GurlAndActivityInfo* out_url_and_activity_name, |
| bool* in_out_safe_to_bypass_ui) { |
| DCHECK(out_url_and_activity_name); |
| DCHECK(!handlers.empty()); |
| |
| if (selected_app_index == handlers.size()) { |
| // The user hasn't made the selection yet. |
| |
| // If |handlers| has only one element and either of the following conditions |
| // is met, open the URL in Chrome or ARC without showing the picker UI. |
| // 1) its package is "Chrome", open the fallback URL in the current tab |
| // without showing the dialog. |
| // 2) its package is not "Chrome" but it has been marked as |
| // |in_out_safe_to_bypass_ui|, this means that we trust the current tab |
| // since its content was originated from ARC. |
| // 3) its package and activity are for opening ARC IME settings page. The |
| // activity is launched with an explicit user action in chrome://settings. |
| if (handlers.size() == 1) { |
| const GetActionResult internal_result = GetActionInternal( |
| original_url, handlers[0], out_url_and_activity_name); |
| |
| if ((internal_result == GetActionResult::HANDLE_URL_IN_ARC && |
| (*in_out_safe_to_bypass_ui || |
| ForOpeningArcImeSettingsPage(handlers[0]))) || |
| internal_result == GetActionResult::OPEN_URL_IN_CHROME) { |
| // Make sure the |in_out_safe_to_bypass_ui| flag is actually marked, its |
| // maybe not important for OPEN_URL_IN_CHROME but just for consistency. |
| *in_out_safe_to_bypass_ui = true; |
| return internal_result; |
| } |
| } |
| |
| // Since we have 2+ app candidates we should display the UI, unless there is |
| // an already preferred app. |is_preferred| will never be true unless the |
| // user explicitly marked it as such. |
| *in_out_safe_to_bypass_ui = false; |
| for (size_t i = 0; i < handlers.size(); ++i) { |
| const ArcIntentHelperMojoDelegate::IntentHandlerInfo& handler = |
| handlers[i]; |
| if (!handler.is_preferred) { |
| continue; |
| } |
| // This is another way to bypass the UI, since the user already expressed |
| // some sort of preference. |
| *in_out_safe_to_bypass_ui = true; |
| // A preferred activity is found. Decide how to open it, either in Chrome |
| // or ARC. |
| return GetActionInternal(original_url, handler, |
| out_url_and_activity_name); |
| } |
| // Ask the user to pick one. |
| return GetActionResult::ASK_USER; |
| } |
| |
| // The user already made a selection so this should be false. |
| *in_out_safe_to_bypass_ui = false; |
| return GetActionInternal(original_url, handlers[selected_app_index], |
| out_url_and_activity_name); |
| } |
| |
| // Returns true if the |url| is safe to be forwarded to ARC without showing the |
| // disambig dialog, besides having this flag set we need to check that there is |
| // only one app candidate, this is enforced via GetAction(). Any navigation |
| // coming from ARC via ChromeShellDelegate MUST be marked as such. |
| // |
| // Mark as not "safe" (aka return false) on the contrary, most likely those |
| // cases will require the user to pass thru the intent picker UI. |
| bool GetAndResetSafeToRedirectToArcWithoutUserConfirmationFlag( |
| WebContents* web_contents) { |
| const char* key = |
| arc::ArcWebContentsData::ArcWebContentsData::kArcTransitionFlag; |
| arc::ArcWebContentsData* arc_data = |
| static_cast<arc::ArcWebContentsData*>(web_contents->GetUserData(key)); |
| if (!arc_data) { |
| return false; |
| } |
| |
| web_contents->RemoveUserData(key); |
| return true; |
| } |
| |
| void HandleDeviceSelection(WebContents* web_contents, |
| const std::vector<SharingTargetDeviceInfo>& devices, |
| const std::string& device_guid, |
| const GURL& url) { |
| if (!web_contents) { |
| return; |
| } |
| |
| const auto it = |
| std::ranges::find(devices, device_guid, &SharingTargetDeviceInfo::guid); |
| CHECK(it != devices.end()); |
| const SharingTargetDeviceInfo& device = *it; |
| |
| ClickToCallUiController::GetOrCreateFromWebContents(web_contents) |
| ->OnDeviceSelected(url.GetContent(), device, |
| SharingClickToCallEntryPoint::kLeftClickLink); |
| } |
| |
| // Handles |url| if possible. Returns true if it is actually handled. |
| bool HandleUrl( |
| base::WeakPtr<WebContents> web_contents, |
| const GURL& url, |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& handlers, |
| size_t selected_app_index, |
| GetActionResult* out_result, |
| bool safe_to_bypass_ui, |
| ArcIntentHelperMojoDelegate* mojo_delegate) { |
| GurlAndActivityInfo url_and_activity_name( |
| GURL(), |
| ArcIntentHelperMojoDelegate::ActivityName{/*package=*/std::string(), |
| /*activity=*/std::string()}); |
| |
| const GetActionResult result = |
| GetAction(url, handlers, selected_app_index, &url_and_activity_name, |
| &safe_to_bypass_ui); |
| if (out_result) { |
| *out_result = result; |
| } |
| |
| switch (result) { |
| case GetActionResult::OPEN_URL_IN_CHROME: |
| OpenUrlInChrome(web_contents, url_and_activity_name.first); |
| return true; |
| case GetActionResult::HANDLE_URL_IN_ARC: |
| HandleUrlInArc(web_contents, url_and_activity_name, safe_to_bypass_ui, |
| mojo_delegate); |
| return true; |
| case GetActionResult::ASK_USER: |
| break; |
| } |
| |
| return false; |
| } |
| |
| // Returns a fallback http(s) in |handlers| which Chrome can handle. Returns |
| // an empty GURL if none found. |
| GURL GetUrlToNavigateOnDeactivate( |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& |
| handlers) { |
| const GURL empty_url; |
| for (size_t i = 0; i < handlers.size(); ++i) { |
| GurlAndActivityInfo url_and_package( |
| GURL(), |
| ArcIntentHelperMojoDelegate::ActivityName{/*package=*/std::string(), |
| /*activity=*/std::string()}); |
| if (GetActionInternal(empty_url, handlers[i], &url_and_package) == |
| GetActionResult::OPEN_URL_IN_CHROME) { |
| DCHECK(url_and_package.first.SchemeIsHTTPOrHTTPS()); |
| return url_and_package.first; |
| } |
| } |
| return empty_url; // nothing found. |
| } |
| |
| // Called when the dialog is just deactivated without pressing one of the |
| // buttons. |
| void OnIntentPickerDialogDeactivated( |
| base::WeakPtr<WebContents> web_contents, |
| bool safe_to_bypass_ui, |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& |
| handlers) { |
| const GURL url_to_open_in_chrome = GetUrlToNavigateOnDeactivate(handlers); |
| if (url_to_open_in_chrome.is_empty()) { |
| CloseTabIfNeeded(web_contents, safe_to_bypass_ui); |
| } else { |
| OpenUrlInChrome(web_contents, url_to_open_in_chrome); |
| } |
| } |
| |
| size_t GetAppIndex( |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& |
| app_candidates, |
| const std::string& selected_app_package) { |
| for (size_t i = 0; i < app_candidates.size(); ++i) { |
| if (app_candidates[i].package_name == selected_app_package) { |
| return i; |
| } |
| } |
| return app_candidates.size(); |
| } |
| |
| // Called when the dialog is closed. Note that once we show the UI, we should |
| // never show the Chrome OS' fallback dialog. |
| void OnIntentPickerClosed( |
| base::WeakPtr<WebContents> web_contents, |
| const GURL& url, |
| bool safe_to_bypass_ui, |
| std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo> handlers, |
| std::unique_ptr<ArcIntentHelperMojoDelegate> mojo_delegate, |
| std::vector<SharingTargetDeviceInfo> devices, |
| apps::IntentPickerBubbleType intent_picker_type, |
| const std::string& selected_app_package, |
| apps::PickerEntryType entry_type, |
| apps::IntentPickerCloseReason reason, |
| bool should_persist) { |
| // ArcIntentHelperMojoDelegate is already varified non-null. |
| DCHECK(mojo_delegate); |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| // Even if ArcExternalProtocolDialog shares the same icon on the omnibox as an |
| // http(s) request (via AppsNavigationThrottle), the UI here shouldn't stay in |
| // the omnibox since the decision should be taken right away in a kind of |
| // blocking fashion. |
| auto* context = web_contents ? web_contents->GetBrowserContext() : nullptr; |
| |
| if (web_contents) { |
| if (intent_picker_type == apps::IntentPickerBubbleType::kClickToCall) { |
| ClickToCallUiController::GetOrCreateFromWebContents(web_contents.get()) |
| ->OnIntentPickerClosed(); |
| } else { |
| IntentPickerTabHelper::ShowOrHideIcon(web_contents.get(), |
| /*should_show_icon=*/false); |
| } |
| } |
| |
| if (entry_type == apps::PickerEntryType::kDevice) { |
| DCHECK_EQ(apps::IntentPickerCloseReason::OPEN_APP, reason); |
| DCHECK(!should_persist); |
| HandleDeviceSelection(web_contents.get(), devices, selected_app_package, |
| url); |
| if (context) { |
| apps::IntentHandlingMetrics::RecordExternalProtocolUserInteractionMetrics( |
| context, entry_type, reason, should_persist); |
| } |
| return; |
| } |
| |
| // If the user selected an app to continue the navigation, confirm that the |
| // |package_name| matches a valid option and return the index. |
| const size_t selected_app_index = GetAppIndex(handlers, selected_app_package); |
| |
| // Make sure ARC intent helper instance is connected. |
| if (!mojo_delegate->IsArcAvailable()) { |
| reason = apps::IntentPickerCloseReason::ERROR_AFTER_PICKER; |
| } |
| |
| if (reason == apps::IntentPickerCloseReason::OPEN_APP || |
| reason == apps::IntentPickerCloseReason::STAY_IN_CHROME) { |
| if (selected_app_index == handlers.size()) { |
| // Selected app does not exist. |
| reason = apps::IntentPickerCloseReason::ERROR_AFTER_PICKER; |
| } |
| } |
| |
| switch (reason) { |
| case apps::IntentPickerCloseReason::OPEN_APP: |
| // Only ARC apps are offered in the external protocol intent picker, so if |
| // the user decided to open in app the type must be ARC. |
| DCHECK_EQ(apps::PickerEntryType::kArc, entry_type); |
| |
| if (should_persist) { |
| mojo_delegate->AddPreferredPackage( |
| handlers[selected_app_index].package_name); |
| } |
| |
| // Launch the selected app. |
| // As the current web page is closed, |web_contents| will be invalidated. |
| HandleUrl(web_contents, url, handlers, selected_app_index, |
| /*out_result=*/nullptr, safe_to_bypass_ui, mojo_delegate.get()); |
| break; |
| case apps::IntentPickerCloseReason::PREFERRED_APP_FOUND: |
| // We shouldn't be here if a preferred app was found. |
| NOTREACHED(); |
| case apps::IntentPickerCloseReason::STAY_IN_CHROME: |
| NOTREACHED() << "Chrome is not a valid option for external protocol URLs"; |
| case apps::IntentPickerCloseReason::ERROR_BEFORE_PICKER: |
| // This can happen since an error could occur right before invoking |
| // Show() on the bubble's UI code. |
| [[fallthrough]]; |
| case apps::IntentPickerCloseReason::ERROR_AFTER_PICKER: |
| LOG(ERROR) << "IntentPickerBubbleView returned CloseReason::ERROR: " |
| << "selected_app_index=" << selected_app_index |
| << ", handlers.size=" << handlers.size(); |
| [[fallthrough]]; |
| case apps::IntentPickerCloseReason::DIALOG_DEACTIVATED: |
| // The user didn't select any ARC activity. |
| OnIntentPickerDialogDeactivated(web_contents, safe_to_bypass_ui, |
| handlers); |
| break; |
| } |
| |
| if (context) { |
| apps::IntentHandlingMetrics::RecordExternalProtocolUserInteractionMetrics( |
| context, entry_type, reason, should_persist); |
| } |
| } |
| |
| // Called when ARC returned activity icons for the |handlers|. |
| void OnAppIconsReceived( |
| base::WeakPtr<WebContents> web_contents, |
| const GURL& url, |
| const std::optional<url::Origin>& initiating_origin, |
| bool safe_to_bypass_ui, |
| std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo> handlers, |
| std::unique_ptr<ArcIntentHelperMojoDelegate> mojo_delegate, |
| base::OnceCallback<void(bool)> handled_cb, |
| bool show_stay_in_chrome, |
| std::unique_ptr<ArcIconCacheDelegate::ActivityToIconsMap> icons) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| using AppInfo = apps::IntentPickerAppInfo; |
| std::vector<AppInfo> app_info; |
| |
| for (const auto& handler : handlers) { |
| const ArcIconCacheDelegate::ActivityName activity(handler.package_name, |
| handler.activity_name); |
| const auto it = icons->find(activity); |
| app_info.emplace_back(apps::PickerEntryType::kArc, |
| it != icons->end() |
| ? ui::ImageModel::FromImage(it->second.icon16) |
| : ui::ImageModel(), |
| handler.package_name, handler.name); |
| } |
| |
| Browser* browser = |
| web_contents ? chrome::FindBrowserWithTab(web_contents.get()) : nullptr; |
| |
| if (!browser) { |
| return std::move(handled_cb).Run(false); |
| } |
| |
| bool handled = MaybeAddDevicesAndShowPicker( |
| url, initiating_origin, web_contents.get(), std::move(app_info), |
| show_stay_in_chrome, |
| /*show_remember_selection=*/true, |
| base::BindOnce(OnIntentPickerClosed, web_contents, url, safe_to_bypass_ui, |
| std::move(handlers), std::move(mojo_delegate))); |
| return std::move(handled_cb).Run(handled); |
| } |
| |
| void ShowExternalProtocolDialogWithoutApps( |
| base::WeakPtr<WebContents> web_contents, |
| const GURL& url, |
| const std::optional<url::Origin>& initiating_origin, |
| std::unique_ptr<ArcIntentHelperMojoDelegate> mojo_delegate, |
| base::OnceCallback<void(bool)> handled_cb) { |
| // Try to show the device picker and fallback to the default dialog otherwise. |
| bool handled = MaybeAddDevicesAndShowPicker( |
| url, initiating_origin, web_contents.get(), |
| /*app_info=*/{}, /*stay_in_chrome=*/false, |
| /*show_remember_selection=*/false, |
| base::BindOnce( |
| OnIntentPickerClosed, web_contents, url, |
| /*safe_to_bypass_ui=*/false, |
| std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>(), |
| std::move(mojo_delegate))); |
| |
| return std::move(handled_cb).Run(handled); |
| } |
| |
| // Called when ARC returned a handler list for the |url|. |
| void OnUrlHandlerList( |
| base::WeakPtr<WebContents> web_contents, |
| const GURL& url, |
| const std::optional<url::Origin>& initiating_origin, |
| bool safe_to_bypass_ui, |
| std::unique_ptr<ArcIntentHelperMojoDelegate> mojo_delegate, |
| base::OnceCallback<void(bool)> handled_cb, |
| std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo> handlers) { |
| // ArcIntentHelperMojoDelegate is already varified non-null. |
| DCHECK(mojo_delegate); |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| // We only reach here if Chrome doesn't think it can handle the URL. If ARC is |
| // not running anymore, or Chrome is the only candidate returned, show the |
| // usual Chrome OS dialog that says we cannot handle the URL. |
| if (!mojo_delegate->IsArcAvailable() || |
| !ArcIconCacheDelegate::GetInstance() || handlers.empty() || |
| IsChromeOnlyAppCandidate(handlers)) { |
| ShowExternalProtocolDialogWithoutApps(web_contents, url, initiating_origin, |
| std::move(mojo_delegate), |
| std::move(handled_cb)); |
| return; |
| } |
| |
| // Check if the |url| should be handled right away without showing the UI. |
| GetActionResult result; |
| if (HandleUrl(web_contents, url, handlers, handlers.size(), &result, |
| safe_to_bypass_ui, mojo_delegate.get())) { |
| auto* context = web_contents ? web_contents->GetBrowserContext() : nullptr; |
| if (context && result == GetActionResult::HANDLE_URL_IN_ARC) { |
| apps::IntentHandlingMetrics::RecordExternalProtocolUserInteractionMetrics( |
| context, apps::PickerEntryType::kArc, |
| apps::IntentPickerCloseReason::PREFERRED_APP_FOUND, |
| /*should_persist=*/false); |
| } |
| return std::move(handled_cb).Run(/*handled=*/true); |
| } |
| |
| // Otherwise, retrieve icons of the activities. Since this function is for |
| // handling external protocols, Chrome is rarely in the list, but if the |url| |
| // is intent: with fallback or geo:, for example, it may be. In this case, we |
| // remove it from the handler list and show the "Stay in Chrome" button |
| // instead. |
| bool show_stay_in_chrome = false; |
| std::vector<ArcIntentHelperMojoDelegate::ActivityName> activities; |
| auto it = handlers.begin(); |
| while (it != handlers.end()) { |
| if (it->package_name == kArcIntentHelperPackageName) { |
| it = handlers.erase(it); |
| show_stay_in_chrome = true; |
| } else { |
| activities.emplace_back(it->package_name, it->activity_name); |
| ++it; |
| } |
| } |
| ArcIconCacheDelegate::GetInstance()->GetActivityIcons( |
| activities, base::BindOnce(OnAppIconsReceived, web_contents, url, |
| initiating_origin, safe_to_bypass_ui, |
| std::move(handlers), std::move(mojo_delegate), |
| std::move(handled_cb), show_stay_in_chrome)); |
| } |
| |
| } // namespace |
| |
| void RunArcExternalProtocolDialog( |
| const GURL& url, |
| const std::optional<url::Origin>& initiating_origin, |
| base::WeakPtr<WebContents> web_contents, |
| ui::PageTransition page_transition, |
| bool has_user_gesture, |
| bool is_in_fenced_frame_tree, |
| std::unique_ptr<ArcIntentHelperMojoDelegate> mojo_delegate, |
| base::OnceCallback<void(bool)> handled_cb) { |
| // This function is for external protocols that Chrome cannot handle. |
| DCHECK(!url.SchemeIsHTTPOrHTTPS()) << url; |
| |
| // For external protocol navigation, always ignore the FROM_API qualifier. |
| const ui::PageTransition masked_page_transition = |
| apps::LinkCapturingNavigationThrottle::MaskOutPageTransition( |
| page_transition, ui::PAGE_TRANSITION_FROM_API); |
| |
| if (!apps::LinkCapturingNavigationThrottle::IsCapturableLinkNavigation( |
| masked_page_transition, |
| /*allow_form_submit=*/true, is_in_fenced_frame_tree, |
| has_user_gesture)) { |
| LOG(WARNING) << "RunArcExternalProtocolDialog: ignoring " << url |
| << " with PageTransition=" << masked_page_transition |
| << ", is_in_fenced_frame_tree=" << is_in_fenced_frame_tree |
| << ", has_user_gesture=" << has_user_gesture; |
| return std::move(handled_cb).Run(false); |
| } |
| |
| // Check ArcIntentHelperMojoDelegate is set. |
| if (!mojo_delegate) { |
| LOG(ERROR) << "ArcIntentHelperMojoDelegate is null. " |
| << "This is required for mojo connection ." |
| << "For testing, set FakeArcIntentHelperMojo."; |
| return std::move(handled_cb).Run(false); |
| } |
| |
| // Make sure that RequestUrlHandlerList API is supported before resetting |
| // user data. |
| if (!mojo_delegate->IsRequestUrlHandlerListAvailable()) { |
| // RequestUrlHandlerList is either not supported or not yet ready. |
| ShowExternalProtocolDialogWithoutApps(web_contents, url, initiating_origin, |
| std::move(mojo_delegate), |
| std::move(handled_cb)); |
| return; |
| } |
| |
| if (!web_contents || !web_contents->GetBrowserContext() || |
| web_contents->GetBrowserContext()->IsOffTheRecord()) { |
| return std::move(handled_cb).Run(/*handled=*/false); |
| } |
| |
| const bool safe_to_bypass_ui = |
| GetAndResetSafeToRedirectToArcWithoutUserConfirmationFlag( |
| web_contents.get()); |
| |
| // Show ARC version of the dialog, which is IntentPickerBubbleView. To show |
| // the bubble view, we need to ask ARC for a handler list first. |
| mojo_delegate->RequestUrlHandlerList( |
| url.spec(), |
| base::BindOnce(OnUrlHandlerList, web_contents, url, initiating_origin, |
| safe_to_bypass_ui, std::move(mojo_delegate), |
| std::move(handled_cb))); |
| } |
| |
| GetActionResult GetActionForTesting( |
| const GURL& original_url, |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& handlers, |
| size_t selected_app_index, |
| GurlAndActivityInfo* out_url_and_activity_name, |
| bool* safe_to_bypass_ui) { |
| return GetAction(original_url, handlers, selected_app_index, |
| out_url_and_activity_name, safe_to_bypass_ui); |
| } |
| |
| GURL GetUrlToNavigateOnDeactivateForTesting( |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& |
| handlers) { |
| return GetUrlToNavigateOnDeactivate(handlers); |
| } |
| |
| bool GetAndResetSafeToRedirectToArcWithoutUserConfirmationFlagForTesting( |
| WebContents* web_contents) { |
| return GetAndResetSafeToRedirectToArcWithoutUserConfirmationFlag( |
| web_contents); |
| } |
| |
| bool IsChromeAnAppCandidateForTesting( |
| const std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo>& |
| handlers) { |
| return IsChromeAnAppCandidate(handlers); |
| } |
| |
| void OnIntentPickerClosedForTesting( |
| base::WeakPtr<WebContents> web_contents, |
| const GURL& url, |
| bool safe_to_bypass_ui, |
| std::vector<ArcIntentHelperMojoDelegate::IntentHandlerInfo> handlers, |
| std::unique_ptr<ArcIntentHelperMojoDelegate> mojo_delegate, |
| std::vector<SharingTargetDeviceInfo> devices, |
| const std::string& selected_app_package, |
| apps::PickerEntryType entry_type, |
| apps::IntentPickerCloseReason reason, |
| bool should_persist) { |
| OnIntentPickerClosed( |
| web_contents, url, safe_to_bypass_ui, std::move(handlers), |
| std::move(mojo_delegate), std::move(devices), |
| apps::IntentPickerBubbleType::kExternalProtocol, selected_app_package, |
| entry_type, reason, should_persist); |
| } |
| |
| } // namespace arc |
