Remove the chrome namespace around ChromeContent[Renderer]Client.

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/debug/crash_logging.h"
 #include "base/file_util.h"
@@ skipping 130 matching lines @@
   // 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;
   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;
+      pdf.name = ChromeContentClient::kPDFPluginName;
       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;
+      nacl.name = ChromeContentClient::kNaClPluginName;
       content::WebPluginMimeType nacl_mime_type(kNaClPluginMimeType,
                                                 kNaClPluginExtension,
                                                 kNaClPluginDescription);
       nacl.mime_types.push_back(nacl_mime_type);
       if (!CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisablePnacl)) {
         content::WebPluginMimeType pnacl_mime_type(kPnaclPluginMimeType,
                                                    kPnaclPluginExtension,
                                                    kPnaclPluginDescription);
         nacl.mime_types.push_back(pnacl_mime_type);
@@ skipping 133 matching lines @@
         // !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::FromUTF8Unsafe(
-      chrome::ChromeContentClient::kRemotingViewerPluginPath);
+      ChromeContentClient::kRemotingViewerPluginPath);
   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 87 matching lines @@
 
   *plugin = CreatePepperFlashInfo(flash_path, FLAPPER_VERSION_STRING);
   return true;
 #else
   return false;
 #endif  // FLAPPER_AVAILABLE
 }
 
 }  // namespace
 
-namespace chrome {
-
 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 21 matching lines @@
   content::PepperPluginInfo plugin;
   if (GetBundledPepperFlash(&plugin))
     plugins->push_back(plugin);
 }
 
 void ChromeContentClient::AddAdditionalSchemes(
     std::vector<std::string>* standard_schemes,
     std::vector<std::string>* savable_schemes) {
   standard_schemes->push_back(extensions::kExtensionScheme);
   savable_schemes->push_back(extensions::kExtensionScheme);
-  standard_schemes->push_back(kExtensionResourceScheme);
-  savable_schemes->push_back(kExtensionResourceScheme);
+  standard_schemes->push_back(chrome::kExtensionResourceScheme);
+  savable_schemes->push_back(chrome::kExtensionResourceScheme);
   standard_schemes->push_back(chrome::kChromeSearchScheme);
   savable_schemes->push_back(chrome::kChromeSearchScheme);
 #if defined(OS_CHROMEOS)
-  standard_schemes->push_back(kCrosScheme);
+  standard_schemes->push_back(chrome::kCrosScheme);
 #endif
 }
 
 bool ChromeContentClient::CanHandleWhileSwappedOut(
     const IPC::Message& msg) {
   // Any Chrome-specific messages (apart from those listed in
   // CanSendWhileSwappedOut) that must be handled by the browser when sent from
   // swapped out renderers.
   return false;
 }
@@ skipping 55 matching lines @@
     *sandbox_profile_resource_id = IDR_NACL_SANDBOX_PROFILE;
     return true;
   }
   return false;
 }
 
 std::string ChromeContentClient::GetCarbonInterposePath() const {
   return std::string(kInterposeLibraryPath);
 }
 #endif
-
-}  // namespace chrome