Address some additional cleanup work needed for the component flash 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"
 
 #if defined(OS_LINUX)
 #include <fcntl.h>
 #endif  // defined(OS_LINUX)
 
 #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 "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_linux.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"
 #include "content/public/common/user_agent.h"
 #include "extensions/common/constants.h"
 #include "gpu/config/gpu_info.h"
 #include "net/http/http_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
+#if defined(OS_LINUX)
+#include "chrome/common/component_flash_hint_file_linux.h"
+#endif  // defined(OS_LINUX)
+
 #if defined(OS_WIN)
 #include "base/win/registry.h"
 #include "base/win/windows_version.h"
 #endif
 
 #if !defined(DISABLE_NACL)
 #include "components/nacl/common/nacl_constants.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "components/nacl/common/nacl_sandbox_type.h"
 #endif
@@ skipping 174 matching lines @@
   // 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)
+// 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;
-  if (!PathService::Get(chrome::DIR_USER_DATA, &user_data_dir))
-    return false;
-  return base::PathExists(user_data_dir);
+  return PathService::Get(chrome::DIR_USER_DATA, &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::component_flash_hint_file::DoesHintFileExist()) {
+  if (component_flash_hint_file::DoesHintFileExist()) {
     base::FilePath flash_path;
     std::string version;
-    if (chrome::component_flash_hint_file::VerifyAndReturnFlashLocation(
-            &flash_path, &version)) {
+    if (component_flash_hint_file::VerifyAndReturnFlashLocation(&flash_path,
+                                                                &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 (!chrome::component_flash_hint_file::TestExecutableMapping(
-              flash_path)) {
+      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);
       return true;
-    } else {
-      LOG(ERROR)
-          << "Failed to locate and load the component updated flash plugin.";
     }
+    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();
 
@@ skipping 154 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) {
-  content::PepperPluginInfo* result = nullptr;
   auto it = std::max_element(
       plugins.begin(), plugins.end(),
       [](content::PepperPluginInfo* x, content::PepperPluginInfo* y) {
         Version version_x(x->version);
         DCHECK(version_x.IsValid());
         return version_x.IsOlderThan(y->version);
       });
-  if (it != plugins.end())
-    result = *it;
-  return result;
+  return it != plugins.end() ? *it : nullptr;
 }
 #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 21 matching lines @@
     flash_versions.push_back(bundled_flash.release());
 
   scoped_ptr<content::PepperPluginInfo> system_flash(
       new content::PepperPluginInfo);
   if (GetSystemPepperFlash(system_flash.get()))
     flash_versions.push_back(system_flash.release());
 
   // This function will return only the most recent version of the flash plugin.
   content::PepperPluginInfo* max_flash =
       FindMostRecentPlugin(flash_versions.get());
-  if (max_flash != nullptr)
+  if (max_flash)
     plugins->push_back(*max_flash);
 #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);
@@ skipping 72 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);
 }