1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/download/download_prefs.h"
6
7#include <string>
8#include <vector>
9
10#include "base/bind.h"
11#include "base/bind_helpers.h"
12#include "base/files/file_util.h"
13#include "base/lazy_instance.h"
14#include "base/logging.h"
15#include "base/path_service.h"
16#include "base/prefs/pref_service.h"
17#include "base/strings/string_split.h"
18#include "base/strings/string_util.h"
19#include "base/strings/sys_string_conversions.h"
20#include "base/strings/utf_string_conversions.h"
21#include "chrome/browser/download/chrome_download_manager_delegate.h"
22#include "chrome/browser/download/download_extensions.h"
23#include "chrome/browser/download/download_service.h"
24#include "chrome/browser/download/download_service_factory.h"
25#include "chrome/browser/download/download_target_determiner.h"
26#include "chrome/browser/profiles/profile.h"
27#include "chrome/browser/profiles/profile_manager.h"
28#include "chrome/common/chrome_paths.h"
29#include "chrome/common/pref_names.h"
30#include "components/pref_registry/pref_registry_syncable.h"
31#include "content/public/browser/browser_thread.h"
32#include "content/public/browser/download_manager.h"
33#include "content/public/browser/save_page_type.h"
34
35#if defined(OS_CHROMEOS)
36#include "chrome/browser/chromeos/drive/drive_integration_service.h"
37#include "chrome/browser/chromeos/drive/file_system_util.h"
38#include "chrome/browser/chromeos/file_manager/path_util.h"
39#endif
40
41#if defined(OS_WIN)
42#include "chrome/browser/ui/pdf/adobe_reader_info_win.h"
43#endif
44
45using content::BrowserContext;
46using content::BrowserThread;
47using content::DownloadManager;
48
49namespace {
50
51// Consider downloads 'dangerous' if they go to the home directory on Linux and
52// to the desktop on any platform.
53bool DownloadPathIsDangerous(const base::FilePath& download_path) {
54#if defined(OS_LINUX)
55  base::FilePath home_dir = base::GetHomeDir();
56  if (download_path == home_dir) {
57    return true;
58  }
59#endif
60
61#if defined(OS_ANDROID)
62  // Android does not have a desktop dir.
63  return false;
64#else
65  base::FilePath desktop_dir;
66  if (!PathService::Get(base::DIR_USER_DESKTOP, &desktop_dir)) {
67    NOTREACHED();
68    return false;
69  }
70  return (download_path == desktop_dir);
71#endif
72}
73
74class DefaultDownloadDirectory {
75 public:
76  const base::FilePath& path() const { return path_; }
77
78 private:
79  friend struct base::DefaultLazyInstanceTraits<DefaultDownloadDirectory>;
80
81  DefaultDownloadDirectory() {
82    if (!PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS, &path_)) {
83      NOTREACHED();
84    }
85    if (DownloadPathIsDangerous(path_)) {
86      // This is only useful on platforms that support
87      // DIR_DEFAULT_DOWNLOADS_SAFE.
88      if (!PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS_SAFE, &path_)) {
89        NOTREACHED();
90      }
91    }
92  }
93
94  base::FilePath path_;
95
96  DISALLOW_COPY_AND_ASSIGN(DefaultDownloadDirectory);
97};
98
99base::LazyInstance<DefaultDownloadDirectory>
100    g_default_download_directory = LAZY_INSTANCE_INITIALIZER;
101
102}  // namespace
103
104DownloadPrefs::DownloadPrefs(Profile* profile) : profile_(profile) {
105  PrefService* prefs = profile->GetPrefs();
106
107#if defined(OS_CHROMEOS)
108  // On Chrome OS, the default download directory is different for each profile.
109  // If the profile-unaware default path (from GetDefaultDownloadDirectory())
110  // is set (this happens during the initial preference registration in static
111  // RegisterProfilePrefs()), alter by GetDefaultDownloadDirectoryForProfile().
112  // file_manager::util::MigratePathFromOldFormat will do this.
113  const char* path_pref[] = {
114      prefs::kSaveFileDefaultDirectory,
115      prefs::kDownloadDefaultDirectory
116  };
117  for (size_t i = 0; i < arraysize(path_pref); ++i) {
118    const base::FilePath current = prefs->GetFilePath(path_pref[i]);
119    base::FilePath migrated;
120    if (!current.empty() &&
121        file_manager::util::MigratePathFromOldFormat(
122            profile_, current, &migrated)) {
123      prefs->SetFilePath(path_pref[i], migrated);
124    }
125  }
126
127  // Ensure that the default download directory exists.
128  BrowserThread::PostTask(
129      BrowserThread::FILE, FROM_HERE,
130      base::Bind(base::IgnoreResult(&base::CreateDirectory),
131                 GetDefaultDownloadDirectoryForProfile()));
132#endif  // defined(OS_CHROMEOS)
133
134#if defined(OS_WIN)
135  should_open_pdf_in_adobe_reader_ =
136      prefs->GetBoolean(prefs::kOpenPdfDownloadInAdobeReader);
137#endif
138
139  // If the download path is dangerous we forcefully reset it. But if we do
140  // so we set a flag to make sure we only do it once, to avoid fighting
141  // the user if he really wants it on an unsafe place such as the desktop.
142  if (!prefs->GetBoolean(prefs::kDownloadDirUpgraded)) {
143    base::FilePath current_download_dir = prefs->GetFilePath(
144        prefs::kDownloadDefaultDirectory);
145    if (DownloadPathIsDangerous(current_download_dir)) {
146      prefs->SetFilePath(prefs::kDownloadDefaultDirectory,
147                         GetDefaultDownloadDirectoryForProfile());
148    }
149    prefs->SetBoolean(prefs::kDownloadDirUpgraded, true);
150  }
151
152  prompt_for_download_.Init(prefs::kPromptForDownload, prefs);
153  download_path_.Init(prefs::kDownloadDefaultDirectory, prefs);
154  save_file_path_.Init(prefs::kSaveFileDefaultDirectory, prefs);
155  save_file_type_.Init(prefs::kSaveFileType, prefs);
156
157  // We store any file extension that should be opened automatically at
158  // download completion in this pref.
159  std::string extensions_to_open =
160      prefs->GetString(prefs::kDownloadExtensionsToOpen);
161  std::vector<std::string> extensions;
162  base::SplitString(extensions_to_open, ':', &extensions);
163
164  for (size_t i = 0; i < extensions.size(); ++i) {
165#if defined(OS_POSIX)
166    base::FilePath path(extensions[i]);
167#elif defined(OS_WIN)
168    base::FilePath path(base::UTF8ToWide(extensions[i]));
169#endif
170    if (!extensions[i].empty() &&
171        download_util::GetFileDangerLevel(path) == download_util::NOT_DANGEROUS)
172      auto_open_.insert(path.value());
173  }
174}
175
176DownloadPrefs::~DownloadPrefs() {}
177
178// static
179void DownloadPrefs::RegisterProfilePrefs(
180    user_prefs::PrefRegistrySyncable* registry) {
181  registry->RegisterBooleanPref(
182      prefs::kPromptForDownload,
183      false,
184      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
185  registry->RegisterStringPref(
186      prefs::kDownloadExtensionsToOpen,
187      std::string(),
188      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
189  registry->RegisterBooleanPref(
190      prefs::kDownloadDirUpgraded,
191      false,
192      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
193  registry->RegisterIntegerPref(
194      prefs::kSaveFileType,
195      content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
196      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
197
198  const base::FilePath& default_download_path = GetDefaultDownloadDirectory();
199  registry->RegisterFilePathPref(
200      prefs::kDownloadDefaultDirectory,
201      default_download_path,
202      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
203  registry->RegisterFilePathPref(
204      prefs::kSaveFileDefaultDirectory,
205      default_download_path,
206      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
207#if defined(OS_WIN)
208  registry->RegisterBooleanPref(
209      prefs::kOpenPdfDownloadInAdobeReader,
210      false,
211      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
212#endif
213}
214
215base::FilePath DownloadPrefs::GetDefaultDownloadDirectoryForProfile() const {
216#if defined(OS_CHROMEOS)
217  return file_manager::util::GetDownloadsFolderForProfile(profile_);
218#else
219  return GetDefaultDownloadDirectory();
220#endif
221}
222
223// static
224const base::FilePath& DownloadPrefs::GetDefaultDownloadDirectory() {
225  return g_default_download_directory.Get().path();
226}
227
228// static
229DownloadPrefs* DownloadPrefs::FromDownloadManager(
230    DownloadManager* download_manager) {
231  ChromeDownloadManagerDelegate* delegate =
232      static_cast<ChromeDownloadManagerDelegate*>(
233          download_manager->GetDelegate());
234  return delegate->download_prefs();
235}
236
237// static
238DownloadPrefs* DownloadPrefs::FromBrowserContext(
239    content::BrowserContext* context) {
240  return FromDownloadManager(BrowserContext::GetDownloadManager(context));
241}
242
243base::FilePath DownloadPrefs::DownloadPath() const {
244#if defined(OS_CHROMEOS)
245  // If the download path is under /drive, and DriveIntegrationService isn't
246  // available (which it isn't for incognito mode, for instance), use the
247  // default download directory (/Downloads).
248  if (drive::util::IsUnderDriveMountPoint(*download_path_)) {
249    drive::DriveIntegrationService* integration_service =
250        drive::DriveIntegrationServiceFactory::FindForProfile(profile_);
251    if (!integration_service || !integration_service->is_enabled())
252      return GetDefaultDownloadDirectoryForProfile();
253  }
254#endif
255  return *download_path_;
256}
257
258void DownloadPrefs::SetDownloadPath(const base::FilePath& path) {
259  download_path_.SetValue(path);
260  SetSaveFilePath(path);
261}
262
263base::FilePath DownloadPrefs::SaveFilePath() const {
264  return *save_file_path_;
265}
266
267void DownloadPrefs::SetSaveFilePath(const base::FilePath& path) {
268  save_file_path_.SetValue(path);
269}
270
271void DownloadPrefs::SetSaveFileType(int type) {
272  save_file_type_.SetValue(type);
273}
274
275bool DownloadPrefs::PromptForDownload() const {
276  // If the DownloadDirectory policy is set, then |prompt_for_download_| should
277  // always be false.
278  DCHECK(!download_path_.IsManaged() || !prompt_for_download_.GetValue());
279  return *prompt_for_download_;
280}
281
282bool DownloadPrefs::IsDownloadPathManaged() const {
283  return download_path_.IsManaged();
284}
285
286bool DownloadPrefs::IsAutoOpenUsed() const {
287#if defined(OS_WIN)
288  if (ShouldOpenPdfInAdobeReader())
289    return true;
290#endif
291  return !auto_open_.empty();
292}
293
294bool DownloadPrefs::IsAutoOpenEnabledBasedOnExtension(
295    const base::FilePath& path) const {
296  base::FilePath::StringType extension = path.Extension();
297  if (extension.empty())
298    return false;
299  DCHECK(extension[0] == base::FilePath::kExtensionSeparator);
300  extension.erase(0, 1);
301#if defined(OS_WIN)
302  if (extension == FILE_PATH_LITERAL("pdf") &&
303      DownloadTargetDeterminer::IsAdobeReaderUpToDate() &&
304      ShouldOpenPdfInAdobeReader())
305    return true;
306#endif
307  return auto_open_.find(extension) != auto_open_.end();
308}
309
310bool DownloadPrefs::EnableAutoOpenBasedOnExtension(
311    const base::FilePath& file_name) {
312  base::FilePath::StringType extension = file_name.Extension();
313  if (extension.empty())
314    return false;
315  DCHECK(extension[0] == base::FilePath::kExtensionSeparator);
316  extension.erase(0, 1);
317
318  auto_open_.insert(extension);
319  SaveAutoOpenState();
320  return true;
321}
322
323void DownloadPrefs::DisableAutoOpenBasedOnExtension(
324    const base::FilePath& file_name) {
325  base::FilePath::StringType extension = file_name.Extension();
326  if (extension.empty())
327    return;
328  DCHECK(extension[0] == base::FilePath::kExtensionSeparator);
329  extension.erase(0, 1);
330  auto_open_.erase(extension);
331  SaveAutoOpenState();
332}
333
334#if defined(OS_WIN)
335void DownloadPrefs::SetShouldOpenPdfInAdobeReader(bool should_open) {
336  if (should_open_pdf_in_adobe_reader_ == should_open)
337    return;
338  should_open_pdf_in_adobe_reader_ = should_open;
339  profile_->GetPrefs()->SetBoolean(prefs::kOpenPdfDownloadInAdobeReader,
340                                   should_open);
341}
342
343bool DownloadPrefs::ShouldOpenPdfInAdobeReader() const {
344  return should_open_pdf_in_adobe_reader_;
345}
346#endif
347
348void DownloadPrefs::ResetAutoOpen() {
349#if defined(OS_WIN)
350  SetShouldOpenPdfInAdobeReader(false);
351#endif
352  auto_open_.clear();
353  SaveAutoOpenState();
354}
355
356void DownloadPrefs::SaveAutoOpenState() {
357  std::string extensions;
358  for (AutoOpenSet::iterator it = auto_open_.begin();
359       it != auto_open_.end(); ++it) {
360#if defined(OS_POSIX)
361    std::string this_extension = *it;
362#elif defined(OS_WIN)
363    // TODO(phajdan.jr): Why we're using Sys conversion here, but not in ctor?
364    std::string this_extension = base::SysWideToUTF8(*it);
365#endif
366    extensions += this_extension + ":";
367  }
368  if (!extensions.empty())
369    extensions.erase(extensions.size() - 1);
370
371  profile_->GetPrefs()->SetString(prefs::kDownloadExtensionsToOpen, extensions);
372}
373
374bool DownloadPrefs::AutoOpenCompareFunctor::operator()(
375    const base::FilePath::StringType& a,
376    const base::FilePath::StringType& b) const {
377  return base::FilePath::CompareLessIgnoreCase(a, b);
378}
379