Move webplugininfo.h to content/public.

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/cpu.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 122 matching lines @@
   // 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;
   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 = chrome::ChromeContentClient::kPDFPluginName;
-      webkit::WebPluginMimeType pdf_mime_type(kPDFPluginMimeType,
-                                              kPDFPluginExtension,
-                                              kPDFPluginDescription);
-      webkit::WebPluginMimeType print_preview_pdf_mime_type(
+      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;
     }
   }
 
   // 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.
   // Specifically, Portable Native Client is only enabled by the command line
   // switch.
   static bool skip_nacl_file_check = false;
   if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) {
     if (skip_nacl_file_check || base::PathExists(path)) {
       content::PepperPluginInfo nacl;
       nacl.path = path;
       nacl.name = chrome::ChromeContentClient::kNaClPluginName;
-      webkit::WebPluginMimeType nacl_mime_type(kNaClPluginMimeType,
-                                               kNaClPluginExtension,
-                                               kNaClPluginDescription);
+      content::WebPluginMimeType nacl_mime_type(kNaClPluginMimeType,
+                                                kNaClPluginExtension,
+                                                kNaClPluginDescription);
       nacl.mime_types.push_back(nacl_mime_type);
       if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePnacl)) {
-        webkit::WebPluginMimeType pnacl_mime_type(kPnaclPluginMimeType,
-                                                  kPnaclPluginExtension,
-                                                  kPnaclPluginDescription);
+        content::WebPluginMimeType pnacl_mime_type(kPnaclPluginMimeType,
+                                                   kPnaclPluginExtension,
+                                                   kPnaclPluginDescription);
         nacl.mime_types.push_back(pnacl_mime_type);
       }
       nacl.permissions = kNaClPluginPermissions;
       plugins->push_back(nacl);
 
       skip_nacl_file_check = true;
     }
   }
 
   // TODO(jhorwich|noahric): Remove o3d ppapi code once o3d is replaced
   // entirely with o1d.
   static bool skip_o3d_file_check = false;
   if (PathService::Get(chrome::FILE_O3D_PLUGIN, &path)) {
     if (skip_o3d_file_check || base::PathExists(path)) {
       content::PepperPluginInfo o3d;
       o3d.path = path;
       o3d.name = kO3DPluginName;
       o3d.is_out_of_process = true;
       o3d.is_sandboxed = false;
       o3d.permissions = kO3DPluginPermissions;
-      webkit::WebPluginMimeType o3d_mime_type(kO3DPluginMimeType,
-                                              kO3DPluginExtension,
-                                              kO3DPluginDescription);
+      content::WebPluginMimeType o3d_mime_type(kO3DPluginMimeType,
+                                               kO3DPluginExtension,
+                                               kO3DPluginDescription);
       o3d.mime_types.push_back(o3d_mime_type);
       plugins->push_back(o3d);
 
       skip_o3d_file_check = true;
     }
   }
 
   static bool skip_o1d_file_check = false;
   if (PathService::Get(chrome::FILE_O1D_PLUGIN, &path)) {
     if (skip_o1d_file_check || base::PathExists(path)) {
       content::PepperPluginInfo o1d;
       o1d.path = path;
       o1d.name = kO1DPluginName;
       o1d.is_out_of_process = true;
       o1d.is_sandboxed = false;
       o1d.permissions = kO1DPluginPermissions;
-      webkit::WebPluginMimeType o1d_mime_type(kO1DPluginMimeType,
-                                              kO1DPluginExtension,
-                                              kO1DPluginDescription);
+      content::WebPluginMimeType o1d_mime_type(kO1DPluginMimeType,
+                                               kO1DPluginExtension,
+                                               kO1DPluginDescription);
       o1d.mime_types.push_back(o1d_mime_type);
       plugins->push_back(o1d);
 
       skip_o1d_file_check = true;
     }
   }
 
   static bool skip_gtalk_file_check = false;
   if (PathService::Get(chrome::FILE_GTALK_PLUGIN, &path)) {
     if (skip_gtalk_file_check || base::PathExists(path)) {
       content::PepperPluginInfo gtalk;
       gtalk.path = path;
       gtalk.name = kGTalkPluginName;
       gtalk.is_out_of_process = true;
       gtalk.is_sandboxed = false;
       gtalk.permissions = kGTalkPluginPermissions;
-      webkit::WebPluginMimeType gtalk_mime_type(kGTalkPluginMimeType,
-                                                kGTalkPluginExtension,
-                                                kGTalkPluginDescription);
+      content::WebPluginMimeType gtalk_mime_type(kGTalkPluginMimeType,
+                                                 kGTalkPluginExtension,
+                                                 kGTalkPluginDescription);
       gtalk.mime_types.push_back(gtalk_mime_type);
       plugins->push_back(gtalk);
 
       skip_gtalk_file_check = true;
     }
   }
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \
     !defined(WIDEVINE_CDM_IS_COMPONENT)
   static bool skip_widevine_cdm_file_check = false;
   if (PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &path)) {
     if (skip_widevine_cdm_file_check || base::PathExists(path)) {
       content::PepperPluginInfo widevine_cdm;
       widevine_cdm.is_out_of_process = true;
       widevine_cdm.path = path;
       widevine_cdm.name = kWidevineCdmDisplayName;
       widevine_cdm.description = kWidevineCdmDescription;
       widevine_cdm.version = WIDEVINE_CDM_VERSION_STRING;
-      webkit::WebPluginMimeType widevine_cdm_mime_type(
+      content::WebPluginMimeType widevine_cdm_mime_type(
           kWidevineCdmPluginMimeType,
           kWidevineCdmPluginExtension,
           kWidevineCdmPluginMimeTypeDescription);
       widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
       widevine_cdm.permissions = kWidevineCdmPluginPermissions;
       plugins->push_back(widevine_cdm);
 
       skip_widevine_cdm_file_check = true;
     }
   }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) &&
         // !defined(WIDEVINE_CDM_IS_COMPONENT)
 
   // The Remoting Viewer plugin is built-in.
 #if defined(ENABLE_REMOTING)
   content::PepperPluginInfo info;
   info.is_internal = true;
   info.is_out_of_process = true;
   info.name = kRemotingViewerPluginName;
   info.description = kRemotingViewerPluginDescription;
   info.path = base::FilePath(kRemotingViewerPluginPath);
-  webkit::WebPluginMimeType remoting_mime_type(
+  content::WebPluginMimeType remoting_mime_type(
       kRemotingViewerPluginMimeType,
       kRemotingViewerPluginMimeExtension,
       kRemotingViewerPluginMimeDescription);
   info.mime_types.push_back(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;
   info.permissions = kRemotingViewerPluginPermissions;
 
@@ skipping 23 matching lines @@
   if (flash_version_numbers.size() < 2)
     flash_version_numbers.push_back("2");
   if (flash_version_numbers.size() < 3)
     flash_version_numbers.push_back("999");
   if (flash_version_numbers.size() < 4)
     flash_version_numbers.push_back("999");
   // E.g., "Shockwave Flash 10.2 r154":
   plugin.description = plugin.name + " " + flash_version_numbers[0] + "." +
       flash_version_numbers[1] + " r" + flash_version_numbers[2];
   plugin.version = JoinString(flash_version_numbers, '.');
-  webkit::WebPluginMimeType swf_mime_type(kFlashPluginSwfMimeType,
-                                          kFlashPluginSwfExtension,
-                                          kFlashPluginSwfDescription);
+  content::WebPluginMimeType swf_mime_type(kFlashPluginSwfMimeType,
+                                           kFlashPluginSwfExtension,
+                                           kFlashPluginSwfDescription);
   plugin.mime_types.push_back(swf_mime_type);
-  webkit::WebPluginMimeType spl_mime_type(kFlashPluginSplMimeType,
-                                          kFlashPluginSplExtension,
-                                          kFlashPluginSplDescription);
+  content::WebPluginMimeType spl_mime_type(kFlashPluginSplMimeType,
+                                           kFlashPluginSplExtension,
+                                           kFlashPluginSplDescription);
   plugin.mime_types.push_back(spl_mime_type);
 
   return plugin;
 }
 
 void AddPepperFlashFromCommandLine(
     std::vector<content::PepperPluginInfo>* plugins) {
   const CommandLine::StringType flash_path =
       CommandLine::ForCurrentProcess()->GetSwitchValueNative(
           switches::kPpapiFlashPath);
@@ skipping 144 matching lines @@
   }
   return false;
 }
 
 std::string ChromeContentClient::GetCarbonInterposePath() const {
   return std::string(kInterposeLibraryPath);
 }
 #endif
 
 }  // namespace chrome