Do not replace up-to-date System Flash with Component Flash.

chrome/common/chrome_content_client.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/common/chrome_content_client.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
@@ skipping 213 matching lines @@
     widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
     widevine_cdm.permissions = kWidevineCdmPluginPermissions;
     plugins->push_back(widevine_cdm);
   }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE_NOT_COMPONENT)
 }
 
 // Creates a PepperPluginInfo for the specified plugin.
 // |path| is the full path to the plugin.
 // |version| is a string representation of the plugin version.
-// |is_debug| is whether the plugin is the debug version or not.
 // |is_external| is whether the plugin is supplied external to Chrome e.g. a
 //     system installation of Adobe Flash.
-// |is_bundled| distinguishes between component updated plugin and a bundled
-//     plugin.
 content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
                                                 const std::string& version,
-                                                bool is_debug,
-                                                bool is_external,
-                                                bool is_bundled) {
+                                                bool is_external) {
   content::PepperPluginInfo plugin;
 
   plugin.is_out_of_process = true;
   plugin.name = content::kFlashPluginName;
   plugin.path = path;
-#if defined(OS_WIN)
-  plugin.is_on_local_drive = !base::IsOnNetworkDrive(path);
-#endif
   plugin.permissions = chrome::kPepperFlashPermissions;
-  plugin.is_debug = is_debug;
   plugin.is_external = is_external;
-  plugin.is_bundled = is_bundled;
 
   std::vector<std::string> flash_version_numbers = base::SplitString(
       version, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (flash_version_numbers.size() < 1)
     flash_version_numbers.push_back("11");
   if (flash_version_numbers.size() < 2)
     flash_version_numbers.push_back("2");
   if (flash_version_numbers.size() < 3)
     flash_version_numbers.push_back("999");
   if (flash_version_numbers.size() < 4)
@@ skipping 20 matching lines @@
           switches::kPpapiFlashPath);
   if (flash_path.empty())
     return false;
 
   // Also get the version from the command-line. Should be something like 11.2
   // or 11.2.123.45.
   std::string flash_version =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kPpapiFlashVersion);
 
-  *plugin = CreatePepperFlashInfo(base::FilePath(flash_path),
-                                  flash_version, false, true, false);
+  *plugin = CreatePepperFlashInfo(base::FilePath(flash_path), flash_version,
+                                  true);
   return true;
 }
 
 // Check if flash player exists on disk, and if so, populate a PepperPluginInfo
 // structure. Returns false if the flash player found is not compatible with the
 // system (architecture, OS, versions, etc.).
 bool TryCreatePepperFlashInfo(const base::FilePath& flash_filename,
                               content::PepperPluginInfo* plugin) {
   if (!base::PathExists(flash_filename))
     return false;
 
   base::FilePath manifest_path(
       flash_filename.DirName().Append(FILE_PATH_LITERAL("manifest.json")));
 
   std::string manifest_data;
   if (!base::ReadFileToString(manifest_path, &manifest_data))
     return false;
 
   std::unique_ptr<base::DictionaryValue> manifest = base::DictionaryValue::From(
       base::JSONReader::Read(manifest_data, base::JSON_ALLOW_TRAILING_COMMAS));
   if (!manifest)
     return false;
 
   base::Version version;
   if (!chrome::CheckPepperFlashManifest(*manifest, &version)) {
     LOG(ERROR) << "Browser not compatible with given flash manifest.";
     return false;
   }
 
-  *plugin = CreatePepperFlashInfo(flash_filename, version.GetString(),
-                                  chrome::IsSystemFlashScriptDebuggerPresent(),
-                                  /*is_external=*/true,
-                                  /*is_bundled=*/false);
+  *plugin = CreatePepperFlashInfo(flash_filename, version.GetString(), true);
   return true;
 }
 
 #if defined(OS_CHROMEOS)
 bool GetComponentUpdatedPepperFlash(content::PepperPluginInfo* plugin) {
   base::FilePath flash_filename;
   if (!base::PathService::Get(chrome::FILE_CHROME_OS_COMPONENT_FLASH,
                               &flash_filename)) {
     return false;
   }
@@ skipping 22 matching lines @@
                                                                 &version)) {
       // Test if the file can be mapped as executable. If the user's home
       // directory is mounted noexec, the component flash plugin will not load.
       // By testing for this, Chrome can fallback to the bundled flash plugin.
       if (!component_flash_hint_file::TestExecutableMapping(flash_path)) {
         LOG(WARNING) << "The component updated flash plugin could not be "
                         "mapped as executable. Attempting to fallback to the "
                         "bundled or system plugin.";
         return false;
       }
-      *plugin = CreatePepperFlashInfo(flash_path, version, false, false, false);
+      *plugin = CreatePepperFlashInfo(flash_path, version, false);
       return true;
     }
     LOG(ERROR)
         << "Failed to locate and load the component updated flash plugin.";
   }
 #endif  // defined(FLAPPER_AVAILABLE)
   return false;
 }
 #endif  // defined(OS_CHROMEOS)
 
@@ skipping 90 matching lines @@
 #endif
 }
 
 #if defined(ENABLE_PLUGINS)
 // static
 content::PepperPluginInfo* ChromeContentClient::FindMostRecentPlugin(
     const std::vector<std::unique_ptr<content::PepperPluginInfo>>& plugins) {
   if (plugins.empty())
     return nullptr;
 
-  using PluginSortKey = std::tuple<base::Version, bool, bool, bool, bool>;
+  using PluginSortKey = std::tuple<base::Version, bool>;
 
   std::map<PluginSortKey, content::PepperPluginInfo*> plugin_map;
 
   for (auto& plugin : plugins) {
     base::Version version(plugin->version);
     DCHECK(version.IsValid());
-    plugin_map[PluginSortKey(version, plugin->is_debug, plugin->is_bundled,
-                             plugin->is_on_local_drive, !plugin->is_external)] =
-        plugin.get();
+    plugin_map[PluginSortKey(version, plugin->is_external)] = plugin.get();
   }
 
   return plugin_map.rbegin()->second;
 }
 #endif  // defined(ENABLE_PLUGINS)
 
 void ChromeContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
 #if defined(ENABLE_PLUGINS)
   ComputeBuiltInPlugins(plugins);
@@ skipping 28 matching lines @@
     plugins->push_back(*max_flash);
   } else {
 #if defined(GOOGLE_CHROME_BUILD) && defined(FLAPPER_AVAILABLE)
     // Add a fake Flash plugin even though it doesn't actually exist - if a
     // web page requests it, it will be component-updated on-demand. There is
     // nothing that guarantees the component update will give us the
     // FLAPPER_VERSION_STRING version of Flash, but using this version seems
     // better than any other hardcoded alternative.
     plugins->push_back(CreatePepperFlashInfo(
         base::FilePath::FromUTF8Unsafe(ChromeContentClient::kNotPresent),
-        FLAPPER_VERSION_STRING, false, false, true));
+        FLAPPER_VERSION_STRING, false));
 #endif  // defined(GOOGLE_CHROME_BUILD) && defined(FLAPPER_AVAILABLE)
   }
 #endif  // defined(ENABLE_PLUGINS)
 }
 
 void ChromeContentClient::AddContentDecryptionModules(
     std::vector<content::CdmInfo>* cdms) {
 // TODO(jrummell): Need to have a better flag to indicate systems Widevine
 // is available on. For now we continue to use ENABLE_PEPPER_CDMS so that
 // we can experiment between pepper and mojo.
@@ skipping 147 matching lines @@
   if (!origin_trial_policy_)
     origin_trial_policy_ = base::MakeUnique<ChromeOriginTrialPolicy>();
   return origin_trial_policy_.get();
 }
 
 #if defined(OS_ANDROID)
 media::MediaClientAndroid* ChromeContentClient::GetMediaClientAndroid() {
   return new ChromeMediaClientAndroid();
 }
 #endif  // OS_ANDROID