Split ppapi::PluginList from PepperPluginRegistry so that DRT could load pepper plugins.

chrome/common/chrome_content_client.cc

 // Copyright (c) 2011 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/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/render_messages.h"
-#include "content/common/pepper_plugin_registry.h"
 #include "remoting/client/plugin/pepper_entrypoints.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/glue/user_agent.h"
 #include "webkit/plugins/plugin_constants.h"
+#include "webkit/plugins/ppapi/ppapi_plugin_info.h"
 
 #if defined(OS_WIN)
 #include "content/common/sandbox_policy.h"
 #include "sandbox/src/sandbox.h"
 #endif
 
 namespace {
 
 const char kPDFPluginName[] = "Chrome PDF Viewer";
 const char kPDFPluginMimeType[] = "application/pdf";
@@ skipping 19 matching lines @@
 // TODO(wez): Remove the old MIME-type once client code no longer needs it.
 const char kRemotingViewerPluginOldMimeType[] =
     "pepper-application/x-chromoting";
 #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<PepperPluginInfo>* plugins) {
+void ComputeBuiltInPlugins(std::vector<webkit::ppapi::PluginInfo>* 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;
   FilePath path;
   if (PathService::Get(chrome::FILE_PDF_PLUGIN, &path)) {
     if (skip_pdf_file_check || file_util::PathExists(path)) {
-      PepperPluginInfo pdf;
+      webkit::ppapi::PluginInfo pdf;
       pdf.path = path;
       pdf.name = kPDFPluginName;
       webkit::WebPluginMimeType pdf_mime_type(kPDFPluginMimeType,
                                               kPDFPluginExtension,
                                               kPDFPluginDescription);
       webkit::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);
       plugins->push_back(pdf);
 
       skip_pdf_file_check = true;
     }
   }
 
   // Handle the Native Client just like the PDF plugin. This means that it is
   // enabled by default. 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.
   static bool skip_nacl_file_check = false;
   if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) {
     if (skip_nacl_file_check || file_util::PathExists(path)) {
-      PepperPluginInfo nacl;
+      webkit::ppapi::PluginInfo nacl;
       nacl.path = path;
       nacl.name = kNaClPluginName;
       webkit::WebPluginMimeType nacl_mime_type(kNaClPluginMimeType,
                                                kNaClPluginExtension,
                                                kNaClPluginDescription);
       nacl.mime_types.push_back(nacl_mime_type);
       plugins->push_back(nacl);
 
       skip_nacl_file_check = true;
     }
   }
 
   // The Remoting Viewer plugin is built-in.
 #if defined(ENABLE_REMOTING)
-  PepperPluginInfo info;
+  webkit::ppapi::PluginInfo info;
   info.is_internal = true;
   info.name = kRemotingViewerPluginName;
   info.path = FilePath(kRemotingViewerPluginPath);
   webkit::WebPluginMimeType remoting_mime_type(
       kRemotingViewerPluginMimeType,
       std::string(),
       std::string());
   info.mime_types.push_back(remoting_mime_type);
   webkit::WebPluginMimeType old_remoting_mime_type(
       kRemotingViewerPluginOldMimeType,
       std::string(),
       std::string());
   info.mime_types.push_back(old_remoting_mime_type);
   info.internal_entry_points.get_interface = remoting::PPP_GetInterface;
   info.internal_entry_points.initialize_module =
       remoting::PPP_InitializeModule;
   info.internal_entry_points.shutdown_module = remoting::PPP_ShutdownModule;
 
   plugins->push_back(info);
 #endif
 }
 
-void AddOutOfProcessFlash(std::vector<PepperPluginInfo>* plugins) {
+void AddOutOfProcessFlash(std::vector<webkit::ppapi::PluginInfo>* plugins) {
   // Flash being out of process is handled separately than general plugins
   // for testing purposes.
   bool flash_out_of_process = !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kPpapiFlashInProcess);
 
   // Handle any Pepper Flash first.
   const CommandLine::StringType flash_path =
       CommandLine::ForCurrentProcess()->GetSwitchValueNative(
           switches::kPpapiFlashPath);
   if (flash_path.empty())
     return;
 
-  PepperPluginInfo plugin;
+  webkit::ppapi::PluginInfo plugin;
   plugin.is_out_of_process = flash_out_of_process;
   plugin.path = FilePath(flash_path);
   plugin.name = kFlashPluginName;
 
   const std::string flash_version =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               switches::kPpapiFlashVersion);
   std::vector<std::string> flash_version_numbers;
   base::SplitString(flash_version, '.', &flash_version_numbers);
   if (flash_version_numbers.size() < 1)
@@ skipping 98 matching lines @@
 
 void ChromeContentClient::SetActiveURL(const GURL& url) {
   child_process_logging::SetActiveURL(url);
 }
 
 void ChromeContentClient::SetGpuInfo(const GPUInfo& gpu_info) {
   child_process_logging::SetGpuInfo(gpu_info);
 }
 
 void ChromeContentClient::AddPepperPlugins(
-    std::vector<PepperPluginInfo>* plugins) {
+    std::vector<webkit::ppapi::PluginInfo>* plugins) {
   ComputeBuiltInPlugins(plugins);
   AddOutOfProcessFlash(plugins);
 }
 
 bool ChromeContentClient::CanSendWhileSwappedOut(const IPC::Message* msg) {
   // Any Chrome-specific messages that must be allowed to be sent from swapped
   // out renderers.
   switch (msg->type()) {
     case ChromeViewHostMsg_DomOperationResponse::ID:
       return true;
@@ skipping 87 matching lines @@
     policy->SetJobLevel(sandbox::JOB_UNPROTECTED, 0);
     policy->SetTokenLevel(
         sandbox::USER_UNPROTECTED, sandbox::USER_UNPROTECTED);
   }
 
   return true;
 }
 #endif
 
 }  // namespace chrome