Don't use command line flags for enabling the internal pdf plugin. Instead, ...

chrome/browser/plugin_service.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #include "chrome/browser/plugin_service.h"
 
 #include "base/command_line.h"
 #include "base/path_service.h"
@@ skipping 33 matching lines @@
   for (ChildProcessHost::Iterator iter(ChildProcessInfo::PLUGIN_PROCESS);
        !iter.Done(); ++iter) {
     PluginProcessHost* plugin = static_cast<PluginProcessHost*>(*iter);
     plugin->OnAppActivation();
   }
 }
 #endif
 
 // static
 bool PluginService::enable_chrome_plugins_ = true;
+bool PluginService::enable_internal_pdf_ = false;
 
 // static
 void PluginService::InitGlobalInstance(Profile* profile) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   bool update_internal_dir = false;
   FilePath last_internal_dir =
       profile->GetPrefs()->GetFilePath(prefs::kPluginsLastInternalDirectory);
   FilePath cur_internal_dir;
-  if (PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &cur_internal_dir))
-    update_internal_dir = (cur_internal_dir != last_internal_dir);
+  if (PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &cur_internal_dir) &&
+      cur_internal_dir != last_internal_dir) {
+    update_internal_dir = true;
+    profile->GetPrefs()->SetFilePath(
+        prefs::kPluginsLastInternalDirectory, cur_internal_dir);
+  }
+
+  bool found_internal_pdf = false;
+  bool force_enable_internal_pdf = false;
+  FilePath pdf_path;
+  PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_path);
+  FilePath::StringType pdf_path_str = pdf_path.value();
+  if (enable_internal_pdf_ &&
+      !profile->GetPrefs()->GetBoolean(prefs::kPluginsEnabledInternalPDF)) {
+    // We switched to the internal pdf plugin being on by default, and so we
+    // need to force it to be enabled.  We only want to do it this once though,
+    // i.e. we don't want to enable it again if the user disables it afterwards.
+    profile->GetPrefs()->SetBoolean(prefs::kPluginsEnabledInternalPDF, true);
+    force_enable_internal_pdf = true;
+  }
 
   // Disable plugins listed as disabled in prefs.
-  if (const ListValue* saved_plugins_list =
-          profile->GetPrefs()->GetList(prefs::kPluginsPluginsList)) {
+  if (ListValue* saved_plugins_list =
+          profile->GetPrefs()->GetMutableList(prefs::kPluginsPluginsList)) {
     for (ListValue::const_iterator it = saved_plugins_list->begin();
          it != saved_plugins_list->end();
          ++it) {
       if (!(*it)->IsType(Value::TYPE_DICTIONARY)) {
         LOG(WARNING) << "Invalid entry in " << prefs::kPluginsPluginsList;
         continue;  // Oops, don't know what to do with this item.
       }
 
       DictionaryValue* plugin = static_cast<DictionaryValue*>(*it);
       FilePath::StringType path;
+      if (!plugin->GetString(L"path", &path))
+        continue;
+
       bool enabled = true;
       plugin->GetBoolean(L"enabled", &enabled);
-      if (!enabled && plugin->GetString(L"path", &path)) {
-        FilePath plugin_path(path);
-        NPAPI::PluginList::Singleton()->DisablePlugin(plugin_path);
 
-        // If the internal plugin directory has changed and if the plugin looks
-        // internal, also disable it in the current internal plugins directory.
-        if (update_internal_dir &&
-            plugin_path.DirName() == last_internal_dir) {
-          NPAPI::PluginList::Singleton()->DisablePlugin(
-              cur_internal_dir.Append(plugin_path.BaseName()));
+      if (path == pdf_path_str) {
+        found_internal_pdf = true;
+        if (!enabled && force_enable_internal_pdf) {
+          enabled = true;
+          plugin->SetBoolean(L"enabled", true);
         }
       }
+
+      FilePath plugin_path(path);
+      if (update_internal_dir && plugin_path.DirName() == last_internal_dir) {
+        // If the internal plugin directory has changed and if the plugin looks
+        // internal, update its path in the prefs.
+        plugin_path = cur_internal_dir.Append(plugin_path.BaseName());
+        plugin->SetString(L"path", plugin_path.value());
+      }
+
+      if (!enabled)
+        NPAPI::PluginList::Singleton()->DisablePlugin(plugin_path);
     }
   }
 
+  if (!enable_internal_pdf_ && !found_internal_pdf) {
+    // The internal PDF plugin is disabled by default, and the user hasn't
+    // overridden the default.
+    NPAPI::PluginList::Singleton()->DisablePlugin(pdf_path);
+  }
+
   // Have Chrome plugins write their data to the profile directory.
   GetInstance()->SetChromePluginDataDir(profile->GetPath());
 }
 
 // static
 PluginService* PluginService::GetInstance() {
   return Singleton<PluginService>::get();
 }
 
 // static
 void PluginService::EnableChromePlugins(bool enable) {
   enable_chrome_plugins_ = enable;
 }
 
 PluginService::PluginService()
     : main_message_loop_(MessageLoop::current()),
       resource_dispatcher_host_(NULL),
       ui_locale_(ASCIIToWide(g_browser_process->GetApplicationLocale())) {
   // Have the NPAPI plugin list search for Chrome plugins as well.
   ChromePluginLib::RegisterPluginsWithNPAPI();
   // Load the one specified on the command line as well.
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   FilePath path = command_line->GetSwitchValuePath(switches::kLoadPlugin);
-  if (!path.empty()) {
+  if (!path.empty())
+    NPAPI::PluginList::Singleton()->AddExtraPluginPath(path);
+
+  // Register the internal Flash and PDF, if available.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableInternalFlash) &&
+      PathService::Get(chrome::FILE_FLASH_PLUGIN, &path)) {
     NPAPI::PluginList::Singleton()->AddExtraPluginPath(path);
   }
 
-  FilePath pdf;
-  if (command_line->HasSwitch(switches::kInternalPDF) &&
-      PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf)) {
-    NPAPI::PluginList::Singleton()->AddExtraPluginPath(pdf);
-  }
+  if (PathService::Get(chrome::FILE_PDF_PLUGIN, &path))
+    NPAPI::PluginList::Singleton()->AddExtraPluginPath(path);
 
 #ifndef DISABLE_NACL
   if (command_line->HasSwitch(switches::kInternalNaCl))
     RegisterInternalNaClPlugin();
 #endif
 
   chrome::RegisterInternalGPUPlugin();
 
 #if defined(OS_WIN)
   hkcu_key_.Create(
@@ skipping 230 matching lines @@
   PrivatePluginMap::iterator it = private_plugins_.find(plugin_path);
   if (it == private_plugins_.end())
     return true;  // This plugin is not private, so it's allowed everywhere.
 
   // We do a dumb compare of scheme and host, rather than using the domain
   // service, since we only care about this for extensions.
   const GURL& required_url = it->second;
   return (url.scheme() == required_url.scheme() &&
           url.host() == required_url.host());
 }