1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/wm/window_pin_util.h"
#include "base/containers/to_vector.h"
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "chrome/browser/apps/app_service/app_service_proxy.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/ash/file_manager/open_util.h"
#include "chrome/browser/ash/guest_os/guest_os_external_protocol_handler.h"
#include "chrome/browser/platform_util.h"
#include "chrome/browser/platform_util_internal.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/simple_message_box.h"
#include "chrome/browser/web_applications/app_service/publisher_helper.h"
#include "chromeos/constants/chromeos_features.h"
#include "chromeos/strings/grit/chromeos_strings.h"
#include "content/public/browser/browser_thread.h"
#include "ui/aura/window.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/chromeos/strings/grit/ui_chromeos_strings.h"
#include "url/gurl.h"
using content::BrowserThread;
namespace platform_util {
namespace {
void ShowWarningOnOpenOperationResult(Profile* profile,
const base::FilePath& path,
OpenOperationResult result) {
int message_id = IDS_FILE_BROWSER_ERROR_VIEWING_FILE;
switch (result) {
case OPEN_SUCCEEDED:
return;
case OPEN_FAILED_PATH_NOT_FOUND:
message_id = IDS_FILE_BROWSER_ERROR_UNRESOLVABLE_FILE;
break;
case OPEN_FAILED_INVALID_TYPE:
return;
case OPEN_FAILED_NO_HANLDER_FOR_FILE_TYPE:
if (path.MatchesExtension(FILE_PATH_LITERAL(".dmg")))
message_id = IDS_FILE_BROWSER_ERROR_VIEWING_FILE_FOR_DMG;
else if (path.MatchesExtension(FILE_PATH_LITERAL(".exe")) ||
path.MatchesExtension(FILE_PATH_LITERAL(".msi")))
message_id = IDS_FILE_BROWSER_ERROR_VIEWING_FILE_FOR_EXECUTABLE;
else
message_id = IDS_FILE_BROWSER_ERROR_VIEWING_FILE;
break;
case OPEN_FAILED_FILE_ERROR:
message_id = IDS_FILE_BROWSER_ERROR_VIEWING_FILE;
break;
}
Browser* browser = chrome::FindTabbedBrowser(profile, false);
chrome::ShowWarningMessageBoxAsync(
browser ? browser->window()->GetNativeWindow() : nullptr,
path.BaseName().AsUTF16Unsafe(), l10n_util::GetStringUTF16(message_id));
}
void HandleWebAppManifestProtocolHandler(
Profile* profile,
const GURL& url,
const std::vector<std::string>& app_ids) {
CHECK(!app_ids.empty());
// TODO(crbug.com/422422887): Figure out how to disambiguate conflicting
// protocol handlers; for now, pick the first one in the list.
const auto& app_id = app_ids[0];
apps::AppLaunchParams params(app_id,
apps::LaunchContainer::kLaunchContainerWindow,
WindowOpenDisposition::NEW_FOREGROUND_TAB,
apps::LaunchSource::kFromProtocolHandler);
params.protocol_handler_launch_url = url;
apps::AppServiceProxyFactory::GetForProfile(profile)->LaunchAppWithParams(
std::move(params));
}
} // namespace
namespace internal {
void DisableShellOperationsForTesting() {
file_manager::util::DisableShellOperationsForTesting();
}
} // namespace internal
void ShowItemInFolder(Profile* profile, const base::FilePath& full_path) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
file_manager::util::ShowItemInFolder(
profile, full_path,
base::BindOnce(&ShowWarningOnOpenOperationResult, profile, full_path));
}
void OpenItem(Profile* profile,
const base::FilePath& full_path,
OpenItemType item_type,
OpenOperationCallback callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
file_manager::util::OpenItem(
profile, full_path, item_type,
callback.is_null() ? base::BindOnce(&ShowWarningOnOpenOperationResult,
profile, full_path)
: std::move(callback));
}
void OpenExternal(Profile* profile, const GURL& url) {
// This code is called either when:
// 1. ChromeAppDelegate::NewWindowContentsDelegate::OpenURLFromTab determines
// that the currently running chrome is not the system default browser. This
// should not happen for Chrome OS (crrev.com/c/2454769).
// 2. |url| uses a external protocol and either
// ExternalProtocolDialog::OnDialogAccepted invokes this, or the dialog has
// previously been accepted with "Always allow ..." and this is called from
// ChromeContentBrowserClient::HandleExternalProtocol.
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (std::vector<std::string> app_ids =
web_app::GetWebAppIdsForProtocolUrl(profile, url);
!app_ids.empty()) {
HandleWebAppManifestProtocolHandler(profile, url, app_ids);
return;
}
std::optional<guest_os::GuestOsUrlHandler> handler =
guest_os::GuestOsUrlHandler::GetForUrl(profile, url);
if (handler) {
handler->Handle(profile, url);
}
}
bool IsBrowserLockedFullscreen(const Browser* browser) {
aura::Window* window = browser->window()->GetNativeWindow();
// |window| can be nullptr inside of unit tests.
if (!window)
return false;
return GetWindowPinType(window) == chromeos::WindowPinType::kTrustedPinned;
}
} // namespace platform_util
|
