Windows: Add an "Open in Adobe Reader" menu item for PDF files in the download shelf.

chrome/browser/download/download_prefs.cc

 // Copyright (c) 2012 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/download/download_prefs.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 19 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/save_page_type.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #endif
 
+#if defined(OS_WIN)
+#include "chrome/browser/ui/pdf/adobe_reader_info_win.h"
+#endif
+
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadManager;
 
 namespace {
 
 // Consider downloads 'dangerous' if they go to the home directory on Linux and
 // to the desktop on any platform.
 bool DownloadPathIsDangerous(const base::FilePath& download_path) {
 #if defined(OS_LINUX)
@@ skipping 34 matching lines @@
         NOTREACHED();
       }
     }
   }
 
   base::FilePath path_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultDownloadDirectory);
 };
 
-static base::LazyInstance<DefaultDownloadDirectory>
+base::LazyInstance<DefaultDownloadDirectory>
     g_default_download_directory = LAZY_INSTANCE_INITIALIZER;
 
+#if defined(OS_WIN)
+bool g_adobe_reader_up_to_date = false;
+
+// Callback when whether Adobe Reader is up to date is known.
+void OnGotAdobeReaderInfo(bool up_to_date) {
+  g_adobe_reader_up_to_date = up_to_date;
+}
+#endif
+
 }  // namespace
 
 DownloadPrefs::DownloadPrefs(Profile* profile) : profile_(profile) {
   PrefService* prefs = profile->GetPrefs();
 
 #if defined(OS_CHROMEOS)
   // On Chrome OS, the default download directory is different for each profile.
   // If the profile-unaware default path (from GetDefaultDownloadDirectory())
   // is set (this happens during the initial preference registration in static
   // RegisterProfilePrefs()), alter by GetDefaultDownloadDirectoryForProfile().
   // file_manager::util::MigratePathFromOldFormat will do this.
   const char* path_pref[] = {
       prefs::kSaveFileDefaultDirectory,
       prefs::kDownloadDefaultDirectory
   };
   for (size_t i = 0; i < arraysize(path_pref); ++i) {
     const base::FilePath current = prefs->GetFilePath(path_pref[i]);
     base::FilePath migrated;
     if (!current.empty() &&
         file_manager::util::MigratePathFromOldFormat(
             profile_, current, &migrated)) {
       prefs->SetFilePath(path_pref[i], migrated);
     }
   }
 
   // Ensure that the default download directory exists.
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
+  BrowserThread::PostBlockingPoolTask(

[asanka, 2014/06/25 03:55:08]

Shall we leave this on the FILE thread?

The sequencing of the creation on FILE thread is, I believe, intentional. The
download related set of objects are instantiated when the first time something
touches the download system (e.g. because the user started a new download or
because the user opened the chrome://downloads page). Sequencing on the FILE
thread ensures that the tasks that will be queued later will be executed after
this one (e.g. opening the downloads folder) and thus see the default download
folder as existing. Posting on the blocking pool doesn't give us that sequence
restriction. Thus it is easier to reason about things if we stick to the FILE
thread for now.

This predates the blocking pool, and there were plans to consider moving to
sequenced worker pool, but there's no cycles to do the transition.

That said, I'm not sure why this is done for Chrome OS. Maybe the Files app
misbehaves if there's no download folder? It's certainly not a requirement on
other OSs.

[Lei Zhang, 2014/06/26 08:06:12]

Reverted. I generally like to do cleanups along the way, one of which is to
ever-so-slowly get rid of the FILE thread.

+      FROM_HERE,
       base::Bind(base::IgnoreResult(&base::CreateDirectory),
                  GetDefaultDownloadDirectoryForProfile()));
 #endif  // defined(OS_CHROMEOS)
 
+#if defined(OS_WIN)
+  if (IsAdobeReaderDefaultPDFViewer()) {
+    base::PostTaskAndReplyWithResult(
+        BrowserThread::GetBlockingPool(),

[asanka, 2014/06/25 03:55:08]

This also makes the extremely likely but still non-deterministic assumption that
the value would be available by the time we hit
CDMD::IsOpenInBrowserPreferredForFile().

Have you looked at DownloadTargetDeterminer? It is intentionally designed to
take these thread jumps into consideration and put all the cross-thread data
gathering into a predictable sequence. For example, we have a check in there for
looking up the plugin that would handle the target file if it was opened inside
the browser (DownloadTargetDeterminer::DoDetermineIfHandledSafely()). We can
move this logic there as well so that this check is performed deterministically
before its result is used.

[Lei Zhang, 2014/06/26 08:06:12]

Thanks for the suggestion, done.

Yes, I was very sad that I couldn't find the full version number using only the
registry, so I was hoping to do this early on and have the info ready by the
time the user hits the context menu 99% of the time.

+        FROM_HERE,
+        base::Bind(&::IsAdobeReaderUpToDate),
+        base::Bind(&OnGotAdobeReaderInfo));
+  }
+
+  should_open_pdf_in_adobe_reader_ =
+      prefs->GetBoolean(prefs::kOpenPdfDownloadInAdobeReader);
+#endif
+
   // If the download path is dangerous we forcefully reset it. But if we do
   // so we set a flag to make sure we only do it once, to avoid fighting
   // the user if he really wants it on an unsafe place such as the desktop.
   if (!prefs->GetBoolean(prefs::kDownloadDirUpgraded)) {
     base::FilePath current_download_dir = prefs->GetFilePath(
         prefs::kDownloadDefaultDirectory);
     if (DownloadPathIsDangerous(current_download_dir)) {
       prefs->SetFilePath(prefs::kDownloadDefaultDirectory,
                          GetDefaultDownloadDirectoryForProfile());
     }
@@ skipping 48 matching lines @@
 
   const base::FilePath& default_download_path = GetDefaultDownloadDirectory();
   registry->RegisterFilePathPref(
       prefs::kDownloadDefaultDirectory,
       default_download_path,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterFilePathPref(
       prefs::kSaveFileDefaultDirectory,
       default_download_path,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+#if defined(OS_WIN)
+  registry->RegisterBooleanPref(
+      prefs::kOpenPdfDownloadInAdobeReader,
+      false,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+#endif
 }
 
+#if defined(OS_WIN)
+// static
+bool DownloadPrefs::IsAdobeReaderUpToDate() {
+  return g_adobe_reader_up_to_date;
+}
+#endif
+
 base::FilePath DownloadPrefs::GetDefaultDownloadDirectoryForProfile() const {
 #if defined(OS_CHROMEOS)
   return file_manager::util::GetDownloadsFolderForProfile(profile_);
 #else
   return GetDefaultDownloadDirectory();
 #endif
 }
 
 // static
 const base::FilePath& DownloadPrefs::GetDefaultDownloadDirectory() {
@@ skipping 52 matching lines @@
   // always be false.
   DCHECK(!download_path_.IsManaged() || !prompt_for_download_.GetValue());
   return *prompt_for_download_;
 }
 
 bool DownloadPrefs::IsDownloadPathManaged() const {
   return download_path_.IsManaged();
 }
 
 bool DownloadPrefs::IsAutoOpenUsed() const {
+#if defined(OS_WIN)
+  if (ShouldOpenPdfInAdobeReader())
+    return true;
+#endif
   return !auto_open_.empty();
 }
 
 bool DownloadPrefs::IsAutoOpenEnabledBasedOnExtension(
     const base::FilePath& path) const {
   base::FilePath::StringType extension = path.Extension();
   if (extension.empty())
     return false;
   DCHECK(extension[0] == base::FilePath::kExtensionSeparator);
   extension.erase(0, 1);
+#if defined(OS_WIN)
+  if (extension == FILE_PATH_LITERAL("pdf") &&
+      g_adobe_reader_up_to_date && ShouldOpenPdfInAdobeReader())
+    return true;
+#endif

[asanka, 2014/06/25 03:55:08]

What should happen here if the Adobe Reader is not up-to-date and .pdf is listed
as an auto open file type?

[Lei Zhang, 2014/06/26 08:06:12]

We currently ignore it because IsOpenInBrowserPreferreredForFile() will return
true for PDFs, right? I imagine we'll continue to do so if Adobe Reader is not
up-to-date.

   return auto_open_.find(extension) != auto_open_.end();
 }
 
 bool DownloadPrefs::EnableAutoOpenBasedOnExtension(
     const base::FilePath& file_name) {
   base::FilePath::StringType extension = file_name.Extension();
   if (extension.empty())
     return false;
   DCHECK(extension[0] == base::FilePath::kExtensionSeparator);
   extension.erase(0, 1);
 
   auto_open_.insert(extension);
   SaveAutoOpenState();
   return true;
 }
 
 void DownloadPrefs::DisableAutoOpenBasedOnExtension(
     const base::FilePath& file_name) {
   base::FilePath::StringType extension = file_name.Extension();
   if (extension.empty())
     return;
   DCHECK(extension[0] == base::FilePath::kExtensionSeparator);
   extension.erase(0, 1);
   auto_open_.erase(extension);
   SaveAutoOpenState();
 }
 
+#if defined(OS_WIN)
+void DownloadPrefs::SetShouldOpenPdfInAdobeReader(bool should_open) {
+  if (should_open_pdf_in_adobe_reader_ == should_open)
+    return;
+  should_open_pdf_in_adobe_reader_ = should_open;
+  profile_->GetPrefs()->SetBoolean(prefs::kOpenPdfDownloadInAdobeReader,
+                                   should_open);
+}
+
+bool DownloadPrefs::ShouldOpenPdfInAdobeReader() const {
+  return should_open_pdf_in_adobe_reader_;
+}
+#endif
+
 void DownloadPrefs::ResetAutoOpen() {
+#if defined(OS_WIN)
+  SetShouldOpenPdfInAdobeReader(false);
+#endif
   auto_open_.clear();
   SaveAutoOpenState();
 }
 
 void DownloadPrefs::SaveAutoOpenState() {
   std::string extensions;
   for (AutoOpenSet::iterator it = auto_open_.begin();
        it != auto_open_.end(); ++it) {
 #if defined(OS_POSIX)
     std::string this_extension = *it;
 #elif defined(OS_WIN)
     // TODO(phajdan.jr): Why we're using Sys conversion here, but not in ctor?
     std::string this_extension = base::SysWideToUTF8(*it);
 #endif
     extensions += this_extension + ":";
   }
   if (!extensions.empty())
     extensions.erase(extensions.size() - 1);
 
   profile_->GetPrefs()->SetString(prefs::kDownloadExtensionsToOpen, extensions);
 }
 
 bool DownloadPrefs::AutoOpenCompareFunctor::operator()(
     const base::FilePath::StringType& a,
     const base::FilePath::StringType& b) const {
   return base::FilePath::CompareLessIgnoreCase(a, b);
 }