atom/app/atom_content_client.cc

   1 // Copyright (c) 2014 GitHub, Inc.
   2 // Use of this source code is governed by the MIT license that can be
   3 // found in the LICENSE file.
   4
   5 #include "atom/app/atom_content_client.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "atom/common/atom_constants.h"
  11 #include "atom/common/atom_version.h"
  12 #include "atom/common/chrome_version.h"
  13 #include "atom/common/options_switches.h"
  14 #include "base/command_line.h"
  15 #include "base/files/file_util.h"
  16 #include "base/strings/string_split.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "content/public/common/content_constants.h"
  20 #include "content/public/common/pepper_plugin_info.h"
  21 #include "content/public/common/user_agent.h"
  22 #include "pdf/pdf.h"
  23 #include "ppapi/shared_impl/ppapi_permissions.h"
  24 #include "third_party/widevine/cdm/stub/widevine_cdm_version.h"
  25 #include "tizen_src/ewk/efl_integration/common/version_info.h"
  26 #include "ui/base/l10n/l10n_util.h"
  27 #include "url/url_constants.h"
  28
  29 #if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
  30 #include "chrome/common/widevine_cdm_constants.h"
  31 #endif
  32
  33 namespace atom {
  34
  35 namespace {
  36
  37 content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
  38                                                 const std::string& version) {
  39   content::PepperPluginInfo plugin;
  40
  41   plugin.is_out_of_process = true;
  42   plugin.name = content::kFlashPluginName;
  43   plugin.path = path;
  44   plugin.permissions = ppapi::PERMISSION_ALL_BITS;
  45
  46   std::vector<std::string> flash_version_numbers = base::SplitString(
  47       version, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  48   if (flash_version_numbers.empty())
  49     flash_version_numbers.push_back("11");
  50   // |SplitString()| puts in an empty string given an empty string. :(
  51   else if (flash_version_numbers[0].empty())
  52     flash_version_numbers[0] = "11";
  53   if (flash_version_numbers.size() < 2)
  54     flash_version_numbers.push_back("2");
  55   if (flash_version_numbers.size() < 3)
  56     flash_version_numbers.push_back("999");
  57   if (flash_version_numbers.size() < 4)
  58     flash_version_numbers.push_back("999");
  59   // E.g., "Shockwave Flash 10.2 r154":
  60   plugin.description = plugin.name + " " + flash_version_numbers[0] + "." +
  61       flash_version_numbers[1] + " r" + flash_version_numbers[2];
  62   plugin.version = base::JoinString(flash_version_numbers, ".");
  63   content::WebPluginMimeType swf_mime_type(
  64       content::kFlashPluginSwfMimeType,
  65       content::kFlashPluginSwfExtension,
  66       content::kFlashPluginSwfDescription);
  67   plugin.mime_types.push_back(swf_mime_type);
  68   content::WebPluginMimeType spl_mime_type(
  69       content::kFlashPluginSplMimeType,
  70       content::kFlashPluginSplExtension,
  71       content::kFlashPluginSplDescription);
  72   plugin.mime_types.push_back(spl_mime_type);
  73
  74   return plugin;
  75 }
  76
  77 #if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
  78 content::PepperPluginInfo CreateWidevineCdmInfo(const base::FilePath& path,
  79                                                 const std::string& version) {
  80   content::PepperPluginInfo widevine_cdm;
  81   widevine_cdm.is_out_of_process = true;
  82   widevine_cdm.path = path;
  83   widevine_cdm.name = kWidevineCdmDisplayName;
  84   widevine_cdm.description = kWidevineCdmDescription +
  85                              std::string(" (version: ") +
  86                              version + ")";
  87   widevine_cdm.version = version;
  88   content::WebPluginMimeType widevine_cdm_mime_type(
  89       kWidevineCdmPluginMimeType,
  90       kWidevineCdmPluginExtension,
  91       kWidevineCdmPluginMimeTypeDescription);
  92
  93   // Add the supported codecs as if they came from the component manifest.
  94   std::vector<std::string> codecs;
  95   codecs.push_back(kCdmSupportedCodecVp8);
  96   codecs.push_back(kCdmSupportedCodecVp9);
  97 #if defined(USE_PROPRIETARY_CODECS)
  98   codecs.push_back(kCdmSupportedCodecAvc1);
  99 #endif  // defined(USE_PROPRIETARY_CODECS)
 100   std::string codec_string = base::JoinString(
 101       codecs, std::string(1, kCdmSupportedCodecsValueDelimiter));
 102   widevine_cdm_mime_type.additional_param_names.push_back(
 103       base::ASCIIToUTF16(kCdmSupportedCodecsParamName));
 104   widevine_cdm_mime_type.additional_param_values.push_back(
 105       base::ASCIIToUTF16(codec_string));
 106
 107   widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
 108   widevine_cdm.permissions = kWidevineCdmPluginPermissions;
 109
 110   return widevine_cdm;
 111 }
 112 #endif
 113
 114 void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
 115   content::PepperPluginInfo pdf_info;
 116   pdf_info.is_internal = true;
 117   pdf_info.is_out_of_process = true;
 118   pdf_info.name = "Chromium PDF Viewer";
 119   pdf_info.description = "Portable Document Format";
 120   pdf_info.path = base::FilePath::FromUTF8Unsafe(kPdfPluginPath);
 121   content::WebPluginMimeType pdf_mime_type(kPdfPluginMimeType, "pdf",
 122                                            "Portable Document Format");
 123   pdf_info.mime_types.push_back(pdf_mime_type);
 124   pdf_info.internal_entry_points.get_interface = chrome_pdf::PPP_GetInterface;
 125   pdf_info.internal_entry_points.initialize_module =
 126       chrome_pdf::PPP_InitializeModule;
 127   pdf_info.internal_entry_points.shutdown_module =
 128       chrome_pdf::PPP_ShutdownModule;
 129   pdf_info.permissions = ppapi::PERMISSION_PRIVATE | ppapi::PERMISSION_DEV;
 130   plugins->push_back(pdf_info);
 131 }
 132
 133 void ConvertStringWithSeparatorToVector(std::vector<std::string>* vec,
 134                                         const char* separator,
 135                                         const char* cmd_switch) {
 136   auto command_line = base::CommandLine::ForCurrentProcess();
 137   auto string_with_separator = command_line->GetSwitchValueASCII(cmd_switch);
 138   if (!string_with_separator.empty())
 139     *vec = base::SplitString(string_with_separator, separator,
 140                              base::TRIM_WHITESPACE,
 141                              base::SPLIT_WANT_NONEMPTY);
 142 }
 143
 144 }  // namespace
 145
 146 void AddPepperFlashFromCommandLine(
 147     std::vector<content::PepperPluginInfo>* plugins) {
 148   auto command_line = base::CommandLine::ForCurrentProcess();
 149   base::FilePath flash_path = command_line->GetSwitchValuePath(
 150       switches::kPpapiFlashPath);
 151   if (flash_path.empty())
 152     return;
 153
 154   auto flash_version = command_line->GetSwitchValueASCII(
 155       switches::kPpapiFlashVersion);
 156
 157   plugins->push_back(CreatePepperFlashInfo(flash_path, flash_version));
 158 }
 159
 160 #if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
 161 void AddWidevineCdmFromCommandLine(
 162     std::vector<content::PepperPluginInfo>* plugins) {
 163   auto command_line = base::CommandLine::ForCurrentProcess();
 164   base::FilePath widevine_cdm_path = command_line->GetSwitchValuePath(
 165       switches::kWidevineCdmPath);
 166   if (widevine_cdm_path.empty())
 167     return;
 168
 169   if (!base::PathExists(widevine_cdm_path))
 170     return;
 171
 172   auto widevine_cdm_version = command_line->GetSwitchValueASCII(
 173       switches::kWidevineCdmVersion);
 174   if (widevine_cdm_version.empty())
 175     return;
 176
 177   plugins->push_back(CreateWidevineCdmInfo(widevine_cdm_path,
 178                                            widevine_cdm_version));
 179 }
 180 #endif
 181
 182 AtomContentClient::AtomContentClient() {
 183 }
 184
 185 AtomContentClient::~AtomContentClient() {
 186 }
 187
 188 std::string AtomContentClient::GetProduct() const {
 189   return "Chrome/" CHROME_VERSION_STRING;
 190 }
 191
 192 std::string AtomContentClient::GetUserAgent() const {
 193   const std::string system_info= EflWebView::VersionInfo::GetInstance()->OSType();
 194   return content::BuildUserAgentFromOSAndProduct(
 195       system_info,"Chrome/" CHROME_VERSION_STRING " " ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING);
 196 }
 197
 198 base::string16 AtomContentClient::GetLocalizedString(int message_id) const {
 199   return l10n_util::GetStringUTF16(message_id);
 200 }
 201
 202 void AtomContentClient::AddAdditionalSchemes(
 203     std::vector<url::SchemeWithType>* standard_schemes,
 204     std::vector<url::SchemeWithType>* referrer_schemes,
 205     std::vector<std::string>* savable_schemes) {
 206   standard_schemes->push_back({"chrome-extension", url::SCHEME_WITHOUT_PORT});
 207 }
 208
 209 void AtomContentClient::AddPepperPlugins(
 210     std::vector<content::PepperPluginInfo>* plugins) {
 211   AddPepperFlashFromCommandLine(plugins);
 212 #if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
 213   AddWidevineCdmFromCommandLine(plugins);
 214 #endif
 215   ComputeBuiltInPlugins(plugins);
 216 }
 217
 218 void AtomContentClient::AddServiceWorkerSchemes(
 219     std::set<std::string>* service_worker_schemes) {
 220   std::vector<std::string> schemes;
 221   ConvertStringWithSeparatorToVector(&schemes, ",",
 222                                      switches::kRegisterServiceWorkerSchemes);
 223   for (const std::string& scheme : schemes)
 224     service_worker_schemes->insert(scheme);
 225
 226   service_worker_schemes->insert(url::kFileScheme);
 227 }
 228
 229 void AtomContentClient::AddSecureSchemesAndOrigins(
 230     std::set<std::string>* secure_schemes,
 231     std::set<GURL>* secure_origins) {
 232   std::vector<std::string> schemes;
 233   ConvertStringWithSeparatorToVector(&schemes, ",", switches::kSecureSchemes);
 234   for (const std::string& scheme : schemes)
 235     secure_schemes->insert(scheme);
 236 }
 237
 238
 239 }  // namespace atom