chrome_content_client.cc revision 010d83a9304c5a91596085d917d248abff47903a 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/common/chrome_content_client.h"
6
7#include "base/command_line.h"
8#include "base/cpu.h"
9#include "base/debug/crash_logging.h"
10#include "base/file_util.h"
11#include "base/path_service.h"
12#include "base/strings/string16.h"
13#include "base/strings/string_number_conversions.h"
14#include "base/strings/string_split.h"
15#include "base/strings/string_util.h"
16#include "base/strings/stringprintf.h"
17#include "base/strings/utf_string_conversions.h"
18#include "build/build_config.h"
19#include "chrome/common/child_process_logging.h"
20#include "chrome/common/chrome_paths.h"
21#include "chrome/common/chrome_switches.h"
22#include "chrome/common/chrome_version_info.h"
23#include "chrome/common/crash_keys.h"
24#include "chrome/common/pepper_flash.h"
25#include "chrome/common/render_messages.h"
26#include "chrome/common/url_constants.h"
27#include "components/nacl/common/nacl_process_type.h"
28#include "content/public/common/content_constants.h"
29#include "content/public/common/content_switches.h"
30#include "content/public/common/pepper_plugin_info.h"
31#include "content/public/common/url_constants.h"
32#include "content/public/common/user_agent.h"
33#include "extensions/common/constants.h"
34#include "gpu/config/gpu_info.h"
35#include "grit/common_resources.h"
36#include "ppapi/shared_impl/ppapi_permissions.h"
37#include "ui/base/l10n/l10n_util.h"
38#include "ui/base/layout.h"
39#include "ui/base/resource/resource_bundle.h"
40
41#include "flapper_version.h"  // In SHARED_INTERMEDIATE_DIR.
42#include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
43
44#if defined(OS_WIN)
45#include "base/win/registry.h"
46#include "base/win/windows_version.h"
47#elif defined(OS_MACOSX)
48#include "components/nacl/common/nacl_sandbox_type_mac.h"
49#endif
50
51#if defined(ENABLE_REMOTING)
52#include "remoting/client/plugin/pepper_entrypoints.h"
53#endif
54
55#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \
56    !defined(WIDEVINE_CDM_IS_COMPONENT)
57#include "chrome/common/widevine_cdm_constants.h"
58#endif
59
60namespace {
61
62const char kPDFPluginMimeType[] = "application/pdf";
63const char kPDFPluginExtension[] = "pdf";
64const char kPDFPluginDescription[] = "Portable Document Format";
65const char kPDFPluginPrintPreviewMimeType[] =
66   "application/x-google-chrome-print-preview-pdf";
67const char kPDFPluginOutOfProcessMimeType[] =
68   "application/x-google-chrome-pdf";
69const uint32 kPDFPluginPermissions = ppapi::PERMISSION_PRIVATE |
70                                     ppapi::PERMISSION_DEV;
71
72const char kNaClPluginMimeType[] = "application/x-nacl";
73const char kNaClPluginExtension[] = "";
74const char kNaClPluginDescription[] = "Native Client Executable";
75const uint32 kNaClPluginPermissions = ppapi::PERMISSION_PRIVATE |
76                                      ppapi::PERMISSION_DEV;
77
78const char kPnaclPluginMimeType[] = "application/x-pnacl";
79const char kPnaclPluginExtension[] = "";
80const char kPnaclPluginDescription[] = "Portable Native Client Executable";
81
82const char kO1DPluginName[] = "Google Talk Plugin Video Renderer";
83const char kO1DPluginMimeType[] ="application/o1d";
84const char kO1DPluginExtension[] = "";
85const char kO1DPluginDescription[] = "Google Talk Plugin Video Renderer";
86const uint32 kO1DPluginPermissions = ppapi::PERMISSION_PRIVATE |
87                                     ppapi::PERMISSION_DEV;
88
89const char kEffectsPluginName[] = "Google Talk Effects Plugin";
90const char kEffectsPluginMimeType[] ="application/x-ppapi-hangouts-effects";
91const char kEffectsPluginExtension[] = "";
92const char kEffectsPluginDescription[] = "Google Talk Effects Plugin";
93const uint32 kEffectsPluginPermissions = ppapi::PERMISSION_PRIVATE |
94                                         ppapi::PERMISSION_DEV;
95
96const char kGTalkPluginName[] = "Google Talk Plugin";
97const char kGTalkPluginMimeType[] ="application/googletalk";
98const char kGTalkPluginExtension[] = ".googletalk";
99const char kGTalkPluginDescription[] = "Google Talk Plugin";
100const uint32 kGTalkPluginPermissions = ppapi::PERMISSION_PRIVATE |
101                                       ppapi::PERMISSION_DEV;
102
103#if defined(ENABLE_REMOTING)
104#if defined(GOOGLE_CHROME_BUILD)
105const char kRemotingViewerPluginName[] = "Chrome Remote Desktop Viewer";
106#else
107const char kRemotingViewerPluginName[] = "Chromoting Viewer";
108#endif  // defined(GOOGLE_CHROME_BUILD)
109const char kRemotingViewerPluginDescription[] =
110    "This plugin allows you to securely access other computers that have been "
111    "shared with you. To use this plugin you must first install the "
112    "<a href=\"https://chrome.google.com/remotedesktop\">"
113    "Chrome Remote Desktop</a> webapp.";
114// Use a consistent MIME-type regardless of branding.
115const char kRemotingViewerPluginMimeType[] =
116    "application/vnd.chromium.remoting-viewer";
117const char kRemotingViewerPluginMimeExtension[] = "";
118const char kRemotingViewerPluginMimeDescription[] = "";
119const uint32 kRemotingViewerPluginPermissions = ppapi::PERMISSION_PRIVATE |
120                                                ppapi::PERMISSION_DEV;
121#endif  // defined(ENABLE_REMOTING)
122
123#if defined(OS_MACOSX) && !defined(OS_IOS)
124const char kInterposeLibraryPath[] =
125    "@executable_path/../../../libplugin_carbon_interpose.dylib";
126#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
127
128// Appends the known built-in plugins to the given vector. Some built-in
129// plugins are "internal" which means they are compiled into the Chrome binary,
130// and some are extra shared libraries distributed with the browser (these are
131// not marked internal, aside from being automatically registered, they're just
132// regular plugins).
133void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
134  // PDF.
135  //
136  // Once we're sandboxed, we can't know if the PDF plugin is available or not;
137  // but (on Linux) this function is always called once before we're sandboxed.
138  // So the first time through test if the file is available and then skip the
139  // check on subsequent calls if yes.
140  static bool skip_pdf_file_check = false;
141  base::FilePath path;
142  if (PathService::Get(chrome::FILE_PDF_PLUGIN, &path)) {
143    if (skip_pdf_file_check || base::PathExists(path)) {
144      content::PepperPluginInfo pdf;
145      pdf.path = path;
146      pdf.name = ChromeContentClient::kPDFPluginName;
147      if (CommandLine::ForCurrentProcess()->HasSwitch(
148              switches::kOutOfProcessPdf)) {
149        pdf.is_out_of_process = true;
150        content::WebPluginMimeType pdf_mime_type(kPDFPluginOutOfProcessMimeType,
151                                                 kPDFPluginExtension,
152                                                 kPDFPluginDescription);
153        pdf.mime_types.push_back(pdf_mime_type);
154        // TODO(raymes): Make print preview work with out of process PDF.
155      } else {
156        content::WebPluginMimeType pdf_mime_type(kPDFPluginMimeType,
157                                                 kPDFPluginExtension,
158                                                 kPDFPluginDescription);
159        content::WebPluginMimeType print_preview_pdf_mime_type(
160            kPDFPluginPrintPreviewMimeType,
161            kPDFPluginExtension,
162            kPDFPluginDescription);
163        pdf.mime_types.push_back(pdf_mime_type);
164        pdf.mime_types.push_back(print_preview_pdf_mime_type);
165      }
166      pdf.permissions = kPDFPluginPermissions;
167      plugins->push_back(pdf);
168
169      skip_pdf_file_check = true;
170    }
171  }
172
173  // Handle Native Client just like the PDF plugin. This means that it is
174  // enabled by default for the non-portable case.  This allows apps installed
175  // from the Chrome Web Store to use NaCl even if the command line switch
176  // isn't set.  For other uses of NaCl we check for the command line switch.
177  // Specifically, Portable Native Client is only enabled by the command line
178  // switch.
179  static bool skip_nacl_file_check = false;
180  if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) {
181    if (skip_nacl_file_check || base::PathExists(path)) {
182      content::PepperPluginInfo nacl;
183      nacl.path = path;
184      nacl.name = ChromeContentClient::kNaClPluginName;
185      content::WebPluginMimeType nacl_mime_type(kNaClPluginMimeType,
186                                                kNaClPluginExtension,
187                                                kNaClPluginDescription);
188      nacl.mime_types.push_back(nacl_mime_type);
189      if (!CommandLine::ForCurrentProcess()->HasSwitch(
190              switches::kDisablePnacl)) {
191        content::WebPluginMimeType pnacl_mime_type(kPnaclPluginMimeType,
192                                                   kPnaclPluginExtension,
193                                                   kPnaclPluginDescription);
194        nacl.mime_types.push_back(pnacl_mime_type);
195      }
196      nacl.permissions = kNaClPluginPermissions;
197      plugins->push_back(nacl);
198
199      skip_nacl_file_check = true;
200    }
201  }
202
203  static bool skip_o1d_file_check = false;
204  if (PathService::Get(chrome::FILE_O1D_PLUGIN, &path)) {
205    if (skip_o1d_file_check || base::PathExists(path)) {
206      content::PepperPluginInfo o1d;
207      o1d.path = path;
208      o1d.name = kO1DPluginName;
209      o1d.is_out_of_process = true;
210      o1d.is_sandboxed = false;
211      o1d.permissions = kO1DPluginPermissions;
212      content::WebPluginMimeType o1d_mime_type(kO1DPluginMimeType,
213                                               kO1DPluginExtension,
214                                               kO1DPluginDescription);
215      o1d.mime_types.push_back(o1d_mime_type);
216      plugins->push_back(o1d);
217
218      skip_o1d_file_check = true;
219    }
220  }
221
222  // TODO(vrk): Remove this when NaCl effects plugin replaces the ppapi effects
223  // plugin.
224  static bool skip_effects_file_check = false;
225  if (PathService::Get(chrome::FILE_EFFECTS_PLUGIN, &path)) {
226    if (skip_effects_file_check || base::PathExists(path)) {
227      content::PepperPluginInfo effects;
228      effects.path = path;
229      effects.name = kEffectsPluginName;
230      effects.is_out_of_process = true;
231      effects.is_sandboxed = true;
232      effects.permissions = kEffectsPluginPermissions;
233      content::WebPluginMimeType effects_mime_type(kEffectsPluginMimeType,
234                                                   kEffectsPluginExtension,
235                                                   kEffectsPluginDescription);
236      effects.mime_types.push_back(effects_mime_type);
237      plugins->push_back(effects);
238
239      skip_effects_file_check = true;
240    }
241  }
242
243  static bool skip_gtalk_file_check = false;
244  if (PathService::Get(chrome::FILE_GTALK_PLUGIN, &path)) {
245    if (skip_gtalk_file_check || base::PathExists(path)) {
246      content::PepperPluginInfo gtalk;
247      gtalk.path = path;
248      gtalk.name = kGTalkPluginName;
249      gtalk.is_out_of_process = true;
250      gtalk.is_sandboxed = false;
251      gtalk.permissions = kGTalkPluginPermissions;
252      content::WebPluginMimeType gtalk_mime_type(kGTalkPluginMimeType,
253                                                 kGTalkPluginExtension,
254                                                 kGTalkPluginDescription);
255      gtalk.mime_types.push_back(gtalk_mime_type);
256      plugins->push_back(gtalk);
257
258      skip_gtalk_file_check = true;
259    }
260  }
261
262#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \
263    !defined(WIDEVINE_CDM_IS_COMPONENT)
264  static bool skip_widevine_cdm_file_check = false;
265  if (PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &path)) {
266    if (skip_widevine_cdm_file_check || base::PathExists(path)) {
267      content::PepperPluginInfo widevine_cdm;
268      widevine_cdm.is_out_of_process = true;
269      widevine_cdm.path = path;
270      widevine_cdm.name = kWidevineCdmDisplayName;
271      widevine_cdm.description = kWidevineCdmDescription;
272      widevine_cdm.version = WIDEVINE_CDM_VERSION_STRING;
273      content::WebPluginMimeType widevine_cdm_mime_type(
274          kWidevineCdmPluginMimeType,
275          kWidevineCdmPluginExtension,
276          kWidevineCdmPluginMimeTypeDescription);
277
278      // Add the supported codecs as if they came from the component manifest.
279      std::vector<std::string> codecs;
280      codecs.push_back(kCdmSupportedCodecVorbis);
281      codecs.push_back(kCdmSupportedCodecVp8);
282      // TODO(xhwang): Add VP9 when it's supported by Widevine CDM.
283      // See http://crbug.com/361318
284#if defined(USE_PROPRIETARY_CODECS)
285// TODO(ddorwin): Rename these macros to reflect their real meaning: whether the
286// CDM Chrome was built [and shipped] with support these types.
287#if defined(WIDEVINE_CDM_AAC_SUPPORT_AVAILABLE)
288      codecs.push_back(kCdmSupportedCodecAac);
289#endif
290#if defined(WIDEVINE_CDM_AVC1_SUPPORT_AVAILABLE)
291      codecs.push_back(kCdmSupportedCodecAvc1);
292#endif
293#endif  // defined(USE_PROPRIETARY_CODECS)
294      std::string codec_string =
295          JoinString(codecs, kCdmSupportedCodecsValueDelimiter);
296      widevine_cdm_mime_type.additional_param_names.push_back(
297          base::ASCIIToUTF16(kCdmSupportedCodecsParamName));
298      widevine_cdm_mime_type.additional_param_values.push_back(
299          base::ASCIIToUTF16(codec_string));
300
301      widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
302      widevine_cdm.permissions = kWidevineCdmPluginPermissions;
303      plugins->push_back(widevine_cdm);
304
305      skip_widevine_cdm_file_check = true;
306    }
307  }
308#endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) &&
309        // !defined(WIDEVINE_CDM_IS_COMPONENT)
310
311  // The Remoting Viewer plugin is built-in.
312#if defined(ENABLE_REMOTING)
313  content::PepperPluginInfo info;
314  info.is_internal = true;
315  info.is_out_of_process = true;
316  info.name = kRemotingViewerPluginName;
317  info.description = kRemotingViewerPluginDescription;
318  info.path = base::FilePath::FromUTF8Unsafe(
319      ChromeContentClient::kRemotingViewerPluginPath);
320  content::WebPluginMimeType remoting_mime_type(
321      kRemotingViewerPluginMimeType,
322      kRemotingViewerPluginMimeExtension,
323      kRemotingViewerPluginMimeDescription);
324  info.mime_types.push_back(remoting_mime_type);
325  info.internal_entry_points.get_interface = remoting::PPP_GetInterface;
326  info.internal_entry_points.initialize_module =
327      remoting::PPP_InitializeModule;
328  info.internal_entry_points.shutdown_module = remoting::PPP_ShutdownModule;
329  info.permissions = kRemotingViewerPluginPermissions;
330
331  plugins->push_back(info);
332#endif
333}
334
335content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
336                                                const std::string& version) {
337  content::PepperPluginInfo plugin;
338
339  plugin.is_out_of_process = true;
340  plugin.name = content::kFlashPluginName;
341  plugin.path = path;
342  plugin.permissions = kPepperFlashPermissions;
343
344  std::vector<std::string> flash_version_numbers;
345  base::SplitString(version, '.', &flash_version_numbers);
346  if (flash_version_numbers.size() < 1)
347    flash_version_numbers.push_back("11");
348  // |SplitString()| puts in an empty string given an empty string. :(
349  else if (flash_version_numbers[0].empty())
350    flash_version_numbers[0] = "11";
351  if (flash_version_numbers.size() < 2)
352    flash_version_numbers.push_back("2");
353  if (flash_version_numbers.size() < 3)
354    flash_version_numbers.push_back("999");
355  if (flash_version_numbers.size() < 4)
356    flash_version_numbers.push_back("999");
357  // E.g., "Shockwave Flash 10.2 r154":
358  plugin.description = plugin.name + " " + flash_version_numbers[0] + "." +
359      flash_version_numbers[1] + " r" + flash_version_numbers[2];
360  plugin.version = JoinString(flash_version_numbers, '.');
361  content::WebPluginMimeType swf_mime_type(content::kFlashPluginSwfMimeType,
362                                           content::kFlashPluginSwfExtension,
363                                           content::kFlashPluginSwfDescription);
364  plugin.mime_types.push_back(swf_mime_type);
365  content::WebPluginMimeType spl_mime_type(content::kFlashPluginSplMimeType,
366                                           content::kFlashPluginSplExtension,
367                                           content::kFlashPluginSplDescription);
368  plugin.mime_types.push_back(spl_mime_type);
369
370  return plugin;
371}
372
373void AddPepperFlashFromCommandLine(
374    std::vector<content::PepperPluginInfo>* plugins) {
375  const CommandLine::StringType flash_path =
376      CommandLine::ForCurrentProcess()->GetSwitchValueNative(
377          switches::kPpapiFlashPath);
378  if (flash_path.empty())
379    return;
380
381  // Also get the version from the command-line. Should be something like 11.2
382  // or 11.2.123.45.
383  std::string flash_version =
384      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
385          switches::kPpapiFlashVersion);
386
387  plugins->push_back(
388      CreatePepperFlashInfo(base::FilePath(flash_path), flash_version));
389}
390
391bool GetBundledPepperFlash(content::PepperPluginInfo* plugin) {
392#if defined(FLAPPER_AVAILABLE)
393  CommandLine* command_line = CommandLine::ForCurrentProcess();
394
395  // Ignore bundled Pepper Flash if there is Pepper Flash specified from the
396  // command-line.
397  if (command_line->HasSwitch(switches::kPpapiFlashPath))
398    return false;
399
400  bool force_disable =
401      command_line->HasSwitch(switches::kDisableBundledPpapiFlash);
402  if (force_disable)
403    return false;
404
405// For Linux ia32, Flapper requires SSE2.
406#if defined(OS_LINUX) && defined(ARCH_CPU_X86)
407  if (!base::CPU().has_sse2())
408    return false;
409#endif  // ARCH_CPU_X86
410
411  base::FilePath flash_path;
412  if (!PathService::Get(chrome::FILE_PEPPER_FLASH_PLUGIN, &flash_path))
413    return false;
414
415  *plugin = CreatePepperFlashInfo(flash_path, FLAPPER_VERSION_STRING);
416  return true;
417#else
418  return false;
419#endif  // FLAPPER_AVAILABLE
420}
421
422std::string GetProduct() {
423  chrome::VersionInfo version_info;
424  return version_info.is_valid() ?
425      version_info.ProductNameAndVersionForUserAgent() : std::string();
426}
427
428}  // namespace
429
430std::string GetUserAgent() {
431  CommandLine* command_line = CommandLine::ForCurrentProcess();
432  if (command_line->HasSwitch(switches::kUserAgent))
433    return command_line->GetSwitchValueASCII(switches::kUserAgent);
434
435  std::string product = GetProduct();
436#if defined(OS_ANDROID)
437  if (command_line->HasSwitch(switches::kUseMobileUserAgent))
438    product += " Mobile";
439#endif
440  return content::BuildUserAgentFromProduct(product);
441}
442
443void ChromeContentClient::SetActiveURL(const GURL& url) {
444  base::debug::SetCrashKeyValue(crash_keys::kActiveURL,
445                                url.possibly_invalid_spec());
446}
447
448void ChromeContentClient::SetGpuInfo(const gpu::GPUInfo& gpu_info) {
449#if !defined(OS_ANDROID)
450  base::debug::SetCrashKeyValue(crash_keys::kGPUVendorID,
451      base::StringPrintf("0x%04x", gpu_info.gpu.vendor_id));
452  base::debug::SetCrashKeyValue(crash_keys::kGPUDeviceID,
453      base::StringPrintf("0x%04x", gpu_info.gpu.device_id));
454#endif
455  base::debug::SetCrashKeyValue(crash_keys::kGPUDriverVersion,
456      gpu_info.driver_version);
457  base::debug::SetCrashKeyValue(crash_keys::kGPUPixelShaderVersion,
458      gpu_info.pixel_shader_version);
459  base::debug::SetCrashKeyValue(crash_keys::kGPUVertexShaderVersion,
460      gpu_info.vertex_shader_version);
461#if defined(OS_MACOSX)
462  base::debug::SetCrashKeyValue(crash_keys::kGPUGLVersion, gpu_info.gl_version);
463#elif defined(OS_POSIX)
464  base::debug::SetCrashKeyValue(crash_keys::kGPUVendor, gpu_info.gl_vendor);
465  base::debug::SetCrashKeyValue(crash_keys::kGPURenderer, gpu_info.gl_renderer);
466#endif
467}
468
469void ChromeContentClient::AddPepperPlugins(
470    std::vector<content::PepperPluginInfo>* plugins) {
471  ComputeBuiltInPlugins(plugins);
472  AddPepperFlashFromCommandLine(plugins);
473
474  content::PepperPluginInfo plugin;
475  if (GetBundledPepperFlash(&plugin))
476    plugins->push_back(plugin);
477}
478
479void ChromeContentClient::AddAdditionalSchemes(
480    std::vector<std::string>* standard_schemes,
481    std::vector<std::string>* savable_schemes) {
482  standard_schemes->push_back(extensions::kExtensionScheme);
483  savable_schemes->push_back(extensions::kExtensionScheme);
484  standard_schemes->push_back(chrome::kChromeNativeScheme);
485  standard_schemes->push_back(extensions::kExtensionResourceScheme);
486  savable_schemes->push_back(extensions::kExtensionResourceScheme);
487  standard_schemes->push_back(chrome::kChromeSearchScheme);
488  savable_schemes->push_back(chrome::kChromeSearchScheme);
489  standard_schemes->push_back(chrome::kDomDistillerScheme);
490  savable_schemes->push_back(chrome::kDomDistillerScheme);
491#if defined(OS_CHROMEOS)
492  standard_schemes->push_back(chrome::kCrosScheme);
493#endif
494}
495
496std::string ChromeContentClient::GetProduct() const {
497  return ::GetProduct();
498}
499
500std::string ChromeContentClient::GetUserAgent() const {
501  return ::GetUserAgent();
502}
503
504base::string16 ChromeContentClient::GetLocalizedString(int message_id) const {
505  return l10n_util::GetStringUTF16(message_id);
506}
507
508base::StringPiece ChromeContentClient::GetDataResource(
509    int resource_id,
510    ui::ScaleFactor scale_factor) const {
511  return ResourceBundle::GetSharedInstance().GetRawDataResourceForScale(
512      resource_id, scale_factor);
513}
514
515base::RefCountedStaticMemory* ChromeContentClient::GetDataResourceBytes(
516    int resource_id) const {
517  return ResourceBundle::GetSharedInstance().LoadDataResourceBytes(resource_id);
518}
519
520gfx::Image& ChromeContentClient::GetNativeImageNamed(int resource_id) const {
521  return ResourceBundle::GetSharedInstance().GetNativeImageNamed(resource_id);
522}
523
524std::string ChromeContentClient::GetProcessTypeNameInEnglish(int type) {
525  switch (type) {
526    case PROCESS_TYPE_NACL_LOADER:
527      return "Native Client module";
528    case PROCESS_TYPE_NACL_BROKER:
529      return "Native Client broker";
530  }
531
532  DCHECK(false) << "Unknown child process type!";
533  return "Unknown";
534}
535
536#if defined(OS_MACOSX) && !defined(OS_IOS)
537bool ChromeContentClient::GetSandboxProfileForSandboxType(
538    int sandbox_type,
539    int* sandbox_profile_resource_id) const {
540  DCHECK(sandbox_profile_resource_id);
541  if (sandbox_type == NACL_SANDBOX_TYPE_NACL_LOADER) {
542    *sandbox_profile_resource_id = IDR_NACL_SANDBOX_PROFILE;
543    return true;
544  }
545  return false;
546}
547
548std::string ChromeContentClient::GetCarbonInterposePath() const {
549  return std::string(kInterposeLibraryPath);
550}
551#endif
552