Move more files from chrome/browser/nacl_host/ to components/nacl/browser/

components/nacl/browser/nacl_process_host.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/browser/nacl_host/nacl_process_host.h"
+#include "components/nacl/browser/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/process_iterator.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
-#include "chrome/browser/nacl_host/nacl_host_message_filter.h"
-#include "chrome/common/chrome_switches.h"
 #include "components/nacl/browser/nacl_browser.h"
+#include "components/nacl/browser/nacl_host_message_filter.h"
 #include "components/nacl/common/nacl_cmd_line.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
@@ skipping 10 matching lines @@
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 
 #include "ipc/ipc_channel_posix.h"
 #elif defined(OS_WIN)
 #include <windows.h>
 
 #include "base/threading/thread.h"
 #include "base/win/scoped_handle.h"
-#include "chrome/browser/nacl_host/nacl_broker_service_win.h"
+#include "components/nacl/browser/nacl_broker_service_win.h"
 #include "components/nacl/common/nacl_debug_exception_handler_win.h"
 #include "content/public/common/sandbox_init.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #endif
 
 using content::BrowserThread;
 using content::ChildProcessData;
 using content::ChildProcessHost;
 using ppapi::proxy::SerializedHandle;
 
@@ skipping 121 matching lines @@
 ppapi::PpapiPermissions GetNaClPermissions(uint32 permission_bits) {
   // Only allow NaCl plugins to request certain permissions. We don't want
   // a compromised renderer to be able to start a nacl plugin with e.g. Flash
   // permissions which may expand the surface area of the sandbox.
   uint32 masked_bits = permission_bits & ppapi::PERMISSION_DEV;
   return ppapi::PpapiPermissions::GetForCommandLine(masked_bits);
 }
 
 }  // namespace
 
+namespace nacl {
+
 struct NaClProcessHost::NaClInternal {
   NaClHandle socket_for_renderer;
   NaClHandle socket_for_sel_ldr;
 
   NaClInternal()
     : socket_for_renderer(NACL_INVALID_HANDLE),
       socket_for_sel_ldr(NACL_INVALID_HANDLE) { }
 };
 
 // -----------------------------------------------------------------------------
@@ skipping 77 matching lines @@
   }
 
   if (reply_msg_) {
     // The process failed to launch for some reason.
     // Don't keep the renderer hanging.
     reply_msg_->set_reply_error();
     nacl_host_message_filter_->Send(reply_msg_);
   }
 #if defined(OS_WIN)
   if (process_launched_by_broker_) {
-    NaClBrokerService::GetInstance()->OnLoaderDied();
+    nacl::NaClBrokerService::GetInstance()->OnLoaderDied();
   }
 #endif
 }
 
 void NaClProcessHost::OnProcessCrashed(int exit_status) {
   if (enable_crash_throttling_ &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePnaclCrashThrottling)) {
     nacl::NaClBrowser::GetInstance()->OnProcessCrashed();
   }
@@ skipping 16 matching lines @@
       "NaCl.nacl-gdb-script",
       !cmd->GetSwitchValuePath(switches::kNaClGdbScript).empty());
   UMA_HISTOGRAM_BOOLEAN(
       "NaCl.enable-nacl-debug",
       cmd->HasSwitch(switches::kEnableNaClDebug));
   nacl::NaClBrowser::GetDelegate()->SetDebugPatterns(
       cmd->GetSwitchValueASCII(switches::kNaClDebugMask));
 }
 
 void NaClProcessHost::Launch(
-    NaClHostMessageFilter* nacl_host_message_filter,
+    nacl::NaClHostMessageFilter* nacl_host_message_filter,
     IPC::Message* reply_msg,
     const base::FilePath& manifest_path) {
   nacl_host_message_filter_ = nacl_host_message_filter;
   reply_msg_ = reply_msg;
   manifest_path_ = manifest_path;
 
   // Do not launch the requested NaCl module if NaCl is marked "unstable" due
   // to too many crashes within a given time period.
   if (enable_crash_throttling_ &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 179 matching lines @@
   cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
   if (nacl::NaClBrowser::GetDelegate()->DialogsAreSuppressed())
     cmd_line->AppendSwitch(switches::kNoErrorDialogs);
 
   if (!nacl_loader_prefix.empty())
     cmd_line->PrependWrapper(nacl_loader_prefix);
 
   // On Windows we might need to start the broker process to launch a new loader
 #if defined(OS_WIN)
   if (RunningOnWOW64()) {
-    if (!NaClBrokerService::GetInstance()->LaunchLoader(
+    if (!nacl::NaClBrokerService::GetInstance()->LaunchLoader(
             weak_factory_.GetWeakPtr(), channel_id)) {
       SendErrorToRenderer("broker service did not launch process");
       return false;
     }
   } else {
     process_->Launch(new NaClSandboxedProcessLauncherDelegate,
                      cmd_line.release());
   }
 #elif defined(OS_POSIX)
   process_->Launch(nacl_loader_prefix.empty(),  // use_zygote
@@ skipping 454 matching lines @@
     LOG(ERROR) << "Failed to get process handle";
     return false;
   }
 
   attach_debug_exception_handler_reply_msg_.reset(reply_msg);
   // If the NaCl loader is 64-bit, the process running its debug
   // exception handler must be 64-bit too, so we use the 64-bit NaCl
   // broker process for this.  Otherwise, on a 32-bit system, we use
   // the 32-bit browser process to run the debug exception handler.
   if (RunningOnWOW64()) {
-    return NaClBrokerService::GetInstance()->LaunchDebugExceptionHandler(
+    return nacl::NaClBrokerService::GetInstance()->LaunchDebugExceptionHandler(
                weak_factory_.GetWeakPtr(), nacl_pid, process_handle, info);
   } else {
     NaClStartDebugExceptionHandlerThread(
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
+
+}  // namespace nacl