Combine PDF plugin into the Chromium binary.

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 "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
@@ skipping 46 matching lines @@
 #endif
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \
     !defined(WIDEVINE_CDM_IS_COMPONENT)
 #include "chrome/common/widevine_cdm_constants.h"
 #endif
 
 namespace {
 
 #if defined(ENABLE_PLUGINS)
-const char kPDFPluginMimeType[] = "application/pdf";
 const char kPDFPluginExtension[] = "pdf";
 const char kPDFPluginDescription[] = "Portable Document Format";
-const char kPDFPluginPrintPreviewMimeType[] =
-    "application/x-google-chrome-print-preview-pdf";
 const char kPDFPluginOutOfProcessMimeType[] =
     "application/x-google-chrome-pdf";
 const uint32 kPDFPluginPermissions = ppapi::PERMISSION_PRIVATE |
                                      ppapi::PERMISSION_DEV;
 
 const char kO1DPluginName[] = "Google Talk Plugin Video Renderer";
 const char kO1DPluginMimeType[] ="application/o1d";
 const char kO1DPluginExtension[] = "";
 const char kO1DPluginDescription[] = "Google Talk Plugin Video Renderer";
 const uint32 kO1DPluginPermissions = ppapi::PERMISSION_PRIVATE |
                                      ppapi::PERMISSION_DEV;
 
 const char kEffectsPluginName[] = "Google Talk Effects Plugin";
 const char kEffectsPluginMimeType[] ="application/x-ppapi-hangouts-effects";
 const char kEffectsPluginExtension[] = "";
 const char kEffectsPluginDescription[] = "Google Talk Effects Plugin";
 const uint32 kEffectsPluginPermissions = ppapi::PERMISSION_PRIVATE |
                                          ppapi::PERMISSION_DEV;
 
 const char kGTalkPluginName[] = "Google Talk Plugin";
 const char kGTalkPluginMimeType[] ="application/googletalk";
 const char kGTalkPluginExtension[] = ".googletalk";
 const char kGTalkPluginDescription[] = "Google Talk Plugin";
 const uint32 kGTalkPluginPermissions = ppapi::PERMISSION_PRIVATE |
                                        ppapi::PERMISSION_DEV;
 
+content::PepperPluginInfo::GetInterfaceFunc g_pdf_get_interface;
+content::PepperPluginInfo::PPP_InitializeModuleFunc g_pdf_initialize_module;
+content::PepperPluginInfo::PPP_ShutdownModuleFunc g_pdf_shutdown_module;
+
 #if defined(ENABLE_REMOTING)
 
 content::PepperPluginInfo::GetInterfaceFunc g_remoting_get_interface;
 content::PepperPluginInfo::PPP_InitializeModuleFunc
     g_remoting_initialize_module;
 content::PepperPluginInfo::PPP_ShutdownModuleFunc g_remoting_shutdown_module;
 
 #if defined(GOOGLE_CHROME_BUILD)
 const char kRemotingViewerPluginName[] = "Chrome Remote Desktop Viewer";
 #else
@@ skipping 18 matching lines @@
 content::PepperPluginInfo::PPP_InitializeModuleFunc g_nacl_initialize_module;
 content::PepperPluginInfo::PPP_ShutdownModuleFunc g_nacl_shutdown_module;
 #endif
 
 // Appends the known built-in plugins to the given vector. Some built-in
 // plugins are "internal" which means they are compiled into the Chrome binary,
 // and some are extra shared libraries distributed with the browser (these are
 // not marked internal, aside from being automatically registered, they're just
 // regular plugins).
 void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
-  // PDF.
-  //
-  // Once we're sandboxed, we can't know if the PDF plugin is available or not;
-  // but (on Linux) this function is always called once before we're sandboxed.
-  // So the first time through test if the file is available and then skip the
-  // check on subsequent calls if yes.
-  static bool skip_pdf_file_check = false;
+  content::PepperPluginInfo pdf_info;
+  pdf_info.is_internal = true;
+  pdf_info.is_out_of_process = true;
+  pdf_info.name = ChromeContentClient::kPDFPluginName;
+  pdf_info.description = kPDFPluginDescription;
+  pdf_info.path = base::FilePath::FromUTF8Unsafe(
+      ChromeContentClient::kPDFPluginPath);
+  content::WebPluginMimeType pdf_mime_type(
+      kPDFPluginOutOfProcessMimeType,
+      kPDFPluginExtension,
+      kPDFPluginDescription);
+  pdf_info.mime_types.push_back(pdf_mime_type);
+  pdf_info.internal_entry_points.get_interface = g_pdf_get_interface;
+  pdf_info.internal_entry_points.initialize_module = g_pdf_initialize_module;
+  pdf_info.internal_entry_points.shutdown_module = g_pdf_shutdown_module;
+  pdf_info.permissions = kPDFPluginPermissions;
+  plugins->push_back(pdf_info);
+
   base::FilePath path;
-  if (PathService::Get(chrome::FILE_PDF_PLUGIN, &path)) {
-    if (skip_pdf_file_check || base::PathExists(path)) {
-      content::PepperPluginInfo pdf;
-      pdf.path = path;
-      pdf.name = ChromeContentClient::kPDFPluginName;
-      if (switches::OutOfProcessPdfEnabled()) {
-        pdf.is_out_of_process = true;
-        content::WebPluginMimeType pdf_mime_type(kPDFPluginOutOfProcessMimeType,
-                                                 kPDFPluginExtension,
-                                                 kPDFPluginDescription);
-        pdf.mime_types.push_back(pdf_mime_type);
-        // TODO(raymes): Make print preview work with out of process PDF.
-      } else {
-        content::WebPluginMimeType pdf_mime_type(kPDFPluginMimeType,
-                                                 kPDFPluginExtension,
-                                                 kPDFPluginDescription);
-        content::WebPluginMimeType print_preview_pdf_mime_type(
-            kPDFPluginPrintPreviewMimeType,
-            kPDFPluginExtension,
-            kPDFPluginDescription);
-        pdf.mime_types.push_back(pdf_mime_type);
-        pdf.mime_types.push_back(print_preview_pdf_mime_type);
-      }
-      pdf.permissions = kPDFPluginPermissions;
-      plugins->push_back(pdf);
-
-      skip_pdf_file_check = true;
-    }
-  }
 
 #if !defined(DISABLE_NACL)
   // Handle Native Client just like the PDF plugin. This means that it is
   // enabled by default for the non-portable case.  This allows apps installed
   // from the Chrome Web Store to use NaCl even if the command line switch
   // isn't set.  For other uses of NaCl we check for the command line switch.
   if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) {
     content::PepperPluginInfo nacl;
     // The nacl plugin is now built into the Chromium binary.
     nacl.is_internal = true;
@@ skipping 264 matching lines @@
 void ChromeContentClient::SetNaClEntryFunctions(
     content::PepperPluginInfo::GetInterfaceFunc get_interface,
     content::PepperPluginInfo::PPP_InitializeModuleFunc initialize_module,
     content::PepperPluginInfo::PPP_ShutdownModuleFunc shutdown_module) {
   g_nacl_get_interface = get_interface;
   g_nacl_initialize_module = initialize_module;
   g_nacl_shutdown_module = shutdown_module;
 }
 #endif
 
+#if defined(ENABLE_PLUGINS)
+void ChromeContentClient::SetPDFEntryFunctions(
+    content::PepperPluginInfo::GetInterfaceFunc get_interface,
+    content::PepperPluginInfo::PPP_InitializeModuleFunc initialize_module,
+    content::PepperPluginInfo::PPP_ShutdownModuleFunc shutdown_module) {
+  g_pdf_get_interface = get_interface;
+  g_pdf_initialize_module = initialize_module;
+  g_pdf_shutdown_module = shutdown_module;
+}
+#endif
+
 void ChromeContentClient::SetActiveURL(const GURL& url) {
   base::debug::SetCrashKeyValue(crash_keys::kActiveURL,
                                 url.possibly_invalid_spec());
 }
 
 void ChromeContentClient::SetGpuInfo(const gpu::GPUInfo& gpu_info) {
 #if !defined(OS_ANDROID)
   base::debug::SetCrashKeyValue(crash_keys::kGPUVendorID,
       base::StringPrintf("0x%04x", gpu_info.gpu.vendor_id));
   base::debug::SetCrashKeyValue(crash_keys::kGPUDeviceID,
@@ skipping 89 matching lines @@
     int sandbox_type,
     int* sandbox_profile_resource_id) const {
   DCHECK(sandbox_profile_resource_id);
   if (sandbox_type == NACL_SANDBOX_TYPE_NACL_LOADER) {
     *sandbox_profile_resource_id = IDR_NACL_SANDBOX_PROFILE;
     return true;
   }
   return false;
 }
 #endif