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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// 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.
#ifndef CHROME_BROWSER_DOWNLOAD_DOWNLOAD_PREFS_H_
#define CHROME_BROWSER_DOWNLOAD_DOWNLOAD_PREFS_H_
#include <memory>
#include <set>
#include "base/files/file_path.h"
#include "base/memory/raw_ptr.h"
#include "build/build_config.h"
#include "components/policy/core/common/policy_pref_names.h"
#include "components/prefs/pref_change_registrar.h"
#include "components/prefs/pref_member.h"
class GURL;
class Profile;
class TrustedSourcesManager;
namespace content {
class BrowserContext;
class DownloadManager;
}
namespace download {
class DownloadItem;
}
namespace policy {
class URLBlocklist;
}
namespace user_prefs {
class PrefRegistrySyncable;
}
// Stores all download-related preferences.
class DownloadPrefs {
public:
explicit DownloadPrefs(Profile* profile);
DownloadPrefs(const DownloadPrefs&) = delete;
DownloadPrefs& operator=(const DownloadPrefs&) = delete;
~DownloadPrefs();
static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
// Returns the default download directory.
static const base::FilePath& GetDefaultDownloadDirectory();
// Returns the default download directory for the current profile.
base::FilePath GetDefaultDownloadDirectoryForProfile() const;
// Returns the DownloadPrefs corresponding to the given DownloadManager
// or BrowserContext.
static DownloadPrefs* FromDownloadManager(
content::DownloadManager* download_manager);
static DownloadPrefs* FromBrowserContext(
content::BrowserContext* browser_context);
// Identify whether the downloaded item was downloaded from a trusted source.
bool IsFromTrustedSource(const download::DownloadItem& item);
base::FilePath DownloadPath() const;
void SetDownloadPath(const base::FilePath& path);
base::FilePath SaveFilePath() const;
void SetSaveFilePath(const base::FilePath& path);
int save_file_type() const { return *save_file_type_; }
void SetSaveFileType(int type);
policy::DownloadRestriction download_restriction() const {
return static_cast<policy::DownloadRestriction>(*download_restriction_);
}
bool safebrowsing_for_trusted_sources_enabled() const {
return *safebrowsing_for_trusted_sources_enabled_;
}
// Returns true if the prompt_for_download preference has been set and the
// download location is not managed (which means the user shouldn't be able
// to choose another download location).
bool PromptForDownload() const;
// Returns true if the download path preference is managed.
bool IsDownloadPathManaged() const;
// Returns true if there is at least one file extension registered
// by the user for auto-open.
bool IsAutoOpenByUserUsed() const;
// Returns true if |path| should be opened automatically.
bool IsAutoOpenEnabled(const GURL& url, const base::FilePath& path) const;
// Returns true if |path| should be opened automatically by policy.
bool IsAutoOpenByPolicy(const GURL& url, const base::FilePath& path) const;
// Enables automatically opening all downloads with the same file type as
// |file_name|. Returns true on success. The call may fail if |file_name|
// either doesn't have an extension (hence the file type cannot be
// determined), or if the file type is one that is disallowed from being
// opened automatically. See IsAllowedToOpenAutomatically() for details on the
// latter.
bool EnableAutoOpenByUserBasedOnExtension(const base::FilePath& file_name);
// Disables auto-open based on file extension.
void DisableAutoOpenByUserBasedOnExtension(const base::FilePath& file_name);
#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
BUILDFLAG(IS_MAC)
// Store the user preference to disk. If |should_open| is true, also disable
// the built-in PDF plugin. If |should_open| is false, enable the PDF plugin.
void SetShouldOpenPdfInSystemReader(bool should_open);
// Return whether the user prefers to open PDF downloads in the platform's
// default reader.
bool ShouldOpenPdfInSystemReader() const;
#endif
void ResetAutoOpenByUser();
// If this is called, the download target path will not be sanitized going
// forward - whatever has been passed to SetDownloadPath will be used.
void SkipSanitizeDownloadTargetPathForTesting();
#if BUILDFLAG(IS_ANDROID)
// Returns whether downloaded pdf from external apps should be auto-opened.
bool IsAutoOpenPdfEnabled();
#endif
private:
void SaveAutoOpenState();
bool CanPlatformEnableAutoOpenForPdf() const;
// Checks whether |path| is a valid download target path. If it is, returns
// it as is. If it isn't returns the default download directory.
base::FilePath SanitizeDownloadTargetPath(const base::FilePath& path) const;
void UpdateAutoOpenByPolicy();
void UpdateAllowedURLsForOpenByPolicy();
raw_ptr<Profile> profile_;
BooleanPrefMember prompt_for_download_;
#if BUILDFLAG(IS_ANDROID)
IntegerPrefMember prompt_for_download_android_;
BooleanPrefMember auto_open_pdf_enabled_;
#endif
FilePathPrefMember download_path_;
FilePathPrefMember save_file_path_;
IntegerPrefMember save_file_type_;
IntegerPrefMember download_restriction_;
BooleanPrefMember safebrowsing_for_trusted_sources_enabled_;
PrefChangeRegistrar pref_change_registrar_;
// To identify if a download URL is from a trusted source.
std::unique_ptr<TrustedSourcesManager> trusted_sources_manager_;
// Set of file extensions to open at download completion.
struct AutoOpenCompareFunctor {
bool operator()(const base::FilePath::StringType& a,
const base::FilePath::StringType& b) const;
};
typedef std::set<base::FilePath::StringType,
AutoOpenCompareFunctor> AutoOpenSet;
AutoOpenSet auto_open_by_user_;
AutoOpenSet auto_open_by_policy_;
std::unique_ptr<policy::URLBlocklist> auto_open_allowed_by_urls_;
#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
BUILDFLAG(IS_MAC)
bool should_open_pdf_in_system_reader_;
#endif
// If this is true, SanitizeDownloadTargetPath will always return the passed
// path verbatim.
bool skip_sanitize_download_target_path_for_testing_ = false;
};
#endif // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_PREFS_H_
|
