Adds a pref and a policy to decide if PDFs should always be opened externally.

chrome/browser/plugins/plugin_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/plugins/plugin_prefs.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 10 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/plugins/plugin_installer.h"
 #include "chrome/browser/plugins/plugin_metadata.h"
 #include "chrome/browser/plugins/plugin_prefs_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/common/webplugininfo.h"
 
@@ skipping 12 matching lines @@
     if (PathService::Get(chrome::DIR_COMPONENT_UPDATED_PEPPER_FLASH_PLUGIN,
                          &component_updated_pepper_flash_dir) &&
         component_updated_pepper_flash_dir.IsParent(plugin)) {
       return true;
     }
   }
 
   return false;
 }
 
+bool IsPDFViewerPlugin(const base::string16& plugin_name) {
+  return plugin_name == base::ASCIIToUTF16(ChromeContentClient::kPDFPluginName);
+}
+
 }  // namespace
 
 PluginPrefs::PluginState::PluginState() {
 }
 
 PluginPrefs::PluginState::~PluginState() {
 }
 
 bool PluginPrefs::PluginState::Get(const base::FilePath& plugin,
                                    bool* enabled) const {
@@ skipping 145 matching lines @@
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&PluginPrefs::OnUpdatePreferences, this, plugins));
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&PluginPrefs::NotifyPluginStatusChanged, this));
   callback.Run(true);
 }
 
 PluginPrefs::PolicyStatus PluginPrefs::PolicyStatusForPlugin(
     const base::string16& name) const {
   base::AutoLock auto_lock(lock_);
+
+  // Special handling for PDF based on its specific policy.
+  if (IsPDFViewerPlugin(name) && always_open_pdf_externally_) {
+    return POLICY_DISABLED;

[Bernhard Bauer, 2016/09/29 08:44:35]

Nit: I think it's more common to leave out braces for one-line bodies in this
file.

[pastarmovj, 2016/09/29 12:14:41]

Yup. Copy-paste relict.

+  }
+
   if (IsStringMatchedInSet(name, policy_enabled_plugin_patterns_)) {
     return POLICY_ENABLED;
   } else if (IsStringMatchedInSet(name, policy_disabled_plugin_patterns_) &&

[Bernhard Bauer, 2016/09/29 08:44:35]

Remove these else's?

[pastarmovj, 2016/09/29 12:14:41]

Done.

              !IsStringMatchedInSet(
                  name, policy_disabled_plugin_exception_patterns_)) {
     return POLICY_DISABLED;
   } else {
     return NO_POLICY;
   }
 }
 
 bool PluginPrefs::IsPluginEnabled(const content::WebPluginInfo& plugin) const {
   std::unique_ptr<PluginMetadata> plugin_metadata(
@@ skipping 39 matching lines @@
 }
 
 void PluginPrefs::UpdatePatternsAndNotify(std::set<base::string16>* patterns,
                                           const std::string& pref_name) {
   base::AutoLock auto_lock(lock_);
   ListValueToStringSet(prefs_->GetList(pref_name.c_str()), patterns);
 
   NotifyPluginStatusChanged();
 }
 
+void PluginPrefs::UpdatePdfPolicy(const std::string& pref_name) {
+  base::AutoLock auto_lock(lock_);
+  always_open_pdf_externally_ =
+      prefs_->GetBoolean(prefs::kAlwaysOpenPdfExternally);
+
+  NotifyPluginStatusChanged();
+}
+
 /*static*/
 bool PluginPrefs::IsStringMatchedInSet(
     const base::string16& name,
     const std::set<base::string16>& pattern_set) {
   std::set<base::string16>::const_iterator pattern(pattern_set.begin());
   while (pattern != pattern_set.end()) {
     if (base::MatchPattern(name, *pattern))
       return true;
     ++pattern;
   }
@@ skipping 112 matching lines @@
 
   // Build the set of policy enabled/disabled plugin patterns once and cache it.
   // Don't do this in the constructor, there's no profile available there.
   ListValueToStringSet(prefs_->GetList(prefs::kPluginsDisabledPlugins),
                        &policy_disabled_plugin_patterns_);
   ListValueToStringSet(
       prefs_->GetList(prefs::kPluginsDisabledPluginsExceptions),
       &policy_disabled_plugin_exception_patterns_);
   ListValueToStringSet(prefs_->GetList(prefs::kPluginsEnabledPlugins),
                        &policy_enabled_plugin_patterns_);
+  always_open_pdf_externally_ =
+      prefs_->GetBoolean(prefs::kAlwaysOpenPdfExternally);
 
   registrar_.Init(prefs_);
 
   // Because pointers to our own members will remain unchanged for the
   // lifetime of |registrar_| (which we also own), we can bind their
   // pointer values directly in the callbacks to avoid string-based
   // lookups at notification time.
   registrar_.Add(prefs::kPluginsDisabledPlugins,
                  base::Bind(&PluginPrefs::UpdatePatternsAndNotify,
                             base::Unretained(this),
                             &policy_disabled_plugin_patterns_));
   registrar_.Add(prefs::kPluginsDisabledPluginsExceptions,
                  base::Bind(&PluginPrefs::UpdatePatternsAndNotify,
                             base::Unretained(this),
                             &policy_disabled_plugin_exception_patterns_));
   registrar_.Add(prefs::kPluginsEnabledPlugins,
                  base::Bind(&PluginPrefs::UpdatePatternsAndNotify,
                             base::Unretained(this),
                             &policy_enabled_plugin_patterns_));
+  registrar_.Add(prefs::kAlwaysOpenPdfExternally,
+                 base::Bind(&PluginPrefs::UpdatePdfPolicy,
+                 base::Unretained(this)));
 
   NotifyPluginStatusChanged();
 }
 
 void PluginPrefs::ShutdownOnUIThread() {
   prefs_ = NULL;
   registrar_.RemoveAll();
 }
 
-PluginPrefs::PluginPrefs() : profile_(NULL),
+PluginPrefs::PluginPrefs() : always_open_pdf_externally_(false),
+                             profile_(NULL),
                              prefs_(NULL) {
 }
 
 PluginPrefs::~PluginPrefs() {
 }
 
 void PluginPrefs::SetPolicyEnforcedPluginPatterns(
     const std::set<base::string16>& disabled_patterns,
     const std::set<base::string16>& disabled_exception_patterns,
     const std::set<base::string16>& enabled_patterns) {
   policy_disabled_plugin_patterns_ = disabled_patterns;
   policy_disabled_plugin_exception_patterns_ = disabled_exception_patterns;
   policy_enabled_plugin_patterns_ = enabled_patterns;
 }
 
+void PluginPrefs::SetAlwaysOpenPdfExternally(bool always_open_pdf_externally) {
+  always_open_pdf_externally_ = always_open_pdf_externally;
+}
+
+
 void PluginPrefs::OnUpdatePreferences(
     const std::vector<content::WebPluginInfo>& plugins) {
   if (!prefs_)
     return;
 
   PluginFinder* finder = PluginFinder::GetInstance();
   ListPrefUpdate update(prefs_, prefs::kPluginsPluginsList);
   base::ListValue* plugins_list = update.Get();
   plugins_list->Clear();
 
@@ skipping 36 matching lines @@
   }
 }
 
 void PluginPrefs::NotifyPluginStatusChanged() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED,
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
 }