Separate NaCl messages from the rest of chrome messages and create a new message filter. This is pa…

chrome/browser/nacl_host/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 <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.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/nacl_host/nacl_browser.h"
-#include "chrome/browser/renderer_host/chrome_render_message_filter.h"
+#include "chrome/browser/nacl_host/nacl_host_message_filter.h"
+#include "chrome/browser/nacl_host/nacl_host_messages.h"
 #include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_process_type.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/nacl_cmd_line.h"
 #include "chrome/common/nacl_messages.h"
 #include "chrome/common/render_messages.h"
@@ skipping 202 matching lines @@
   if (internal_->socket_for_sel_ldr != NACL_INVALID_HANDLE) {
     if (NaClClose(internal_->socket_for_sel_ldr) != 0) {
       NOTREACHED() << "NaClClose() failed";
     }
   }
 
   if (reply_msg_) {
     // The process failed to launch for some reason.
     // Don't keep the renderer hanging.
     reply_msg_->set_reply_error();
-    chrome_render_message_filter_->Send(reply_msg_);
+    nacl_host_message_filter_->Send(reply_msg_);
   }
 #if defined(OS_WIN)
   if (process_launched_by_broker_) {
     NaClBrokerService::GetInstance()->OnLoaderDied();
   }
 #endif
 }
 
 // This is called at browser startup.
 // static
@@ skipping 11 matching lines @@
       "NaCl.nacl-gdb-script",
       !cmd->GetSwitchValuePath(switches::kNaClGdbScript).empty());
   UMA_HISTOGRAM_BOOLEAN(
       "NaCl.enable-nacl-debug",
       cmd->HasSwitch(switches::kEnableNaClDebug));
   NaClBrowser::GetInstance()->SetDebugPatterns(
       cmd->GetSwitchValueASCII(switches::kNaClDebugMask));
 }
 
 void NaClProcessHost::Launch(
-    ChromeRenderMessageFilter* chrome_render_message_filter,
+    NaClHostMessageFilter* nacl_host_message_filter,
     IPC::Message* reply_msg,
     scoped_refptr<ExtensionInfoMap> extension_info_map) {
-  chrome_render_message_filter_ = chrome_render_message_filter;
+  nacl_host_message_filter_ = nacl_host_message_filter;
   reply_msg_ = reply_msg;
   extension_info_map_ = extension_info_map;
 
   // Start getting the IRT open asynchronously while we launch the NaCl process.
   // We'll make sure this actually finished in StartWithLaunchedProcess, below.
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   nacl_browser->EnsureAllResourcesAvailable();
   if (!nacl_browser->IsOk()) {
     LOG(ERROR) << "NaCl process launch failed: could not find all the "
         "resources needed to launch the process";
@@ skipping 355 matching lines @@
 
 bool NaClProcessHost::ReplyToRenderer(
     const IPC::ChannelHandle& channel_handle) {
   nacl::FileDescriptor handle_for_renderer;
 #if defined(OS_WIN)
   // Copy the handle into the renderer process.
   HANDLE handle_in_renderer;
   if (!DuplicateHandle(base::GetCurrentProcessHandle(),
                        reinterpret_cast<HANDLE>(
                            internal_->socket_for_renderer),
-                       chrome_render_message_filter_->peer_handle(),
+                       nacl_host_message_filter_->peer_handle(),
                        &handle_in_renderer,
                        0,  // Unused given DUPLICATE_SAME_ACCESS.
                        FALSE,
                        DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS)) {
     LOG(ERROR) << "DuplicateHandle() failed";
     return false;
   }
   handle_for_renderer = reinterpret_cast<nacl::FileDescriptor>(
       handle_in_renderer);
 #else
@@ skipping 13 matching lines @@
   // BrokerDuplicateHandle().
   if (RunningOnWOW64()) {
     if (!content::BrokerAddTargetPeer(process_->GetData().handle)) {
       LOG(ERROR) << "Failed to add NaCl process PID";
       return false;
     }
   }
 #endif
 
   const ChildProcessData& data = process_->GetData();
-  ChromeViewHostMsg_LaunchNaCl::WriteReplyParams(
+  NaClHostMsg_LaunchNaCl::WriteReplyParams(
       reply_msg_, handle_for_renderer,
       channel_handle, base::GetProcId(data.handle), data.id);
-  chrome_render_message_filter_->Send(reply_msg_);
-  chrome_render_message_filter_ = NULL;
+  nacl_host_message_filter_->Send(reply_msg_);
+  nacl_host_message_filter_ = NULL;
   reply_msg_ = NULL;
   internal_->socket_for_renderer = NACL_INVALID_HANDLE;
   return true;
 }
 
 // TCP port we chose for NaCl debug stub. It can be any other number.
 static const int kDebugStubPort = 4014;
 
 #if defined(OS_POSIX)
 SocketDescriptor NaClProcessHost::GetDebugStubSocketHandle() {
@@ skipping 118 matching lines @@
                               IPC::Channel::MODE_CLIENT,
                               &ipc_plugin_listener_,
                               base::MessageLoopProxy::current()));
     // Create the browser ppapi host and enable PPAPI message dispatching to the
     // browser process.
     ppapi_host_.reset(content::BrowserPpapiHost::CreateExternalPluginProcess(
         ipc_proxy_channel_.get(),  // sender
         permissions_,
         process_->GetData().handle,
         ipc_proxy_channel_.get(),
-        chrome_render_message_filter_->GetHostResolver(),
-        chrome_render_message_filter_->render_process_id(),
+        nacl_host_message_filter_->GetHostResolver(),
+        nacl_host_message_filter_->render_process_id(),
         render_view_id_,
         profile_directory_));
 
     ppapi::PpapiNaClChannelArgs args;
-    args.off_the_record = chrome_render_message_filter_->off_the_record();
+    args.off_the_record = nacl_host_message_filter_->off_the_record();
     args.permissions = permissions_;
     CommandLine* cmdline = CommandLine::ForCurrentProcess();
     DCHECK(cmdline);
     std::string flag_whitelist[] = {switches::kV, switches::kVModule};
     for (size_t i = 0; i < arraysize(flag_whitelist); ++i) {
       std::string value = cmdline->GetSwitchValueASCII(flag_whitelist[i]);
       if (!value.empty()) {
         args.switch_names.push_back(flag_whitelist[i]);
         args.switch_values.push_back(value);
       }
     }
 
     ppapi_host_->GetPpapiHost()->AddHostFactoryFilter(
         scoped_ptr<ppapi::host::HostFactory>(
             new chrome::ChromeBrowserPepperHostFactory(ppapi_host_.get())));
 
     // Send a message to create the NaCl-Renderer channel. The handle is just
     // a place holder.
     ipc_proxy_channel_->Send(
         new PpapiMsg_CreateNaClChannel(
-            chrome_render_message_filter_->render_process_id(),
+            nacl_host_message_filter_->render_process_id(),
             args,
             SerializedHandle(SerializedHandle::CHANNEL_HANDLE,
                              IPC::InvalidPlatformFileForTransit())));
   } else if (reply_msg_) {
     // Otherwise, this must be a renderer channel.
     ReplyToRenderer(channel_handle);
   } else {
     // Attempt to open more than 1 renderer channel is not supported.
     // Shut down the NaCl process.
     process_->GetHost()->ForceShutdown();
@@ skipping 192 matching lines @@
   } else {
     NaClStartDebugExceptionHandlerThread(
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif