Prefer System Flash over non-local component updated 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 "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/tuple.h"
 #include "build/build_config.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/pepper_flash.h"
 #include "chrome/common/secure_origin_whitelist.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/common_resources.h"
@@ skipping 159 matching lines @@
       widevine_cdm.permissions = kWidevineCdmPluginPermissions;
       plugins->push_back(widevine_cdm);
 
       skip_widevine_cdm_file_check = true;
     }
   }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) &&
         // !defined(WIDEVINE_CDM_IS_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_debug,
+                                                bool is_external,
+                                                bool is_bundled) {
   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 22 matching lines @@
   if (flash_path.empty())
     return;
 
   // 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);
 
   plugins->push_back(
-      CreatePepperFlashInfo(base::FilePath(flash_path), flash_version, false));
+      CreatePepperFlashInfo(base::FilePath(flash_path),
+                            flash_version, false, true, false));
 }
 
 #if defined(OS_LINUX)
 // This function tests if DIR_USER_DATA can be accessed, as a simple check to
 // see if the zygote has been sandboxed at this point.
 bool IsUserDataDirAvailable() {
   base::FilePath user_data_dir;
   return PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 }
 
@@ skipping 13 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);
+      *plugin = CreatePepperFlashInfo(flash_path, version, false, false, false);
       return true;
     }
     LOG(ERROR)
         << "Failed to locate and load the component updated flash plugin.";
   }
 #endif  // defined(FLAPPER_AVAILABLE)
   return false;
 }
 #endif  // defined(OS_LINUX)
 
 bool GetBundledPepperFlash(content::PepperPluginInfo* plugin) {
 #if defined(FLAPPER_AVAILABLE)
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   // Ignore bundled Pepper Flash if there is Pepper Flash specified from the
   // command-line.
   if (command_line->HasSwitch(switches::kPpapiFlashPath))
     return false;
 
   bool force_disable =
       command_line->HasSwitch(switches::kDisableBundledPpapiFlash);
   if (force_disable)
     return false;
 
   base::FilePath flash_path;
   if (!PathService::Get(chrome::FILE_PEPPER_FLASH_PLUGIN, &flash_path))
     return false;
 
-  *plugin = CreatePepperFlashInfo(flash_path, FLAPPER_VERSION_STRING, false);
+  *plugin = CreatePepperFlashInfo(flash_path, FLAPPER_VERSION_STRING, false,
+                                  false, true);
   return true;
 #else
   return false;
 #endif  // FLAPPER_AVAILABLE
 }
 
 bool IsSystemFlashScriptDebuggerPresent() {
 #if defined(OS_WIN)
   const wchar_t kFlashRegistryRoot[] =
       L"SOFTWARE\\Macromedia\\FlashPlayerPepper";
   const wchar_t kIsDebuggerValueName[] = L"isScriptDebugger";
 
   base::win::RegKey path_key(HKEY_LOCAL_MACHINE, kFlashRegistryRoot, KEY_READ);
   DWORD debug_value;
   if (path_key.ReadValueDW(kIsDebuggerValueName, &debug_value) != ERROR_SUCCESS)
     return false;
 
   return (debug_value == 1);
 #else
   // TODO(wfh): implement this on OS X and Linux. crbug.com/497996.
   return false;
 #endif
 }
 
 bool GetSystemPepperFlash(content::PepperPluginInfo* plugin) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  bool system_flash_is_debug = IsSystemFlashScriptDebuggerPresent();
-
-#if defined(FLAPPER_AVAILABLE)
-  // If flapper is available, only try the system plugin if either:
-  // --disable-bundled-ppapi-flash is specified, or the system debugger is the
-  // Flash Script Debugger.
-  if (!(command_line->HasSwitch(switches::kDisableBundledPpapiFlash) ||
-        system_flash_is_debug)) {
-    return false;
-  }
-#endif  // defined(FLAPPER_AVAILABLE)
-
   // Do not try and find System Pepper Flash if there is a specific path on
   // the commmand-line.
   if (command_line->HasSwitch(switches::kPpapiFlashPath))
     return false;
 
   base::FilePath flash_filename;
   if (!PathService::Get(chrome::FILE_PEPPER_FLASH_SYSTEM_PLUGIN,
                         &flash_filename))
     return false;
 
@@ skipping 11 matching lines @@
   if (!manifest_value.get())
     return false;
   base::DictionaryValue* manifest = NULL;
   if (!manifest_value->GetAsDictionary(&manifest))
     return false;
 
   Version version;
   if (!chrome::CheckPepperFlashManifest(*manifest, &version))
     return false;
 
-  *plugin = CreatePepperFlashInfo(flash_filename, version.GetString(),
-                                  system_flash_is_debug);
+  *plugin = CreatePepperFlashInfo(flash_filename,
+                                  version.GetString(),
+                                  IsSystemFlashScriptDebuggerPresent(),
+                                  true,
+                                  false);
   return true;
 }
 #endif  //  defined(ENABLE_PLUGINS)
 
 std::string GetProduct() {
   return version_info::GetProductNameAndVersionForUserAgent();
 }
 
 }  // namespace
 
@@ skipping 59 matching lines @@
 #elif defined(OS_POSIX)
   base::debug::SetCrashKeyValue(crash_keys::kGPUVendor, gpu_info.gl_vendor);
   base::debug::SetCrashKeyValue(crash_keys::kGPURenderer, gpu_info.gl_renderer);
 #endif
 }
 
 #if defined(ENABLE_PLUGINS)
 // static
 content::PepperPluginInfo* ChromeContentClient::FindMostRecentPlugin(
     const std::vector<content::PepperPluginInfo*>& plugins) {
-  auto it = std::max_element(
-      plugins.begin(), plugins.end(),
-      [](content::PepperPluginInfo* x, content::PepperPluginInfo* y) {
-        Version version_x(x->version);
-        Version version_y(y->version);
-        DCHECK(version_x.IsValid() && version_y.IsValid());
-        if (version_x == version_y)
-          return !x->is_debug && y->is_debug;
-        return version_x < version_y;
-      });
-  return it != plugins.end() ? *it : nullptr;
+  if (!plugins.size())

[Lei Zhang, 2016/04/15 21:16:36]

if (plugins.empty())

[Will Harris, 2016/04/15 21:43:28]

Done.

+    return nullptr;
+
+  using PluginSortKey = base::Tuple<base::Version, bool, bool, bool, bool>;
+
+  std::map<PluginSortKey, content::PepperPluginInfo*> plugin_map;
+
+  for (const auto& plugin : plugins)
+    plugin_map[PluginSortKey(Version(plugin->version), plugin->is_debug,
+                             plugin->is_bundled, plugin->is_on_local_drive,
+                             !plugin->is_external)] = plugin;
+
+  return plugin_map.rbegin()->second;
 }
 #endif  // defined(ENABLE_PLUGINS)
 
 void ChromeContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
 #if defined(ENABLE_PLUGINS)
   ComputeBuiltInPlugins(plugins);
   AddPepperFlashFromCommandLine(plugins);
 
 #if defined(OS_LINUX)
@@ skipping 152 matching lines @@
 #if defined(ENABLE_EXTENSIONS)
   return extensions::IsIsolateExtensionsEnabled();
 #else
   return false;
 #endif
 }
 
 base::StringPiece ChromeContentClient::GetOriginTrialPublicKey() {
   return origin_trial_key_manager_.GetPublicKey();
 }