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

chrome/browser/download/download_target_determiner.cc

 // Copyright 2013 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_target_determiner.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ skipping 18 matching lines @@
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "extensions/common/feature_switch.h"
 #endif
 
 #if defined(ENABLE_PLUGINS)
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/common/webplugininfo.h"
 #endif
 
+#if defined(OS_WIN)
+#include "chrome/browser/ui/pdf/adobe_reader_info_win.h"
+#endif
+
 using content::BrowserThread;
 using content::DownloadItem;
 
 namespace {
 
 const base::FilePath::CharType kCrdownloadSuffix[] =
     FILE_PATH_LITERAL(".crdownload");
 
 // Condenses the results from HistoryService::GetVisibleVisitCountToHost() to a
 // single bool. A host is considered visited before if prior visible visits were
 // found in history and the first such visit was earlier than the most recent
 // midnight.
 void VisitCountsToVisitedBefore(
     const base::Callback<void(bool)>& callback,
     HistoryService::Handle unused_handle,
     bool found_visits,
     int count,
     base::Time first_visit) {
   callback.Run(
       found_visits && count > 0 &&
       (first_visit.LocalMidnight() < base::Time::Now().LocalMidnight()));
 }
 
-} // namespace
+#if defined(OS_WIN)
+// Keeps track of whether Adobe Reader is up to date.
+bool g_is_adobe_reader_up_to_date_ = false;
+#endif
+
+}  // namespace
 
 DownloadTargetInfo::DownloadTargetInfo()
     : is_filetype_handled_safely(false) {}
 
 DownloadTargetInfo::~DownloadTargetInfo() {}
 
 DownloadTargetDeterminerDelegate::~DownloadTargetDeterminerDelegate() {
 }
 
 DownloadTargetDeterminer::DownloadTargetDeterminer(
@@ skipping 54 matching lines @@
         break;
       case STATE_DETERMINE_LOCAL_PATH:
         result = DoDetermineLocalPath();
         break;
       case STATE_DETERMINE_MIME_TYPE:
         result = DoDetermineMimeType();
         break;
       case STATE_DETERMINE_IF_HANDLED_SAFELY_BY_BROWSER:
         result = DoDetermineIfHandledSafely();
         break;
+      case STATE_DETERMINE_IF_ADOBE_READER_UP_TO_DATE:
+        result = DoDetermineIfAdobeReaderUpToDate();
+        break;
       case STATE_CHECK_DOWNLOAD_URL:
         result = DoCheckDownloadUrl();
         break;
       case STATE_DETERMINE_INTERMEDIATE_PATH:
         result = DoDetermineIntermediatePath();
         break;
       case STATE_CHECK_VISITED_REFERRER_BEFORE:
         result = DoCheckVisitedReferrerBefore();
         break;
       case STATE_NONE:
@@ skipping 296 matching lines @@
   // In practice, we assume that retrying once is enough.
   DCHECK(!is_stale);
   bool is_handled_safely =
       plugin_found &&
       (plugin_info.type == WebPluginInfo::PLUGIN_TYPE_PEPPER_IN_PROCESS ||
        plugin_info.type == WebPluginInfo::PLUGIN_TYPE_PEPPER_OUT_OF_PROCESS);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(callback, is_handled_safely));
 }
 
-} // namespace
-#endif  // ENABLE_PLUGINS
+}  // namespace
+#endif  // defined(ENABLE_PLUGINS)
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineIfHandledSafely() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!virtual_path_.empty());
   DCHECK(!local_path_.empty());
   DCHECK(!is_filetype_handled_safely_);
 
-  next_state_ = STATE_CHECK_DOWNLOAD_URL;
+  next_state_ = STATE_DETERMINE_IF_ADOBE_READER_UP_TO_DATE;
 
   if (mime_type_.empty())
     return CONTINUE;
 
   if (net::IsSupportedMimeType(mime_type_)) {
     is_filetype_handled_safely_ = true;
     return CONTINUE;
   }
 
 #if defined(ENABLE_PLUGINS)
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &IsHandledBySafePlugin,
           GetProfile()->GetResourceContext(),
           net::FilePathToFileURL(local_path_),
           mime_type_,
           RETRY_IF_STALE_PLUGIN_LIST,
           base::Bind(&DownloadTargetDeterminer::DetermineIfHandledSafelyDone,
                      weak_ptr_factory_.GetWeakPtr())));
   return QUIT_DOLOOP;
 #else
   return CONTINUE;
 #endif
 }
 
+#if defined(ENABLE_PLUGINS)
 void DownloadTargetDeterminer::DetermineIfHandledSafelyDone(
     bool is_handled_safely) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(20) << "Is file type handled safely: " << is_filetype_handled_safely_;
-  DCHECK_EQ(STATE_CHECK_DOWNLOAD_URL, next_state_);
+  DCHECK_EQ(STATE_DETERMINE_IF_ADOBE_READER_UP_TO_DATE, next_state_);
   is_filetype_handled_safely_ = is_handled_safely;
   DoLoop();
 }
+#endif
+
+DownloadTargetDeterminer::Result
+    DownloadTargetDeterminer::DoDetermineIfAdobeReaderUpToDate() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  next_state_ = STATE_CHECK_DOWNLOAD_URL;
+
+#if defined(OS_WIN)
+  if (!local_path_.MatchesExtension(FILE_PATH_LITERAL(".pdf")))
+    return CONTINUE;
+  if (!IsAdobeReaderDefaultPDFViewer())
+    return CONTINUE;
+
+  base::PostTaskAndReplyWithResult(
+      BrowserThread::GetBlockingPool(),
+      FROM_HERE,
+      base::Bind(&::IsAdobeReaderUpToDate),
+      base::Bind(&DownloadTargetDeterminer::DetermineIfAdobeReaderUpToDateDone,
+                 weak_ptr_factory_.GetWeakPtr()));
+  return QUIT_DOLOOP;
+#else
+  return CONTINUE;
+#endif
+}
+
+#if defined(OS_WIN)
+void DownloadTargetDeterminer::DetermineIfAdobeReaderUpToDateDone(
+    bool adobe_reader_up_to_date) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DVLOG(20) << "Is Adobe Reader Up To Date: " << adobe_reader_up_to_date;
+  DCHECK_EQ(STATE_CHECK_DOWNLOAD_URL, next_state_);
+  g_is_adobe_reader_up_to_date_ = adobe_reader_up_to_date;
+  DoLoop();
+}
+#endif
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoCheckDownloadUrl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!virtual_path_.empty());
   next_state_ = STATE_CHECK_VISITED_REFERRER_BEFORE;
   delegate_->CheckDownloadUrl(
       download_,
       virtual_path_,
       base::Bind(&DownloadTargetDeterminer::CheckDownloadUrlDone,
@@ skipping 310 matching lines @@
   // asynchronously.
   new DownloadTargetDeterminer(download, initial_virtual_path, download_prefs,
                                delegate, callback);
 }
 
 // static
 base::FilePath DownloadTargetDeterminer::GetCrDownloadPath(
     const base::FilePath& suggested_path) {
   return base::FilePath(suggested_path.value() + kCrdownloadSuffix);
 }
+
+#if defined(OS_WIN)
+// static
+bool DownloadTargetDeterminer::IsAdobeReaderUpToDate() {
+  return g_is_adobe_reader_up_to_date_;
+}
+#endif