Add support for Flash Player Component updates on Linux

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 <fcntl.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/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 "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/component_flash_hint_file.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"
 #include "components/dom_distiller/core/url_constants.h"
 #include "components/version_info/version_info.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
@@ skipping 241 matching lines @@
   // 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));
 }
 
+#if defined(OS_LINUX)
+bool IsUserDataDirAvailable() {
+  base::FilePath user_data_dir;
+  if (!PathService::Get(chrome::DIR_USER_DATA, &user_data_dir))
+    return false;
+  return base::PathExists(user_data_dir);
+}
+
+// This method is used on Linux only because of architectural differences in how
+// it loads the component updated flash plugin, and not because the other
+// platforms do not support component updated flash. On other platforms, the
+// component updater sends an IPC message to all threads, at undefined points in
+// time, with the URL of the component updated flash. Because the linux zygote
+// thread has no access to the file system after it warms up, it must preload
+// the component updated flash.
+bool GetComponentUpdatedPepperFlash(content::PepperPluginInfo* plugin) {
+#if defined(FLAPPER_AVAILABLE)
+  if (chrome::ComponentFlashHintFile::DoesHintFileExist()) {
+    base::FilePath flash_path;
+    std::string version;
+    const bool verified =
+        chrome::ComponentFlashHintFile::VerifyAndReturnFlashLocation(
+            &flash_path, &version);
+    // In case the user's home directory is mounted NOEXEC, or the plugin could

[jln (very slow on Chromium), 2015/08/06 18:48:14]

s/NOEXEC/noexec/

[Greg K, 2015/08/07 21:15:28]

Done.

+    // not be verified, do not use the plugin.

[jln (very slow on Chromium), 2015/08/06 18:48:14]

Log an error if !verified?

[Greg K, 2015/08/07 21:15:28]

Yes, although it's misleading because that function can return false for a
number of reasons, and the function already logs if the SHAs don't match up. I
will drop the verified bool and just add a log explaining that it failed to find
the flash plugin.

+    if (verified &&
+        chrome::ComponentFlashHintFile::TestExecutableMapping(flash_path)) {

[jln (very slow on Chromium), 2015/08/06 18:48:14]

Explain why it's useful to bail early in case we can't map it as executable.

[Greg K, 2015/08/07 21:15:28]

Done.

+      *plugin = CreatePepperFlashInfo(flash_path, version);
+      return true;
+    }
+  }
+  return false;
+#else
+  return false;

[jln (very slow on Chromium), 2015/08/06 18:48:14]

Nit: return false outside of the #if #else seems a bit more readable.

[Greg K, 2015/08/07 21:15:28]

Done.

+#endif  // defined(FLAPPER_AVAILABLE)
+}
+#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 =
@@ skipping 163 matching lines @@
   base::debug::SetCrashKeyValue(crash_keys::kGPURenderer, gpu_info.gl_renderer);
 #endif
 }
 
 void ChromeContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
 #if defined(ENABLE_PLUGINS)
   ComputeBuiltInPlugins(plugins);
   AddPepperFlashFromCommandLine(plugins);
 
-  content::PepperPluginInfo plugin;
-  if (GetBundledPepperFlash(&plugin))
-    plugins->push_back(plugin);
-  if (GetSystemPepperFlash(&plugin))
-    plugins->push_back(plugin);
-#endif
+#if defined(OS_LINUX)
+  // Depending on the sandbox configurtion, the user data directory
+  // is not always available. If it is not available, do not try and load and
+  // flash plugin. It may incorrectly try to load the system flash plugin in
+  // this case.

[jln (very slow on Chromium), 2015/08/06 18:48:14]

What happens in this case? Is it falling back to the system Flash plugin or not?

[Greg K, 2015/08/07 21:15:28]

I clarified that it will continue to use whatever flash plugin was loaded before
sandbox initialization.

+  if (!IsUserDataDirAvailable()) {
+    return;
+  }
+#endif  // defined(OS_LINUX)
+
+  std::vector<content::PepperPluginInfo*> flash_versions;

[jln (very slow on Chromium), 2015/08/06 18:48:14]

This is a little strange because this vector will outlive the objects it is
pointing to at the function's epilogue.

How about a scoped_vector and allocating these objects on the heap instead?

[Greg K, 2015/08/07 21:15:28]

Done.

+
+#if defined(OS_LINUX)
+  content::PepperPluginInfo component_flash;
+  if (GetComponentUpdatedPepperFlash(&component_flash))
+    flash_versions.push_back(&component_flash);
+#endif  // defined(OS_LINUX)
+
+  content::PepperPluginInfo bundled_flash;

[jln (very slow on Chromium), 2015/08/06 18:48:14]

How is this logic affecting other platforms than Linux?

The commit message doesn't say anything, so please make that clear.

[Greg K, 2015/08/07 21:15:28]

Will do, answer: it shouldn't affect other platforms at all, unless there's a
bug of course. 

+  if (GetBundledPepperFlash(&bundled_flash))
+    flash_versions.push_back(&bundled_flash);
+
+  content::PepperPluginInfo system_flash;
+  if (GetSystemPepperFlash(&system_flash))
+    flash_versions.push_back(&system_flash);
+
+  // Now sort the list and add the most recent flash plugin to the plugins list.
+  std::sort(flash_versions.begin(), flash_versions.end(),

[jln (very slow on Chromium), 2015/08/06 18:48:14]

I wonder if version comparison shouldn't be it's own separate function that is
unit tested.

[Greg K, 2015/08/07 21:15:28]

Done.

+            [](content::PepperPluginInfo* x, content::PepperPluginInfo* y) {
+              Version version_x(x->version);
+              DCHECK(version_x.IsValid());
+              return version_x.IsOlderThan(y->version);
+            });
+  // Use the last element in the list, which will be the most recent flash.
+  if (flash_versions.size() > 0)

[jln (very slow on Chromium), 2015/08/06 18:48:14]

It looks like you only need max_element, not a full sort, no?

[Greg K, 2015/08/07 21:15:28]

Done.

+    plugins->push_back(*flash_versions.back());
+#endif  // defined(ENABLE_PLUGINS)
 }
 
 void ChromeContentClient::AddAdditionalSchemes(
     std::vector<std::string>* standard_schemes,
     std::vector<std::string>* savable_schemes) {
   standard_schemes->push_back(extensions::kExtensionScheme);
   savable_schemes->push_back(extensions::kExtensionScheme);
   standard_schemes->push_back(chrome::kChromeNativeScheme);
   standard_schemes->push_back(extensions::kExtensionResourceScheme);
   savable_schemes->push_back(extensions::kExtensionResourceScheme);
@@ skipping 69 matching lines @@
   schemes->insert(content::kChromeUIScheme);
   schemes->insert(extensions::kExtensionScheme);
   schemes->insert(extensions::kExtensionResourceScheme);
   GetSecureOriginWhitelist(origins);
 }
 
 void ChromeContentClient::AddServiceWorkerSchemes(
     std::set<std::string>* schemes) {
   schemes->insert(extensions::kExtensionScheme);
 }